text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Provide a correct Python 3 solution for this coding contest problem.
There are two standard ways to represent a graph $G = (V, E)$, where $V$ is a set of vertices and $E$ is a set of edges; Adjacency list representation and Adjacency matrix representation.
An adjacency-list representation consists of an array $Adj[|V|]$ of $|V|$ lists, one for each vertex in $V$. For each $u \in V$, the adjacency list $Adj[u]$ contains all vertices $v$ such that there is an edge $(u, v) \in E$. That is, $Adj[u]$ consists of all vertices adjacent to $u$ in $G$.
An adjacency-matrix representation consists of $|V| \times |V|$ matrix $A = a_{ij}$ such that $a_{ij} = 1$ if $(i, j) \in E$, $a_{ij} = 0$ otherwise.
Write a program which reads a directed graph $G$ represented by the adjacency list, and prints its adjacency-matrix representation. $G$ consists of $n\; (=|V|)$ vertices identified by their IDs $1, 2,.., n$ respectively.
Constraints
* $1 \leq n \leq 100$
Input
In the first line, an integer $n$ is given. In the next $n$ lines, an adjacency list $Adj[u]$ for vertex $u$ are given in the following format:
$u$ $k$ $v_1$ $v_2$ ... $v_k$
$u$ is vertex ID and $k$ denotes its degree. $v_i$ are IDs of vertices adjacent to $u$.
Output
As shown in the following sample output, print the adjacent-matrix representation of $G$. Put a single space character between $a_{ij}$.
Example
Input
4
1 2 2 4
2 1 4
3 0
4 1 3
Output
0 1 0 1
0 0 0 1
0 0 0 0
0 0 1 0
"Correct Solution:
```
n = int(input())
m = [[0 for _ in range(n)] for _ in range(n)]
for i in range(n):
u, k, *v = map(int, input().split())
for j in v:
m[u-1][j-1] = 1
for i in range(n):
print(" ".join(map(str,m[i])))
```
| 107,000 |
Provide a correct Python 3 solution for this coding contest problem.
There are two standard ways to represent a graph $G = (V, E)$, where $V$ is a set of vertices and $E$ is a set of edges; Adjacency list representation and Adjacency matrix representation.
An adjacency-list representation consists of an array $Adj[|V|]$ of $|V|$ lists, one for each vertex in $V$. For each $u \in V$, the adjacency list $Adj[u]$ contains all vertices $v$ such that there is an edge $(u, v) \in E$. That is, $Adj[u]$ consists of all vertices adjacent to $u$ in $G$.
An adjacency-matrix representation consists of $|V| \times |V|$ matrix $A = a_{ij}$ such that $a_{ij} = 1$ if $(i, j) \in E$, $a_{ij} = 0$ otherwise.
Write a program which reads a directed graph $G$ represented by the adjacency list, and prints its adjacency-matrix representation. $G$ consists of $n\; (=|V|)$ vertices identified by their IDs $1, 2,.., n$ respectively.
Constraints
* $1 \leq n \leq 100$
Input
In the first line, an integer $n$ is given. In the next $n$ lines, an adjacency list $Adj[u]$ for vertex $u$ are given in the following format:
$u$ $k$ $v_1$ $v_2$ ... $v_k$
$u$ is vertex ID and $k$ denotes its degree. $v_i$ are IDs of vertices adjacent to $u$.
Output
As shown in the following sample output, print the adjacent-matrix representation of $G$. Put a single space character between $a_{ij}$.
Example
Input
4
1 2 2 4
2 1 4
3 0
4 1 3
Output
0 1 0 1
0 0 0 1
0 0 0 0
0 0 1 0
"Correct Solution:
```
def adjmatrices():
n = int(input())
for i in range(n):
node_list = list(map(int, input().split()))
matrix = [0]*n
for j in node_list[2:]:
matrix[j-1] = 1
print(*matrix)
if __name__ == '__main__':
adjmatrices()
```
| 107,001 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are two standard ways to represent a graph $G = (V, E)$, where $V$ is a set of vertices and $E$ is a set of edges; Adjacency list representation and Adjacency matrix representation.
An adjacency-list representation consists of an array $Adj[|V|]$ of $|V|$ lists, one for each vertex in $V$. For each $u \in V$, the adjacency list $Adj[u]$ contains all vertices $v$ such that there is an edge $(u, v) \in E$. That is, $Adj[u]$ consists of all vertices adjacent to $u$ in $G$.
An adjacency-matrix representation consists of $|V| \times |V|$ matrix $A = a_{ij}$ such that $a_{ij} = 1$ if $(i, j) \in E$, $a_{ij} = 0$ otherwise.
Write a program which reads a directed graph $G$ represented by the adjacency list, and prints its adjacency-matrix representation. $G$ consists of $n\; (=|V|)$ vertices identified by their IDs $1, 2,.., n$ respectively.
Constraints
* $1 \leq n \leq 100$
Input
In the first line, an integer $n$ is given. In the next $n$ lines, an adjacency list $Adj[u]$ for vertex $u$ are given in the following format:
$u$ $k$ $v_1$ $v_2$ ... $v_k$
$u$ is vertex ID and $k$ denotes its degree. $v_i$ are IDs of vertices adjacent to $u$.
Output
As shown in the following sample output, print the adjacent-matrix representation of $G$. Put a single space character between $a_{ij}$.
Example
Input
4
1 2 2 4
2 1 4
3 0
4 1 3
Output
0 1 0 1
0 0 0 1
0 0 0 0
0 0 1 0
Submitted Solution:
```
n=int(input())
v=[]
u=0
e=0
A=[[0 for j in range(n)]for i in range(n)]
for i in range(n):
S=input().split()
if S[1]!=0:
for j in range(int(S[1])):
A[i][int(S[2+j])-1]=1
for i in range(n):
for j in range(n):
if j!=n-1:
print(A[i][j],end=" ")
else:
print(A[i][j],end="\n")
```
Yes
| 107,002 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are two standard ways to represent a graph $G = (V, E)$, where $V$ is a set of vertices and $E$ is a set of edges; Adjacency list representation and Adjacency matrix representation.
An adjacency-list representation consists of an array $Adj[|V|]$ of $|V|$ lists, one for each vertex in $V$. For each $u \in V$, the adjacency list $Adj[u]$ contains all vertices $v$ such that there is an edge $(u, v) \in E$. That is, $Adj[u]$ consists of all vertices adjacent to $u$ in $G$.
An adjacency-matrix representation consists of $|V| \times |V|$ matrix $A = a_{ij}$ such that $a_{ij} = 1$ if $(i, j) \in E$, $a_{ij} = 0$ otherwise.
Write a program which reads a directed graph $G$ represented by the adjacency list, and prints its adjacency-matrix representation. $G$ consists of $n\; (=|V|)$ vertices identified by their IDs $1, 2,.., n$ respectively.
Constraints
* $1 \leq n \leq 100$
Input
In the first line, an integer $n$ is given. In the next $n$ lines, an adjacency list $Adj[u]$ for vertex $u$ are given in the following format:
$u$ $k$ $v_1$ $v_2$ ... $v_k$
$u$ is vertex ID and $k$ denotes its degree. $v_i$ are IDs of vertices adjacent to $u$.
Output
As shown in the following sample output, print the adjacent-matrix representation of $G$. Put a single space character between $a_{ij}$.
Example
Input
4
1 2 2 4
2 1 4
3 0
4 1 3
Output
0 1 0 1
0 0 0 1
0 0 0 0
0 0 1 0
Submitted Solution:
```
import sys
def input():
return sys.stdin.readline().rstrip()
def main():
n = int(input())
G = [[0] * n for _ in range(n)]
for i in range(n):
u, k, *v = map(int, input().split())
for j in range(k):
G[u-1][v[j]-1] = 1
for i in range(n):
print(*G[i])
if __name__ == '__main__':
main()
```
Yes
| 107,003 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are two standard ways to represent a graph $G = (V, E)$, where $V$ is a set of vertices and $E$ is a set of edges; Adjacency list representation and Adjacency matrix representation.
An adjacency-list representation consists of an array $Adj[|V|]$ of $|V|$ lists, one for each vertex in $V$. For each $u \in V$, the adjacency list $Adj[u]$ contains all vertices $v$ such that there is an edge $(u, v) \in E$. That is, $Adj[u]$ consists of all vertices adjacent to $u$ in $G$.
An adjacency-matrix representation consists of $|V| \times |V|$ matrix $A = a_{ij}$ such that $a_{ij} = 1$ if $(i, j) \in E$, $a_{ij} = 0$ otherwise.
Write a program which reads a directed graph $G$ represented by the adjacency list, and prints its adjacency-matrix representation. $G$ consists of $n\; (=|V|)$ vertices identified by their IDs $1, 2,.., n$ respectively.
Constraints
* $1 \leq n \leq 100$
Input
In the first line, an integer $n$ is given. In the next $n$ lines, an adjacency list $Adj[u]$ for vertex $u$ are given in the following format:
$u$ $k$ $v_1$ $v_2$ ... $v_k$
$u$ is vertex ID and $k$ denotes its degree. $v_i$ are IDs of vertices adjacent to $u$.
Output
As shown in the following sample output, print the adjacent-matrix representation of $G$. Put a single space character between $a_{ij}$.
Example
Input
4
1 2 2 4
2 1 4
3 0
4 1 3
Output
0 1 0 1
0 0 0 1
0 0 0 0
0 0 1 0
Submitted Solution:
```
n = int(input())
A = [[0] * n for _ in range(n)]
for _ in range(n):
u, k, *v = list(map(int, input().split()))
for j in v:
A[u-1][j-1] = 1
for row in A:
print(' '.join(list(map(str,row))))
```
Yes
| 107,004 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are two standard ways to represent a graph $G = (V, E)$, where $V$ is a set of vertices and $E$ is a set of edges; Adjacency list representation and Adjacency matrix representation.
An adjacency-list representation consists of an array $Adj[|V|]$ of $|V|$ lists, one for each vertex in $V$. For each $u \in V$, the adjacency list $Adj[u]$ contains all vertices $v$ such that there is an edge $(u, v) \in E$. That is, $Adj[u]$ consists of all vertices adjacent to $u$ in $G$.
An adjacency-matrix representation consists of $|V| \times |V|$ matrix $A = a_{ij}$ such that $a_{ij} = 1$ if $(i, j) \in E$, $a_{ij} = 0$ otherwise.
Write a program which reads a directed graph $G$ represented by the adjacency list, and prints its adjacency-matrix representation. $G$ consists of $n\; (=|V|)$ vertices identified by their IDs $1, 2,.., n$ respectively.
Constraints
* $1 \leq n \leq 100$
Input
In the first line, an integer $n$ is given. In the next $n$ lines, an adjacency list $Adj[u]$ for vertex $u$ are given in the following format:
$u$ $k$ $v_1$ $v_2$ ... $v_k$
$u$ is vertex ID and $k$ denotes its degree. $v_i$ are IDs of vertices adjacent to $u$.
Output
As shown in the following sample output, print the adjacent-matrix representation of $G$. Put a single space character between $a_{ij}$.
Example
Input
4
1 2 2 4
2 1 4
3 0
4 1 3
Output
0 1 0 1
0 0 0 1
0 0 0 0
0 0 1 0
Submitted Solution:
```
n = int(input())
G = [[0]*n for i in range(n)]
for i in range(n):
u,k,*vs = map(int,input().split())
for j in range(len(vs)):
G[u-1][vs[j]-1] = 1
for i in range(n):
print(" ".join(map(str,G[i])))
```
Yes
| 107,005 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are two standard ways to represent a graph $G = (V, E)$, where $V$ is a set of vertices and $E$ is a set of edges; Adjacency list representation and Adjacency matrix representation.
An adjacency-list representation consists of an array $Adj[|V|]$ of $|V|$ lists, one for each vertex in $V$. For each $u \in V$, the adjacency list $Adj[u]$ contains all vertices $v$ such that there is an edge $(u, v) \in E$. That is, $Adj[u]$ consists of all vertices adjacent to $u$ in $G$.
An adjacency-matrix representation consists of $|V| \times |V|$ matrix $A = a_{ij}$ such that $a_{ij} = 1$ if $(i, j) \in E$, $a_{ij} = 0$ otherwise.
Write a program which reads a directed graph $G$ represented by the adjacency list, and prints its adjacency-matrix representation. $G$ consists of $n\; (=|V|)$ vertices identified by their IDs $1, 2,.., n$ respectively.
Constraints
* $1 \leq n \leq 100$
Input
In the first line, an integer $n$ is given. In the next $n$ lines, an adjacency list $Adj[u]$ for vertex $u$ are given in the following format:
$u$ $k$ $v_1$ $v_2$ ... $v_k$
$u$ is vertex ID and $k$ denotes its degree. $v_i$ are IDs of vertices adjacent to $u$.
Output
As shown in the following sample output, print the adjacent-matrix representation of $G$. Put a single space character between $a_{ij}$.
Example
Input
4
1 2 2 4
2 1 4
3 0
4 1 3
Output
0 1 0 1
0 0 0 1
0 0 0 0
0 0 1 0
Submitted Solution:
```
import sys
class Graph:
def __init__(self, nodes={}):
self.nodes = nodes
n = int(input())
G = Graph()
for line in sys.stdin:
numList = line.split()
G.nodes[int(numList[0])] = list(map(int, numList[1:]))
for _ in range(n):
out = ''
for i in range(n):
if i + 1 != n:
out += '0 ' if i + 1 in G.nodes[1] else '1 '
else:
out += '0' if i + 1 in G.nodes[1] else '1'
print(out)
```
No
| 107,006 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are two standard ways to represent a graph $G = (V, E)$, where $V$ is a set of vertices and $E$ is a set of edges; Adjacency list representation and Adjacency matrix representation.
An adjacency-list representation consists of an array $Adj[|V|]$ of $|V|$ lists, one for each vertex in $V$. For each $u \in V$, the adjacency list $Adj[u]$ contains all vertices $v$ such that there is an edge $(u, v) \in E$. That is, $Adj[u]$ consists of all vertices adjacent to $u$ in $G$.
An adjacency-matrix representation consists of $|V| \times |V|$ matrix $A = a_{ij}$ such that $a_{ij} = 1$ if $(i, j) \in E$, $a_{ij} = 0$ otherwise.
Write a program which reads a directed graph $G$ represented by the adjacency list, and prints its adjacency-matrix representation. $G$ consists of $n\; (=|V|)$ vertices identified by their IDs $1, 2,.., n$ respectively.
Constraints
* $1 \leq n \leq 100$
Input
In the first line, an integer $n$ is given. In the next $n$ lines, an adjacency list $Adj[u]$ for vertex $u$ are given in the following format:
$u$ $k$ $v_1$ $v_2$ ... $v_k$
$u$ is vertex ID and $k$ denotes its degree. $v_i$ are IDs of vertices adjacent to $u$.
Output
As shown in the following sample output, print the adjacent-matrix representation of $G$. Put a single space character between $a_{ij}$.
Example
Input
4
1 2 2 4
2 1 4
3 0
4 1 3
Output
0 1 0 1
0 0 0 1
0 0 0 0
0 0 1 0
Submitted Solution:
```
import numpy as np
n=int(input())
g=np.zeros((n,n),dtype=np.int)
for i in range(n):
s=list(map(int,input().split()))
for j in range(s[1]):
g[s[0]][s[2+j]]+=1
print(g)
```
No
| 107,007 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are two standard ways to represent a graph $G = (V, E)$, where $V$ is a set of vertices and $E$ is a set of edges; Adjacency list representation and Adjacency matrix representation.
An adjacency-list representation consists of an array $Adj[|V|]$ of $|V|$ lists, one for each vertex in $V$. For each $u \in V$, the adjacency list $Adj[u]$ contains all vertices $v$ such that there is an edge $(u, v) \in E$. That is, $Adj[u]$ consists of all vertices adjacent to $u$ in $G$.
An adjacency-matrix representation consists of $|V| \times |V|$ matrix $A = a_{ij}$ such that $a_{ij} = 1$ if $(i, j) \in E$, $a_{ij} = 0$ otherwise.
Write a program which reads a directed graph $G$ represented by the adjacency list, and prints its adjacency-matrix representation. $G$ consists of $n\; (=|V|)$ vertices identified by their IDs $1, 2,.., n$ respectively.
Constraints
* $1 \leq n \leq 100$
Input
In the first line, an integer $n$ is given. In the next $n$ lines, an adjacency list $Adj[u]$ for vertex $u$ are given in the following format:
$u$ $k$ $v_1$ $v_2$ ... $v_k$
$u$ is vertex ID and $k$ denotes its degree. $v_i$ are IDs of vertices adjacent to $u$.
Output
As shown in the following sample output, print the adjacent-matrix representation of $G$. Put a single space character between $a_{ij}$.
Example
Input
4
1 2 2 4
2 1 4
3 0
4 1 3
Output
0 1 0 1
0 0 0 1
0 0 0 0
0 0 1 0
Submitted Solution:
```
#16D8102008K Yagyu Hazuki
n=int(input())
dp = [[0 for i in range(n)] for j in range(n)]
for _ in range(n):
inputs = list(map(int, input().split()))
u = inputs[0]
k = inputs[1]
v = inputs[2:]
for each in v:
dp[u-1][each-1] = 1
print(dp)
```
No
| 107,008 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are two standard ways to represent a graph $G = (V, E)$, where $V$ is a set of vertices and $E$ is a set of edges; Adjacency list representation and Adjacency matrix representation.
An adjacency-list representation consists of an array $Adj[|V|]$ of $|V|$ lists, one for each vertex in $V$. For each $u \in V$, the adjacency list $Adj[u]$ contains all vertices $v$ such that there is an edge $(u, v) \in E$. That is, $Adj[u]$ consists of all vertices adjacent to $u$ in $G$.
An adjacency-matrix representation consists of $|V| \times |V|$ matrix $A = a_{ij}$ such that $a_{ij} = 1$ if $(i, j) \in E$, $a_{ij} = 0$ otherwise.
Write a program which reads a directed graph $G$ represented by the adjacency list, and prints its adjacency-matrix representation. $G$ consists of $n\; (=|V|)$ vertices identified by their IDs $1, 2,.., n$ respectively.
Constraints
* $1 \leq n \leq 100$
Input
In the first line, an integer $n$ is given. In the next $n$ lines, an adjacency list $Adj[u]$ for vertex $u$ are given in the following format:
$u$ $k$ $v_1$ $v_2$ ... $v_k$
$u$ is vertex ID and $k$ denotes its degree. $v_i$ are IDs of vertices adjacent to $u$.
Output
As shown in the following sample output, print the adjacent-matrix representation of $G$. Put a single space character between $a_{ij}$.
Example
Input
4
1 2 2 4
2 1 4
3 0
4 1 3
Output
0 1 0 1
0 0 0 1
0 0 0 0
0 0 1 0
Submitted Solution:
```
n=int(input())
a=[[0 for j in range(n)]for i in range(n)]
for i in range(n):
b=list(map(int,input().split()))
for i in range(b[1]):
print(b[i+2])
a[b[0]-1][b[i+2]-1]=1
for i in range(n):
print(a[i])
```
No
| 107,009 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program to simulate rolling a dice, which can be constructed by the following net.
<image>
<image>
As shown in the figures, each face is identified by a different label from 1 to 6.
Write a program which reads integers assigned to each face identified by the label and a sequence of commands to roll the dice, and prints the integer on the top face. At the initial state, the dice is located as shown in the above figures.
Constraints
* $0 \leq $ the integer assigned to a face $ \leq 100$
* $0 \leq $ the length of the command $\leq 100$
Input
In the first line, six integers assigned to faces are given in ascending order of their corresponding labels.
In the second line, a string which represents a sequence of commands, is given. The command is one of 'E', 'N', 'S' and 'W' representing four directions shown in the above figures.
Output
Print the integer which appears on the top face after the simulation.
Examples
Input
1 2 4 8 16 32
SE
Output
8
Input
1 2 4 8 16 32
EESWN
Output
32
"Correct Solution:
```
# coding : utf-8
class Dice:
def __init__(self, label):
self.d = label
def north(self):
d = self.d
self.d = [d[1],d[5],d[2],d[3],d[0],d[4]]
def east(self):
d = self.d
self.d = [d[3],d[1],d[0],d[5],d[4],d[2]]
def west(self):
d = self.d
self.d = [d[2],d[1],d[5],d[0],d[4],d[3]]
def south(self):
d = self.d
self.d = [d[4],d[0],d[2],d[3],d[5],d[1]]
def output(self):
d = self.d
print(self.d[0])
label = list(map(int, input().split()))
op_list = list(input())
d0 = Dice(label)
for op in op_list:
if op =='N':
d0.north()
if op =='E':
d0.east()
if op =='W':
d0.west()
if op =='S':
d0.south()
d0.output()
```
| 107,010 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program to simulate rolling a dice, which can be constructed by the following net.
<image>
<image>
As shown in the figures, each face is identified by a different label from 1 to 6.
Write a program which reads integers assigned to each face identified by the label and a sequence of commands to roll the dice, and prints the integer on the top face. At the initial state, the dice is located as shown in the above figures.
Constraints
* $0 \leq $ the integer assigned to a face $ \leq 100$
* $0 \leq $ the length of the command $\leq 100$
Input
In the first line, six integers assigned to faces are given in ascending order of their corresponding labels.
In the second line, a string which represents a sequence of commands, is given. The command is one of 'E', 'N', 'S' and 'W' representing four directions shown in the above figures.
Output
Print the integer which appears on the top face after the simulation.
Examples
Input
1 2 4 8 16 32
SE
Output
8
Input
1 2 4 8 16 32
EESWN
Output
32
"Correct Solution:
```
class Dise():
def __init__(self, aLabelList):
self.LabelList = aLabelList
self.NEWS = {"N": [0,4,5,1],
"E": [0,2,5,3],
"W": [0,3,5,2],
"S": [0,1,5,4]}
def move(self,aNEWS):
idx = self.NEWS[aNEWS]
tmp = self.LabelList[idx[0]]
self.LabelList[idx[0]] = self.LabelList[idx[3]]
self.LabelList[idx[3]] = self.LabelList[idx[2]]
self.LabelList[idx[2]] = self.LabelList[idx[1]]
self.LabelList[idx[1]] = tmp
def DisePrint(self):
print(self.LabelList[0])
myInstance = Dise(input().split())
x = input()
for i in range(len(x)):
myInstance.move(x[i:i+1])
myInstance.DisePrint()
```
| 107,011 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program to simulate rolling a dice, which can be constructed by the following net.
<image>
<image>
As shown in the figures, each face is identified by a different label from 1 to 6.
Write a program which reads integers assigned to each face identified by the label and a sequence of commands to roll the dice, and prints the integer on the top face. At the initial state, the dice is located as shown in the above figures.
Constraints
* $0 \leq $ the integer assigned to a face $ \leq 100$
* $0 \leq $ the length of the command $\leq 100$
Input
In the first line, six integers assigned to faces are given in ascending order of their corresponding labels.
In the second line, a string which represents a sequence of commands, is given. The command is one of 'E', 'N', 'S' and 'W' representing four directions shown in the above figures.
Output
Print the integer which appears on the top face after the simulation.
Examples
Input
1 2 4 8 16 32
SE
Output
8
Input
1 2 4 8 16 32
EESWN
Output
32
"Correct Solution:
```
# ['表面', '南面', '東面', '西面', '北面', '裏面']
dice = input().split()
com = [c for c in input()]
rolling = {
'E': [3, 1, 0, 5, 4, 2],
'W': [2, 1, 5, 0, 4, 3],
'S': [4, 0, 2, 3, 5, 1],
'N': [1, 5, 2, 3, 0, 4]
}
for c in com:
dice = [dice[i] for i in rolling[c]]
print(dice[0])
```
| 107,012 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program to simulate rolling a dice, which can be constructed by the following net.
<image>
<image>
As shown in the figures, each face is identified by a different label from 1 to 6.
Write a program which reads integers assigned to each face identified by the label and a sequence of commands to roll the dice, and prints the integer on the top face. At the initial state, the dice is located as shown in the above figures.
Constraints
* $0 \leq $ the integer assigned to a face $ \leq 100$
* $0 \leq $ the length of the command $\leq 100$
Input
In the first line, six integers assigned to faces are given in ascending order of their corresponding labels.
In the second line, a string which represents a sequence of commands, is given. The command is one of 'E', 'N', 'S' and 'W' representing four directions shown in the above figures.
Output
Print the integer which appears on the top face after the simulation.
Examples
Input
1 2 4 8 16 32
SE
Output
8
Input
1 2 4 8 16 32
EESWN
Output
32
"Correct Solution:
```
d = [_ for _ in input().split()]
commands = input()
for c in commands:
if c == 'E':
d[0], d[2], d[3], d[5] = d[3], d[0], d[5], d[2]
elif c == 'W':
d[0], d[2], d[3], d[5] = d[2], d[5], d[0], d[3]
elif c == 'N':
d[0], d[1], d[4], d[5] = d[1], d[5], d[0], d[4]
elif c == 'S':
d[0], d[1], d[4], d[5] = d[4], d[0], d[5], d[1]
print(d[0])
```
| 107,013 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program to simulate rolling a dice, which can be constructed by the following net.
<image>
<image>
As shown in the figures, each face is identified by a different label from 1 to 6.
Write a program which reads integers assigned to each face identified by the label and a sequence of commands to roll the dice, and prints the integer on the top face. At the initial state, the dice is located as shown in the above figures.
Constraints
* $0 \leq $ the integer assigned to a face $ \leq 100$
* $0 \leq $ the length of the command $\leq 100$
Input
In the first line, six integers assigned to faces are given in ascending order of their corresponding labels.
In the second line, a string which represents a sequence of commands, is given. The command is one of 'E', 'N', 'S' and 'W' representing four directions shown in the above figures.
Output
Print the integer which appears on the top face after the simulation.
Examples
Input
1 2 4 8 16 32
SE
Output
8
Input
1 2 4 8 16 32
EESWN
Output
32
"Correct Solution:
```
d=list(map(int,input().split()))
o=str(input())
for i in o:
if i=='N':
d[0],d[1],d[4],d[5]=d[1],d[5],d[0],d[4]
elif i=='S':
d[0],d[1],d[4],d[5]=d[4],d[0],d[5],d[1]
elif i=='E':
d[0],d[2],d[3],d[5]=d[3],d[0],d[5],d[2]
elif i=='W':
d[0],d[2],d[3],d[5]=d[2],d[5],d[0],d[3]
print(int(d[0]))
```
| 107,014 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program to simulate rolling a dice, which can be constructed by the following net.
<image>
<image>
As shown in the figures, each face is identified by a different label from 1 to 6.
Write a program which reads integers assigned to each face identified by the label and a sequence of commands to roll the dice, and prints the integer on the top face. At the initial state, the dice is located as shown in the above figures.
Constraints
* $0 \leq $ the integer assigned to a face $ \leq 100$
* $0 \leq $ the length of the command $\leq 100$
Input
In the first line, six integers assigned to faces are given in ascending order of their corresponding labels.
In the second line, a string which represents a sequence of commands, is given. The command is one of 'E', 'N', 'S' and 'W' representing four directions shown in the above figures.
Output
Print the integer which appears on the top face after the simulation.
Examples
Input
1 2 4 8 16 32
SE
Output
8
Input
1 2 4 8 16 32
EESWN
Output
32
"Correct Solution:
```
a1,a2,a3,a4,a5,a6=map(int,input().split())
s=input()
for i in s:
if i=="E":
a1,a2,a3,a4,a5,a6=a4,a2,a1,a6,a5,a3
elif i=="S":
a1,a2,a3,a4,a5,a6=a5,a1,a3,a4,a6,a2
elif i=="W":
a1,a2,a3,a4,a5,a6=a3,a2,a6,a1,a5,a4
elif i=="N":
a1,a2,a3,a4,a5,a6=a2,a6,a3,a4,a1,a5
print(a1)
```
| 107,015 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program to simulate rolling a dice, which can be constructed by the following net.
<image>
<image>
As shown in the figures, each face is identified by a different label from 1 to 6.
Write a program which reads integers assigned to each face identified by the label and a sequence of commands to roll the dice, and prints the integer on the top face. At the initial state, the dice is located as shown in the above figures.
Constraints
* $0 \leq $ the integer assigned to a face $ \leq 100$
* $0 \leq $ the length of the command $\leq 100$
Input
In the first line, six integers assigned to faces are given in ascending order of their corresponding labels.
In the second line, a string which represents a sequence of commands, is given. The command is one of 'E', 'N', 'S' and 'W' representing four directions shown in the above figures.
Output
Print the integer which appears on the top face after the simulation.
Examples
Input
1 2 4 8 16 32
SE
Output
8
Input
1 2 4 8 16 32
EESWN
Output
32
"Correct Solution:
```
dice = list(input().split(' '))
a = list(input())
for i in a:
if i == 'W':
dice = [dice[2],dice[1],dice[5],dice[0],dice[4],dice[3]]
elif i == 'S':
dice = [dice[4],dice[0],dice[2],dice[3],dice[5],dice[1]]
elif i == 'N':
dice = [dice[1],dice[5],dice[2],dice[3],dice[0],dice[4]]
elif i == 'E':
dice = [dice[3],dice[1],dice[0],dice[5],dice[4],dice[2]]
print(dice[0])
```
| 107,016 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program to simulate rolling a dice, which can be constructed by the following net.
<image>
<image>
As shown in the figures, each face is identified by a different label from 1 to 6.
Write a program which reads integers assigned to each face identified by the label and a sequence of commands to roll the dice, and prints the integer on the top face. At the initial state, the dice is located as shown in the above figures.
Constraints
* $0 \leq $ the integer assigned to a face $ \leq 100$
* $0 \leq $ the length of the command $\leq 100$
Input
In the first line, six integers assigned to faces are given in ascending order of their corresponding labels.
In the second line, a string which represents a sequence of commands, is given. The command is one of 'E', 'N', 'S' and 'W' representing four directions shown in the above figures.
Output
Print the integer which appears on the top face after the simulation.
Examples
Input
1 2 4 8 16 32
SE
Output
8
Input
1 2 4 8 16 32
EESWN
Output
32
"Correct Solution:
```
def swap(dice,i,j,k,l):#diceの目をi→ｊ→ｋ→ｌ→iの順に入れ替える
x=dice[l]
dice[l]=dice[k]
dice[k]=dice[j]
dice[j]=dice[i]
dice[i]=x
return dice
dice=list(map(int,input().split()))
Dice=[0]
dice=Dice +dice
roll=list(input())
for i in range(0,len(roll)):
if(roll[i]=="S"):
dice=swap(dice,1,2,6,5)
elif(roll[i]=="E"):
dice=swap(dice,1,3,6,4)
elif(roll[i]=="W"):
dice=swap(dice,1,4,6,3)
elif(roll[i]=="N"):
dice=swap(dice,1,5,6,2)
print(dice[1])
```
| 107,017 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program to simulate rolling a dice, which can be constructed by the following net.
<image>
<image>
As shown in the figures, each face is identified by a different label from 1 to 6.
Write a program which reads integers assigned to each face identified by the label and a sequence of commands to roll the dice, and prints the integer on the top face. At the initial state, the dice is located as shown in the above figures.
Constraints
* $0 \leq $ the integer assigned to a face $ \leq 100$
* $0 \leq $ the length of the command $\leq 100$
Input
In the first line, six integers assigned to faces are given in ascending order of their corresponding labels.
In the second line, a string which represents a sequence of commands, is given. The command is one of 'E', 'N', 'S' and 'W' representing four directions shown in the above figures.
Output
Print the integer which appears on the top face after the simulation.
Examples
Input
1 2 4 8 16 32
SE
Output
8
Input
1 2 4 8 16 32
EESWN
Output
32
Submitted Solution:
```
initial=list( map(int,input().split()))
change=initial
def East(a,b,c,d,e,f):
return [d, b, a, f, e, c]
def West(a,b,c,d,e,f):
return [c, b, f, a, e, d]
def South(a,b,c,d,e,f):
return [e, a, c, d, f, b]
def North(a,b,c,d,e,f):
return [b, f, c, d, a, e]
a=input()
for idx in range(0, len(a)):
if a[idx]=="E":
change=East(*change)
elif a[idx]=="W":
change=West(*change)
elif a[idx]=="S":
change=South(*change)
elif a[idx]=="N":
change=North(*change)
print(change[0])
```
Yes
| 107,018 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program to simulate rolling a dice, which can be constructed by the following net.
<image>
<image>
As shown in the figures, each face is identified by a different label from 1 to 6.
Write a program which reads integers assigned to each face identified by the label and a sequence of commands to roll the dice, and prints the integer on the top face. At the initial state, the dice is located as shown in the above figures.
Constraints
* $0 \leq $ the integer assigned to a face $ \leq 100$
* $0 \leq $ the length of the command $\leq 100$
Input
In the first line, six integers assigned to faces are given in ascending order of their corresponding labels.
In the second line, a string which represents a sequence of commands, is given. The command is one of 'E', 'N', 'S' and 'W' representing four directions shown in the above figures.
Output
Print the integer which appears on the top face after the simulation.
Examples
Input
1 2 4 8 16 32
SE
Output
8
Input
1 2 4 8 16 32
EESWN
Output
32
Submitted Solution:
```
def rotate(l, d):
if d == 'S':
return [l[4], l[0], l[2], l[3], l[5], l[1]]
if d == 'N':
return [l[1], l[5], l[2], l[3], l[0], l[4]]
if d == 'W':
return [l[2], l[1], l[5], l[0], l[4], l[3]]
if d == 'E':
return [l[3], l[1], l[0], l[5], l[4], l[2]]
l = list(map(int, input().split()))
for c in input():
l = rotate(l, c)
print(l[0])
```
Yes
| 107,019 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program to simulate rolling a dice, which can be constructed by the following net.
<image>
<image>
As shown in the figures, each face is identified by a different label from 1 to 6.
Write a program which reads integers assigned to each face identified by the label and a sequence of commands to roll the dice, and prints the integer on the top face. At the initial state, the dice is located as shown in the above figures.
Constraints
* $0 \leq $ the integer assigned to a face $ \leq 100$
* $0 \leq $ the length of the command $\leq 100$
Input
In the first line, six integers assigned to faces are given in ascending order of their corresponding labels.
In the second line, a string which represents a sequence of commands, is given. The command is one of 'E', 'N', 'S' and 'W' representing four directions shown in the above figures.
Output
Print the integer which appears on the top face after the simulation.
Examples
Input
1 2 4 8 16 32
SE
Output
8
Input
1 2 4 8 16 32
EESWN
Output
32
Submitted Solution:
```
dice = [int(e) for e in input().split()]
roll = input()
for roll1 in roll:
if roll1 == "N":
dice = [dice[1],dice[5],dice[2],dice[3],dice[0],dice[4]]
elif roll1 == "W":
dice = [dice[2],dice[1],dice[5],dice[0],dice[4],dice[3]]
elif roll1 == "E":
dice = [dice[3],dice[1],dice[0],dice[5],dice[4],dice[2]]
elif roll1 == "S":
dice = [dice[4],dice[0],dice[2],dice[3],dice[5],dice[1]]
print(dice[0])
```
Yes
| 107,020 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program to simulate rolling a dice, which can be constructed by the following net.
<image>
<image>
As shown in the figures, each face is identified by a different label from 1 to 6.
Write a program which reads integers assigned to each face identified by the label and a sequence of commands to roll the dice, and prints the integer on the top face. At the initial state, the dice is located as shown in the above figures.
Constraints
* $0 \leq $ the integer assigned to a face $ \leq 100$
* $0 \leq $ the length of the command $\leq 100$
Input
In the first line, six integers assigned to faces are given in ascending order of their corresponding labels.
In the second line, a string which represents a sequence of commands, is given. The command is one of 'E', 'N', 'S' and 'W' representing four directions shown in the above figures.
Output
Print the integer which appears on the top face after the simulation.
Examples
Input
1 2 4 8 16 32
SE
Output
8
Input
1 2 4 8 16 32
EESWN
Output
32
Submitted Solution:
```
u, s, e, w, n, d = input().split()
t = input()
for i in t:
if i == 'N':
u, s, n, d = s, d, u, n
elif i == 'E':
u, e, w, d = w, u, d, e
elif i == 'S':
u, s, n, d = n, u, d, s
elif i == 'W':
u, e, w, d = e, d, u, w
print(u)
```
Yes
| 107,021 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program to simulate rolling a dice, which can be constructed by the following net.
<image>
<image>
As shown in the figures, each face is identified by a different label from 1 to 6.
Write a program which reads integers assigned to each face identified by the label and a sequence of commands to roll the dice, and prints the integer on the top face. At the initial state, the dice is located as shown in the above figures.
Constraints
* $0 \leq $ the integer assigned to a face $ \leq 100$
* $0 \leq $ the length of the command $\leq 100$
Input
In the first line, six integers assigned to faces are given in ascending order of their corresponding labels.
In the second line, a string which represents a sequence of commands, is given. The command is one of 'E', 'N', 'S' and 'W' representing four directions shown in the above figures.
Output
Print the integer which appears on the top face after the simulation.
Examples
Input
1 2 4 8 16 32
SE
Output
8
Input
1 2 4 8 16 32
EESWN
Output
32
Submitted Solution:
```
#!/usr/bin/env python
faces = list(map(int, input().split()))
print(faces)
command = list(input())
print(command)
def dice(face, command):
face_1 = {"E": 4, "W": 3, "S": 5, "N": 2}
face_2 = {"E": 4, "W": 3, "S": 1, "N": 6}
face_3 = {"E": 2, "W": 5, "S": 1, "N": 6}
face_4 = {"E": 5, "W": 2, "S": 1, "N": 6}
face_5 = {"E": 4, "W": 3, "S": 6, "N": 1}
face_6 = {"E": 4, "W": 3, "S": 2, "N": 1}
rulebase = [face_1, face_2, face_3, face_4, face_5, face_6]
return rulebase[face - 1][command]
top = 1
for c in command:
top = dice(top, c)
print(top)
print(faces[top - 1])
```
No
| 107,022 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program to simulate rolling a dice, which can be constructed by the following net.
<image>
<image>
As shown in the figures, each face is identified by a different label from 1 to 6.
Write a program which reads integers assigned to each face identified by the label and a sequence of commands to roll the dice, and prints the integer on the top face. At the initial state, the dice is located as shown in the above figures.
Constraints
* $0 \leq $ the integer assigned to a face $ \leq 100$
* $0 \leq $ the length of the command $\leq 100$
Input
In the first line, six integers assigned to faces are given in ascending order of their corresponding labels.
In the second line, a string which represents a sequence of commands, is given. The command is one of 'E', 'N', 'S' and 'W' representing four directions shown in the above figures.
Output
Print the integer which appears on the top face after the simulation.
Examples
Input
1 2 4 8 16 32
SE
Output
8
Input
1 2 4 8 16 32
EESWN
Output
32
Submitted Solution:
```
import sys
data=list(map(int,input().split()))
order=sys.stdin.readline()
char_list=list(order)
for i in char_list:
if i=='N':
print(i)
k=data[1]
m=data[5]
data[0]=data[1]
data[1]=data[5]
data[4]=k
data[5]=m
elif i=='E':
k=data[0]
m=data[2]
data[0]=data[3]
data[2]=k
data[3]=data[5]
data[5]=m
elif i=='S':
k=data[0]
m=data[1]
data[0]=data[4]
data[1]=k
data[4]=data[5]
data[5]=m
elif i=='W':
k=data[0]
m=data[3]
data[0]=data[2]
data[3]=data[5]
data[4]=k
data[5]=m
print(data[0])
```
No
| 107,023 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program to simulate rolling a dice, which can be constructed by the following net.
<image>
<image>
As shown in the figures, each face is identified by a different label from 1 to 6.
Write a program which reads integers assigned to each face identified by the label and a sequence of commands to roll the dice, and prints the integer on the top face. At the initial state, the dice is located as shown in the above figures.
Constraints
* $0 \leq $ the integer assigned to a face $ \leq 100$
* $0 \leq $ the length of the command $\leq 100$
Input
In the first line, six integers assigned to faces are given in ascending order of their corresponding labels.
In the second line, a string which represents a sequence of commands, is given. The command is one of 'E', 'N', 'S' and 'W' representing four directions shown in the above figures.
Output
Print the integer which appears on the top face after the simulation.
Examples
Input
1 2 4 8 16 32
SE
Output
8
Input
1 2 4 8 16 32
EESWN
Output
32
Submitted Solution:
```
l = list(map(int, input().split()))
s = input()
for c in s:
if c == "S":
l = [l[4], l[0], l[2], l[3], l[1], l[5]]
elif c == "N":
l = [l[1], l[5], l[2], l[3], l[4], l[0]]
elif c == "E":
l = [l[3], l[1], l[0], l[5], l[4], l[2]]
else:
l = [l[2], l[1], l[5], l[0], l[4], l[3]]
print(l[0])
```
No
| 107,024 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program to simulate rolling a dice, which can be constructed by the following net.
<image>
<image>
As shown in the figures, each face is identified by a different label from 1 to 6.
Write a program which reads integers assigned to each face identified by the label and a sequence of commands to roll the dice, and prints the integer on the top face. At the initial state, the dice is located as shown in the above figures.
Constraints
* $0 \leq $ the integer assigned to a face $ \leq 100$
* $0 \leq $ the length of the command $\leq 100$
Input
In the first line, six integers assigned to faces are given in ascending order of their corresponding labels.
In the second line, a string which represents a sequence of commands, is given. The command is one of 'E', 'N', 'S' and 'W' representing four directions shown in the above figures.
Output
Print the integer which appears on the top face after the simulation.
Examples
Input
1 2 4 8 16 32
SE
Output
8
Input
1 2 4 8 16 32
EESWN
Output
32
Submitted Solution:
```
def __init__ (self,data):
self.data = data
class Dice:
def move(self,direction):
if direction == 'E':
self.data[0],self.data[3],self.data[5],self.data[2] = \
self.data[3],self.data[5],self.data[2],self.data[0]
elif direction == 'N':
self.data[0],self.data[4],self.data[5],self.data[1] = \
self.data[4],elf.data[5],self.data[1],self.data[0]
elif direction == 'S':
self.data[0],self.data[1],self.data[5],self.data[4] = \
self.data[4],self.data[0],self.data[1],self.data[5]
elif direction == 'W':
self.data[0],self.data[2],self.data[5],self.data[3] = \
self.data[2],self.data[5],self.data[3],self.data[0]
def getTop(self):
return self.data[0]
dice = Dice(input().split())
cmd = input()
for i in range(len(cmd)):
dice.move(cmd[i])
print(dice.getTop())
```
No
| 107,025 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After the war, the supersonic rocket became the most common public transportation.
Each supersonic rocket consists of two "engines". Each engine is a set of "power sources". The first engine has n power sources, and the second one has m power sources. A power source can be described as a point (x_i, y_i) on a 2-D plane. All points in each engine are different.
You can manipulate each engine separately. There are two operations that you can do with each engine. You can do each operation as many times as you want.
1. For every power source as a whole in that engine: (x_i, y_i) becomes (x_i+a, y_i+b), a and b can be any real numbers. In other words, all power sources will be shifted.
2. For every power source as a whole in that engine: (x_i, y_i) becomes (x_i cos θ - y_i sin θ, x_i sin θ + y_i cos θ), θ can be any real number. In other words, all power sources will be rotated.
The engines work as follows: after the two engines are powered, their power sources are being combined (here power sources of different engines may coincide). If two power sources A(x_a, y_a) and B(x_b, y_b) exist, then for all real number k that 0 < k < 1, a new power source will be created C_k(kx_a+(1-k)x_b,ky_a+(1-k)y_b). Then, this procedure will be repeated again with all new and old power sources. After that, the "power field" from all power sources will be generated (can be considered as an infinite set of all power sources occurred).
A supersonic rocket is "safe" if and only if after you manipulate the engines, destroying any power source and then power the engine, the power field generated won't be changed (comparing to the situation where no power source erased). Two power fields are considered the same if and only if any power source in one field belongs to the other one as well.
Given a supersonic rocket, check whether it is safe or not.
Input
The first line contains two integers n, m (3 ≤ n, m ≤ 10^5) — the number of power sources in each engine.
Each of the next n lines contains two integers x_i and y_i (0≤ x_i, y_i≤ 10^8) — the coordinates of the i-th power source in the first engine.
Each of the next m lines contains two integers x_i and y_i (0≤ x_i, y_i≤ 10^8) — the coordinates of the i-th power source in the second engine.
It is guaranteed that there are no two or more power sources that are located in the same point in each engine.
Output
Print "YES" if the supersonic rocket is safe, otherwise "NO".
You can print each letter in an arbitrary case (upper or lower).
Examples
Input
3 4
0 0
0 2
2 0
0 2
2 2
2 0
1 1
Output
YES
Input
3 4
0 0
0 2
2 0
0 2
2 2
2 0
0 0
Output
NO
Note
The first sample:
<image> Those near pairs of blue and orange points actually coincide.
First, manipulate the first engine: use the second operation with θ = π (to rotate all power sources 180 degrees).
The power sources in the first engine become (0, 0), (0, -2), and (-2, 0).
<image>
Second, manipulate the second engine: use the first operation with a = b = -2.
The power sources in the second engine become (-2, 0), (0, 0), (0, -2), and (-1, -1).
<image>
You can examine that destroying any point, the power field formed by the two engines are always the solid triangle (0, 0), (-2, 0), (0, -2).
In the second sample, no matter how you manipulate the engines, there always exists a power source in the second engine that power field will shrink if you destroy it.
Tags: geometry, hashing, strings
Correct Solution:
```
import sys
# > 0 anti-clock, < 0 clockwise, == 0 same line
def orientation(p1, p2, p3):
return (p2[0] - p1[0])*(p3[1] - p1[1]) - (p2[1] - p1[1])*(p3[0] - p1[0])
def dot(p1, p2, p3, p4):
return (p2[0]-p1[0])*(p4[0]-p3[0]) + (p2[1]-p1[1])*(p4[1]-p3[1])
def theta(p1, p2):
dx = p2[0] - p1[0]
dy = p2[1] - p1[1]
if abs(dx) < 0.1 and abs(dy) < 0.1:
t = 0
else:
t = dy/(abs(dx) + abs(dy))
if abs(t) < 0.1 ** 10:
t = 0
if dx < 0:
t = 2 - t
elif dy < 0:
t = 4 + t
return t*90
def dist_sq(p1, p2):
return (p1[0] - p2[0])*(p1[0] - p2[0]) + (p1[1] - p2[1])*(p1[1] - p2[1])
def chull(points):
# let 0 element to be smallest, reorder elements
pi = [x for x in range(len(points))]
min_y = points[0][1]
min_x = points[0][0]
min_ind = 0
for i in range(len(points)):
if points[i][1] < min_y or points[i][1] == min_y and points[i][0] < min_x:
min_y = points[i][1]
min_x = points[i][0]
min_ind = i
pi[0] = min_ind
pi[min_ind] = 0
th = [theta(points[pi[0]], points[x]) for x in range(len(points))]
pi.sort(key=lambda x: th[x])
# process equals
unique = [pi[0], pi[1]]
for i in range(2, len(pi)):
if th[pi[i]] != th[unique[-1]]:
unique.append(pi[i])
else:
if dist_sq(points[pi[0]], points[unique[-1]]) < dist_sq(points[pi[0]], points[pi[i]]):
unique[-1] = pi[i] # put max
pi = unique
stack = []
for i in range(min(len(pi), 3)):
stack.append(points[pi[i]])
if len(stack) < 3:
return stack
for i in range(3, len(pi)):
while len(stack) >= 2:
o = orientation(stack[-2], stack[-1], points[pi[i]])
if o > 0:
stack.append(points[pi[i]])
break
elif o < 0:
stack.pop()
else: # ==
if dist_sq(stack[-2], stack[-1]) < dist_sq(stack[-2], points[pi[i]]):
stack.pop()
else:
break # skip i-th point
return stack
def z_func(s):
slen, l, r = len(s), 0, 0
z = [0]*slen
z[0] = slen
for i in range(1, slen):
if i <= r: z[i] = min(r-i+1, z[i-l])
while i+z[i] < slen and s[z[i]] == s[i+z[i]]: z[i] += 1
if i+z[i]-1 > r: l, r = i, i+z[i]-1
return z
n,m = map(int, sys.stdin.readline().strip().split())
a = []
for _ in range(n):
x,y = map(int, sys.stdin.readline().strip().split())
a.append((x, y))
b = []
for _ in range(m):
x, y = map(int, sys.stdin.readline().strip().split())
b.append((x, y))
ah = chull(a)
bh = chull(b)
if len(ah) == len(bh):
if len(ah) == 2:
if dist_sq(ah[0], ah[1]) == dist_sq(bh[0], bh[1]):
print('YES')
else:
print('NO')
else:
da = []
for i in range(len(ah)):
dot_a = dot(ah[i-2], ah[i-1], ah[i-1], ah[i])
da.append((dist_sq(ah[i], ah[i-1]), dot_a))
db = []
for i in range(len(bh)):
dot_b = dot(bh[i - 2], bh[i - 1], bh[i - 1], bh[i])
db.append((dist_sq(bh[i], bh[i-1]), dot_b))
l = r = 0
daab = []
daab.extend(db)
daab.append(-1)
daab.extend(da)
daab.extend(da)
zab = z_func(daab)
found = False
for i in range(len(db)+1, len(daab)-len(db)+1):
if zab[i] == len(db):
found = True
break
if found:
print('YES')
else:
print('NO')
else:
print('NO')
```
| 107,026 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After the war, the supersonic rocket became the most common public transportation.
Each supersonic rocket consists of two "engines". Each engine is a set of "power sources". The first engine has n power sources, and the second one has m power sources. A power source can be described as a point (x_i, y_i) on a 2-D plane. All points in each engine are different.
You can manipulate each engine separately. There are two operations that you can do with each engine. You can do each operation as many times as you want.
1. For every power source as a whole in that engine: (x_i, y_i) becomes (x_i+a, y_i+b), a and b can be any real numbers. In other words, all power sources will be shifted.
2. For every power source as a whole in that engine: (x_i, y_i) becomes (x_i cos θ - y_i sin θ, x_i sin θ + y_i cos θ), θ can be any real number. In other words, all power sources will be rotated.
The engines work as follows: after the two engines are powered, their power sources are being combined (here power sources of different engines may coincide). If two power sources A(x_a, y_a) and B(x_b, y_b) exist, then for all real number k that 0 < k < 1, a new power source will be created C_k(kx_a+(1-k)x_b,ky_a+(1-k)y_b). Then, this procedure will be repeated again with all new and old power sources. After that, the "power field" from all power sources will be generated (can be considered as an infinite set of all power sources occurred).
A supersonic rocket is "safe" if and only if after you manipulate the engines, destroying any power source and then power the engine, the power field generated won't be changed (comparing to the situation where no power source erased). Two power fields are considered the same if and only if any power source in one field belongs to the other one as well.
Given a supersonic rocket, check whether it is safe or not.
Input
The first line contains two integers n, m (3 ≤ n, m ≤ 10^5) — the number of power sources in each engine.
Each of the next n lines contains two integers x_i and y_i (0≤ x_i, y_i≤ 10^8) — the coordinates of the i-th power source in the first engine.
Each of the next m lines contains two integers x_i and y_i (0≤ x_i, y_i≤ 10^8) — the coordinates of the i-th power source in the second engine.
It is guaranteed that there are no two or more power sources that are located in the same point in each engine.
Output
Print "YES" if the supersonic rocket is safe, otherwise "NO".
You can print each letter in an arbitrary case (upper or lower).
Examples
Input
3 4
0 0
0 2
2 0
0 2
2 2
2 0
1 1
Output
YES
Input
3 4
0 0
0 2
2 0
0 2
2 2
2 0
0 0
Output
NO
Note
The first sample:
<image> Those near pairs of blue and orange points actually coincide.
First, manipulate the first engine: use the second operation with θ = π (to rotate all power sources 180 degrees).
The power sources in the first engine become (0, 0), (0, -2), and (-2, 0).
<image>
Second, manipulate the second engine: use the first operation with a = b = -2.
The power sources in the second engine become (-2, 0), (0, 0), (0, -2), and (-1, -1).
<image>
You can examine that destroying any point, the power field formed by the two engines are always the solid triangle (0, 0), (-2, 0), (0, -2).
In the second sample, no matter how you manipulate the engines, there always exists a power source in the second engine that power field will shrink if you destroy it.
Submitted Solution:
```
import sys
# > 0 anti-clock, < 0 clockwise, == 0 same line
def orientation(p1, p2, p3):
return (p2[0] - p1[0])*(p3[1] - p1[1]) - (p2[1] - p1[1])*(p3[0] - p1[0])
def theta(p1, p2):
dx = p2[0] - p1[0]
dy = p2[1] - p1[1]
if abs(dx) < 0.1**10 and abs(dy) < 0.1**10:
t = 0
else:
t = dy/(abs(dx) + abs(dy))
if dx < 0:
t = 2 - t
elif dy < 0:
t = 4 + t
return t*90
def dist_sq(p1, p2):
return (p1[0] - p2[0])*(p1[0] - p2[0]) + (p1[1] - p2[1])*(p1[1] - p2[1])
def chull(points):
# let 0 element to be smallest, reorder elements
pi = [x for x in range(len(points))]
min_y = points[0][1]
min_ind = 0
for i in range(len(points)):
if points[i][1] < min_y:
min_y = points[i][1]
min_ind = i
pi[0] = min_ind
pi[min_ind] = 0
th = [theta(points[pi[0]], points[x]) for x in range(len(points))]
pi.sort(key=lambda x: th[x])
# process equals
unique = [pi[0], pi[1]]
for i in range(2, len(pi)):
if th[pi[i]] != th[unique[-1]]:
unique.append(pi[i])
else:
if dist_sq(points[pi[0]], points[unique[-1]]) < dist_sq(points[pi[0]], points[pi[i]]):
unique[-1] = pi[i] # put max
pi = unique
stack = []
for i in range(min(len(pi), 3)):
stack.append(points[pi[i]])
if len(stack) < 3:
return stack
for i in range(3, len(pi)):
while len(stack) >= 2:
o = orientation(stack[-2], stack[-1], points[pi[i]])
if o > 0:
stack.append(points[pi[i]])
break
elif o < 0:
stack.pop()
else: # ==
if dist_sq(stack[-2], stack[-1]) < dist_sq(stack[-2], points[pi[i]]):
stack.pop()
else:
break # skip i-th point
return stack
def z_func(s):
slen, l, r = len(s), 0, 0
z = [0]*slen
z[0] = slen
for i in range(1, slen):
if i <= r: z[i] = min(r-i+1, z[i-l])
while i+z[i] < slen and s[z[i]] == s[i+z[i]]: z[i] += 1
if i+z[i]-1 > r: l, r = i, i+z[i]-1
return z
n,m = map(int, sys.stdin.readline().strip().split())
a = []
for _ in range(n):
x,y = map(int, sys.stdin.readline().strip().split())
a.append((x, y))
b = []
for _ in range(m):
x, y = map(int, sys.stdin.readline().strip().split())
b.append((x, y))
ah = chull(a)
bh = chull(b)
if len(ah) == len(bh):
if len(ah) == 2:
if dist_sq(ah[0], ah[1]) == dist_sq(bh[0], bh[1]):
print('YES')
else:
print('NO')
else:
da = []
for i in range(len(ah)):
da.append((dist_sq(ah[i], ah[i-1]), orientation(ah[i-2], ah[i-1], ah[i])))
db = []
for i in range(len(bh)):
db.append((dist_sq(bh[i], bh[i - 1]), orientation(bh[i - 2], bh[i - 1], bh[i])))
l = r = 0
dab = []
dab.extend(da)
dab.append(-1111)
dab.extend(db)
zab = z_func(dab)
dba = []
dba.extend(db)
dba.append(-1111)
dba.extend(da)
zba = z_func(dba)
found = False
for i in range(len(da)+1, len(dba)):
if zab[i] == len(dba)-i:
rem = len(da) - zab[i]
if rem == 0 or zba[-rem] == rem:
found = True
if found:
print('YES')
else:
print('NO')
else:
print('NO')
```
No
| 107,027 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After the war, the supersonic rocket became the most common public transportation.
Each supersonic rocket consists of two "engines". Each engine is a set of "power sources". The first engine has n power sources, and the second one has m power sources. A power source can be described as a point (x_i, y_i) on a 2-D plane. All points in each engine are different.
You can manipulate each engine separately. There are two operations that you can do with each engine. You can do each operation as many times as you want.
1. For every power source as a whole in that engine: (x_i, y_i) becomes (x_i+a, y_i+b), a and b can be any real numbers. In other words, all power sources will be shifted.
2. For every power source as a whole in that engine: (x_i, y_i) becomes (x_i cos θ - y_i sin θ, x_i sin θ + y_i cos θ), θ can be any real number. In other words, all power sources will be rotated.
The engines work as follows: after the two engines are powered, their power sources are being combined (here power sources of different engines may coincide). If two power sources A(x_a, y_a) and B(x_b, y_b) exist, then for all real number k that 0 < k < 1, a new power source will be created C_k(kx_a+(1-k)x_b,ky_a+(1-k)y_b). Then, this procedure will be repeated again with all new and old power sources. After that, the "power field" from all power sources will be generated (can be considered as an infinite set of all power sources occurred).
A supersonic rocket is "safe" if and only if after you manipulate the engines, destroying any power source and then power the engine, the power field generated won't be changed (comparing to the situation where no power source erased). Two power fields are considered the same if and only if any power source in one field belongs to the other one as well.
Given a supersonic rocket, check whether it is safe or not.
Input
The first line contains two integers n, m (3 ≤ n, m ≤ 10^5) — the number of power sources in each engine.
Each of the next n lines contains two integers x_i and y_i (0≤ x_i, y_i≤ 10^8) — the coordinates of the i-th power source in the first engine.
Each of the next m lines contains two integers x_i and y_i (0≤ x_i, y_i≤ 10^8) — the coordinates of the i-th power source in the second engine.
It is guaranteed that there are no two or more power sources that are located in the same point in each engine.
Output
Print "YES" if the supersonic rocket is safe, otherwise "NO".
You can print each letter in an arbitrary case (upper or lower).
Examples
Input
3 4
0 0
0 2
2 0
0 2
2 2
2 0
1 1
Output
YES
Input
3 4
0 0
0 2
2 0
0 2
2 2
2 0
0 0
Output
NO
Note
The first sample:
<image> Those near pairs of blue and orange points actually coincide.
First, manipulate the first engine: use the second operation with θ = π (to rotate all power sources 180 degrees).
The power sources in the first engine become (0, 0), (0, -2), and (-2, 0).
<image>
Second, manipulate the second engine: use the first operation with a = b = -2.
The power sources in the second engine become (-2, 0), (0, 0), (0, -2), and (-1, -1).
<image>
You can examine that destroying any point, the power field formed by the two engines are always the solid triangle (0, 0), (-2, 0), (0, -2).
In the second sample, no matter how you manipulate the engines, there always exists a power source in the second engine that power field will shrink if you destroy it.
Submitted Solution:
```
import sys
# > 0 anti-clock, < 0 clockwise, == 0 same line
def orientation(p1, p2, p3):
return (p2[0] - p1[0])*(p3[1] - p1[1]) - (p2[1] - p1[1])*(p3[0] - p1[0])
def theta(p1, p2):
dx = p2[0] - p1[0]
dy = p2[1] - p1[1]
if abs(dx) < 0.1**5 and abs(dy) < 0.1**5:
t = 0
else:
t = dy/(abs(dx) + abs(dy))
if dx < 0:
t = 2 - t
elif dy < 0:
t = 4 + t
return t*90
def dist_sq(p1, p2):
return (p1[0] - p2[0])*(p1[0] - p2[0]) + (p1[1] - p2[1])*(p1[1] - p2[1])
def chull(points):
# let 0 element to be smallest, reorder elements
pi = [x for x in range(len(points))]
min_y = points[0][1]
min_ind = 0
for i in range(len(points)):
if points[i][1] < min_y:
min_y = points[i][1]
min_ind = i
pi[0] = min_ind
pi[min_ind] = 0
th = [theta(points[pi[0]], points[x]) for x in range(len(points))]
pi.sort(key=lambda x: th[x])
# process equals
unique = [pi[0], pi[1]]
for i in range(2, len(pi)):
if th[pi[i]] != th[unique[-1]]:
unique.append(pi[i])
else:
if dist_sq(points[pi[0]], points[unique[-1]]) < dist_sq(points[pi[0]], points[pi[i]]):
unique[-1] = pi[i] # put max
pi = unique
stack = []
for i in range(min(len(pi), 3)):
stack.append(points[pi[i]])
if len(stack) < 3:
return stack
for i in range(3, len(pi)):
while len(stack) >= 2:
o = orientation(stack[-2], stack[-1], points[pi[i]])
if o > 0:
stack.append(points[pi[i]])
break
elif o < 0:
stack.pop()
else: # ==
if dist_sq(stack[-2], stack[-1]) < dist_sq(stack[-2], points[pi[i]]):
stack.pop()
else:
break # skip i-th point
return stack
def z_func(s):
out = []
if not s: return out
i, slen = 1, len(s)
out.append(slen)
while i < slen:
left, right = 0, i
while right < slen and s[left] == s[right]:
left += 1
right += 1
out.append(left)
i += 1
return out
n,m = map(int, sys.stdin.readline().strip().split())
a = []
for _ in range(n):
x,y = map(int, sys.stdin.readline().strip().split())
a.append((x, y))
b = []
for _ in range(m):
x, y = map(int, sys.stdin.readline().strip().split())
b.append((x, y))
ah = chull(a)
bh = chull(b)
if len(ah) == len(bh):
da = [dist_sq(ah[-1], ah[0])]
for i in range(1, len(ah)):
da.append(dist_sq(ah[i], ah[i-1]))
db = [dist_sq(bh[-1], bh[0])]
for i in range(1, len(bh)):
db.append(dist_sq(bh[i], bh[i-1]))
l = r = 0
dab = []
dab.extend(da)
dab.append(-1)
dab.extend(db)
zab = z_func(dab)
dba = []
dba.extend(db)
dba.append(-1)
dba.extend(da)
zba = z_func(dba)
found = False
for i in range(len(da)+1, len(dba)):
if zab[i] == len(dba)-i:
rem = len(da) - zab[i]
if rem == 0 or zba[-rem] == rem:
found = True
if found:
print('YES')
else:
print('NO')
else:
print('NO')
```
No
| 107,028 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After the war, the supersonic rocket became the most common public transportation.
Each supersonic rocket consists of two "engines". Each engine is a set of "power sources". The first engine has n power sources, and the second one has m power sources. A power source can be described as a point (x_i, y_i) on a 2-D plane. All points in each engine are different.
You can manipulate each engine separately. There are two operations that you can do with each engine. You can do each operation as many times as you want.
1. For every power source as a whole in that engine: (x_i, y_i) becomes (x_i+a, y_i+b), a and b can be any real numbers. In other words, all power sources will be shifted.
2. For every power source as a whole in that engine: (x_i, y_i) becomes (x_i cos θ - y_i sin θ, x_i sin θ + y_i cos θ), θ can be any real number. In other words, all power sources will be rotated.
The engines work as follows: after the two engines are powered, their power sources are being combined (here power sources of different engines may coincide). If two power sources A(x_a, y_a) and B(x_b, y_b) exist, then for all real number k that 0 < k < 1, a new power source will be created C_k(kx_a+(1-k)x_b,ky_a+(1-k)y_b). Then, this procedure will be repeated again with all new and old power sources. After that, the "power field" from all power sources will be generated (can be considered as an infinite set of all power sources occurred).
A supersonic rocket is "safe" if and only if after you manipulate the engines, destroying any power source and then power the engine, the power field generated won't be changed (comparing to the situation where no power source erased). Two power fields are considered the same if and only if any power source in one field belongs to the other one as well.
Given a supersonic rocket, check whether it is safe or not.
Input
The first line contains two integers n, m (3 ≤ n, m ≤ 10^5) — the number of power sources in each engine.
Each of the next n lines contains two integers x_i and y_i (0≤ x_i, y_i≤ 10^8) — the coordinates of the i-th power source in the first engine.
Each of the next m lines contains two integers x_i and y_i (0≤ x_i, y_i≤ 10^8) — the coordinates of the i-th power source in the second engine.
It is guaranteed that there are no two or more power sources that are located in the same point in each engine.
Output
Print "YES" if the supersonic rocket is safe, otherwise "NO".
You can print each letter in an arbitrary case (upper or lower).
Examples
Input
3 4
0 0
0 2
2 0
0 2
2 2
2 0
1 1
Output
YES
Input
3 4
0 0
0 2
2 0
0 2
2 2
2 0
0 0
Output
NO
Note
The first sample:
<image> Those near pairs of blue and orange points actually coincide.
First, manipulate the first engine: use the second operation with θ = π (to rotate all power sources 180 degrees).
The power sources in the first engine become (0, 0), (0, -2), and (-2, 0).
<image>
Second, manipulate the second engine: use the first operation with a = b = -2.
The power sources in the second engine become (-2, 0), (0, 0), (0, -2), and (-1, -1).
<image>
You can examine that destroying any point, the power field formed by the two engines are always the solid triangle (0, 0), (-2, 0), (0, -2).
In the second sample, no matter how you manipulate the engines, there always exists a power source in the second engine that power field will shrink if you destroy it.
Submitted Solution:
```
import sys
# > 0 anti-clock, < 0 clockwise, == 0 same line
def orientation(p1, p2, p3):
return (p2[0] - p1[0])*(p3[1] - p1[1]) - (p2[1] - p1[1])*(p3[0] - p1[0])
def theta(p1, p2):
dx = p2[0] - p1[0]
dy = p2[1] - p1[1]
if abs(dx) < 0.1**5 and abs(dy) < 0.1**5:
t = 0
else:
t = dy/(abs(dx) + abs(dy))
if dx < 0:
t = 2 - t
elif dy < 0:
t = 4 + t
return t*90
def dist_sq(p1, p2):
return (p1[0] - p2[0])*(p1[0] - p2[0]) + (p1[1] - p2[1])*(p1[1] - p2[1])
def chull(points):
# let 0 element to be smallest, reorder elements
pi = [x for x in range(len(points))]
min_y = points[0][1]
min_ind = 0
for i in range(len(points)):
if points[i][1] < min_y:
min_y = points[i][1]
min_ind = i
pi[0] = min_ind
pi[min_ind] = 0
th = [theta(points[pi[0]], points[x]) for x in range(len(points))]
pi.sort(key=lambda x: th[x])
# process equals
unique = [pi[0], pi[1]]
for i in range(2, len(pi)):
if th[pi[i]] != th[unique[-1]]:
unique.append(pi[i])
else:
if dist_sq(points[pi[0]], points[unique[-1]]) < dist_sq(points[pi[0]], points[pi[i]]):
unique[-1] = pi[i] # put max
pi = unique
stack = []
for i in range(min(len(pi), 3)):
stack.append(points[pi[i]])
if len(stack) < 3:
return stack
for i in range(3, len(pi)):
while len(stack) >= 2:
o = orientation(stack[-2], stack[-1], points[pi[i]])
if o > 0:
stack.append(points[pi[i]])
break
elif o < 0:
stack.pop()
else: # ==
if dist_sq(stack[-2], stack[-1]) < dist_sq(stack[-2], points[pi[i]]):
stack.pop()
else:
break # skip i-th point
return stack
def z_func(s):
out = []
if not s: return out
i, slen = 1, len(s)
out.append(slen)
while i < slen:
left, right = 0, i
while right < slen and s[left] == s[right]:
left += 1
right += 1
out.append(left)
i += 1
return out
n,m = map(int, sys.stdin.readline().strip().split())
a = []
for _ in range(n):
x,y = map(int, sys.stdin.readline().strip().split())
a.append((x, y))
b = []
for _ in range(m):
x, y = map(int, sys.stdin.readline().strip().split())
b.append((x, y))
ah = chull(a)
bh = chull(b)
if len(ah) == len(bh):
if len(ah) == 2:
if dist_sq(ah[0], ah[1]) == dist_sq(bh[0], bh[1]):
print('YES')
else:
print('NO')
else:
da = []
for i in range(len(ah)):
da.append((dist_sq(ah[i], ah[i-1]), orientation(ah[i-2], ah[i-1], ah[i])))
db = []
for i in range(len(bh)):
db.append((dist_sq(bh[i], bh[i - 1]), orientation(bh[i - 2], bh[i - 1], bh[i])))
l = r = 0
dab = []
dab.extend(da)
dab.append(-1)
dab.extend(db)
zab = z_func(dab)
dba = []
dba.extend(db)
dba.append(-1)
dba.extend(da)
zba = z_func(dba)
found = False
for i in range(len(da)+1, len(dba)):
if zab[i] == len(dba)-i:
rem = len(da) - zab[i]
if rem == 0 or zba[-rem] == rem:
found = True
if found:
print('YES')
else:
print('NO')
else:
print('NO')
```
No
| 107,029 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After the war, the supersonic rocket became the most common public transportation.
Each supersonic rocket consists of two "engines". Each engine is a set of "power sources". The first engine has n power sources, and the second one has m power sources. A power source can be described as a point (x_i, y_i) on a 2-D plane. All points in each engine are different.
You can manipulate each engine separately. There are two operations that you can do with each engine. You can do each operation as many times as you want.
1. For every power source as a whole in that engine: (x_i, y_i) becomes (x_i+a, y_i+b), a and b can be any real numbers. In other words, all power sources will be shifted.
2. For every power source as a whole in that engine: (x_i, y_i) becomes (x_i cos θ - y_i sin θ, x_i sin θ + y_i cos θ), θ can be any real number. In other words, all power sources will be rotated.
The engines work as follows: after the two engines are powered, their power sources are being combined (here power sources of different engines may coincide). If two power sources A(x_a, y_a) and B(x_b, y_b) exist, then for all real number k that 0 < k < 1, a new power source will be created C_k(kx_a+(1-k)x_b,ky_a+(1-k)y_b). Then, this procedure will be repeated again with all new and old power sources. After that, the "power field" from all power sources will be generated (can be considered as an infinite set of all power sources occurred).
A supersonic rocket is "safe" if and only if after you manipulate the engines, destroying any power source and then power the engine, the power field generated won't be changed (comparing to the situation where no power source erased). Two power fields are considered the same if and only if any power source in one field belongs to the other one as well.
Given a supersonic rocket, check whether it is safe or not.
Input
The first line contains two integers n, m (3 ≤ n, m ≤ 10^5) — the number of power sources in each engine.
Each of the next n lines contains two integers x_i and y_i (0≤ x_i, y_i≤ 10^8) — the coordinates of the i-th power source in the first engine.
Each of the next m lines contains two integers x_i and y_i (0≤ x_i, y_i≤ 10^8) — the coordinates of the i-th power source in the second engine.
It is guaranteed that there are no two or more power sources that are located in the same point in each engine.
Output
Print "YES" if the supersonic rocket is safe, otherwise "NO".
You can print each letter in an arbitrary case (upper or lower).
Examples
Input
3 4
0 0
0 2
2 0
0 2
2 2
2 0
1 1
Output
YES
Input
3 4
0 0
0 2
2 0
0 2
2 2
2 0
0 0
Output
NO
Note
The first sample:
<image> Those near pairs of blue and orange points actually coincide.
First, manipulate the first engine: use the second operation with θ = π (to rotate all power sources 180 degrees).
The power sources in the first engine become (0, 0), (0, -2), and (-2, 0).
<image>
Second, manipulate the second engine: use the first operation with a = b = -2.
The power sources in the second engine become (-2, 0), (0, 0), (0, -2), and (-1, -1).
<image>
You can examine that destroying any point, the power field formed by the two engines are always the solid triangle (0, 0), (-2, 0), (0, -2).
In the second sample, no matter how you manipulate the engines, there always exists a power source in the second engine that power field will shrink if you destroy it.
Submitted Solution:
```
import sys
# > 0 anti-clock, < 0 clockwise, == 0 same line
def orientation(p1, p2, p3):
return (p2[0] - p1[0])*(p3[1] - p1[1]) - (p2[1] - p1[1])*(p3[0] - p1[0])
def theta(p1, p2):
dx = p2[0] - p1[0]
dy = p2[1] - p1[1]
if abs(dx) < 0.1**10 and abs(dy) < 0.1**10:
t = 0
else:
t = dy/(abs(dx) + abs(dy))
if dx < 0:
t = 2 - t
elif dy < 0:
t = 4 + t
return t*90
def dist_sq(p1, p2):
return (p1[0] - p2[0])*(p1[0] - p2[0]) + (p1[1] - p2[1])*(p1[1] - p2[1])
def chull(points):
# let 0 element to be smallest, reorder elements
pi = [x for x in range(len(points))]
min_y = points[0][1]
min_ind = 0
for i in range(len(points)):
if points[i][1] < min_y:
min_y = points[i][1]
min_ind = i
pi[0] = min_ind
pi[min_ind] = 0
th = [theta(points[pi[0]], points[x]) for x in range(len(points))]
pi.sort(key=lambda x: th[x])
# process equals
unique = [pi[0], pi[1]]
for i in range(2, len(pi)):
if th[pi[i]] != th[unique[-1]]:
unique.append(pi[i])
else:
if dist_sq(points[pi[0]], points[unique[-1]]) < dist_sq(points[pi[0]], points[pi[i]]):
unique[-1] = pi[i] # put max
pi = unique
stack = []
for i in range(min(len(pi), 3)):
stack.append(points[pi[i]])
if len(stack) < 3:
return stack
for i in range(3, len(pi)):
while len(stack) >= 2:
o = orientation(stack[-2], stack[-1], points[pi[i]])
if o > 0:
stack.append(points[pi[i]])
break
elif o < 0:
stack.pop()
else: # ==
if dist_sq(stack[-2], stack[-1]) < dist_sq(stack[-2], points[pi[i]]):
stack.pop()
else:
break # skip i-th point
return stack
def z_func(s):
out = []
if not s: return out
i, slen = 1, len(s)
out.append(slen)
while i < slen:
left, right = 0, i
while right < slen and s[left] == s[right]:
left += 1
right += 1
out.append(left)
i += 1
return out
def z_func2(s):
z = [0]*len(s)
z[0] = len(s)
l = r = 0
for i in range(1, len(s)):
if i > r:
j = 0
while i+j < len(s) and s[i+j] == s[j]: j += 1
z[i] = j
l = i
r = i+j-1
else:
if z[i-l] < r-i+1:
z[i] = z[i-l]
else:
j = 1
while j + r < len(s) and s[r + j] == s[r-i+j]: j += 1
z[i] = r-i+j
l = i
r += j-1
return z
n,m = map(int, sys.stdin.readline().strip().split())
a = []
for _ in range(n):
x,y = map(int, sys.stdin.readline().strip().split())
a.append((x, y))
b = []
for _ in range(m):
x, y = map(int, sys.stdin.readline().strip().split())
b.append((x, y))
ah = chull(a)
bh = chull(b)
if len(ah) == len(bh):
if len(ah) == 2:
if dist_sq(ah[0], ah[1]) == dist_sq(bh[0], bh[1]):
print('YES')
else:
print('NO')
else:
da = []
for i in range(len(ah)):
da.append((dist_sq(ah[i], ah[i-1]), orientation(ah[i-2], ah[i-1], ah[i])))
db = []
for i in range(len(bh)):
db.append((dist_sq(bh[i], bh[i - 1]), orientation(bh[i - 2], bh[i - 1], bh[i])))
l = r = 0
dab = []
dab.extend(da)
dab.append(-1)
dab.extend(db)
zab = z_func(dab)
dba = []
dba.extend(db)
dba.append(-1)
dba.extend(da)
zba = z_func2(dba)
found = False
for i in range(len(da)+1, len(dba)):
if zab[i] == len(dba)-i:
rem = len(da) - zab[i]
if rem == 0 or zba[-rem] == rem:
found = True
if found:
print('YES')
else:
print('NO')
else:
print('NO')
```
No
| 107,030 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp has decided to buy a new TV set and hang it on the wall in his flat. The wall has enough free space so Monocarp can buy a TV set with screen width not greater than a and screen height not greater than b. Monocarp is also used to TV sets with a certain aspect ratio: formally, if the width of the screen is w, and the height of the screen is h, then the following condition should be met: w/h = x/y.
There are many different TV sets in the shop. Monocarp is sure that for any pair of positive integers w and h there is a TV set with screen width w and height h in the shop.
Monocarp isn't ready to choose the exact TV set he is going to buy. Firstly he wants to determine the optimal screen resolution. He has decided to try all possible variants of screen size. But he must count the number of pairs of positive integers w and h, beforehand, such that (w ≤ a), (h ≤ b) and (w/h = x/y).
In other words, Monocarp wants to determine the number of TV sets having aspect ratio x/y, screen width not exceeding a, and screen height not exceeding b. Two TV sets are considered different if they have different screen width or different screen height.
Input
The first line contains four integers a, b, x, y (1 ≤ a, b, x, y ≤ 10^{18}) — the constraints on the screen width and height, and on the aspect ratio.
Output
Print one integer — the number of different variants to choose TV screen width and screen height so that they meet the aforementioned constraints.
Examples
Input
17 15 5 3
Output
3
Input
14 16 7 22
Output
0
Input
4 2 6 4
Output
1
Input
1000000000000000000 1000000000000000000 999999866000004473 999999822000007597
Output
1000000063
Note
In the first example, there are 3 possible variants: (5, 3), (10, 6), (15, 9).
In the second example, there is no TV set meeting the constraints.
In the third example, there is only one variant: (3, 2).
Tags: math
Correct Solution:
```
def uscln(u, v):
if u == v:
return u
elif u == 0:
return v
elif v == 0:
return u
elif u & 1 == 0:
if v & 1 == 0:
return 2*uscln(u >> 1, v >> 1)
else:
return uscln(u >> 1, v)
elif u & 1 != 0:
if v & 1 == 0:
return uscln(u, v >> 1)
elif u > v and v & 1 != 0:
return uscln((u-v) >> 1, v)
else:
return uscln((v-u) >> 1, u)
[a,b,x,y] = list(map(int,input(' ').split(' ')))
temp = uscln(x,y)
print(int(min(a/(x/temp),b/(y/temp))))
```
| 107,031 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp has decided to buy a new TV set and hang it on the wall in his flat. The wall has enough free space so Monocarp can buy a TV set with screen width not greater than a and screen height not greater than b. Monocarp is also used to TV sets with a certain aspect ratio: formally, if the width of the screen is w, and the height of the screen is h, then the following condition should be met: w/h = x/y.
There are many different TV sets in the shop. Monocarp is sure that for any pair of positive integers w and h there is a TV set with screen width w and height h in the shop.
Monocarp isn't ready to choose the exact TV set he is going to buy. Firstly he wants to determine the optimal screen resolution. He has decided to try all possible variants of screen size. But he must count the number of pairs of positive integers w and h, beforehand, such that (w ≤ a), (h ≤ b) and (w/h = x/y).
In other words, Monocarp wants to determine the number of TV sets having aspect ratio x/y, screen width not exceeding a, and screen height not exceeding b. Two TV sets are considered different if they have different screen width or different screen height.
Input
The first line contains four integers a, b, x, y (1 ≤ a, b, x, y ≤ 10^{18}) — the constraints on the screen width and height, and on the aspect ratio.
Output
Print one integer — the number of different variants to choose TV screen width and screen height so that they meet the aforementioned constraints.
Examples
Input
17 15 5 3
Output
3
Input
14 16 7 22
Output
0
Input
4 2 6 4
Output
1
Input
1000000000000000000 1000000000000000000 999999866000004473 999999822000007597
Output
1000000063
Note
In the first example, there are 3 possible variants: (5, 3), (10, 6), (15, 9).
In the second example, there is no TV set meeting the constraints.
In the third example, there is only one variant: (3, 2).
Tags: math
Correct Solution:
```
def HOD(a, b):
while (b > 0):
a, b = b, a % b
return a
a, b, x, y = map(int, input().split())
d = HOD(x, y)
x //= d
y //= d
# w * y = h * x
# W % x == 0
# H % y == 0
#w / x = h / y
maxw = (a // x) * x
maxw1 = a // x * y
maxh = (b // y) * y
maxh1 = b // y * x
if (maxw1 <= b):
print(a // x)
else:
print(b // y)
```
| 107,032 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp has decided to buy a new TV set and hang it on the wall in his flat. The wall has enough free space so Monocarp can buy a TV set with screen width not greater than a and screen height not greater than b. Monocarp is also used to TV sets with a certain aspect ratio: formally, if the width of the screen is w, and the height of the screen is h, then the following condition should be met: w/h = x/y.
There are many different TV sets in the shop. Monocarp is sure that for any pair of positive integers w and h there is a TV set with screen width w and height h in the shop.
Monocarp isn't ready to choose the exact TV set he is going to buy. Firstly he wants to determine the optimal screen resolution. He has decided to try all possible variants of screen size. But he must count the number of pairs of positive integers w and h, beforehand, such that (w ≤ a), (h ≤ b) and (w/h = x/y).
In other words, Monocarp wants to determine the number of TV sets having aspect ratio x/y, screen width not exceeding a, and screen height not exceeding b. Two TV sets are considered different if they have different screen width or different screen height.
Input
The first line contains four integers a, b, x, y (1 ≤ a, b, x, y ≤ 10^{18}) — the constraints on the screen width and height, and on the aspect ratio.
Output
Print one integer — the number of different variants to choose TV screen width and screen height so that they meet the aforementioned constraints.
Examples
Input
17 15 5 3
Output
3
Input
14 16 7 22
Output
0
Input
4 2 6 4
Output
1
Input
1000000000000000000 1000000000000000000 999999866000004473 999999822000007597
Output
1000000063
Note
In the first example, there are 3 possible variants: (5, 3), (10, 6), (15, 9).
In the second example, there is no TV set meeting the constraints.
In the third example, there is only one variant: (3, 2).
Tags: math
Correct Solution:
```
import math
I=lambda:map(int,input().split())
a,b,x,y=I()
g1=math.gcd(x,y)
x=x//g1
y=y//g1
print(min(a//x,b//y))
```
| 107,033 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp has decided to buy a new TV set and hang it on the wall in his flat. The wall has enough free space so Monocarp can buy a TV set with screen width not greater than a and screen height not greater than b. Monocarp is also used to TV sets with a certain aspect ratio: formally, if the width of the screen is w, and the height of the screen is h, then the following condition should be met: w/h = x/y.
There are many different TV sets in the shop. Monocarp is sure that for any pair of positive integers w and h there is a TV set with screen width w and height h in the shop.
Monocarp isn't ready to choose the exact TV set he is going to buy. Firstly he wants to determine the optimal screen resolution. He has decided to try all possible variants of screen size. But he must count the number of pairs of positive integers w and h, beforehand, such that (w ≤ a), (h ≤ b) and (w/h = x/y).
In other words, Monocarp wants to determine the number of TV sets having aspect ratio x/y, screen width not exceeding a, and screen height not exceeding b. Two TV sets are considered different if they have different screen width or different screen height.
Input
The first line contains four integers a, b, x, y (1 ≤ a, b, x, y ≤ 10^{18}) — the constraints on the screen width and height, and on the aspect ratio.
Output
Print one integer — the number of different variants to choose TV screen width and screen height so that they meet the aforementioned constraints.
Examples
Input
17 15 5 3
Output
3
Input
14 16 7 22
Output
0
Input
4 2 6 4
Output
1
Input
1000000000000000000 1000000000000000000 999999866000004473 999999822000007597
Output
1000000063
Note
In the first example, there are 3 possible variants: (5, 3), (10, 6), (15, 9).
In the second example, there is no TV set meeting the constraints.
In the third example, there is only one variant: (3, 2).
Tags: math
Correct Solution:
```
import math
a,b,c,d=map(int,input().split())
divisor=math.gcd(c,d)
c//=divisor
d//=divisor
print(min(a//c,b//d))
```
| 107,034 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp has decided to buy a new TV set and hang it on the wall in his flat. The wall has enough free space so Monocarp can buy a TV set with screen width not greater than a and screen height not greater than b. Monocarp is also used to TV sets with a certain aspect ratio: formally, if the width of the screen is w, and the height of the screen is h, then the following condition should be met: w/h = x/y.
There are many different TV sets in the shop. Monocarp is sure that for any pair of positive integers w and h there is a TV set with screen width w and height h in the shop.
Monocarp isn't ready to choose the exact TV set he is going to buy. Firstly he wants to determine the optimal screen resolution. He has decided to try all possible variants of screen size. But he must count the number of pairs of positive integers w and h, beforehand, such that (w ≤ a), (h ≤ b) and (w/h = x/y).
In other words, Monocarp wants to determine the number of TV sets having aspect ratio x/y, screen width not exceeding a, and screen height not exceeding b. Two TV sets are considered different if they have different screen width or different screen height.
Input
The first line contains four integers a, b, x, y (1 ≤ a, b, x, y ≤ 10^{18}) — the constraints on the screen width and height, and on the aspect ratio.
Output
Print one integer — the number of different variants to choose TV screen width and screen height so that they meet the aforementioned constraints.
Examples
Input
17 15 5 3
Output
3
Input
14 16 7 22
Output
0
Input
4 2 6 4
Output
1
Input
1000000000000000000 1000000000000000000 999999866000004473 999999822000007597
Output
1000000063
Note
In the first example, there are 3 possible variants: (5, 3), (10, 6), (15, 9).
In the second example, there is no TV set meeting the constraints.
In the third example, there is only one variant: (3, 2).
Tags: math
Correct Solution:
```
def GCD(a, b):
while (a != 0 and b != 0):
a, b = b % a, a
return max(a, b)
a, b, x, y = map(int, input().split())
f = GCD(x, y)
x //= f
y //= f
n = min(a, b * x // y)
print(n // x)
```
| 107,035 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp has decided to buy a new TV set and hang it on the wall in his flat. The wall has enough free space so Monocarp can buy a TV set with screen width not greater than a and screen height not greater than b. Monocarp is also used to TV sets with a certain aspect ratio: formally, if the width of the screen is w, and the height of the screen is h, then the following condition should be met: w/h = x/y.
There are many different TV sets in the shop. Monocarp is sure that for any pair of positive integers w and h there is a TV set with screen width w and height h in the shop.
Monocarp isn't ready to choose the exact TV set he is going to buy. Firstly he wants to determine the optimal screen resolution. He has decided to try all possible variants of screen size. But he must count the number of pairs of positive integers w and h, beforehand, such that (w ≤ a), (h ≤ b) and (w/h = x/y).
In other words, Monocarp wants to determine the number of TV sets having aspect ratio x/y, screen width not exceeding a, and screen height not exceeding b. Two TV sets are considered different if they have different screen width or different screen height.
Input
The first line contains four integers a, b, x, y (1 ≤ a, b, x, y ≤ 10^{18}) — the constraints on the screen width and height, and on the aspect ratio.
Output
Print one integer — the number of different variants to choose TV screen width and screen height so that they meet the aforementioned constraints.
Examples
Input
17 15 5 3
Output
3
Input
14 16 7 22
Output
0
Input
4 2 6 4
Output
1
Input
1000000000000000000 1000000000000000000 999999866000004473 999999822000007597
Output
1000000063
Note
In the first example, there are 3 possible variants: (5, 3), (10, 6), (15, 9).
In the second example, there is no TV set meeting the constraints.
In the third example, there is only one variant: (3, 2).
Tags: math
Correct Solution:
```
def compute_gcd(x,y):
if y==0:
return x
else:
return compute_gcd(y,x%y)
a, b, x, y = map(int, input().split())
gcd = compute_gcd(x,y)
x /= gcd
y /= gcd
num_x, num_y = x, y
mx = int(a/x)
my = int(b/y)
print( min(mx,my) )
```
| 107,036 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp has decided to buy a new TV set and hang it on the wall in his flat. The wall has enough free space so Monocarp can buy a TV set with screen width not greater than a and screen height not greater than b. Monocarp is also used to TV sets with a certain aspect ratio: formally, if the width of the screen is w, and the height of the screen is h, then the following condition should be met: w/h = x/y.
There are many different TV sets in the shop. Monocarp is sure that for any pair of positive integers w and h there is a TV set with screen width w and height h in the shop.
Monocarp isn't ready to choose the exact TV set he is going to buy. Firstly he wants to determine the optimal screen resolution. He has decided to try all possible variants of screen size. But he must count the number of pairs of positive integers w and h, beforehand, such that (w ≤ a), (h ≤ b) and (w/h = x/y).
In other words, Monocarp wants to determine the number of TV sets having aspect ratio x/y, screen width not exceeding a, and screen height not exceeding b. Two TV sets are considered different if they have different screen width or different screen height.
Input
The first line contains four integers a, b, x, y (1 ≤ a, b, x, y ≤ 10^{18}) — the constraints on the screen width and height, and on the aspect ratio.
Output
Print one integer — the number of different variants to choose TV screen width and screen height so that they meet the aforementioned constraints.
Examples
Input
17 15 5 3
Output
3
Input
14 16 7 22
Output
0
Input
4 2 6 4
Output
1
Input
1000000000000000000 1000000000000000000 999999866000004473 999999822000007597
Output
1000000063
Note
In the first example, there are 3 possible variants: (5, 3), (10, 6), (15, 9).
In the second example, there is no TV set meeting the constraints.
In the third example, there is only one variant: (3, 2).
Tags: math
Correct Solution:
```
a,b,x,y=map(int,input().split())
def computeGCD(x, y):
while(y):
x, y = y, x % y
return x
z=computeGCD(x,y)
x=x/z
y=y/z
print(int(min(a//x,b//y)))
```
| 107,037 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp has decided to buy a new TV set and hang it on the wall in his flat. The wall has enough free space so Monocarp can buy a TV set with screen width not greater than a and screen height not greater than b. Monocarp is also used to TV sets with a certain aspect ratio: formally, if the width of the screen is w, and the height of the screen is h, then the following condition should be met: w/h = x/y.
There are many different TV sets in the shop. Monocarp is sure that for any pair of positive integers w and h there is a TV set with screen width w and height h in the shop.
Monocarp isn't ready to choose the exact TV set he is going to buy. Firstly he wants to determine the optimal screen resolution. He has decided to try all possible variants of screen size. But he must count the number of pairs of positive integers w and h, beforehand, such that (w ≤ a), (h ≤ b) and (w/h = x/y).
In other words, Monocarp wants to determine the number of TV sets having aspect ratio x/y, screen width not exceeding a, and screen height not exceeding b. Two TV sets are considered different if they have different screen width or different screen height.
Input
The first line contains four integers a, b, x, y (1 ≤ a, b, x, y ≤ 10^{18}) — the constraints on the screen width and height, and on the aspect ratio.
Output
Print one integer — the number of different variants to choose TV screen width and screen height so that they meet the aforementioned constraints.
Examples
Input
17 15 5 3
Output
3
Input
14 16 7 22
Output
0
Input
4 2 6 4
Output
1
Input
1000000000000000000 1000000000000000000 999999866000004473 999999822000007597
Output
1000000063
Note
In the first example, there are 3 possible variants: (5, 3), (10, 6), (15, 9).
In the second example, there is no TV set meeting the constraints.
In the third example, there is only one variant: (3, 2).
Tags: math
Correct Solution:
```
import math
a, b, x, y = map(int, input().split())
lcm = int(x*y/math.gcd(x, y))
v1 = a*y - (a*y)%lcm
v2 = lcm
ans = max(0, int(1+(v1-v2)/lcm))
v1 = b*x - (b*x)%lcm
ans = min(ans, int(1+(v1-v2)/lcm))
ans = max(0, ans)
print(ans)
```
| 107,038 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has decided to buy a new TV set and hang it on the wall in his flat. The wall has enough free space so Monocarp can buy a TV set with screen width not greater than a and screen height not greater than b. Monocarp is also used to TV sets with a certain aspect ratio: formally, if the width of the screen is w, and the height of the screen is h, then the following condition should be met: w/h = x/y.
There are many different TV sets in the shop. Monocarp is sure that for any pair of positive integers w and h there is a TV set with screen width w and height h in the shop.
Monocarp isn't ready to choose the exact TV set he is going to buy. Firstly he wants to determine the optimal screen resolution. He has decided to try all possible variants of screen size. But he must count the number of pairs of positive integers w and h, beforehand, such that (w ≤ a), (h ≤ b) and (w/h = x/y).
In other words, Monocarp wants to determine the number of TV sets having aspect ratio x/y, screen width not exceeding a, and screen height not exceeding b. Two TV sets are considered different if they have different screen width or different screen height.
Input
The first line contains four integers a, b, x, y (1 ≤ a, b, x, y ≤ 10^{18}) — the constraints on the screen width and height, and on the aspect ratio.
Output
Print one integer — the number of different variants to choose TV screen width and screen height so that they meet the aforementioned constraints.
Examples
Input
17 15 5 3
Output
3
Input
14 16 7 22
Output
0
Input
4 2 6 4
Output
1
Input
1000000000000000000 1000000000000000000 999999866000004473 999999822000007597
Output
1000000063
Note
In the first example, there are 3 possible variants: (5, 3), (10, 6), (15, 9).
In the second example, there is no TV set meeting the constraints.
In the third example, there is only one variant: (3, 2).
Submitted Solution:
```
def gcd(a, b):
while b:
a, b = b, a % b
return a
a,b,x,y = map(int, input().split())
d = gcd(x,y)
A = x//d;
B = y//d
k2 = a//A
k1 =b//B
print(min(k1,k2))
```
Yes
| 107,039 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has decided to buy a new TV set and hang it on the wall in his flat. The wall has enough free space so Monocarp can buy a TV set with screen width not greater than a and screen height not greater than b. Monocarp is also used to TV sets with a certain aspect ratio: formally, if the width of the screen is w, and the height of the screen is h, then the following condition should be met: w/h = x/y.
There are many different TV sets in the shop. Monocarp is sure that for any pair of positive integers w and h there is a TV set with screen width w and height h in the shop.
Monocarp isn't ready to choose the exact TV set he is going to buy. Firstly he wants to determine the optimal screen resolution. He has decided to try all possible variants of screen size. But he must count the number of pairs of positive integers w and h, beforehand, such that (w ≤ a), (h ≤ b) and (w/h = x/y).
In other words, Monocarp wants to determine the number of TV sets having aspect ratio x/y, screen width not exceeding a, and screen height not exceeding b. Two TV sets are considered different if they have different screen width or different screen height.
Input
The first line contains four integers a, b, x, y (1 ≤ a, b, x, y ≤ 10^{18}) — the constraints on the screen width and height, and on the aspect ratio.
Output
Print one integer — the number of different variants to choose TV screen width and screen height so that they meet the aforementioned constraints.
Examples
Input
17 15 5 3
Output
3
Input
14 16 7 22
Output
0
Input
4 2 6 4
Output
1
Input
1000000000000000000 1000000000000000000 999999866000004473 999999822000007597
Output
1000000063
Note
In the first example, there are 3 possible variants: (5, 3), (10, 6), (15, 9).
In the second example, there is no TV set meeting the constraints.
In the third example, there is only one variant: (3, 2).
Submitted Solution:
```
'''input
1000000000000000000 1000000000000000000 999999866000004473 999999822000007597
'''
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod=10**9+7
def ri(flag=0):
if flag==0:
return [int(i) for i in input().split()]
else:
return int(input())
a,b,x,y=ri()
from math import gcd
le=gcd(x,y)
x=x//le
y=y//le
print(min(a//x,b//y))
```
Yes
| 107,040 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has decided to buy a new TV set and hang it on the wall in his flat. The wall has enough free space so Monocarp can buy a TV set with screen width not greater than a and screen height not greater than b. Monocarp is also used to TV sets with a certain aspect ratio: formally, if the width of the screen is w, and the height of the screen is h, then the following condition should be met: w/h = x/y.
There are many different TV sets in the shop. Monocarp is sure that for any pair of positive integers w and h there is a TV set with screen width w and height h in the shop.
Monocarp isn't ready to choose the exact TV set he is going to buy. Firstly he wants to determine the optimal screen resolution. He has decided to try all possible variants of screen size. But he must count the number of pairs of positive integers w and h, beforehand, such that (w ≤ a), (h ≤ b) and (w/h = x/y).
In other words, Monocarp wants to determine the number of TV sets having aspect ratio x/y, screen width not exceeding a, and screen height not exceeding b. Two TV sets are considered different if they have different screen width or different screen height.
Input
The first line contains four integers a, b, x, y (1 ≤ a, b, x, y ≤ 10^{18}) — the constraints on the screen width and height, and on the aspect ratio.
Output
Print one integer — the number of different variants to choose TV screen width and screen height so that they meet the aforementioned constraints.
Examples
Input
17 15 5 3
Output
3
Input
14 16 7 22
Output
0
Input
4 2 6 4
Output
1
Input
1000000000000000000 1000000000000000000 999999866000004473 999999822000007597
Output
1000000063
Note
In the first example, there are 3 possible variants: (5, 3), (10, 6), (15, 9).
In the second example, there is no TV set meeting the constraints.
In the third example, there is only one variant: (3, 2).
Submitted Solution:
```
import math
a, b, x, y = map(int, input().split(' '))
gcd = math.gcd(x, y)
xx = x//gcd
yy = y//gcd
print(min(a//xx, b//yy))
```
Yes
| 107,041 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has decided to buy a new TV set and hang it on the wall in his flat. The wall has enough free space so Monocarp can buy a TV set with screen width not greater than a and screen height not greater than b. Monocarp is also used to TV sets with a certain aspect ratio: formally, if the width of the screen is w, and the height of the screen is h, then the following condition should be met: w/h = x/y.
There are many different TV sets in the shop. Monocarp is sure that for any pair of positive integers w and h there is a TV set with screen width w and height h in the shop.
Monocarp isn't ready to choose the exact TV set he is going to buy. Firstly he wants to determine the optimal screen resolution. He has decided to try all possible variants of screen size. But he must count the number of pairs of positive integers w and h, beforehand, such that (w ≤ a), (h ≤ b) and (w/h = x/y).
In other words, Monocarp wants to determine the number of TV sets having aspect ratio x/y, screen width not exceeding a, and screen height not exceeding b. Two TV sets are considered different if they have different screen width or different screen height.
Input
The first line contains four integers a, b, x, y (1 ≤ a, b, x, y ≤ 10^{18}) — the constraints on the screen width and height, and on the aspect ratio.
Output
Print one integer — the number of different variants to choose TV screen width and screen height so that they meet the aforementioned constraints.
Examples
Input
17 15 5 3
Output
3
Input
14 16 7 22
Output
0
Input
4 2 6 4
Output
1
Input
1000000000000000000 1000000000000000000 999999866000004473 999999822000007597
Output
1000000063
Note
In the first example, there are 3 possible variants: (5, 3), (10, 6), (15, 9).
In the second example, there is no TV set meeting the constraints.
In the third example, there is only one variant: (3, 2).
Submitted Solution:
```
def gcd(a, b):
if a < b:
a, b = b, a
if b == 0:
return a
return gcd(b, a % b)
a, b, x, y = map(int, input().split())
gcd_xy = gcd(x, y)
if gcd_xy > 1:
x = x // gcd_xy
y = y // gcd_xy
print(min(a // x, b // y))
```
Yes
| 107,042 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has decided to buy a new TV set and hang it on the wall in his flat. The wall has enough free space so Monocarp can buy a TV set with screen width not greater than a and screen height not greater than b. Monocarp is also used to TV sets with a certain aspect ratio: formally, if the width of the screen is w, and the height of the screen is h, then the following condition should be met: w/h = x/y.
There are many different TV sets in the shop. Monocarp is sure that for any pair of positive integers w and h there is a TV set with screen width w and height h in the shop.
Monocarp isn't ready to choose the exact TV set he is going to buy. Firstly he wants to determine the optimal screen resolution. He has decided to try all possible variants of screen size. But he must count the number of pairs of positive integers w and h, beforehand, such that (w ≤ a), (h ≤ b) and (w/h = x/y).
In other words, Monocarp wants to determine the number of TV sets having aspect ratio x/y, screen width not exceeding a, and screen height not exceeding b. Two TV sets are considered different if they have different screen width or different screen height.
Input
The first line contains four integers a, b, x, y (1 ≤ a, b, x, y ≤ 10^{18}) — the constraints on the screen width and height, and on the aspect ratio.
Output
Print one integer — the number of different variants to choose TV screen width and screen height so that they meet the aforementioned constraints.
Examples
Input
17 15 5 3
Output
3
Input
14 16 7 22
Output
0
Input
4 2 6 4
Output
1
Input
1000000000000000000 1000000000000000000 999999866000004473 999999822000007597
Output
1000000063
Note
In the first example, there are 3 possible variants: (5, 3), (10, 6), (15, 9).
In the second example, there is no TV set meeting the constraints.
In the third example, there is only one variant: (3, 2).
Submitted Solution:
```
def gcd(a,b):
if a==0:
return b
return gcd(b%a,a)
a,b,x,y=map(int,str(input()).strip().split())
while(gcd(x,y)!=1):
t=gcd(x,y)
x//=t
y//=t
r=a//x
p=b//y
print(min(r,b))
```
No
| 107,043 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has decided to buy a new TV set and hang it on the wall in his flat. The wall has enough free space so Monocarp can buy a TV set with screen width not greater than a and screen height not greater than b. Monocarp is also used to TV sets with a certain aspect ratio: formally, if the width of the screen is w, and the height of the screen is h, then the following condition should be met: w/h = x/y.
There are many different TV sets in the shop. Monocarp is sure that for any pair of positive integers w and h there is a TV set with screen width w and height h in the shop.
Monocarp isn't ready to choose the exact TV set he is going to buy. Firstly he wants to determine the optimal screen resolution. He has decided to try all possible variants of screen size. But he must count the number of pairs of positive integers w and h, beforehand, such that (w ≤ a), (h ≤ b) and (w/h = x/y).
In other words, Monocarp wants to determine the number of TV sets having aspect ratio x/y, screen width not exceeding a, and screen height not exceeding b. Two TV sets are considered different if they have different screen width or different screen height.
Input
The first line contains four integers a, b, x, y (1 ≤ a, b, x, y ≤ 10^{18}) — the constraints on the screen width and height, and on the aspect ratio.
Output
Print one integer — the number of different variants to choose TV screen width and screen height so that they meet the aforementioned constraints.
Examples
Input
17 15 5 3
Output
3
Input
14 16 7 22
Output
0
Input
4 2 6 4
Output
1
Input
1000000000000000000 1000000000000000000 999999866000004473 999999822000007597
Output
1000000063
Note
In the first example, there are 3 possible variants: (5, 3), (10, 6), (15, 9).
In the second example, there is no TV set meeting the constraints.
In the third example, there is only one variant: (3, 2).
Submitted Solution:
```
import math
arr = [int(s) for s in input().split()]
a = arr[0]
b = arr[1]
x = arr[2]
y = arr[3]
g = math.gcd(x, y)
x /= g
y /= g
w = a//x
h = b//y
if w > h :
print(h)
else:
print(w)
```
No
| 107,044 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has decided to buy a new TV set and hang it on the wall in his flat. The wall has enough free space so Monocarp can buy a TV set with screen width not greater than a and screen height not greater than b. Monocarp is also used to TV sets with a certain aspect ratio: formally, if the width of the screen is w, and the height of the screen is h, then the following condition should be met: w/h = x/y.
There are many different TV sets in the shop. Monocarp is sure that for any pair of positive integers w and h there is a TV set with screen width w and height h in the shop.
Monocarp isn't ready to choose the exact TV set he is going to buy. Firstly he wants to determine the optimal screen resolution. He has decided to try all possible variants of screen size. But he must count the number of pairs of positive integers w and h, beforehand, such that (w ≤ a), (h ≤ b) and (w/h = x/y).
In other words, Monocarp wants to determine the number of TV sets having aspect ratio x/y, screen width not exceeding a, and screen height not exceeding b. Two TV sets are considered different if they have different screen width or different screen height.
Input
The first line contains four integers a, b, x, y (1 ≤ a, b, x, y ≤ 10^{18}) — the constraints on the screen width and height, and on the aspect ratio.
Output
Print one integer — the number of different variants to choose TV screen width and screen height so that they meet the aforementioned constraints.
Examples
Input
17 15 5 3
Output
3
Input
14 16 7 22
Output
0
Input
4 2 6 4
Output
1
Input
1000000000000000000 1000000000000000000 999999866000004473 999999822000007597
Output
1000000063
Note
In the first example, there are 3 possible variants: (5, 3), (10, 6), (15, 9).
In the second example, there is no TV set meeting the constraints.
In the third example, there is only one variant: (3, 2).
Submitted Solution:
```
a,b,x,y = map(int,input().split())
if y > x:
tmp = y
y = x
x = tmp
masx = x
masy = y
while x % y:
x, y = y, x % y
x, y = masx//y, masy//y
if a/x >= b/y:
print(b//y)
else :
print(a//x)
```
No
| 107,045 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has decided to buy a new TV set and hang it on the wall in his flat. The wall has enough free space so Monocarp can buy a TV set with screen width not greater than a and screen height not greater than b. Monocarp is also used to TV sets with a certain aspect ratio: formally, if the width of the screen is w, and the height of the screen is h, then the following condition should be met: w/h = x/y.
There are many different TV sets in the shop. Monocarp is sure that for any pair of positive integers w and h there is a TV set with screen width w and height h in the shop.
Monocarp isn't ready to choose the exact TV set he is going to buy. Firstly he wants to determine the optimal screen resolution. He has decided to try all possible variants of screen size. But he must count the number of pairs of positive integers w and h, beforehand, such that (w ≤ a), (h ≤ b) and (w/h = x/y).
In other words, Monocarp wants to determine the number of TV sets having aspect ratio x/y, screen width not exceeding a, and screen height not exceeding b. Two TV sets are considered different if they have different screen width or different screen height.
Input
The first line contains four integers a, b, x, y (1 ≤ a, b, x, y ≤ 10^{18}) — the constraints on the screen width and height, and on the aspect ratio.
Output
Print one integer — the number of different variants to choose TV screen width and screen height so that they meet the aforementioned constraints.
Examples
Input
17 15 5 3
Output
3
Input
14 16 7 22
Output
0
Input
4 2 6 4
Output
1
Input
1000000000000000000 1000000000000000000 999999866000004473 999999822000007597
Output
1000000063
Note
In the first example, there are 3 possible variants: (5, 3), (10, 6), (15, 9).
In the second example, there is no TV set meeting the constraints.
In the third example, there is only one variant: (3, 2).
Submitted Solution:
```
def ucln(a, b):
while a != b:
if a > b:
a = a - b;
else:
b = b - a;
return a
a, b, x, y = list(map(int, input().split(' ')))
uc = ucln(x, y)
x = x/uc
y = y/uc
w = a/x
h = b/y
if w < h:
print(w)
else:
print(h)
```
No
| 107,046 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Masha has three sticks of length a, b and c centimeters respectively. In one minute Masha can pick one arbitrary stick and increase its length by one centimeter. She is not allowed to break sticks.
What is the minimum number of minutes she needs to spend increasing the stick's length in order to be able to assemble a triangle of positive area. Sticks should be used as triangle's sides (one stick for one side) and their endpoints should be located at triangle's vertices.
Input
The only line contains tree integers a, b and c (1 ≤ a, b, c ≤ 100) — the lengths of sticks Masha possesses.
Output
Print a single integer — the minimum number of minutes that Masha needs to spend in order to be able to make the triangle of positive area from her sticks.
Examples
Input
3 4 5
Output
0
Input
2 5 3
Output
1
Input
100 10 10
Output
81
Note
In the first example, Masha can make a triangle from the sticks without increasing the length of any of them.
In the second example, Masha can't make a triangle of positive area from the sticks she has at the beginning, but she can spend one minute to increase the length 2 centimeter stick by one and after that form a triangle with sides 3, 3 and 5 centimeters.
In the third example, Masha can take 33 minutes to increase one of the 10 centimeters sticks by 33 centimeters, and after that take 48 minutes to increase another 10 centimeters stick by 48 centimeters. This way she can form a triangle with lengths 43, 58 and 100 centimeters in 81 minutes. One can show that it is impossible to get a valid triangle faster.
Tags: brute force, geometry, math
Correct Solution:
```
lati = sorted([int(x) for x in input().split()])
if (lati[0]+lati[1] > lati[2]):
print("0")
else:
print(lati[2]-lati[1]-lati[0]+1)
```
| 107,047 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Masha has three sticks of length a, b and c centimeters respectively. In one minute Masha can pick one arbitrary stick and increase its length by one centimeter. She is not allowed to break sticks.
What is the minimum number of minutes she needs to spend increasing the stick's length in order to be able to assemble a triangle of positive area. Sticks should be used as triangle's sides (one stick for one side) and their endpoints should be located at triangle's vertices.
Input
The only line contains tree integers a, b and c (1 ≤ a, b, c ≤ 100) — the lengths of sticks Masha possesses.
Output
Print a single integer — the minimum number of minutes that Masha needs to spend in order to be able to make the triangle of positive area from her sticks.
Examples
Input
3 4 5
Output
0
Input
2 5 3
Output
1
Input
100 10 10
Output
81
Note
In the first example, Masha can make a triangle from the sticks without increasing the length of any of them.
In the second example, Masha can't make a triangle of positive area from the sticks she has at the beginning, but she can spend one minute to increase the length 2 centimeter stick by one and after that form a triangle with sides 3, 3 and 5 centimeters.
In the third example, Masha can take 33 minutes to increase one of the 10 centimeters sticks by 33 centimeters, and after that take 48 minutes to increase another 10 centimeters stick by 48 centimeters. This way she can form a triangle with lengths 43, 58 and 100 centimeters in 81 minutes. One can show that it is impossible to get a valid triangle faster.
Tags: brute force, geometry, math
Correct Solution:
```
a=list(map(int,input().split()))
a.sort()
x=a[0]
y=a[1]
z=a[2]+1
ans=max(0,z-x-y)
print(ans)
```
| 107,048 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Masha has three sticks of length a, b and c centimeters respectively. In one minute Masha can pick one arbitrary stick and increase its length by one centimeter. She is not allowed to break sticks.
What is the minimum number of minutes she needs to spend increasing the stick's length in order to be able to assemble a triangle of positive area. Sticks should be used as triangle's sides (one stick for one side) and their endpoints should be located at triangle's vertices.
Input
The only line contains tree integers a, b and c (1 ≤ a, b, c ≤ 100) — the lengths of sticks Masha possesses.
Output
Print a single integer — the minimum number of minutes that Masha needs to spend in order to be able to make the triangle of positive area from her sticks.
Examples
Input
3 4 5
Output
0
Input
2 5 3
Output
1
Input
100 10 10
Output
81
Note
In the first example, Masha can make a triangle from the sticks without increasing the length of any of them.
In the second example, Masha can't make a triangle of positive area from the sticks she has at the beginning, but she can spend one minute to increase the length 2 centimeter stick by one and after that form a triangle with sides 3, 3 and 5 centimeters.
In the third example, Masha can take 33 minutes to increase one of the 10 centimeters sticks by 33 centimeters, and after that take 48 minutes to increase another 10 centimeters stick by 48 centimeters. This way she can form a triangle with lengths 43, 58 and 100 centimeters in 81 minutes. One can show that it is impossible to get a valid triangle faster.
Tags: brute force, geometry, math
Correct Solution:
```
def ok(arr1):
arr1.sort()
if arr1[2]-arr1[0]-arr1[1]<0:
return 0
else:
return arr1[2]-arr1[0]-arr1[1]+1
arr1=list(map(int,input().split()))
print(ok(arr1))
```
| 107,049 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Masha has three sticks of length a, b and c centimeters respectively. In one minute Masha can pick one arbitrary stick and increase its length by one centimeter. She is not allowed to break sticks.
What is the minimum number of minutes she needs to spend increasing the stick's length in order to be able to assemble a triangle of positive area. Sticks should be used as triangle's sides (one stick for one side) and their endpoints should be located at triangle's vertices.
Input
The only line contains tree integers a, b and c (1 ≤ a, b, c ≤ 100) — the lengths of sticks Masha possesses.
Output
Print a single integer — the minimum number of minutes that Masha needs to spend in order to be able to make the triangle of positive area from her sticks.
Examples
Input
3 4 5
Output
0
Input
2 5 3
Output
1
Input
100 10 10
Output
81
Note
In the first example, Masha can make a triangle from the sticks without increasing the length of any of them.
In the second example, Masha can't make a triangle of positive area from the sticks she has at the beginning, but she can spend one minute to increase the length 2 centimeter stick by one and after that form a triangle with sides 3, 3 and 5 centimeters.
In the third example, Masha can take 33 minutes to increase one of the 10 centimeters sticks by 33 centimeters, and after that take 48 minutes to increase another 10 centimeters stick by 48 centimeters. This way she can form a triangle with lengths 43, 58 and 100 centimeters in 81 minutes. One can show that it is impossible to get a valid triangle faster.
Tags: brute force, geometry, math
Correct Solution:
```
ai = list(map(int,input().split()))
ai.sort()
print(max(0,ai[2] - ai[1] - ai[0] + 1))
```
| 107,050 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Masha has three sticks of length a, b and c centimeters respectively. In one minute Masha can pick one arbitrary stick and increase its length by one centimeter. She is not allowed to break sticks.
What is the minimum number of minutes she needs to spend increasing the stick's length in order to be able to assemble a triangle of positive area. Sticks should be used as triangle's sides (one stick for one side) and their endpoints should be located at triangle's vertices.
Input
The only line contains tree integers a, b and c (1 ≤ a, b, c ≤ 100) — the lengths of sticks Masha possesses.
Output
Print a single integer — the minimum number of minutes that Masha needs to spend in order to be able to make the triangle of positive area from her sticks.
Examples
Input
3 4 5
Output
0
Input
2 5 3
Output
1
Input
100 10 10
Output
81
Note
In the first example, Masha can make a triangle from the sticks without increasing the length of any of them.
In the second example, Masha can't make a triangle of positive area from the sticks she has at the beginning, but she can spend one minute to increase the length 2 centimeter stick by one and after that form a triangle with sides 3, 3 and 5 centimeters.
In the third example, Masha can take 33 minutes to increase one of the 10 centimeters sticks by 33 centimeters, and after that take 48 minutes to increase another 10 centimeters stick by 48 centimeters. This way she can form a triangle with lengths 43, 58 and 100 centimeters in 81 minutes. One can show that it is impossible to get a valid triangle faster.
Tags: brute force, geometry, math
Correct Solution:
```
a,b,c = map(int,input().split())
l = [a,b,c]
a1 = []
k = 0
max1 = max(l)
if a == b == c:
print(0)
exit()
for i in l:
if i == max1 and k == 0:
k = 1
pass
else:
a1.append(i)
if sum(a1) > max1:
print(0)
exit()
if max1 - sum(a1) >= 0:
print((max1 - sum(a1))+1)
else:
print(0)
```
| 107,051 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Masha has three sticks of length a, b and c centimeters respectively. In one minute Masha can pick one arbitrary stick and increase its length by one centimeter. She is not allowed to break sticks.
What is the minimum number of minutes she needs to spend increasing the stick's length in order to be able to assemble a triangle of positive area. Sticks should be used as triangle's sides (one stick for one side) and their endpoints should be located at triangle's vertices.
Input
The only line contains tree integers a, b and c (1 ≤ a, b, c ≤ 100) — the lengths of sticks Masha possesses.
Output
Print a single integer — the minimum number of minutes that Masha needs to spend in order to be able to make the triangle of positive area from her sticks.
Examples
Input
3 4 5
Output
0
Input
2 5 3
Output
1
Input
100 10 10
Output
81
Note
In the first example, Masha can make a triangle from the sticks without increasing the length of any of them.
In the second example, Masha can't make a triangle of positive area from the sticks she has at the beginning, but she can spend one minute to increase the length 2 centimeter stick by one and after that form a triangle with sides 3, 3 and 5 centimeters.
In the third example, Masha can take 33 minutes to increase one of the 10 centimeters sticks by 33 centimeters, and after that take 48 minutes to increase another 10 centimeters stick by 48 centimeters. This way she can form a triangle with lengths 43, 58 and 100 centimeters in 81 minutes. One can show that it is impossible to get a valid triangle faster.
Tags: brute force, geometry, math
Correct Solution:
```
sides = list(map(int, input().split()))
sides.sort()
print("0" if sides[2] < sides[1] + sides[0] else str(sides[2] - sides[1] - sides[0] + 1))
```
| 107,052 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Masha has three sticks of length a, b and c centimeters respectively. In one minute Masha can pick one arbitrary stick and increase its length by one centimeter. She is not allowed to break sticks.
What is the minimum number of minutes she needs to spend increasing the stick's length in order to be able to assemble a triangle of positive area. Sticks should be used as triangle's sides (one stick for one side) and their endpoints should be located at triangle's vertices.
Input
The only line contains tree integers a, b and c (1 ≤ a, b, c ≤ 100) — the lengths of sticks Masha possesses.
Output
Print a single integer — the minimum number of minutes that Masha needs to spend in order to be able to make the triangle of positive area from her sticks.
Examples
Input
3 4 5
Output
0
Input
2 5 3
Output
1
Input
100 10 10
Output
81
Note
In the first example, Masha can make a triangle from the sticks without increasing the length of any of them.
In the second example, Masha can't make a triangle of positive area from the sticks she has at the beginning, but she can spend one minute to increase the length 2 centimeter stick by one and after that form a triangle with sides 3, 3 and 5 centimeters.
In the third example, Masha can take 33 minutes to increase one of the 10 centimeters sticks by 33 centimeters, and after that take 48 minutes to increase another 10 centimeters stick by 48 centimeters. This way she can form a triangle with lengths 43, 58 and 100 centimeters in 81 minutes. One can show that it is impossible to get a valid triangle faster.
Tags: brute force, geometry, math
Correct Solution:
```
string = input()
arr = string.split()
fir = int(arr[0])
sec = int(arr[1])
thir = int(arr[2])
res = 1
f_summ = sec + fir + thir
if fir + sec > thir:
res = res
else:
fir += (thir - fir - sec + 1)
if fir + thir > sec:
res = res
else:
fir += (sec - fir - thir + 1)
if sec + thir > fir:
res = res
else:
sec += (fir - thir - sec + 1)
summ = sec + fir + thir
print(summ - f_summ)
```
| 107,053 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Masha has three sticks of length a, b and c centimeters respectively. In one minute Masha can pick one arbitrary stick and increase its length by one centimeter. She is not allowed to break sticks.
What is the minimum number of minutes she needs to spend increasing the stick's length in order to be able to assemble a triangle of positive area. Sticks should be used as triangle's sides (one stick for one side) and their endpoints should be located at triangle's vertices.
Input
The only line contains tree integers a, b and c (1 ≤ a, b, c ≤ 100) — the lengths of sticks Masha possesses.
Output
Print a single integer — the minimum number of minutes that Masha needs to spend in order to be able to make the triangle of positive area from her sticks.
Examples
Input
3 4 5
Output
0
Input
2 5 3
Output
1
Input
100 10 10
Output
81
Note
In the first example, Masha can make a triangle from the sticks without increasing the length of any of them.
In the second example, Masha can't make a triangle of positive area from the sticks she has at the beginning, but she can spend one minute to increase the length 2 centimeter stick by one and after that form a triangle with sides 3, 3 and 5 centimeters.
In the third example, Masha can take 33 minutes to increase one of the 10 centimeters sticks by 33 centimeters, and after that take 48 minutes to increase another 10 centimeters stick by 48 centimeters. This way she can form a triangle with lengths 43, 58 and 100 centimeters in 81 minutes. One can show that it is impossible to get a valid triangle faster.
Tags: brute force, geometry, math
Correct Solution:
```
a=[]
a=list(map(int,input().split()))
a.sort()
if a[0]+a[1]>a[2]:
print("0")
elif a[0]+a[1]==a[2]:
print("1")
else:
print(a[2]-a[1]-a[0]+1)
```
| 107,054 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Masha has three sticks of length a, b and c centimeters respectively. In one minute Masha can pick one arbitrary stick and increase its length by one centimeter. She is not allowed to break sticks.
What is the minimum number of minutes she needs to spend increasing the stick's length in order to be able to assemble a triangle of positive area. Sticks should be used as triangle's sides (one stick for one side) and their endpoints should be located at triangle's vertices.
Input
The only line contains tree integers a, b and c (1 ≤ a, b, c ≤ 100) — the lengths of sticks Masha possesses.
Output
Print a single integer — the minimum number of minutes that Masha needs to spend in order to be able to make the triangle of positive area from her sticks.
Examples
Input
3 4 5
Output
0
Input
2 5 3
Output
1
Input
100 10 10
Output
81
Note
In the first example, Masha can make a triangle from the sticks without increasing the length of any of them.
In the second example, Masha can't make a triangle of positive area from the sticks she has at the beginning, but she can spend one minute to increase the length 2 centimeter stick by one and after that form a triangle with sides 3, 3 and 5 centimeters.
In the third example, Masha can take 33 minutes to increase one of the 10 centimeters sticks by 33 centimeters, and after that take 48 minutes to increase another 10 centimeters stick by 48 centimeters. This way she can form a triangle with lengths 43, 58 and 100 centimeters in 81 minutes. One can show that it is impossible to get a valid triangle faster.
Submitted Solution:
```
s=input()
s=s.split()
a=int(s[0])
b=int(s[1])
c=int(s[2])
if(a+b>c and a+c>b and b+c>a):
print("0")
exit(0)
ct=[]
if(a+b<=c):
x=(c+1)-(a+b)
ct.append(x)
if(a+c<=b):
x=(b+1)-(a+c)
ct.append(x)
if(b+c<=a):
x=(a+1)-(c+b)
ct.append(x)
print(min(ct))
```
Yes
| 107,055 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Masha has three sticks of length a, b and c centimeters respectively. In one minute Masha can pick one arbitrary stick and increase its length by one centimeter. She is not allowed to break sticks.
What is the minimum number of minutes she needs to spend increasing the stick's length in order to be able to assemble a triangle of positive area. Sticks should be used as triangle's sides (one stick for one side) and their endpoints should be located at triangle's vertices.
Input
The only line contains tree integers a, b and c (1 ≤ a, b, c ≤ 100) — the lengths of sticks Masha possesses.
Output
Print a single integer — the minimum number of minutes that Masha needs to spend in order to be able to make the triangle of positive area from her sticks.
Examples
Input
3 4 5
Output
0
Input
2 5 3
Output
1
Input
100 10 10
Output
81
Note
In the first example, Masha can make a triangle from the sticks without increasing the length of any of them.
In the second example, Masha can't make a triangle of positive area from the sticks she has at the beginning, but she can spend one minute to increase the length 2 centimeter stick by one and after that form a triangle with sides 3, 3 and 5 centimeters.
In the third example, Masha can take 33 minutes to increase one of the 10 centimeters sticks by 33 centimeters, and after that take 48 minutes to increase another 10 centimeters stick by 48 centimeters. This way she can form a triangle with lengths 43, 58 and 100 centimeters in 81 minutes. One can show that it is impossible to get a valid triangle faster.
Submitted Solution:
```
l=list(map(int, input().split()))
l.sort()
v=l[0]+l[1]
res=(l[2]-v)
if res>=0:
print(res+1)
else:
print('0')
```
Yes
| 107,056 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Masha has three sticks of length a, b and c centimeters respectively. In one minute Masha can pick one arbitrary stick and increase its length by one centimeter. She is not allowed to break sticks.
What is the minimum number of minutes she needs to spend increasing the stick's length in order to be able to assemble a triangle of positive area. Sticks should be used as triangle's sides (one stick for one side) and their endpoints should be located at triangle's vertices.
Input
The only line contains tree integers a, b and c (1 ≤ a, b, c ≤ 100) — the lengths of sticks Masha possesses.
Output
Print a single integer — the minimum number of minutes that Masha needs to spend in order to be able to make the triangle of positive area from her sticks.
Examples
Input
3 4 5
Output
0
Input
2 5 3
Output
1
Input
100 10 10
Output
81
Note
In the first example, Masha can make a triangle from the sticks without increasing the length of any of them.
In the second example, Masha can't make a triangle of positive area from the sticks she has at the beginning, but she can spend one minute to increase the length 2 centimeter stick by one and after that form a triangle with sides 3, 3 and 5 centimeters.
In the third example, Masha can take 33 minutes to increase one of the 10 centimeters sticks by 33 centimeters, and after that take 48 minutes to increase another 10 centimeters stick by 48 centimeters. This way she can form a triangle with lengths 43, 58 and 100 centimeters in 81 minutes. One can show that it is impossible to get a valid triangle faster.
Submitted Solution:
```
from math import fabs
arr=list(map(int,input().split()))
arr.sort()
if arr[2]>=arr[1]+arr[0]:
print(int((fabs(arr[2]-(arr[0]+arr[1]))+1)))
else:
print(0)
```
Yes
| 107,057 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Masha has three sticks of length a, b and c centimeters respectively. In one minute Masha can pick one arbitrary stick and increase its length by one centimeter. She is not allowed to break sticks.
What is the minimum number of minutes she needs to spend increasing the stick's length in order to be able to assemble a triangle of positive area. Sticks should be used as triangle's sides (one stick for one side) and their endpoints should be located at triangle's vertices.
Input
The only line contains tree integers a, b and c (1 ≤ a, b, c ≤ 100) — the lengths of sticks Masha possesses.
Output
Print a single integer — the minimum number of minutes that Masha needs to spend in order to be able to make the triangle of positive area from her sticks.
Examples
Input
3 4 5
Output
0
Input
2 5 3
Output
1
Input
100 10 10
Output
81
Note
In the first example, Masha can make a triangle from the sticks without increasing the length of any of them.
In the second example, Masha can't make a triangle of positive area from the sticks she has at the beginning, but she can spend one minute to increase the length 2 centimeter stick by one and after that form a triangle with sides 3, 3 and 5 centimeters.
In the third example, Masha can take 33 minutes to increase one of the 10 centimeters sticks by 33 centimeters, and after that take 48 minutes to increase another 10 centimeters stick by 48 centimeters. This way she can form a triangle with lengths 43, 58 and 100 centimeters in 81 minutes. One can show that it is impossible to get a valid triangle faster.
Submitted Solution:
```
'''input
10 10 100
'''
from sys import stdin, stdout
arr = list(map(int, stdin.readline().split()))
arr.sort()
SUM = arr[0] + arr[1]
if SUM > arr[2]:
print(0)
else:
print(arr[2] - SUM + 1)
```
Yes
| 107,058 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Masha has three sticks of length a, b and c centimeters respectively. In one minute Masha can pick one arbitrary stick and increase its length by one centimeter. She is not allowed to break sticks.
What is the minimum number of minutes she needs to spend increasing the stick's length in order to be able to assemble a triangle of positive area. Sticks should be used as triangle's sides (one stick for one side) and their endpoints should be located at triangle's vertices.
Input
The only line contains tree integers a, b and c (1 ≤ a, b, c ≤ 100) — the lengths of sticks Masha possesses.
Output
Print a single integer — the minimum number of minutes that Masha needs to spend in order to be able to make the triangle of positive area from her sticks.
Examples
Input
3 4 5
Output
0
Input
2 5 3
Output
1
Input
100 10 10
Output
81
Note
In the first example, Masha can make a triangle from the sticks without increasing the length of any of them.
In the second example, Masha can't make a triangle of positive area from the sticks she has at the beginning, but she can spend one minute to increase the length 2 centimeter stick by one and after that form a triangle with sides 3, 3 and 5 centimeters.
In the third example, Masha can take 33 minutes to increase one of the 10 centimeters sticks by 33 centimeters, and after that take 48 minutes to increase another 10 centimeters stick by 48 centimeters. This way she can form a triangle with lengths 43, 58 and 100 centimeters in 81 minutes. One can show that it is impossible to get a valid triangle faster.
Submitted Solution:
```
a, b, c = list(map(int, input().split()))
x = min(a,b)
y = min(b,c)
if (x + y > max(a,b,c)):
print(0)
else:
print(max(a,b,c) - (x+y) + 1)
```
No
| 107,059 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Masha has three sticks of length a, b and c centimeters respectively. In one minute Masha can pick one arbitrary stick and increase its length by one centimeter. She is not allowed to break sticks.
What is the minimum number of minutes she needs to spend increasing the stick's length in order to be able to assemble a triangle of positive area. Sticks should be used as triangle's sides (one stick for one side) and their endpoints should be located at triangle's vertices.
Input
The only line contains tree integers a, b and c (1 ≤ a, b, c ≤ 100) — the lengths of sticks Masha possesses.
Output
Print a single integer — the minimum number of minutes that Masha needs to spend in order to be able to make the triangle of positive area from her sticks.
Examples
Input
3 4 5
Output
0
Input
2 5 3
Output
1
Input
100 10 10
Output
81
Note
In the first example, Masha can make a triangle from the sticks without increasing the length of any of them.
In the second example, Masha can't make a triangle of positive area from the sticks she has at the beginning, but she can spend one minute to increase the length 2 centimeter stick by one and after that form a triangle with sides 3, 3 and 5 centimeters.
In the third example, Masha can take 33 minutes to increase one of the 10 centimeters sticks by 33 centimeters, and after that take 48 minutes to increase another 10 centimeters stick by 48 centimeters. This way she can form a triangle with lengths 43, 58 and 100 centimeters in 81 minutes. One can show that it is impossible to get a valid triangle faster.
Submitted Solution:
```
def checktriangle(a,b,c):
if a+b > c and b+c > a and a+c > b:
return True
else:
return False
inp=input("input:")
splt=inp.split()
a=int(splt[0])
b=int(splt[1])
c=int(splt[2])
step=0
while not checktriangle(a,b,c):
step +=1
if min(a,b,c)==a:
a+=1
elif min(a,b,c)==b:
b+=1
elif min(a,b,c)==c:
c+=1
print(step)
```
No
| 107,060 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Masha has three sticks of length a, b and c centimeters respectively. In one minute Masha can pick one arbitrary stick and increase its length by one centimeter. She is not allowed to break sticks.
What is the minimum number of minutes she needs to spend increasing the stick's length in order to be able to assemble a triangle of positive area. Sticks should be used as triangle's sides (one stick for one side) and their endpoints should be located at triangle's vertices.
Input
The only line contains tree integers a, b and c (1 ≤ a, b, c ≤ 100) — the lengths of sticks Masha possesses.
Output
Print a single integer — the minimum number of minutes that Masha needs to spend in order to be able to make the triangle of positive area from her sticks.
Examples
Input
3 4 5
Output
0
Input
2 5 3
Output
1
Input
100 10 10
Output
81
Note
In the first example, Masha can make a triangle from the sticks without increasing the length of any of them.
In the second example, Masha can't make a triangle of positive area from the sticks she has at the beginning, but she can spend one minute to increase the length 2 centimeter stick by one and after that form a triangle with sides 3, 3 and 5 centimeters.
In the third example, Masha can take 33 minutes to increase one of the 10 centimeters sticks by 33 centimeters, and after that take 48 minutes to increase another 10 centimeters stick by 48 centimeters. This way she can form a triangle with lengths 43, 58 and 100 centimeters in 81 minutes. One can show that it is impossible to get a valid triangle faster.
Submitted Solution:
```
if __name__ == '__main__':
a,b,c = [int(i) for i in input().split(' ')]
#print(a,b,c)
if a >= b + c:
print( max(0, a - (b+c -1)))
elif b >= a + c:
print( max(0, b - (a+c-1)))
elif c >= a + b:
print( max(0, c - (a+b-1)))
print(0)
```
No
| 107,061 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Masha has three sticks of length a, b and c centimeters respectively. In one minute Masha can pick one arbitrary stick and increase its length by one centimeter. She is not allowed to break sticks.
What is the minimum number of minutes she needs to spend increasing the stick's length in order to be able to assemble a triangle of positive area. Sticks should be used as triangle's sides (one stick for one side) and their endpoints should be located at triangle's vertices.
Input
The only line contains tree integers a, b and c (1 ≤ a, b, c ≤ 100) — the lengths of sticks Masha possesses.
Output
Print a single integer — the minimum number of minutes that Masha needs to spend in order to be able to make the triangle of positive area from her sticks.
Examples
Input
3 4 5
Output
0
Input
2 5 3
Output
1
Input
100 10 10
Output
81
Note
In the first example, Masha can make a triangle from the sticks without increasing the length of any of them.
In the second example, Masha can't make a triangle of positive area from the sticks she has at the beginning, but she can spend one minute to increase the length 2 centimeter stick by one and after that form a triangle with sides 3, 3 and 5 centimeters.
In the third example, Masha can take 33 minutes to increase one of the 10 centimeters sticks by 33 centimeters, and after that take 48 minutes to increase another 10 centimeters stick by 48 centimeters. This way she can form a triangle with lengths 43, 58 and 100 centimeters in 81 minutes. One can show that it is impossible to get a valid triangle faster.
Submitted Solution:
```
a = list(map(int,input().split()))
a.sort()
if (a[2]-a[0]-a[1])>0:
print(a[2]-a[0]-a[1]+1)
else:
print(0)
```
No
| 107,062 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kilani is playing a game with his friends. This game can be represented as a grid of size n × m, where each cell is either empty or blocked, and every player has one or more castles in some cells (there are no two castles in one cell).
The game is played in rounds. In each round players expand turn by turn: firstly, the first player expands, then the second player expands and so on. The expansion happens as follows: for each castle the player owns now, he tries to expand into the empty cells nearby. The player i can expand from a cell with his castle to the empty cell if it's possible to reach it in at most s_i (where s_i is player's expansion speed) moves to the left, up, right or down without going through blocked cells or cells occupied by some other player's castle. The player examines the set of cells he can expand to and builds a castle in each of them at once. The turned is passed to the next player after that.
The game ends when no player can make a move. You are given the game field and speed of the expansion for each player. Kilani wants to know for each player how many cells he will control (have a castle their) after the game ends.
Input
The first line contains three integers n, m and p (1 ≤ n, m ≤ 1000, 1 ≤ p ≤ 9) — the size of the grid and the number of players.
The second line contains p integers s_i (1 ≤ s ≤ 10^9) — the speed of the expansion for every player.
The following n lines describe the game grid. Each of them consists of m symbols, where '.' denotes an empty cell, '#' denotes a blocked cell and digit x (1 ≤ x ≤ p) denotes the castle owned by player x.
It is guaranteed, that each player has at least one castle on the grid.
Output
Print p integers — the number of cells controlled by each player after the game ends.
Examples
Input
3 3 2
1 1
1..
...
..2
Output
6 3
Input
3 4 4
1 1 1 1
....
#...
1234
Output
1 4 3 3
Note
The picture below show the game before it started, the game after the first round and game after the second round in the first example:
<image>
In the second example, the first player is "blocked" so he will not capture new cells for the entire game. All other player will expand up during the first two rounds and in the third round only the second player will move to the left.
Tags: dfs and similar, graphs, implementation, shortest paths
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
from collections import defaultdict, deque, Counter, OrderedDict
import threading
from heapq import *
dx,dy = [1,-1,0,0],[0,0,1,-1]
def main():
n, m, p = map(int,input().split())
s = [*map(int,input().split())]
D = [[*input()] for _ in range(n)]
S = [[-1]*m for _ in range(n)]
ans = [0]*p
q=[deque() for _ in range(p)]
new_q = [deque() for _ in range(p)]
for i in range(n):
for j in range(m):
if 49<=ord(D[i][j])<=57:
x = int(D[i][j])
S[i][j] = x
q[x-1].append([i,j,x,0])
ans[x-1] += 1
while 1:
flag = False
for i in range(p):
if len(q[i]): flag = True
if not flag: break
for i in range(p):
while q[i]:
x,y,num,move = q[i].popleft()
for j in range(4):
nx,ny = x+dx[j],y+dy[j]
if 0<=nx<n and 0<=ny<m and D[nx][ny] == '.' and S[nx][ny] ==-1 and move < s[num-1]:
S[nx][ny] = num
ans[num-1] += 1
if move + 1 == s[num-1]: new_q[i].append([nx,ny,num,0])
else:q[i].append([nx,ny,num,move+1])
if len(new_q[i]):
q[i] = new_q[i]
new_q[i] = deque()
print(*ans)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
"""sys.setrecursionlimit(400000)
threading.stack_size(40960000)
thread = threading.Thread(target=main)
thread.start()"""
main()
```
| 107,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kilani is playing a game with his friends. This game can be represented as a grid of size n × m, where each cell is either empty or blocked, and every player has one or more castles in some cells (there are no two castles in one cell).
The game is played in rounds. In each round players expand turn by turn: firstly, the first player expands, then the second player expands and so on. The expansion happens as follows: for each castle the player owns now, he tries to expand into the empty cells nearby. The player i can expand from a cell with his castle to the empty cell if it's possible to reach it in at most s_i (where s_i is player's expansion speed) moves to the left, up, right or down without going through blocked cells or cells occupied by some other player's castle. The player examines the set of cells he can expand to and builds a castle in each of them at once. The turned is passed to the next player after that.
The game ends when no player can make a move. You are given the game field and speed of the expansion for each player. Kilani wants to know for each player how many cells he will control (have a castle their) after the game ends.
Input
The first line contains three integers n, m and p (1 ≤ n, m ≤ 1000, 1 ≤ p ≤ 9) — the size of the grid and the number of players.
The second line contains p integers s_i (1 ≤ s ≤ 10^9) — the speed of the expansion for every player.
The following n lines describe the game grid. Each of them consists of m symbols, where '.' denotes an empty cell, '#' denotes a blocked cell and digit x (1 ≤ x ≤ p) denotes the castle owned by player x.
It is guaranteed, that each player has at least one castle on the grid.
Output
Print p integers — the number of cells controlled by each player after the game ends.
Examples
Input
3 3 2
1 1
1..
...
..2
Output
6 3
Input
3 4 4
1 1 1 1
....
#...
1234
Output
1 4 3 3
Note
The picture below show the game before it started, the game after the first round and game after the second round in the first example:
<image>
In the second example, the first player is "blocked" so he will not capture new cells for the entire game. All other player will expand up during the first two rounds and in the third round only the second player will move to the left.
Tags: dfs and similar, graphs, implementation, shortest paths
Correct Solution:
```
import sys
from collections import deque as dq
h,w,P = [int(x) for x in input().split()]
S = [int(x) for x in input().split()]
board = []
for b in sys.stdin.read():
for c in b:
if c=='.':
board.append(-1)
elif 0<=ord(c)-49<=9:
board.append(ord(c)-49)
elif c=='#':
board.append(-2)
new_castles = [dq() for _ in range(P)]
for pos in range(h*w):
if board[pos]>=0:
new_castles[board[pos]].append((pos,0))
Q = dq()
player_Q = dq(p for p in range(P) if new_castles[p])
while player_Q:
p = player_Q.popleft()
Q = new_castles[p]
# Do S[p] moves
goal = Q[-1][1] + S[p]
while Q and Q[0][1] != goal:
pos,moves = Q.popleft()
y = pos//w
x = pos - y*w
if 0<x and board[pos-1]==-1:
board[pos-1]=p
Q.append((pos-1,moves+1))
if x<w-1 and board[pos+1]==-1:
board[pos+1]=p
Q.append((pos+1,moves+1))
if 0<y and board[pos-w]==-1:
board[pos-w]=p
Q.append((pos-w,moves+1))
if y<h-1 and board[pos+w]==-1:
board[pos+w]=p
Q.append((pos+w,moves+1))
if Q:
player_Q.append(p)
count = [0 for _ in range(P)]
for x in board:
if x >= 0:
count[x] += 1
print(*count)
```
| 107,064 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kilani is playing a game with his friends. This game can be represented as a grid of size n × m, where each cell is either empty or blocked, and every player has one or more castles in some cells (there are no two castles in one cell).
The game is played in rounds. In each round players expand turn by turn: firstly, the first player expands, then the second player expands and so on. The expansion happens as follows: for each castle the player owns now, he tries to expand into the empty cells nearby. The player i can expand from a cell with his castle to the empty cell if it's possible to reach it in at most s_i (where s_i is player's expansion speed) moves to the left, up, right or down without going through blocked cells or cells occupied by some other player's castle. The player examines the set of cells he can expand to and builds a castle in each of them at once. The turned is passed to the next player after that.
The game ends when no player can make a move. You are given the game field and speed of the expansion for each player. Kilani wants to know for each player how many cells he will control (have a castle their) after the game ends.
Input
The first line contains three integers n, m and p (1 ≤ n, m ≤ 1000, 1 ≤ p ≤ 9) — the size of the grid and the number of players.
The second line contains p integers s_i (1 ≤ s ≤ 10^9) — the speed of the expansion for every player.
The following n lines describe the game grid. Each of them consists of m symbols, where '.' denotes an empty cell, '#' denotes a blocked cell and digit x (1 ≤ x ≤ p) denotes the castle owned by player x.
It is guaranteed, that each player has at least one castle on the grid.
Output
Print p integers — the number of cells controlled by each player after the game ends.
Examples
Input
3 3 2
1 1
1..
...
..2
Output
6 3
Input
3 4 4
1 1 1 1
....
#...
1234
Output
1 4 3 3
Note
The picture below show the game before it started, the game after the first round and game after the second round in the first example:
<image>
In the second example, the first player is "blocked" so he will not capture new cells for the entire game. All other player will expand up during the first two rounds and in the third round only the second player will move to the left.
Tags: dfs and similar, graphs, implementation, shortest paths
Correct Solution:
```
import sys
import math
from collections import defaultdict,deque
import heapq
mod=998244353
def check(x,y,n,m):
return (0<=x<n and 0<=y<m)
n,m,k=map(int,sys.stdin.readline().split())
grid=[]
s=list(map(int,sys.stdin.readline().split()))
for i in range(n):
grid.append(list(sys.stdin.readline()[:-1]))
q=deque()
dic=defaultdict(deque)
for i in range(n):
for j in range(m):
if grid[i][j]!='.' and grid[i][j]!='#':
dic[int(grid[i][j])].append([i,j])
#q.append([int(grid[i][j]),i,j])
q=True
dirs=[[0,1],[0,-1],[1,0],[-1,0]]
while q:
z=True
for i in range(k):
nq=deque()
while dic[i+1]:
j=dic[i+1].popleft()
#print(j,'j')
nq.append(j+[s[i]])
z=False
p=i+1
while nq:
#print(nq,'nq')
x,y,dis=nq.popleft()
if dis==0:
dic[p].append([x,y])
else:
for i,j in dirs:
nx,ny=x+i,y+j
if check(nx,ny,n,m) and grid[nx][ny]=='.':
grid[nx][ny]=p
#print(nx,'nx',ny,'ny',dis-1,'dis-1')
nq.append([nx,ny,dis-1])
if z:
q=False
'''for i in range(k):
for j in dic[i+1]:
q.append([i+1]+j)
#print(q,'q')
while q:
p,curx,cury=q.popleft()
#print(p,'p',curx,'curx',cury,'cury',s[p-1])
nq=deque()
nq.append([curx,cury,s[p-1]])
if int(grid[curx][cury])==p:
while nq:
x,y,dis=nq.popleft()
#print(x,'x',y,'y',dis,'dis')
if dis==0:
q.append([p,x,y])
else:
for i,j in dirs:
nx,ny=x+i,y+j
if check(nx,ny,n,m) and grid[nx][ny]=='.':
grid[nx][ny]=p
#print(nx,'nx',ny,'ny',dis-1,'dis-1')
nq.append([nx,ny,dis-1])
for i in range(n):
print(grid[i])
print('\n')'''
ans=[0 for _ in range(k)]
#print(ans,'ans')
for i in range(n):
for j in range(m):
if grid[i][j]!='.' and grid[i][j]!='#':
ans[int(grid[i][j])-1]+=1
#print(grid,'grid')
print(*ans)
```
| 107,065 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kilani is playing a game with his friends. This game can be represented as a grid of size n × m, where each cell is either empty or blocked, and every player has one or more castles in some cells (there are no two castles in one cell).
The game is played in rounds. In each round players expand turn by turn: firstly, the first player expands, then the second player expands and so on. The expansion happens as follows: for each castle the player owns now, he tries to expand into the empty cells nearby. The player i can expand from a cell with his castle to the empty cell if it's possible to reach it in at most s_i (where s_i is player's expansion speed) moves to the left, up, right or down without going through blocked cells or cells occupied by some other player's castle. The player examines the set of cells he can expand to and builds a castle in each of them at once. The turned is passed to the next player after that.
The game ends when no player can make a move. You are given the game field and speed of the expansion for each player. Kilani wants to know for each player how many cells he will control (have a castle their) after the game ends.
Input
The first line contains three integers n, m and p (1 ≤ n, m ≤ 1000, 1 ≤ p ≤ 9) — the size of the grid and the number of players.
The second line contains p integers s_i (1 ≤ s ≤ 10^9) — the speed of the expansion for every player.
The following n lines describe the game grid. Each of them consists of m symbols, where '.' denotes an empty cell, '#' denotes a blocked cell and digit x (1 ≤ x ≤ p) denotes the castle owned by player x.
It is guaranteed, that each player has at least one castle on the grid.
Output
Print p integers — the number of cells controlled by each player after the game ends.
Examples
Input
3 3 2
1 1
1..
...
..2
Output
6 3
Input
3 4 4
1 1 1 1
....
#...
1234
Output
1 4 3 3
Note
The picture below show the game before it started, the game after the first round and game after the second round in the first example:
<image>
In the second example, the first player is "blocked" so he will not capture new cells for the entire game. All other player will expand up during the first two rounds and in the third round only the second player will move to the left.
Tags: dfs and similar, graphs, implementation, shortest paths
Correct Solution:
```
from collections import deque
n, m, p = [int(v) for v in input().split()]
s = [int(v) for v in input().split()]
d = {'.': 0, '#': 10}
d.update({str(v) : v for v in range(1, p + 1)})
field = [[d[c] for c in input().strip()] for _ in range(n)]
ans = [0] * p
dists = [[[9999999 for _ in range(m)] for _ in range(n)] for _ in range(p)]
frontiers = [deque() for _ in range(p)]
for i in range(n):
for j in range(m):
pp = field[i][j]
if 1 <= pp <= 9:
frontiers[pp - 1].append((i, j, 0))
ans[pp - 1] += 1
dists[pp - 1][i][j] = 0
off = [(1, 0), (0, 1), (-1, 0), (0, -1)]
curr_lim = s[:]
def dump():
for line in field:
print(line)
print()
while True:
was = False
for pp in range(1, p + 1):
# dump()
while frontiers[pp - 1]:
i, j, dist = frontiers[pp - 1].popleft()
if field[i][j] not in (0, pp):
continue
if dist > curr_lim[pp - 1]:
frontiers[pp - 1].appendleft((i, j, dist))
break
if field[i][j] != pp:
field[i][j] = pp
ans[pp - 1] += 1
was = True
for di, dj in off:
ni, nj = i + di, j + dj
if 0 <= ni < n and 0 <= nj < m and field[ni][nj] == 0:
# print(ni, nj)
new_dist = dist + 1
if new_dist < dists[pp - 1][ni][nj]:
frontiers[pp - 1].append((ni, nj, new_dist))
dists[pp - 1][ni][nj] = new_dist
if was:
for i in range(p):
curr_lim[i] += s[i]
else:
break
print(' '.join(str(v) for v in ans))
```
| 107,066 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kilani is playing a game with his friends. This game can be represented as a grid of size n × m, where each cell is either empty or blocked, and every player has one or more castles in some cells (there are no two castles in one cell).
The game is played in rounds. In each round players expand turn by turn: firstly, the first player expands, then the second player expands and so on. The expansion happens as follows: for each castle the player owns now, he tries to expand into the empty cells nearby. The player i can expand from a cell with his castle to the empty cell if it's possible to reach it in at most s_i (where s_i is player's expansion speed) moves to the left, up, right or down without going through blocked cells or cells occupied by some other player's castle. The player examines the set of cells he can expand to and builds a castle in each of them at once. The turned is passed to the next player after that.
The game ends when no player can make a move. You are given the game field and speed of the expansion for each player. Kilani wants to know for each player how many cells he will control (have a castle their) after the game ends.
Input
The first line contains three integers n, m and p (1 ≤ n, m ≤ 1000, 1 ≤ p ≤ 9) — the size of the grid and the number of players.
The second line contains p integers s_i (1 ≤ s ≤ 10^9) — the speed of the expansion for every player.
The following n lines describe the game grid. Each of them consists of m symbols, where '.' denotes an empty cell, '#' denotes a blocked cell and digit x (1 ≤ x ≤ p) denotes the castle owned by player x.
It is guaranteed, that each player has at least one castle on the grid.
Output
Print p integers — the number of cells controlled by each player after the game ends.
Examples
Input
3 3 2
1 1
1..
...
..2
Output
6 3
Input
3 4 4
1 1 1 1
....
#...
1234
Output
1 4 3 3
Note
The picture below show the game before it started, the game after the first round and game after the second round in the first example:
<image>
In the second example, the first player is "blocked" so he will not capture new cells for the entire game. All other player will expand up during the first two rounds and in the third round only the second player will move to the left.
Tags: dfs and similar, graphs, implementation, shortest paths
Correct Solution:
```
import sys
input = sys.stdin.readline
import gc, os
from collections import deque
from os import _exit
gc.disable()
def safe(i, j):
return i<n and j<m and i>=0 and j>=0 and mat[i][j]=='.'
def bfs(h):
while any(h):
for i in range(1,p+1):
h[i] = bfs2(i)
def bfs2(c):
global mat
s = l[c-1]
q = deque()
for i,j in h[c]:
q.append((i,j,0))
ans = []
while q:
i,j,k = q.popleft()
if k>=s:
ans.append((i,j))
continue
for dx,dy in [(0,1), (0,-1), (1,0), (-1,0)]:
x,y = i+dx, j+dy
if safe(x,y):
mat[x][y]=str(c)
q.append((x,y,k+1))
return ans
n,m,p = map(int, input().split())
l = list(map(int, input().split()))
mat = [list(input()) for i in range(n)]
q = []
h = [[] for _ in range(p+1)]
for i in range(n):
for j in range(m):
if mat[i][j] not in '.#':
z = int(mat[i][j])
h[z].append((i,j))
bfs(h)
count = [0]*p
for i in range(n):
for j in range(m):
if mat[i][j] not in '.#':
count[int(mat[i][j]) - 1] += 1
print(*count)
sys.stdout.flush()
_exit(0)
```
| 107,067 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kilani is playing a game with his friends. This game can be represented as a grid of size n × m, where each cell is either empty or blocked, and every player has one or more castles in some cells (there are no two castles in one cell).
The game is played in rounds. In each round players expand turn by turn: firstly, the first player expands, then the second player expands and so on. The expansion happens as follows: for each castle the player owns now, he tries to expand into the empty cells nearby. The player i can expand from a cell with his castle to the empty cell if it's possible to reach it in at most s_i (where s_i is player's expansion speed) moves to the left, up, right or down without going through blocked cells or cells occupied by some other player's castle. The player examines the set of cells he can expand to and builds a castle in each of them at once. The turned is passed to the next player after that.
The game ends when no player can make a move. You are given the game field and speed of the expansion for each player. Kilani wants to know for each player how many cells he will control (have a castle their) after the game ends.
Input
The first line contains three integers n, m and p (1 ≤ n, m ≤ 1000, 1 ≤ p ≤ 9) — the size of the grid and the number of players.
The second line contains p integers s_i (1 ≤ s ≤ 10^9) — the speed of the expansion for every player.
The following n lines describe the game grid. Each of them consists of m symbols, where '.' denotes an empty cell, '#' denotes a blocked cell and digit x (1 ≤ x ≤ p) denotes the castle owned by player x.
It is guaranteed, that each player has at least one castle on the grid.
Output
Print p integers — the number of cells controlled by each player after the game ends.
Examples
Input
3 3 2
1 1
1..
...
..2
Output
6 3
Input
3 4 4
1 1 1 1
....
#...
1234
Output
1 4 3 3
Note
The picture below show the game before it started, the game after the first round and game after the second round in the first example:
<image>
In the second example, the first player is "blocked" so he will not capture new cells for the entire game. All other player will expand up during the first two rounds and in the third round only the second player will move to the left.
Tags: dfs and similar, graphs, implementation, shortest paths
Correct Solution:
```
n, m, p=map(int, input().split())
s=list(map(int, input().split()))
a=[]
front=[set() for i in range(p)]
for i in range(n):
a.append([(int(0) if ch=='.' else (-1 if ch=='#' else (int(ch) if not front[int(ch)-1].add( (i, j) ) else -99 ))) for j, ch in enumerate(input())])
move=[(-1, 0), (1, 0), (0, -1), (0, 1)]
i=0
blocked=[False]*p
activeplayers=p
i=0
while activeplayers>0:
if blocked[i]:
i=(i+1)%p
continue
aset=front[i]
mademove=False
for gtime in range(s[i]):
newset=set()
for x,y in aset:
for dx, dy in move:
if 0<=x+dx<n and 0<=y+dy<m:
if a[x+dx][y+dy]==0:
newset.add( (x+dx, y+dy) )
a[x+dx][y+dy]=(i+1)
mademove=True
aset=newset
if len(aset)==0:
mademove=False
break
front[i]=aset
if not mademove:
blocked[i]=True
activeplayers=activeplayers-1
i=(i+1)%p
res=[0]*p
for i in range(n):
for j in range(m):
if a[i][j]>0:
res[int(a[i][j])-1]=res[int(a[i][j])-1]+1
for i in range(p):
print(res[i], end=' ')
```
| 107,068 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kilani is playing a game with his friends. This game can be represented as a grid of size n × m, where each cell is either empty or blocked, and every player has one or more castles in some cells (there are no two castles in one cell).
The game is played in rounds. In each round players expand turn by turn: firstly, the first player expands, then the second player expands and so on. The expansion happens as follows: for each castle the player owns now, he tries to expand into the empty cells nearby. The player i can expand from a cell with his castle to the empty cell if it's possible to reach it in at most s_i (where s_i is player's expansion speed) moves to the left, up, right or down without going through blocked cells or cells occupied by some other player's castle. The player examines the set of cells he can expand to and builds a castle in each of them at once. The turned is passed to the next player after that.
The game ends when no player can make a move. You are given the game field and speed of the expansion for each player. Kilani wants to know for each player how many cells he will control (have a castle their) after the game ends.
Input
The first line contains three integers n, m and p (1 ≤ n, m ≤ 1000, 1 ≤ p ≤ 9) — the size of the grid and the number of players.
The second line contains p integers s_i (1 ≤ s ≤ 10^9) — the speed of the expansion for every player.
The following n lines describe the game grid. Each of them consists of m symbols, where '.' denotes an empty cell, '#' denotes a blocked cell and digit x (1 ≤ x ≤ p) denotes the castle owned by player x.
It is guaranteed, that each player has at least one castle on the grid.
Output
Print p integers — the number of cells controlled by each player after the game ends.
Examples
Input
3 3 2
1 1
1..
...
..2
Output
6 3
Input
3 4 4
1 1 1 1
....
#...
1234
Output
1 4 3 3
Note
The picture below show the game before it started, the game after the first round and game after the second round in the first example:
<image>
In the second example, the first player is "blocked" so he will not capture new cells for the entire game. All other player will expand up during the first two rounds and in the third round only the second player will move to the left.
Tags: dfs and similar, graphs, implementation, shortest paths
Correct Solution:
```
import time
def get_frontiers(feild, n, m, p):
# print(feild)
# print(n, m)
frontiers = [[] for i in range(p)]
for i in range(n):
for j in range(m):
ele = feild[i][j]
if 1 <= ele <= 9:
# print('ele:', ele)
frontiers[ele - 1].append((i, j))
return frontiers
def go(player_id, frontier, n_turn, feild, n, m):
frontier = frontier
# print('In go:', player_id, frontier, n_turn)
while n_turn and frontier:
n_turn -= 1
new_frontier = []
for i, j in frontier:
# Down.
if i + 1 < n:
new_space = feild[i + 1][j]
if not new_space:
feild[i + 1][j] = player_id
new_frontier.append((i + 1, j))
# Up.
if i - 1 >= 0:
new_space = feild[i - 1][j]
if not new_space:
feild[i - 1][j] = player_id
new_frontier.append((i - 1, j))
# Rigth.
if j + 1 < m:
new_space = feild[i][j + 1]
if not new_space:
feild[i][j + 1] = player_id
new_frontier.append((i, j + 1))
# Left.
if j - 1 >= 0:
new_space = feild[i][j - 1]
if not new_space:
feild[i][j - 1] = player_id
new_frontier.append((i, j - 1))
# for d_i, d_j in (-1, 0), (1, 0), (0, 1), (0, -1):
# check boarder.
# new_i, new_j = i + d_i, j + d_j
# if new_i < 0 or new_j < 0 or new_i > n - 1 or new_j > m - 1:
# continue
# new_space = feild[new_i][new_j]
# if new_space == 0:
# feild[new_i][new_j] = player_id
# new_frontier.append((new_i, new_j))
frontier = new_frontier
# print('haha:', frontier)
# print('player:', player_id)
# for ele in feild:
# print(ele)
# print('Got new frontier:', frontier)
return frontier
def solve(speeds, feild, n, m, p):
frontiers = get_frontiers(feild, n, m, p)
# print('f:', frontiers)
hope = set(range(p))
while hope:
lost_hope = set()
for i in hope:
n_turn = speeds[i]
frontier = frontiers[i]
new_frontier = go(i + 1, frontier, n_turn, feild, n, m)
# print('i:', i)
# print(new_frontier)
if not new_frontier:
lost_hope.add(i)
frontiers[i] = new_frontier
hope -= lost_hope
result = get_frontiers(feild, n, m, p)
return [len(ele) for ele in result]
def test():
n, m, p = 1000, 1000, 9
speeds = [1000000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 1]
feild = [[0, -1] * (m // 2) for i in range(n)]
for i in range(m):
if i % 4 != 1:
feild[0][i] = 0
if i % 4 != 3:
feild[n - 1][i] = 0
# feild[0][0] = 1
for i in range(9):
feild[0][i * 8] = i + 1
# for ele in feild:
# print(ele)
tick = time.time()
result = solve(speeds, feild, n, m, p)
tock = time.time()
print(' '.join(map(str, result)))
print('T:', round(tock - tick, 5))
def main():
d = {str(i): i for i in range(1, 10)}
d['.'] = 0
d['#'] = -1
n, m, p = map(int, input().split())
speeds = list(map(int, input().split()))
feild = []
for i in range(n):
feild.append(list(map(d.get, input())))
# for ele in feild:
# print(ele)
result = solve(speeds, feild, n, m, p)
print(' '.join(map(str, result)))
# for ele in feild:
# print(ele)
if __name__ == "__main__":
main()
```
| 107,069 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kilani is playing a game with his friends. This game can be represented as a grid of size n × m, where each cell is either empty or blocked, and every player has one or more castles in some cells (there are no two castles in one cell).
The game is played in rounds. In each round players expand turn by turn: firstly, the first player expands, then the second player expands and so on. The expansion happens as follows: for each castle the player owns now, he tries to expand into the empty cells nearby. The player i can expand from a cell with his castle to the empty cell if it's possible to reach it in at most s_i (where s_i is player's expansion speed) moves to the left, up, right or down without going through blocked cells or cells occupied by some other player's castle. The player examines the set of cells he can expand to and builds a castle in each of them at once. The turned is passed to the next player after that.
The game ends when no player can make a move. You are given the game field and speed of the expansion for each player. Kilani wants to know for each player how many cells he will control (have a castle their) after the game ends.
Input
The first line contains three integers n, m and p (1 ≤ n, m ≤ 1000, 1 ≤ p ≤ 9) — the size of the grid and the number of players.
The second line contains p integers s_i (1 ≤ s ≤ 10^9) — the speed of the expansion for every player.
The following n lines describe the game grid. Each of them consists of m symbols, where '.' denotes an empty cell, '#' denotes a blocked cell and digit x (1 ≤ x ≤ p) denotes the castle owned by player x.
It is guaranteed, that each player has at least one castle on the grid.
Output
Print p integers — the number of cells controlled by each player after the game ends.
Examples
Input
3 3 2
1 1
1..
...
..2
Output
6 3
Input
3 4 4
1 1 1 1
....
#...
1234
Output
1 4 3 3
Note
The picture below show the game before it started, the game after the first round and game after the second round in the first example:
<image>
In the second example, the first player is "blocked" so he will not capture new cells for the entire game. All other player will expand up during the first two rounds and in the third round only the second player will move to the left.
Tags: dfs and similar, graphs, implementation, shortest paths
Correct Solution:
```
from collections import defaultdict as dd, deque
n,m,p = map(int,input().split())
S = [0]+[int(x) for x in input().split()]
M = [list(input())+['#'] for i in range(n)]
M.append(['#']*m)
front = [[], [],[],[],[],[],[],[],[],[]]
for i in range(n):
for j in range(m):
if M[i][j] not in '.#':
a = int(M[i][j])
front[a].append((i,j))
M[i][j] = a
def expand(p):
s = S[p]
Q = deque()
for i,j in front[p]:
Q.append((i,j,0))
new = False
nfront = []
while Q:
i,j,d = Q.popleft()
nfront.append((i,j))
if d >= s:
continue
for di,dj in [(-1,0), (1,0), (0,1), (0,-1)]:
if M[i+di][j+dj] == '.':
new = True
M[i+di][j+dj] = p
Q.append((i+di,j+dj,d+1))
nnfront = []
for i,j in nfront:
if M[i-1][j] == '.' or \
M[i+1][j] == '.' or \
M[i][j+1] == '.' or \
M[i][j-1] == '.':
nnfront.append((i,j))
front[p] = nnfront
return new
while any([expand(i) for i in range(1,p+1)]):
#for _ in M:
# print(*_)
pass
C = dd(int)
for i in range(n):
for j in range(m):
C[M[i][j]] += 1
print(*(C[i] for i in range(1,p+1)))
```
| 107,070 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kilani is playing a game with his friends. This game can be represented as a grid of size n × m, where each cell is either empty or blocked, and every player has one or more castles in some cells (there are no two castles in one cell).
The game is played in rounds. In each round players expand turn by turn: firstly, the first player expands, then the second player expands and so on. The expansion happens as follows: for each castle the player owns now, he tries to expand into the empty cells nearby. The player i can expand from a cell with his castle to the empty cell if it's possible to reach it in at most s_i (where s_i is player's expansion speed) moves to the left, up, right or down without going through blocked cells or cells occupied by some other player's castle. The player examines the set of cells he can expand to and builds a castle in each of them at once. The turned is passed to the next player after that.
The game ends when no player can make a move. You are given the game field and speed of the expansion for each player. Kilani wants to know for each player how many cells he will control (have a castle their) after the game ends.
Input
The first line contains three integers n, m and p (1 ≤ n, m ≤ 1000, 1 ≤ p ≤ 9) — the size of the grid and the number of players.
The second line contains p integers s_i (1 ≤ s ≤ 10^9) — the speed of the expansion for every player.
The following n lines describe the game grid. Each of them consists of m symbols, where '.' denotes an empty cell, '#' denotes a blocked cell and digit x (1 ≤ x ≤ p) denotes the castle owned by player x.
It is guaranteed, that each player has at least one castle on the grid.
Output
Print p integers — the number of cells controlled by each player after the game ends.
Examples
Input
3 3 2
1 1
1..
...
..2
Output
6 3
Input
3 4 4
1 1 1 1
....
#...
1234
Output
1 4 3 3
Note
The picture below show the game before it started, the game after the first round and game after the second round in the first example:
<image>
In the second example, the first player is "blocked" so he will not capture new cells for the entire game. All other player will expand up during the first two rounds and in the third round only the second player will move to the left.
Submitted Solution:
```
# import sys
#
# f = open('input1.txt', 'r')
#
#
# sys.stdin = f
n, m, p = list(map(int, input().split()))
s = list(map(int, input().split()))
q = [[] for _ in range(p)] # fromnt of each palyer
counts = [0] * p
field = []
for i in range(n):
line = input()
field.append([0] * m)
for j, c in enumerate(line):
if c == '.':
field[i][j] = 0
elif c == '#':
field[i][j] = -1
else:
# player
pi = int(c)
field[i][j] = pi
counts[pi-1] += 1
def get_neibs(i, j):
up = (i - 1, j) if i > 0 else None
down = (i + 1, j) if i < n - 1 else None
left = (i, j - 1) if j > 0 else None
right = (i, j + 1) if j < m - 1 else None
nbs = [up, down, left, right]
return [a for a in nbs if a is not None]
def init_bounds(field, q):
for i in range(n):
for j in range(m):
if field[i][j] > 0:
index = field[i][j]-1
nbs = get_neibs(i, j)
neib_vals = [field[a[0]][a[1]] for a in nbs]
if 0 in neib_vals:
q[index].append((i, j))
def step_one(index, field, front: list):
new_front = []
total_add = 0
for i, j in front:
nbs = get_neibs(i, j)
for a in nbs:
if field[a[0]][a[1]] == 0:
# if not yet added
field[a[0]][a[1]] = index+1
counts[index] += 1
total_add += 1
new_front.append(a)
return new_front, total_add
def step(index, field, front, speed):
added_len = 0
while speed > 0:
front, added_len = step_one(index, field, front)
speed -= 1
if added_len == 0:
break
q[index] = front
return front, added_len
init_bounds(field, q)
while True:
progress = 0
added = 0
for i in range(p):
_, added = step(i, field, q[i], s[i])
progress += added
if progress == 0:
break
print(" ".join(map(str, counts)))
# f.close()
```
Yes
| 107,071 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kilani is playing a game with his friends. This game can be represented as a grid of size n × m, where each cell is either empty or blocked, and every player has one or more castles in some cells (there are no two castles in one cell).
The game is played in rounds. In each round players expand turn by turn: firstly, the first player expands, then the second player expands and so on. The expansion happens as follows: for each castle the player owns now, he tries to expand into the empty cells nearby. The player i can expand from a cell with his castle to the empty cell if it's possible to reach it in at most s_i (where s_i is player's expansion speed) moves to the left, up, right or down without going through blocked cells or cells occupied by some other player's castle. The player examines the set of cells he can expand to and builds a castle in each of them at once. The turned is passed to the next player after that.
The game ends when no player can make a move. You are given the game field and speed of the expansion for each player. Kilani wants to know for each player how many cells he will control (have a castle their) after the game ends.
Input
The first line contains three integers n, m and p (1 ≤ n, m ≤ 1000, 1 ≤ p ≤ 9) — the size of the grid and the number of players.
The second line contains p integers s_i (1 ≤ s ≤ 10^9) — the speed of the expansion for every player.
The following n lines describe the game grid. Each of them consists of m symbols, where '.' denotes an empty cell, '#' denotes a blocked cell and digit x (1 ≤ x ≤ p) denotes the castle owned by player x.
It is guaranteed, that each player has at least one castle on the grid.
Output
Print p integers — the number of cells controlled by each player after the game ends.
Examples
Input
3 3 2
1 1
1..
...
..2
Output
6 3
Input
3 4 4
1 1 1 1
....
#...
1234
Output
1 4 3 3
Note
The picture below show the game before it started, the game after the first round and game after the second round in the first example:
<image>
In the second example, the first player is "blocked" so he will not capture new cells for the entire game. All other player will expand up during the first two rounds and in the third round only the second player will move to the left.
Submitted Solution:
```
import time
def get_frontiers(feild, n, m, p):
# print(feild)
# print(n, m)
frontiers = [[] for i in range(p)]
for i in range(n):
for j in range(m):
ele = feild[i][j]
if 1 <= ele <= 9:
# print('ele:', ele)
frontiers[ele - 1].append((i, j))
return frontiers
def go(player_id, frontier, n_turn, feild, n, m):
frontier = frontier
# print('In go:', player_id, frontier, n_turn)
while n_turn and frontier:
n_turn -= 1
new_frontier = []
for i, j in frontier:
# Down.
if i + 1 < n:
new_space = feild[i + 1][j]
if not new_space:
feild[i + 1][j] = player_id
new_frontier.append((i + 1, j))
# Up.
if i - 1 >= 0:
new_space = feild[i - 1][j]
if not new_space:
feild[i - 1][j] = player_id
new_frontier.append((i - 1, j))
# Rigth.
if j + 1 < m:
new_space = feild[i][j + 1]
if not new_space:
feild[i][j + 1] = player_id
new_frontier.append((i, j + 1))
# Left.
if j - 1 >= 0:
new_space = feild[i][j - 1]
if not new_space:
feild[i][j - 1] = player_id
new_frontier.append((i, j - 1))
# for d_i, d_j in (-1, 0), (1, 0), (0, 1), (0, -1):
# check boarder.
# new_i, new_j = i + d_i, j + d_j
# if new_i < 0 or new_j < 0 or new_i > n - 1 or new_j > m - 1:
# continue
# new_space = feild[new_i][new_j]
# if new_space == 0:
# feild[new_i][new_j] = player_id
# new_frontier.append((new_i, new_j))
frontier = new_frontier
# print('haha:', frontier)
# print('player:', player_id)
# for ele in feild:
# print(ele)
# print('Got new frontier:', frontier)
return frontier
def solve(speeds, feild, n, m, p):
frontiers = get_frontiers(feild, n, m, p)
# print('f:', frontiers)
hope = set(range(p))
while hope:
new_hope = set()
for i in hope:
n_turn = speeds[i]
frontier = frontiers[i]
new_frontier = go(i + 1, frontier, n_turn, feild, n, m)
# print('i:', i)
# print(new_frontier)
if new_frontier:
new_hope.add(i)
frontiers[i] = new_frontier
hope = new_hope
result = get_frontiers(feild, n, m, p)
return [len(ele) for ele in result]
def test():
n, m, p = 1000, 1000, 9
speeds = [1000000, 100000, 100000, 100000, 100000, 100000, 100000, 100000, 1]
feild = [[0, -1] * (m // 2) for i in range(n)]
for i in range(m):
if i % 4 != 1:
feild[0][i] = 0
if i % 4 != 3:
feild[n - 1][i] = 0
# feild[0][0] = 1
for i in range(9):
feild[0][i * 8] = i + 1
# for ele in feild:
# print(ele)
tick = time.time()
result = solve(speeds, feild, n, m, p)
tock = time.time()
print(' '.join(map(str, result)))
print('T:', round(tock - tick, 5))
def main():
d = {str(i): i for i in range(1, 10)}
d['.'] = 0
d['#'] = -1
n, m, p = map(int, input().split())
speeds = list(map(int, input().split()))
feild = []
for i in range(n):
feild.append(list(map(d.get, input())))
# for ele in feild:
# print(ele)
result = solve(speeds, feild, n, m, p)
print(' '.join(map(str, result)))
# for ele in feild:
# print(ele)
if __name__ == "__main__":
main()
```
Yes
| 107,072 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kilani is playing a game with his friends. This game can be represented as a grid of size n × m, where each cell is either empty or blocked, and every player has one or more castles in some cells (there are no two castles in one cell).
The game is played in rounds. In each round players expand turn by turn: firstly, the first player expands, then the second player expands and so on. The expansion happens as follows: for each castle the player owns now, he tries to expand into the empty cells nearby. The player i can expand from a cell with his castle to the empty cell if it's possible to reach it in at most s_i (where s_i is player's expansion speed) moves to the left, up, right or down without going through blocked cells or cells occupied by some other player's castle. The player examines the set of cells he can expand to and builds a castle in each of them at once. The turned is passed to the next player after that.
The game ends when no player can make a move. You are given the game field and speed of the expansion for each player. Kilani wants to know for each player how many cells he will control (have a castle their) after the game ends.
Input
The first line contains three integers n, m and p (1 ≤ n, m ≤ 1000, 1 ≤ p ≤ 9) — the size of the grid and the number of players.
The second line contains p integers s_i (1 ≤ s ≤ 10^9) — the speed of the expansion for every player.
The following n lines describe the game grid. Each of them consists of m symbols, where '.' denotes an empty cell, '#' denotes a blocked cell and digit x (1 ≤ x ≤ p) denotes the castle owned by player x.
It is guaranteed, that each player has at least one castle on the grid.
Output
Print p integers — the number of cells controlled by each player after the game ends.
Examples
Input
3 3 2
1 1
1..
...
..2
Output
6 3
Input
3 4 4
1 1 1 1
....
#...
1234
Output
1 4 3 3
Note
The picture below show the game before it started, the game after the first round and game after the second round in the first example:
<image>
In the second example, the first player is "blocked" so he will not capture new cells for the entire game. All other player will expand up during the first two rounds and in the third round only the second player will move to the left.
Submitted Solution:
```
from collections import deque
import sys
DBG = False
n,m,p = map(int, input().split())
spd = list(map(int, input().split()))
spd.insert(0,-1) # p starts at 1
grid = [ [0] * m for i in range(n) ]
c2d = { "#":-1, ".":0, "1":1, "2":2, "3":3, "4":4,
"5":5, "6":6, "7":7, "8":8, "9":9 }
castle = [ [] for i in range(p+1)]
for i in range(n):
s = input()
for j in range(m):
v = c2d[s[j]]
grid[i][j] = v
if v>0:
castle[v].append([i,j])
if DBG:
print(grid)
print("\n")
print(spd)
print("\n")
def mark(proc,t):
global changed, grid, castle, newcastle
dir = [ [1,0], [-1,0], [0,1], [0,-1] ]
while len(proc) > 0:
ent = proc.popleft()
c = ent[0]
s = ent[1]
for d in dir:
x = c[0]+d[0]
y = c[1]+d[1]
if x<0 or n<=x or y<0 or m<=y or grid[x][y]!=0:
continue
changed = True
grid[x][y] = t
if s>1:
proc.append([ [x,y], s-1 ])
else:
newcastle.append([x,y])
changed = True
while changed:
if DBG:
print("---- new loop ----")
changed = False
for t in range(1,p+1):
newcastle = []
proc = deque([])
for c in castle[t]:
proc.append([c, spd[t]])
mark(proc, t)
if False and DBG:
print("turn for %d, (%d,%d) ended" %
(t,c[0],c[1]))
print(grid)
#for x in $newcastle
# $castle[t] << x
#end
castle[t] = newcastle
a = [ 0 for i in range(p+1) ]
for x in range(n):
for y in range(m):
if grid[x][y] != -1:
a[grid[x][y]] += 1
for i in range(1,p+1):
sys.stdout.write("%d " % a[i])
print("")
```
Yes
| 107,073 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kilani is playing a game with his friends. This game can be represented as a grid of size n × m, where each cell is either empty or blocked, and every player has one or more castles in some cells (there are no two castles in one cell).
The game is played in rounds. In each round players expand turn by turn: firstly, the first player expands, then the second player expands and so on. The expansion happens as follows: for each castle the player owns now, he tries to expand into the empty cells nearby. The player i can expand from a cell with his castle to the empty cell if it's possible to reach it in at most s_i (where s_i is player's expansion speed) moves to the left, up, right or down without going through blocked cells or cells occupied by some other player's castle. The player examines the set of cells he can expand to and builds a castle in each of them at once. The turned is passed to the next player after that.
The game ends when no player can make a move. You are given the game field and speed of the expansion for each player. Kilani wants to know for each player how many cells he will control (have a castle their) after the game ends.
Input
The first line contains three integers n, m and p (1 ≤ n, m ≤ 1000, 1 ≤ p ≤ 9) — the size of the grid and the number of players.
The second line contains p integers s_i (1 ≤ s ≤ 10^9) — the speed of the expansion for every player.
The following n lines describe the game grid. Each of them consists of m symbols, where '.' denotes an empty cell, '#' denotes a blocked cell and digit x (1 ≤ x ≤ p) denotes the castle owned by player x.
It is guaranteed, that each player has at least one castle on the grid.
Output
Print p integers — the number of cells controlled by each player after the game ends.
Examples
Input
3 3 2
1 1
1..
...
..2
Output
6 3
Input
3 4 4
1 1 1 1
....
#...
1234
Output
1 4 3 3
Note
The picture below show the game before it started, the game after the first round and game after the second round in the first example:
<image>
In the second example, the first player is "blocked" so he will not capture new cells for the entire game. All other player will expand up during the first two rounds and in the third round only the second player will move to the left.
Submitted Solution:
```
# -*- coding: utf-8 -*-
# @Time : 2019/1/20 21:02
# @Author : LunaFire
# @Email : gilgemesh2012@gmail.com
# @File : D. Kilani and the Game.py
# import atexit
# import io
# import sys
#
# _INPUT_LINES = sys.stdin.read().splitlines()
# input = iter(_INPUT_LINES).__next__
# _OUTPUT_BUFFER = io.StringIO()
# sys.stdout = _OUTPUT_BUFFER
#
#
# @atexit.register
# def write():
# sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
from collections import deque
def check_empty(deque_array):
count = 0
for q in deque_array:
count += len(q)
return count == 0
def print_grid(grid):
for i in range(len(grid)):
for j in range(len(grid[0])):
print(grid[i][j], end='')
print()
print()
def main():
n, m, p = map(int, input().split())
s = list(map(int, input().split()))
grid = [list(input()) for _ in range(n)]
deque_array = [deque() for _ in range(p)]
for i in range(n):
for j in range(m):
if '1' <= grid[i][j] <= '9':
x = int(grid[i][j])
deque_array[x - 1].append((i, j, 0))
# print(deque_array)
curr_round = 1
while not check_empty(deque_array):
for r in range(p):
while deque_array[r]:
x, y, step = deque_array[r].popleft()
if step >= s[r] * curr_round:
deque_array[r].appendleft((x, y, step))
break
for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
nx, ny = x + dx, y + dy
# print(nx, ny)
if nx < 0 or nx >= n or ny < 0 or ny >= m or grid[nx][ny] != '.':
continue
grid[nx][ny] = str(r + 1)
deque_array[r].append((nx, ny, step + 1))
# print_grid(grid)
curr_round += 1
cell_count = [0] * p
for i in range(n):
for j in range(m):
if '1' <= grid[i][j] <= '9':
x = int(grid[i][j])
cell_count[x - 1] += 1
for r in range(p):
print(cell_count[r], end=' ')
print()
if __name__ == '__main__':
main()
```
Yes
| 107,074 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kilani is playing a game with his friends. This game can be represented as a grid of size n × m, where each cell is either empty or blocked, and every player has one or more castles in some cells (there are no two castles in one cell).
The game is played in rounds. In each round players expand turn by turn: firstly, the first player expands, then the second player expands and so on. The expansion happens as follows: for each castle the player owns now, he tries to expand into the empty cells nearby. The player i can expand from a cell with his castle to the empty cell if it's possible to reach it in at most s_i (where s_i is player's expansion speed) moves to the left, up, right or down without going through blocked cells or cells occupied by some other player's castle. The player examines the set of cells he can expand to and builds a castle in each of them at once. The turned is passed to the next player after that.
The game ends when no player can make a move. You are given the game field and speed of the expansion for each player. Kilani wants to know for each player how many cells he will control (have a castle their) after the game ends.
Input
The first line contains three integers n, m and p (1 ≤ n, m ≤ 1000, 1 ≤ p ≤ 9) — the size of the grid and the number of players.
The second line contains p integers s_i (1 ≤ s ≤ 10^9) — the speed of the expansion for every player.
The following n lines describe the game grid. Each of them consists of m symbols, where '.' denotes an empty cell, '#' denotes a blocked cell and digit x (1 ≤ x ≤ p) denotes the castle owned by player x.
It is guaranteed, that each player has at least one castle on the grid.
Output
Print p integers — the number of cells controlled by each player after the game ends.
Examples
Input
3 3 2
1 1
1..
...
..2
Output
6 3
Input
3 4 4
1 1 1 1
....
#...
1234
Output
1 4 3 3
Note
The picture below show the game before it started, the game after the first round and game after the second round in the first example:
<image>
In the second example, the first player is "blocked" so he will not capture new cells for the entire game. All other player will expand up during the first two rounds and in the third round only the second player will move to the left.
Submitted Solution:
```
from collections import deque
def bfs(queue,q,cell):
while (queue):
i,j=queue.popleft()
num=int(cell[i][j])
for k in range(i+1,min(i+q[num],n-1)+1):
if(cell[k][j]=="."):
cell[k][j]=num
queue.append([k,j])
else:
break
for k in range(i-1,max(i-q[num],0)-1,-1):
if(cell[k][j]=="."):
cell[k][j]=num
queue.append([k,j])
else:
break
for k in range(j+1,min(j+q[num],m-1)+1):
if(cell[i][k]=="."):
cell[i][k]=num
queue.append([i,k])
else:
break
for k in range(j-1,max(j-q[num],0)-1,-1):
if(cell[i][k]=="."):
cell[i][k]=num
queue.append([i,k])
else:
break
n,m,p=map(int,input().split())
q=[0]+list(map(int,input().split()))
cells=[]
for i in range(n):
cells.append(input())
cell=[[] for i in range(n)]
for i in range(n):
for j in range(m):
cell[i].append(cells[i][j])
qqueue=[]
for i in range(n):
for j in range(m):
if(cell[i][j]!="." and cell[i][j]!="#"):
qqueue.append([int(cell[i][j]),i,j])
qqueue.sort()
queue=deque()
for i in qqueue:
queue.append([i[1],i[2]])
bfs(queue,q,cell)
counted=[0 for i in range(p+1)]
for i in range(n):
for j in range(m):
if(cell[i][j]!="." and cell[i][j]!="#"):
counted[int(cell[i][j])]+=1
print(*counted[1:])
```
No
| 107,075 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kilani is playing a game with his friends. This game can be represented as a grid of size n × m, where each cell is either empty or blocked, and every player has one or more castles in some cells (there are no two castles in one cell).
The game is played in rounds. In each round players expand turn by turn: firstly, the first player expands, then the second player expands and so on. The expansion happens as follows: for each castle the player owns now, he tries to expand into the empty cells nearby. The player i can expand from a cell with his castle to the empty cell if it's possible to reach it in at most s_i (where s_i is player's expansion speed) moves to the left, up, right or down without going through blocked cells or cells occupied by some other player's castle. The player examines the set of cells he can expand to and builds a castle in each of them at once. The turned is passed to the next player after that.
The game ends when no player can make a move. You are given the game field and speed of the expansion for each player. Kilani wants to know for each player how many cells he will control (have a castle their) after the game ends.
Input
The first line contains three integers n, m and p (1 ≤ n, m ≤ 1000, 1 ≤ p ≤ 9) — the size of the grid and the number of players.
The second line contains p integers s_i (1 ≤ s ≤ 10^9) — the speed of the expansion for every player.
The following n lines describe the game grid. Each of them consists of m symbols, where '.' denotes an empty cell, '#' denotes a blocked cell and digit x (1 ≤ x ≤ p) denotes the castle owned by player x.
It is guaranteed, that each player has at least one castle on the grid.
Output
Print p integers — the number of cells controlled by each player after the game ends.
Examples
Input
3 3 2
1 1
1..
...
..2
Output
6 3
Input
3 4 4
1 1 1 1
....
#...
1234
Output
1 4 3 3
Note
The picture below show the game before it started, the game after the first round and game after the second round in the first example:
<image>
In the second example, the first player is "blocked" so he will not capture new cells for the entire game. All other player will expand up during the first two rounds and in the third round only the second player will move to the left.
Submitted Solution:
```
[n, m, p] = [int(i) for i in input().split(" ")]
scores = [int(i) for i in input().split(" ")]
grid = []
bitgrid = [([1] * m) for i in range(n)]
for i in range(n):
grid.append([str(i) for i in list(input())])
castles = [0] * p
to_check = {}
for i in range(n):
for j in range(m):
if grid[i][j] != '#' and grid[i][j] != '.':
bitgrid[i][j] = 0
castles[int(grid[i][j]) - 1] += 1
if grid[i][j] in to_check:
to_check[grid[i][j]].add((i,j))
else:
to_check[grid[i][j]] = {(i,j)}
while True:
for player in to_check:
for i in range(scores[int(player) - 1]):
if len(to_check[player]) == 0:
break
temp = set()
for cell in to_check[player]:
if cell[0] > 0:
if grid[cell[0] - 1][cell[1]] == '.':
grid[cell[0] - 1][cell[1]] = player
temp.add((cell[0] - 1, cell[1]))
castles[int(player) - 1] += 1
if cell[0] < n - 1:
if grid[cell[0] + 1][cell[1]] == '.':
grid[cell[0] + 1][cell[1]] = player
temp.add((cell[0] + 1, cell[1]))
castles[int(player) - 1] += 1
if cell[1] > 0:
if grid[cell[0]][cell[1] - 1] == '.':
grid[cell[0]][cell[1] - 1] = player
temp.add((cell[0], cell[1] - 1))
castles[int(player) - 1] += 1
if cell[1] < m - 1:
if grid[cell[0]][cell[1] + 1] == '.':
grid[cell[0]][cell[1] + 1] = player
temp.add((cell[0], cell[1] + 1))
castles[int(player) - 1] += 1
to_check[player] = temp
flag = False
for i in to_check:
if len(to_check[i]) > 0:
flag = True
break
if not flag:
break
for i in castles:
print(i)
```
No
| 107,076 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kilani is playing a game with his friends. This game can be represented as a grid of size n × m, where each cell is either empty or blocked, and every player has one or more castles in some cells (there are no two castles in one cell).
The game is played in rounds. In each round players expand turn by turn: firstly, the first player expands, then the second player expands and so on. The expansion happens as follows: for each castle the player owns now, he tries to expand into the empty cells nearby. The player i can expand from a cell with his castle to the empty cell if it's possible to reach it in at most s_i (where s_i is player's expansion speed) moves to the left, up, right or down without going through blocked cells or cells occupied by some other player's castle. The player examines the set of cells he can expand to and builds a castle in each of them at once. The turned is passed to the next player after that.
The game ends when no player can make a move. You are given the game field and speed of the expansion for each player. Kilani wants to know for each player how many cells he will control (have a castle their) after the game ends.
Input
The first line contains three integers n, m and p (1 ≤ n, m ≤ 1000, 1 ≤ p ≤ 9) — the size of the grid and the number of players.
The second line contains p integers s_i (1 ≤ s ≤ 10^9) — the speed of the expansion for every player.
The following n lines describe the game grid. Each of them consists of m symbols, where '.' denotes an empty cell, '#' denotes a blocked cell and digit x (1 ≤ x ≤ p) denotes the castle owned by player x.
It is guaranteed, that each player has at least one castle on the grid.
Output
Print p integers — the number of cells controlled by each player after the game ends.
Examples
Input
3 3 2
1 1
1..
...
..2
Output
6 3
Input
3 4 4
1 1 1 1
....
#...
1234
Output
1 4 3 3
Note
The picture below show the game before it started, the game after the first round and game after the second round in the first example:
<image>
In the second example, the first player is "blocked" so he will not capture new cells for the entire game. All other player will expand up during the first two rounds and in the third round only the second player will move to the left.
Submitted Solution:
```
[n, m, p] = [int(i) for i in input().split(" ")]
scores = [int(i) for i in input().split(" ")]
grid = []
bitgrid = [([1] * m) for i in range(n)]
for i in range(n):
grid.append([str(i) for i in list(input())])
castles = [0] * p
to_check = {}
for i in range(n):
for j in range(m):
if grid[i][j] != '#' and grid[i][j] != '.':
bitgrid[i][j] = 0
castles[int(grid[i][j]) - 1] += 1
if grid[i][j] in to_check:
to_check[int(grid[i][j])].add((i,j))
else:
to_check[int(grid[i][j])] = {(i,j)}
while True:
for player in range(1, p + 1):
for i in range(scores[player - 1]):
if len(to_check[player]) == 0:
break
temp = set()
for cell in to_check[player]:
if cell[0] > 0:
if grid[cell[0] - 1][cell[1]] == '.':
grid[cell[0] - 1][cell[1]] = player
temp.add((cell[0] - 1, cell[1]))
castles[player - 1] += 1
if cell[0] < n - 1:
if grid[cell[0] + 1][cell[1]] == '.':
grid[cell[0] + 1][cell[1]] = player
temp.add((cell[0] + 1, cell[1]))
castles[player - 1] += 1
if cell[1] > 0:
if grid[cell[0]][cell[1] - 1] == '.':
grid[cell[0]][cell[1] - 1] = player
temp.add((cell[0], cell[1] - 1))
castles[player - 1] += 1
if cell[1] < m - 1:
if grid[cell[0]][cell[1] + 1] == '.':
grid[cell[0]][cell[1] + 1] = player
temp.add((cell[0], cell[1] + 1))
castles[player - 1] += 1
to_check[player] = temp
flag = False
for i in to_check:
if len(to_check[i]) > 0:
flag = True
break
if not flag:
break
for i in castles:
print(i)
```
No
| 107,077 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kilani is playing a game with his friends. This game can be represented as a grid of size n × m, where each cell is either empty or blocked, and every player has one or more castles in some cells (there are no two castles in one cell).
The game is played in rounds. In each round players expand turn by turn: firstly, the first player expands, then the second player expands and so on. The expansion happens as follows: for each castle the player owns now, he tries to expand into the empty cells nearby. The player i can expand from a cell with his castle to the empty cell if it's possible to reach it in at most s_i (where s_i is player's expansion speed) moves to the left, up, right or down without going through blocked cells or cells occupied by some other player's castle. The player examines the set of cells he can expand to and builds a castle in each of them at once. The turned is passed to the next player after that.
The game ends when no player can make a move. You are given the game field and speed of the expansion for each player. Kilani wants to know for each player how many cells he will control (have a castle their) after the game ends.
Input
The first line contains three integers n, m and p (1 ≤ n, m ≤ 1000, 1 ≤ p ≤ 9) — the size of the grid and the number of players.
The second line contains p integers s_i (1 ≤ s ≤ 10^9) — the speed of the expansion for every player.
The following n lines describe the game grid. Each of them consists of m symbols, where '.' denotes an empty cell, '#' denotes a blocked cell and digit x (1 ≤ x ≤ p) denotes the castle owned by player x.
It is guaranteed, that each player has at least one castle on the grid.
Output
Print p integers — the number of cells controlled by each player after the game ends.
Examples
Input
3 3 2
1 1
1..
...
..2
Output
6 3
Input
3 4 4
1 1 1 1
....
#...
1234
Output
1 4 3 3
Note
The picture below show the game before it started, the game after the first round and game after the second round in the first example:
<image>
In the second example, the first player is "blocked" so he will not capture new cells for the entire game. All other player will expand up during the first two rounds and in the third round only the second player will move to the left.
Submitted Solution:
```
from collections import deque
n, m, p = map(int, input().split())
speed = list(map(int, input().split()))
grid = [input() for _ in range(n)]
memo = [[0] * m for _ in range(n)]
point = [0] * p
start = [[] for _ in range(p)]
for i in range(n):
for j in range(m):
if grid[i][j] != "#" and grid[i][j] != ".":
start[int(grid[i][j]) - 1].append((i, j))
if grid[i][j] == "#":
memo[i][j] = 1
# x = y, y = x
q = deque([])
for i in range(p):
x, y = start[i][0]
q.append((i, x, y))
memo[x][y] = 1
point[i] += 1
dir = [[1, 0], [-1, 0], [0, 1], [0, -1]]
while q:
i, x, y = q.popleft()
for dx, dy in dir:
for _ in range(p):
nx = x + dx
ny = y + dy
if 0 <= nx <= n - 1 and 0 <= ny <= m - 1:
if memo[nx][ny] == 1:
continue
memo[nx][ny] = 1
point[i] += 1
q.append((i, nx, ny))
print(*point)
```
No
| 107,078 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(".
Tags: greedy, strings
Correct Solution:
```
_str = str
n, str = int(input()), list(input())
if str[0] == '?': str[0] = '('
if str[-1] == '?': str[-1] = ')'
pp, nn = n//2, n//2
for ch in str:
if ch == '(': pp -= 1
if ch == ')': nn -= 1
if n%2 == 1 or str[0] != '(' or str[-1] != ')' or pp < 0 or nn < 0:
print(':(')
exit(0)
res, sum = [], 0
for ch in str:
if ch == '(':
res.append('(')
sum += 1
elif ch == ')':
res.append(')')
sum -= 1
elif pp > 0:
res.append('(')
sum += 1
pp -= 1
elif nn > 0:
res.append(')')
sum -= 1
nn -= 1
else:
print(':(')
exit(0)
if sum <= 0:
break
if sum == 0 and len(res) == n:
print(_str(res).replace(', ', '').replace('[', '').replace(']', '').replace('\'', ''))
else:
print(':(')
```
| 107,079 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(".
Tags: greedy, strings
Correct Solution:
```
import sys
#comment these out later
#sys.stdin = open("in.in", "r")
#sys.stdout = open("out.out", "w")
def main():
inp = sys.stdin.read().split(); ii = 0
n = int(inp[ii]); ii += 1
s = list(inp[ii])
if n%2:
print(":(")
sys.exit()
a = n//2 - s.count("(")
b = n//2 - s.count(")")
if a < 0 or b < 0:
print(":(")
sys.exit()
for i in range(n):
if s[i] == "?":
if a:
s[i] = "("
a -= 1
else:
s[i] = ")"
b -= 1
check = 0
bad = False
for i in range(n-1):
if s[i] == "(":
check += 1
else:
check -= 1
if check <= 0:
bad = True
break
if bad:
print(":(")
else:
print("".join(s))
main()
```
| 107,080 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(".
Tags: greedy, strings
Correct Solution:
```
n = int(input())
if n % 2:
print(':(')
exit(0)
s = list(input())
ans = ''
c1, c2 = s.count('('), s.count(')')
cnt90 = 0
cnt9, cnt0 = 0, 0
for i in s[:-1]:
if i == '(':
cnt90 += 1
if cnt9 + cnt90 > n // 2:
print(':(')
exit(0)
ans += i
elif i == ')':
cnt0 += 1
if cnt0 > n // 2:
print(':(')
exit(0)
ans += i
else:
if cnt9 + c1 < n // 2:
ans += '('
cnt9 += 1
else:
ans += ')'
cnt0 += 1
if cnt90 + cnt9 <= cnt0:
print(':(')
exit(0)
if s[-1] == '(' or cnt9 + cnt90 != n // 2:
print(':(')
exit(0)
print(ans + ')')
```
| 107,081 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(".
Tags: greedy, strings
Correct Solution:
```
import sys
input=sys.stdin.readline
n=int(input())
a=list(input())
if n%2!=0:
print(":(")
else:
b=a.count("(")
c=a.count(")")
if b>n//2 or c>n//2:
print(":(")
else:
b=n//2-b
c=n//2-c
d=0
for i in range(n):
if a[i]=="?":
a[i]="("
d+=1
if d==b:
break
d=0
for i in range(n):
if a[i]=="?":
a[i]=")"
d+=1
if d==c:
break
d=0
e=0
f=[]
for i in range(n-1):
if a[i]=="(":
d+=1
else:
d+=-1
f.append(d)
if min(f)<1:
e=1
if e==0:
print("".join(a))
else:
print(":(")
```
| 107,082 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(".
Tags: greedy, strings
Correct Solution:
```
from __future__ import print_function, division
from sys import stdin, exit
def no_ans():
print(":(")
exit(0)
n = int(stdin.readline())
s = [ch for ch in stdin.readline()[:n]]
if n % 2 == 1 or s[0] == ')' or s[-1] == '(':
no_ans()
s[0] = '('
s[-1] = ')'
cur_open = 0
open_left = (n - 1) // 2 - s[1:n - 1].count('(')
for i, char in enumerate(s[1:n - 1], 1):
if char == '(':
cur_open += 1
elif char == '?' and open_left > 0:
cur_open += 1
open_left -= 1
s[i] = '('
else:
cur_open -= 1
s[i] = ')'
if cur_open < 0:
no_ans()
if cur_open != 0:
no_ans()
print(''.join(s))
```
| 107,083 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(".
Tags: greedy, strings
Correct Solution:
```
n = int(input())
s = input()
open = 0
closed = 0
for i in range(n):
if s[i] == '(':
open += 1
elif s[i] == ')':
closed += 1
a = n/2 - open
b = n/2 - closed
ans = ""
openct = 0
closedct = 0
can = True
if n%2 or open > n/2:
can = False
can = False
if can:
for i in range(n):
if s[i] == '?':
if a:
openct += 1
ans += '('
a -= 1
else:
closedct += 1
ans += ')'
elif s[i] == '(':
ans += '('
openct += 1
elif s[i] == ')':
ans += ')'
closedct += 1
if i != n-1:
if closedct >= openct:
can = False
break
if can:
print(ans)
else:
print(':(')
```
| 107,084 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(".
Tags: greedy, strings
Correct Solution:
```
n = int(input())
s = [i for i in input()]
o = 0
z = 0
O = s.count('(')
Z = s.count(')')
V = s.count('?')
on = (V - (O - Z)) // 2
flag = 0
if on >= 0:
for i in range(n):
if s[i] == '(':
o += 1
if s[i] == ')':
z += 1
if s[i] == '?':
if on > 0:
s[i] = '('
o += 1
on -= 1
else:
s[i] = ')'
z += 1
if z == o and i != len(s) - 1:
flag = 1
break
if z > o:
flag = 1
break
else:
flag = 1
if z != o:
flag = 1
if flag == 0:
print(*s, sep='')
else:
print(':(')
```
| 107,085 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(".
Tags: greedy, strings
Correct Solution:
```
n = int(input())
s = input()
a = []
for i in range(n):
if s[i] == '?':
a.append('(')
else:
a.append(s[i])
cnt = 0
ans = 0
for i in range(n):
if a[i] == '(':
cnt+=1
else:
cnt -= 1
ans = min(ans, cnt)
for i in range(n-1, -1, -1):
if cnt > 0 and s[i] == '?':
cnt -= 2
a[i] = ')'
cnt = 0
b = []
for i in range(n):
if a[i] == '(':
cnt += 1
else:
cnt -= 1
b.append(cnt)
if len(b) == 1 or min(b[:-1]) <= 0 or b[-1] != 0:
ans = -1
if ans < 0:
print(':(')
else:
print(''.join(a))
```
| 107,086 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(".
Submitted Solution:
```
n = int(input(''))
s = list(input(''))
x = 0
y = 0
p = 0
q = 0
z = 0
m = 0
for i in range(n):
if s[i] == '(':
m += 1
if n % 2 == 1:
print(':(')
else:
for i in range(n-1):
if s[-i-1] == '(':
x += 1
else:
y += 1
if s[i] == ')':
p += 1
else:
q += 1
if x >= y:
z = 1
break
if p >= q:
z = 1
break
if z == 1:
print(':(')
else:
for i in range(n):
if s[i] == '?':
if m >= n//2:
s[i] = ')'
else:
s[i] = '('
m += 1
print(s[i], end='')
```
Yes
| 107,087 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(".
Submitted Solution:
```
n=int(input())
S=list(input())
def solve():
if n%2:
return ':('
L=[0]*n
maxcnt=n//2-S.count('(')
cnt=0
for i in range(n):
if S[i]=='(':
L[i]=1
elif S[i]==')':
L[i]=-1
else:
if cnt<maxcnt:
L[i]=1; S[i]='('
cnt+=1
else:
L[i]=-1; S[i]=')'
judge=0
for i in range(n-1):
judge+=L[i]
if judge<=0:
return ':('
judge+=L[-1]
if judge!=0:
return ':('
return ''.join(S)
print(solve())
```
Yes
| 107,088 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(".
Submitted Solution:
```
from math import ceil
import sys
input=sys.stdin.readline
from collections import defaultdict as dd
n=int(input())
s=input().split()[0]
lol=0
res=[0]*n
if(n%2 or s[0]==')' or s[-1]=='('):
print(':(')
else:
st=[]
stt=[]
res[0]='('
res[-1]=')'
for i in range(1,n-1):
if(s[i]=='('):
st.append(i)
res[i]='('
elif(s[i]=='?'):
stt.append(i)
else:
if(len(st)!=0):
st.pop()
res[i]=')'
else:
if(stt):
ind=stt.pop()
res[ind]='('
res[i]=')'
else:
lol=1
break
#print(lol)
x=len(stt)
#print(len(st),x)
if(len(st)>x):
lol=1
elif((x-len(st))%2):
lol=1
else:
cou=0
dif=len(st)
for i in range(dif):
a=st.pop()
b=stt.pop()
if(a>b):
lol=1
break
else:
res[b]=')'
while stt:
if(cou%2==0):
res[stt.pop()]=')'
else:
res[stt.pop()]='('
cou+=1
#print(lol)
if(lol):
print(':(')
else:
print(*res,sep="")
```
Yes
| 107,089 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(".
Submitted Solution:
```
import sys
num = int(input())
raw = input()
inputs = [item for item in raw]
result = [item for item in raw]
if(num % 2 == 0):
found = True
a = 0
b = 0
c = 0
for i in range(num):
if(inputs[i] == '('):
a += 1
elif(inputs[i] == ')'):
b += 1
else:
c += 1
if((abs(a - b) + c)) % 2 != 0 or (a - b + c) < 0 or (b - a + c) < 0:
print(":(")
else:
if(a > b):
n = a - b
for i in range(num-1, 0, -1):
if(n == 0):
break
if(inputs[i] == '?'):
inputs[i] = ')'
n -= 1
elif(a < b):
n = b - a
for i in range(0, num):
if(n == 0):
break
if(inputs[i] == '?'):
inputs[i] = '('
n -= 1
n = (c - abs(a - b)) / 2
for i in range(0, num):
if(n == 0):
break
if(inputs[i] == '?'):
inputs[i] = '('
n -= 1
n = (c - abs(a - b)) / 2
for i in range(num-1, 0, -1):
if(n == 0):
break
if(inputs[i] == '?'):
inputs[i] = ')'
n -= 1
sum = (inputs[0] == '(') - (inputs[0] == ')')
temp = 0
for i in range(1, num - 1):
sum = sum + (inputs[i] == '(') - (inputs[i] == ')')
if(sum <= 0):
print(":(")
sys.exit(0)
print(''.join(inputs))
else:
print(":(")
```
Yes
| 107,090 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(".
Submitted Solution:
```
n = int(input())
string = input()
if n % 2 != 0:
print(":(")
else:
ms = ""
sum = 0
o = 0
c = 0
h = n // 2
for i in string:
if i == "(":
o += 1
elif i == ")":
c += 1
# print(o, c, h)
for i in range(n):
if sum <= 0 and i != 0:
sum = 0
break
if sum == 0 and i == 0:
if string[i] == "?":
ms += "("
o += 1
sum += 1
elif string[i] == "(":
sum += 1
ms += "("
else:
sum -= 1
ms += ")"
if sum > 0 and i != 0:
if string[i] == "?":
if h - o > 0:
ms += "("
o += 1
sum += 1
elif h - c > 0:
ms += ")"
c += 1
sum -= 1
if sum == 0 and i < n-1:
print(":(")
else:
print(ms)
```
No
| 107,091 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(".
Submitted Solution:
```
import sys
import math
from collections import defaultdict,deque
import heapq
n=int(sys.stdin.readline())
s = sys.stdin.readline()[:-1]
cnt=0
if s[0]==')':
print(":(")
sys.exit()
cnt+=1
ans=[0 for _ in range(n)]
ans[0]='('
#print(cnt,'cnt')
if n%2:
print(':(')
ans[0]='('
ans[1]='('
cnt=0
cnto=0
cntc=0
for i in range(n):
if s[i]=='(':
cnt+=1
rem=n//2-(cnt)
if s[0]=='?':
rem-=1
if s[1]=='?':
rem-=1
#print(rem,'rem')
for i in range(2,n-1):
if s[i]=='?':
if cnto<rem:
ans[i]='('
cnto+=1
else:
ans[i]=')'
else:
if s[i]=='(':
cnto+=1
ans[i]=s[i]
if s[-1]!='?':
if s[-1]=='(':
print(':(')
sys.exit()
ans[-1]=')'
res=0
#print(ans,'ans')
for i in range(n):
if res<0:
print(":(")
sys.exit()
if ans[i]=='(':
res+=1
else:
res-=1
if res>0:
print(':(')
sys.exit()
print(''.join(x for x in ans))
```
No
| 107,092 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(".
Submitted Solution:
```
import sys
import math
from collections import defaultdict,deque
import heapq
n=int(sys.stdin.readline())
s = sys.stdin.readline()[:-1]
cnt=0
if s[0]==')':
print(":(")
sys.exit()
cnt+=1
ans=[0 for _ in range(n)]
ans[0]='('
#print(cnt,'cnt')
if n%2:
print(':(')
ans[0]='('
ans[1]='('
cnt=0
cnto=0
cntc=0
for i in range(n):
if s[i]=='(':
cnt+=1
rem=n//2-(cnt)
if s[0]=='?':
rem-=1
if s[1]=='?':
rem-=1
print(rem,'rem')
for i in range(2,n-1):
if s[i]=='?':
if cnto<rem:
ans[i]='('
cnto+=1
else:
ans[i]=')'
else:
if s[i]=='(':
cnto+=1
ans[i]=s[i]
if s[-1]!='?':
if s[-1]=='(':
print(':(')
sys.exit()
ans[-1]=')'
res=0
#print(ans,'ans')
for i in range(n):
if res<0:
print(":(")
sys.exit()
if ans[i]=='(':
res+=1
else:
res-=1
if res>0:
print(':(')
sys.exit()
print(''.join(x for x in ans))
```
No
| 107,093 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(".
Submitted Solution:
```
n = int(input())
s = str(input()[:n])
a = [0]*n
count = 0 # count open parenthesis
pos = 1
if n%2 !=0:
print(":(")
else:
for i in range(1, n):
if s[i] == '(':
a[i] = 1
elif s[i] == ')':
a[i] = -1
a[0] = 1
#print(a)
for pos in range(1, n//2):
if a[pos] == 1:
count += 1
elif a[pos] == 0:
if count > 1:
a[pos] = -1
count -= 1
else:
a[pos] = 1
count += 1
for pos in range(n//2, n-1):
if a[pos] == 0 and count > 0:
a[pos] = -1
count -= 1
else:
a[pos] = 1
count += 1
#print(a)
if s[n-1] == '(':
print(':(')
quit()
else:
a[n - 1] = -1
for i in range(n):
if sum(a) == 0:
if a[i] == 1:
print('(', end='')
elif a[i] == -1:
print(')', end='')
else:
print(':(')
break
#print(a)
```
No
| 107,094 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a function f written in some basic language. The function accepts an integer value, which is immediately written into some variable x. x is an integer variable and can be assigned values from 0 to 2^{32}-1. The function contains three types of commands:
* for n — for loop;
* end — every command between "for n" and corresponding "end" is executed n times;
* add — adds 1 to x.
After the execution of these commands, value of x is returned.
Every "for n" is matched with "end", thus the function is guaranteed to be valid. "for n" can be immediately followed by "end"."add" command can be outside of any for loops.
Notice that "add" commands might overflow the value of x! It means that the value of x becomes greater than 2^{32}-1 after some "add" command.
Now you run f(0) and wonder if the resulting value of x is correct or some overflow made it incorrect.
If overflow happened then output "OVERFLOW!!!", otherwise print the resulting value of x.
Input
The first line contains a single integer l (1 ≤ l ≤ 10^5) — the number of lines in the function.
Each of the next l lines contains a single command of one of three types:
* for n (1 ≤ n ≤ 100) — for loop;
* end — every command between "for n" and corresponding "end" is executed n times;
* add — adds 1 to x.
Output
If overflow happened during execution of f(0), then output "OVERFLOW!!!", otherwise print the resulting value of x.
Examples
Input
9
add
for 43
end
for 10
for 15
add
end
add
end
Output
161
Input
2
for 62
end
Output
0
Input
11
for 100
for 100
for 100
for 100
for 100
add
end
end
end
end
end
Output
OVERFLOW!!!
Note
In the first example the first "add" is executed 1 time, the second "add" is executed 150 times and the last "add" is executed 10 times. Note that "for n" can be immediately followed by "end" and that "add" can be outside of any for loops.
In the second example there are no commands "add", thus the returning value is 0.
In the third example "add" command is executed too many times, which causes x to go over 2^{32}-1.
Tags: data structures, expression parsing, implementation
Correct Solution:
```
from sys import stdin, stdout
def read():
return stdin.readline().rstrip()
def write(s):
stdout.write(s + "\n")
def solve():
l = int(read())
st = []
lim = 2*2147483647+ 1
cur = 1
x = 0
for i in range(l):
s = read().split()
if s[0] == 'for':
y = int(s[1])
cur = cur*y if (cur * y <= lim) else lim+1
st.append(cur)
elif s[0] == 'end':
st.pop()
cur = 1 if not st else st[-1]
else:
x += cur
#if x > lim: #2**32-1:
if x > 2**32-1:
write("OVERFLOW!!!")
break
else:
write(str(x))
solve()
```
| 107,095 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a function f written in some basic language. The function accepts an integer value, which is immediately written into some variable x. x is an integer variable and can be assigned values from 0 to 2^{32}-1. The function contains three types of commands:
* for n — for loop;
* end — every command between "for n" and corresponding "end" is executed n times;
* add — adds 1 to x.
After the execution of these commands, value of x is returned.
Every "for n" is matched with "end", thus the function is guaranteed to be valid. "for n" can be immediately followed by "end"."add" command can be outside of any for loops.
Notice that "add" commands might overflow the value of x! It means that the value of x becomes greater than 2^{32}-1 after some "add" command.
Now you run f(0) and wonder if the resulting value of x is correct or some overflow made it incorrect.
If overflow happened then output "OVERFLOW!!!", otherwise print the resulting value of x.
Input
The first line contains a single integer l (1 ≤ l ≤ 10^5) — the number of lines in the function.
Each of the next l lines contains a single command of one of three types:
* for n (1 ≤ n ≤ 100) — for loop;
* end — every command between "for n" and corresponding "end" is executed n times;
* add — adds 1 to x.
Output
If overflow happened during execution of f(0), then output "OVERFLOW!!!", otherwise print the resulting value of x.
Examples
Input
9
add
for 43
end
for 10
for 15
add
end
add
end
Output
161
Input
2
for 62
end
Output
0
Input
11
for 100
for 100
for 100
for 100
for 100
add
end
end
end
end
end
Output
OVERFLOW!!!
Note
In the first example the first "add" is executed 1 time, the second "add" is executed 150 times and the last "add" is executed 10 times. Note that "for n" can be immediately followed by "end" and that "add" can be outside of any for loops.
In the second example there are no commands "add", thus the returning value is 0.
In the third example "add" command is executed too many times, which causes x to go over 2^{32}-1.
Tags: data structures, expression parsing, implementation
Correct Solution:
```
t = int(input())
r = 0
s = [0] * 10**5
ss = 0
for _ in range(t):
x = input().split()
if x[0] == 'add':
r += 1
elif x[0] == 'for':
s[ss] = (r, int(x[1]))
ss += 1
r = 0
elif x[0] == 'end':
ss -= 1
r_old, k = s[ss]
r = r_old + r * k
if r >= 2**32:
print("OVERFLOW!!!")
break
else:
print(r if r < 2**32 else "OVERFLOW!!!")
```
| 107,096 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a function f written in some basic language. The function accepts an integer value, which is immediately written into some variable x. x is an integer variable and can be assigned values from 0 to 2^{32}-1. The function contains three types of commands:
* for n — for loop;
* end — every command between "for n" and corresponding "end" is executed n times;
* add — adds 1 to x.
After the execution of these commands, value of x is returned.
Every "for n" is matched with "end", thus the function is guaranteed to be valid. "for n" can be immediately followed by "end"."add" command can be outside of any for loops.
Notice that "add" commands might overflow the value of x! It means that the value of x becomes greater than 2^{32}-1 after some "add" command.
Now you run f(0) and wonder if the resulting value of x is correct or some overflow made it incorrect.
If overflow happened then output "OVERFLOW!!!", otherwise print the resulting value of x.
Input
The first line contains a single integer l (1 ≤ l ≤ 10^5) — the number of lines in the function.
Each of the next l lines contains a single command of one of three types:
* for n (1 ≤ n ≤ 100) — for loop;
* end — every command between "for n" and corresponding "end" is executed n times;
* add — adds 1 to x.
Output
If overflow happened during execution of f(0), then output "OVERFLOW!!!", otherwise print the resulting value of x.
Examples
Input
9
add
for 43
end
for 10
for 15
add
end
add
end
Output
161
Input
2
for 62
end
Output
0
Input
11
for 100
for 100
for 100
for 100
for 100
add
end
end
end
end
end
Output
OVERFLOW!!!
Note
In the first example the first "add" is executed 1 time, the second "add" is executed 150 times and the last "add" is executed 10 times. Note that "for n" can be immediately followed by "end" and that "add" can be outside of any for loops.
In the second example there are no commands "add", thus the returning value is 0.
In the third example "add" command is executed too many times, which causes x to go over 2^{32}-1.
Tags: data structures, expression parsing, implementation
Correct Solution:
```
def catch_overflow(o):
stack = [1]
output = 0
for i in range(o):
n = input()
if n[:3] == 'for':
stack.append(min(2**32,stack[-1]*int(n[4:])))
elif n == 'end':
stack.pop()
else:
output += stack[-1]
if output >= 2**32:
print('OVERFLOW!!!')
else:
print(output)
n = int(input())
catch_overflow(n)
```
| 107,097 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a function f written in some basic language. The function accepts an integer value, which is immediately written into some variable x. x is an integer variable and can be assigned values from 0 to 2^{32}-1. The function contains three types of commands:
* for n — for loop;
* end — every command between "for n" and corresponding "end" is executed n times;
* add — adds 1 to x.
After the execution of these commands, value of x is returned.
Every "for n" is matched with "end", thus the function is guaranteed to be valid. "for n" can be immediately followed by "end"."add" command can be outside of any for loops.
Notice that "add" commands might overflow the value of x! It means that the value of x becomes greater than 2^{32}-1 after some "add" command.
Now you run f(0) and wonder if the resulting value of x is correct or some overflow made it incorrect.
If overflow happened then output "OVERFLOW!!!", otherwise print the resulting value of x.
Input
The first line contains a single integer l (1 ≤ l ≤ 10^5) — the number of lines in the function.
Each of the next l lines contains a single command of one of three types:
* for n (1 ≤ n ≤ 100) — for loop;
* end — every command between "for n" and corresponding "end" is executed n times;
* add — adds 1 to x.
Output
If overflow happened during execution of f(0), then output "OVERFLOW!!!", otherwise print the resulting value of x.
Examples
Input
9
add
for 43
end
for 10
for 15
add
end
add
end
Output
161
Input
2
for 62
end
Output
0
Input
11
for 100
for 100
for 100
for 100
for 100
add
end
end
end
end
end
Output
OVERFLOW!!!
Note
In the first example the first "add" is executed 1 time, the second "add" is executed 150 times and the last "add" is executed 10 times. Note that "for n" can be immediately followed by "end" and that "add" can be outside of any for loops.
In the second example there are no commands "add", thus the returning value is 0.
In the third example "add" command is executed too many times, which causes x to go over 2^{32}-1.
Tags: data structures, expression parsing, implementation
Correct Solution:
```
from array import array
n = int(input())
stack = array('Q', list(1 for _ in range(n // 2 + 1)))
stack_top = 1
overflow = 2**32 - 1
s = 0
flag = True
for _ in range(n):
command = input()
if command == "end":
stack_top -= 1
elif command == "add":
s += stack[stack_top - 1]
if s > overflow:
print("OVERFLOW!!!")
flag = False
break
else:
res = stack[stack_top - 1] * int(command[4 : len(command)])
stack[stack_top] = min(res, overflow + 1)
stack_top += 1
if flag:
print(s)
```
| 107,098 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a function f written in some basic language. The function accepts an integer value, which is immediately written into some variable x. x is an integer variable and can be assigned values from 0 to 2^{32}-1. The function contains three types of commands:
* for n — for loop;
* end — every command between "for n" and corresponding "end" is executed n times;
* add — adds 1 to x.
After the execution of these commands, value of x is returned.
Every "for n" is matched with "end", thus the function is guaranteed to be valid. "for n" can be immediately followed by "end"."add" command can be outside of any for loops.
Notice that "add" commands might overflow the value of x! It means that the value of x becomes greater than 2^{32}-1 after some "add" command.
Now you run f(0) and wonder if the resulting value of x is correct or some overflow made it incorrect.
If overflow happened then output "OVERFLOW!!!", otherwise print the resulting value of x.
Input
The first line contains a single integer l (1 ≤ l ≤ 10^5) — the number of lines in the function.
Each of the next l lines contains a single command of one of three types:
* for n (1 ≤ n ≤ 100) — for loop;
* end — every command between "for n" and corresponding "end" is executed n times;
* add — adds 1 to x.
Output
If overflow happened during execution of f(0), then output "OVERFLOW!!!", otherwise print the resulting value of x.
Examples
Input
9
add
for 43
end
for 10
for 15
add
end
add
end
Output
161
Input
2
for 62
end
Output
0
Input
11
for 100
for 100
for 100
for 100
for 100
add
end
end
end
end
end
Output
OVERFLOW!!!
Note
In the first example the first "add" is executed 1 time, the second "add" is executed 150 times and the last "add" is executed 10 times. Note that "for n" can be immediately followed by "end" and that "add" can be outside of any for loops.
In the second example there are no commands "add", thus the returning value is 0.
In the third example "add" command is executed too many times, which causes x to go over 2^{32}-1.
Tags: data structures, expression parsing, implementation
Correct Solution:
```
n=int(input())
stack_for = [[1,0]]
overflow=int(0xffffffff)
ans=0
for i in range(n) :
c = input()
if c[0] == 'f' :
f_str=c.split()
stack_for.append([int(f_str[1]),0])
elif c[0] == 'a' :
L=stack_for.pop()
a=L[1]
a+=1
L[1] = a
stack_for.append(L)
else :
L = stack_for.pop()
f= L[0]
a=L[1]
stack_for[len(stack_for)-1][1]+=(f*a)
if stack_for[len(stack_for)-1][1] > overflow :
print("OVERFLOW!!!")
exit(0)
ans=stack_for.pop()[1]
if ans <= overflow :
print(ans)
else :
print("OVERFLOW!!!")
```
| 107,099 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.