message stringlengths 2 19.9k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 322 108k | cluster float64 15 15 | __index_level_0__ int64 644 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The last product of the R2 company in the 2D games' field is a new revolutionary algorithm of searching for the shortest path in a 2 Γ n maze.
Imagine a maze that looks like a 2 Γ n rectangle, divided into unit squares. Each unit square is either an empty cell or an obstacle. In one unit of time, a person can move from an empty cell of the maze to any side-adjacent empty cell. The shortest path problem is formulated as follows. Given two free maze cells, you need to determine the minimum time required to go from one cell to the other.
Unfortunately, the developed algorithm works well for only one request for finding the shortest path, in practice such requests occur quite often. You, as the chief R2 programmer, are commissioned to optimize the algorithm to find the shortest path. Write a program that will effectively respond to multiple requests to find the shortest path in a 2 Γ n maze.
Input
The first line contains two integers, n and m (1 β€ n β€ 2Β·105; 1 β€ m β€ 2Β·105) β the width of the maze and the number of queries, correspondingly. Next two lines contain the maze. Each line contains n characters, each character equals either '.' (empty cell), or 'X' (obstacle).
Each of the next m lines contains two integers vi and ui (1 β€ vi, ui β€ 2n) β the description of the i-th request. Numbers vi, ui mean that you need to print the value of the shortest path from the cell of the maze number vi to the cell number ui. We assume that the cells of the first line of the maze are numbered from 1 to n, from left to right, and the cells of the second line are numbered from n + 1 to 2n from left to right. It is guaranteed that both given cells are empty.
Output
Print m lines. In the i-th line print the answer to the i-th request β either the size of the shortest path or -1, if we can't reach the second cell from the first one.
Examples
Input
4 7
.X..
...X
5 1
1 3
7 7
1 4
6 1
4 7
5 7
Output
1
4
0
5
2
2
2
Input
10 3
X...X..X..
..X...X..X
11 7
7 18
18 10
Output
9
-1
3
Submitted Solution:
```
def s(x,y):
global n
if l[1-y][x]=='.':newqueue.append((x,1-y))
if x+1<n and l[y][x+1] == '.': newqueue.append((x+1,y))
n,k=map(int,input().split())
l=[list(input()),list(input())]
prep=[0]
fx=fy=-1
flag=1
cnt=0
for i in range(n):
prep.append(prep[-1]+int(l[0][i]=='X')+int(l[1][i]=='X'))
if l[0][i]=='.'and flag:
fx=i
fy=0
flag=0
elif l[1][i]=='.'and flag:
fx=i
fy=1
flag=0
cnt+=int(l[0][i]=='.')+int(l[1][i]=='.')
i=1
queue=[(fx,fy)]
ns={}
nn=1
lx=fx
while cnt:
if queue:
newqueue=[]
cnt-=len(queue)
for x,y in queue:
l[y][x]=i
s(x,y)
ns[(x,y)]=nn
lx=x
queue=set(newqueue)
i+=1
else:
nn+=1
lx+=1
while True:
if l[0][lx]=='.':
queue=[(lx,0)]
break
if l[1][lx]=='.':
queue=[(lx,1)]
break
lx+=1
for _ in range(k):
a,b=map(int,input().split())
a-=1
b-=1
ax,ay=a%n,int(a>=n)
bx, by = b % n, int(b >= n)
if ns[(ax,ay)]!=ns[(bx,by)]:print(-1)
elif prep[ax]==prep[bx+1]:print(abs(ax-bx)+abs(ay-by))
else:print(abs(l[ay][ax]-l[by][bx]))
``` | instruction | 0 | 70,172 | 15 | 140,344 |
No | output | 1 | 70,172 | 15 | 140,345 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The last product of the R2 company in the 2D games' field is a new revolutionary algorithm of searching for the shortest path in a 2 Γ n maze.
Imagine a maze that looks like a 2 Γ n rectangle, divided into unit squares. Each unit square is either an empty cell or an obstacle. In one unit of time, a person can move from an empty cell of the maze to any side-adjacent empty cell. The shortest path problem is formulated as follows. Given two free maze cells, you need to determine the minimum time required to go from one cell to the other.
Unfortunately, the developed algorithm works well for only one request for finding the shortest path, in practice such requests occur quite often. You, as the chief R2 programmer, are commissioned to optimize the algorithm to find the shortest path. Write a program that will effectively respond to multiple requests to find the shortest path in a 2 Γ n maze.
Input
The first line contains two integers, n and m (1 β€ n β€ 2Β·105; 1 β€ m β€ 2Β·105) β the width of the maze and the number of queries, correspondingly. Next two lines contain the maze. Each line contains n characters, each character equals either '.' (empty cell), or 'X' (obstacle).
Each of the next m lines contains two integers vi and ui (1 β€ vi, ui β€ 2n) β the description of the i-th request. Numbers vi, ui mean that you need to print the value of the shortest path from the cell of the maze number vi to the cell number ui. We assume that the cells of the first line of the maze are numbered from 1 to n, from left to right, and the cells of the second line are numbered from n + 1 to 2n from left to right. It is guaranteed that both given cells are empty.
Output
Print m lines. In the i-th line print the answer to the i-th request β either the size of the shortest path or -1, if we can't reach the second cell from the first one.
Examples
Input
4 7
.X..
...X
5 1
1 3
7 7
1 4
6 1
4 7
5 7
Output
1
4
0
5
2
2
2
Input
10 3
X...X..X..
..X...X..X
11 7
7 18
18 10
Output
9
-1
3
Submitted Solution:
```
n, m = list(map(int, input().split()))
lab = []
lab.append(input())
lab.append(input())
def findPath(a, y1, x1, y2, x2):
way = 0
if x2 > x1:
d = 1
elif x2 < x1:
d = -1
else:
return 1
cy = y1
cx = x1
while not (cx == x2 and cy == y2):
if cx == x2:
if cy == y2:
return way
else:
return way+1
if lab[cy][cx+d] == '.':
way += 1
cx += d
else:
if cy == 1 and lab[0][cx] == '.':
cy = 0
way += 1
elif cy == 0 and lab[1][cx] == '.':
cy = 1
way += 1
else:
return -1
return way
def calc(lab, n):
a, b = list(map(int, input().split()))
if a==b:
return 0
if a > n:
v = [1, a%n-1]
else:
v = [0, a-1]
if b > n:
u = [1, b%n-1]
else:
u = [0, b-1]
#print('\n', '---', v, u)
return findPath(lab, v[0], v[1], u[0], u[1])
for i in range(m):
print(calc(lab, n))
``` | instruction | 0 | 70,173 | 15 | 140,346 |
No | output | 1 | 70,173 | 15 | 140,347 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The last product of the R2 company in the 2D games' field is a new revolutionary algorithm of searching for the shortest path in a 2 Γ n maze.
Imagine a maze that looks like a 2 Γ n rectangle, divided into unit squares. Each unit square is either an empty cell or an obstacle. In one unit of time, a person can move from an empty cell of the maze to any side-adjacent empty cell. The shortest path problem is formulated as follows. Given two free maze cells, you need to determine the minimum time required to go from one cell to the other.
Unfortunately, the developed algorithm works well for only one request for finding the shortest path, in practice such requests occur quite often. You, as the chief R2 programmer, are commissioned to optimize the algorithm to find the shortest path. Write a program that will effectively respond to multiple requests to find the shortest path in a 2 Γ n maze.
Input
The first line contains two integers, n and m (1 β€ n β€ 2Β·105; 1 β€ m β€ 2Β·105) β the width of the maze and the number of queries, correspondingly. Next two lines contain the maze. Each line contains n characters, each character equals either '.' (empty cell), or 'X' (obstacle).
Each of the next m lines contains two integers vi and ui (1 β€ vi, ui β€ 2n) β the description of the i-th request. Numbers vi, ui mean that you need to print the value of the shortest path from the cell of the maze number vi to the cell number ui. We assume that the cells of the first line of the maze are numbered from 1 to n, from left to right, and the cells of the second line are numbered from n + 1 to 2n from left to right. It is guaranteed that both given cells are empty.
Output
Print m lines. In the i-th line print the answer to the i-th request β either the size of the shortest path or -1, if we can't reach the second cell from the first one.
Examples
Input
4 7
.X..
...X
5 1
1 3
7 7
1 4
6 1
4 7
5 7
Output
1
4
0
5
2
2
2
Input
10 3
X...X..X..
..X...X..X
11 7
7 18
18 10
Output
9
-1
3
Submitted Solution:
```
n, m = map(int, input().split())
s1 = input()
s1 = 'X' + s1
s2 = input()
s2 = 'X' + s2
blocks = []
groups = [0 for i in range(n)]
res = [0 for i in range(2 * n)]
group = 0
for i in range(n + 1):
el1 = s1[i]
el2 = s2[i]
if el1 == el2 == 'X':
blocks.append(3)
elif el1 == 'X':
blocks.append(1)
elif el2 == 'X':
blocks.append(2)
else:
blocks.append(0)
for i in range(1, n + 1):
if blocks[i] == 3:
continue
if blocks[i - 1] == 3 or blocks[i - 1] + blocks[i] == 3:
group += 1
groups[i - 1] = group
if s1[i] != 'X':
res[i - 1] = 0
if s2[i] != 'X':
res[n + i - 1] = 1
continue
groups[i - 1] = group
if blocks[i - 1] == 2:
if blocks[i] == 0:
res[i - 1] = res[i - 2] + 1
res[n + i - 1] = res[i - 1] + 1
else:
res[i - 1] = res[i - 2] + 1
elif blocks[i - 1] == 1:
if blocks[i] == 0:
res[n + i - 1] = res[n + i - 2] + 1
res[i - 1] = res[n + i - 1] + 1
else:
res[n + i - 1] = res[n + i - 2] + 1
else:
if blocks[i] == 1:
res[n + i - 1] = res[n + i - 2] + 1
elif blocks[i] == 2:
res[i - 1] = res[i - 2] + 1
else:
res[n + i - 1] = res[n + i - 2] + 1
res[i - 1] = res[i - 2] + 1
for i in range(m):
a, b = map(int, input().split())
a_ = a - 1
if a_ >= n:
a_ -= n
b_ = b - 1
if b_ >= n:
b_ -= n
if groups[a_] != groups[b_]:
print(-1)
else:
print(abs(res[a - 1] - res[b - 1]))
``` | instruction | 0 | 70,174 | 15 | 140,348 |
No | output | 1 | 70,174 | 15 | 140,349 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The mobile application store has a new game called "Subway Roller".
The protagonist of the game Philip is located in one end of the tunnel and wants to get out of the other one. The tunnel is a rectangular field consisting of three rows and n columns. At the beginning of the game the hero is in some cell of the leftmost column. Some number of trains rides towards the hero. Each train consists of two or more neighbouring cells in some row of the field.
All trains are moving from right to left at a speed of two cells per second, and the hero runs from left to right at the speed of one cell per second. For simplicity, the game is implemented so that the hero and the trains move in turns. First, the hero moves one cell to the right, then one square up or down, or stays idle. Then all the trains move twice simultaneously one cell to the left. Thus, in one move, Philip definitely makes a move to the right and can move up or down. If at any point, Philip is in the same cell with a train, he loses. If the train reaches the left column, it continues to move as before, leaving the tunnel.
Your task is to answer the question whether there is a sequence of movements of Philip, such that he would be able to get to the rightmost column.
<image>
Input
Each test contains from one to ten sets of the input data. The first line of the test contains a single integer t (1 β€ t β€ 10 for pretests and tests or t = 1 for hacks; see the Notes section for details) β the number of sets.
Then follows the description of t sets of the input data.
The first line of the description of each set contains two integers n, k (2 β€ n β€ 100, 1 β€ k β€ 26) β the number of columns on the field and the number of trains. Each of the following three lines contains the sequence of n character, representing the row of the field where the game is on. Philip's initial position is marked as 's', he is in the leftmost column. Each of the k trains is marked by some sequence of identical uppercase letters of the English alphabet, located in one line. Distinct trains are represented by distinct letters. Character '.' represents an empty cell, that is, the cell that doesn't contain either Philip or the trains.
Output
For each set of the input data print on a single line word YES, if it is possible to win the game and word NO otherwise.
Examples
Input
2
16 4
...AAAAA........
s.BBB......CCCCC
........DDDDD...
16 4
...AAAAA........
s.BBB....CCCCC..
.......DDDDD....
Output
YES
NO
Input
2
10 4
s.ZZ......
.....AAABB
.YYYYYY...
10 4
s.ZZ......
....AAAABB
.YYYYYY...
Output
YES
NO
Note
In the first set of the input of the first sample Philip must first go forward and go down to the third row of the field, then go only forward, then go forward and climb to the second row, go forward again and go up to the first row. After that way no train blocks Philip's path, so he can go straight to the end of the tunnel.
Note that in this problem the challenges are restricted to tests that contain only one testset. | instruction | 0 | 70,243 | 15 | 140,486 |
Tags: dfs and similar, graphs, shortest paths
Correct Solution:
```
#!/usr/bin/python3
t=int(input())
cmi=[0,-1,1]
def dfs(i,j,data,n):
stacki=list()
stackj=list()
stacki.append(i)
stackj.append(j)
while(len(stacki)!=0):
ti=stacki.pop()
tj=stackj.pop()
for i in range(0,3):
nexti=ti+cmi[i]
nextj=tj+3
if not (0<=nexti and nexti<=2):
continue
isb=True
for nn in [(ti,tj+1),(nexti,tj+1),(nexti,tj+2),(nexti,tj+3)]:
(tti,ttj)=nn
if ttj < n and data[tti][ttj] == False:
isb=False
break
if isb==False:
continue
if nextj>=n:
return True
else:
data[nexti][nextj]=False
stacki.append(nexti)
stackj.append(nextj)
return False
for i in range(0,t):
n,k=map(int,input().split())
si=0
sj=0
data=list()
for j in range(0,3):
s=input()
tmp=list()
for k in range(0,n):
if s[k]=="s":
si=j
sj=k
tmp.append(True)
elif s[k]!=".":
tmp.append(False)
else:
tmp.append(True)
data.append(tmp)
print(["NO","YES"][dfs(si,sj,data,n)])
``` | output | 1 | 70,243 | 15 | 140,487 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The mobile application store has a new game called "Subway Roller".
The protagonist of the game Philip is located in one end of the tunnel and wants to get out of the other one. The tunnel is a rectangular field consisting of three rows and n columns. At the beginning of the game the hero is in some cell of the leftmost column. Some number of trains rides towards the hero. Each train consists of two or more neighbouring cells in some row of the field.
All trains are moving from right to left at a speed of two cells per second, and the hero runs from left to right at the speed of one cell per second. For simplicity, the game is implemented so that the hero and the trains move in turns. First, the hero moves one cell to the right, then one square up or down, or stays idle. Then all the trains move twice simultaneously one cell to the left. Thus, in one move, Philip definitely makes a move to the right and can move up or down. If at any point, Philip is in the same cell with a train, he loses. If the train reaches the left column, it continues to move as before, leaving the tunnel.
Your task is to answer the question whether there is a sequence of movements of Philip, such that he would be able to get to the rightmost column.
<image>
Input
Each test contains from one to ten sets of the input data. The first line of the test contains a single integer t (1 β€ t β€ 10 for pretests and tests or t = 1 for hacks; see the Notes section for details) β the number of sets.
Then follows the description of t sets of the input data.
The first line of the description of each set contains two integers n, k (2 β€ n β€ 100, 1 β€ k β€ 26) β the number of columns on the field and the number of trains. Each of the following three lines contains the sequence of n character, representing the row of the field where the game is on. Philip's initial position is marked as 's', he is in the leftmost column. Each of the k trains is marked by some sequence of identical uppercase letters of the English alphabet, located in one line. Distinct trains are represented by distinct letters. Character '.' represents an empty cell, that is, the cell that doesn't contain either Philip or the trains.
Output
For each set of the input data print on a single line word YES, if it is possible to win the game and word NO otherwise.
Examples
Input
2
16 4
...AAAAA........
s.BBB......CCCCC
........DDDDD...
16 4
...AAAAA........
s.BBB....CCCCC..
.......DDDDD....
Output
YES
NO
Input
2
10 4
s.ZZ......
.....AAABB
.YYYYYY...
10 4
s.ZZ......
....AAAABB
.YYYYYY...
Output
YES
NO
Note
In the first set of the input of the first sample Philip must first go forward and go down to the third row of the field, then go only forward, then go forward and climb to the second row, go forward again and go up to the first row. After that way no train blocks Philip's path, so he can go straight to the end of the tunnel.
Note that in this problem the challenges are restricted to tests that contain only one testset. | instruction | 0 | 70,244 | 15 | 140,488 |
Tags: dfs and similar, graphs, shortest paths
Correct Solution:
```
from queue import Queue
from collections import defaultdict
class PhilipTrains():
def __init__(self, n, k, state):
self.n = n
self.k = k
self.state = state
self.graph = [[[0 for i in range(n+1)] for j in range(n)] for k in range(3)]
for i in range(len(state)):
for j in range(len(state[i])):
if 'A' <= state[i][j] <= 'Z':
for k in range(n):
nj = j-(2*k)
if nj >= 0:
self.graph[i][nj][k] = -1
else:
break
for i in range(len(state)):
if state[i][0] == 's':
self.r = i
self.c = 0
def check_reach(self):
q = Queue()
check = defaultdict(int)
changes = [(1,1,1),(-1,1,1), (0,1,1)]
q.put((self.r, self.c, 0))
check[(self.r, self.c, 0)] = 1
while not q.empty():
pr, pc, pt = q.get()
if self.graph[pr][pc][pt] == -1:
continue
if pc == self.n-1:
return 'YES'
if self.graph[pr][pc+1][pt] != -1:
if check[(pr, pc+1,pt+1)] != 1:
q.put((pr, pc+1,pt+1))
check[(pr, pc+1, pt+1)] = 1
for ch in [1,-1]:
if 0 <= pr+ch <= 2 and check[(pr+ch, pc+1,pt+1)] != 1 and self.graph[pr+ch][pc+1][pt] != -1:
q.put((pr+ch, pc+1,pt+1))
check[(pr+ch, pc+1, pt+1)] = 1
return 'NO'
t = int(input())
for i in range(t):
n, k = list(map(int,input().strip(' ').split(' ')))
arr = []
for i in range(3):
arr.append(input().strip(' '))
graph = PhilipTrains(n, k, arr)
print(graph.check_reach())
``` | output | 1 | 70,244 | 15 | 140,489 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The mobile application store has a new game called "Subway Roller".
The protagonist of the game Philip is located in one end of the tunnel and wants to get out of the other one. The tunnel is a rectangular field consisting of three rows and n columns. At the beginning of the game the hero is in some cell of the leftmost column. Some number of trains rides towards the hero. Each train consists of two or more neighbouring cells in some row of the field.
All trains are moving from right to left at a speed of two cells per second, and the hero runs from left to right at the speed of one cell per second. For simplicity, the game is implemented so that the hero and the trains move in turns. First, the hero moves one cell to the right, then one square up or down, or stays idle. Then all the trains move twice simultaneously one cell to the left. Thus, in one move, Philip definitely makes a move to the right and can move up or down. If at any point, Philip is in the same cell with a train, he loses. If the train reaches the left column, it continues to move as before, leaving the tunnel.
Your task is to answer the question whether there is a sequence of movements of Philip, such that he would be able to get to the rightmost column.
<image>
Input
Each test contains from one to ten sets of the input data. The first line of the test contains a single integer t (1 β€ t β€ 10 for pretests and tests or t = 1 for hacks; see the Notes section for details) β the number of sets.
Then follows the description of t sets of the input data.
The first line of the description of each set contains two integers n, k (2 β€ n β€ 100, 1 β€ k β€ 26) β the number of columns on the field and the number of trains. Each of the following three lines contains the sequence of n character, representing the row of the field where the game is on. Philip's initial position is marked as 's', he is in the leftmost column. Each of the k trains is marked by some sequence of identical uppercase letters of the English alphabet, located in one line. Distinct trains are represented by distinct letters. Character '.' represents an empty cell, that is, the cell that doesn't contain either Philip or the trains.
Output
For each set of the input data print on a single line word YES, if it is possible to win the game and word NO otherwise.
Examples
Input
2
16 4
...AAAAA........
s.BBB......CCCCC
........DDDDD...
16 4
...AAAAA........
s.BBB....CCCCC..
.......DDDDD....
Output
YES
NO
Input
2
10 4
s.ZZ......
.....AAABB
.YYYYYY...
10 4
s.ZZ......
....AAAABB
.YYYYYY...
Output
YES
NO
Note
In the first set of the input of the first sample Philip must first go forward and go down to the third row of the field, then go only forward, then go forward and climb to the second row, go forward again and go up to the first row. After that way no train blocks Philip's path, so he can go straight to the end of the tunnel.
Note that in this problem the challenges are restricted to tests that contain only one testset. | instruction | 0 | 70,245 | 15 | 140,490 |
Tags: dfs and similar, graphs, shortest paths
Correct Solution:
```
#!/usr/bin/python3
# -*- coding: utf-8 -*-
def checkPoint(graph, x, y):
n = len(graph)
m = len(graph[0])
if y >= m:
return True
if x >= 0 and x < n and y >=0 and graph[x][y] == '.':
return True
return False
def BFS(graph):
queue = [] #ε°θΎΎθΏηηΉηεζ
vis = set() #ε―ε°θΎΎηηΉηεζ ιε
x = 0
y = 0
ans = False
m = len(graph[0])
for i in range(3):
if graph[i][y] == 's':
x = i
break
queue.append((x,y)) #εε§εζ
vis.add((x,y))
while len(queue) > 0:
currentPosition = queue.pop(0)
#print(currentPosition)
currentx = currentPosition[0]
currenty = currentPosition[1]
if checkPoint(graph, currentx, currenty+1) and checkPoint(graph, currentx, currenty+2) and checkPoint(graph, currentx, currenty+3): #δΈη΄εε³θ΅°
# currenty += 3
if currenty + 3 >= m-1:
ans = True
break
if (currentx, currenty + 3) not in vis:
queue.append((currentx, currenty + 3))
vis.add((currentx, currenty + 3))
if checkPoint(graph, currentx, currenty+1) and checkPoint(graph, currentx -1, currenty+1) and checkPoint(graph, currentx-1, currenty+2) and checkPoint(graph, currentx-1, currenty+3): #εε³δΈζ ΌεεδΈδΈζ Όεεε³2ζ Ό
# currentx -= 1
# currenty += 3
if currenty + 3 >= m-1:
ans = True
break
if (currentx - 1, currenty + 3) not in vis:
queue.append((currentx - 1, currenty + 3))
vis.add((currentx - 1, currenty + 3))
if checkPoint(graph, currentx, currenty+1) and checkPoint(graph, currentx + 1, currenty+1) and checkPoint(graph, currentx+1, currenty+2) and checkPoint(graph, currentx+1, currenty+3):#εε³δΈζ ΌεεδΈδΈζ Όεεε³2ζ Ό
currentx += 1
currenty += 3
if currenty >= m-1:
ans = True
break
if (currentx, currenty) not in vis:
queue.append((currentx, currenty))
vis.add((currentx , currenty))
return ans
t = int(input())
while t > 0:
t -= 1
s = input().split()
n = int(s[0])
k = int(s[1])
graph = []
k = 3
while k > 0:
k -= 1
s = input()
graph.append(s)
ans = BFS(graph)
if ans == True:
print("YES")
else:
print("NO")
``` | output | 1 | 70,245 | 15 | 140,491 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The mobile application store has a new game called "Subway Roller".
The protagonist of the game Philip is located in one end of the tunnel and wants to get out of the other one. The tunnel is a rectangular field consisting of three rows and n columns. At the beginning of the game the hero is in some cell of the leftmost column. Some number of trains rides towards the hero. Each train consists of two or more neighbouring cells in some row of the field.
All trains are moving from right to left at a speed of two cells per second, and the hero runs from left to right at the speed of one cell per second. For simplicity, the game is implemented so that the hero and the trains move in turns. First, the hero moves one cell to the right, then one square up or down, or stays idle. Then all the trains move twice simultaneously one cell to the left. Thus, in one move, Philip definitely makes a move to the right and can move up or down. If at any point, Philip is in the same cell with a train, he loses. If the train reaches the left column, it continues to move as before, leaving the tunnel.
Your task is to answer the question whether there is a sequence of movements of Philip, such that he would be able to get to the rightmost column.
<image>
Input
Each test contains from one to ten sets of the input data. The first line of the test contains a single integer t (1 β€ t β€ 10 for pretests and tests or t = 1 for hacks; see the Notes section for details) β the number of sets.
Then follows the description of t sets of the input data.
The first line of the description of each set contains two integers n, k (2 β€ n β€ 100, 1 β€ k β€ 26) β the number of columns on the field and the number of trains. Each of the following three lines contains the sequence of n character, representing the row of the field where the game is on. Philip's initial position is marked as 's', he is in the leftmost column. Each of the k trains is marked by some sequence of identical uppercase letters of the English alphabet, located in one line. Distinct trains are represented by distinct letters. Character '.' represents an empty cell, that is, the cell that doesn't contain either Philip or the trains.
Output
For each set of the input data print on a single line word YES, if it is possible to win the game and word NO otherwise.
Examples
Input
2
16 4
...AAAAA........
s.BBB......CCCCC
........DDDDD...
16 4
...AAAAA........
s.BBB....CCCCC..
.......DDDDD....
Output
YES
NO
Input
2
10 4
s.ZZ......
.....AAABB
.YYYYYY...
10 4
s.ZZ......
....AAAABB
.YYYYYY...
Output
YES
NO
Note
In the first set of the input of the first sample Philip must first go forward and go down to the third row of the field, then go only forward, then go forward and climb to the second row, go forward again and go up to the first row. After that way no train blocks Philip's path, so he can go straight to the end of the tunnel.
Note that in this problem the challenges are restricted to tests that contain only one testset. | instruction | 0 | 70,246 | 15 | 140,492 |
Tags: dfs and similar, graphs, shortest paths
Correct Solution:
```
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
# Copyright Β© 2016 missingdays <missingdays@missingdays>
#
# Distributed under terms of the MIT license.
"""
"""
def shift(a, n):
b = [["." for i in range(n)] for i in range(3)]
for i in range(3):
for j in range(n-2):
b[i][j] = a[i][j+2]
return b
n = int(input())
for case in range(n):
n, k = [int(i) for i in input().split()]
a = []
for i in range(3):
a.append(list(input()))
m = [[False for i in range(n)] for j in range(3)]
for i in range(3):
if a[i][0] == 's':
m[i][0] = True
for i in range(1, n):
#print(a)
for j in range(3):
if m[j][i-1] and a[j][i] == "." and (a[j][i-1] == "." or a[j][i-1] == "s") and (i < 2 or a[j][i-2] == "."):
m[j][i] = True
ms = [False for something in range(3)]
if m[0][i]:
if a[1][i] == ".": #and (i > n-2 or a[1][i+1] == ".") and (i > n-3 or a[1][i+2] == "."):
ms[1] = True
if m[1][i]:
if a[0][i] == ".": #and (i > n-2 or a[0][i+1] == ".") and (i > n-3 or a[0][i+2] == "."):
ms[0] = True
if a[2][i] == ".": #and (i > n-2 or a[2][i+1] == ".") and (i > n-3 or a[2][i+2] == "."):
ms[2] = True
if m[2][i]:
if a[1][i] == ".": #and (i > n-2 or a[1][i+1] == ".") and (i > n-3 or a[1][i+2] == "."):
ms[1] = True
for j in range(3):
if ms[j]:
m[j][i] = True
#print(m)
a = shift(a, n)
for i in range(3):
if m[i][n-1]:
print("YES")
break
else:
print("NO")
``` | output | 1 | 70,246 | 15 | 140,493 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The mobile application store has a new game called "Subway Roller".
The protagonist of the game Philip is located in one end of the tunnel and wants to get out of the other one. The tunnel is a rectangular field consisting of three rows and n columns. At the beginning of the game the hero is in some cell of the leftmost column. Some number of trains rides towards the hero. Each train consists of two or more neighbouring cells in some row of the field.
All trains are moving from right to left at a speed of two cells per second, and the hero runs from left to right at the speed of one cell per second. For simplicity, the game is implemented so that the hero and the trains move in turns. First, the hero moves one cell to the right, then one square up or down, or stays idle. Then all the trains move twice simultaneously one cell to the left. Thus, in one move, Philip definitely makes a move to the right and can move up or down. If at any point, Philip is in the same cell with a train, he loses. If the train reaches the left column, it continues to move as before, leaving the tunnel.
Your task is to answer the question whether there is a sequence of movements of Philip, such that he would be able to get to the rightmost column.
<image>
Input
Each test contains from one to ten sets of the input data. The first line of the test contains a single integer t (1 β€ t β€ 10 for pretests and tests or t = 1 for hacks; see the Notes section for details) β the number of sets.
Then follows the description of t sets of the input data.
The first line of the description of each set contains two integers n, k (2 β€ n β€ 100, 1 β€ k β€ 26) β the number of columns on the field and the number of trains. Each of the following three lines contains the sequence of n character, representing the row of the field where the game is on. Philip's initial position is marked as 's', he is in the leftmost column. Each of the k trains is marked by some sequence of identical uppercase letters of the English alphabet, located in one line. Distinct trains are represented by distinct letters. Character '.' represents an empty cell, that is, the cell that doesn't contain either Philip or the trains.
Output
For each set of the input data print on a single line word YES, if it is possible to win the game and word NO otherwise.
Examples
Input
2
16 4
...AAAAA........
s.BBB......CCCCC
........DDDDD...
16 4
...AAAAA........
s.BBB....CCCCC..
.......DDDDD....
Output
YES
NO
Input
2
10 4
s.ZZ......
.....AAABB
.YYYYYY...
10 4
s.ZZ......
....AAAABB
.YYYYYY...
Output
YES
NO
Note
In the first set of the input of the first sample Philip must first go forward and go down to the third row of the field, then go only forward, then go forward and climb to the second row, go forward again and go up to the first row. After that way no train blocks Philip's path, so he can go straight to the end of the tunnel.
Note that in this problem the challenges are restricted to tests that contain only one testset. | instruction | 0 | 70,247 | 15 | 140,494 |
Tags: dfs and similar, graphs, shortest paths
Correct Solution:
```
import sys
flag = False
t = int(input())
for kek in range(t):
n, k = [int(i) for i in input().split()]
if t == 10 and n == 95 and k == 6:
flag = True
a = [[0] * n for i in range(3)]
for i in range(3):
a[i] = [i for i in input()]
dp = [[False] * n for i in range(3)]
l = 0
if a[0][0] == 's':
l = 0
if a[1][0] == 's':
l = 1
if a[2][0] == 's':
l = 2
dp[l][0] = True
first = [[False] * n for i in range(3)]
bad = [True] * 3
for i in range(1, n):
if 3 * i < n and a[0][3 * i] == '.' and a[0][3 * i - 2] == '.':
if (dp[0][i - 1] or first[0][i - 1]) or (a[1][3 * i - 2] == '.' and dp[1][i - 1]):
dp[0][i] = True
elif 3 * i >= n > 3 * i - 2:
if (dp[0][i - 1] and a[0][3 * i - 2] == '.') or (dp[1][i - 1] and a[1][3 * i - 2] == '.'):
dp[0][i] = True
elif 3 * i >= n and (dp[0][i - 1] or dp[1][i - 1]):
dp[0][i] = True
if 3 * i < n and a[1][3 * i] == '.' and a[1][3 * i - 2] == '.':
if (dp[1][i - 1] or first[1][i - 1]) or (a[0][3 * i - 2] == '.' and dp[0][i - 1]) or (a[2][3 * i - 2] == '.' and dp[2][i - 1]):
dp[1][i] = True
elif 3 * i >= n > 3 * i - 2:
if (dp[0][i - 1] and a[0][3 * i - 2] == '.') or (dp[1][i - 1] and a[1][3 * i - 2] == '.') or (dp[2][i - 1] and a[2][3 * i - 2] == '.'):
dp[1][i] = True
elif 3 * i >= n and (dp[0][i - 1] or dp[1][i - 1] or dp[2][i - 1]):
dp[1][i] = True
if 3 * i < n and a[2][3 * i] == '.' and a[2][3 * i - 2] == '.':
if (dp[2][i - 1] or first[2][i - 1]) or (a[1][3 * i - 2] == '.' and dp[1][i - 1]):
dp[2][i] = True
elif 3 * i >= n > 3 * i - 2:
if (dp[2][i - 1] and a[2][3 * i - 2] == '.') or (dp[1][i - 1] and a[1][3 * i - 2] == '.'):
dp[2][i] = True
elif 3 * i >= n and (dp[1][i - 1] or dp[2][i - 1]):
dp[2][i] = True
#for i in range(3):
# print(dp[i])
if max(dp[0][n - 1], dp[1][n - 1], dp[2][n - 1]):
print('YES')
else:
print('NO')
``` | output | 1 | 70,247 | 15 | 140,495 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The mobile application store has a new game called "Subway Roller".
The protagonist of the game Philip is located in one end of the tunnel and wants to get out of the other one. The tunnel is a rectangular field consisting of three rows and n columns. At the beginning of the game the hero is in some cell of the leftmost column. Some number of trains rides towards the hero. Each train consists of two or more neighbouring cells in some row of the field.
All trains are moving from right to left at a speed of two cells per second, and the hero runs from left to right at the speed of one cell per second. For simplicity, the game is implemented so that the hero and the trains move in turns. First, the hero moves one cell to the right, then one square up or down, or stays idle. Then all the trains move twice simultaneously one cell to the left. Thus, in one move, Philip definitely makes a move to the right and can move up or down. If at any point, Philip is in the same cell with a train, he loses. If the train reaches the left column, it continues to move as before, leaving the tunnel.
Your task is to answer the question whether there is a sequence of movements of Philip, such that he would be able to get to the rightmost column.
<image>
Input
Each test contains from one to ten sets of the input data. The first line of the test contains a single integer t (1 β€ t β€ 10 for pretests and tests or t = 1 for hacks; see the Notes section for details) β the number of sets.
Then follows the description of t sets of the input data.
The first line of the description of each set contains two integers n, k (2 β€ n β€ 100, 1 β€ k β€ 26) β the number of columns on the field and the number of trains. Each of the following three lines contains the sequence of n character, representing the row of the field where the game is on. Philip's initial position is marked as 's', he is in the leftmost column. Each of the k trains is marked by some sequence of identical uppercase letters of the English alphabet, located in one line. Distinct trains are represented by distinct letters. Character '.' represents an empty cell, that is, the cell that doesn't contain either Philip or the trains.
Output
For each set of the input data print on a single line word YES, if it is possible to win the game and word NO otherwise.
Examples
Input
2
16 4
...AAAAA........
s.BBB......CCCCC
........DDDDD...
16 4
...AAAAA........
s.BBB....CCCCC..
.......DDDDD....
Output
YES
NO
Input
2
10 4
s.ZZ......
.....AAABB
.YYYYYY...
10 4
s.ZZ......
....AAAABB
.YYYYYY...
Output
YES
NO
Note
In the first set of the input of the first sample Philip must first go forward and go down to the third row of the field, then go only forward, then go forward and climb to the second row, go forward again and go up to the first row. After that way no train blocks Philip's path, so he can go straight to the end of the tunnel.
Note that in this problem the challenges are restricted to tests that contain only one testset. | instruction | 0 | 70,248 | 15 | 140,496 |
Tags: dfs and similar, graphs, shortest paths
Correct Solution:
```
# import sys
# sys.stdin = open('cf586d.in')
def handle_test():
n, k = [int(v) for v in input().split()]
field = [input() for _ in range(3)]
if field[0][0] == 's':
cpos = [0, 0]
elif field[1][0] == 's':
cpos = [1, 0]
else:
cpos = [2, 0]
available = [[False] * len(field[0]) for _ in range(3)]
available[cpos[0]][cpos[1]] = True
for i in range(n):
for j in range(3):
if available[j][i]:
if i + 1 >= n:
return True
elif field[j][i + 1] != '.':
continue
for offset in (-1, 0, 1):
if not (0 <= j + offset < 3) or field[j + offset][i + 1] != '.':
continue
if i + 2 >= n:
return True
elif field[j + offset][i + 2] != '.':
continue
elif i + 3 >= n:
return True
elif field[j + offset][i + 3] != '.':
continue
else:
available[j + offset][i + 3] = True
return False
t = int(input())
for _ in range(t):
print(['NO', 'YES'][handle_test()])
# Made By Mostafa_Khaled
``` | output | 1 | 70,248 | 15 | 140,497 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The mobile application store has a new game called "Subway Roller".
The protagonist of the game Philip is located in one end of the tunnel and wants to get out of the other one. The tunnel is a rectangular field consisting of three rows and n columns. At the beginning of the game the hero is in some cell of the leftmost column. Some number of trains rides towards the hero. Each train consists of two or more neighbouring cells in some row of the field.
All trains are moving from right to left at a speed of two cells per second, and the hero runs from left to right at the speed of one cell per second. For simplicity, the game is implemented so that the hero and the trains move in turns. First, the hero moves one cell to the right, then one square up or down, or stays idle. Then all the trains move twice simultaneously one cell to the left. Thus, in one move, Philip definitely makes a move to the right and can move up or down. If at any point, Philip is in the same cell with a train, he loses. If the train reaches the left column, it continues to move as before, leaving the tunnel.
Your task is to answer the question whether there is a sequence of movements of Philip, such that he would be able to get to the rightmost column.
<image>
Input
Each test contains from one to ten sets of the input data. The first line of the test contains a single integer t (1 β€ t β€ 10 for pretests and tests or t = 1 for hacks; see the Notes section for details) β the number of sets.
Then follows the description of t sets of the input data.
The first line of the description of each set contains two integers n, k (2 β€ n β€ 100, 1 β€ k β€ 26) β the number of columns on the field and the number of trains. Each of the following three lines contains the sequence of n character, representing the row of the field where the game is on. Philip's initial position is marked as 's', he is in the leftmost column. Each of the k trains is marked by some sequence of identical uppercase letters of the English alphabet, located in one line. Distinct trains are represented by distinct letters. Character '.' represents an empty cell, that is, the cell that doesn't contain either Philip or the trains.
Output
For each set of the input data print on a single line word YES, if it is possible to win the game and word NO otherwise.
Examples
Input
2
16 4
...AAAAA........
s.BBB......CCCCC
........DDDDD...
16 4
...AAAAA........
s.BBB....CCCCC..
.......DDDDD....
Output
YES
NO
Input
2
10 4
s.ZZ......
.....AAABB
.YYYYYY...
10 4
s.ZZ......
....AAAABB
.YYYYYY...
Output
YES
NO
Note
In the first set of the input of the first sample Philip must first go forward and go down to the third row of the field, then go only forward, then go forward and climb to the second row, go forward again and go up to the first row. After that way no train blocks Philip's path, so he can go straight to the end of the tunnel.
Note that in this problem the challenges are restricted to tests that contain only one testset. | instruction | 0 | 70,249 | 15 | 140,498 |
Tags: dfs and similar, graphs, shortest paths
Correct Solution:
```
T = int(input())
for t in range(T):
n, k = map(int, input().split(' ')[:2])
s = ["","",""]
for i in range(3):
s[i] = input()
s[0] += '.' * (n*3)
s[1] += '.' * (n*3)
s[2] += '.' * (n*3)
def top():
return [s[0][0] != '.', s[1][0] != '.', s[2][0] != '.']
def shift():
s[0] = s[0][1:]
s[1] = s[1][1:]
s[2] = s[2][1:]
return top()
p = [s[0][0] == 's', s[1][0] == 's', s[2][0] == 's']
for i in range(1, n):
np = [False, False, False]
if p[0] == True and s[0][1] == '.':
np[0] = True
np[1] = True
if p[1] == True and s[1][1] == '.':
np[0] = True
np[1] = True
np[2] = True
if p[2] == True and s[2][1] == '.':
np[1] = True
np[2] = True
p = np
s0, s1, s2 = shift()
if s0: p[0] = False
if s1: p[1] = False
if s2: p[2] = False
# my move ended
s0, s1, s2 = shift()
if s0: p[0] = False
if s1: p[1] = False
if s2: p[2] = False
s0, s1, s2 = shift()
if s0: p[0] = False
if s1: p[1] = False
if s2: p[2] = False
if p[0] or p[1] or p[2]:
print("YES")
else:
print("NO")
``` | output | 1 | 70,249 | 15 | 140,499 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The mobile application store has a new game called "Subway Roller".
The protagonist of the game Philip is located in one end of the tunnel and wants to get out of the other one. The tunnel is a rectangular field consisting of three rows and n columns. At the beginning of the game the hero is in some cell of the leftmost column. Some number of trains rides towards the hero. Each train consists of two or more neighbouring cells in some row of the field.
All trains are moving from right to left at a speed of two cells per second, and the hero runs from left to right at the speed of one cell per second. For simplicity, the game is implemented so that the hero and the trains move in turns. First, the hero moves one cell to the right, then one square up or down, or stays idle. Then all the trains move twice simultaneously one cell to the left. Thus, in one move, Philip definitely makes a move to the right and can move up or down. If at any point, Philip is in the same cell with a train, he loses. If the train reaches the left column, it continues to move as before, leaving the tunnel.
Your task is to answer the question whether there is a sequence of movements of Philip, such that he would be able to get to the rightmost column.
<image>
Input
Each test contains from one to ten sets of the input data. The first line of the test contains a single integer t (1 β€ t β€ 10 for pretests and tests or t = 1 for hacks; see the Notes section for details) β the number of sets.
Then follows the description of t sets of the input data.
The first line of the description of each set contains two integers n, k (2 β€ n β€ 100, 1 β€ k β€ 26) β the number of columns on the field and the number of trains. Each of the following three lines contains the sequence of n character, representing the row of the field where the game is on. Philip's initial position is marked as 's', he is in the leftmost column. Each of the k trains is marked by some sequence of identical uppercase letters of the English alphabet, located in one line. Distinct trains are represented by distinct letters. Character '.' represents an empty cell, that is, the cell that doesn't contain either Philip or the trains.
Output
For each set of the input data print on a single line word YES, if it is possible to win the game and word NO otherwise.
Examples
Input
2
16 4
...AAAAA........
s.BBB......CCCCC
........DDDDD...
16 4
...AAAAA........
s.BBB....CCCCC..
.......DDDDD....
Output
YES
NO
Input
2
10 4
s.ZZ......
.....AAABB
.YYYYYY...
10 4
s.ZZ......
....AAAABB
.YYYYYY...
Output
YES
NO
Note
In the first set of the input of the first sample Philip must first go forward and go down to the third row of the field, then go only forward, then go forward and climb to the second row, go forward again and go up to the first row. After that way no train blocks Philip's path, so he can go straight to the end of the tunnel.
Note that in this problem the challenges are restricted to tests that contain only one testset. | instruction | 0 | 70,250 | 15 | 140,500 |
Tags: dfs and similar, graphs, shortest paths
Correct Solution:
```
def bfs(mat,x,y,n):
queue = [[x,y,0]]
mark = {j:{u:False for u in range(n)} for j in range(3)}
n-=1
while queue:
q = queue.pop(0)
a,b,c = q[0],q[1],q[2]
if mark[a][b]==True:
continue
mark[a][b]=True
if b==n:
return 'YES'
c+=2
e,r,f = 0,0,0
p = min(b-1+c,n)
z = min(b+2+c,n)
for i in range(p,z):
if mat[0][i]!='.':
e=1
if mat[1][i]!='.':
r=1
if mat[2][i]!='.':
f=1
if mat[a][p]=='.' or p==n:
if e==0:
if a==1 or a==0:
if mark[0][b+1]==False:
queue.append([0,b+1,c])
if r==0:
if mark[1][b+1]==False:
queue.append([1,b+1,c])
if f==0:
if a==1 or a==2:
if mark[2][b+1]==False:
queue.append([2,b+1,c])
t = int(input())
for i in range(t):
n,k = map(int,input().split())
mat = {j:{u:x for u,x in enumerate(input())} for j in range(3)}
if mat[0][0]=='s':
res = bfs(mat,0,0,n)
elif mat[1][0]=='s':
res = bfs(mat,1,0,n)
else:
res = bfs(mat,2,0,n)
if res==None:
print('NO')
else:
print('YES')
``` | output | 1 | 70,250 | 15 | 140,501 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The mobile application store has a new game called "Subway Roller".
The protagonist of the game Philip is located in one end of the tunnel and wants to get out of the other one. The tunnel is a rectangular field consisting of three rows and n columns. At the beginning of the game the hero is in some cell of the leftmost column. Some number of trains rides towards the hero. Each train consists of two or more neighbouring cells in some row of the field.
All trains are moving from right to left at a speed of two cells per second, and the hero runs from left to right at the speed of one cell per second. For simplicity, the game is implemented so that the hero and the trains move in turns. First, the hero moves one cell to the right, then one square up or down, or stays idle. Then all the trains move twice simultaneously one cell to the left. Thus, in one move, Philip definitely makes a move to the right and can move up or down. If at any point, Philip is in the same cell with a train, he loses. If the train reaches the left column, it continues to move as before, leaving the tunnel.
Your task is to answer the question whether there is a sequence of movements of Philip, such that he would be able to get to the rightmost column.
<image>
Input
Each test contains from one to ten sets of the input data. The first line of the test contains a single integer t (1 β€ t β€ 10 for pretests and tests or t = 1 for hacks; see the Notes section for details) β the number of sets.
Then follows the description of t sets of the input data.
The first line of the description of each set contains two integers n, k (2 β€ n β€ 100, 1 β€ k β€ 26) β the number of columns on the field and the number of trains. Each of the following three lines contains the sequence of n character, representing the row of the field where the game is on. Philip's initial position is marked as 's', he is in the leftmost column. Each of the k trains is marked by some sequence of identical uppercase letters of the English alphabet, located in one line. Distinct trains are represented by distinct letters. Character '.' represents an empty cell, that is, the cell that doesn't contain either Philip or the trains.
Output
For each set of the input data print on a single line word YES, if it is possible to win the game and word NO otherwise.
Examples
Input
2
16 4
...AAAAA........
s.BBB......CCCCC
........DDDDD...
16 4
...AAAAA........
s.BBB....CCCCC..
.......DDDDD....
Output
YES
NO
Input
2
10 4
s.ZZ......
.....AAABB
.YYYYYY...
10 4
s.ZZ......
....AAAABB
.YYYYYY...
Output
YES
NO
Note
In the first set of the input of the first sample Philip must first go forward and go down to the third row of the field, then go only forward, then go forward and climb to the second row, go forward again and go up to the first row. After that way no train blocks Philip's path, so he can go straight to the end of the tunnel.
Note that in this problem the challenges are restricted to tests that contain only one testset.
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")
##########################################################
import math
import bisect
mod = 998244353
# for _ in range(int(input())):
from collections import Counter
# sys.setrecursionlimit(10**6)
# dp=[[-1 for i in range(n+5)]for j in range(cap+5)]
# arr= list(map(int, input().split()))
# n,l= map(int, input().split())
# arr= list(map(int, input().split()))
# for _ in range(int(input())):
# n=int(input())
# for _ in range(int(input())):
import bisect
from heapq import *
from collections import defaultdict,deque
def okay(x,y):
if x<0 or x>=3 :
return False
if y<n and mat[x][y]!=".":
return False
if y+1<n and mat[x][y+1]!=".":
return False
if y+2<n and mat[x][y+2]!=".":
return False
return True
'''for i in range(int(input())):
n,m=map(int, input().split())
g=[[] for i in range(n+m)]
for i in range(n):
s=input()
for j,x in enumerate(s):
if x=="#":
g[i].append(n+j)
g[n+j].append(i)
q=deque([0])
dis=[10**9]*(n+m)
dis[0]=0
while q:
node=q.popleft()
for i in g[node]:
if dis[i]>dis[node]+1:
dis[i]=dis[node]+1
q.append(i)
print(-1 if dis[n-1]==10**9 else dis[n-1])'''
from collections import deque
t = int(input())
for _ in range(t):
q = deque([])
flag=False
n,k = map(int, input().split())
mat = [input() for i in range(3)]
vis=[[0 for i in range(105)]for j in range(3)]
for i in range(3):
if mat[i][0]=="s":
q.append((i,0))
while q:
x,y=q.popleft()
if y+1>=n:
flag=True
break
if vis[x][y]==1:
continue
vis[x][y]=1
if (y+1<n and mat[x][y+1]=='.' and okay(x-1,y+1)==True):
q.append((x-1,y+3))
if (y+1<n and mat[x][y+1]=='.' and okay(x,y+1)==True):
q.append((x,y+3))
if (y+1<n and mat[x][y+1]=='.' and okay(x+1,y+1)==True):
q.append((x+1,y+3))
if flag:
print("YES")
else:
print("NO")
# ls=list(map(int, input().split()))
# d=defaultdict(list)
#for _ in range(int(input())):
#import math
#print(math.factorial(20)//200)
# n=int(input())
# n,k= map(int, input().split())
# arr=list(map(int, input().split()))
``` | instruction | 0 | 70,251 | 15 | 140,502 |
Yes | output | 1 | 70,251 | 15 | 140,503 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The mobile application store has a new game called "Subway Roller".
The protagonist of the game Philip is located in one end of the tunnel and wants to get out of the other one. The tunnel is a rectangular field consisting of three rows and n columns. At the beginning of the game the hero is in some cell of the leftmost column. Some number of trains rides towards the hero. Each train consists of two or more neighbouring cells in some row of the field.
All trains are moving from right to left at a speed of two cells per second, and the hero runs from left to right at the speed of one cell per second. For simplicity, the game is implemented so that the hero and the trains move in turns. First, the hero moves one cell to the right, then one square up or down, or stays idle. Then all the trains move twice simultaneously one cell to the left. Thus, in one move, Philip definitely makes a move to the right and can move up or down. If at any point, Philip is in the same cell with a train, he loses. If the train reaches the left column, it continues to move as before, leaving the tunnel.
Your task is to answer the question whether there is a sequence of movements of Philip, such that he would be able to get to the rightmost column.
<image>
Input
Each test contains from one to ten sets of the input data. The first line of the test contains a single integer t (1 β€ t β€ 10 for pretests and tests or t = 1 for hacks; see the Notes section for details) β the number of sets.
Then follows the description of t sets of the input data.
The first line of the description of each set contains two integers n, k (2 β€ n β€ 100, 1 β€ k β€ 26) β the number of columns on the field and the number of trains. Each of the following three lines contains the sequence of n character, representing the row of the field where the game is on. Philip's initial position is marked as 's', he is in the leftmost column. Each of the k trains is marked by some sequence of identical uppercase letters of the English alphabet, located in one line. Distinct trains are represented by distinct letters. Character '.' represents an empty cell, that is, the cell that doesn't contain either Philip or the trains.
Output
For each set of the input data print on a single line word YES, if it is possible to win the game and word NO otherwise.
Examples
Input
2
16 4
...AAAAA........
s.BBB......CCCCC
........DDDDD...
16 4
...AAAAA........
s.BBB....CCCCC..
.......DDDDD....
Output
YES
NO
Input
2
10 4
s.ZZ......
.....AAABB
.YYYYYY...
10 4
s.ZZ......
....AAAABB
.YYYYYY...
Output
YES
NO
Note
In the first set of the input of the first sample Philip must first go forward and go down to the third row of the field, then go only forward, then go forward and climb to the second row, go forward again and go up to the first row. After that way no train blocks Philip's path, so he can go straight to the end of the tunnel.
Note that in this problem the challenges are restricted to tests that contain only one testset.
Submitted Solution:
```
def dfs(x,y):
global f
pos.append((x,y))
y+=1
if f or str(gr[x][y]).isalpha():
return
if y>=q-1:
f=True
return
if not str(gr[x][y+1]).isalpha():
if not str(gr[x][y+2]).isalpha():
if (x,y+2) not in pos:
dfs(x,y+2)
if x>0:
if not str(gr[x-1][y]).isalpha():
if not str(gr[x-1][y+1]).isalpha():
if not str(gr[x-1][y+2]).isalpha():
if (x-1,y+2) not in pos:
dfs(x-1,y+2)
if x<2:
if not str(gr[x+1][y]).isalpha():
if not str(gr[x+1][y+1]).isalpha():
if not str(gr[x+1][y+2]).isalpha():
if (x+1,y+2) not in pos:
dfs(x+1,y+2)
n=int(input())
for i in range(n):
q,w=[int(i) for i in input().split()]
gr=list()
gr.append(input()+" ")
gr.append(input()+" ")
gr.append(input()+" ")
pos=[]
f=False
for i in range(3):
if gr[i][0]=='s':
gr[i]=" "+gr[i][1:]
dfs(i,0)
break
if f:
print("YES")
else:
print("NO")
``` | instruction | 0 | 70,252 | 15 | 140,504 |
Yes | output | 1 | 70,252 | 15 | 140,505 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The mobile application store has a new game called "Subway Roller".
The protagonist of the game Philip is located in one end of the tunnel and wants to get out of the other one. The tunnel is a rectangular field consisting of three rows and n columns. At the beginning of the game the hero is in some cell of the leftmost column. Some number of trains rides towards the hero. Each train consists of two or more neighbouring cells in some row of the field.
All trains are moving from right to left at a speed of two cells per second, and the hero runs from left to right at the speed of one cell per second. For simplicity, the game is implemented so that the hero and the trains move in turns. First, the hero moves one cell to the right, then one square up or down, or stays idle. Then all the trains move twice simultaneously one cell to the left. Thus, in one move, Philip definitely makes a move to the right and can move up or down. If at any point, Philip is in the same cell with a train, he loses. If the train reaches the left column, it continues to move as before, leaving the tunnel.
Your task is to answer the question whether there is a sequence of movements of Philip, such that he would be able to get to the rightmost column.
<image>
Input
Each test contains from one to ten sets of the input data. The first line of the test contains a single integer t (1 β€ t β€ 10 for pretests and tests or t = 1 for hacks; see the Notes section for details) β the number of sets.
Then follows the description of t sets of the input data.
The first line of the description of each set contains two integers n, k (2 β€ n β€ 100, 1 β€ k β€ 26) β the number of columns on the field and the number of trains. Each of the following three lines contains the sequence of n character, representing the row of the field where the game is on. Philip's initial position is marked as 's', he is in the leftmost column. Each of the k trains is marked by some sequence of identical uppercase letters of the English alphabet, located in one line. Distinct trains are represented by distinct letters. Character '.' represents an empty cell, that is, the cell that doesn't contain either Philip or the trains.
Output
For each set of the input data print on a single line word YES, if it is possible to win the game and word NO otherwise.
Examples
Input
2
16 4
...AAAAA........
s.BBB......CCCCC
........DDDDD...
16 4
...AAAAA........
s.BBB....CCCCC..
.......DDDDD....
Output
YES
NO
Input
2
10 4
s.ZZ......
.....AAABB
.YYYYYY...
10 4
s.ZZ......
....AAAABB
.YYYYYY...
Output
YES
NO
Note
In the first set of the input of the first sample Philip must first go forward and go down to the third row of the field, then go only forward, then go forward and climb to the second row, go forward again and go up to the first row. After that way no train blocks Philip's path, so he can go straight to the end of the tunnel.
Note that in this problem the challenges are restricted to tests that contain only one testset.
Submitted Solution:
```
def simulate(grid):
n, m = len(grid), len(grid[0])
threshold = n * [ m ]
for r in range(n):
c = m - 1
while c >= 0 and grid[r][c] == '.':
c -= 1
threshold[r] = c + 1
#print(threshold)
in_row = n * [ False ]
for r in range(n):
if grid[r][0] == 's':
in_row[r] = True
break
c = 0
while True:
next_in_row = n * [ False ]
for r, possible in enumerate(in_row):
if not possible:
continue
if c + 1 >= threshold[r]:
return True
if grid[r][c + 1] != '.':
continue
for rr in range(max(0, r - 1), min(r + 2, n)):
okay = True
for cc in range(c + 1, c + 4):
if cc >= threshold[rr]:
return True
if grid[rr][cc] != '.':
okay = False
break
if okay:
next_in_row[rr] = True
in_row = next_in_row
c += 3
#print(c, in_row)
if True not in in_row:
return False
num_cases = int(input())
for case_index in range(num_cases):
m, k = map(int, input().split())
grid = [ list(input().strip()) for r in range(3) ]
if simulate(grid):
print('YES')
else:
print('NO')
``` | instruction | 0 | 70,253 | 15 | 140,506 |
Yes | output | 1 | 70,253 | 15 | 140,507 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The mobile application store has a new game called "Subway Roller".
The protagonist of the game Philip is located in one end of the tunnel and wants to get out of the other one. The tunnel is a rectangular field consisting of three rows and n columns. At the beginning of the game the hero is in some cell of the leftmost column. Some number of trains rides towards the hero. Each train consists of two or more neighbouring cells in some row of the field.
All trains are moving from right to left at a speed of two cells per second, and the hero runs from left to right at the speed of one cell per second. For simplicity, the game is implemented so that the hero and the trains move in turns. First, the hero moves one cell to the right, then one square up or down, or stays idle. Then all the trains move twice simultaneously one cell to the left. Thus, in one move, Philip definitely makes a move to the right and can move up or down. If at any point, Philip is in the same cell with a train, he loses. If the train reaches the left column, it continues to move as before, leaving the tunnel.
Your task is to answer the question whether there is a sequence of movements of Philip, such that he would be able to get to the rightmost column.
<image>
Input
Each test contains from one to ten sets of the input data. The first line of the test contains a single integer t (1 β€ t β€ 10 for pretests and tests or t = 1 for hacks; see the Notes section for details) β the number of sets.
Then follows the description of t sets of the input data.
The first line of the description of each set contains two integers n, k (2 β€ n β€ 100, 1 β€ k β€ 26) β the number of columns on the field and the number of trains. Each of the following three lines contains the sequence of n character, representing the row of the field where the game is on. Philip's initial position is marked as 's', he is in the leftmost column. Each of the k trains is marked by some sequence of identical uppercase letters of the English alphabet, located in one line. Distinct trains are represented by distinct letters. Character '.' represents an empty cell, that is, the cell that doesn't contain either Philip or the trains.
Output
For each set of the input data print on a single line word YES, if it is possible to win the game and word NO otherwise.
Examples
Input
2
16 4
...AAAAA........
s.BBB......CCCCC
........DDDDD...
16 4
...AAAAA........
s.BBB....CCCCC..
.......DDDDD....
Output
YES
NO
Input
2
10 4
s.ZZ......
.....AAABB
.YYYYYY...
10 4
s.ZZ......
....AAAABB
.YYYYYY...
Output
YES
NO
Note
In the first set of the input of the first sample Philip must first go forward and go down to the third row of the field, then go only forward, then go forward and climb to the second row, go forward again and go up to the first row. After that way no train blocks Philip's path, so he can go straight to the end of the tunnel.
Note that in this problem the challenges are restricted to tests that contain only one testset.
Submitted Solution:
```
t = int(input())
for test in range(t):
n,k = [int(i) for i in input().split()]
grid = [[True for i in range(3)] for i in range(n)]
ok = [[False for i in range(3)] for i in range(n)]
#x-col, y-row
rx = 0; ry = 0
for i in range(3):
row = input()
j=0
for v in row:
if v=='s':
#print("here")
rx = j
ry = i
elif v!='.':
grid[j][i] = False
j+=1
def verify(x,y):
if x<n and y<3 and x>=0 and y>=0:
return grid[x][y]
else:
return False
def dfs(x,y):
global ok
if not ok[x][y]:
#print(x,' ',y)
ok[x][y]=True
if verify(x+1, y) and verify(x+3,y):
dfs(x+3,y)
if verify(x+1,y) and verify(x+1,y+1) and verify(x+3,y+1):
dfs(x+3,y+1)
if verify(x+1,y) and verify(x+1,y-1) and verify(x+3,y-1):
dfs(x+3,y-1)
#end game(tap in)
if x+2>=n-1:
if verify(x+1,y):
dfs(x+1,y)
dfs(rx, ry)
#print(rx, ry)
#print(ok)
res = False
for i in range(3):
if ok[n-1][i]:
res=True
if res:
print("YES")
else:
print("NO")
``` | instruction | 0 | 70,254 | 15 | 140,508 |
Yes | output | 1 | 70,254 | 15 | 140,509 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The mobile application store has a new game called "Subway Roller".
The protagonist of the game Philip is located in one end of the tunnel and wants to get out of the other one. The tunnel is a rectangular field consisting of three rows and n columns. At the beginning of the game the hero is in some cell of the leftmost column. Some number of trains rides towards the hero. Each train consists of two or more neighbouring cells in some row of the field.
All trains are moving from right to left at a speed of two cells per second, and the hero runs from left to right at the speed of one cell per second. For simplicity, the game is implemented so that the hero and the trains move in turns. First, the hero moves one cell to the right, then one square up or down, or stays idle. Then all the trains move twice simultaneously one cell to the left. Thus, in one move, Philip definitely makes a move to the right and can move up or down. If at any point, Philip is in the same cell with a train, he loses. If the train reaches the left column, it continues to move as before, leaving the tunnel.
Your task is to answer the question whether there is a sequence of movements of Philip, such that he would be able to get to the rightmost column.
<image>
Input
Each test contains from one to ten sets of the input data. The first line of the test contains a single integer t (1 β€ t β€ 10 for pretests and tests or t = 1 for hacks; see the Notes section for details) β the number of sets.
Then follows the description of t sets of the input data.
The first line of the description of each set contains two integers n, k (2 β€ n β€ 100, 1 β€ k β€ 26) β the number of columns on the field and the number of trains. Each of the following three lines contains the sequence of n character, representing the row of the field where the game is on. Philip's initial position is marked as 's', he is in the leftmost column. Each of the k trains is marked by some sequence of identical uppercase letters of the English alphabet, located in one line. Distinct trains are represented by distinct letters. Character '.' represents an empty cell, that is, the cell that doesn't contain either Philip or the trains.
Output
For each set of the input data print on a single line word YES, if it is possible to win the game and word NO otherwise.
Examples
Input
2
16 4
...AAAAA........
s.BBB......CCCCC
........DDDDD...
16 4
...AAAAA........
s.BBB....CCCCC..
.......DDDDD....
Output
YES
NO
Input
2
10 4
s.ZZ......
.....AAABB
.YYYYYY...
10 4
s.ZZ......
....AAAABB
.YYYYYY...
Output
YES
NO
Note
In the first set of the input of the first sample Philip must first go forward and go down to the third row of the field, then go only forward, then go forward and climb to the second row, go forward again and go up to the first row. After that way no train blocks Philip's path, so he can go straight to the end of the tunnel.
Note that in this problem the challenges are restricted to tests that contain only one testset.
Submitted Solution:
```
ress=[]
for asdf in range(int(input())):
a=list(map(int,input().split(' ')))
n=a[0]
res='YES'
lvl=[]
lvl.append(list(input()+'.'))
lvl.append(list(input()+'.'))
lvl.append(list(input()+'.'))
k=1
dom=set()
if lvl[0][0]=='s':
ph=0
elif lvl[0][1]=='s':
ph=1
else:
ph=2
if lvl[ph][k]!='.':
res='NO'
else:
for i in range(3):
if lvl[i][k]=='.':
dom.add(i)
while k<n-2:
rng=set()
if 0 in dom:
if lvl[0][k+1]=='.' and lvl[0][k+2]=='.' and lvl[0][k+3]=='.':
rng.add(0)
if lvl[1][k+3]=='.':
rng.add(1)
if 1 in dom:
if 1 not in rng:
if lvl[1][k+1]=='.' and lvl[1][k+2]=='.' and lvl[1][k+3]=='.':
rng.add(1)
if lvl[0][k+3]=='.':
rng.add(0)
if lvl[2][k+3]=='.':
rng.add(2)
if 2 in dom:
if 2 not in rng:
if lvl[2][k+1]=='.' and lvl[2][k+2]=='.' and lvl[2][k+3]=='.':
rng.add(2)
if lvl[1][k+3]=='.':
rng.add(1)
if not rng:
res='NO'
break
dom=rng
k+=3
ress.append(res)
for i in ress:
print(i)
``` | instruction | 0 | 70,255 | 15 | 140,510 |
No | output | 1 | 70,255 | 15 | 140,511 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The mobile application store has a new game called "Subway Roller".
The protagonist of the game Philip is located in one end of the tunnel and wants to get out of the other one. The tunnel is a rectangular field consisting of three rows and n columns. At the beginning of the game the hero is in some cell of the leftmost column. Some number of trains rides towards the hero. Each train consists of two or more neighbouring cells in some row of the field.
All trains are moving from right to left at a speed of two cells per second, and the hero runs from left to right at the speed of one cell per second. For simplicity, the game is implemented so that the hero and the trains move in turns. First, the hero moves one cell to the right, then one square up or down, or stays idle. Then all the trains move twice simultaneously one cell to the left. Thus, in one move, Philip definitely makes a move to the right and can move up or down. If at any point, Philip is in the same cell with a train, he loses. If the train reaches the left column, it continues to move as before, leaving the tunnel.
Your task is to answer the question whether there is a sequence of movements of Philip, such that he would be able to get to the rightmost column.
<image>
Input
Each test contains from one to ten sets of the input data. The first line of the test contains a single integer t (1 β€ t β€ 10 for pretests and tests or t = 1 for hacks; see the Notes section for details) β the number of sets.
Then follows the description of t sets of the input data.
The first line of the description of each set contains two integers n, k (2 β€ n β€ 100, 1 β€ k β€ 26) β the number of columns on the field and the number of trains. Each of the following three lines contains the sequence of n character, representing the row of the field where the game is on. Philip's initial position is marked as 's', he is in the leftmost column. Each of the k trains is marked by some sequence of identical uppercase letters of the English alphabet, located in one line. Distinct trains are represented by distinct letters. Character '.' represents an empty cell, that is, the cell that doesn't contain either Philip or the trains.
Output
For each set of the input data print on a single line word YES, if it is possible to win the game and word NO otherwise.
Examples
Input
2
16 4
...AAAAA........
s.BBB......CCCCC
........DDDDD...
16 4
...AAAAA........
s.BBB....CCCCC..
.......DDDDD....
Output
YES
NO
Input
2
10 4
s.ZZ......
.....AAABB
.YYYYYY...
10 4
s.ZZ......
....AAAABB
.YYYYYY...
Output
YES
NO
Note
In the first set of the input of the first sample Philip must first go forward and go down to the third row of the field, then go only forward, then go forward and climb to the second row, go forward again and go up to the first row. After that way no train blocks Philip's path, so he can go straight to the end of the tunnel.
Note that in this problem the challenges are restricted to tests that contain only one testset.
Submitted Solution:
```
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
# Copyright Β© 2016 missingdays <missingdays@missingdays>
#
# Distributed under terms of the MIT license.
"""
"""
def shift(a, n):
b = [["." for i in range(n)] for i in range(3)]
for i in range(3):
for j in range(n-2):
b[i][j] = a[i][j+2]
return b
n = int(input())
for case in range(n):
n, k = [int(i) for i in input().split()]
a = []
for i in range(3):
a.append(list(input()))
m = [[False for i in range(n)] for j in range(3)]
for i in range(3):
if a[i][0] == 's':
m[i][0] = True
for i in range(1, n):
#print(a)
for j in range(3):
if m[j][i-1] and a[j][i] == "." and (a[j][i-1] == "." or a[j][i-1] == "s") and (i > 1 or a[j][i-2] == "."):
m[j][i] = True
if m[0][i]:
if a[1][i] == ".": #and (i > n-2 or a[1][i+1] == ".") and (i > n-3 or a[1][i+2] == "."):
m[1][i] = True
if m[1][i]:
if a[0][i] == ".": #and (i > n-2 or a[0][i+1] == ".") and (i > n-3 or a[0][i+2] == "."):
m[0][i] = True
if a[2][i] == ".": #and (i > n-2 or a[2][i+1] == ".") and (i > n-3 or a[2][i+2] == "."):
m[2][i] = True
if m[2][i]:
if a[1][i] == ".": #and (i > n-2 or a[1][i+1] == ".") and (i > n-3 or a[1][i+2] == "."):
m[1][i] = True
#print(m)
a = shift(a, n)
for i in range(3):
if m[i][n-1]:
print("YES")
break
else:
print("NO")
``` | instruction | 0 | 70,256 | 15 | 140,512 |
No | output | 1 | 70,256 | 15 | 140,513 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The mobile application store has a new game called "Subway Roller".
The protagonist of the game Philip is located in one end of the tunnel and wants to get out of the other one. The tunnel is a rectangular field consisting of three rows and n columns. At the beginning of the game the hero is in some cell of the leftmost column. Some number of trains rides towards the hero. Each train consists of two or more neighbouring cells in some row of the field.
All trains are moving from right to left at a speed of two cells per second, and the hero runs from left to right at the speed of one cell per second. For simplicity, the game is implemented so that the hero and the trains move in turns. First, the hero moves one cell to the right, then one square up or down, or stays idle. Then all the trains move twice simultaneously one cell to the left. Thus, in one move, Philip definitely makes a move to the right and can move up or down. If at any point, Philip is in the same cell with a train, he loses. If the train reaches the left column, it continues to move as before, leaving the tunnel.
Your task is to answer the question whether there is a sequence of movements of Philip, such that he would be able to get to the rightmost column.
<image>
Input
Each test contains from one to ten sets of the input data. The first line of the test contains a single integer t (1 β€ t β€ 10 for pretests and tests or t = 1 for hacks; see the Notes section for details) β the number of sets.
Then follows the description of t sets of the input data.
The first line of the description of each set contains two integers n, k (2 β€ n β€ 100, 1 β€ k β€ 26) β the number of columns on the field and the number of trains. Each of the following three lines contains the sequence of n character, representing the row of the field where the game is on. Philip's initial position is marked as 's', he is in the leftmost column. Each of the k trains is marked by some sequence of identical uppercase letters of the English alphabet, located in one line. Distinct trains are represented by distinct letters. Character '.' represents an empty cell, that is, the cell that doesn't contain either Philip or the trains.
Output
For each set of the input data print on a single line word YES, if it is possible to win the game and word NO otherwise.
Examples
Input
2
16 4
...AAAAA........
s.BBB......CCCCC
........DDDDD...
16 4
...AAAAA........
s.BBB....CCCCC..
.......DDDDD....
Output
YES
NO
Input
2
10 4
s.ZZ......
.....AAABB
.YYYYYY...
10 4
s.ZZ......
....AAAABB
.YYYYYY...
Output
YES
NO
Note
In the first set of the input of the first sample Philip must first go forward and go down to the third row of the field, then go only forward, then go forward and climb to the second row, go forward again and go up to the first row. After that way no train blocks Philip's path, so he can go straight to the end of the tunnel.
Note that in this problem the challenges are restricted to tests that contain only one testset.
Submitted Solution:
```
import sys
flag = False
t = int(input())
for kek in range(t):
n, k = [int(i) for i in input().split()]
if t == 10 and n == 95 and k == 6:
flag = True
a = [[0] * n for i in range(3)]
for i in range(3):
a[i] = [i for i in input()]
dp = [[False] * n for i in range(3)]
l = 0
if a[0][0] == 's':
l = 0
if a[1][0] == 's':
l = 1
if a[2][0] == 's':
l = 2
dp[l][0] = True
first = [[False] * n for i in range(3)]
first[l][0] = True
first[max(l - 1, 0)][0] = True
first[min(l + 1, 2)][0] = True
bad = [True] * 3
for i in range(1, n):
if 3 * i < n and a[0][3 * i] == '.' and a[0][3 * i - 2] == '.':
if (dp[0][i - 1] or first[0][i - 1]) or (a[1][3 * i - 2] == '.' and dp[1][i - 1]):
dp[0][i] = True
elif 3 * i >= n > 3 * i - 2:
if (dp[0][i - 1] and a[0][3 * i - 2] == '.') or (dp[1][i - 1] and a[1][3 * i - 2] == '.'):
dp[0][i] = True
elif 3 * i >= n and (dp[0][i - 1] or dp[1][i - 1]):
dp[0][i] = True
if 3 * i < n and a[1][3 * i] == '.' and a[1][3 * i - 2] == '.':
if (dp[1][i - 1] or first[1][i - 1]) or (a[0][3 * i - 2] == '.' and dp[0][i - 1]) or (a[2][3 * i - 2] == '.' and dp[2][i - 1]):
dp[1][i] = True
elif 3 * i >= n > 3 * i - 2:
if (dp[0][i - 1] and a[0][3 * i - 2] == '.') or (dp[1][i - 1] and a[1][3 * i - 2] == '.') or (dp[2][i - 1] and a[2][3 * i - 2] == '.'):
dp[1][i] = True
elif 3 * i >= n and (dp[0][i - 1] or dp[1][i - 1] or dp[2][i - 1]):
dp[1][i] = True
if 3 * i < n and a[2][3 * i] == '.' and a[2][3 * i - 2] == '.':
if (dp[2][i - 1] or first[2][i - 1]) or (a[1][3 * i - 2] == '.' and dp[1][i - 1]):
dp[2][i] = True
elif 3 * i >= n > 3 * i - 2:
if (dp[2][i - 1] and a[2][3 * i - 2] == '.') or (dp[1][i - 1] and a[1][3 * i - 2] == '.'):
dp[2][i] = True
elif 3 * i >= n and (dp[1][i - 1] or dp[2][i - 1]):
dp[2][i] = True
#for i in range(3):
# print(dp[i])
if not flag or kek != 3:
if max(dp[0][n - 1], dp[1][n - 1], dp[2][n - 1]):
print('YES')
else:
print('NO')
else:
for i in range(3):
print(a[i])
``` | instruction | 0 | 70,257 | 15 | 140,514 |
No | output | 1 | 70,257 | 15 | 140,515 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The mobile application store has a new game called "Subway Roller".
The protagonist of the game Philip is located in one end of the tunnel and wants to get out of the other one. The tunnel is a rectangular field consisting of three rows and n columns. At the beginning of the game the hero is in some cell of the leftmost column. Some number of trains rides towards the hero. Each train consists of two or more neighbouring cells in some row of the field.
All trains are moving from right to left at a speed of two cells per second, and the hero runs from left to right at the speed of one cell per second. For simplicity, the game is implemented so that the hero and the trains move in turns. First, the hero moves one cell to the right, then one square up or down, or stays idle. Then all the trains move twice simultaneously one cell to the left. Thus, in one move, Philip definitely makes a move to the right and can move up or down. If at any point, Philip is in the same cell with a train, he loses. If the train reaches the left column, it continues to move as before, leaving the tunnel.
Your task is to answer the question whether there is a sequence of movements of Philip, such that he would be able to get to the rightmost column.
<image>
Input
Each test contains from one to ten sets of the input data. The first line of the test contains a single integer t (1 β€ t β€ 10 for pretests and tests or t = 1 for hacks; see the Notes section for details) β the number of sets.
Then follows the description of t sets of the input data.
The first line of the description of each set contains two integers n, k (2 β€ n β€ 100, 1 β€ k β€ 26) β the number of columns on the field and the number of trains. Each of the following three lines contains the sequence of n character, representing the row of the field where the game is on. Philip's initial position is marked as 's', he is in the leftmost column. Each of the k trains is marked by some sequence of identical uppercase letters of the English alphabet, located in one line. Distinct trains are represented by distinct letters. Character '.' represents an empty cell, that is, the cell that doesn't contain either Philip or the trains.
Output
For each set of the input data print on a single line word YES, if it is possible to win the game and word NO otherwise.
Examples
Input
2
16 4
...AAAAA........
s.BBB......CCCCC
........DDDDD...
16 4
...AAAAA........
s.BBB....CCCCC..
.......DDDDD....
Output
YES
NO
Input
2
10 4
s.ZZ......
.....AAABB
.YYYYYY...
10 4
s.ZZ......
....AAAABB
.YYYYYY...
Output
YES
NO
Note
In the first set of the input of the first sample Philip must first go forward and go down to the third row of the field, then go only forward, then go forward and climb to the second row, go forward again and go up to the first row. After that way no train blocks Philip's path, so he can go straight to the end of the tunnel.
Note that in this problem the challenges are restricted to tests that contain only one testset.
Submitted Solution:
```
import sys
t = int(input())
for kek in range(t):
n, k = [int(i) for i in input().split()]
# if t == 10 and n == 30 and k == 6:
# for i in range(t):
# print('NO')
# sys.exit()
# if t == 10 and n == 95 and k == 6:
# ans = ['YES', 'YES', 'NO', 'NO', 'NO', 'YES', 'YES', 'YES', 'NO', 'YES']
# for i in range(t):
# print(ans[i])
# sys.exit()
a = [[0] * n for i in range(3)]
for i in range(3):
a[i] = [i for i in input()]
dp = [[False] * n for i in range(3)]
l = 0
if a[0][0] == 's':
l = 0
if a[1][0] == 's':
l = 1
if a[2][0] == 's':
l = 2
dp[l][0] = True
first = [[False] * n for i in range(3)]
first[l][0] = True
first[max(l - 1, 0)][0] = True
first[min(l + 1, 2)][0] = True
bad = [True] * 3
for i in range(1, n):
if 3 * i < n and a[0][3 * i] == '.' and a[0][3 * i - 2] == '.':
if (dp[0][i - 1] or first[0][i - 1]) or (a[1][3 * i - 2] == '.' and dp[1][i - 1]):
dp[0][i] = True
elif 3 * i >= n > 3 * i - 2:
if (dp[0][i - 1] and a[0][3 * i - 2] == '.') or (dp[1][i - 1] and a[1][3 * i - 2] == '.'):
dp[0][i] = True
elif 3 * i >= n and (dp[0][i - 1] or dp[1][i - 1]):
dp[0][i] = True
if 3 * i < n and a[1][3 * i] == '.' and a[1][3 * i - 2] == '.':
if (dp[1][i - 1] or first[1][i - 1]) or (a[0][3 * i - 2] == '.' and dp[0][i - 1]) or (a[2][3 * i - 2] == '.' and dp[2][i - 1]):
dp[1][i] = True
elif 3 * i >= n > 3 * i - 2:
if (dp[0][i - 1] and a[0][3 * i - 2] == '.') or (dp[1][i - 1] and a[1][3 * i - 2] == '.') or (dp[2][i - 1] and a[2][3 * i - 2] == '.'):
dp[1][i] = True
elif 3 * i >= n and (dp[0][i - 1] or dp[1][i - 1] or dp[2][i - 1]):
dp[1][i] = True
if 3 * i < n and a[2][3 * i] == '.' and a[2][3 * i - 2] == '.':
if (dp[2][i - 1] or first[2][i - 1]) or (a[1][3 * i - 2] == '.' and dp[1][i - 1]):
dp[2][i] = True
elif 3 * i >= n > 3 * i - 2:
if (dp[2][i - 1] and a[2][3 * i - 2] == '.') or (dp[1][i - 1] and a[1][3 * i - 2] == '.'):
dp[2][i] = True
elif 3 * i >= n and (dp[1][i - 1] or dp[2][i - 1]):
dp[2][i] = True
#for i in range(3):
# print(dp[i])
if max(dp[0][n - 1], dp[1][n - 1], dp[2][n - 1]):
print('YES')
else:
print('NO')
``` | instruction | 0 | 70,258 | 15 | 140,516 |
No | output | 1 | 70,258 | 15 | 140,517 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob programmed a robot to navigate through a 2d maze.
The maze has some obstacles. Empty cells are denoted by the character '.', where obstacles are denoted by '#'.
There is a single robot in the maze. Its start position is denoted with the character 'S'. This position has no obstacle in it. There is also a single exit in the maze. Its position is denoted with the character 'E'. This position has no obstacle in it.
The robot can only move up, left, right, or down.
When Bob programmed the robot, he wrote down a string of digits consisting of the digits 0 to 3, inclusive. He intended for each digit to correspond to a distinct direction, and the robot would follow the directions in order to reach the exit. Unfortunately, he forgot to actually assign the directions to digits.
The robot will choose some random mapping of digits to distinct directions. The robot will map distinct digits to distinct directions. The robot will then follow the instructions according to the given string in order and chosen mapping. If an instruction would lead the robot to go off the edge of the maze or hit an obstacle, the robot will crash and break down. If the robot reaches the exit at any point, then the robot will stop following any further instructions.
Bob is having trouble debugging his robot, so he would like to determine the number of mappings of digits to directions that would lead the robot to the exit.
Input
The first line of input will contain two integers n and m (2 β€ n, m β€ 50), denoting the dimensions of the maze.
The next n lines will contain exactly m characters each, denoting the maze.
Each character of the maze will be '.', '#', 'S', or 'E'.
There will be exactly one 'S' and exactly one 'E' in the maze.
The last line will contain a single string s (1 β€ |s| β€ 100) β the instructions given to the robot. Each character of s is a digit from 0 to 3.
Output
Print a single integer, the number of mappings of digits to directions that will lead the robot to the exit.
Examples
Input
5 6
.....#
S....#
.#....
.#....
...E..
333300012
Output
1
Input
6 6
......
......
..SE..
......
......
......
01232123212302123021
Output
14
Input
5 3
...
.S.
###
.E.
...
3
Output
0
Note
For the first sample, the only valid mapping is <image>, where D is down, L is left, U is up, R is right. | instruction | 0 | 70,434 | 15 | 140,868 |
Tags: brute force, implementation
Correct Solution:
```
z=[(1,0),(0,1),(-1,0),(0,-1)]
from itertools import permutations
z=permutations(z,4)
a,b=map(int,input().split())
x,y=0,0;o=[]
for i in range(a):
q=input()
if "S" in q:x=i;y=q.index("S")
o+=[q]
code=input()
def mar(k,f,f1):
global o,q,code,a,b
x=f;y=f1
for i in code:
s=k[int(i)]
x+=s[0];y+=s[1]
if x<0 or y<0 or x>=a or y>=b or o[x][y]=="#":return False
if o[x][y]=="E":return True
return False
su=0
for i in z:
if mar(i,x,y):su+=1
print(su)
``` | output | 1 | 70,434 | 15 | 140,869 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob programmed a robot to navigate through a 2d maze.
The maze has some obstacles. Empty cells are denoted by the character '.', where obstacles are denoted by '#'.
There is a single robot in the maze. Its start position is denoted with the character 'S'. This position has no obstacle in it. There is also a single exit in the maze. Its position is denoted with the character 'E'. This position has no obstacle in it.
The robot can only move up, left, right, or down.
When Bob programmed the robot, he wrote down a string of digits consisting of the digits 0 to 3, inclusive. He intended for each digit to correspond to a distinct direction, and the robot would follow the directions in order to reach the exit. Unfortunately, he forgot to actually assign the directions to digits.
The robot will choose some random mapping of digits to distinct directions. The robot will map distinct digits to distinct directions. The robot will then follow the instructions according to the given string in order and chosen mapping. If an instruction would lead the robot to go off the edge of the maze or hit an obstacle, the robot will crash and break down. If the robot reaches the exit at any point, then the robot will stop following any further instructions.
Bob is having trouble debugging his robot, so he would like to determine the number of mappings of digits to directions that would lead the robot to the exit.
Input
The first line of input will contain two integers n and m (2 β€ n, m β€ 50), denoting the dimensions of the maze.
The next n lines will contain exactly m characters each, denoting the maze.
Each character of the maze will be '.', '#', 'S', or 'E'.
There will be exactly one 'S' and exactly one 'E' in the maze.
The last line will contain a single string s (1 β€ |s| β€ 100) β the instructions given to the robot. Each character of s is a digit from 0 to 3.
Output
Print a single integer, the number of mappings of digits to directions that will lead the robot to the exit.
Examples
Input
5 6
.....#
S....#
.#....
.#....
...E..
333300012
Output
1
Input
6 6
......
......
..SE..
......
......
......
01232123212302123021
Output
14
Input
5 3
...
.S.
###
.E.
...
3
Output
0
Note
For the first sample, the only valid mapping is <image>, where D is down, L is left, U is up, R is right. | instruction | 0 | 70,435 | 15 | 140,870 |
Tags: brute force, implementation
Correct Solution:
```
n,m=input().split()
n=int(n)
m=int(m)
iS=list()
iE=list()
maze=list()
for i in range(n):
x=input()
if 'S' in x:
for j in range(len(x)):
if 'S'==x[j]:
iS.append(i)
iS.append(j)
if 'E' in x:
for j in range(len(x)):
if 'E'==x[j]:
iE.append(i)
iE.append(j)
l=list()
for i in range(len(x)):
l.append(x[i])
maze.append(l)
s=input()
count=0
case=["0123","0132","0213","0231","0312","0321",\
"1230","1203","1302","1320","1032","1023",\
"2301","2310","2013","2031","2103","2130",\
"3012","3021","3102","3120","3201","3210"]
for i in range(len(case)):
u=case[i][0]
d=case[i][1]
r=case[i][2]
l=case[i][3]
x=iS[0]
y=iS[1]
flag=1
for j in range(len(s)):
if s[j]==u:
x=x-1
elif s[j]==d:
x=x+1
elif s[j]==r:
y=y+1
elif s[j]==l:
y=y-1
#print(x,y)
if((x<0) or (x>n-1) or (y<0) or (y>m-1)):
break
elif(maze[x][y]=='E'):
flag=0
break
elif(maze[x][y]=='#'):
break;
if flag==0:
count=count+1
print(count)
``` | output | 1 | 70,435 | 15 | 140,871 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob programmed a robot to navigate through a 2d maze.
The maze has some obstacles. Empty cells are denoted by the character '.', where obstacles are denoted by '#'.
There is a single robot in the maze. Its start position is denoted with the character 'S'. This position has no obstacle in it. There is also a single exit in the maze. Its position is denoted with the character 'E'. This position has no obstacle in it.
The robot can only move up, left, right, or down.
When Bob programmed the robot, he wrote down a string of digits consisting of the digits 0 to 3, inclusive. He intended for each digit to correspond to a distinct direction, and the robot would follow the directions in order to reach the exit. Unfortunately, he forgot to actually assign the directions to digits.
The robot will choose some random mapping of digits to distinct directions. The robot will map distinct digits to distinct directions. The robot will then follow the instructions according to the given string in order and chosen mapping. If an instruction would lead the robot to go off the edge of the maze or hit an obstacle, the robot will crash and break down. If the robot reaches the exit at any point, then the robot will stop following any further instructions.
Bob is having trouble debugging his robot, so he would like to determine the number of mappings of digits to directions that would lead the robot to the exit.
Input
The first line of input will contain two integers n and m (2 β€ n, m β€ 50), denoting the dimensions of the maze.
The next n lines will contain exactly m characters each, denoting the maze.
Each character of the maze will be '.', '#', 'S', or 'E'.
There will be exactly one 'S' and exactly one 'E' in the maze.
The last line will contain a single string s (1 β€ |s| β€ 100) β the instructions given to the robot. Each character of s is a digit from 0 to 3.
Output
Print a single integer, the number of mappings of digits to directions that will lead the robot to the exit.
Examples
Input
5 6
.....#
S....#
.#....
.#....
...E..
333300012
Output
1
Input
6 6
......
......
..SE..
......
......
......
01232123212302123021
Output
14
Input
5 3
...
.S.
###
.E.
...
3
Output
0
Note
For the first sample, the only valid mapping is <image>, where D is down, L is left, U is up, R is right. | instruction | 0 | 70,436 | 15 | 140,872 |
Tags: brute force, implementation
Correct Solution:
```
from itertools import permutations
n,m=list(map(int,input().split()))
a=[]
for i in range(n):
a.append(input())
s=input()
b=[[1,0],[0,1],[-1,0],[0,-1]]
ans=0
def f(s,l,n,m):
temp=0
for i in range(n):
for j in range(m):
if a[i][j]=='S':
p=[i,j]
temp=1
break
if temp:
break
for i in s:
p[0]+=l[int(i)-1][0]
p[1]+=l[int(i)-1][1]
if p[0]<0 or p[0]>=n:
return 0
if p[1]<0 or p[1]>=m:
return 0
if a[p[0]][p[1]]=='#':
return 0
if a[p[0]][p[1]]=='E':
return 1
return 0
for i in permutations(b):
ans+=f(s,list(i),n,m)
print(ans)
``` | output | 1 | 70,436 | 15 | 140,873 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob programmed a robot to navigate through a 2d maze.
The maze has some obstacles. Empty cells are denoted by the character '.', where obstacles are denoted by '#'.
There is a single robot in the maze. Its start position is denoted with the character 'S'. This position has no obstacle in it. There is also a single exit in the maze. Its position is denoted with the character 'E'. This position has no obstacle in it.
The robot can only move up, left, right, or down.
When Bob programmed the robot, he wrote down a string of digits consisting of the digits 0 to 3, inclusive. He intended for each digit to correspond to a distinct direction, and the robot would follow the directions in order to reach the exit. Unfortunately, he forgot to actually assign the directions to digits.
The robot will choose some random mapping of digits to distinct directions. The robot will map distinct digits to distinct directions. The robot will then follow the instructions according to the given string in order and chosen mapping. If an instruction would lead the robot to go off the edge of the maze or hit an obstacle, the robot will crash and break down. If the robot reaches the exit at any point, then the robot will stop following any further instructions.
Bob is having trouble debugging his robot, so he would like to determine the number of mappings of digits to directions that would lead the robot to the exit.
Input
The first line of input will contain two integers n and m (2 β€ n, m β€ 50), denoting the dimensions of the maze.
The next n lines will contain exactly m characters each, denoting the maze.
Each character of the maze will be '.', '#', 'S', or 'E'.
There will be exactly one 'S' and exactly one 'E' in the maze.
The last line will contain a single string s (1 β€ |s| β€ 100) β the instructions given to the robot. Each character of s is a digit from 0 to 3.
Output
Print a single integer, the number of mappings of digits to directions that will lead the robot to the exit.
Examples
Input
5 6
.....#
S....#
.#....
.#....
...E..
333300012
Output
1
Input
6 6
......
......
..SE..
......
......
......
01232123212302123021
Output
14
Input
5 3
...
.S.
###
.E.
...
3
Output
0
Note
For the first sample, the only valid mapping is <image>, where D is down, L is left, U is up, R is right. | instruction | 0 | 70,437 | 15 | 140,874 |
Tags: brute force, implementation
Correct Solution:
```
import itertools
import sys
n, m = [int(x) for x in sys.stdin.readline().split()]
maze = []
robopos = None
for i in range(n):
maze.append(sys.stdin.readline())
if maze[i].find('S') != -1:
robopos = [i, maze[i].find('S')]
directions = [int(x) for x in sys.stdin.readline()[:-1]]
howgo = [(-1,0),(1,0),(0,-1),(0,1)]
escapes = 0
for howgoo in itertools.permutations(howgo):
roboposs = robopos.copy()
for d in directions:
roboposs[0] += howgoo[d][0]
roboposs[1] += howgoo[d][1]
if roboposs[0] < 0 or roboposs[1] < 0 or roboposs[0] >= n or roboposs[1] >= m:
break
if maze[roboposs[0]][roboposs[1]] == '#':
break
if maze[roboposs[0]][roboposs[1]] == 'E':
escapes += 1
break
# . doesnt matter
print(escapes)
``` | output | 1 | 70,437 | 15 | 140,875 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob programmed a robot to navigate through a 2d maze.
The maze has some obstacles. Empty cells are denoted by the character '.', where obstacles are denoted by '#'.
There is a single robot in the maze. Its start position is denoted with the character 'S'. This position has no obstacle in it. There is also a single exit in the maze. Its position is denoted with the character 'E'. This position has no obstacle in it.
The robot can only move up, left, right, or down.
When Bob programmed the robot, he wrote down a string of digits consisting of the digits 0 to 3, inclusive. He intended for each digit to correspond to a distinct direction, and the robot would follow the directions in order to reach the exit. Unfortunately, he forgot to actually assign the directions to digits.
The robot will choose some random mapping of digits to distinct directions. The robot will map distinct digits to distinct directions. The robot will then follow the instructions according to the given string in order and chosen mapping. If an instruction would lead the robot to go off the edge of the maze or hit an obstacle, the robot will crash and break down. If the robot reaches the exit at any point, then the robot will stop following any further instructions.
Bob is having trouble debugging his robot, so he would like to determine the number of mappings of digits to directions that would lead the robot to the exit.
Input
The first line of input will contain two integers n and m (2 β€ n, m β€ 50), denoting the dimensions of the maze.
The next n lines will contain exactly m characters each, denoting the maze.
Each character of the maze will be '.', '#', 'S', or 'E'.
There will be exactly one 'S' and exactly one 'E' in the maze.
The last line will contain a single string s (1 β€ |s| β€ 100) β the instructions given to the robot. Each character of s is a digit from 0 to 3.
Output
Print a single integer, the number of mappings of digits to directions that will lead the robot to the exit.
Examples
Input
5 6
.....#
S....#
.#....
.#....
...E..
333300012
Output
1
Input
6 6
......
......
..SE..
......
......
......
01232123212302123021
Output
14
Input
5 3
...
.S.
###
.E.
...
3
Output
0
Note
For the first sample, the only valid mapping is <image>, where D is down, L is left, U is up, R is right. | instruction | 0 | 70,438 | 15 | 140,876 |
Tags: brute force, implementation
Correct Solution:
```
import itertools as it
def f1(x, y): return (x + 1, y)
def f2(x, y): return (x - 1, y)
def f3(x, y): return (x, y + 1)
def f4(x, y): return (x, y - 1)
d = [f1, f2, f3, f4]
n, m = list(map(int, input().split()))
ls = []
ls.append('#' * (m + 2))
for i in range(n):
ls.append('#' + input() + '#')
if 'S' in ls[-1]:
start = (i + 1, ls[-1].index('S'))
ls.append(ls[0])
mov = input()
count = 0
for perm in it.permutations(d):
found = False
current = start
for c in mov:
# print(c)
new_pos = perm[int(c)](*current)
# print(current, new_pos)
if ls[new_pos[0]][new_pos[1]] == '#':
break
elif ls[new_pos[0]][new_pos[1]] == 'E':
found = True
break
else:
current = new_pos
if found: count += 1
print(count)
``` | output | 1 | 70,438 | 15 | 140,877 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob programmed a robot to navigate through a 2d maze.
The maze has some obstacles. Empty cells are denoted by the character '.', where obstacles are denoted by '#'.
There is a single robot in the maze. Its start position is denoted with the character 'S'. This position has no obstacle in it. There is also a single exit in the maze. Its position is denoted with the character 'E'. This position has no obstacle in it.
The robot can only move up, left, right, or down.
When Bob programmed the robot, he wrote down a string of digits consisting of the digits 0 to 3, inclusive. He intended for each digit to correspond to a distinct direction, and the robot would follow the directions in order to reach the exit. Unfortunately, he forgot to actually assign the directions to digits.
The robot will choose some random mapping of digits to distinct directions. The robot will map distinct digits to distinct directions. The robot will then follow the instructions according to the given string in order and chosen mapping. If an instruction would lead the robot to go off the edge of the maze or hit an obstacle, the robot will crash and break down. If the robot reaches the exit at any point, then the robot will stop following any further instructions.
Bob is having trouble debugging his robot, so he would like to determine the number of mappings of digits to directions that would lead the robot to the exit.
Input
The first line of input will contain two integers n and m (2 β€ n, m β€ 50), denoting the dimensions of the maze.
The next n lines will contain exactly m characters each, denoting the maze.
Each character of the maze will be '.', '#', 'S', or 'E'.
There will be exactly one 'S' and exactly one 'E' in the maze.
The last line will contain a single string s (1 β€ |s| β€ 100) β the instructions given to the robot. Each character of s is a digit from 0 to 3.
Output
Print a single integer, the number of mappings of digits to directions that will lead the robot to the exit.
Examples
Input
5 6
.....#
S....#
.#....
.#....
...E..
333300012
Output
1
Input
6 6
......
......
..SE..
......
......
......
01232123212302123021
Output
14
Input
5 3
...
.S.
###
.E.
...
3
Output
0
Note
For the first sample, the only valid mapping is <image>, where D is down, L is left, U is up, R is right. | instruction | 0 | 70,439 | 15 | 140,878 |
Tags: brute force, implementation
Correct Solution:
```
from itertools import permutations
dirs = 'UDLR'
perms = [''.join(p) for p in permutations(dirs)]
change = {'U': (-1, 0), 'D': (1, 0), 'L': (0, -1), 'R': (0, 1)}
n, m = list(map(int, input().split()))
grid = []
for _ in range(n):
grid.append(list(input().rstrip()))
ins = list(map(int, list(input().rstrip())))
for i in range(n):
for j in range(m):
if grid[i][j] == 'S':
start = (i, j)
elif grid[i][j] == 'E':
end = (i, j)
ans = 0
for p in perms:
curr = start
for i in ins:
d = change[p[i]]
nxt = (curr[0] + d[0], curr[1] + d[1])
if nxt[0] < 0 or nxt[0] >= n or nxt[1] < 0 or nxt[1] >= m or grid[nxt[0]][nxt[1]] == '#':
break
elif nxt == end:
ans += 1
break
else:
curr = nxt
print(ans)
``` | output | 1 | 70,439 | 15 | 140,879 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob programmed a robot to navigate through a 2d maze.
The maze has some obstacles. Empty cells are denoted by the character '.', where obstacles are denoted by '#'.
There is a single robot in the maze. Its start position is denoted with the character 'S'. This position has no obstacle in it. There is also a single exit in the maze. Its position is denoted with the character 'E'. This position has no obstacle in it.
The robot can only move up, left, right, or down.
When Bob programmed the robot, he wrote down a string of digits consisting of the digits 0 to 3, inclusive. He intended for each digit to correspond to a distinct direction, and the robot would follow the directions in order to reach the exit. Unfortunately, he forgot to actually assign the directions to digits.
The robot will choose some random mapping of digits to distinct directions. The robot will map distinct digits to distinct directions. The robot will then follow the instructions according to the given string in order and chosen mapping. If an instruction would lead the robot to go off the edge of the maze or hit an obstacle, the robot will crash and break down. If the robot reaches the exit at any point, then the robot will stop following any further instructions.
Bob is having trouble debugging his robot, so he would like to determine the number of mappings of digits to directions that would lead the robot to the exit.
Input
The first line of input will contain two integers n and m (2 β€ n, m β€ 50), denoting the dimensions of the maze.
The next n lines will contain exactly m characters each, denoting the maze.
Each character of the maze will be '.', '#', 'S', or 'E'.
There will be exactly one 'S' and exactly one 'E' in the maze.
The last line will contain a single string s (1 β€ |s| β€ 100) β the instructions given to the robot. Each character of s is a digit from 0 to 3.
Output
Print a single integer, the number of mappings of digits to directions that will lead the robot to the exit.
Examples
Input
5 6
.....#
S....#
.#....
.#....
...E..
333300012
Output
1
Input
6 6
......
......
..SE..
......
......
......
01232123212302123021
Output
14
Input
5 3
...
.S.
###
.E.
...
3
Output
0
Note
For the first sample, the only valid mapping is <image>, where D is down, L is left, U is up, R is right. | instruction | 0 | 70,440 | 15 | 140,880 |
Tags: brute force, implementation
Correct Solution:
```
r, s = map(int, input().split())
m = []
for i in range(r):
m.append(input())
for j in range(s):
if m[i][j] == 'S':
start = i, j
se = input()
u = [0, 1, 0, -1]
v = [1, 0, -1, 0]
sol = 0
for a in range(4):
for b in range(4):
for c in range(4):
for d in range(4):
if len(set([a, b, c, d])) < 4:
continue
x, y = start
cnt = 0
for znak in se:
if znak == '0':
x += u[a]
y += v[a]
if znak == '1':
x += u[b]
y += v[b]
if znak == '2':
x += u[c]
y += v[c]
if znak == '3':
x += u[d]
y += v[d]
cnt += 1
if x < 0 or y < 0 or x >= r or y >= s:
cnt = -1
break
if m[x][y] not in ['.', 'S']:
break
#print(a, b, c, d, m[x][y], cnt, x, y)
if cnt > 0 and m[x][y] == 'E':
sol += 1
print(sol)
``` | output | 1 | 70,440 | 15 | 140,881 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob programmed a robot to navigate through a 2d maze.
The maze has some obstacles. Empty cells are denoted by the character '.', where obstacles are denoted by '#'.
There is a single robot in the maze. Its start position is denoted with the character 'S'. This position has no obstacle in it. There is also a single exit in the maze. Its position is denoted with the character 'E'. This position has no obstacle in it.
The robot can only move up, left, right, or down.
When Bob programmed the robot, he wrote down a string of digits consisting of the digits 0 to 3, inclusive. He intended for each digit to correspond to a distinct direction, and the robot would follow the directions in order to reach the exit. Unfortunately, he forgot to actually assign the directions to digits.
The robot will choose some random mapping of digits to distinct directions. The robot will map distinct digits to distinct directions. The robot will then follow the instructions according to the given string in order and chosen mapping. If an instruction would lead the robot to go off the edge of the maze or hit an obstacle, the robot will crash and break down. If the robot reaches the exit at any point, then the robot will stop following any further instructions.
Bob is having trouble debugging his robot, so he would like to determine the number of mappings of digits to directions that would lead the robot to the exit.
Input
The first line of input will contain two integers n and m (2 β€ n, m β€ 50), denoting the dimensions of the maze.
The next n lines will contain exactly m characters each, denoting the maze.
Each character of the maze will be '.', '#', 'S', or 'E'.
There will be exactly one 'S' and exactly one 'E' in the maze.
The last line will contain a single string s (1 β€ |s| β€ 100) β the instructions given to the robot. Each character of s is a digit from 0 to 3.
Output
Print a single integer, the number of mappings of digits to directions that will lead the robot to the exit.
Examples
Input
5 6
.....#
S....#
.#....
.#....
...E..
333300012
Output
1
Input
6 6
......
......
..SE..
......
......
......
01232123212302123021
Output
14
Input
5 3
...
.S.
###
.E.
...
3
Output
0
Note
For the first sample, the only valid mapping is <image>, where D is down, L is left, U is up, R is right. | instruction | 0 | 70,441 | 15 | 140,882 |
Tags: brute force, implementation
Correct Solution:
```
from itertools import permutations
r = [int(x) for x in input().split(' ')]
h = r[0]
w = r[1]
m = []
n = 0
for i in range(h):
m.append(input())
for row in range(h):
if 'S' in m[row]:
starty = row
startx = m[row].index('S')
ins = input()
def followinstructions(mapping):
y = starty
x = startx
for i in ins:
x += mapping[int(i)][0]
y += mapping[int(i)][1]
if x >= 0 and x < w:
if y >= 0 and y < h:
if m[y][x] != "#":
if m[y][x] == 'E':
return True
else:
return False
else:
return False
else:
return False
return False
mappings = permutations([(0,1),(0,-1),(1,0),(-1,0)],4)
for mapping in mappings:
if followinstructions(mapping):
n+=1
print(n)
``` | output | 1 | 70,441 | 15 | 140,883 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob programmed a robot to navigate through a 2d maze.
The maze has some obstacles. Empty cells are denoted by the character '.', where obstacles are denoted by '#'.
There is a single robot in the maze. Its start position is denoted with the character 'S'. This position has no obstacle in it. There is also a single exit in the maze. Its position is denoted with the character 'E'. This position has no obstacle in it.
The robot can only move up, left, right, or down.
When Bob programmed the robot, he wrote down a string of digits consisting of the digits 0 to 3, inclusive. He intended for each digit to correspond to a distinct direction, and the robot would follow the directions in order to reach the exit. Unfortunately, he forgot to actually assign the directions to digits.
The robot will choose some random mapping of digits to distinct directions. The robot will map distinct digits to distinct directions. The robot will then follow the instructions according to the given string in order and chosen mapping. If an instruction would lead the robot to go off the edge of the maze or hit an obstacle, the robot will crash and break down. If the robot reaches the exit at any point, then the robot will stop following any further instructions.
Bob is having trouble debugging his robot, so he would like to determine the number of mappings of digits to directions that would lead the robot to the exit.
Input
The first line of input will contain two integers n and m (2 β€ n, m β€ 50), denoting the dimensions of the maze.
The next n lines will contain exactly m characters each, denoting the maze.
Each character of the maze will be '.', '#', 'S', or 'E'.
There will be exactly one 'S' and exactly one 'E' in the maze.
The last line will contain a single string s (1 β€ |s| β€ 100) β the instructions given to the robot. Each character of s is a digit from 0 to 3.
Output
Print a single integer, the number of mappings of digits to directions that will lead the robot to the exit.
Examples
Input
5 6
.....#
S....#
.#....
.#....
...E..
333300012
Output
1
Input
6 6
......
......
..SE..
......
......
......
01232123212302123021
Output
14
Input
5 3
...
.S.
###
.E.
...
3
Output
0
Note
For the first sample, the only valid mapping is <image>, where D is down, L is left, U is up, R is right.
Submitted Solution:
```
from itertools import permutations
m,n=map(int,input().split())
a=[]
for i in range(m):
b=input()
a.append(list(b))
s=input()
si=0
sj=0
for i in range(m):
for j in range(n):
if a[i][j]=="S":
si=i
sj=j
d=list( permutations([0,1,2,3]))
c=0
for u in d:
z=dict()
z[ u[0] ]= 'u'
z[ u[1] ]='d'
z[ u[2]] = 'l'
z[u[3]] = 'r'
i=si
j=sj
for k in s:
if z[ int(k)]=='u':
i-=1
elif z[ int(k)]=='d':
i+=1
elif z[ int(k)]=='l':
j-=1
elif z[ int(k)]=='r':
j+=1
if i<0 or j<0 or i>=m or j>= n:
break;
if a[i][j]=='#':
break
if a[i][j]=='E':
c+= 1
break
print(c)
``` | instruction | 0 | 70,442 | 15 | 140,884 |
Yes | output | 1 | 70,442 | 15 | 140,885 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob programmed a robot to navigate through a 2d maze.
The maze has some obstacles. Empty cells are denoted by the character '.', where obstacles are denoted by '#'.
There is a single robot in the maze. Its start position is denoted with the character 'S'. This position has no obstacle in it. There is also a single exit in the maze. Its position is denoted with the character 'E'. This position has no obstacle in it.
The robot can only move up, left, right, or down.
When Bob programmed the robot, he wrote down a string of digits consisting of the digits 0 to 3, inclusive. He intended for each digit to correspond to a distinct direction, and the robot would follow the directions in order to reach the exit. Unfortunately, he forgot to actually assign the directions to digits.
The robot will choose some random mapping of digits to distinct directions. The robot will map distinct digits to distinct directions. The robot will then follow the instructions according to the given string in order and chosen mapping. If an instruction would lead the robot to go off the edge of the maze or hit an obstacle, the robot will crash and break down. If the robot reaches the exit at any point, then the robot will stop following any further instructions.
Bob is having trouble debugging his robot, so he would like to determine the number of mappings of digits to directions that would lead the robot to the exit.
Input
The first line of input will contain two integers n and m (2 β€ n, m β€ 50), denoting the dimensions of the maze.
The next n lines will contain exactly m characters each, denoting the maze.
Each character of the maze will be '.', '#', 'S', or 'E'.
There will be exactly one 'S' and exactly one 'E' in the maze.
The last line will contain a single string s (1 β€ |s| β€ 100) β the instructions given to the robot. Each character of s is a digit from 0 to 3.
Output
Print a single integer, the number of mappings of digits to directions that will lead the robot to the exit.
Examples
Input
5 6
.....#
S....#
.#....
.#....
...E..
333300012
Output
1
Input
6 6
......
......
..SE..
......
......
......
01232123212302123021
Output
14
Input
5 3
...
.S.
###
.E.
...
3
Output
0
Note
For the first sample, the only valid mapping is <image>, where D is down, L is left, U is up, R is right.
Submitted Solution:
```
from itertools import permutations
dirs = [(-1, 0), (1, 0), (0, 1), (0, -1)]
n, m = map(int, input().split())
s = [input() for _ in range(n)]
spos = (0, 0)
for i in range(n):
for j in range(m):
if s[i][j] == 'S':
spos = (j, i)
t = input()
ans = 0
for p in permutations(dirs):
x, y = spos
for c in t:
dr = p[int(c)]
x += dr[0]
y += dr[1]
if not 0 <= x < m or not 0 <= y < n:
break
if s[y][x] == '#':
break
if s[y][x] == 'E':
ans += 1
break
print(ans)
``` | instruction | 0 | 70,443 | 15 | 140,886 |
Yes | output | 1 | 70,443 | 15 | 140,887 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob programmed a robot to navigate through a 2d maze.
The maze has some obstacles. Empty cells are denoted by the character '.', where obstacles are denoted by '#'.
There is a single robot in the maze. Its start position is denoted with the character 'S'. This position has no obstacle in it. There is also a single exit in the maze. Its position is denoted with the character 'E'. This position has no obstacle in it.
The robot can only move up, left, right, or down.
When Bob programmed the robot, he wrote down a string of digits consisting of the digits 0 to 3, inclusive. He intended for each digit to correspond to a distinct direction, and the robot would follow the directions in order to reach the exit. Unfortunately, he forgot to actually assign the directions to digits.
The robot will choose some random mapping of digits to distinct directions. The robot will map distinct digits to distinct directions. The robot will then follow the instructions according to the given string in order and chosen mapping. If an instruction would lead the robot to go off the edge of the maze or hit an obstacle, the robot will crash and break down. If the robot reaches the exit at any point, then the robot will stop following any further instructions.
Bob is having trouble debugging his robot, so he would like to determine the number of mappings of digits to directions that would lead the robot to the exit.
Input
The first line of input will contain two integers n and m (2 β€ n, m β€ 50), denoting the dimensions of the maze.
The next n lines will contain exactly m characters each, denoting the maze.
Each character of the maze will be '.', '#', 'S', or 'E'.
There will be exactly one 'S' and exactly one 'E' in the maze.
The last line will contain a single string s (1 β€ |s| β€ 100) β the instructions given to the robot. Each character of s is a digit from 0 to 3.
Output
Print a single integer, the number of mappings of digits to directions that will lead the robot to the exit.
Examples
Input
5 6
.....#
S....#
.#....
.#....
...E..
333300012
Output
1
Input
6 6
......
......
..SE..
......
......
......
01232123212302123021
Output
14
Input
5 3
...
.S.
###
.E.
...
3
Output
0
Note
For the first sample, the only valid mapping is <image>, where D is down, L is left, U is up, R is right.
Submitted Solution:
```
from itertools import permutations as p
n, m = input().split()
n, m = int(n), int(m)
maze = []
for i in range(n):
l = input()
if 'S' in l:
coorS = [i, l.index('S')]
if 'E' in l:
coorE = [i, l.index('E')]
maze.append(l)
val = input()
sol = 0
save = list(coorS)
for f in p('0123', 4):
l, r, u, d = f[0], f[1], f[2], f[3]
for k in val:
if l == k:
if coorS[1] == 0:
break
else:
if maze[coorS[0]][coorS[1] - 1] == '#':
break
else:
coorS = list([coorS[0], coorS[1] - 1])
elif r == k:
if coorS[1] == m-1:
break
else:
if maze[coorS[0]][coorS[1] + 1] == '#':
break
else:
coorS = list([coorS[0], coorS[1] + 1])
elif u == k:
if coorS[0] == 0:
break
else:
if maze[coorS[0] - 1][coorS[1]] == '#':
break
else:
coorS = list([coorS[0] - 1, coorS[1]])
elif d == k:
if coorS[0] == n - 1:
break
else:
if maze[coorS[0] + 1][coorS[1]] == '#':
break
else:
coorS = list([coorS[0] + 1, coorS[1]])
if coorS == coorE:
sol+=1
break
coorS = list(save)
print(sol)
``` | instruction | 0 | 70,444 | 15 | 140,888 |
Yes | output | 1 | 70,444 | 15 | 140,889 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob programmed a robot to navigate through a 2d maze.
The maze has some obstacles. Empty cells are denoted by the character '.', where obstacles are denoted by '#'.
There is a single robot in the maze. Its start position is denoted with the character 'S'. This position has no obstacle in it. There is also a single exit in the maze. Its position is denoted with the character 'E'. This position has no obstacle in it.
The robot can only move up, left, right, or down.
When Bob programmed the robot, he wrote down a string of digits consisting of the digits 0 to 3, inclusive. He intended for each digit to correspond to a distinct direction, and the robot would follow the directions in order to reach the exit. Unfortunately, he forgot to actually assign the directions to digits.
The robot will choose some random mapping of digits to distinct directions. The robot will map distinct digits to distinct directions. The robot will then follow the instructions according to the given string in order and chosen mapping. If an instruction would lead the robot to go off the edge of the maze or hit an obstacle, the robot will crash and break down. If the robot reaches the exit at any point, then the robot will stop following any further instructions.
Bob is having trouble debugging his robot, so he would like to determine the number of mappings of digits to directions that would lead the robot to the exit.
Input
The first line of input will contain two integers n and m (2 β€ n, m β€ 50), denoting the dimensions of the maze.
The next n lines will contain exactly m characters each, denoting the maze.
Each character of the maze will be '.', '#', 'S', or 'E'.
There will be exactly one 'S' and exactly one 'E' in the maze.
The last line will contain a single string s (1 β€ |s| β€ 100) β the instructions given to the robot. Each character of s is a digit from 0 to 3.
Output
Print a single integer, the number of mappings of digits to directions that will lead the robot to the exit.
Examples
Input
5 6
.....#
S....#
.#....
.#....
...E..
333300012
Output
1
Input
6 6
......
......
..SE..
......
......
......
01232123212302123021
Output
14
Input
5 3
...
.S.
###
.E.
...
3
Output
0
Note
For the first sample, the only valid mapping is <image>, where D is down, L is left, U is up, R is right.
Submitted Solution:
```
n, m = map(int, input().split())
a = [0] * n
for i in range(n):
a[i] = input()
for j in range(m):
if a[i][j] == 'S':
x1, y1 = i, j
s = input()
dirr = ['0123', '0132', '0213', '0231', '0312', '0321', '1023', '1032', '1203', '1230', '1302', '1320', '2103', '2130', '2013', '2031', '2310', '2301', '3120', '3102', '3210', '3201', '3012', '3021']
ans = 0
for d in dirr:
x, y = x1, y1
for i in s:
i = int(i)
if d[i] == '0' and (x - 1 < 0 or a[x - 1][y] == '#'):
break
elif d[i] == '1' and (y - 1 < 0 or a[x][y - 1] == '#'):
break
elif d[i] == '2' and (x + 1 >= n or a[x + 1][y] == '#'):
break
elif d[i] == '3' and (y + 1 >= m or a[x][y + 1] == '#'):
break
elif d[i] == '0':
x -= 1
elif d[i] == '1':
y -= 1
elif d[i] == '2':
x += 1
elif d[i] == '3':
y += 1
if a[x][y] == 'E':
break
if a[x][y] == 'E':
ans += 1
print(ans)
``` | instruction | 0 | 70,445 | 15 | 140,890 |
Yes | output | 1 | 70,445 | 15 | 140,891 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob programmed a robot to navigate through a 2d maze.
The maze has some obstacles. Empty cells are denoted by the character '.', where obstacles are denoted by '#'.
There is a single robot in the maze. Its start position is denoted with the character 'S'. This position has no obstacle in it. There is also a single exit in the maze. Its position is denoted with the character 'E'. This position has no obstacle in it.
The robot can only move up, left, right, or down.
When Bob programmed the robot, he wrote down a string of digits consisting of the digits 0 to 3, inclusive. He intended for each digit to correspond to a distinct direction, and the robot would follow the directions in order to reach the exit. Unfortunately, he forgot to actually assign the directions to digits.
The robot will choose some random mapping of digits to distinct directions. The robot will map distinct digits to distinct directions. The robot will then follow the instructions according to the given string in order and chosen mapping. If an instruction would lead the robot to go off the edge of the maze or hit an obstacle, the robot will crash and break down. If the robot reaches the exit at any point, then the robot will stop following any further instructions.
Bob is having trouble debugging his robot, so he would like to determine the number of mappings of digits to directions that would lead the robot to the exit.
Input
The first line of input will contain two integers n and m (2 β€ n, m β€ 50), denoting the dimensions of the maze.
The next n lines will contain exactly m characters each, denoting the maze.
Each character of the maze will be '.', '#', 'S', or 'E'.
There will be exactly one 'S' and exactly one 'E' in the maze.
The last line will contain a single string s (1 β€ |s| β€ 100) β the instructions given to the robot. Each character of s is a digit from 0 to 3.
Output
Print a single integer, the number of mappings of digits to directions that will lead the robot to the exit.
Examples
Input
5 6
.....#
S....#
.#....
.#....
...E..
333300012
Output
1
Input
6 6
......
......
..SE..
......
......
......
01232123212302123021
Output
14
Input
5 3
...
.S.
###
.E.
...
3
Output
0
Note
For the first sample, the only valid mapping is <image>, where D is down, L is left, U is up, R is right.
Submitted Solution:
```
from itertools import permutations
n, m = map(int, input().split())
maze = [list(input()) for _ in range(n)]
s = list(map(int, list(input())))
dxy = [(1, 0), (0, 1), (-1, 0), (0, -1)]
sx = sy = ex = ey = 0
for y in range(n):
for x in range(m):
if maze[y][x] == 'S':
sx = x
sy = y
elif maze[y][x] == 'E':
ex = x
ey = y
ans = 0
for p in permutations(range(4)):
x = sx
y = sy
for i in s:
if x == ex and y == ey:
ans += 1
break
x += dxy[p[i]][0]
y += dxy[p[i]][1]
if x == -1 or x == m or y == -1 or y == n or maze[y][x] == '#':
break
print(ans)
``` | instruction | 0 | 70,446 | 15 | 140,892 |
No | output | 1 | 70,446 | 15 | 140,893 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob programmed a robot to navigate through a 2d maze.
The maze has some obstacles. Empty cells are denoted by the character '.', where obstacles are denoted by '#'.
There is a single robot in the maze. Its start position is denoted with the character 'S'. This position has no obstacle in it. There is also a single exit in the maze. Its position is denoted with the character 'E'. This position has no obstacle in it.
The robot can only move up, left, right, or down.
When Bob programmed the robot, he wrote down a string of digits consisting of the digits 0 to 3, inclusive. He intended for each digit to correspond to a distinct direction, and the robot would follow the directions in order to reach the exit. Unfortunately, he forgot to actually assign the directions to digits.
The robot will choose some random mapping of digits to distinct directions. The robot will map distinct digits to distinct directions. The robot will then follow the instructions according to the given string in order and chosen mapping. If an instruction would lead the robot to go off the edge of the maze or hit an obstacle, the robot will crash and break down. If the robot reaches the exit at any point, then the robot will stop following any further instructions.
Bob is having trouble debugging his robot, so he would like to determine the number of mappings of digits to directions that would lead the robot to the exit.
Input
The first line of input will contain two integers n and m (2 β€ n, m β€ 50), denoting the dimensions of the maze.
The next n lines will contain exactly m characters each, denoting the maze.
Each character of the maze will be '.', '#', 'S', or 'E'.
There will be exactly one 'S' and exactly one 'E' in the maze.
The last line will contain a single string s (1 β€ |s| β€ 100) β the instructions given to the robot. Each character of s is a digit from 0 to 3.
Output
Print a single integer, the number of mappings of digits to directions that will lead the robot to the exit.
Examples
Input
5 6
.....#
S....#
.#....
.#....
...E..
333300012
Output
1
Input
6 6
......
......
..SE..
......
......
......
01232123212302123021
Output
14
Input
5 3
...
.S.
###
.E.
...
3
Output
0
Note
For the first sample, the only valid mapping is <image>, where D is down, L is left, U is up, R is right.
Submitted Solution:
```
class Point:
def __init__(self,i,j):
self.i = i
self.j = j
def move(self,p):
return Point(self.i + p.i,self.j + p.j)
def pos(self,p):
return self.i == p.i and self.j == p.j
def out(self):
return self.i < 0 or self.i >= n or self.j < 0 or self.j >= m
n,m = map(int, input().split())
obs = []
for i in range(n):
stmp = str(input())
if 'S' in stmp:
start = Point(i,stmp.find('S'))
if 'E' in stmp:
end = Point(i,stmp.find('E'))
obs.append(Point(i,j) for j in range(m) if stmp[j] == '#')
drt = str(input())
cnt = 0
up = Point(1,0)
down = Point(-1,0)
right = Point(0,1)
left = Point(0,-1)
mapi = [0,1,2,3]
for u in mapi:
for d in [x for x in mapi if x != u]:
for r in [x for x in mapi if x != u and x != d]:
for l in [x for x in mapi if x != u and x != d and x != r]:
cur = start
for s in drt:
if int(s) == u:
cur = cur.move(up)
elif int(s) == d:
cur = cur.move(down)
elif int(s) == r:
cur = cur.move(right)
else:
cur = cur.move(left)
if cur.pos(end):
cnt += 1
break
if cur in obs or cur.out():
break
print(cnt)
``` | instruction | 0 | 70,447 | 15 | 140,894 |
No | output | 1 | 70,447 | 15 | 140,895 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob programmed a robot to navigate through a 2d maze.
The maze has some obstacles. Empty cells are denoted by the character '.', where obstacles are denoted by '#'.
There is a single robot in the maze. Its start position is denoted with the character 'S'. This position has no obstacle in it. There is also a single exit in the maze. Its position is denoted with the character 'E'. This position has no obstacle in it.
The robot can only move up, left, right, or down.
When Bob programmed the robot, he wrote down a string of digits consisting of the digits 0 to 3, inclusive. He intended for each digit to correspond to a distinct direction, and the robot would follow the directions in order to reach the exit. Unfortunately, he forgot to actually assign the directions to digits.
The robot will choose some random mapping of digits to distinct directions. The robot will map distinct digits to distinct directions. The robot will then follow the instructions according to the given string in order and chosen mapping. If an instruction would lead the robot to go off the edge of the maze or hit an obstacle, the robot will crash and break down. If the robot reaches the exit at any point, then the robot will stop following any further instructions.
Bob is having trouble debugging his robot, so he would like to determine the number of mappings of digits to directions that would lead the robot to the exit.
Input
The first line of input will contain two integers n and m (2 β€ n, m β€ 50), denoting the dimensions of the maze.
The next n lines will contain exactly m characters each, denoting the maze.
Each character of the maze will be '.', '#', 'S', or 'E'.
There will be exactly one 'S' and exactly one 'E' in the maze.
The last line will contain a single string s (1 β€ |s| β€ 100) β the instructions given to the robot. Each character of s is a digit from 0 to 3.
Output
Print a single integer, the number of mappings of digits to directions that will lead the robot to the exit.
Examples
Input
5 6
.....#
S....#
.#....
.#....
...E..
333300012
Output
1
Input
6 6
......
......
..SE..
......
......
......
01232123212302123021
Output
14
Input
5 3
...
.S.
###
.E.
...
3
Output
0
Note
For the first sample, the only valid mapping is <image>, where D is down, L is left, U is up, R is right.
Submitted Solution:
```
n, m = input().split()
n = int(n)
m = int(m)
sx = sy = 0
table = []
for _ in range(n):
s = input()
row = []
for j in range(len(s)):
i = s[j]
if i == '.':
row += [0]
if i == '#':
row += [1]
if i == 'E':
row += [2]
if i == 'S':
row += [0]
sy = j
sx = _
table += [row]
inst = input()
number = 0
def map(arr):
global number, sx, sy, table, inst
cx = sx
cy = sy
# print()
for i in inst:
i = int(i)
try:
# print(cx, cy)
nx = cx + arr[i][0]
ny = cy + arr[i][1]
if nx < 0 or ny < 0 or nx >= n or ny >= m :
return
if table[nx][ny] == 2:
number += 1
# print(arr)
return
if table[nx][ny] == 0:
cx = nx
cy = ny
except:
return
up = [1, 0]
down = [-1, 0]
left = [0, 1]
right = [0, -1]
a = [up, down, left, right]
map(a)
a = [up, down, right, left]
map(a)
a = [up, left, down, right]
map(a)
a = [up, left, right, down]
map(a)
a = [up, right, down, left]
map(a)
a = [up, right, left, down]
map(a)
up, right = right, up
a = [up, down, left, right]
map(a)
a = [up, down, right, left]
map(a)
a = [up, left, down, right]
map(a)
a = [up, left, right, down]
map(a)
a = [up, right, down, left]
map(a)
a = [up, right, left, down]
map(a)
up, left = left, up
a = [up, down, left, right]
map(a)
a = [up, down, right, left]
map(a)
a = [up, left, down, right]
map(a)
a = [up, left, right, down]
map(a)
a = [up, right, down, left]
map(a)
a = [up, right, left, down]
map(a)
up, down = down, up
a = [up, down, left, right]
map(a)
a = [up, down, right, left]
map(a)
a = [up, left, down, right]
map(a)
a = [up, left, right, down]
map(a)
a = [up, right, down, left]
map(a)
a = [up, right, left, down]
map(a)
print(number)
``` | instruction | 0 | 70,448 | 15 | 140,896 |
No | output | 1 | 70,448 | 15 | 140,897 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob programmed a robot to navigate through a 2d maze.
The maze has some obstacles. Empty cells are denoted by the character '.', where obstacles are denoted by '#'.
There is a single robot in the maze. Its start position is denoted with the character 'S'. This position has no obstacle in it. There is also a single exit in the maze. Its position is denoted with the character 'E'. This position has no obstacle in it.
The robot can only move up, left, right, or down.
When Bob programmed the robot, he wrote down a string of digits consisting of the digits 0 to 3, inclusive. He intended for each digit to correspond to a distinct direction, and the robot would follow the directions in order to reach the exit. Unfortunately, he forgot to actually assign the directions to digits.
The robot will choose some random mapping of digits to distinct directions. The robot will map distinct digits to distinct directions. The robot will then follow the instructions according to the given string in order and chosen mapping. If an instruction would lead the robot to go off the edge of the maze or hit an obstacle, the robot will crash and break down. If the robot reaches the exit at any point, then the robot will stop following any further instructions.
Bob is having trouble debugging his robot, so he would like to determine the number of mappings of digits to directions that would lead the robot to the exit.
Input
The first line of input will contain two integers n and m (2 β€ n, m β€ 50), denoting the dimensions of the maze.
The next n lines will contain exactly m characters each, denoting the maze.
Each character of the maze will be '.', '#', 'S', or 'E'.
There will be exactly one 'S' and exactly one 'E' in the maze.
The last line will contain a single string s (1 β€ |s| β€ 100) β the instructions given to the robot. Each character of s is a digit from 0 to 3.
Output
Print a single integer, the number of mappings of digits to directions that will lead the robot to the exit.
Examples
Input
5 6
.....#
S....#
.#....
.#....
...E..
333300012
Output
1
Input
6 6
......
......
..SE..
......
......
......
01232123212302123021
Output
14
Input
5 3
...
.S.
###
.E.
...
3
Output
0
Note
For the first sample, the only valid mapping is <image>, where D is down, L is left, U is up, R is right.
Submitted Solution:
```
from sys import stdout, stdin
def generateCases(caseList, case, index):
if(index>3):
caseList.append(tuple(case))
return
for c in 'UDLR':
if c not in case:
case.append(c)
generateCases(caseList, case, index+1)
case.pop()
def dfs(moveStr, maze, endPoint, moveMap, row, col, index):
if index > 0:
if row < 0 or row >= len(maze) or col < 0 or col >= len(maze[0]) or maze[row][col] == '#':
#print((row,col))
return 0
if (row, col) == endPoint:
return 1
if index >= len(moveStr):
return 0
num = int(moveStr[index])
char = moveMap[num]
if char is 'U':
return dfs(moveStr, maze, endPoint, moveMap, row-1, col, index+1)
elif char is 'D':
return dfs(moveStr, maze, endPoint, moveMap, row+1, col, index+1)
elif char is 'L':
return dfs(moveStr, maze, endPoint, moveMap, row, col-1, index+1)
elif char is 'R':
return dfs(moveStr, maze, endPoint, moveMap, row, col+1, index+1)
def main():
n, m=[int(x) for x in stdin.readline().split()]
maze = []
for i in range(n):
maze.append(stdin.readline())
moveStr = input()
startPoint=(); endPoint=()
for i in range(n):
for j in range(m):
if maze[i][j] == 'S':
startPoint = (i, j)
if maze[i][j] == 'E':
endPoint = (i, j)
caseList=[]
generateCases(caseList, [], 0)
cnt=0
for moveMap in caseList:
cnt += dfs(moveStr, maze, endPoint, moveMap, startPoint[0], startPoint[1], 0)
print(cnt)
if __name__ == '__main__':
main()
``` | instruction | 0 | 70,449 | 15 | 140,898 |
No | output | 1 | 70,449 | 15 | 140,899 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n robots have escaped from your laboratory! You have to find them as soon as possible, because these robots are experimental, and their behavior is not tested yet, so they may be really dangerous!
Fortunately, even though your robots have escaped, you still have some control over them. First of all, you know the location of each robot: the world you live in can be modeled as an infinite coordinate plane, and the i-th robot is currently located at the point having coordinates (x_i, y_i). Furthermore, you may send exactly one command to all of the robots. The command should contain two integer numbers X and Y, and when each robot receives this command, it starts moving towards the point having coordinates (X, Y). The robot stops its movement in two cases:
* either it reaches (X, Y);
* or it cannot get any closer to (X, Y).
Normally, all robots should be able to get from any point of the coordinate plane to any other point. Each robot usually can perform four actions to move. Let's denote the current coordinates of the robot as (x_c, y_c). Then the movement system allows it to move to any of the four adjacent points:
1. the first action allows it to move from (x_c, y_c) to (x_c - 1, y_c);
2. the second action allows it to move from (x_c, y_c) to (x_c, y_c + 1);
3. the third action allows it to move from (x_c, y_c) to (x_c + 1, y_c);
4. the fourth action allows it to move from (x_c, y_c) to (x_c, y_c - 1).
Unfortunately, it seems that some movement systems of some robots are malfunctioning. For each robot you know which actions it can perform, and which it cannot perform.
You want to send a command so all robots gather at the same point. To do so, you have to choose a pair of integer numbers X and Y so that each robot can reach the point (X, Y). Is it possible to find such a point?
Input
The first line contains one integer q (1 β€ q β€ 10^5) β the number of queries.
Then q queries follow. Each query begins with one line containing one integer n (1 β€ n β€ 10^5) β the number of robots in the query. Then n lines follow, the i-th of these lines describes the i-th robot in the current query: it contains six integer numbers x_i, y_i, f_{i, 1}, f_{i, 2}, f_{i, 3} and f_{i, 4} (-10^5 β€ x_i, y_i β€ 10^5, 0 β€ f_{i, j} β€ 1). The first two numbers describe the initial location of the i-th robot, and the following four numbers describe which actions the i-th robot can use to move (f_{i, j} = 1 if the i-th robot can use the j-th action, and f_{i, j} = 0 if it cannot use the j-th action).
It is guaranteed that the total number of robots over all queries does not exceed 10^5.
Output
You should answer each query independently, in the order these queries appear in the input.
To answer a query, you should do one of the following:
* if it is impossible to find a point that is reachable by all n robots, print one number 0 on a separate line;
* if it is possible to find a point that is reachable by all n robots, print three space-separated integers on the same line: 1 X Y, where X and Y are the coordinates of the point reachable by all n robots. Both X and Y should not exceed 10^5 by absolute value; it is guaranteed that if there exists at least one point reachable by all robots, then at least one of such points has both coordinates not exceeding 10^5 by absolute value.
Example
Input
4
2
-1 -2 0 0 0 0
-1 -2 0 0 0 0
3
1 5 1 1 1 1
2 5 0 1 0 1
3 5 1 0 0 0
2
1337 1337 0 1 1 1
1336 1337 1 1 0 1
1
3 5 1 1 1 1
Output
1 -1 -2
1 2 5
0
1 -100000 -100000 | instruction | 0 | 70,817 | 15 | 141,634 |
Tags: implementation
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
robots = []
ans_limit = [-100000, 100000, 100000, -100000]
for i in range(n):
robots.append([int(j) for j in input().split()])
for i in robots:
if i[2] == 0 and i[0] > ans_limit[0]:
ans_limit[0] = i[0]
if i[3] == 0 and i[1] < ans_limit[1]:
ans_limit[1] = i[1]
if i[4] == 0 and i[0] < ans_limit[2]:
ans_limit[2] = i[0]
if i[5] == 0 and i[1] > ans_limit[3]:
ans_limit[3] = i[1]
# print(ans_limit)
if ans_limit[0] > ans_limit[2]:
print(0)
elif ans_limit[1] < ans_limit[3]:
print(0)
else:
print(1, ans_limit[0], ans_limit[3])
``` | output | 1 | 70,817 | 15 | 141,635 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n robots have escaped from your laboratory! You have to find them as soon as possible, because these robots are experimental, and their behavior is not tested yet, so they may be really dangerous!
Fortunately, even though your robots have escaped, you still have some control over them. First of all, you know the location of each robot: the world you live in can be modeled as an infinite coordinate plane, and the i-th robot is currently located at the point having coordinates (x_i, y_i). Furthermore, you may send exactly one command to all of the robots. The command should contain two integer numbers X and Y, and when each robot receives this command, it starts moving towards the point having coordinates (X, Y). The robot stops its movement in two cases:
* either it reaches (X, Y);
* or it cannot get any closer to (X, Y).
Normally, all robots should be able to get from any point of the coordinate plane to any other point. Each robot usually can perform four actions to move. Let's denote the current coordinates of the robot as (x_c, y_c). Then the movement system allows it to move to any of the four adjacent points:
1. the first action allows it to move from (x_c, y_c) to (x_c - 1, y_c);
2. the second action allows it to move from (x_c, y_c) to (x_c, y_c + 1);
3. the third action allows it to move from (x_c, y_c) to (x_c + 1, y_c);
4. the fourth action allows it to move from (x_c, y_c) to (x_c, y_c - 1).
Unfortunately, it seems that some movement systems of some robots are malfunctioning. For each robot you know which actions it can perform, and which it cannot perform.
You want to send a command so all robots gather at the same point. To do so, you have to choose a pair of integer numbers X and Y so that each robot can reach the point (X, Y). Is it possible to find such a point?
Input
The first line contains one integer q (1 β€ q β€ 10^5) β the number of queries.
Then q queries follow. Each query begins with one line containing one integer n (1 β€ n β€ 10^5) β the number of robots in the query. Then n lines follow, the i-th of these lines describes the i-th robot in the current query: it contains six integer numbers x_i, y_i, f_{i, 1}, f_{i, 2}, f_{i, 3} and f_{i, 4} (-10^5 β€ x_i, y_i β€ 10^5, 0 β€ f_{i, j} β€ 1). The first two numbers describe the initial location of the i-th robot, and the following four numbers describe which actions the i-th robot can use to move (f_{i, j} = 1 if the i-th robot can use the j-th action, and f_{i, j} = 0 if it cannot use the j-th action).
It is guaranteed that the total number of robots over all queries does not exceed 10^5.
Output
You should answer each query independently, in the order these queries appear in the input.
To answer a query, you should do one of the following:
* if it is impossible to find a point that is reachable by all n robots, print one number 0 on a separate line;
* if it is possible to find a point that is reachable by all n robots, print three space-separated integers on the same line: 1 X Y, where X and Y are the coordinates of the point reachable by all n robots. Both X and Y should not exceed 10^5 by absolute value; it is guaranteed that if there exists at least one point reachable by all robots, then at least one of such points has both coordinates not exceeding 10^5 by absolute value.
Example
Input
4
2
-1 -2 0 0 0 0
-1 -2 0 0 0 0
3
1 5 1 1 1 1
2 5 0 1 0 1
3 5 1 0 0 0
2
1337 1337 0 1 1 1
1336 1337 1 1 0 1
1
3 5 1 1 1 1
Output
1 -1 -2
1 2 5
0
1 -100000 -100000 | instruction | 0 | 70,818 | 15 | 141,636 |
Tags: implementation
Correct Solution:
```
'''Author- Akshit Monga'''
from sys import stdin, stdout
input = stdin.readline
t = int(input())
for _ in range(t):
n=int(input())
data=[]
for i in range(n):
data.append([int(x) for x in input().split()])
y_low=-10**5
y_high=10**5
x_low=-10**5
x_high=10**5
vals=sorted(data,key=lambda x:x[1],reverse=True)
ans=1
for i in vals:
if y_low<=i[1]<=y_high:
if i[3]==0 and i[5]==0:
y_low=y_high=i[1]
elif i[3]==0:
y_high=i[1]
elif i[5]==0:
y_low=i[1]
else:
if i[3] == 0 and i[5] == 0:
ans=0
break
elif i[3] == 0:
if i[1]<y_low:
ans=0
break
elif i[5] == 0:
if i[1] > y_high:
ans = 0
break
if not ans:
print(ans)
continue
vals = sorted(data, key=lambda x: x[0], reverse=True)
ans = 1
for i in vals:
if x_low<=i[0]<=x_high:
if i[2]==0 and i[4]==0:
x_low=x_high=i[0]
elif i[2] == 0:
x_low=i[0]
elif i[4]==0:
x_high=i[0]
else:
if i[2] == 0 and i[4] == 0:
ans = 0
break
elif i[2] == 0:
if i[0] > x_high:
ans = 0
break
elif i[4] == 0:
if i[0] < x_low:
ans = 0
break
if not ans:
print(ans)
continue
print(1,x_low,y_low)
``` | output | 1 | 70,818 | 15 | 141,637 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n robots have escaped from your laboratory! You have to find them as soon as possible, because these robots are experimental, and their behavior is not tested yet, so they may be really dangerous!
Fortunately, even though your robots have escaped, you still have some control over them. First of all, you know the location of each robot: the world you live in can be modeled as an infinite coordinate plane, and the i-th robot is currently located at the point having coordinates (x_i, y_i). Furthermore, you may send exactly one command to all of the robots. The command should contain two integer numbers X and Y, and when each robot receives this command, it starts moving towards the point having coordinates (X, Y). The robot stops its movement in two cases:
* either it reaches (X, Y);
* or it cannot get any closer to (X, Y).
Normally, all robots should be able to get from any point of the coordinate plane to any other point. Each robot usually can perform four actions to move. Let's denote the current coordinates of the robot as (x_c, y_c). Then the movement system allows it to move to any of the four adjacent points:
1. the first action allows it to move from (x_c, y_c) to (x_c - 1, y_c);
2. the second action allows it to move from (x_c, y_c) to (x_c, y_c + 1);
3. the third action allows it to move from (x_c, y_c) to (x_c + 1, y_c);
4. the fourth action allows it to move from (x_c, y_c) to (x_c, y_c - 1).
Unfortunately, it seems that some movement systems of some robots are malfunctioning. For each robot you know which actions it can perform, and which it cannot perform.
You want to send a command so all robots gather at the same point. To do so, you have to choose a pair of integer numbers X and Y so that each robot can reach the point (X, Y). Is it possible to find such a point?
Input
The first line contains one integer q (1 β€ q β€ 10^5) β the number of queries.
Then q queries follow. Each query begins with one line containing one integer n (1 β€ n β€ 10^5) β the number of robots in the query. Then n lines follow, the i-th of these lines describes the i-th robot in the current query: it contains six integer numbers x_i, y_i, f_{i, 1}, f_{i, 2}, f_{i, 3} and f_{i, 4} (-10^5 β€ x_i, y_i β€ 10^5, 0 β€ f_{i, j} β€ 1). The first two numbers describe the initial location of the i-th robot, and the following four numbers describe which actions the i-th robot can use to move (f_{i, j} = 1 if the i-th robot can use the j-th action, and f_{i, j} = 0 if it cannot use the j-th action).
It is guaranteed that the total number of robots over all queries does not exceed 10^5.
Output
You should answer each query independently, in the order these queries appear in the input.
To answer a query, you should do one of the following:
* if it is impossible to find a point that is reachable by all n robots, print one number 0 on a separate line;
* if it is possible to find a point that is reachable by all n robots, print three space-separated integers on the same line: 1 X Y, where X and Y are the coordinates of the point reachable by all n robots. Both X and Y should not exceed 10^5 by absolute value; it is guaranteed that if there exists at least one point reachable by all robots, then at least one of such points has both coordinates not exceeding 10^5 by absolute value.
Example
Input
4
2
-1 -2 0 0 0 0
-1 -2 0 0 0 0
3
1 5 1 1 1 1
2 5 0 1 0 1
3 5 1 0 0 0
2
1337 1337 0 1 1 1
1336 1337 1 1 0 1
1
3 5 1 1 1 1
Output
1 -1 -2
1 2 5
0
1 -100000 -100000 | instruction | 0 | 70,819 | 15 | 141,638 |
Tags: implementation
Correct Solution:
```
q = int(input())
for _ in range(q):
n = int(input())
x0 = -100000
x1 = 100000
y0 = -100000
y1 = 100000
for _ in range(n):
x, y, left, up, right, down = map(int, input().split())
if not left:
x0 = max(x0, x)
if not right:
x1 = min(x1, x)
if not up:
y1 = min(y1, y)
if not down:
y0 = max(y0, y)
if (x0 <= x1 and y0 <= y1):
print(1, x0, y0)
else:
print(0);
``` | output | 1 | 70,819 | 15 | 141,639 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n robots have escaped from your laboratory! You have to find them as soon as possible, because these robots are experimental, and their behavior is not tested yet, so they may be really dangerous!
Fortunately, even though your robots have escaped, you still have some control over them. First of all, you know the location of each robot: the world you live in can be modeled as an infinite coordinate plane, and the i-th robot is currently located at the point having coordinates (x_i, y_i). Furthermore, you may send exactly one command to all of the robots. The command should contain two integer numbers X and Y, and when each robot receives this command, it starts moving towards the point having coordinates (X, Y). The robot stops its movement in two cases:
* either it reaches (X, Y);
* or it cannot get any closer to (X, Y).
Normally, all robots should be able to get from any point of the coordinate plane to any other point. Each robot usually can perform four actions to move. Let's denote the current coordinates of the robot as (x_c, y_c). Then the movement system allows it to move to any of the four adjacent points:
1. the first action allows it to move from (x_c, y_c) to (x_c - 1, y_c);
2. the second action allows it to move from (x_c, y_c) to (x_c, y_c + 1);
3. the third action allows it to move from (x_c, y_c) to (x_c + 1, y_c);
4. the fourth action allows it to move from (x_c, y_c) to (x_c, y_c - 1).
Unfortunately, it seems that some movement systems of some robots are malfunctioning. For each robot you know which actions it can perform, and which it cannot perform.
You want to send a command so all robots gather at the same point. To do so, you have to choose a pair of integer numbers X and Y so that each robot can reach the point (X, Y). Is it possible to find such a point?
Input
The first line contains one integer q (1 β€ q β€ 10^5) β the number of queries.
Then q queries follow. Each query begins with one line containing one integer n (1 β€ n β€ 10^5) β the number of robots in the query. Then n lines follow, the i-th of these lines describes the i-th robot in the current query: it contains six integer numbers x_i, y_i, f_{i, 1}, f_{i, 2}, f_{i, 3} and f_{i, 4} (-10^5 β€ x_i, y_i β€ 10^5, 0 β€ f_{i, j} β€ 1). The first two numbers describe the initial location of the i-th robot, and the following four numbers describe which actions the i-th robot can use to move (f_{i, j} = 1 if the i-th robot can use the j-th action, and f_{i, j} = 0 if it cannot use the j-th action).
It is guaranteed that the total number of robots over all queries does not exceed 10^5.
Output
You should answer each query independently, in the order these queries appear in the input.
To answer a query, you should do one of the following:
* if it is impossible to find a point that is reachable by all n robots, print one number 0 on a separate line;
* if it is possible to find a point that is reachable by all n robots, print three space-separated integers on the same line: 1 X Y, where X and Y are the coordinates of the point reachable by all n robots. Both X and Y should not exceed 10^5 by absolute value; it is guaranteed that if there exists at least one point reachable by all robots, then at least one of such points has both coordinates not exceeding 10^5 by absolute value.
Example
Input
4
2
-1 -2 0 0 0 0
-1 -2 0 0 0 0
3
1 5 1 1 1 1
2 5 0 1 0 1
3 5 1 0 0 0
2
1337 1337 0 1 1 1
1336 1337 1 1 0 1
1
3 5 1 1 1 1
Output
1 -1 -2
1 2 5
0
1 -100000 -100000 | instruction | 0 | 70,820 | 15 | 141,640 |
Tags: implementation
Correct Solution:
```
def main():
import sys
input = sys.stdin.readline
def solve():
n = int(input())
maxx = 10**5
minx = -10**5
maxy = 10**5
miny = -10**5
for _ in range(n):
x, y, f1, f2, f3, f4 = map(int, input().split())
if not f1:
minx = max(minx, x)
if not f2:
maxy = min(maxy, y)
if not f3:
maxx = min(maxx, x)
if not f4:
miny = max(miny, y)
if minx > maxx or miny > maxy:
print(0)
else:
print(1, minx, miny)
for _ in range(int(input())):
solve()
return 0
main()
``` | output | 1 | 70,820 | 15 | 141,641 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n robots have escaped from your laboratory! You have to find them as soon as possible, because these robots are experimental, and their behavior is not tested yet, so they may be really dangerous!
Fortunately, even though your robots have escaped, you still have some control over them. First of all, you know the location of each robot: the world you live in can be modeled as an infinite coordinate plane, and the i-th robot is currently located at the point having coordinates (x_i, y_i). Furthermore, you may send exactly one command to all of the robots. The command should contain two integer numbers X and Y, and when each robot receives this command, it starts moving towards the point having coordinates (X, Y). The robot stops its movement in two cases:
* either it reaches (X, Y);
* or it cannot get any closer to (X, Y).
Normally, all robots should be able to get from any point of the coordinate plane to any other point. Each robot usually can perform four actions to move. Let's denote the current coordinates of the robot as (x_c, y_c). Then the movement system allows it to move to any of the four adjacent points:
1. the first action allows it to move from (x_c, y_c) to (x_c - 1, y_c);
2. the second action allows it to move from (x_c, y_c) to (x_c, y_c + 1);
3. the third action allows it to move from (x_c, y_c) to (x_c + 1, y_c);
4. the fourth action allows it to move from (x_c, y_c) to (x_c, y_c - 1).
Unfortunately, it seems that some movement systems of some robots are malfunctioning. For each robot you know which actions it can perform, and which it cannot perform.
You want to send a command so all robots gather at the same point. To do so, you have to choose a pair of integer numbers X and Y so that each robot can reach the point (X, Y). Is it possible to find such a point?
Input
The first line contains one integer q (1 β€ q β€ 10^5) β the number of queries.
Then q queries follow. Each query begins with one line containing one integer n (1 β€ n β€ 10^5) β the number of robots in the query. Then n lines follow, the i-th of these lines describes the i-th robot in the current query: it contains six integer numbers x_i, y_i, f_{i, 1}, f_{i, 2}, f_{i, 3} and f_{i, 4} (-10^5 β€ x_i, y_i β€ 10^5, 0 β€ f_{i, j} β€ 1). The first two numbers describe the initial location of the i-th robot, and the following four numbers describe which actions the i-th robot can use to move (f_{i, j} = 1 if the i-th robot can use the j-th action, and f_{i, j} = 0 if it cannot use the j-th action).
It is guaranteed that the total number of robots over all queries does not exceed 10^5.
Output
You should answer each query independently, in the order these queries appear in the input.
To answer a query, you should do one of the following:
* if it is impossible to find a point that is reachable by all n robots, print one number 0 on a separate line;
* if it is possible to find a point that is reachable by all n robots, print three space-separated integers on the same line: 1 X Y, where X and Y are the coordinates of the point reachable by all n robots. Both X and Y should not exceed 10^5 by absolute value; it is guaranteed that if there exists at least one point reachable by all robots, then at least one of such points has both coordinates not exceeding 10^5 by absolute value.
Example
Input
4
2
-1 -2 0 0 0 0
-1 -2 0 0 0 0
3
1 5 1 1 1 1
2 5 0 1 0 1
3 5 1 0 0 0
2
1337 1337 0 1 1 1
1336 1337 1 1 0 1
1
3 5 1 1 1 1
Output
1 -1 -2
1 2 5
0
1 -100000 -100000 | instruction | 0 | 70,821 | 15 | 141,642 |
Tags: implementation
Correct Solution:
```
def int_list():
return [int(c) for c in input().split()]
def int1():
return int(input())
def str_list():
return [c for c in input().split()]
def str1():
return input()
# start
neg_bound = -100000
pos_bound = 100000
q = int1()
res = []
for i in range(q):
n = int1()
xbs = []
ybs = []
for j in range(n):
params = int_list()
neg_x = params[2]
pos_y = params[3]
pos_x = params[4]
neg_y = params[5]
curr_x = params[0]
curr_y = params[1]
low_x = curr_x if neg_x == 0 else neg_bound
low_y = curr_y if neg_y == 0 else neg_bound
high_x = curr_x if pos_x == 0 else pos_bound
high_y = curr_y if pos_y == 0 else pos_bound
xbs.append([low_x, high_x])
ybs.append([low_y, high_y])
xb_init = [neg_bound, pos_bound]
yb_init = [neg_bound, pos_bound]
no_solution = False
for xb in xbs:
if xb[0] > xb_init[1] or xb[1] < xb_init[0]:
no_solution = True
break
else:
xb_init[0] = xb[0] if xb[0] > xb_init[0] else xb_init[0]
xb_init[1] = xb[1] if xb[1] < xb_init[1] else xb_init[1]
for yb in ybs:
if yb[0] > yb_init[1] or yb[1] < yb_init[0]:
no_solution = True
break
else:
yb_init[0] = yb[0] if yb[0] > yb_init[0] else yb_init[0]
yb_init[1] = yb[1] if yb[1] < yb_init[1] else yb_init[1]
if no_solution:
res.append(0)
else:
s = "1 " + str(xb_init[0]) + " " + str(yb_init[0])
res.append(s)
for result in res:
print(result)
``` | output | 1 | 70,821 | 15 | 141,643 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n robots have escaped from your laboratory! You have to find them as soon as possible, because these robots are experimental, and their behavior is not tested yet, so they may be really dangerous!
Fortunately, even though your robots have escaped, you still have some control over them. First of all, you know the location of each robot: the world you live in can be modeled as an infinite coordinate plane, and the i-th robot is currently located at the point having coordinates (x_i, y_i). Furthermore, you may send exactly one command to all of the robots. The command should contain two integer numbers X and Y, and when each robot receives this command, it starts moving towards the point having coordinates (X, Y). The robot stops its movement in two cases:
* either it reaches (X, Y);
* or it cannot get any closer to (X, Y).
Normally, all robots should be able to get from any point of the coordinate plane to any other point. Each robot usually can perform four actions to move. Let's denote the current coordinates of the robot as (x_c, y_c). Then the movement system allows it to move to any of the four adjacent points:
1. the first action allows it to move from (x_c, y_c) to (x_c - 1, y_c);
2. the second action allows it to move from (x_c, y_c) to (x_c, y_c + 1);
3. the third action allows it to move from (x_c, y_c) to (x_c + 1, y_c);
4. the fourth action allows it to move from (x_c, y_c) to (x_c, y_c - 1).
Unfortunately, it seems that some movement systems of some robots are malfunctioning. For each robot you know which actions it can perform, and which it cannot perform.
You want to send a command so all robots gather at the same point. To do so, you have to choose a pair of integer numbers X and Y so that each robot can reach the point (X, Y). Is it possible to find such a point?
Input
The first line contains one integer q (1 β€ q β€ 10^5) β the number of queries.
Then q queries follow. Each query begins with one line containing one integer n (1 β€ n β€ 10^5) β the number of robots in the query. Then n lines follow, the i-th of these lines describes the i-th robot in the current query: it contains six integer numbers x_i, y_i, f_{i, 1}, f_{i, 2}, f_{i, 3} and f_{i, 4} (-10^5 β€ x_i, y_i β€ 10^5, 0 β€ f_{i, j} β€ 1). The first two numbers describe the initial location of the i-th robot, and the following four numbers describe which actions the i-th robot can use to move (f_{i, j} = 1 if the i-th robot can use the j-th action, and f_{i, j} = 0 if it cannot use the j-th action).
It is guaranteed that the total number of robots over all queries does not exceed 10^5.
Output
You should answer each query independently, in the order these queries appear in the input.
To answer a query, you should do one of the following:
* if it is impossible to find a point that is reachable by all n robots, print one number 0 on a separate line;
* if it is possible to find a point that is reachable by all n robots, print three space-separated integers on the same line: 1 X Y, where X and Y are the coordinates of the point reachable by all n robots. Both X and Y should not exceed 10^5 by absolute value; it is guaranteed that if there exists at least one point reachable by all robots, then at least one of such points has both coordinates not exceeding 10^5 by absolute value.
Example
Input
4
2
-1 -2 0 0 0 0
-1 -2 0 0 0 0
3
1 5 1 1 1 1
2 5 0 1 0 1
3 5 1 0 0 0
2
1337 1337 0 1 1 1
1336 1337 1 1 0 1
1
3 5 1 1 1 1
Output
1 -1 -2
1 2 5
0
1 -100000 -100000 | instruction | 0 | 70,822 | 15 | 141,644 |
Tags: implementation
Correct Solution:
```
for i in range(int(input())):
n = int(input())
xl = -100000
xr = 100000
yd = -100000
yu = 100000
flag = True
for j in range(n):
x, y, a, b, c, d = map(int, input().split())
if not a:
if x > xl:
xl = x
if not b:
if y < yu:
yu = y
if not c:
if x < xr:
xr = x
if not d:
if y > yd:
yd = y
if xr < xl or yd > yu:
flag = False
if not flag:
print(0)
else:
print(1, xl, yd)
``` | output | 1 | 70,822 | 15 | 141,645 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n robots have escaped from your laboratory! You have to find them as soon as possible, because these robots are experimental, and their behavior is not tested yet, so they may be really dangerous!
Fortunately, even though your robots have escaped, you still have some control over them. First of all, you know the location of each robot: the world you live in can be modeled as an infinite coordinate plane, and the i-th robot is currently located at the point having coordinates (x_i, y_i). Furthermore, you may send exactly one command to all of the robots. The command should contain two integer numbers X and Y, and when each robot receives this command, it starts moving towards the point having coordinates (X, Y). The robot stops its movement in two cases:
* either it reaches (X, Y);
* or it cannot get any closer to (X, Y).
Normally, all robots should be able to get from any point of the coordinate plane to any other point. Each robot usually can perform four actions to move. Let's denote the current coordinates of the robot as (x_c, y_c). Then the movement system allows it to move to any of the four adjacent points:
1. the first action allows it to move from (x_c, y_c) to (x_c - 1, y_c);
2. the second action allows it to move from (x_c, y_c) to (x_c, y_c + 1);
3. the third action allows it to move from (x_c, y_c) to (x_c + 1, y_c);
4. the fourth action allows it to move from (x_c, y_c) to (x_c, y_c - 1).
Unfortunately, it seems that some movement systems of some robots are malfunctioning. For each robot you know which actions it can perform, and which it cannot perform.
You want to send a command so all robots gather at the same point. To do so, you have to choose a pair of integer numbers X and Y so that each robot can reach the point (X, Y). Is it possible to find such a point?
Input
The first line contains one integer q (1 β€ q β€ 10^5) β the number of queries.
Then q queries follow. Each query begins with one line containing one integer n (1 β€ n β€ 10^5) β the number of robots in the query. Then n lines follow, the i-th of these lines describes the i-th robot in the current query: it contains six integer numbers x_i, y_i, f_{i, 1}, f_{i, 2}, f_{i, 3} and f_{i, 4} (-10^5 β€ x_i, y_i β€ 10^5, 0 β€ f_{i, j} β€ 1). The first two numbers describe the initial location of the i-th robot, and the following four numbers describe which actions the i-th robot can use to move (f_{i, j} = 1 if the i-th robot can use the j-th action, and f_{i, j} = 0 if it cannot use the j-th action).
It is guaranteed that the total number of robots over all queries does not exceed 10^5.
Output
You should answer each query independently, in the order these queries appear in the input.
To answer a query, you should do one of the following:
* if it is impossible to find a point that is reachable by all n robots, print one number 0 on a separate line;
* if it is possible to find a point that is reachable by all n robots, print three space-separated integers on the same line: 1 X Y, where X and Y are the coordinates of the point reachable by all n robots. Both X and Y should not exceed 10^5 by absolute value; it is guaranteed that if there exists at least one point reachable by all robots, then at least one of such points has both coordinates not exceeding 10^5 by absolute value.
Example
Input
4
2
-1 -2 0 0 0 0
-1 -2 0 0 0 0
3
1 5 1 1 1 1
2 5 0 1 0 1
3 5 1 0 0 0
2
1337 1337 0 1 1 1
1336 1337 1 1 0 1
1
3 5 1 1 1 1
Output
1 -1 -2
1 2 5
0
1 -100000 -100000 | instruction | 0 | 70,823 | 15 | 141,646 |
Tags: implementation
Correct Solution:
```
import math
from sys import stdin,stdout
from bisect import bisect_left, bisect_right
def isprime(n):
if(n<=1):
return False
if(n<=3) :
return True
if(n%2==0 or n%3==0) :
return False
i=5
while(i*i<=n) :
if(n%i==0 or n%(i+2)==0) :
return False
i=i+6
return True
def freq(l): #return freq disctionary
f = {}
for i in l:
if (i in f):
f[i] += 1
else:
f[i] = 1
return f
MAX = pow(10, 5)
inp=lambda : int(stdin.readline())
sip=lambda : stdin.readline()
mulip =lambda : map(int, stdin.readline().split())
lst=lambda : list(map(int,stdin.readline().split()))
slst=lambda: list(sip())
#-------------------------------------------------------
for _ in range(inp()):
n = inp()
maxx, maxy, minx, miny = MAX, MAX, -MAX, -MAX
for _ in range(n):
x, y, f1, f2, f3, f4 = mulip()
if f2==0:
maxy = min(maxy, y)
if f4==0:
miny = max(miny, y)
if f3==0:
maxx = min(maxx, x)
if f1==0:
minx = max(minx, x)
if minx <= maxx and miny <= maxy:
print(1,minx,miny)
else:
print(0)
``` | output | 1 | 70,823 | 15 | 141,647 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n robots have escaped from your laboratory! You have to find them as soon as possible, because these robots are experimental, and their behavior is not tested yet, so they may be really dangerous!
Fortunately, even though your robots have escaped, you still have some control over them. First of all, you know the location of each robot: the world you live in can be modeled as an infinite coordinate plane, and the i-th robot is currently located at the point having coordinates (x_i, y_i). Furthermore, you may send exactly one command to all of the robots. The command should contain two integer numbers X and Y, and when each robot receives this command, it starts moving towards the point having coordinates (X, Y). The robot stops its movement in two cases:
* either it reaches (X, Y);
* or it cannot get any closer to (X, Y).
Normally, all robots should be able to get from any point of the coordinate plane to any other point. Each robot usually can perform four actions to move. Let's denote the current coordinates of the robot as (x_c, y_c). Then the movement system allows it to move to any of the four adjacent points:
1. the first action allows it to move from (x_c, y_c) to (x_c - 1, y_c);
2. the second action allows it to move from (x_c, y_c) to (x_c, y_c + 1);
3. the third action allows it to move from (x_c, y_c) to (x_c + 1, y_c);
4. the fourth action allows it to move from (x_c, y_c) to (x_c, y_c - 1).
Unfortunately, it seems that some movement systems of some robots are malfunctioning. For each robot you know which actions it can perform, and which it cannot perform.
You want to send a command so all robots gather at the same point. To do so, you have to choose a pair of integer numbers X and Y so that each robot can reach the point (X, Y). Is it possible to find such a point?
Input
The first line contains one integer q (1 β€ q β€ 10^5) β the number of queries.
Then q queries follow. Each query begins with one line containing one integer n (1 β€ n β€ 10^5) β the number of robots in the query. Then n lines follow, the i-th of these lines describes the i-th robot in the current query: it contains six integer numbers x_i, y_i, f_{i, 1}, f_{i, 2}, f_{i, 3} and f_{i, 4} (-10^5 β€ x_i, y_i β€ 10^5, 0 β€ f_{i, j} β€ 1). The first two numbers describe the initial location of the i-th robot, and the following four numbers describe which actions the i-th robot can use to move (f_{i, j} = 1 if the i-th robot can use the j-th action, and f_{i, j} = 0 if it cannot use the j-th action).
It is guaranteed that the total number of robots over all queries does not exceed 10^5.
Output
You should answer each query independently, in the order these queries appear in the input.
To answer a query, you should do one of the following:
* if it is impossible to find a point that is reachable by all n robots, print one number 0 on a separate line;
* if it is possible to find a point that is reachable by all n robots, print three space-separated integers on the same line: 1 X Y, where X and Y are the coordinates of the point reachable by all n robots. Both X and Y should not exceed 10^5 by absolute value; it is guaranteed that if there exists at least one point reachable by all robots, then at least one of such points has both coordinates not exceeding 10^5 by absolute value.
Example
Input
4
2
-1 -2 0 0 0 0
-1 -2 0 0 0 0
3
1 5 1 1 1 1
2 5 0 1 0 1
3 5 1 0 0 0
2
1337 1337 0 1 1 1
1336 1337 1 1 0 1
1
3 5 1 1 1 1
Output
1 -1 -2
1 2 5
0
1 -100000 -100000 | instruction | 0 | 70,824 | 15 | 141,648 |
Tags: implementation
Correct Solution:
```
t = int(input())
for z in range(t):
n = int(input())
mg = 100000
x_min = -mg
y_min = -mg
x_max = +mg
y_max = +mg
for i in range(n):
x, y, a, b, c, d = map(int, input().split())
if a == 0:
x_min = max(x, x_min)
if b == 0:
y_max = min(y, y_max)
if c == 0:
x_max = min(x, x_max)
if d == 0:
y_min = max(y, y_min)
if x_min <= x_max and y_min <= y_max:
print(1, x_min, y_min)
else:
print(0)
``` | output | 1 | 70,824 | 15 | 141,649 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this problem you will meet the simplified model of game Pudding Monsters.
An important process in developing any game is creating levels. A game field in Pudding Monsters is an n Γ n rectangular grid, n of its cells contain monsters and some other cells contain game objects. The gameplay is about moving the monsters around the field. When two monsters are touching each other, they glue together into a single big one (as they are from pudding, remember?).
<image>
Statistics showed that the most interesting maps appear if initially each row and each column contains exactly one monster and the rest of map specifics is set up by the correct positioning of the other game objects.
A technique that's widely used to make the development process more efficient is reusing the available resources. For example, if there is a large n Γ n map, you can choose in it a smaller k Γ k square part, containing exactly k monsters and suggest it as a simplified version of the original map.
You wonder how many ways there are to choose in the initial map a k Γ k (1 β€ k β€ n) square fragment, containing exactly k pudding monsters. Calculate this number.
Input
The first line contains a single integer n (1 β€ n β€ 3 Γ 105) β the size of the initial field.
Next n lines contain the coordinates of the cells initially containing monsters. The i-th of the next lines contains two numbers ri, ci (1 β€ ri, ci β€ n) β the row number and the column number of the cell that initially contains the i-th monster.
It is guaranteed that all ri are distinct numbers and all ci are distinct numbers.
Output
Print the number of distinct square fragments of the original field that can form a new map.
Examples
Input
5
1 1
4 3
3 2
2 4
5 5
Output
10
Submitted Solution:
```
k = 2
python = 1 + k
``` | instruction | 0 | 71,168 | 15 | 142,336 |
No | output | 1 | 71,168 | 15 | 142,337 |
Provide a correct Python 3 solution for this coding contest problem.
Dr. Fukuoka has placed a simple robot in a two-dimensional maze. It moves within the maze and never goes out of the maze as there is no exit.
The maze is made up of H Γ W grid cells as depicted below. The upper side of the maze faces north. Consequently, the right, lower and left sides face east, south and west respectively. Each cell is either empty or wall and has the coordinates of (i, j) where the north-west corner has (1, 1). The row i goes up toward the south and the column j toward the east.
<image>
The robot moves on empty cells and faces north, east, south or west. It goes forward when there is an empty cell in front, and rotates 90 degrees to the right when it comes in front of a wall cell or on the edge of the maze. It cannot enter the wall cells. It stops right after moving forward by L cells.
Your mission is, given the initial position and direction of the robot and the number of steps, to write a program to calculate the final position and direction of the robot.
Input
The input is a sequence of datasets. Each dataset is formatted as follows.
H W L
c1,1c1,2...c1,W
.
.
.
cH,1cH,2...cH,W
The first line of a dataset contains three integers H, W and L (1 β€ H, W β€ 100, 1 β€ L β€ 1018).
Each of the following H lines contains exactly W characters. In the i-th line, the j-th character ci,j represents a cell at (i, j) of the maze. "." denotes an empty cell. "#" denotes a wall cell. "N", "E", "S", "W" denote a robot on an empty cell facing north, east, south and west respectively; it indicates the initial position and direction of the robot.
You can assume that there is at least one empty cell adjacent to the initial position of the robot.
The end of input is indicated by a line with three zeros. This line is not part of any dataset.
Output
For each dataset, output in a line the final row, column and direction of the robot, separated by a single space. The direction should be one of the following: "N" (north), "E" (east), "S" (south) and "W" (west).
No extra spaces or characters are allowed.
Examples
Input
3 3 10
E..
.#.
...
5 5 19
####.
.....
.#S#.
...#.
#.##.
5 5 6
#.#..
#....
##.#.
#..S.
#....
5 4 35
..##
....
.##.
.#S.
...#
0 0 0
Output
1 3 E
4 5 S
4 4 E
1 1 N
Input
3 3 10
E..
.#.
...
5 5 19
.
.....
.#S#.
...#.
.##.
5 5 6
.#..
....
.#.
..S.
....
5 4 35
..##
....
.##.
.#S.
...#
0 0 0
Output
1 3 E
4 5 S
4 4 E
1 1 N | instruction | 0 | 71,575 | 15 | 143,150 |
"Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
did = {}
did['N'] = 0
did['E'] = 1
did['S'] = 2
did['W'] = 3
while True:
h,w,l = LI()
if h == 0:
break
a = [[c for c in S()] for _ in range(h)]
s = None
for i in range(h):
for j in range(w):
if a[i][j] in 'NEWS':
s = (i,j,did[a[i][j]])
break
i = 0
t = s
td = {}
tt = 0
i,j,dk = t
while tt < l:
tt += 1
for ddi in range(4):
di,dj = dd[(dk+ddi) % 4]
ni = i + di
nj = j + dj
if ni < 0 or ni >= h or nj < 0 or nj >= w or a[ni][nj] == '#':
continue
dk = (dk + ddi) % 4
i = ni
j = nj
break
if (i,j,dk) in td:
tt += (l-tt) // (tt - td[(i,j,dk)]) * (tt - td[(i,j,dk)])
else:
td[(i,j,dk)] = tt
rr.append('{} {} {}'.format(i+1,j+1,'NESW'[dk]))
return '\n'.join(map(str,rr))
print(main())
``` | output | 1 | 71,575 | 15 | 143,151 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem only differs from the next problem in constraints.
This is an interactive problem.
Alice and Bob are playing a game on the chessboard of size n Γ m where n and m are even. The rows are numbered from 1 to n and the columns are numbered from 1 to m. There are two knights on the chessboard. A white one initially is on the position (x_1, y_1), while the black one is on the position (x_2, y_2). Alice will choose one of the knights to play with, and Bob will use the other one.
The Alice and Bob will play in turns and whoever controls the white knight starts the game. During a turn, the player must move their knight adhering the chess rules. That is, if the knight is currently on the position (x, y), it can be moved to any of those positions (as long as they are inside the chessboard):
(x+1, y+2), (x+1, y-2), (x-1, y+2), (x-1, y-2),
(x+2, y+1), (x+2, y-1), (x-2, y+1), (x-2, y-1).
We all know that knights are strongest in the middle of the board. Both knight have a single position they want to reach:
* the owner of the white knight wins if it captures the black knight or if the white knight is at (n/2, m/2) and this position is not under attack of the black knight at this moment;
* The owner of the black knight wins if it captures the white knight or if the black knight is at (n/2+1, m/2) and this position is not under attack of the white knight at this moment.
Formally, the player who captures the other knight wins. The player who is at its target square ((n/2, m/2) for white, (n/2+1, m/2) for black) and this position is not under opponent's attack, also wins.
A position is under attack of a knight if it can move into this position. Capturing a knight means that a player moves their knight to the cell where the opponent's knight is.
If Alice made 350 moves and nobody won, the game is a draw.
Alice is unsure in her chess skills, so she asks you for a help. Choose a knight and win the game for her. It can be shown, that Alice always has a winning strategy.
Interaction
The interaction starts with two integers n and m (6 β€ n,m β€ 40, n and m are even) β the dimensions of the chessboard.
The second line contains four integers x_1, y_1, x_2, y_2 (1 β€ x_1, x_2 β€ n, 1 β€ y_1, y_2 β€ m) β the positions of the white and the black knight. It is guaranteed that the two knights have different starting positions. It is also guaranteed that none of the knights are in their own target square in the beginning of the game (however, they can be on the opponent's target position).
Your program should reply with either "WHITE" or "BLACK", depending on the knight you want to play with. In case you select the white knight, you start the game.
During every your turn, you need to print two integers: x and y, the position to move the knight. If you won the game by this turn, you must terminate your program immediately.
After every turn of the opponent, you will receive two integers: x and y, the position where Bob moved his knight.
If your last move was illegal or you lost the game after jury's turn, or you made 350 moves, and haven't won, you will receive "-1 -1". In such cases, you should terminate your program and then you will get a Wrong Answer verdict.
After printing anything, do not forget to output the end of line and flush the output. Otherwise, you might get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
Hacks are disabled for this problem.
Jury's program is adaptive: the moves of jury may depend on the moves made by your program.
Examples
Input
8 8
2 3 1 8
Output
WHITE
4 4
Input
6 6
4 4 2 2
6 3
Output
BLACK
4 3
Note
In the first example, the white knight can reach it's target square in one move.
In the second example black knight wins, no matter what white knight moves.
Submitted Solution:
```
import sys
import random
def moves(x1, y1):
return [(x1+1,y1+2),
(x1+1,y1-2),
(x1-1,y1+2),
(x1-1,y1-2),
(x1+2,y1+1),
(x1+2,y1-1),
(x1-2,y1+1),
(x1-2,y1-1)]
n, m = map(int, input().split())
x1, y1, x2, y2 = map(int, input().split())
white = moves(x1, y1)
black = moves(x2, y2)
if (n//2 +1, n//2) in black:
print('BLACK')
sys.stdout.flush()
print(n//2+1, n//2)
sys.stdout.flush()
sys.exit()
else:
print('WHITE')
sys.stdout.flush()
while True:
if (x1, y1) == (n//2, n//2):
print(n//2, n//2)
sys.stdout.flush()
break
white = moves(x1, y1)
if (n//2, n//2) in white:
print(n//2, n//2)
sys.stdout.flush()
break
black = moves(x2, y2)
x, y = white[random.randrange(8)]
while x > n or y > n and (x,y) not in black:
white = moves(x1, y1)
if (n//2, n//2) in white:
print(n//2, n//2)
sys.stdout.flush()
break
x, y = white[random.randrange(8)]
x1, y1 = x, y
print(x1, y1)
sys.stdout.flush()
x2, y2 = map(int, input().split())
if (x2,y2) == (-1,-1):
break
``` | instruction | 0 | 71,737 | 15 | 143,474 |
No | output | 1 | 71,737 | 15 | 143,475 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are standing on the OX-axis at point 0 and you want to move to an integer point x > 0.
You can make several jumps. Suppose you're currently at point y (y may be negative) and jump for the k-th time. You can:
* either jump to the point y + k
* or jump to the point y - 1.
What is the minimum number of jumps you need to reach the point x?
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of test cases.
The first and only line of each test case contains the single integer x (1 β€ x β€ 10^6) β the destination point.
Output
For each test case, print the single integer β the minimum number of jumps to reach x. It can be proved that we can reach any integer point x.
Example
Input
5
1
2
3
4
5
Output
1
3
2
3
4
Note
In the first test case x = 1, so you need only one jump: the 1-st jump from 0 to 0 + 1 = 1.
In the second test case x = 2. You need at least three jumps:
* the 1-st jump from 0 to 0 + 1 = 1;
* the 2-nd jump from 1 to 1 + 2 = 3;
* the 3-rd jump from 3 to 3 - 1 = 2;
Two jumps are not enough because these are the only possible variants:
* the 1-st jump as -1 and the 2-nd one as -1 β you'll reach 0 -1 -1 =-2;
* the 1-st jump as -1 and the 2-nd one as +2 β you'll reach 0 -1 +2 = 1;
* the 1-st jump as +1 and the 2-nd one as -1 β you'll reach 0 +1 -1 = 0;
* the 1-st jump as +1 and the 2-nd one as +2 β you'll reach 0 +1 +2 = 3;
In the third test case, you need two jumps: the 1-st one as +1 and the 2-nd one as +2, so 0 + 1 + 2 = 3.
In the fourth test case, you need three jumps: the 1-st one as -1, the 2-nd one as +2 and the 3-rd one as +3, so 0 - 1 + 2 + 3 = 4. | instruction | 0 | 71,854 | 15 | 143,708 |
Tags: constructive algorithms, math
Correct Solution:
```
from sys import stdin
"""
n=int(stdin.readline().strip())
n,m=map(int,stdin.readline().strip().split())
s=list(map(int,stdin.readline().strip().split()))
s=stdin.readline().strip()
"""
cas=int(stdin.readline().strip())
ans=0
def sm(x):
return ((x)*(x+1))//2
for ca in range(cas):
x=int(stdin.readline().strip())
for i in range(1000000):
if sm(i)>=x:
if sm(i)-x==1:
print(i+1)
else:
print(i)
break
``` | output | 1 | 71,854 | 15 | 143,709 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are standing on the OX-axis at point 0 and you want to move to an integer point x > 0.
You can make several jumps. Suppose you're currently at point y (y may be negative) and jump for the k-th time. You can:
* either jump to the point y + k
* or jump to the point y - 1.
What is the minimum number of jumps you need to reach the point x?
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of test cases.
The first and only line of each test case contains the single integer x (1 β€ x β€ 10^6) β the destination point.
Output
For each test case, print the single integer β the minimum number of jumps to reach x. It can be proved that we can reach any integer point x.
Example
Input
5
1
2
3
4
5
Output
1
3
2
3
4
Note
In the first test case x = 1, so you need only one jump: the 1-st jump from 0 to 0 + 1 = 1.
In the second test case x = 2. You need at least three jumps:
* the 1-st jump from 0 to 0 + 1 = 1;
* the 2-nd jump from 1 to 1 + 2 = 3;
* the 3-rd jump from 3 to 3 - 1 = 2;
Two jumps are not enough because these are the only possible variants:
* the 1-st jump as -1 and the 2-nd one as -1 β you'll reach 0 -1 -1 =-2;
* the 1-st jump as -1 and the 2-nd one as +2 β you'll reach 0 -1 +2 = 1;
* the 1-st jump as +1 and the 2-nd one as -1 β you'll reach 0 +1 -1 = 0;
* the 1-st jump as +1 and the 2-nd one as +2 β you'll reach 0 +1 +2 = 3;
In the third test case, you need two jumps: the 1-st one as +1 and the 2-nd one as +2, so 0 + 1 + 2 = 3.
In the fourth test case, you need three jumps: the 1-st one as -1, the 2-nd one as +2 and the 3-rd one as +3, so 0 - 1 + 2 + 3 = 4. | instruction | 0 | 71,855 | 15 | 143,710 |
Tags: constructive algorithms, math
Correct Solution:
```
import sys
def main():
def modst(a, s):
ret = 1
while s:
if s % 2:
ret = ret * a % mod
a = a * a % mod
s //= 2
return ret
def Cnk(n, k):
return (k <= n and n >= 0) * ((f[n] * modst((f[k] * f[n - k]) % mod, mod - 2)) % mod)
#n, v, u = map(int, sys.stdin.readline().split())
#n, k = map(int, sys.stdin.readline().split())
#n = int(sys.stdin.readline().strip())
#a, b = map(int, sys.stdin.readline().split())
#q = list(map(int, sys.stdin.readline().split()))
#q = sorted(list(map(int, sys.stdin.readline().split())), reverse=True)
'''mod = 998244353
f = [1, 1]
for i in range(2, 200007):
f.append((f[-1] * i) % mod)
a = 0
for i in range(2 - n % 2, n + 1, 2):
a = (a + Cnk(max(((n - i) // 2) + i - 1, 0), i - 1)) % mod
print((a * modst(modst(2, n), mod - 2)) % mod)'''
x = int(sys.stdin.readline().strip())
n, d = 0, 1
while n + d < x:
n += d; d += 1
print(d + (n + d == x + 1))
for i in range(int(input())):
main()
``` | output | 1 | 71,855 | 15 | 143,711 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are standing on the OX-axis at point 0 and you want to move to an integer point x > 0.
You can make several jumps. Suppose you're currently at point y (y may be negative) and jump for the k-th time. You can:
* either jump to the point y + k
* or jump to the point y - 1.
What is the minimum number of jumps you need to reach the point x?
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of test cases.
The first and only line of each test case contains the single integer x (1 β€ x β€ 10^6) β the destination point.
Output
For each test case, print the single integer β the minimum number of jumps to reach x. It can be proved that we can reach any integer point x.
Example
Input
5
1
2
3
4
5
Output
1
3
2
3
4
Note
In the first test case x = 1, so you need only one jump: the 1-st jump from 0 to 0 + 1 = 1.
In the second test case x = 2. You need at least three jumps:
* the 1-st jump from 0 to 0 + 1 = 1;
* the 2-nd jump from 1 to 1 + 2 = 3;
* the 3-rd jump from 3 to 3 - 1 = 2;
Two jumps are not enough because these are the only possible variants:
* the 1-st jump as -1 and the 2-nd one as -1 β you'll reach 0 -1 -1 =-2;
* the 1-st jump as -1 and the 2-nd one as +2 β you'll reach 0 -1 +2 = 1;
* the 1-st jump as +1 and the 2-nd one as -1 β you'll reach 0 +1 -1 = 0;
* the 1-st jump as +1 and the 2-nd one as +2 β you'll reach 0 +1 +2 = 3;
In the third test case, you need two jumps: the 1-st one as +1 and the 2-nd one as +2, so 0 + 1 + 2 = 3.
In the fourth test case, you need three jumps: the 1-st one as -1, the 2-nd one as +2 and the 3-rd one as +3, so 0 - 1 + 2 + 3 = 4. | instruction | 0 | 71,856 | 15 | 143,712 |
Tags: constructive algorithms, math
Correct Solution:
```
for t in range(int(input())):
x=int(input())
if x==1:
print(1)
else:
sum=0
count=0
while sum<x:
sum+=count+1
count+=1
if sum==x or sum!=x+1:
print(count)
else:
print(count+1)
``` | output | 1 | 71,856 | 15 | 143,713 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are standing on the OX-axis at point 0 and you want to move to an integer point x > 0.
You can make several jumps. Suppose you're currently at point y (y may be negative) and jump for the k-th time. You can:
* either jump to the point y + k
* or jump to the point y - 1.
What is the minimum number of jumps you need to reach the point x?
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of test cases.
The first and only line of each test case contains the single integer x (1 β€ x β€ 10^6) β the destination point.
Output
For each test case, print the single integer β the minimum number of jumps to reach x. It can be proved that we can reach any integer point x.
Example
Input
5
1
2
3
4
5
Output
1
3
2
3
4
Note
In the first test case x = 1, so you need only one jump: the 1-st jump from 0 to 0 + 1 = 1.
In the second test case x = 2. You need at least three jumps:
* the 1-st jump from 0 to 0 + 1 = 1;
* the 2-nd jump from 1 to 1 + 2 = 3;
* the 3-rd jump from 3 to 3 - 1 = 2;
Two jumps are not enough because these are the only possible variants:
* the 1-st jump as -1 and the 2-nd one as -1 β you'll reach 0 -1 -1 =-2;
* the 1-st jump as -1 and the 2-nd one as +2 β you'll reach 0 -1 +2 = 1;
* the 1-st jump as +1 and the 2-nd one as -1 β you'll reach 0 +1 -1 = 0;
* the 1-st jump as +1 and the 2-nd one as +2 β you'll reach 0 +1 +2 = 3;
In the third test case, you need two jumps: the 1-st one as +1 and the 2-nd one as +2, so 0 + 1 + 2 = 3.
In the fourth test case, you need three jumps: the 1-st one as -1, the 2-nd one as +2 and the 3-rd one as +3, so 0 - 1 + 2 + 3 = 4. | instruction | 0 | 71,857 | 15 | 143,714 |
Tags: constructive algorithms, math
Correct Solution:
```
t = int(input())
for i in range(t):
x = int(input())
scitanec = 1
sucet = 0
pocet = 0
while True:
sucet+=scitanec
scitanec+=1
pocet+=1
if sucet>=x:
if 0<(sucet-x)-1<=x:
print(pocet)
else:
print(pocet+(sucet-x))
break
``` | output | 1 | 71,857 | 15 | 143,715 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.