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.
You've got a 5 × 5 matrix, consisting of 24 zeroes and a single number one. Let's index the matrix rows by numbers from 1 to 5 from top to bottom, let's index the matrix columns by numbers from 1 to 5 from left to right. In one move, you are allowed to apply one of the two following transformations to the matrix:
1. Swap two neighboring matrix rows, that is, rows with indexes i and i + 1 for some integer i (1 ≤ i < 5).
2. Swap two neighboring matrix columns, that is, columns with indexes j and j + 1 for some integer j (1 ≤ j < 5).
You think that a matrix looks beautiful, if the single number one of the matrix is located in its middle (in the cell that is on the intersection of the third row and the third column). Count the minimum number of moves needed to make the matrix beautiful.
Input
The input consists of five lines, each line contains five integers: the j-th integer in the i-th line of the input represents the element of the matrix that is located on the intersection of the i-th row and the j-th column. It is guaranteed that the matrix consists of 24 zeroes and a single number one.
Output
Print a single integer — the minimum number of moves needed to make the matrix beautiful.
Examples
Input
0 0 0 0 0
0 0 0 0 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
3
Input
0 0 0 0 0
0 0 0 0 0
0 1 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
1
Submitted Solution:
```
lst = list()
rowWithOne = -1
columnWithOne = -1
for i in range(5) :
rowStr = input()
row = [int(ch) for ch in rowStr.split() ]
lst.append(row)
if rowStr.find("1") != -1 :
for j in range(5) :
if row[j] == 1 :
rowWithOne = i
columnWithOne = j
dist = abs(rowWithOne - 2) + abs(columnWithOne - 2)
print(dist)
``` | instruction | 0 | 64,281 | 15 | 128,562 |
Yes | output | 1 | 64,281 | 15 | 128,563 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got a 5 × 5 matrix, consisting of 24 zeroes and a single number one. Let's index the matrix rows by numbers from 1 to 5 from top to bottom, let's index the matrix columns by numbers from 1 to 5 from left to right. In one move, you are allowed to apply one of the two following transformations to the matrix:
1. Swap two neighboring matrix rows, that is, rows with indexes i and i + 1 for some integer i (1 ≤ i < 5).
2. Swap two neighboring matrix columns, that is, columns with indexes j and j + 1 for some integer j (1 ≤ j < 5).
You think that a matrix looks beautiful, if the single number one of the matrix is located in its middle (in the cell that is on the intersection of the third row and the third column). Count the minimum number of moves needed to make the matrix beautiful.
Input
The input consists of five lines, each line contains five integers: the j-th integer in the i-th line of the input represents the element of the matrix that is located on the intersection of the i-th row and the j-th column. It is guaranteed that the matrix consists of 24 zeroes and a single number one.
Output
Print a single integer — the minimum number of moves needed to make the matrix beautiful.
Examples
Input
0 0 0 0 0
0 0 0 0 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
3
Input
0 0 0 0 0
0 0 0 0 0
0 1 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
1
Submitted Solution:
```
'''
Codeforces A. Beautiful Matrix
'''
matrix = []
one_i = 0
one_j = 0
for i in range(0, 5):
row = input().split()
row = [int(i) for i in row]
if 1 in row:
one_i = i
one_j = row.index(1)
matrix.append(row)
print(abs(2 - one_i) + abs(2 - one_j))
``` | instruction | 0 | 64,282 | 15 | 128,564 |
Yes | output | 1 | 64,282 | 15 | 128,565 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got a 5 × 5 matrix, consisting of 24 zeroes and a single number one. Let's index the matrix rows by numbers from 1 to 5 from top to bottom, let's index the matrix columns by numbers from 1 to 5 from left to right. In one move, you are allowed to apply one of the two following transformations to the matrix:
1. Swap two neighboring matrix rows, that is, rows with indexes i and i + 1 for some integer i (1 ≤ i < 5).
2. Swap two neighboring matrix columns, that is, columns with indexes j and j + 1 for some integer j (1 ≤ j < 5).
You think that a matrix looks beautiful, if the single number one of the matrix is located in its middle (in the cell that is on the intersection of the third row and the third column). Count the minimum number of moves needed to make the matrix beautiful.
Input
The input consists of five lines, each line contains five integers: the j-th integer in the i-th line of the input represents the element of the matrix that is located on the intersection of the i-th row and the j-th column. It is guaranteed that the matrix consists of 24 zeroes and a single number one.
Output
Print a single integer — the minimum number of moves needed to make the matrix beautiful.
Examples
Input
0 0 0 0 0
0 0 0 0 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
3
Input
0 0 0 0 0
0 0 0 0 0
0 1 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
1
Submitted Solution:
```
matrix = []
position = []
for i in range(5):
matrix.append(list(input()))
matrix[i] = [int(j) for j in matrix[i] if j != ' ']
for j in range(5):
if matrix[i][j] == 1:
position = [i + 1, j + 1]
answer = abs(3 - position[0]) + abs(3 - position[1])
print(answer)
``` | instruction | 0 | 64,283 | 15 | 128,566 |
Yes | output | 1 | 64,283 | 15 | 128,567 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got a 5 × 5 matrix, consisting of 24 zeroes and a single number one. Let's index the matrix rows by numbers from 1 to 5 from top to bottom, let's index the matrix columns by numbers from 1 to 5 from left to right. In one move, you are allowed to apply one of the two following transformations to the matrix:
1. Swap two neighboring matrix rows, that is, rows with indexes i and i + 1 for some integer i (1 ≤ i < 5).
2. Swap two neighboring matrix columns, that is, columns with indexes j and j + 1 for some integer j (1 ≤ j < 5).
You think that a matrix looks beautiful, if the single number one of the matrix is located in its middle (in the cell that is on the intersection of the third row and the third column). Count the minimum number of moves needed to make the matrix beautiful.
Input
The input consists of five lines, each line contains five integers: the j-th integer in the i-th line of the input represents the element of the matrix that is located on the intersection of the i-th row and the j-th column. It is guaranteed that the matrix consists of 24 zeroes and a single number one.
Output
Print a single integer — the minimum number of moves needed to make the matrix beautiful.
Examples
Input
0 0 0 0 0
0 0 0 0 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
3
Input
0 0 0 0 0
0 0 0 0 0
0 1 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
1
Submitted Solution:
```
n = list(map(str, input().split()))
s = "".join(n)
#print(s)
b = s.find("1")
a = b+1
#print(a)
if a ==13:
print("0")
elif a == 2 or a==6 or a==4 or a==10 or a==16 or a==20 or a==22 or a==24:
print("3")
elif a == 1 or a==5 or a==21 or a==25:
print("4")
else:
print("2")
``` | instruction | 0 | 64,284 | 15 | 128,568 |
No | output | 1 | 64,284 | 15 | 128,569 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got a 5 × 5 matrix, consisting of 24 zeroes and a single number one. Let's index the matrix rows by numbers from 1 to 5 from top to bottom, let's index the matrix columns by numbers from 1 to 5 from left to right. In one move, you are allowed to apply one of the two following transformations to the matrix:
1. Swap two neighboring matrix rows, that is, rows with indexes i and i + 1 for some integer i (1 ≤ i < 5).
2. Swap two neighboring matrix columns, that is, columns with indexes j and j + 1 for some integer j (1 ≤ j < 5).
You think that a matrix looks beautiful, if the single number one of the matrix is located in its middle (in the cell that is on the intersection of the third row and the third column). Count the minimum number of moves needed to make the matrix beautiful.
Input
The input consists of five lines, each line contains five integers: the j-th integer in the i-th line of the input represents the element of the matrix that is located on the intersection of the i-th row and the j-th column. It is guaranteed that the matrix consists of 24 zeroes and a single number one.
Output
Print a single integer — the minimum number of moves needed to make the matrix beautiful.
Examples
Input
0 0 0 0 0
0 0 0 0 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
3
Input
0 0 0 0 0
0 0 0 0 0
0 1 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
1
Submitted Solution:
```
a=[]
for i in range(5):
a.append(list(map(int,input().split())))
for i in range(5):
for j in range(5):
if a[i][j]==1:
print(abs(i-j))
break
``` | instruction | 0 | 64,285 | 15 | 128,570 |
No | output | 1 | 64,285 | 15 | 128,571 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got a 5 × 5 matrix, consisting of 24 zeroes and a single number one. Let's index the matrix rows by numbers from 1 to 5 from top to bottom, let's index the matrix columns by numbers from 1 to 5 from left to right. In one move, you are allowed to apply one of the two following transformations to the matrix:
1. Swap two neighboring matrix rows, that is, rows with indexes i and i + 1 for some integer i (1 ≤ i < 5).
2. Swap two neighboring matrix columns, that is, columns with indexes j and j + 1 for some integer j (1 ≤ j < 5).
You think that a matrix looks beautiful, if the single number one of the matrix is located in its middle (in the cell that is on the intersection of the third row and the third column). Count the minimum number of moves needed to make the matrix beautiful.
Input
The input consists of five lines, each line contains five integers: the j-th integer in the i-th line of the input represents the element of the matrix that is located on the intersection of the i-th row and the j-th column. It is guaranteed that the matrix consists of 24 zeroes and a single number one.
Output
Print a single integer — the minimum number of moves needed to make the matrix beautiful.
Examples
Input
0 0 0 0 0
0 0 0 0 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
3
Input
0 0 0 0 0
0 0 0 0 0
0 1 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
1
Submitted Solution:
```
done = False
for row in range(5):
if done:
break
col = 0
for ch in input():
if ch!=' ':
col += 1
if ch=='1':
done = True
break
print(abs(col-2)+abs(row-2))
``` | instruction | 0 | 64,286 | 15 | 128,572 |
No | output | 1 | 64,286 | 15 | 128,573 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got a 5 × 5 matrix, consisting of 24 zeroes and a single number one. Let's index the matrix rows by numbers from 1 to 5 from top to bottom, let's index the matrix columns by numbers from 1 to 5 from left to right. In one move, you are allowed to apply one of the two following transformations to the matrix:
1. Swap two neighboring matrix rows, that is, rows with indexes i and i + 1 for some integer i (1 ≤ i < 5).
2. Swap two neighboring matrix columns, that is, columns with indexes j and j + 1 for some integer j (1 ≤ j < 5).
You think that a matrix looks beautiful, if the single number one of the matrix is located in its middle (in the cell that is on the intersection of the third row and the third column). Count the minimum number of moves needed to make the matrix beautiful.
Input
The input consists of five lines, each line contains five integers: the j-th integer in the i-th line of the input represents the element of the matrix that is located on the intersection of the i-th row and the j-th column. It is guaranteed that the matrix consists of 24 zeroes and a single number one.
Output
Print a single integer — the minimum number of moves needed to make the matrix beautiful.
Examples
Input
0 0 0 0 0
0 0 0 0 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
3
Input
0 0 0 0 0
0 0 0 0 0
0 1 0 0 0
0 0 0 0 0
0 0 0 0 0
Output
1
Submitted Solution:
```
l=[[],[],[],[],[]]
x=y=0
for i in range(5):
l[i]=[int(x) for x in input().split()]
for i in range(5):
if 1 in l[i]:
x=i+1
for j in range(5):
if l[i][j]==1:
y=j+1
break
else:
continue
print(abs(x-2)+abs(y-2))
``` | instruction | 0 | 64,287 | 15 | 128,574 |
No | output | 1 | 64,287 | 15 | 128,575 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gerald plays the following game. He has a checkered field of size n × n cells, where m various cells are banned. Before the game, he has to put a few chips on some border (but not corner) board cells. Then for n - 1 minutes, Gerald every minute moves each chip into an adjacent cell. He moves each chip from its original edge to the opposite edge. Gerald loses in this game in each of the three cases:
* At least one of the chips at least once fell to the banned cell.
* At least once two chips were on the same cell.
* At least once two chips swapped in a minute (for example, if you stand two chips on two opposite border cells of a row with even length, this situation happens in the middle of the row).
In that case he loses and earns 0 points. When nothing like that happened, he wins and earns the number of points equal to the number of chips he managed to put on the board. Help Gerald earn the most points.
Input
The first line contains two space-separated integers n and m (2 ≤ n ≤ 1000, 0 ≤ m ≤ 105) — the size of the field and the number of banned cells. Next m lines each contain two space-separated integers. Specifically, the i-th of these lines contains numbers xi and yi (1 ≤ xi, yi ≤ n) — the coordinates of the i-th banned cell. All given cells are distinct.
Consider the field rows numbered from top to bottom from 1 to n, and the columns — from left to right from 1 to n.
Output
Print a single integer — the maximum points Gerald can earn in this game.
Examples
Input
3 1
2 2
Output
0
Input
3 0
Output
1
Input
4 3
3 1
3 2
3 3
Output
1
Note
In the first test the answer equals zero as we can't put chips into the corner cells.
In the second sample we can place one chip into either cell (1, 2), or cell (3, 2), or cell (2, 1), or cell (2, 3). We cannot place two chips.
In the third sample we can only place one chip into either cell (2, 1), or cell (2, 4). | instruction | 0 | 64,320 | 15 | 128,640 |
Tags: greedy
Correct Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
# from fractions import *
# from heapq import*
from bisect import *
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ALPHA='abcdefghijklmnopqrstuvwxyz/'
M=1000000007
EPS=1e-6
def Ceil(a,b): return a//b+int(a%b>0)
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
# vsInput()
n,m=value()
row_blocked=defaultdict(bool)
col_blocked=defaultdict(bool)
for i in range(m):
x,y=value()
row_blocked[x]=True
col_blocked[y]=True
ans=0
for i in range(2,n):
if(not row_blocked[i]): ans+=1
if(not col_blocked[i]): ans+=1
if(n%2):
if(not row_blocked[n//2+1] and not col_blocked[n//2+1]): ans-=1
print(ans)
``` | output | 1 | 64,320 | 15 | 128,641 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gerald plays the following game. He has a checkered field of size n × n cells, where m various cells are banned. Before the game, he has to put a few chips on some border (but not corner) board cells. Then for n - 1 minutes, Gerald every minute moves each chip into an adjacent cell. He moves each chip from its original edge to the opposite edge. Gerald loses in this game in each of the three cases:
* At least one of the chips at least once fell to the banned cell.
* At least once two chips were on the same cell.
* At least once two chips swapped in a minute (for example, if you stand two chips on two opposite border cells of a row with even length, this situation happens in the middle of the row).
In that case he loses and earns 0 points. When nothing like that happened, he wins and earns the number of points equal to the number of chips he managed to put on the board. Help Gerald earn the most points.
Input
The first line contains two space-separated integers n and m (2 ≤ n ≤ 1000, 0 ≤ m ≤ 105) — the size of the field and the number of banned cells. Next m lines each contain two space-separated integers. Specifically, the i-th of these lines contains numbers xi and yi (1 ≤ xi, yi ≤ n) — the coordinates of the i-th banned cell. All given cells are distinct.
Consider the field rows numbered from top to bottom from 1 to n, and the columns — from left to right from 1 to n.
Output
Print a single integer — the maximum points Gerald can earn in this game.
Examples
Input
3 1
2 2
Output
0
Input
3 0
Output
1
Input
4 3
3 1
3 2
3 3
Output
1
Note
In the first test the answer equals zero as we can't put chips into the corner cells.
In the second sample we can place one chip into either cell (1, 2), or cell (3, 2), or cell (2, 1), or cell (2, 3). We cannot place two chips.
In the third sample we can only place one chip into either cell (2, 1), or cell (2, 4). | instruction | 0 | 64,321 | 15 | 128,642 |
Tags: greedy
Correct Solution:
```
n, m = map(int, input().split())
l = [0 for i in range(0, n)]
c = [0 for i in range(0, n)]
sol = 0
for i in range(0, m):
a, b = map(int, input().split())
l[a-1] = 1
c[b-1] = 1
for i in range(1, n//2):
#ma ocup de liniile i si n-i, coloanele la fel
sol += 4 - (l[i] + c[i] + l[n-i-1] + c[n-i-1])
if n % 2 == 1:
if not l[n//2] or not c[n//2]: sol += 1
print(sol)
``` | output | 1 | 64,321 | 15 | 128,643 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gerald plays the following game. He has a checkered field of size n × n cells, where m various cells are banned. Before the game, he has to put a few chips on some border (but not corner) board cells. Then for n - 1 minutes, Gerald every minute moves each chip into an adjacent cell. He moves each chip from its original edge to the opposite edge. Gerald loses in this game in each of the three cases:
* At least one of the chips at least once fell to the banned cell.
* At least once two chips were on the same cell.
* At least once two chips swapped in a minute (for example, if you stand two chips on two opposite border cells of a row with even length, this situation happens in the middle of the row).
In that case he loses and earns 0 points. When nothing like that happened, he wins and earns the number of points equal to the number of chips he managed to put on the board. Help Gerald earn the most points.
Input
The first line contains two space-separated integers n and m (2 ≤ n ≤ 1000, 0 ≤ m ≤ 105) — the size of the field and the number of banned cells. Next m lines each contain two space-separated integers. Specifically, the i-th of these lines contains numbers xi and yi (1 ≤ xi, yi ≤ n) — the coordinates of the i-th banned cell. All given cells are distinct.
Consider the field rows numbered from top to bottom from 1 to n, and the columns — from left to right from 1 to n.
Output
Print a single integer — the maximum points Gerald can earn in this game.
Examples
Input
3 1
2 2
Output
0
Input
3 0
Output
1
Input
4 3
3 1
3 2
3 3
Output
1
Note
In the first test the answer equals zero as we can't put chips into the corner cells.
In the second sample we can place one chip into either cell (1, 2), or cell (3, 2), or cell (2, 1), or cell (2, 3). We cannot place two chips.
In the third sample we can only place one chip into either cell (2, 1), or cell (2, 4). | instruction | 0 | 64,322 | 15 | 128,644 |
Tags: greedy
Correct Solution:
```
n, m = tuple(map(int, input().split(' ')))
vb = set()
hb = set()
for k in range(m):
i, j = tuple(map(int, input().split(' ')))
hb.add(i-1)
vb.add(j-1)
c = 0
for i in range(1, n//2):
c += 1 if i not in hb else 0
c += 1 if n-i-1 not in hb else 0
c += 1 if i not in vb else 0
c += 1 if n-i-1 not in vb else 0
c += 1 if n%2==1 and (n//2 not in hb or n//2 not in vb) else 0
print(c)
``` | output | 1 | 64,322 | 15 | 128,645 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gerald plays the following game. He has a checkered field of size n × n cells, where m various cells are banned. Before the game, he has to put a few chips on some border (but not corner) board cells. Then for n - 1 minutes, Gerald every minute moves each chip into an adjacent cell. He moves each chip from its original edge to the opposite edge. Gerald loses in this game in each of the three cases:
* At least one of the chips at least once fell to the banned cell.
* At least once two chips were on the same cell.
* At least once two chips swapped in a minute (for example, if you stand two chips on two opposite border cells of a row with even length, this situation happens in the middle of the row).
In that case he loses and earns 0 points. When nothing like that happened, he wins and earns the number of points equal to the number of chips he managed to put on the board. Help Gerald earn the most points.
Input
The first line contains two space-separated integers n and m (2 ≤ n ≤ 1000, 0 ≤ m ≤ 105) — the size of the field and the number of banned cells. Next m lines each contain two space-separated integers. Specifically, the i-th of these lines contains numbers xi and yi (1 ≤ xi, yi ≤ n) — the coordinates of the i-th banned cell. All given cells are distinct.
Consider the field rows numbered from top to bottom from 1 to n, and the columns — from left to right from 1 to n.
Output
Print a single integer — the maximum points Gerald can earn in this game.
Examples
Input
3 1
2 2
Output
0
Input
3 0
Output
1
Input
4 3
3 1
3 2
3 3
Output
1
Note
In the first test the answer equals zero as we can't put chips into the corner cells.
In the second sample we can place one chip into either cell (1, 2), or cell (3, 2), or cell (2, 1), or cell (2, 3). We cannot place two chips.
In the third sample we can only place one chip into either cell (2, 1), or cell (2, 4). | instruction | 0 | 64,323 | 15 | 128,646 |
Tags: greedy
Correct Solution:
```
n,m=map(int,input().split())
a=[0 for i in range(0,n+1)]
b=[0 for i in range(0,n+1)]
for i in range(0,m):
x,y=map(int,input().split())
a[x]=b[y]=1
s=0
for i in range(2,n):
if a[i]==0:s+=1
if b[i]==0:s+=1
if (n%2)and(a[n//2+1]==0)and(b[n//2+1]==0):s-=1
print(s)
``` | output | 1 | 64,323 | 15 | 128,647 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gerald plays the following game. He has a checkered field of size n × n cells, where m various cells are banned. Before the game, he has to put a few chips on some border (but not corner) board cells. Then for n - 1 minutes, Gerald every minute moves each chip into an adjacent cell. He moves each chip from its original edge to the opposite edge. Gerald loses in this game in each of the three cases:
* At least one of the chips at least once fell to the banned cell.
* At least once two chips were on the same cell.
* At least once two chips swapped in a minute (for example, if you stand two chips on two opposite border cells of a row with even length, this situation happens in the middle of the row).
In that case he loses and earns 0 points. When nothing like that happened, he wins and earns the number of points equal to the number of chips he managed to put on the board. Help Gerald earn the most points.
Input
The first line contains two space-separated integers n and m (2 ≤ n ≤ 1000, 0 ≤ m ≤ 105) — the size of the field and the number of banned cells. Next m lines each contain two space-separated integers. Specifically, the i-th of these lines contains numbers xi and yi (1 ≤ xi, yi ≤ n) — the coordinates of the i-th banned cell. All given cells are distinct.
Consider the field rows numbered from top to bottom from 1 to n, and the columns — from left to right from 1 to n.
Output
Print a single integer — the maximum points Gerald can earn in this game.
Examples
Input
3 1
2 2
Output
0
Input
3 0
Output
1
Input
4 3
3 1
3 2
3 3
Output
1
Note
In the first test the answer equals zero as we can't put chips into the corner cells.
In the second sample we can place one chip into either cell (1, 2), or cell (3, 2), or cell (2, 1), or cell (2, 3). We cannot place two chips.
In the third sample we can only place one chip into either cell (2, 1), or cell (2, 4).
Submitted Solution:
```
n, m = tuple(map(int, input().split(' ')))
vb = set()
hb = set()
for k in range(m):
i, j = tuple(map(int, input().split(' ')))
hb.add(i-1)
vb.add(j-1)
c = 0
for i in range(1, n//2):
c += 1 if i not in hb else 0
c += 1 if n-i-1 not in hb else 0
c += 1 if i not in vb else 0
c += 1 if n-i-1 not in vb else 0
c += 1 if n%2==1 and (n//2+1 not in hb or n//2+1 not in vb) else 0
print(c)
``` | instruction | 0 | 64,324 | 15 | 128,648 |
No | output | 1 | 64,324 | 15 | 128,649 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gerald plays the following game. He has a checkered field of size n × n cells, where m various cells are banned. Before the game, he has to put a few chips on some border (but not corner) board cells. Then for n - 1 minutes, Gerald every minute moves each chip into an adjacent cell. He moves each chip from its original edge to the opposite edge. Gerald loses in this game in each of the three cases:
* At least one of the chips at least once fell to the banned cell.
* At least once two chips were on the same cell.
* At least once two chips swapped in a minute (for example, if you stand two chips on two opposite border cells of a row with even length, this situation happens in the middle of the row).
In that case he loses and earns 0 points. When nothing like that happened, he wins and earns the number of points equal to the number of chips he managed to put on the board. Help Gerald earn the most points.
Input
The first line contains two space-separated integers n and m (2 ≤ n ≤ 1000, 0 ≤ m ≤ 105) — the size of the field and the number of banned cells. Next m lines each contain two space-separated integers. Specifically, the i-th of these lines contains numbers xi and yi (1 ≤ xi, yi ≤ n) — the coordinates of the i-th banned cell. All given cells are distinct.
Consider the field rows numbered from top to bottom from 1 to n, and the columns — from left to right from 1 to n.
Output
Print a single integer — the maximum points Gerald can earn in this game.
Examples
Input
3 1
2 2
Output
0
Input
3 0
Output
1
Input
4 3
3 1
3 2
3 3
Output
1
Note
In the first test the answer equals zero as we can't put chips into the corner cells.
In the second sample we can place one chip into either cell (1, 2), or cell (3, 2), or cell (2, 1), or cell (2, 3). We cannot place two chips.
In the third sample we can only place one chip into either cell (2, 1), or cell (2, 4).
Submitted Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
# from fractions import *
# from heapq import*
from bisect import *
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ALPHA='abcdefghijklmnopqrstuvwxyz/'
M=1000000007
EPS=1e-6
def Ceil(a,b): return a//b+int(a%b>0)
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
# vsInput()
n,m=value()
row_blocked=defaultdict(bool)
col_blocked=defaultdict(bool)
for i in range(m):
x,y=value()
row_blocked[x]=True
col_blocked[y]=True
ans=0
for i in range(2,n):
if(not row_blocked[i]): ans+=1
if(not col_blocked[i]): ans+=1
if(n%2):
if(not row_blocked[n//2] and not col_blocked[n//2]): ans-=1
print(ans)
``` | instruction | 0 | 64,325 | 15 | 128,650 |
No | output | 1 | 64,325 | 15 | 128,651 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gerald plays the following game. He has a checkered field of size n × n cells, where m various cells are banned. Before the game, he has to put a few chips on some border (but not corner) board cells. Then for n - 1 minutes, Gerald every minute moves each chip into an adjacent cell. He moves each chip from its original edge to the opposite edge. Gerald loses in this game in each of the three cases:
* At least one of the chips at least once fell to the banned cell.
* At least once two chips were on the same cell.
* At least once two chips swapped in a minute (for example, if you stand two chips on two opposite border cells of a row with even length, this situation happens in the middle of the row).
In that case he loses and earns 0 points. When nothing like that happened, he wins and earns the number of points equal to the number of chips he managed to put on the board. Help Gerald earn the most points.
Input
The first line contains two space-separated integers n and m (2 ≤ n ≤ 1000, 0 ≤ m ≤ 105) — the size of the field and the number of banned cells. Next m lines each contain two space-separated integers. Specifically, the i-th of these lines contains numbers xi and yi (1 ≤ xi, yi ≤ n) — the coordinates of the i-th banned cell. All given cells are distinct.
Consider the field rows numbered from top to bottom from 1 to n, and the columns — from left to right from 1 to n.
Output
Print a single integer — the maximum points Gerald can earn in this game.
Examples
Input
3 1
2 2
Output
0
Input
3 0
Output
1
Input
4 3
3 1
3 2
3 3
Output
1
Note
In the first test the answer equals zero as we can't put chips into the corner cells.
In the second sample we can place one chip into either cell (1, 2), or cell (3, 2), or cell (2, 1), or cell (2, 3). We cannot place two chips.
In the third sample we can only place one chip into either cell (2, 1), or cell (2, 4).
Submitted Solution:
```
n, m = map(int, input().split())
lbad = [False for i in range(0, n)]
cbad = [False for i in range(0, n)]
lbad[0], lbad[n-1], cbad[0], cbad[n-1] = True, True, True, True
for i in range(0, m):
x, y = map(int, input().split())
lbad[x-1] = True
cbad[y-1] = True
print(max(lbad.count(False), cbad.count(False)))
``` | instruction | 0 | 64,326 | 15 | 128,652 |
No | output | 1 | 64,326 | 15 | 128,653 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gerald plays the following game. He has a checkered field of size n × n cells, where m various cells are banned. Before the game, he has to put a few chips on some border (but not corner) board cells. Then for n - 1 minutes, Gerald every minute moves each chip into an adjacent cell. He moves each chip from its original edge to the opposite edge. Gerald loses in this game in each of the three cases:
* At least one of the chips at least once fell to the banned cell.
* At least once two chips were on the same cell.
* At least once two chips swapped in a minute (for example, if you stand two chips on two opposite border cells of a row with even length, this situation happens in the middle of the row).
In that case he loses and earns 0 points. When nothing like that happened, he wins and earns the number of points equal to the number of chips he managed to put on the board. Help Gerald earn the most points.
Input
The first line contains two space-separated integers n and m (2 ≤ n ≤ 1000, 0 ≤ m ≤ 105) — the size of the field and the number of banned cells. Next m lines each contain two space-separated integers. Specifically, the i-th of these lines contains numbers xi and yi (1 ≤ xi, yi ≤ n) — the coordinates of the i-th banned cell. All given cells are distinct.
Consider the field rows numbered from top to bottom from 1 to n, and the columns — from left to right from 1 to n.
Output
Print a single integer — the maximum points Gerald can earn in this game.
Examples
Input
3 1
2 2
Output
0
Input
3 0
Output
1
Input
4 3
3 1
3 2
3 3
Output
1
Note
In the first test the answer equals zero as we can't put chips into the corner cells.
In the second sample we can place one chip into either cell (1, 2), or cell (3, 2), or cell (2, 1), or cell (2, 3). We cannot place two chips.
In the third sample we can only place one chip into either cell (2, 1), or cell (2, 4).
Submitted Solution:
```
n, m = tuple(map(int, input().split(' ')))
vb = set()
hb = set()
for k in range(m):
i, j = tuple(map(int, input().split(' ')))
hb.add(i)
vb.add(j)
c = 0
for i in range(1, n//2):
c += 1 if i not in hb else 0
c += 1 if n-i-1 not in hb else 0
c += 1 if i not in vb else 0
c += 1 if n-i-1 not in vb else 0
c += 1 if n%2==1 and (n//2+1 not in hb or n//2+1 not in vb) else 0
print(c)
``` | instruction | 0 | 64,327 | 15 | 128,654 |
No | output | 1 | 64,327 | 15 | 128,655 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After winning gold and silver in IOI 2014, Akshat and Malvika want to have some fun. Now they are playing a game on a grid made of n horizontal and m vertical sticks.
An intersection point is any point on the grid which is formed by the intersection of one horizontal stick and one vertical stick.
In the grid shown below, n = 3 and m = 3. There are n + m = 6 sticks in total (horizontal sticks are shown in red and vertical sticks are shown in green). There are n·m = 9 intersection points, numbered from 1 to 9.
<image>
The rules of the game are very simple. The players move in turns. Akshat won gold, so he makes the first move. During his/her move, a player must choose any remaining intersection point and remove from the grid all sticks which pass through this point. A player will lose the game if he/she cannot make a move (i.e. there are no intersection points remaining on the grid at his/her move).
Assume that both players play optimally. Who will win the game?
Input
The first line of input contains two space-separated integers, n and m (1 ≤ n, m ≤ 100).
Output
Print a single line containing "Akshat" or "Malvika" (without the quotes), depending on the winner of the game.
Examples
Input
2 2
Output
Malvika
Input
2 3
Output
Malvika
Input
3 3
Output
Akshat
Note
Explanation of the first sample:
The grid has four intersection points, numbered from 1 to 4.
<image>
If Akshat chooses intersection point 1, then he will remove two sticks (1 - 2 and 1 - 3). The resulting grid will look like this.
<image>
Now there is only one remaining intersection point (i.e. 4). Malvika must choose it and remove both remaining sticks. After her move the grid will be empty.
In the empty grid, Akshat cannot make any move, hence he will lose.
Since all 4 intersection points of the grid are equivalent, Akshat will lose no matter which one he picks. | instruction | 0 | 64,360 | 15 | 128,720 |
Tags: implementation
Correct Solution:
```
n, m = map(int, input().split())
step = 0
count = n * m
while count > 0:
n -= 1
m -= 1
count = n * m
step += 1
if step % 2 == 0:
print('Malvika')
else:
print('Akshat')
``` | output | 1 | 64,360 | 15 | 128,721 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After winning gold and silver in IOI 2014, Akshat and Malvika want to have some fun. Now they are playing a game on a grid made of n horizontal and m vertical sticks.
An intersection point is any point on the grid which is formed by the intersection of one horizontal stick and one vertical stick.
In the grid shown below, n = 3 and m = 3. There are n + m = 6 sticks in total (horizontal sticks are shown in red and vertical sticks are shown in green). There are n·m = 9 intersection points, numbered from 1 to 9.
<image>
The rules of the game are very simple. The players move in turns. Akshat won gold, so he makes the first move. During his/her move, a player must choose any remaining intersection point and remove from the grid all sticks which pass through this point. A player will lose the game if he/she cannot make a move (i.e. there are no intersection points remaining on the grid at his/her move).
Assume that both players play optimally. Who will win the game?
Input
The first line of input contains two space-separated integers, n and m (1 ≤ n, m ≤ 100).
Output
Print a single line containing "Akshat" or "Malvika" (without the quotes), depending on the winner of the game.
Examples
Input
2 2
Output
Malvika
Input
2 3
Output
Malvika
Input
3 3
Output
Akshat
Note
Explanation of the first sample:
The grid has four intersection points, numbered from 1 to 4.
<image>
If Akshat chooses intersection point 1, then he will remove two sticks (1 - 2 and 1 - 3). The resulting grid will look like this.
<image>
Now there is only one remaining intersection point (i.e. 4). Malvika must choose it and remove both remaining sticks. After her move the grid will be empty.
In the empty grid, Akshat cannot make any move, hence he will lose.
Since all 4 intersection points of the grid are equivalent, Akshat will lose no matter which one he picks. | instruction | 0 | 64,361 | 15 | 128,722 |
Tags: implementation
Correct Solution:
```
n,m = map(int,input().split())
k = min(n,m)
if k % 2:
print("Akshat")
else:
print("Malvika")
``` | output | 1 | 64,361 | 15 | 128,723 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After winning gold and silver in IOI 2014, Akshat and Malvika want to have some fun. Now they are playing a game on a grid made of n horizontal and m vertical sticks.
An intersection point is any point on the grid which is formed by the intersection of one horizontal stick and one vertical stick.
In the grid shown below, n = 3 and m = 3. There are n + m = 6 sticks in total (horizontal sticks are shown in red and vertical sticks are shown in green). There are n·m = 9 intersection points, numbered from 1 to 9.
<image>
The rules of the game are very simple. The players move in turns. Akshat won gold, so he makes the first move. During his/her move, a player must choose any remaining intersection point and remove from the grid all sticks which pass through this point. A player will lose the game if he/she cannot make a move (i.e. there are no intersection points remaining on the grid at his/her move).
Assume that both players play optimally. Who will win the game?
Input
The first line of input contains two space-separated integers, n and m (1 ≤ n, m ≤ 100).
Output
Print a single line containing "Akshat" or "Malvika" (without the quotes), depending on the winner of the game.
Examples
Input
2 2
Output
Malvika
Input
2 3
Output
Malvika
Input
3 3
Output
Akshat
Note
Explanation of the first sample:
The grid has four intersection points, numbered from 1 to 4.
<image>
If Akshat chooses intersection point 1, then he will remove two sticks (1 - 2 and 1 - 3). The resulting grid will look like this.
<image>
Now there is only one remaining intersection point (i.e. 4). Malvika must choose it and remove both remaining sticks. After her move the grid will be empty.
In the empty grid, Akshat cannot make any move, hence he will lose.
Since all 4 intersection points of the grid are equivalent, Akshat will lose no matter which one he picks. | instruction | 0 | 64,362 | 15 | 128,724 |
Tags: implementation
Correct Solution:
```
a,b = map(int,input().split())
z=min(a,b)
if z%2 == 0:
print("Malvika")
else:
print("Akshat")
``` | output | 1 | 64,362 | 15 | 128,725 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After winning gold and silver in IOI 2014, Akshat and Malvika want to have some fun. Now they are playing a game on a grid made of n horizontal and m vertical sticks.
An intersection point is any point on the grid which is formed by the intersection of one horizontal stick and one vertical stick.
In the grid shown below, n = 3 and m = 3. There are n + m = 6 sticks in total (horizontal sticks are shown in red and vertical sticks are shown in green). There are n·m = 9 intersection points, numbered from 1 to 9.
<image>
The rules of the game are very simple. The players move in turns. Akshat won gold, so he makes the first move. During his/her move, a player must choose any remaining intersection point and remove from the grid all sticks which pass through this point. A player will lose the game if he/she cannot make a move (i.e. there are no intersection points remaining on the grid at his/her move).
Assume that both players play optimally. Who will win the game?
Input
The first line of input contains two space-separated integers, n and m (1 ≤ n, m ≤ 100).
Output
Print a single line containing "Akshat" or "Malvika" (without the quotes), depending on the winner of the game.
Examples
Input
2 2
Output
Malvika
Input
2 3
Output
Malvika
Input
3 3
Output
Akshat
Note
Explanation of the first sample:
The grid has four intersection points, numbered from 1 to 4.
<image>
If Akshat chooses intersection point 1, then he will remove two sticks (1 - 2 and 1 - 3). The resulting grid will look like this.
<image>
Now there is only one remaining intersection point (i.e. 4). Malvika must choose it and remove both remaining sticks. After her move the grid will be empty.
In the empty grid, Akshat cannot make any move, hence he will lose.
Since all 4 intersection points of the grid are equivalent, Akshat will lose no matter which one he picks. | instruction | 0 | 64,363 | 15 | 128,726 |
Tags: implementation
Correct Solution:
```
entrada = input().split()
n1 = int(entrada[0])
n2 = int(entrada[1])
if n1>=1 and n1<=100 and n2>=1 and n2<=100:
if n1<n2:
pegar = n1
else:
pegar = n2
if pegar%2==0 and pegar!=0: #par
print('Malvika')
else:
print('Akshat')
``` | output | 1 | 64,363 | 15 | 128,727 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After winning gold and silver in IOI 2014, Akshat and Malvika want to have some fun. Now they are playing a game on a grid made of n horizontal and m vertical sticks.
An intersection point is any point on the grid which is formed by the intersection of one horizontal stick and one vertical stick.
In the grid shown below, n = 3 and m = 3. There are n + m = 6 sticks in total (horizontal sticks are shown in red and vertical sticks are shown in green). There are n·m = 9 intersection points, numbered from 1 to 9.
<image>
The rules of the game are very simple. The players move in turns. Akshat won gold, so he makes the first move. During his/her move, a player must choose any remaining intersection point and remove from the grid all sticks which pass through this point. A player will lose the game if he/she cannot make a move (i.e. there are no intersection points remaining on the grid at his/her move).
Assume that both players play optimally. Who will win the game?
Input
The first line of input contains two space-separated integers, n and m (1 ≤ n, m ≤ 100).
Output
Print a single line containing "Akshat" or "Malvika" (without the quotes), depending on the winner of the game.
Examples
Input
2 2
Output
Malvika
Input
2 3
Output
Malvika
Input
3 3
Output
Akshat
Note
Explanation of the first sample:
The grid has four intersection points, numbered from 1 to 4.
<image>
If Akshat chooses intersection point 1, then he will remove two sticks (1 - 2 and 1 - 3). The resulting grid will look like this.
<image>
Now there is only one remaining intersection point (i.e. 4). Malvika must choose it and remove both remaining sticks. After her move the grid will be empty.
In the empty grid, Akshat cannot make any move, hence he will lose.
Since all 4 intersection points of the grid are equivalent, Akshat will lose no matter which one he picks. | instruction | 0 | 64,364 | 15 | 128,728 |
Tags: implementation
Correct Solution:
```
l= input().split()
n=0
m=0
n = int(l[0])
m = int(l[1])
mini = min(n,m)
if(mini%2==0):
print("Malvika")
else:
print("Akshat")
``` | output | 1 | 64,364 | 15 | 128,729 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After winning gold and silver in IOI 2014, Akshat and Malvika want to have some fun. Now they are playing a game on a grid made of n horizontal and m vertical sticks.
An intersection point is any point on the grid which is formed by the intersection of one horizontal stick and one vertical stick.
In the grid shown below, n = 3 and m = 3. There are n + m = 6 sticks in total (horizontal sticks are shown in red and vertical sticks are shown in green). There are n·m = 9 intersection points, numbered from 1 to 9.
<image>
The rules of the game are very simple. The players move in turns. Akshat won gold, so he makes the first move. During his/her move, a player must choose any remaining intersection point and remove from the grid all sticks which pass through this point. A player will lose the game if he/she cannot make a move (i.e. there are no intersection points remaining on the grid at his/her move).
Assume that both players play optimally. Who will win the game?
Input
The first line of input contains two space-separated integers, n and m (1 ≤ n, m ≤ 100).
Output
Print a single line containing "Akshat" or "Malvika" (without the quotes), depending on the winner of the game.
Examples
Input
2 2
Output
Malvika
Input
2 3
Output
Malvika
Input
3 3
Output
Akshat
Note
Explanation of the first sample:
The grid has four intersection points, numbered from 1 to 4.
<image>
If Akshat chooses intersection point 1, then he will remove two sticks (1 - 2 and 1 - 3). The resulting grid will look like this.
<image>
Now there is only one remaining intersection point (i.e. 4). Malvika must choose it and remove both remaining sticks. After her move the grid will be empty.
In the empty grid, Akshat cannot make any move, hence he will lose.
Since all 4 intersection points of the grid are equivalent, Akshat will lose no matter which one he picks. | instruction | 0 | 64,365 | 15 | 128,730 |
Tags: implementation
Correct Solution:
```
def main():
n, m = [int(i) for i in input().split(" ")]
_ = min(n, m)
print("Malvika") if _ % 2 == 0 else print("Akshat")
if __name__ == "__main__":
main()
``` | output | 1 | 64,365 | 15 | 128,731 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After winning gold and silver in IOI 2014, Akshat and Malvika want to have some fun. Now they are playing a game on a grid made of n horizontal and m vertical sticks.
An intersection point is any point on the grid which is formed by the intersection of one horizontal stick and one vertical stick.
In the grid shown below, n = 3 and m = 3. There are n + m = 6 sticks in total (horizontal sticks are shown in red and vertical sticks are shown in green). There are n·m = 9 intersection points, numbered from 1 to 9.
<image>
The rules of the game are very simple. The players move in turns. Akshat won gold, so he makes the first move. During his/her move, a player must choose any remaining intersection point and remove from the grid all sticks which pass through this point. A player will lose the game if he/she cannot make a move (i.e. there are no intersection points remaining on the grid at his/her move).
Assume that both players play optimally. Who will win the game?
Input
The first line of input contains two space-separated integers, n and m (1 ≤ n, m ≤ 100).
Output
Print a single line containing "Akshat" or "Malvika" (without the quotes), depending on the winner of the game.
Examples
Input
2 2
Output
Malvika
Input
2 3
Output
Malvika
Input
3 3
Output
Akshat
Note
Explanation of the first sample:
The grid has four intersection points, numbered from 1 to 4.
<image>
If Akshat chooses intersection point 1, then he will remove two sticks (1 - 2 and 1 - 3). The resulting grid will look like this.
<image>
Now there is only one remaining intersection point (i.e. 4). Malvika must choose it and remove both remaining sticks. After her move the grid will be empty.
In the empty grid, Akshat cannot make any move, hence he will lose.
Since all 4 intersection points of the grid are equivalent, Akshat will lose no matter which one he picks. | instruction | 0 | 64,366 | 15 | 128,732 |
Tags: implementation
Correct Solution:
```
n, m = map(int, input().split())
print('Akshat') if (min(n,m))%2 == 1 else print('Malvika')
``` | output | 1 | 64,366 | 15 | 128,733 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After winning gold and silver in IOI 2014, Akshat and Malvika want to have some fun. Now they are playing a game on a grid made of n horizontal and m vertical sticks.
An intersection point is any point on the grid which is formed by the intersection of one horizontal stick and one vertical stick.
In the grid shown below, n = 3 and m = 3. There are n + m = 6 sticks in total (horizontal sticks are shown in red and vertical sticks are shown in green). There are n·m = 9 intersection points, numbered from 1 to 9.
<image>
The rules of the game are very simple. The players move in turns. Akshat won gold, so he makes the first move. During his/her move, a player must choose any remaining intersection point and remove from the grid all sticks which pass through this point. A player will lose the game if he/she cannot make a move (i.e. there are no intersection points remaining on the grid at his/her move).
Assume that both players play optimally. Who will win the game?
Input
The first line of input contains two space-separated integers, n and m (1 ≤ n, m ≤ 100).
Output
Print a single line containing "Akshat" or "Malvika" (without the quotes), depending on the winner of the game.
Examples
Input
2 2
Output
Malvika
Input
2 3
Output
Malvika
Input
3 3
Output
Akshat
Note
Explanation of the first sample:
The grid has four intersection points, numbered from 1 to 4.
<image>
If Akshat chooses intersection point 1, then he will remove two sticks (1 - 2 and 1 - 3). The resulting grid will look like this.
<image>
Now there is only one remaining intersection point (i.e. 4). Malvika must choose it and remove both remaining sticks. After her move the grid will be empty.
In the empty grid, Akshat cannot make any move, hence he will lose.
Since all 4 intersection points of the grid are equivalent, Akshat will lose no matter which one he picks. | instruction | 0 | 64,367 | 15 | 128,734 |
Tags: implementation
Correct Solution:
```
a,b=map(int,input().split())
c=max(a,b)
if a*b/c%2==0:
print('Malvika')
else:
print('Akshat')
``` | output | 1 | 64,367 | 15 | 128,735 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After winning gold and silver in IOI 2014, Akshat and Malvika want to have some fun. Now they are playing a game on a grid made of n horizontal and m vertical sticks.
An intersection point is any point on the grid which is formed by the intersection of one horizontal stick and one vertical stick.
In the grid shown below, n = 3 and m = 3. There are n + m = 6 sticks in total (horizontal sticks are shown in red and vertical sticks are shown in green). There are n·m = 9 intersection points, numbered from 1 to 9.
<image>
The rules of the game are very simple. The players move in turns. Akshat won gold, so he makes the first move. During his/her move, a player must choose any remaining intersection point and remove from the grid all sticks which pass through this point. A player will lose the game if he/she cannot make a move (i.e. there are no intersection points remaining on the grid at his/her move).
Assume that both players play optimally. Who will win the game?
Input
The first line of input contains two space-separated integers, n and m (1 ≤ n, m ≤ 100).
Output
Print a single line containing "Akshat" or "Malvika" (without the quotes), depending on the winner of the game.
Examples
Input
2 2
Output
Malvika
Input
2 3
Output
Malvika
Input
3 3
Output
Akshat
Note
Explanation of the first sample:
The grid has four intersection points, numbered from 1 to 4.
<image>
If Akshat chooses intersection point 1, then he will remove two sticks (1 - 2 and 1 - 3). The resulting grid will look like this.
<image>
Now there is only one remaining intersection point (i.e. 4). Malvika must choose it and remove both remaining sticks. After her move the grid will be empty.
In the empty grid, Akshat cannot make any move, hence he will lose.
Since all 4 intersection points of the grid are equivalent, Akshat will lose no matter which one he picks.
Submitted Solution:
```
z,zz=input,lambda:list(map(int,z().split()))
zzz=lambda:[int(i) for i in stdin.readline().split()]
szz,graph,mod,szzz=lambda:sorted(zz()),{},10**9+7,lambda:sorted(zzz())
from string import *
from re import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac
def lcd(xnum1,xnum2):return (xnum1*xnum2//gcd(xnum1,xnum2))
def prime(x):
p=ceil(x**.5)+1
for i in range(2,p):
if (x%i==0 and x!=2) or x==0:return 0
return 1
def dfs(u,visit,graph):
visit[u]=True
for i in graph[u]:
if not visit[i]:
dfs(i,visit,graph)
###########################---Test-Case---#################################
"""
"""
###########################---START-CODING---##############################
print('Malvika' if min(zz())&1==0 else 'Akshat')
``` | instruction | 0 | 64,368 | 15 | 128,736 |
Yes | output | 1 | 64,368 | 15 | 128,737 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After winning gold and silver in IOI 2014, Akshat and Malvika want to have some fun. Now they are playing a game on a grid made of n horizontal and m vertical sticks.
An intersection point is any point on the grid which is formed by the intersection of one horizontal stick and one vertical stick.
In the grid shown below, n = 3 and m = 3. There are n + m = 6 sticks in total (horizontal sticks are shown in red and vertical sticks are shown in green). There are n·m = 9 intersection points, numbered from 1 to 9.
<image>
The rules of the game are very simple. The players move in turns. Akshat won gold, so he makes the first move. During his/her move, a player must choose any remaining intersection point and remove from the grid all sticks which pass through this point. A player will lose the game if he/she cannot make a move (i.e. there are no intersection points remaining on the grid at his/her move).
Assume that both players play optimally. Who will win the game?
Input
The first line of input contains two space-separated integers, n and m (1 ≤ n, m ≤ 100).
Output
Print a single line containing "Akshat" or "Malvika" (without the quotes), depending on the winner of the game.
Examples
Input
2 2
Output
Malvika
Input
2 3
Output
Malvika
Input
3 3
Output
Akshat
Note
Explanation of the first sample:
The grid has four intersection points, numbered from 1 to 4.
<image>
If Akshat chooses intersection point 1, then he will remove two sticks (1 - 2 and 1 - 3). The resulting grid will look like this.
<image>
Now there is only one remaining intersection point (i.e. 4). Malvika must choose it and remove both remaining sticks. After her move the grid will be empty.
In the empty grid, Akshat cannot make any move, hence he will lose.
Since all 4 intersection points of the grid are equivalent, Akshat will lose no matter which one he picks.
Submitted Solution:
```
n, m = map(int, input().split())
print("Malvika" if (min(n, m)) % 2 == 0 else "Akshat")
``` | instruction | 0 | 64,369 | 15 | 128,738 |
Yes | output | 1 | 64,369 | 15 | 128,739 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After winning gold and silver in IOI 2014, Akshat and Malvika want to have some fun. Now they are playing a game on a grid made of n horizontal and m vertical sticks.
An intersection point is any point on the grid which is formed by the intersection of one horizontal stick and one vertical stick.
In the grid shown below, n = 3 and m = 3. There are n + m = 6 sticks in total (horizontal sticks are shown in red and vertical sticks are shown in green). There are n·m = 9 intersection points, numbered from 1 to 9.
<image>
The rules of the game are very simple. The players move in turns. Akshat won gold, so he makes the first move. During his/her move, a player must choose any remaining intersection point and remove from the grid all sticks which pass through this point. A player will lose the game if he/she cannot make a move (i.e. there are no intersection points remaining on the grid at his/her move).
Assume that both players play optimally. Who will win the game?
Input
The first line of input contains two space-separated integers, n and m (1 ≤ n, m ≤ 100).
Output
Print a single line containing "Akshat" or "Malvika" (without the quotes), depending on the winner of the game.
Examples
Input
2 2
Output
Malvika
Input
2 3
Output
Malvika
Input
3 3
Output
Akshat
Note
Explanation of the first sample:
The grid has four intersection points, numbered from 1 to 4.
<image>
If Akshat chooses intersection point 1, then he will remove two sticks (1 - 2 and 1 - 3). The resulting grid will look like this.
<image>
Now there is only one remaining intersection point (i.e. 4). Malvika must choose it and remove both remaining sticks. After her move the grid will be empty.
In the empty grid, Akshat cannot make any move, hence he will lose.
Since all 4 intersection points of the grid are equivalent, Akshat will lose no matter which one he picks.
Submitted Solution:
```
a, b = map(int , input().split(' '))
if min(a, b) % 2 == 0:
print('Malvika')
else:
print('Akshat')
``` | instruction | 0 | 64,370 | 15 | 128,740 |
Yes | output | 1 | 64,370 | 15 | 128,741 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After winning gold and silver in IOI 2014, Akshat and Malvika want to have some fun. Now they are playing a game on a grid made of n horizontal and m vertical sticks.
An intersection point is any point on the grid which is formed by the intersection of one horizontal stick and one vertical stick.
In the grid shown below, n = 3 and m = 3. There are n + m = 6 sticks in total (horizontal sticks are shown in red and vertical sticks are shown in green). There are n·m = 9 intersection points, numbered from 1 to 9.
<image>
The rules of the game are very simple. The players move in turns. Akshat won gold, so he makes the first move. During his/her move, a player must choose any remaining intersection point and remove from the grid all sticks which pass through this point. A player will lose the game if he/she cannot make a move (i.e. there are no intersection points remaining on the grid at his/her move).
Assume that both players play optimally. Who will win the game?
Input
The first line of input contains two space-separated integers, n and m (1 ≤ n, m ≤ 100).
Output
Print a single line containing "Akshat" or "Malvika" (without the quotes), depending on the winner of the game.
Examples
Input
2 2
Output
Malvika
Input
2 3
Output
Malvika
Input
3 3
Output
Akshat
Note
Explanation of the first sample:
The grid has four intersection points, numbered from 1 to 4.
<image>
If Akshat chooses intersection point 1, then he will remove two sticks (1 - 2 and 1 - 3). The resulting grid will look like this.
<image>
Now there is only one remaining intersection point (i.e. 4). Malvika must choose it and remove both remaining sticks. After her move the grid will be empty.
In the empty grid, Akshat cannot make any move, hence he will lose.
Since all 4 intersection points of the grid are equivalent, Akshat will lose no matter which one he picks.
Submitted Solution:
```
a,b = map(int, input().split())
while a>=b:
if b%2==0:
print("Malvika")
else:
print("Akshat")
break
while b>a:
if a%2==0:
print("Malvika")
else:
print("Akshat")
break
``` | instruction | 0 | 64,371 | 15 | 128,742 |
Yes | output | 1 | 64,371 | 15 | 128,743 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After winning gold and silver in IOI 2014, Akshat and Malvika want to have some fun. Now they are playing a game on a grid made of n horizontal and m vertical sticks.
An intersection point is any point on the grid which is formed by the intersection of one horizontal stick and one vertical stick.
In the grid shown below, n = 3 and m = 3. There are n + m = 6 sticks in total (horizontal sticks are shown in red and vertical sticks are shown in green). There are n·m = 9 intersection points, numbered from 1 to 9.
<image>
The rules of the game are very simple. The players move in turns. Akshat won gold, so he makes the first move. During his/her move, a player must choose any remaining intersection point and remove from the grid all sticks which pass through this point. A player will lose the game if he/she cannot make a move (i.e. there are no intersection points remaining on the grid at his/her move).
Assume that both players play optimally. Who will win the game?
Input
The first line of input contains two space-separated integers, n and m (1 ≤ n, m ≤ 100).
Output
Print a single line containing "Akshat" or "Malvika" (without the quotes), depending on the winner of the game.
Examples
Input
2 2
Output
Malvika
Input
2 3
Output
Malvika
Input
3 3
Output
Akshat
Note
Explanation of the first sample:
The grid has four intersection points, numbered from 1 to 4.
<image>
If Akshat chooses intersection point 1, then he will remove two sticks (1 - 2 and 1 - 3). The resulting grid will look like this.
<image>
Now there is only one remaining intersection point (i.e. 4). Malvika must choose it and remove both remaining sticks. After her move the grid will be empty.
In the empty grid, Akshat cannot make any move, hence he will lose.
Since all 4 intersection points of the grid are equivalent, Akshat will lose no matter which one he picks.
Submitted Solution:
```
a,b=map(int,input().split())
if(a==1 or b==1):
print("Akshat")
elif((a*b)%2==0):
print("Malvika")
else:
print("Akshat")
``` | instruction | 0 | 64,372 | 15 | 128,744 |
No | output | 1 | 64,372 | 15 | 128,745 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After winning gold and silver in IOI 2014, Akshat and Malvika want to have some fun. Now they are playing a game on a grid made of n horizontal and m vertical sticks.
An intersection point is any point on the grid which is formed by the intersection of one horizontal stick and one vertical stick.
In the grid shown below, n = 3 and m = 3. There are n + m = 6 sticks in total (horizontal sticks are shown in red and vertical sticks are shown in green). There are n·m = 9 intersection points, numbered from 1 to 9.
<image>
The rules of the game are very simple. The players move in turns. Akshat won gold, so he makes the first move. During his/her move, a player must choose any remaining intersection point and remove from the grid all sticks which pass through this point. A player will lose the game if he/she cannot make a move (i.e. there are no intersection points remaining on the grid at his/her move).
Assume that both players play optimally. Who will win the game?
Input
The first line of input contains two space-separated integers, n and m (1 ≤ n, m ≤ 100).
Output
Print a single line containing "Akshat" or "Malvika" (without the quotes), depending on the winner of the game.
Examples
Input
2 2
Output
Malvika
Input
2 3
Output
Malvika
Input
3 3
Output
Akshat
Note
Explanation of the first sample:
The grid has four intersection points, numbered from 1 to 4.
<image>
If Akshat chooses intersection point 1, then he will remove two sticks (1 - 2 and 1 - 3). The resulting grid will look like this.
<image>
Now there is only one remaining intersection point (i.e. 4). Malvika must choose it and remove both remaining sticks. After her move the grid will be empty.
In the empty grid, Akshat cannot make any move, hence he will lose.
Since all 4 intersection points of the grid are equivalent, Akshat will lose no matter which one he picks.
Submitted Solution:
```
n, m = map(int, input().
split())
number_of_points = n * m
if number_of_points % 2 == 0:
print("Malvika")
else:
print("Akshat")
``` | instruction | 0 | 64,373 | 15 | 128,746 |
No | output | 1 | 64,373 | 15 | 128,747 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After winning gold and silver in IOI 2014, Akshat and Malvika want to have some fun. Now they are playing a game on a grid made of n horizontal and m vertical sticks.
An intersection point is any point on the grid which is formed by the intersection of one horizontal stick and one vertical stick.
In the grid shown below, n = 3 and m = 3. There are n + m = 6 sticks in total (horizontal sticks are shown in red and vertical sticks are shown in green). There are n·m = 9 intersection points, numbered from 1 to 9.
<image>
The rules of the game are very simple. The players move in turns. Akshat won gold, so he makes the first move. During his/her move, a player must choose any remaining intersection point and remove from the grid all sticks which pass through this point. A player will lose the game if he/she cannot make a move (i.e. there are no intersection points remaining on the grid at his/her move).
Assume that both players play optimally. Who will win the game?
Input
The first line of input contains two space-separated integers, n and m (1 ≤ n, m ≤ 100).
Output
Print a single line containing "Akshat" or "Malvika" (without the quotes), depending on the winner of the game.
Examples
Input
2 2
Output
Malvika
Input
2 3
Output
Malvika
Input
3 3
Output
Akshat
Note
Explanation of the first sample:
The grid has four intersection points, numbered from 1 to 4.
<image>
If Akshat chooses intersection point 1, then he will remove two sticks (1 - 2 and 1 - 3). The resulting grid will look like this.
<image>
Now there is only one remaining intersection point (i.e. 4). Malvika must choose it and remove both remaining sticks. After her move the grid will be empty.
In the empty grid, Akshat cannot make any move, hence he will lose.
Since all 4 intersection points of the grid are equivalent, Akshat will lose no matter which one he picks.
Submitted Solution:
```
from sys import*
input= stdin.readline
a,b=map(int,input().split())
if(a%2!=0):
print("Akshat")
else:
print("Malvika")
``` | instruction | 0 | 64,374 | 15 | 128,748 |
No | output | 1 | 64,374 | 15 | 128,749 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After winning gold and silver in IOI 2014, Akshat and Malvika want to have some fun. Now they are playing a game on a grid made of n horizontal and m vertical sticks.
An intersection point is any point on the grid which is formed by the intersection of one horizontal stick and one vertical stick.
In the grid shown below, n = 3 and m = 3. There are n + m = 6 sticks in total (horizontal sticks are shown in red and vertical sticks are shown in green). There are n·m = 9 intersection points, numbered from 1 to 9.
<image>
The rules of the game are very simple. The players move in turns. Akshat won gold, so he makes the first move. During his/her move, a player must choose any remaining intersection point and remove from the grid all sticks which pass through this point. A player will lose the game if he/she cannot make a move (i.e. there are no intersection points remaining on the grid at his/her move).
Assume that both players play optimally. Who will win the game?
Input
The first line of input contains two space-separated integers, n and m (1 ≤ n, m ≤ 100).
Output
Print a single line containing "Akshat" or "Malvika" (without the quotes), depending on the winner of the game.
Examples
Input
2 2
Output
Malvika
Input
2 3
Output
Malvika
Input
3 3
Output
Akshat
Note
Explanation of the first sample:
The grid has four intersection points, numbered from 1 to 4.
<image>
If Akshat chooses intersection point 1, then he will remove two sticks (1 - 2 and 1 - 3). The resulting grid will look like this.
<image>
Now there is only one remaining intersection point (i.e. 4). Malvika must choose it and remove both remaining sticks. After her move the grid will be empty.
In the empty grid, Akshat cannot make any move, hence he will lose.
Since all 4 intersection points of the grid are equivalent, Akshat will lose no matter which one he picks.
Submitted Solution:
```
n,m=map(int,input().split())
t=n*m
if (t%2==0):
print("Malvika")
else:
print("Akshat")
``` | instruction | 0 | 64,375 | 15 | 128,750 |
No | output | 1 | 64,375 | 15 | 128,751 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob play 5-in-a-row game. They have a playing field of size 10 × 10. In turns they put either crosses or noughts, one at a time. Alice puts crosses and Bob puts noughts.
In current match they have made some turns and now it's Alice's turn. She wonders if she can put cross in such empty cell that she wins immediately.
Alice wins if some crosses in the field form line of length not smaller than 5. This line can be horizontal, vertical and diagonal.
Input
You are given matrix 10 × 10 (10 lines of 10 characters each) with capital Latin letters 'X' being a cross, letters 'O' being a nought and '.' being an empty cell. The number of 'X' cells is equal to the number of 'O' cells and there is at least one of each type. There is at least one empty cell.
It is guaranteed that in the current arrangement nobody has still won.
Output
Print 'YES' if it's possible for Alice to win in one turn by putting cross in some empty cell. Otherwise print 'NO'.
Examples
Input
XX.XX.....
.....OOOO.
..........
..........
..........
..........
..........
..........
..........
..........
Output
YES
Input
XXOXX.....
OO.O......
..........
..........
..........
..........
..........
..........
..........
..........
Output
NO | instruction | 0 | 64,505 | 15 | 129,010 |
Tags: brute force, implementation
Correct Solution:
```
mat1=[input() for l in range(10)]
mat2=list(reversed(mat1))
mat3=[]
for l in mat1:
mat3.append(l[::-1])
def horizontal(inp,i,j):
s=''
for k in range(j, j+5):
s=s+inp[i][k]
return s
def vertical(inp,i, j):
s=''
for k in range(i, i+5):
s=s+inp[k][j]
return s
def diagonal(inp,i,j):
first=range(i,i+5,1)
second=range(j,j+5,1)
s=''
for k, l in zip(first, second):
s+=inp[k][l]
return s
def checker(s):
if '0' in s:
return False
else:
if s.count('X')<4:
return False
else:
if '.' not in s:
return False
return True
def solve(mat):
for i in range(6):
for j in range(6):
if (checker(horizontal(mat,i, j))):
return True
if (checker(vertical(mat,i,j))):
return True
if checker(diagonal(mat,i,j)):
return True
return False
a=solve(mat1)
b=solve(mat2)
c=solve(mat3)
if a or b or c:
print("YES")
else:
print("NO")
``` | output | 1 | 64,505 | 15 | 129,011 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob play 5-in-a-row game. They have a playing field of size 10 × 10. In turns they put either crosses or noughts, one at a time. Alice puts crosses and Bob puts noughts.
In current match they have made some turns and now it's Alice's turn. She wonders if she can put cross in such empty cell that she wins immediately.
Alice wins if some crosses in the field form line of length not smaller than 5. This line can be horizontal, vertical and diagonal.
Input
You are given matrix 10 × 10 (10 lines of 10 characters each) with capital Latin letters 'X' being a cross, letters 'O' being a nought and '.' being an empty cell. The number of 'X' cells is equal to the number of 'O' cells and there is at least one of each type. There is at least one empty cell.
It is guaranteed that in the current arrangement nobody has still won.
Output
Print 'YES' if it's possible for Alice to win in one turn by putting cross in some empty cell. Otherwise print 'NO'.
Examples
Input
XX.XX.....
.....OOOO.
..........
..........
..........
..........
..........
..........
..........
..........
Output
YES
Input
XXOXX.....
OO.O......
..........
..........
..........
..........
..........
..........
..........
..........
Output
NO | instruction | 0 | 64,506 | 15 | 129,012 |
Tags: brute force, implementation
Correct Solution:
```
l = [input() for _ in range(10)]
for c in range(5):
t = ['X'] * 5
t[c] = '.'
for i in range(10):
for j in range(6):
cnt = 0
for k in range(5):
if l[i][j + k] == '.':
cnt += 1
elif l[i][j + k] == 'O':
cnt += 2
if cnt == 1:
print('YES')
exit()
for i in range(6):
for j in range(10):
cnt = 0
for k in range(5):
if l[i + k][j] == '.':
cnt += 1
elif l[i + k][j] == 'O':
cnt += 2
if cnt == 1:
print('YES')
exit()
for i in range(6):
for j in range(6):
cnt = 0
for k in range(5):
if l[i + k][j + k] == '.':
cnt += 1
elif l[i + k][j + k] == 'O':
cnt += 2
if cnt == 1:
print('YES')
exit()
for i in range(4, 10):
for j in range(6):
cnt = 0
for k in range(5):
if l[i - k][j + k] == '.':
cnt += 1
elif l[i - k][j + k] == 'O':
cnt += 2
if cnt == 1:
print('YES')
exit()
print('NO')
``` | output | 1 | 64,506 | 15 | 129,013 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob play 5-in-a-row game. They have a playing field of size 10 × 10. In turns they put either crosses or noughts, one at a time. Alice puts crosses and Bob puts noughts.
In current match they have made some turns and now it's Alice's turn. She wonders if she can put cross in such empty cell that she wins immediately.
Alice wins if some crosses in the field form line of length not smaller than 5. This line can be horizontal, vertical and diagonal.
Input
You are given matrix 10 × 10 (10 lines of 10 characters each) with capital Latin letters 'X' being a cross, letters 'O' being a nought and '.' being an empty cell. The number of 'X' cells is equal to the number of 'O' cells and there is at least one of each type. There is at least one empty cell.
It is guaranteed that in the current arrangement nobody has still won.
Output
Print 'YES' if it's possible for Alice to win in one turn by putting cross in some empty cell. Otherwise print 'NO'.
Examples
Input
XX.XX.....
.....OOOO.
..........
..........
..........
..........
..........
..........
..........
..........
Output
YES
Input
XXOXX.....
OO.O......
..........
..........
..........
..........
..........
..........
..........
..........
Output
NO | instruction | 0 | 64,507 | 15 | 129,014 |
Tags: brute force, implementation
Correct Solution:
```
m = []
for x in range(10):
m.append(input())
t = False
for y in range(10):
for x in range(10):
if(x<6):
if(m[y][x+1] == m[y][x+2] == m[y][x+3] == m[y][x+4]=="X" and m[y][x]!="O"):
t = True
break
if(x>0 and x<7):
if(m[y][x-1] == m[y][x+1] == m[y][x+2] == m[y][x+3]=="X" and m[y][x]!="O"):
t = True
break
if(x>1 and x<8):
if(m[y][x-1] == m[y][x-2] == m[y][x+1] == m[y][x+2]=="X" and m[y][x]!="O"):
t = True
break
if(x>2 and x<9):
if(m[y][x-1] == m[y][x-2] == m[y][x-3] == m[y][x+1]=="X" and m[y][x]!="O"):
t = True
break
if(x>3):
if(m[y][x-1] == m[y][x-2] == m[y][x-3] == m[y][x-4]=="X" and m[y][x]!="O"):
t = True
break
if(x<6 and y <6):
if( m[y][x]!="O" and m[y+1][x+1] == m[y+2][x+2] == m[y+3][x+3] == m[y+4][x+4]=="X"):
t = True
break
if(x<7 and y <7 and x>0 and y >0):
if( m[y][x]!="O" and m[y-1][x-1] == m[y+1][x+1] == m[y+2][x+2] == m[y+3][x+3]=="X"):
t = True
break
if(x<8 and y <8 and x>1 and y >1):
if( m[y][x]!="O" and m[y-1][x-1] == m[y-2][x-2] == m[y+1][x+1] == m[y+2][x+2]=="X"):
t = True
break
if(x<9 and y <9 and x>2 and y >2):
if( m[y][x]!="O" and m[y-1][x-1] == m[y-2][x-2] == m[y-3][x-3] == m[y+1][x+1]=="X"):
t = True
break
if(x>3 and y >3):
if( m[y][x]!="O" and m[y-1][x-1] == m[y-2][x-2] == m[y-3][x-3] == m[y-4][x-4]=="X"):
t = True
break
if(x > 3 and y < 6):
if( m[y][x]!="O" and m[y+1][x-1] == m[y+2][x-2] == m[y+3][x-3] == m[y+4][x-4]=="X"):
t = True
break
if(x>2 and y <7 and x<9 and y >0):
if( m[y][x]!="O" and m[y-1][x+1] == m[y+1][x-1] == m[y+2][x-2] == m[y+3][x-3]=="X"):
t = True
break
if(x>1 and y <8 and x<8 and y >1):
if( m[y][x]!="O" and m[y+1][x-1] == m[y+2][x-2] == m[y-1][x+1] == m[y-2][x+2]=="X"):
t = True
break
if(x>0 and y <9 and x<7 and y >2):
if( m[y][x]!="O" and m[y+1][x-1] == m[y-1][x+1] == m[y-2][x+2] == m[y-3][x+3]=="X"):
t = True
break
if(x<6 and y >3):
if( m[y][x]!="O" and m[y-1][x+1] == m[y-2][x+2] == m[y-3][x+3] == m[y-4][x+4]=="X"):
t = True
break
if(y<6):
if(m[y+1][x] == m[y+2][x] == m[y+3][x] == m[y+4][x]=="X" and m[y][x]!="O"):
t = True
break
if(y>0 and y<7):
if(m[y-1][x] == m[y+1][x] == m[y+2][x] == m[y+3][x]=="X" and m[y][x]!="O"):
t = True
break
if(y>1 and y<8):
if(m[y-1][x] == m[y-2][x] == m[y+1][x] == m[y+2][x]=="X" and m[y][x]!="O"):
t = True
break
if(y>2 and y<9):
if(m[y-1][x] == m[y-2][x] == m[y-3][x] == m[y+1][x]=="X" and m[y][x]!="O"):
t = True
break
if(y>3):
if(m[y-1][x] == m[y-2][x] == m[y-3][x] == m[y-4][x]=="X" and m[y][x]!="O"):
t = True
break
if(t==False):
print("NO")
else:
print("YES")
``` | output | 1 | 64,507 | 15 | 129,015 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob play 5-in-a-row game. They have a playing field of size 10 × 10. In turns they put either crosses or noughts, one at a time. Alice puts crosses and Bob puts noughts.
In current match they have made some turns and now it's Alice's turn. She wonders if she can put cross in such empty cell that she wins immediately.
Alice wins if some crosses in the field form line of length not smaller than 5. This line can be horizontal, vertical and diagonal.
Input
You are given matrix 10 × 10 (10 lines of 10 characters each) with capital Latin letters 'X' being a cross, letters 'O' being a nought and '.' being an empty cell. The number of 'X' cells is equal to the number of 'O' cells and there is at least one of each type. There is at least one empty cell.
It is guaranteed that in the current arrangement nobody has still won.
Output
Print 'YES' if it's possible for Alice to win in one turn by putting cross in some empty cell. Otherwise print 'NO'.
Examples
Input
XX.XX.....
.....OOOO.
..........
..........
..........
..........
..........
..........
..........
..........
Output
YES
Input
XXOXX.....
OO.O......
..........
..........
..........
..........
..........
..........
..........
..........
Output
NO | instruction | 0 | 64,508 | 15 | 129,016 |
Tags: brute force, implementation
Correct Solution:
```
a=[]
f=False
for i in range(10):
s=input()
a.append(s)
if s.find('XXXX.')!=-1 or s.find('XXX.X')!=-1 or s.find('XX.XX')!=-1 or s.find('X.XXX')!=-1 or s.find('.XXXX')!=-1:
f=True
for i in range(10):
s=''
for j in range(10):
s+=a[j][i]
if s.find('XXXX.')!=-1 or s.find('XXX.X')!=-1 or s.find('XX.XX')!=-1 or s.find('X.XXX')!=-1 or s.find('.XXXX')!=-1:
f=True
for k in range(10):
s=''
for i in range(k+1):
s+=a[i][k-i]
if s.find('XXXX.')!=-1 or s.find('XXX.X')!=-1 or s.find('XX.XX')!=-1 or s.find('X.XXX')!=-1 or s.find('.XXXX')!=-1:
f=True
for k in range(10,19):
s=''
for i in range(k-9,10):
s+=a[i][k-i]
if s.find('XXXX.')!=-1 or s.find('XXX.X')!=-1 or s.find('XX.XX')!=-1 or s.find('X.XXX')!=-1 or s.find('.XXXX')!=-1:
f=True
for k in range(-9,0):
s=''
for i in range(k+10):
s+=a[i][i-k]
if s.find('XXXX.')!=-1 or s.find('XXX.X')!=-1 or s.find('XX.XX')!=-1 or s.find('X.XXX')!=-1 or s.find('.XXXX')!=-1:
f=True
for k in range(10):
s=''
for i in range(k,10):
s+=a[i][i-k]
if s.find('XXXX.')!=-1 or s.find('XXX.X')!=-1 or s.find('XX.XX')!=-1 or s.find('X.XXX')!=-1 or s.find('.XXXX')!=-1:
f=True
if f:
print('YES')
else:
print('NO')
``` | output | 1 | 64,508 | 15 | 129,017 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob play 5-in-a-row game. They have a playing field of size 10 × 10. In turns they put either crosses or noughts, one at a time. Alice puts crosses and Bob puts noughts.
In current match they have made some turns and now it's Alice's turn. She wonders if she can put cross in such empty cell that she wins immediately.
Alice wins if some crosses in the field form line of length not smaller than 5. This line can be horizontal, vertical and diagonal.
Input
You are given matrix 10 × 10 (10 lines of 10 characters each) with capital Latin letters 'X' being a cross, letters 'O' being a nought and '.' being an empty cell. The number of 'X' cells is equal to the number of 'O' cells and there is at least one of each type. There is at least one empty cell.
It is guaranteed that in the current arrangement nobody has still won.
Output
Print 'YES' if it's possible for Alice to win in one turn by putting cross in some empty cell. Otherwise print 'NO'.
Examples
Input
XX.XX.....
.....OOOO.
..........
..........
..........
..........
..........
..........
..........
..........
Output
YES
Input
XXOXX.....
OO.O......
..........
..........
..........
..........
..........
..........
..........
..........
Output
NO | instruction | 0 | 64,509 | 15 | 129,018 |
Tags: brute force, implementation
Correct Solution:
```
def din(matx):
for i in range(10):
for j in range(10) :
dd=False
x=[[i,j],[i-1,j-1],[i-2,j-2],[i-3,j-3],[i-4,j-4]]
for p in x:
if p[0]>9 or p[0]<0 or p[1]>9 or p[1]<0:
dd=True
break
if not dd:
c=0
for p in x:
if matx[p[0]][p[1]]=='X':
c+=1
if matx[p[0]][p[1]]=='O':
c=0
break
if c==4:
return True
return False
def dix(matx):
for i in range(10):
for j in range(10):
dd = False
x = [[i, j], [i + 1, j - 1], [i + 2, j - 2], [i + 3, j - 3], [i + 4, j - 4]]
for p in x:
if p[0] > 9 or p[0] < 0 or p[1] > 9 or p[1] < 0:
dd = True
break
if not dd:
c = 0
for p in x:
if matx[p[0]][p[1]] == 'X':
c += 1
if matx[p[0]][p[1]] == 'O':
c = 0
break
if c == 4:
return True
return False
def hoz(matx):
for i in range(10):
for j in range(10) :
dd=False
x=[[i,j],[i,j-1],[i,j-2],[i,j-3],[i,j-4]]
for p in x:
if p[0]>9 or p[0]<0 or p[1]>9 or p[1]<0:
dd=True
break
if not dd:
c=0
for p in x:
if matx[p[0]][p[1]]=='X':
c+=1
if matx[p[0]][p[1]]=='O':
c=0
break
if c==4:
return True
return False
def vet(matx):
for i in range(10):
for j in range(10) :
dd=False
x=[[i,j],[i-1,j],[i-4,j],[i-3,j],[i-2,j]]
for p in x:
if p[0]>9 or p[0]<0 or p[1]>9 or p[1]<0:
dd=True
break
if not dd:
c=0
for p in x:
if matx[p[0]][p[1]]=='X':
c+=1
if matx[p[0]][p[1]]=='O':
c=0
break
if c==4:
return True
return False
matx=[list(input().strip()) for i in range(10) ]
#rint(din(matx))
if vet(matx)|hoz(matx)|din(matx)|dix(matx):
print('YES')
else:
print('NO')
``` | output | 1 | 64,509 | 15 | 129,019 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob play 5-in-a-row game. They have a playing field of size 10 × 10. In turns they put either crosses or noughts, one at a time. Alice puts crosses and Bob puts noughts.
In current match they have made some turns and now it's Alice's turn. She wonders if she can put cross in such empty cell that she wins immediately.
Alice wins if some crosses in the field form line of length not smaller than 5. This line can be horizontal, vertical and diagonal.
Input
You are given matrix 10 × 10 (10 lines of 10 characters each) with capital Latin letters 'X' being a cross, letters 'O' being a nought and '.' being an empty cell. The number of 'X' cells is equal to the number of 'O' cells and there is at least one of each type. There is at least one empty cell.
It is guaranteed that in the current arrangement nobody has still won.
Output
Print 'YES' if it's possible for Alice to win in one turn by putting cross in some empty cell. Otherwise print 'NO'.
Examples
Input
XX.XX.....
.....OOOO.
..........
..........
..........
..........
..........
..........
..........
..........
Output
YES
Input
XXOXX.....
OO.O......
..........
..........
..........
..........
..........
..........
..........
..........
Output
NO | instruction | 0 | 64,510 | 15 | 129,020 |
Tags: brute force, implementation
Correct Solution:
```
a=[ [x for x in input()] for i in range(10) ]
def f():
global a
for i in range(10):
for j in range(6):
q=0
for k in range(5):
q+=int(a[i][j+k]=='X')
if(q==5):
return(1)
for j in range(10):
for i in range(6):
q=0
for k in range(5):
q+=int(a[i+k][j]=='X')
if(q==5):
return(1)
for i in range(6):
for j in range(6):
q=0
for k in range(5):
q+=int(a[i+k][j+k]=='X')
if(q==5):
return(1)
return(0)
fl=0
for i in range(10):
for j in range(10):
if(a[i][j]=='.'):
a[i][j]='X'
if(f()):
fl=1
a[i][j]='.'
for i in range(10):
a[i]=list(reversed(a[i]))
for i in range(10):
for j in range(10):
if(a[i][j]=='.'):
a[i][j]='X'
if(f()):
fl=1
a[i][j]='.'
if(fl):
print("YES")
else:
print("NO")
``` | output | 1 | 64,510 | 15 | 129,021 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob play 5-in-a-row game. They have a playing field of size 10 × 10. In turns they put either crosses or noughts, one at a time. Alice puts crosses and Bob puts noughts.
In current match they have made some turns and now it's Alice's turn. She wonders if she can put cross in such empty cell that she wins immediately.
Alice wins if some crosses in the field form line of length not smaller than 5. This line can be horizontal, vertical and diagonal.
Input
You are given matrix 10 × 10 (10 lines of 10 characters each) with capital Latin letters 'X' being a cross, letters 'O' being a nought and '.' being an empty cell. The number of 'X' cells is equal to the number of 'O' cells and there is at least one of each type. There is at least one empty cell.
It is guaranteed that in the current arrangement nobody has still won.
Output
Print 'YES' if it's possible for Alice to win in one turn by putting cross in some empty cell. Otherwise print 'NO'.
Examples
Input
XX.XX.....
.....OOOO.
..........
..........
..........
..........
..........
..........
..........
..........
Output
YES
Input
XXOXX.....
OO.O......
..........
..........
..........
..........
..........
..........
..........
..........
Output
NO | instruction | 0 | 64,511 | 15 | 129,022 |
Tags: brute force, implementation
Correct Solution:
```
def check(a, b, c, d, e):
countX = 0
countD = 0
if a == 'X': countX += 1
elif a == '.': countD += 1
if b == 'X': countX += 1
elif b == '.': countD += 1
if c == 'X': countX += 1
elif c == '.': countD += 1
if d == 'X': countX += 1
elif d == '.': countD += 1
if e == 'X': countX += 1
elif e == '.': countD += 1
return countX == 4 and countD == 1
def f(a):
for i in range(10):
for j in range(6):
if (check(a[i][j], a[i][j+1], a[i][j+2], a[i][j+3], a[i][j+4])
or i < 6 and check(a[i][j], a[i+1][j+1], a[i+2][j+2], a[i+3][j+3], a[i+4][j+4])):
return True
for i in range(10):
for j in range(6):
if (check(a[j][i], a[j+1][i], a[j+2][i], a[j+3][i], a[j+4][i])
or i > 3 and check(a[j][i], a[j+1][i-1], a[j+2][i-2], a[j+3][i-3], a[j+4][i-4])):
return True
print('YES' if f([input() for _ in range(10)]) else 'NO')
``` | output | 1 | 64,511 | 15 | 129,023 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob play 5-in-a-row game. They have a playing field of size 10 × 10. In turns they put either crosses or noughts, one at a time. Alice puts crosses and Bob puts noughts.
In current match they have made some turns and now it's Alice's turn. She wonders if she can put cross in such empty cell that she wins immediately.
Alice wins if some crosses in the field form line of length not smaller than 5. This line can be horizontal, vertical and diagonal.
Input
You are given matrix 10 × 10 (10 lines of 10 characters each) with capital Latin letters 'X' being a cross, letters 'O' being a nought and '.' being an empty cell. The number of 'X' cells is equal to the number of 'O' cells and there is at least one of each type. There is at least one empty cell.
It is guaranteed that in the current arrangement nobody has still won.
Output
Print 'YES' if it's possible for Alice to win in one turn by putting cross in some empty cell. Otherwise print 'NO'.
Examples
Input
XX.XX.....
.....OOOO.
..........
..........
..........
..........
..........
..........
..........
..........
Output
YES
Input
XXOXX.....
OO.O......
..........
..........
..........
..........
..........
..........
..........
..........
Output
NO | instruction | 0 | 64,512 | 15 | 129,024 |
Tags: brute force, implementation
Correct Solution:
```
a = ['$'*12]
for i in range(10):
a.append('$' + input() + '$')
a.append('$'*12)
def count(r, c, dr, dc):
k = 0
while a[r][c] == 'X':
k += 1
r += dr
c += dc
return k
f = 0
for i in range(1,11):
if f == 1:
break
for j in range(1, 11):
if a[i][j] == '.':
h = count(i, j-1, 0, -1) + count(i, j+1, 0, 1)
v = count(i+1, j, 1, 0) + count(i-1, j, -1, 0)
d1 = count(i-1, j-1, -1, -1) + count(i+1, j+1, 1, 1)
d2 = count (i+1, j-1, 1, -1) + count(i-1, j+1, -1, 1)
if h >= 4 or v >= 4 or d1 >= 4 or d2 >= 4:
print('YES')
f = 1
break
if f == 0:
print('NO')
``` | output | 1 | 64,512 | 15 | 129,025 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob play 5-in-a-row game. They have a playing field of size 10 × 10. In turns they put either crosses or noughts, one at a time. Alice puts crosses and Bob puts noughts.
In current match they have made some turns and now it's Alice's turn. She wonders if she can put cross in such empty cell that she wins immediately.
Alice wins if some crosses in the field form line of length not smaller than 5. This line can be horizontal, vertical and diagonal.
Input
You are given matrix 10 × 10 (10 lines of 10 characters each) with capital Latin letters 'X' being a cross, letters 'O' being a nought and '.' being an empty cell. The number of 'X' cells is equal to the number of 'O' cells and there is at least one of each type. There is at least one empty cell.
It is guaranteed that in the current arrangement nobody has still won.
Output
Print 'YES' if it's possible for Alice to win in one turn by putting cross in some empty cell. Otherwise print 'NO'.
Examples
Input
XX.XX.....
.....OOOO.
..........
..........
..........
..........
..........
..........
..........
..........
Output
YES
Input
XXOXX.....
OO.O......
..........
..........
..........
..........
..........
..........
..........
..........
Output
NO
Submitted Solution:
```
arr = list()
for _ in range(10):
arr.append(list(input()))
for i in range(10):
for j in range(6):
lst = arr[i][j:j + 5]
if lst.count('X') == 4 and '.' in lst:
print('YES')
exit()
for j in range(10):
for i in range(6):
lst = list()
for k in range(i, i + 5):
lst.append(arr[k][j])
if lst.count('X') == 4 and '.' in lst:
print('YES')
exit()
for i in range(6):
for j in range(6):
lst = list()
for k in range(5):
lst.append(arr[i + k][j + k])
if lst.count('X') == 4 and '.' in lst:
print('YES')
exit()
for i in range(6):
for j in range(4, 10):
lst = list()
for k in range(5):
lst.append(arr[i + k][j - k])
if lst.count('X') == 4 and '.' in lst:
print('YES')
exit()
print('NO')
``` | instruction | 0 | 64,514 | 15 | 129,028 |
Yes | output | 1 | 64,514 | 15 | 129,029 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob play 5-in-a-row game. They have a playing field of size 10 × 10. In turns they put either crosses or noughts, one at a time. Alice puts crosses and Bob puts noughts.
In current match they have made some turns and now it's Alice's turn. She wonders if she can put cross in such empty cell that she wins immediately.
Alice wins if some crosses in the field form line of length not smaller than 5. This line can be horizontal, vertical and diagonal.
Input
You are given matrix 10 × 10 (10 lines of 10 characters each) with capital Latin letters 'X' being a cross, letters 'O' being a nought and '.' being an empty cell. The number of 'X' cells is equal to the number of 'O' cells and there is at least one of each type. There is at least one empty cell.
It is guaranteed that in the current arrangement nobody has still won.
Output
Print 'YES' if it's possible for Alice to win in one turn by putting cross in some empty cell. Otherwise print 'NO'.
Examples
Input
XX.XX.....
.....OOOO.
..........
..........
..........
..........
..........
..........
..........
..........
Output
YES
Input
XXOXX.....
OO.O......
..........
..........
..........
..........
..........
..........
..........
..........
Output
NO
Submitted Solution:
```
N = 10
A = []
for _ in range(N):
A += [list(input())]
result = "NO"
# \
# \
for i in range(N // 2 + 1):
for j in range(N // 2 + 1):
cross, dots = 0, 0
for k in range(N // 2):
if A[i + k][j + k] == '.':
dots += 1
elif A[i + k][j + k] == 'X':
cross += 1
if cross == 4 and dots == 1:
result = "YES"
# /
# /
for i in range(N // 2 + 1):
for j in range(N // 2 - 1, N):
cross, dots = 0, 0
for k in range(N // 2):
if A[i + k][j - k] == '.':
dots += 1
elif A[i + k][j - k] == 'X':
cross += 1
if cross == 4 and dots == 1:
result = "YES"
# --
for i in range(N):
for j in range(N // 2 + 1):
cross, dots = 0, 0
for k in range(N // 2):
if A[i][j + k] == '.':
dots += 1
elif A[i][j + k] == 'X':
cross += 1
if cross == 4 and dots == 1:
result = "YES"
# |
# |
for i in range(N // 2 + 1):
for j in range(N):
cross, dots = 0, 0
for k in range(N // 2):
if A[i + k][j] == '.':
dots += 1
elif A[i + k][j] == 'X':
cross += 1
if cross == 4 and dots == 1:
result = "YES"
print(result)
``` | instruction | 0 | 64,515 | 15 | 129,030 |
Yes | output | 1 | 64,515 | 15 | 129,031 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob play 5-in-a-row game. They have a playing field of size 10 × 10. In turns they put either crosses or noughts, one at a time. Alice puts crosses and Bob puts noughts.
In current match they have made some turns and now it's Alice's turn. She wonders if she can put cross in such empty cell that she wins immediately.
Alice wins if some crosses in the field form line of length not smaller than 5. This line can be horizontal, vertical and diagonal.
Input
You are given matrix 10 × 10 (10 lines of 10 characters each) with capital Latin letters 'X' being a cross, letters 'O' being a nought and '.' being an empty cell. The number of 'X' cells is equal to the number of 'O' cells and there is at least one of each type. There is at least one empty cell.
It is guaranteed that in the current arrangement nobody has still won.
Output
Print 'YES' if it's possible for Alice to win in one turn by putting cross in some empty cell. Otherwise print 'NO'.
Examples
Input
XX.XX.....
.....OOOO.
..........
..........
..........
..........
..........
..........
..........
..........
Output
YES
Input
XXOXX.....
OO.O......
..........
..........
..........
..........
..........
..........
..........
..........
Output
NO
Submitted Solution:
```
import itertools
def main():
global MAP
MAP = []
for i in range(10):
MAP.append(list(input()))
# MAP = np.array(MAP)
for (i, j) in itertools.product(range(10), range(10)):
if check(i, j):
print('YES')
return
print("NO")
def check(i, j):
for a, b in [(0,1), (1,0), (1,1), (1,-1), (-1,1), (-1,0), (0, -1), (-1,-1)]:
count = 0
ecount = 0
for k in range(5):
if (not (0 <= i + k*a <= 9)) or (not (0 <= j + k*b <= 9)):
break
if MAP[i + k*a][j + k*b] == "X":
count += 1
elif MAP[i + k*a][j + k*b] == ".":
ecount += 1
if count == 4 and ecount == 1:
return True
return False
if __name__ == "__main__":
# global stime
# stime = time.clock()
main()
``` | instruction | 0 | 64,516 | 15 | 129,032 |
Yes | output | 1 | 64,516 | 15 | 129,033 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob play 5-in-a-row game. They have a playing field of size 10 × 10. In turns they put either crosses or noughts, one at a time. Alice puts crosses and Bob puts noughts.
In current match they have made some turns and now it's Alice's turn. She wonders if she can put cross in such empty cell that she wins immediately.
Alice wins if some crosses in the field form line of length not smaller than 5. This line can be horizontal, vertical and diagonal.
Input
You are given matrix 10 × 10 (10 lines of 10 characters each) with capital Latin letters 'X' being a cross, letters 'O' being a nought and '.' being an empty cell. The number of 'X' cells is equal to the number of 'O' cells and there is at least one of each type. There is at least one empty cell.
It is guaranteed that in the current arrangement nobody has still won.
Output
Print 'YES' if it's possible for Alice to win in one turn by putting cross in some empty cell. Otherwise print 'NO'.
Examples
Input
XX.XX.....
.....OOOO.
..........
..........
..........
..........
..........
..........
..........
..........
Output
YES
Input
XXOXX.....
OO.O......
..........
..........
..........
..........
..........
..........
..........
..........
Output
NO
Submitted Solution:
```
def goriz(i,j):
k=0
p=0
x=j
if 9-x>=3:
while (g[i][x]=='X' or g[i][x+1]=='X') and (x<=8):
if g[i][x]=='.':
k+=1
elif g[i][x]=='X':
p+=1
elif g[i][x]=='O':
break
if x<8:
x+=1
else:
break
#print(k,' ',p)
if x==8 and (g[i][x]=='X' or g[i][x+1]=='X'):
if g[i][x+1]=='.':
k+=1
elif g[i][x+1]=='X':
p+=1
if p>=4 and k==0 and j>0:
if g[i][j-1]=='.':
k+=1
elif g[i][x]=='O' and p>=4 and k==0 and j>0:
if g[i][j-1]=='.':
k+=1
if k==1 and p>=4:
return(1)
else:
return(0)
else:
return(0)
def vertik(i,j):
k=0
p=0
x=i
if 9-i>=3:
while (g[x][j]=='X' or g[x+1][j]=='X') and (x<=8):
if g[x][j]=='.':
k+=1
elif g[x][j]=='X':
p+=1
elif g[x][j]=='O':
break
if x<8:
x+=1
else:
break
if x==8:
if g[x+1][j]=='.':
k+=1
elif g[x+1][j]=='X':
p+=1
elif k==0:
if g[x][j]=='.':
k+=1
elif g[x][j]=='X':
p+=1
if p>=4 and k==0 and i>0:
if g[i-1][j]=='.':
k+=1
if k==1 and p>=4:
return(1)
else:
return(0)
else:
return(0)
def diagon1(i,j):
k=0
p=0
x=i
y=j
if 9-i>=3 and 9-j>=3:
while (x<=8 and y<=8) and (g[x][y]=='X' or g[x+1][y+1]=='X'):
if g[x][y]=='.':
k+=1
x+=1
y+=1
elif g[x][y]=='X':
p+=1
x+=1
y+=1
elif g[x][y]=='O':
break
#print(k,' ',p)
if k==1 and p>=4:
return(1)
elif p>=4 and k==0 and i>0 and j>0:
if g[i-1][j-1]=='.':
k+=1
#print(k)
if k==1 and p>=4:
return(1)
elif (x==9 or y==9) and g[x][y]=='.':
k+=1
if k==1 and p>=4:
return(1)
elif (x==9 or y==9) and g[x][y]=='X':
p+=1
#print(k,' ',p)
if k==1 and p>=4:
return(1)
elif p>=4 and k==0 and i>0 and j>0:
if g[i-1][j-1]=='.':
k+=1
#print(k)
if k==1 and p>=4:
return(1)
else:
return(0)
else:
return(0)
def diagon2(i,j):
k=0
p=0
x=i
y=j
if 9-i>=3 and 9-j<=6:
while (x<=8 and y>0) and (g[x][y]=='X' or g[x+1][y-1]=='X'):
if g[x][y]=='.':
k+=1
x+=1
y-=1
elif g[x][y]=='X':
p+=1
x+=1
y-=1
elif g[x][y]=='O':
break
if g[x][y]=='.' and k==0:
k+=1
elif g[x][y]=='X':
p+=1
if p>=4 and k==0 and i>0 and j<9:
if g[i-1][j+1]=='.':
k+=1
if k==1 and p>=4:
return(1)
elif (x==9 or y==0) and g[x][y]=='.':
k+=1
if k==1 and p>=4:
return(1)
elif (x==9 or y==0) and g[x][y]=='X':
p+=1
if k==1 and p>=4:
return(1)
else:
return(0)
else:
return(0)
g = [input() for i in range(10)]
#print(g)
b=0
for i in range(10):
for j in range(10):
if g[i][j]=='X':
if goriz(i,j)==1:
print('YES')
b=1
break
elif vertik(i,j)==1:
print('YES')
b=1
break
elif diagon1(i,j)==1:
print('YES')
b=1
break
elif diagon2(i,j)==1:
print('YES')
b=1
break
if b==1:
break
else:
print('NO')
``` | instruction | 0 | 64,517 | 15 | 129,034 |
No | output | 1 | 64,517 | 15 | 129,035 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob play 5-in-a-row game. They have a playing field of size 10 × 10. In turns they put either crosses or noughts, one at a time. Alice puts crosses and Bob puts noughts.
In current match they have made some turns and now it's Alice's turn. She wonders if she can put cross in such empty cell that she wins immediately.
Alice wins if some crosses in the field form line of length not smaller than 5. This line can be horizontal, vertical and diagonal.
Input
You are given matrix 10 × 10 (10 lines of 10 characters each) with capital Latin letters 'X' being a cross, letters 'O' being a nought and '.' being an empty cell. The number of 'X' cells is equal to the number of 'O' cells and there is at least one of each type. There is at least one empty cell.
It is guaranteed that in the current arrangement nobody has still won.
Output
Print 'YES' if it's possible for Alice to win in one turn by putting cross in some empty cell. Otherwise print 'NO'.
Examples
Input
XX.XX.....
.....OOOO.
..........
..........
..........
..........
..........
..........
..........
..........
Output
YES
Input
XXOXX.....
OO.O......
..........
..........
..........
..........
..........
..........
..........
..........
Output
NO
Submitted Solution:
```
r = [input() for _ in range(10)]
c = []
for i in range(10):
t = ""
for j in range(10):
t += r[j][i]
c.append(t)
for x in r:
if any(s in x for s in [".XXXX", "X.XXX", "XX.XX", "XXX.X", "XXXX."]):
print("YES")
break
else:
for y in c:
if any(s in y for s in [".XXXX", "X.XXX", "XX.XX", "XXX.X", "XXXX."]):
print("YES")
break
else:
for a in range(6):
z1 = ""
z2 = ""
for b in range(10-a):
z1 += r[a+b][b]
z2 += r[b][a+b]
if any(s in z1 for s in [".XXXX", "X.XXX", "XX.XX", "XXX.X", "XXXX."]):
print("YES")
quit()
if any(s in z2 for s in [".XXXX", "X.XXX", "XX.XX", "XXX.X", "XXXX."]):
print("YES")
quit()
c = list(zip(*r[::-1]))
for a in range(6):
z1 = ""
z2 = ""
for b in range(10-a):
z1 += c[a+b][b]
z2 += c[b][a+b]
# print(z1, z2)
if any(s in z1 for s in [".XXXX", "X.XXX", "XX.XX", "XXX.X", "XXXX."]):
print("YES")
quit()
if any(s in z2 for s in [".XXXX", "X.XXX", "XX.XX", "XXX.X", "XXXX."]):
print("YES")
quit()
print("NO")
``` | instruction | 0 | 64,520 | 15 | 129,040 |
No | output | 1 | 64,520 | 15 | 129,041 |
Provide a correct Python 3 solution for this coding contest problem.
There are N robots numbered 1 to N placed on a number line. Robot i is placed at coordinate X_i. When activated, it will travel the distance of D_i in the positive direction, and then it will be removed from the number line. All the robots move at the same speed, and their sizes are ignorable.
Takahashi, who is a mischievous boy, can do the following operation any number of times (possibly zero) as long as there is a robot remaining on the number line.
* Choose a robot and activate it. This operation cannot be done when there is a robot moving.
While Robot i is moving, if it touches another robot j that is remaining in the range [X_i, X_i + D_i) on the number line, Robot j also gets activated and starts moving. This process is repeated recursively.
How many possible sets of robots remaining on the number line are there after Takahashi does the operation some number of times? Compute this count modulo 998244353, since it can be enormous.
Constraints
* 1 \leq N \leq 2 \times 10^5
* -10^9 \leq X_i \leq 10^9
* 1 \leq D_i \leq 10^9
* X_i \neq X_j (i \neq j)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 D_1
:
X_N D_N
Output
Print the number of possible sets of robots remaining on the number line, modulo 998244353.
Examples
Input
2
1 5
3 3
Output
3
Input
3
6 5
-1 10
3 3
Output
5
Input
4
7 10
-10 3
4 3
-4 3
Output
16
Input
20
-8 1
26 4
0 5
9 1
19 4
22 20
28 27
11 8
-3 20
-25 17
10 4
-18 27
24 28
-11 19
2 27
-2 18
-1 12
-24 29
31 29
29 7
Output
110 | instruction | 0 | 64,600 | 15 | 129,200 |
"Correct Solution:
```
from bisect import bisect_left
class SegTree:
def __init__(self, raw_data):
n = len(raw_data)
self.size = 1 << (n.bit_length()) # 葉の要素数
self.data = [0] * (2*self.size)
self.build(raw_data)
def build(self, raw_data):
for i, x in enumerate(raw_data):
self.data[self.size+i] = x
for i in range(self.size-1, 0, -1):
x = self.data[2*i]
y = self.data[2*i+1]
self.data[i] = x if x > y else y # ここを変更
def update(self, i, x):
i += self.size
self.data[i] = x
i >>= 1
while i:
x = self.data[2*i]
y = self.data[2*i+1]
self.data[i] = x if x > y else y # ここを変更
i >>= 1
def get_data(self, i):
return self.data[i+self.size]
# これを変更
def get_max(self, L, R):
L += self.size
R += self.size + 1
x = 0
while L < R:
if L & 1:
y = self.data[L]
if x < y: x = y
L += 1
if R & 1:
R -= 1
y = self.data[R]
if x < y: x = y
L >>= 1
R >>= 1
return x
N = int(input())
robots = sorted([tuple(map(int, input().split())) for _ in range(N)])
X, D = zip(*robots)
mod = 998244353
affects = [0] + [bisect_left(X, x+d) for x, d in robots]
seg = SegTree(affects)
S = [0] * len(affects)
for n in range(N, 0, -1):
affect = affects[n]
x = seg.get_max(n, affect)
S[n] = x
seg.update(n, x)
dp = [0] * (N+1)
dp[0] = 1
dp_cum = [1] * (N+1)
for n, r in enumerate(S[1:], 1):
dp[r] += dp_cum[n-1]
dp[r] %= mod
dp_cum[n] = dp_cum[n-1] + dp[n]
dp_cum[n] %= mod
print(dp_cum[-1])
``` | output | 1 | 64,600 | 15 | 129,201 |
Provide a correct Python 3 solution for this coding contest problem.
There are N robots numbered 1 to N placed on a number line. Robot i is placed at coordinate X_i. When activated, it will travel the distance of D_i in the positive direction, and then it will be removed from the number line. All the robots move at the same speed, and their sizes are ignorable.
Takahashi, who is a mischievous boy, can do the following operation any number of times (possibly zero) as long as there is a robot remaining on the number line.
* Choose a robot and activate it. This operation cannot be done when there is a robot moving.
While Robot i is moving, if it touches another robot j that is remaining in the range [X_i, X_i + D_i) on the number line, Robot j also gets activated and starts moving. This process is repeated recursively.
How many possible sets of robots remaining on the number line are there after Takahashi does the operation some number of times? Compute this count modulo 998244353, since it can be enormous.
Constraints
* 1 \leq N \leq 2 \times 10^5
* -10^9 \leq X_i \leq 10^9
* 1 \leq D_i \leq 10^9
* X_i \neq X_j (i \neq j)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 D_1
:
X_N D_N
Output
Print the number of possible sets of robots remaining on the number line, modulo 998244353.
Examples
Input
2
1 5
3 3
Output
3
Input
3
6 5
-1 10
3 3
Output
5
Input
4
7 10
-10 3
4 3
-4 3
Output
16
Input
20
-8 1
26 4
0 5
9 1
19 4
22 20
28 27
11 8
-3 20
-25 17
10 4
-18 27
24 28
-11 19
2 27
-2 18
-1 12
-24 29
31 29
29 7
Output
110 | instruction | 0 | 64,601 | 15 | 129,202 |
"Correct Solution:
```
from bisect import bisect
from itertools import accumulate
from functools import reduce
from sys import setrecursionlimit
setrecursionlimit(10000000)
MOD = 998244353
def solve(robots):
N = len(robots)
robots.sort()
parent = [None]*(N+1)
stack = [(float('inf'),0)]
for i,(x,d) in enumerate(robots,start=1):
d += x
while stack[-1][0] <= x:
stack.pop()
parent[i] = stack[-1][1]
while stack[-1][0] <= d:
stack.pop()
stack.append((d,i))
dp = [1]*(N+1)
for i in reversed(range(1,N+1)):
p = parent[i]
dp[p] *= dp[i]+1
dp[p] %= MOD
return dp[0]
if __name__ == '__main__':
N = int(input())
robots = [tuple(map(int,input().split())) for _ in range(N)]
print(solve(robots))
``` | output | 1 | 64,601 | 15 | 129,203 |
Provide a correct Python 3 solution for this coding contest problem.
There are N robots numbered 1 to N placed on a number line. Robot i is placed at coordinate X_i. When activated, it will travel the distance of D_i in the positive direction, and then it will be removed from the number line. All the robots move at the same speed, and their sizes are ignorable.
Takahashi, who is a mischievous boy, can do the following operation any number of times (possibly zero) as long as there is a robot remaining on the number line.
* Choose a robot and activate it. This operation cannot be done when there is a robot moving.
While Robot i is moving, if it touches another robot j that is remaining in the range [X_i, X_i + D_i) on the number line, Robot j also gets activated and starts moving. This process is repeated recursively.
How many possible sets of robots remaining on the number line are there after Takahashi does the operation some number of times? Compute this count modulo 998244353, since it can be enormous.
Constraints
* 1 \leq N \leq 2 \times 10^5
* -10^9 \leq X_i \leq 10^9
* 1 \leq D_i \leq 10^9
* X_i \neq X_j (i \neq j)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 D_1
:
X_N D_N
Output
Print the number of possible sets of robots remaining on the number line, modulo 998244353.
Examples
Input
2
1 5
3 3
Output
3
Input
3
6 5
-1 10
3 3
Output
5
Input
4
7 10
-10 3
4 3
-4 3
Output
16
Input
20
-8 1
26 4
0 5
9 1
19 4
22 20
28 27
11 8
-3 20
-25 17
10 4
-18 27
24 28
-11 19
2 27
-2 18
-1 12
-24 29
31 29
29 7
Output
110 | instruction | 0 | 64,602 | 15 | 129,204 |
"Correct Solution:
```
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 998244353
mans = 998244353 ;ans = 0 ;count = 0 ;pro = 1
sys.setrecursionlimit(10**6)
n = int(input())
XD = [tuple(map(int,input().split())) for i in range(n)]
XD.append((-10**10,inf))
XD.sort()
now = 0
visited1 = []
def dfs(node):
visited1.append(node)
global now
pro = 1
while now < n :
if XD[now+1][0] < XD[node][0] + XD[node][1]:
now += 1
pro *= dfs(now)
pro %= mod
else:break
return pro + 1
ans = dfs(0)
print((ans-1)%mod)
``` | output | 1 | 64,602 | 15 | 129,205 |
Provide a correct Python 3 solution for this coding contest problem.
There are N robots numbered 1 to N placed on a number line. Robot i is placed at coordinate X_i. When activated, it will travel the distance of D_i in the positive direction, and then it will be removed from the number line. All the robots move at the same speed, and their sizes are ignorable.
Takahashi, who is a mischievous boy, can do the following operation any number of times (possibly zero) as long as there is a robot remaining on the number line.
* Choose a robot and activate it. This operation cannot be done when there is a robot moving.
While Robot i is moving, if it touches another robot j that is remaining in the range [X_i, X_i + D_i) on the number line, Robot j also gets activated and starts moving. This process is repeated recursively.
How many possible sets of robots remaining on the number line are there after Takahashi does the operation some number of times? Compute this count modulo 998244353, since it can be enormous.
Constraints
* 1 \leq N \leq 2 \times 10^5
* -10^9 \leq X_i \leq 10^9
* 1 \leq D_i \leq 10^9
* X_i \neq X_j (i \neq j)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 D_1
:
X_N D_N
Output
Print the number of possible sets of robots remaining on the number line, modulo 998244353.
Examples
Input
2
1 5
3 3
Output
3
Input
3
6 5
-1 10
3 3
Output
5
Input
4
7 10
-10 3
4 3
-4 3
Output
16
Input
20
-8 1
26 4
0 5
9 1
19 4
22 20
28 27
11 8
-3 20
-25 17
10 4
-18 27
24 28
-11 19
2 27
-2 18
-1 12
-24 29
31 29
29 7
Output
110 | instruction | 0 | 64,603 | 15 | 129,206 |
"Correct Solution:
```
n = int(input())
x = [list(map(int,input().split())) for i in range(n)]
x.sort(key=lambda x:x[0])
x.append([2*10**9+1,0])
y = [0]*(n-1) + [n-1]
a = [0]*(n-1) + [2]
for i in range(n-2,-1,-1):
j = i+1
while x[j][0] < sum(x[i]):
j = y[j] + 1
y[i] = j - 1
for i in range(n-2,-1,-1):
a[i] = a[y[i]+1] if y[i]+1 < n else 1
a[i] = (a[i]+a[i+1]) % 998244353
print(a[0])
``` | output | 1 | 64,603 | 15 | 129,207 |
Provide a correct Python 3 solution for this coding contest problem.
There are N robots numbered 1 to N placed on a number line. Robot i is placed at coordinate X_i. When activated, it will travel the distance of D_i in the positive direction, and then it will be removed from the number line. All the robots move at the same speed, and their sizes are ignorable.
Takahashi, who is a mischievous boy, can do the following operation any number of times (possibly zero) as long as there is a robot remaining on the number line.
* Choose a robot and activate it. This operation cannot be done when there is a robot moving.
While Robot i is moving, if it touches another robot j that is remaining in the range [X_i, X_i + D_i) on the number line, Robot j also gets activated and starts moving. This process is repeated recursively.
How many possible sets of robots remaining on the number line are there after Takahashi does the operation some number of times? Compute this count modulo 998244353, since it can be enormous.
Constraints
* 1 \leq N \leq 2 \times 10^5
* -10^9 \leq X_i \leq 10^9
* 1 \leq D_i \leq 10^9
* X_i \neq X_j (i \neq j)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 D_1
:
X_N D_N
Output
Print the number of possible sets of robots remaining on the number line, modulo 998244353.
Examples
Input
2
1 5
3 3
Output
3
Input
3
6 5
-1 10
3 3
Output
5
Input
4
7 10
-10 3
4 3
-4 3
Output
16
Input
20
-8 1
26 4
0 5
9 1
19 4
22 20
28 27
11 8
-3 20
-25 17
10 4
-18 27
24 28
-11 19
2 27
-2 18
-1 12
-24 29
31 29
29 7
Output
110 | instruction | 0 | 64,604 | 15 | 129,208 |
"Correct Solution:
```
import sys
input=sys.stdin.readline
N=int(input())
robot=[]
for i in range(N):
x,d=map(int,input().split())
robot.append((x,d))
mod=998244353
robot.sort()
move=[i for i in range(0,N)]
for i in range(0,N):
x,d=robot[i]
start=i
end=N-1
while end-start>1:
test=(end+start)//2
if x+d>robot[test][0]:
start=test
else:
end=test
if x+d>robot[end][0]:
move[i]=end
else:
move[i]=start
n=N
#####segfunc######
def segfunc(x,y):
return max(x,y)
def init(init_val):
#set_val
for i in range(n):
seg[i+num-1]=init_val[i]
#built
for i in range(num-2,-1,-1) :
seg[i]=segfunc(seg[2*i+1],seg[2*i+2])
def update(k,x):
k += num-1
seg[k] = x
while k:
k = (k-1)//2
seg[k] = segfunc(seg[k*2+1],seg[k*2+2])
def query(p,q):
if q<=p:
return ide_ele
p += num-1
q += num-2
res=ide_ele
while q-p>1:
if p&1 == 0:
res = segfunc(res,seg[p])
if q&1 == 1:
res = segfunc(res,seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = segfunc(res,seg[p])
else:
res = segfunc(segfunc(res,seg[p]),seg[q])
return res
#####単位元######
ide_ele =0
#num:n以上の最小の2のべき乗
num =2**(n-1).bit_length()
seg=[ide_ele]*2*num
chain=[i for i in range(N)]
for _ in range(0,N):
i=N-1-_
if move[i]==i:
chain[i]=i
update(i,chain[i])
else:
chain[i]=query(i+1,move[i]+1)
update(i,chain[i])
dp=[0 for i in range(0,N+1)]
dp[N]=1
for j in range(0,N):
i=N-1-j
if chain[i]==i:
dp[i]=(2*dp[i+1])%mod
else:
dp[i]=(dp[i+1]+dp[chain[i]+1])%mod
print(dp[0])
``` | output | 1 | 64,604 | 15 | 129,209 |
Provide a correct Python 3 solution for this coding contest problem.
There are N robots numbered 1 to N placed on a number line. Robot i is placed at coordinate X_i. When activated, it will travel the distance of D_i in the positive direction, and then it will be removed from the number line. All the robots move at the same speed, and their sizes are ignorable.
Takahashi, who is a mischievous boy, can do the following operation any number of times (possibly zero) as long as there is a robot remaining on the number line.
* Choose a robot and activate it. This operation cannot be done when there is a robot moving.
While Robot i is moving, if it touches another robot j that is remaining in the range [X_i, X_i + D_i) on the number line, Robot j also gets activated and starts moving. This process is repeated recursively.
How many possible sets of robots remaining on the number line are there after Takahashi does the operation some number of times? Compute this count modulo 998244353, since it can be enormous.
Constraints
* 1 \leq N \leq 2 \times 10^5
* -10^9 \leq X_i \leq 10^9
* 1 \leq D_i \leq 10^9
* X_i \neq X_j (i \neq j)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 D_1
:
X_N D_N
Output
Print the number of possible sets of robots remaining on the number line, modulo 998244353.
Examples
Input
2
1 5
3 3
Output
3
Input
3
6 5
-1 10
3 3
Output
5
Input
4
7 10
-10 3
4 3
-4 3
Output
16
Input
20
-8 1
26 4
0 5
9 1
19 4
22 20
28 27
11 8
-3 20
-25 17
10 4
-18 27
24 28
-11 19
2 27
-2 18
-1 12
-24 29
31 29
29 7
Output
110 | instruction | 0 | 64,605 | 15 | 129,210 |
"Correct Solution:
```
from bisect import bisect
from itertools import accumulate
from functools import reduce
from sys import setrecursionlimit
setrecursionlimit(10000000)
MOD = 998244353
def solve(robots):
N = len(robots)+1
robots.sort()
parent = [None]*N
stack = [(float('inf'),0)]
for i,(x,d) in enumerate(robots,start=1):
d += x
while stack[-1][0] <= x:
stack.pop()
parent[i] = stack[-1][1]
while stack[-1][0] <= d:
stack.pop()
stack.append((d,i))
dp = [1]*N
for i in reversed(range(1,N)):
p = parent[i]
dp[p] *= dp[i]+1
dp[p] %= MOD
return dp[0]
if __name__ == '__main__':
N = int(input())
robots = [tuple(map(int,input().split())) for _ in range(N)]
print(solve(robots))
``` | output | 1 | 64,605 | 15 | 129,211 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.