message stringlengths 2 15.4k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 45 107k | cluster float64 21 21 | __index_level_0__ int64 90 214k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string a, consisting of n characters, n is even. For each i from 1 to n a_i is one of 'A', 'B' or 'C'.
A bracket sequence is a string containing only characters "(" and ")". A regular bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()()" and "(())" are regular (the resulting expressions are: "(1)+(1)" and "((1+1)+1)"), and ")(", "(" and ")" are not.
You want to find a string b that consists of n characters such that:
* b is a regular bracket sequence;
* if for some i and j (1 β€ i, j β€ n) a_i=a_j, then b_i=b_j.
In other words, you want to replace all occurrences of 'A' with the same type of bracket, then all occurrences of 'B' with the same type of bracket and all occurrences of 'C' with the same type of bracket.
Your task is to determine if such a string b exists.
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of testcases.
Then the descriptions of t testcases follow.
The only line of each testcase contains a string a. a consists only of uppercase letters 'A', 'B' and 'C'. Let n be the length of a. It is guaranteed that n is even and 2 β€ n β€ 50.
Output
For each testcase print "YES" if there exists such a string b that:
* b is a regular bracket sequence;
* if for some i and j (1 β€ i, j β€ n) a_i=a_j, then b_i=b_j.
Otherwise, print "NO".
You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES are all recognized as positive answer).
Example
Input
4
AABBAC
CACA
BBBBAC
ABCA
Output
YES
YES
NO
NO
Note
In the first testcase one of the possible strings b is "(())()".
In the second testcase one of the possible strings b is "()()".
Submitted Solution:
```
for s in[*open(0)][1:]:
a=max('ABC',key=s.count);r=0,
for u in s[:-1]:r+=r[-1]+2*(u==a)-1,
print('YNEOS'[r[-1]|min(r)*max(r)!=0::2])
``` | instruction | 0 | 21,435 | 21 | 42,870 |
Yes | output | 1 | 21,435 | 21 | 42,871 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string a, consisting of n characters, n is even. For each i from 1 to n a_i is one of 'A', 'B' or 'C'.
A bracket sequence is a string containing only characters "(" and ")". A regular bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()()" and "(())" are regular (the resulting expressions are: "(1)+(1)" and "((1+1)+1)"), and ")(", "(" and ")" are not.
You want to find a string b that consists of n characters such that:
* b is a regular bracket sequence;
* if for some i and j (1 β€ i, j β€ n) a_i=a_j, then b_i=b_j.
In other words, you want to replace all occurrences of 'A' with the same type of bracket, then all occurrences of 'B' with the same type of bracket and all occurrences of 'C' with the same type of bracket.
Your task is to determine if such a string b exists.
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of testcases.
Then the descriptions of t testcases follow.
The only line of each testcase contains a string a. a consists only of uppercase letters 'A', 'B' and 'C'. Let n be the length of a. It is guaranteed that n is even and 2 β€ n β€ 50.
Output
For each testcase print "YES" if there exists such a string b that:
* b is a regular bracket sequence;
* if for some i and j (1 β€ i, j β€ n) a_i=a_j, then b_i=b_j.
Otherwise, print "NO".
You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES are all recognized as positive answer).
Example
Input
4
AABBAC
CACA
BBBBAC
ABCA
Output
YES
YES
NO
NO
Note
In the first testcase one of the possible strings b is "(())()".
In the second testcase one of the possible strings b is "()()".
Submitted Solution:
```
#######################################################################################################################
# Author: BlackFyre
# Language: PyPy 3.7
#######################################################################################################################
from sys import stdin, stdout, setrecursionlimit
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log, log2
from random import seed, randint
from datetime import datetime
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
from collections import defaultdict as dd
mod = pow(10, 9) + 7
mod2 = 998244353
# setrecursionlimit(3000)
def inp(): return stdin.readline().strip()
def iinp(): return int(inp())
def out(var, end="\n"): stdout.write(str(var) + "\n")
def outa(*var, end="\n"): stdout.write(' '.join(map(str, var)) + end)
def lmp(): return list(mp())
def mp(): return map(int, inp().split())
def smp(): return map(str, inp().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(m, val) for j in range(n)]
def remadd(x, y): return 1 if x % y else 0
def ceil(a, b): return (a + b - 1) // b
def def_value(): return 0
def def_inf(): return inf
for _ in range(iinp()):
a = inp()
x = list(set(a+"ABC"))
n = len(a)
cntl = l1d(3)
cntr = l1d(3)
flg = l1d(3,True)
b = ["","",""]
for i in range(n):
if a[i]==x[0]:
for j in range(3): cntl[j]+=1
for j in range(3): b[j]+="("
elif a[i]==x[1]:
cntl[0]+=1
b[0]+="("
cntr[1]+=1
b[1]+=")"
cntr[2]+=1
b[2]+=")"
else:
cntr[0]+=1
b[0]+=")"
cntl[1]+=1
b[1]+="("
cntr[2]+=1
b[2]+=")"
for j in range(3):
if cntr[j]>cntl[j]: flg[j]=False
f = False
for i in range(3):
if flg[i] and cntl[i]==cntr[i]:
print("YES")
f =True
break
if not f: print("NO")
``` | instruction | 0 | 21,436 | 21 | 42,872 |
Yes | output | 1 | 21,436 | 21 | 42,873 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string a, consisting of n characters, n is even. For each i from 1 to n a_i is one of 'A', 'B' or 'C'.
A bracket sequence is a string containing only characters "(" and ")". A regular bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()()" and "(())" are regular (the resulting expressions are: "(1)+(1)" and "((1+1)+1)"), and ")(", "(" and ")" are not.
You want to find a string b that consists of n characters such that:
* b is a regular bracket sequence;
* if for some i and j (1 β€ i, j β€ n) a_i=a_j, then b_i=b_j.
In other words, you want to replace all occurrences of 'A' with the same type of bracket, then all occurrences of 'B' with the same type of bracket and all occurrences of 'C' with the same type of bracket.
Your task is to determine if such a string b exists.
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of testcases.
Then the descriptions of t testcases follow.
The only line of each testcase contains a string a. a consists only of uppercase letters 'A', 'B' and 'C'. Let n be the length of a. It is guaranteed that n is even and 2 β€ n β€ 50.
Output
For each testcase print "YES" if there exists such a string b that:
* b is a regular bracket sequence;
* if for some i and j (1 β€ i, j β€ n) a_i=a_j, then b_i=b_j.
Otherwise, print "NO".
You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES are all recognized as positive answer).
Example
Input
4
AABBAC
CACA
BBBBAC
ABCA
Output
YES
YES
NO
NO
Note
In the first testcase one of the possible strings b is "(())()".
In the second testcase one of the possible strings b is "()()".
Submitted Solution:
```
import sys
import math
import bisect
from sys import stdin,stdout
from math import gcd,floor,sqrt,log
from collections import defaultdict as dd
from bisect import bisect_left as bl,bisect_right as br
sys.setrecursionlimit(100000000)
inp =lambda: int(input())
strng =lambda: input().strip()
jn =lambda x,l: x.join(map(str,l))
strl =lambda: list(input().strip())
mul =lambda: map(int,input().strip().split())
mulf =lambda: map(float,input().strip().split())
seq =lambda: list(map(int,input().strip().split()))
ceil =lambda x: int(x) if(x==int(x)) else int(x)+1
ceildiv=lambda x,d: x//d if(x%d==0) else x//d+1
flush =lambda: stdout.flush()
stdstr =lambda: stdin.readline()
stdint =lambda: int(stdin.readline())
stdpr =lambda x: stdout.write(str(x))
mod=1000000007
#main code
for _ in range(int(input())):
ls=input().strip()
n=len(ls)
cA=ls.count('A')
cB=ls.count('B')
cC=ls.count('C')
if(cA>n//2 or cB>n//2 or cC>n//2):
print('NO')
continue
op=str(ls[0])
cl=str(ls[len(ls)-1])
if op==cl:
print('NO')
continue
else:
l=['A','B','C']
l.remove(str(op))
l.remove(str(cl))
if(ls.count(op)+ ls.count(l[0]))== ls.count(cl):
# if ls.count(l[0])>0:
# ls.replace(str(l[0]),op)
# print(ls)
# for i in range(len(ls)):
# if ls[i]==l[0]:
# ls=ls[:i]+str(op)+ls[i+1:]
c=0
for ele in ls:
if ele==op or ele == l[0]:
c+=1
else:
c-=1
if c<0:
print("NO")
break
if c==0:
print("YES")
elif c>0:
print("NO")
elif (ls.count(op) == (ls.count(l[0])+ ls.count(cl) )):
# if ls.count(l[0])>0:
# ls.replace(l[0],cl)
c=0
for ele in ls:
if ele==op:
c+=1
else:
c-=1
if c<0:
print("NO")
break
if c==0:
print("YES")
elif c>0:
print("NO")
else:
print('NO')
``` | instruction | 0 | 21,437 | 21 | 42,874 |
Yes | output | 1 | 21,437 | 21 | 42,875 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string a, consisting of n characters, n is even. For each i from 1 to n a_i is one of 'A', 'B' or 'C'.
A bracket sequence is a string containing only characters "(" and ")". A regular bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()()" and "(())" are regular (the resulting expressions are: "(1)+(1)" and "((1+1)+1)"), and ")(", "(" and ")" are not.
You want to find a string b that consists of n characters such that:
* b is a regular bracket sequence;
* if for some i and j (1 β€ i, j β€ n) a_i=a_j, then b_i=b_j.
In other words, you want to replace all occurrences of 'A' with the same type of bracket, then all occurrences of 'B' with the same type of bracket and all occurrences of 'C' with the same type of bracket.
Your task is to determine if such a string b exists.
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of testcases.
Then the descriptions of t testcases follow.
The only line of each testcase contains a string a. a consists only of uppercase letters 'A', 'B' and 'C'. Let n be the length of a. It is guaranteed that n is even and 2 β€ n β€ 50.
Output
For each testcase print "YES" if there exists such a string b that:
* b is a regular bracket sequence;
* if for some i and j (1 β€ i, j β€ n) a_i=a_j, then b_i=b_j.
Otherwise, print "NO".
You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES are all recognized as positive answer).
Example
Input
4
AABBAC
CACA
BBBBAC
ABCA
Output
YES
YES
NO
NO
Note
In the first testcase one of the possible strings b is "(())()".
In the second testcase one of the possible strings b is "()()".
Submitted Solution:
```
for _ in range(int(input())):
li = list(input())
li2 = ["A","B","C"]
inde = 0
if li[0]==li[-1]: print("NO"); continue
elif (li[0]=="A"):
if (li[-1]=="B"):
for i in li:
if i == "A": inde+=1
if i == "B": inde-=1
if i == "C": inde+=1
if inde<0: break
if inde == 0 :
print("YES")
else:
inde = 0
for i in li:
if i == "A": inde += 1
if i == "B": inde -= 1
if i == "C": inde -= 1
if inde < 0: break
if inde == 0 : print("YES")
else:print("NO")
if (li[-1] == "C"):
for i in li:
if i == "A": inde += 1
if i == "C": inde -= 1
if i == "B": inde += 1
if inde < 0: break
if inde == 0:
print("YES")
else:
inde = 0
for i in li:
if i == "A": inde += 1
if i == "C": inde -= 1
if i == "B": inde -= 1
if inde < 0: break
if inde == 0:
print("YES")
else:
print("NO")
elif (li[0] == "B"):
if (li[-1] == "C"):
for i in li:
if i == "B": inde += 1
if i == "C": inde -= 1
if i == "A": inde += 1
if inde < 0: break
if inde == 0:
print("YES")
else:
inde = 0
for i in li:
if i == "B": inde += 1
if i == "C": inde -= 1
if i == "A": inde -= 1
if inde < 0: break
if inde == 0:
print("YES")
else:
print("NO")
if (li[-1] == "A"):
for i in li:
if i == "B": inde += 1
if i == "A": inde -= 1
if i == "C": inde += 1
if inde < 0: break
if inde == 0:
print("YES")
else:
inde = 0
for i in li:
if i == "B": inde += 1
if i == "A": inde -= 1
if i == "C": inde -= 1
if inde < 0: break
if inde == 0:
print("YES")
else:
print("NO")
elif (li[0] == "C"):
if (li[-1] == "A"):
for i in li:
if i == "C": inde += 1
if i == "A": inde -= 1
if i == "B": inde += 1
if inde < 0: break
if inde == 0:
print("YES")
else:
inde = 0
for i in li:
if i == "C": inde += 1
if i == "A": inde -= 1
if i == "B": inde -= 1
if inde < 0: break
if inde == 0:
print("YES")
else:
print("NO")
if (li[-1] == "B"):
for i in li:
if i == "C": inde += 1
if i == "B": inde -= 1
if i == "A": inde += 1
if inde < 0: break
if inde == 0:
print("YES")
else:
inde = 0
for i in li:
if i == "C": inde += 1
if i == "B": inde -= 1
if i == "A": inde -= 1
if inde < 0: break
if inde == 0:
print("YES")
else:
print("NO")
``` | instruction | 0 | 21,438 | 21 | 42,876 |
Yes | output | 1 | 21,438 | 21 | 42,877 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string a, consisting of n characters, n is even. For each i from 1 to n a_i is one of 'A', 'B' or 'C'.
A bracket sequence is a string containing only characters "(" and ")". A regular bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()()" and "(())" are regular (the resulting expressions are: "(1)+(1)" and "((1+1)+1)"), and ")(", "(" and ")" are not.
You want to find a string b that consists of n characters such that:
* b is a regular bracket sequence;
* if for some i and j (1 β€ i, j β€ n) a_i=a_j, then b_i=b_j.
In other words, you want to replace all occurrences of 'A' with the same type of bracket, then all occurrences of 'B' with the same type of bracket and all occurrences of 'C' with the same type of bracket.
Your task is to determine if such a string b exists.
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of testcases.
Then the descriptions of t testcases follow.
The only line of each testcase contains a string a. a consists only of uppercase letters 'A', 'B' and 'C'. Let n be the length of a. It is guaranteed that n is even and 2 β€ n β€ 50.
Output
For each testcase print "YES" if there exists such a string b that:
* b is a regular bracket sequence;
* if for some i and j (1 β€ i, j β€ n) a_i=a_j, then b_i=b_j.
Otherwise, print "NO".
You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES are all recognized as positive answer).
Example
Input
4
AABBAC
CACA
BBBBAC
ABCA
Output
YES
YES
NO
NO
Note
In the first testcase one of the possible strings b is "(())()".
In the second testcase one of the possible strings b is "()()".
Submitted Solution:
```
def sm(a,j,p,n):
f=0
for i in range(1,len(a)//2):
if a[i]==p and a[len(a)-i-1]==p:
f+=2
elif a[i]==n and a[len(a)-i-1]!=n and a[len(a)-i-1]!=p:
f=-1+j+f
elif a[len(a)-i-1]==n and a[i]!=n and a[i]!=p:
f=-1+j+f
elif a[i]==p and a[len(a)-i-1]!=n and a[len(a)-1-i]!=p:
f=1+j+f
elif a[len(a)-i-1]==p and a[i]!=n and a[i]!=p:
f=1+j+f
elif a[i]!=n and a[i]!=p and a[len(a)-1-i]!=n and a[len(a)-i-1]!=p:
f=f+2*j
elif a[i]==n and a[len(a)-i-1]==n:
f-=2
if f!=0:
return 'n'
return 'y'
out=[]
for _ in range(int(input())):
a = input()
p, n = a[0], a[-1]
if p == n:
out.append('NO')
else:
f1 = sm(a, 1, p, n)
f2 = sm(a, -1, p, n)
if f1 == 'y' or f2 == 'y':
out.append('YES')
else:
out.append('NO')
for i in out:
print(i)
``` | instruction | 0 | 21,439 | 21 | 42,878 |
No | output | 1 | 21,439 | 21 | 42,879 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string a, consisting of n characters, n is even. For each i from 1 to n a_i is one of 'A', 'B' or 'C'.
A bracket sequence is a string containing only characters "(" and ")". A regular bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()()" and "(())" are regular (the resulting expressions are: "(1)+(1)" and "((1+1)+1)"), and ")(", "(" and ")" are not.
You want to find a string b that consists of n characters such that:
* b is a regular bracket sequence;
* if for some i and j (1 β€ i, j β€ n) a_i=a_j, then b_i=b_j.
In other words, you want to replace all occurrences of 'A' with the same type of bracket, then all occurrences of 'B' with the same type of bracket and all occurrences of 'C' with the same type of bracket.
Your task is to determine if such a string b exists.
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of testcases.
Then the descriptions of t testcases follow.
The only line of each testcase contains a string a. a consists only of uppercase letters 'A', 'B' and 'C'. Let n be the length of a. It is guaranteed that n is even and 2 β€ n β€ 50.
Output
For each testcase print "YES" if there exists such a string b that:
* b is a regular bracket sequence;
* if for some i and j (1 β€ i, j β€ n) a_i=a_j, then b_i=b_j.
Otherwise, print "NO".
You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES are all recognized as positive answer).
Example
Input
4
AABBAC
CACA
BBBBAC
ABCA
Output
YES
YES
NO
NO
Note
In the first testcase one of the possible strings b is "(())()".
In the second testcase one of the possible strings b is "()()".
Submitted Solution:
```
t = int (input ())
while t:
t -= 1
s = input()
if len (s)<2:
print ('NO')
continue
if s[0] == s[-1]:
print ('NO')
continue
dct = {'A':0, 'B':0, 'C':0}
for x in s:
dct[x] += 1
lst = list(dct.values())
lst.sort()
if lst[2] == lst[1]:
if lst[0] % 2 == 0:
print ('YES')
continue
else:
print ('NO')
continue
else:
if lst[2]-lst[1] == lst[0]:
print ('YES')
continue
else:
print('NO')
continue
``` | instruction | 0 | 21,440 | 21 | 42,880 |
No | output | 1 | 21,440 | 21 | 42,881 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string a, consisting of n characters, n is even. For each i from 1 to n a_i is one of 'A', 'B' or 'C'.
A bracket sequence is a string containing only characters "(" and ")". A regular bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()()" and "(())" are regular (the resulting expressions are: "(1)+(1)" and "((1+1)+1)"), and ")(", "(" and ")" are not.
You want to find a string b that consists of n characters such that:
* b is a regular bracket sequence;
* if for some i and j (1 β€ i, j β€ n) a_i=a_j, then b_i=b_j.
In other words, you want to replace all occurrences of 'A' with the same type of bracket, then all occurrences of 'B' with the same type of bracket and all occurrences of 'C' with the same type of bracket.
Your task is to determine if such a string b exists.
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of testcases.
Then the descriptions of t testcases follow.
The only line of each testcase contains a string a. a consists only of uppercase letters 'A', 'B' and 'C'. Let n be the length of a. It is guaranteed that n is even and 2 β€ n β€ 50.
Output
For each testcase print "YES" if there exists such a string b that:
* b is a regular bracket sequence;
* if for some i and j (1 β€ i, j β€ n) a_i=a_j, then b_i=b_j.
Otherwise, print "NO".
You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES are all recognized as positive answer).
Example
Input
4
AABBAC
CACA
BBBBAC
ABCA
Output
YES
YES
NO
NO
Note
In the first testcase one of the possible strings b is "(())()".
In the second testcase one of the possible strings b is "()()".
Submitted Solution:
```
tcs = int(input())
for tc in range(tcs):
A = input()
if A[0] == A[-1]:
print('no')
continue
bal = 0
first, last = A[0], A[-1]
for i in range(len(A)):
if A[i] == first:
bal += 1
elif A[i] == last:
bal -= 1
else:
bal += 1
if bal == 0:
print('yes')
continue
bal = 0
for i in range(len(A)):
if A[i] == first:
bal += 1
elif A[i] == last:
bal -= 1
else:
bal -= 1
if bal == 0:
print('yes')
else:
print('no')
``` | instruction | 0 | 21,441 | 21 | 42,882 |
No | output | 1 | 21,441 | 21 | 42,883 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string a, consisting of n characters, n is even. For each i from 1 to n a_i is one of 'A', 'B' or 'C'.
A bracket sequence is a string containing only characters "(" and ")". A regular bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()()" and "(())" are regular (the resulting expressions are: "(1)+(1)" and "((1+1)+1)"), and ")(", "(" and ")" are not.
You want to find a string b that consists of n characters such that:
* b is a regular bracket sequence;
* if for some i and j (1 β€ i, j β€ n) a_i=a_j, then b_i=b_j.
In other words, you want to replace all occurrences of 'A' with the same type of bracket, then all occurrences of 'B' with the same type of bracket and all occurrences of 'C' with the same type of bracket.
Your task is to determine if such a string b exists.
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of testcases.
Then the descriptions of t testcases follow.
The only line of each testcase contains a string a. a consists only of uppercase letters 'A', 'B' and 'C'. Let n be the length of a. It is guaranteed that n is even and 2 β€ n β€ 50.
Output
For each testcase print "YES" if there exists such a string b that:
* b is a regular bracket sequence;
* if for some i and j (1 β€ i, j β€ n) a_i=a_j, then b_i=b_j.
Otherwise, print "NO".
You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES are all recognized as positive answer).
Example
Input
4
AABBAC
CACA
BBBBAC
ABCA
Output
YES
YES
NO
NO
Note
In the first testcase one of the possible strings b is "(())()".
In the second testcase one of the possible strings b is "()()".
Submitted Solution:
```
def valid(string,a,b,c):
count=0
for i in string:
if(i=='A'):
count+=a
elif(i=='B'):
count+=b
else:
count+=c
return count
for _ in range(int(input())):
string=str(input())
if(string[0]==string[-1]):
print("NO")
else:
if(string[0]=='A'):
if(valid(string,1,-1,-1)!=0):
if(valid(string,1,-1,1)!=0):
if(valid(string,1,1,-1)!=0):
print("NO")
else:
print("YES")
else:
print("YES")
else:
print("YES")
elif(string[0]=='B'):
if(valid(string,-1,1,-1)!=0):
if(valid(string,-1,1,1)!=0):
if(valid(string,1,1,-1)!=0):
print("NO")
else:
print("YES")
else:
print("YES")
else:
print("YES")
elif(string[0]=='C'):
if(valid(string,-1,-1,1)!=0):
if(valid(string,-1,1,1)!=0):
if(valid(string,1,-1,1)!=0):
print("NO")
else:
print("YES")
else:
print("YES")
else:
print("YES")
``` | instruction | 0 | 21,442 | 21 | 42,884 |
No | output | 1 | 21,442 | 21 | 42,885 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A bracket sequence is a string, containing only characters "(", ")", "[" and "]".
A correct bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()[]", "([])" are correct (the resulting expressions are: "(1)+[1]", "([1+1]+1)"), and "](" and "[" are not. The empty string is a correct bracket sequence by definition.
A substring s[l... r] (1 β€ l β€ r β€ |s|) of string s = s1s2... s|s| (where |s| is the length of string s) is the string slsl + 1... sr. The empty string is a substring of any string by definition.
You are given a bracket sequence, not necessarily correct. Find its substring which is a correct bracket sequence and contains as many opening square brackets Β«[Β» as possible.
Input
The first and the only line contains the bracket sequence as a string, consisting only of characters "(", ")", "[" and "]". It is guaranteed that the string is non-empty and its length doesn't exceed 105 characters.
Output
In the first line print a single integer β the number of brackets Β«[Β» in the required bracket sequence. In the second line print the optimal sequence. If there are more than one optimal solutions print any of them.
Examples
Input
([])
Output
1
([])
Input
(((
Output
0 | instruction | 0 | 24,096 | 21 | 48,192 |
Tags: data structures, expression parsing, implementation
Correct Solution:
```
'''input
((()))([]
'''
from sys import stdin
def check_valid(string):
stack = []
for i in string:
if i in ['(', '[']:
stack.append(i)
elif i == ')':
if len(stack) > 0:
if stack[-1] == '(':
stack.pop()
continue
return False
elif i == ']':
if len(stack) > 0:
if stack[-1] == '[':
stack.pop()
continue
return False
return len(stack) == 0
def merge(index):
# refining
aux = []
if len(index) > 0:
start = index[0][0]
end = index[0][1]
for i in range(1, len(index)):
s, e = index[i]
if e <= end:
pass
elif s >= end:
aux.append([start, end])
start, end = s, e
aux.append([start, end])
index = aux
# acutal merging
aux = []
if len(index) > 0:
aux = [index[0]]
for i in range(1, len(index)):
if index[i][0] == aux[-1][1] + 1:
aux[-1][1] = index[i][1]
else:
if check_valid(string[aux[-1][1] + 1: index[i][0]]):
aux[-1][1] = index[i][1]
else:
aux.append(index[i])
return aux
# main starts
string = stdin.readline().strip()
stack = []
index = []
start = -1
end = -1
for i in range(len(string)):
if string[i] == '(':
stack.append(i)
elif string[i] == '[':
stack.append(i)
elif string[i] == ')':
if len(stack) > 0 and string[stack[-1]] == '(':
index.append([stack[-1], i])
stack.pop()
else:
stack = []
elif string[i] == ']':
if len(stack) > 0 and string[stack[-1]] == '[':
index.append([stack[-1], i])
stack.pop()
else:
stack = []
index.sort(key = lambda x:(x[0], x[1]))
index = merge(index)
diff = 0
ans = [-1, -1]
for i in index:
start, end = i
c = string[start: end + 1].count('[')
if diff < c :
ans = [start, end + 1]
diff = c
print(diff)
print(string[ans[0]: ans[1]])
``` | output | 1 | 24,096 | 21 | 48,193 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A bracket sequence is a string, containing only characters "(", ")", "[" and "]".
A correct bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()[]", "([])" are correct (the resulting expressions are: "(1)+[1]", "([1+1]+1)"), and "](" and "[" are not. The empty string is a correct bracket sequence by definition.
A substring s[l... r] (1 β€ l β€ r β€ |s|) of string s = s1s2... s|s| (where |s| is the length of string s) is the string slsl + 1... sr. The empty string is a substring of any string by definition.
You are given a bracket sequence, not necessarily correct. Find its substring which is a correct bracket sequence and contains as many opening square brackets Β«[Β» as possible.
Input
The first and the only line contains the bracket sequence as a string, consisting only of characters "(", ")", "[" and "]". It is guaranteed that the string is non-empty and its length doesn't exceed 105 characters.
Output
In the first line print a single integer β the number of brackets Β«[Β» in the required bracket sequence. In the second line print the optimal sequence. If there are more than one optimal solutions print any of them.
Examples
Input
([])
Output
1
([])
Input
(((
Output
0 | instruction | 0 | 24,097 | 21 | 48,194 |
Tags: data structures, expression parsing, implementation
Correct Solution:
```
import sys
import math
import string
import operator
import functools
import fractions
import collections
sys.setrecursionlimit(10**7)
dX= [-1, 1, 0, 0,-1, 1,-1, 1]
dY= [ 0, 0,-1, 1, 1,-1,-1, 1]
RI=lambda: list(map(int,input().split()))
RS=lambda: input().rstrip().split()
#################################################
s=RS()[0]
st=[]
closeInd=[0]*len(s)
def rev(c):
return "(["[c==']']
for i in range(len(s)):
if len(st) and s[i] in ")]" and st[-1][0]==rev(s[i]):
temp=st[-1]
st.pop()
closeInd[temp[1]]=i
else:
st.append((s[i],i))
maxSq=0
maxX,maxY=0,0
i=0
while i<len(s):
sq=0
start=i
while i<len(s) and closeInd[i]:
j=i
while i<=closeInd[j]:
if s[i]=='[':
sq+=1
i+=1
else:
i+=1
if sq>maxSq:
maxSq=sq
maxX=start
maxY=i-1
print(maxSq, s[maxX:maxY], sep='\n')
``` | output | 1 | 24,097 | 21 | 48,195 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A bracket sequence is a string, containing only characters "(", ")", "[" and "]".
A correct bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()[]", "([])" are correct (the resulting expressions are: "(1)+[1]", "([1+1]+1)"), and "](" and "[" are not. The empty string is a correct bracket sequence by definition.
A substring s[l... r] (1 β€ l β€ r β€ |s|) of string s = s1s2... s|s| (where |s| is the length of string s) is the string slsl + 1... sr. The empty string is a substring of any string by definition.
You are given a bracket sequence, not necessarily correct. Find its substring which is a correct bracket sequence and contains as many opening square brackets Β«[Β» as possible.
Input
The first and the only line contains the bracket sequence as a string, consisting only of characters "(", ")", "[" and "]". It is guaranteed that the string is non-empty and its length doesn't exceed 105 characters.
Output
In the first line print a single integer β the number of brackets Β«[Β» in the required bracket sequence. In the second line print the optimal sequence. If there are more than one optimal solutions print any of them.
Examples
Input
([])
Output
1
([])
Input
(((
Output
0 | instruction | 0 | 24,098 | 21 | 48,196 |
Tags: data structures, expression parsing, implementation
Correct Solution:
```
string = list(input())
d, p = [], set(range(len(string)))
for j, q in enumerate(string):
if q in '([': d.append((j,q))
elif d:
i, x = d.pop()
if x+q in '(][)': d = []
else: p -= {i, j}
n, s = 0, ''
for i in p: string[i] = ' '
for k in "".join(string).split():
if k.count("[") > n:
n = k.count("[")
s = k
print(n, s)
``` | output | 1 | 24,098 | 21 | 48,197 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A bracket sequence is a string, containing only characters "(", ")", "[" and "]".
A correct bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()[]", "([])" are correct (the resulting expressions are: "(1)+[1]", "([1+1]+1)"), and "](" and "[" are not. The empty string is a correct bracket sequence by definition.
A substring s[l... r] (1 β€ l β€ r β€ |s|) of string s = s1s2... s|s| (where |s| is the length of string s) is the string slsl + 1... sr. The empty string is a substring of any string by definition.
You are given a bracket sequence, not necessarily correct. Find its substring which is a correct bracket sequence and contains as many opening square brackets Β«[Β» as possible.
Input
The first and the only line contains the bracket sequence as a string, consisting only of characters "(", ")", "[" and "]". It is guaranteed that the string is non-empty and its length doesn't exceed 105 characters.
Output
In the first line print a single integer β the number of brackets Β«[Β» in the required bracket sequence. In the second line print the optimal sequence. If there are more than one optimal solutions print any of them.
Examples
Input
([])
Output
1
([])
Input
(((
Output
0 | instruction | 0 | 24,099 | 21 | 48,198 |
Tags: data structures, expression parsing, implementation
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 10**9+7
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
s = ri()
sta = []
l,r = -1,-2
lis = []
for i in range(len(s)):
if s[i] == '(':
sta.append(['(', i])
elif s[i] == '[':
sta.append(['[', i])
elif s[i] == ')':
if len(sta) == 0 or sta[-1][0] != '(':
sta = []
else:
temp = sta.pop()
lis.append([temp[1], i])
elif s[i] == ']':
if len(sta) == 0 or sta[-1][0] != '[':
sta = []
else:
temp = sta.pop()
lis.append([temp[1], i])
lis.sort(key = lambda x : (x[0], -x[1]))
cur = []
totcnt =0
cnt = 0
# print(lis)
for i in range(len(lis)):
if len(cur) == 0:
cur = lis[i][:]
if s[lis[i][0]] == '[':
cnt+=1
elif cur[0] <= lis[i][0] and lis[i][1] <= cur[1]:
if s[lis[i][0]] == '[':
cnt+=1
else:
if lis[i][0] == cur[1]+1:
cur[1] = lis[i][1]
if s[lis[i][0]] == '[':
cnt+=1
else:
if cnt > totcnt:
l,r = cur[0],cur[1]
totcnt = cnt
cur = lis[i][:]
cnt = 0
if s[lis[i][0]] == '[':
cnt+=1
if cnt > totcnt:
l,r = cur[0],cur[1]
if l == -1:
print(0)
else:
cnt =0
for i in range(l, r+1):
if s[i] == '[':
cnt+=1
print(cnt)
print(s[l:r+1])
``` | output | 1 | 24,099 | 21 | 48,199 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A bracket sequence is a string, containing only characters "(", ")", "[" and "]".
A correct bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()[]", "([])" are correct (the resulting expressions are: "(1)+[1]", "([1+1]+1)"), and "](" and "[" are not. The empty string is a correct bracket sequence by definition.
A substring s[l... r] (1 β€ l β€ r β€ |s|) of string s = s1s2... s|s| (where |s| is the length of string s) is the string slsl + 1... sr. The empty string is a substring of any string by definition.
You are given a bracket sequence, not necessarily correct. Find its substring which is a correct bracket sequence and contains as many opening square brackets Β«[Β» as possible.
Input
The first and the only line contains the bracket sequence as a string, consisting only of characters "(", ")", "[" and "]". It is guaranteed that the string is non-empty and its length doesn't exceed 105 characters.
Output
In the first line print a single integer β the number of brackets Β«[Β» in the required bracket sequence. In the second line print the optimal sequence. If there are more than one optimal solutions print any of them.
Examples
Input
([])
Output
1
([])
Input
(((
Output
0 | instruction | 0 | 24,100 | 21 | 48,200 |
Tags: data structures, expression parsing, implementation
Correct Solution:
```
t = list(input())
d, p = [], set(range(len(t)))
for j, q in enumerate(t):
if q in '([': d.append((q, j))
elif d:
x, i = d.pop()
if x + q in '(][)': d = []
else: p -= {i, j}
for i in p: t[i] = ' '
n, s = 0, ''
for q in ''.join(t).split():
k = q.count('[')
if k > n: n, s = k, q
print(n, s)
``` | output | 1 | 24,100 | 21 | 48,201 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A bracket sequence is a string, containing only characters "(", ")", "[" and "]".
A correct bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()[]", "([])" are correct (the resulting expressions are: "(1)+[1]", "([1+1]+1)"), and "](" and "[" are not. The empty string is a correct bracket sequence by definition.
A substring s[l... r] (1 β€ l β€ r β€ |s|) of string s = s1s2... s|s| (where |s| is the length of string s) is the string slsl + 1... sr. The empty string is a substring of any string by definition.
You are given a bracket sequence, not necessarily correct. Find its substring which is a correct bracket sequence and contains as many opening square brackets Β«[Β» as possible.
Input
The first and the only line contains the bracket sequence as a string, consisting only of characters "(", ")", "[" and "]". It is guaranteed that the string is non-empty and its length doesn't exceed 105 characters.
Output
In the first line print a single integer β the number of brackets Β«[Β» in the required bracket sequence. In the second line print the optimal sequence. If there are more than one optimal solutions print any of them.
Examples
Input
([])
Output
1
([])
Input
(((
Output
0 | instruction | 0 | 24,101 | 21 | 48,202 |
Tags: data structures, expression parsing, implementation
Correct Solution:
```
s, st, v, vi, vj, vc = input(), [], [], 0, 0, 0
for i, ch in enumerate(s):
if ch == "[" or ch == "(":
st.append(i)
else:
if st and s[st[-1]] + ch in ('()', '[]'):
b = (st[-1], i + 1)
if v and v[-1][1] == i:
v[-1] = b
else:
v.append(b)
if len(v) >= 2 and v[-2][1] == v[-1][0]:
v[-2:] = [(v[-2][0], v[-1][1])]
st.pop()
else:
st = []
for b in v:
c = s.count('[', b[0], b[1])
if c > vc:
vi, vj, vc = b[0], b[1], c
print(vc)
print(s[vi:vj])
``` | output | 1 | 24,101 | 21 | 48,203 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A bracket sequence is a string, containing only characters "(", ")", "[" and "]".
A correct bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()[]", "([])" are correct (the resulting expressions are: "(1)+[1]", "([1+1]+1)"), and "](" and "[" are not. The empty string is a correct bracket sequence by definition.
A substring s[l... r] (1 β€ l β€ r β€ |s|) of string s = s1s2... s|s| (where |s| is the length of string s) is the string slsl + 1... sr. The empty string is a substring of any string by definition.
You are given a bracket sequence, not necessarily correct. Find its substring which is a correct bracket sequence and contains as many opening square brackets Β«[Β» as possible.
Input
The first and the only line contains the bracket sequence as a string, consisting only of characters "(", ")", "[" and "]". It is guaranteed that the string is non-empty and its length doesn't exceed 105 characters.
Output
In the first line print a single integer β the number of brackets Β«[Β» in the required bracket sequence. In the second line print the optimal sequence. If there are more than one optimal solutions print any of them.
Examples
Input
([])
Output
1
([])
Input
(((
Output
0 | instruction | 0 | 24,102 | 21 | 48,204 |
Tags: data structures, expression parsing, implementation
Correct Solution:
```
s = input()
a = []
for i in range(len(s)):
if len(a) != 0 and ((s[a[-1]] == '(' and s[i] == ')') or (s[a[-1]] == '[' and s[i] == ']')):
a.pop()
else:
a.append(i)
if len(a) == 0:
print(s.count('['))
print(s)
else:
s1 = s[0: a[0]]
le = s[0: a[0]].count('[')
for i in range(len(a) - 1):
le1 = s[a[i] + 1: a[i + 1]].count('[')
if le1 > le:
s1 = s[a[i] + 1: a[i + 1]]
le = le1
le1 = s[a[-1] + 1:].count('[')
if le1 > le:
s1 = s[a[-1] + 1:]
le = le1
print(le)
print(s1)
``` | output | 1 | 24,102 | 21 | 48,205 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A bracket sequence is a string, containing only characters "(", ")", "[" and "]".
A correct bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()[]", "([])" are correct (the resulting expressions are: "(1)+[1]", "([1+1]+1)"), and "](" and "[" are not. The empty string is a correct bracket sequence by definition.
A substring s[l... r] (1 β€ l β€ r β€ |s|) of string s = s1s2... s|s| (where |s| is the length of string s) is the string slsl + 1... sr. The empty string is a substring of any string by definition.
You are given a bracket sequence, not necessarily correct. Find its substring which is a correct bracket sequence and contains as many opening square brackets Β«[Β» as possible.
Input
The first and the only line contains the bracket sequence as a string, consisting only of characters "(", ")", "[" and "]". It is guaranteed that the string is non-empty and its length doesn't exceed 105 characters.
Output
In the first line print a single integer β the number of brackets Β«[Β» in the required bracket sequence. In the second line print the optimal sequence. If there are more than one optimal solutions print any of them.
Examples
Input
([])
Output
1
([])
Input
(((
Output
0 | instruction | 0 | 24,103 | 21 | 48,206 |
Tags: data structures, expression parsing, implementation
Correct Solution:
```
S=input().strip()
subIndex=[]
for i in range(len(S)):
if len(subIndex)!=0 and (((S[subIndex[-1]]=='[' and S[i]==']') or (S[subIndex[-1]]=='(' and S[i]==')'))):
subIndex.pop()
else:
subIndex.append(i)
'tamamΔ± dogru olan S'
if not len(subIndex):
print(S.count('['))
print(S)
else:
'index out of range'
subIndex.append(len(S))
'print(subIndex)'
subString=S[:subIndex[0]]
subStringSquaredBracketCount=subString.count('[')
for i in range(len(subIndex)-1):
tempCount=S[subIndex[i]+1:subIndex[i+1]].count('[')
if tempCount>subStringSquaredBracketCount:
subStringSquaredBracketCount=tempCount
subString=S[subIndex[i]+1:subIndex[i+1]]
print(subStringSquaredBracketCount)
print(subString)
"""
([])
1
([])
(((
(][)
0
(()[))()[]
1
()[]
"""
``` | output | 1 | 24,103 | 21 | 48,207 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A bracket sequence is a string, containing only characters "(", ")", "[" and "]".
A correct bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()[]", "([])" are correct (the resulting expressions are: "(1)+[1]", "([1+1]+1)"), and "](" and "[" are not. The empty string is a correct bracket sequence by definition.
A substring s[l... r] (1 β€ l β€ r β€ |s|) of string s = s1s2... s|s| (where |s| is the length of string s) is the string slsl + 1... sr. The empty string is a substring of any string by definition.
You are given a bracket sequence, not necessarily correct. Find its substring which is a correct bracket sequence and contains as many opening square brackets Β«[Β» as possible.
Input
The first and the only line contains the bracket sequence as a string, consisting only of characters "(", ")", "[" and "]". It is guaranteed that the string is non-empty and its length doesn't exceed 105 characters.
Output
In the first line print a single integer β the number of brackets Β«[Β» in the required bracket sequence. In the second line print the optimal sequence. If there are more than one optimal solutions print any of them.
Examples
Input
([])
Output
1
([])
Input
(((
Output
0
Submitted Solution:
```
s, st, v, vi, vj, vc = input(), [], [], 0, 0, 0
for i, ch in enumerate(s):
if ch in '[(':
st.append(i)
else:
if st and s[st[-1]] + ch in ('()', '[]'):
b = (st[-1], i + 1)
if v and v[-1][1] == i:
v[-1] = b
else:
v.append(b)
if len(v) >= 2 and v[-2][1] == v[-1][0]:
v[-2:] = [(v[-2][0], v[-1][1])]
st.pop()
else:
st = []
for b in v:
c = s.count('[', b[0], b[1])
if c > vc:
vi, vj, vc = b[0], b[1], c
print(vc)
print(s[vi:vj])
``` | instruction | 0 | 24,104 | 21 | 48,208 |
Yes | output | 1 | 24,104 | 21 | 48,209 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A bracket sequence is a string, containing only characters "(", ")", "[" and "]".
A correct bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()[]", "([])" are correct (the resulting expressions are: "(1)+[1]", "([1+1]+1)"), and "](" and "[" are not. The empty string is a correct bracket sequence by definition.
A substring s[l... r] (1 β€ l β€ r β€ |s|) of string s = s1s2... s|s| (where |s| is the length of string s) is the string slsl + 1... sr. The empty string is a substring of any string by definition.
You are given a bracket sequence, not necessarily correct. Find its substring which is a correct bracket sequence and contains as many opening square brackets Β«[Β» as possible.
Input
The first and the only line contains the bracket sequence as a string, consisting only of characters "(", ")", "[" and "]". It is guaranteed that the string is non-empty and its length doesn't exceed 105 characters.
Output
In the first line print a single integer β the number of brackets Β«[Β» in the required bracket sequence. In the second line print the optimal sequence. If there are more than one optimal solutions print any of them.
Examples
Input
([])
Output
1
([])
Input
(((
Output
0
Submitted Solution:
```
import sys
from math import gcd,sqrt,ceil,log2
from collections import defaultdict,Counter,deque
from bisect import bisect_left,bisect_right
import math
import heapq
from itertools import permutations
# input=sys.stdin.readline
# def print(x):
# sys.stdout.write(str(x)+"\n")
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# import sys
# import io, os
# input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def get_sum(bit,i):
s = 0
i+=1
while i>0:
s+=bit[i]
i-=i&(-i)
return s
def update(bit,n,i,v):
i+=1
while i<=n:
bit[i]+=v
i+=i&(-i)
def modInverse(b,m):
g = math.gcd(b, m)
if (g != 1):
return -1
else:
return pow(b, m - 2, m)
def primeFactors(n):
sa = set()
sa.add(n)
while n % 2 == 0:
sa.add(2)
n = n // 2
for i in range(3,int(math.sqrt(n))+1,2):
while n % i== 0:
sa.add(i)
n = n // i
# sa.add(n)
return sa
def seive(n):
pri = [True]*(n+1)
p = 2
while p*p<=n:
if pri[p] == True:
for i in range(p*p,n+1,p):
pri[i] = False
p+=1
return pri
def check_prim(n):
if n<0:
return False
for i in range(2,int(sqrt(n))+1):
if n%i == 0:
return False
return True
def getZarr(string, z):
n = len(string)
# [L,R] make a window which matches
# with prefix of s
l, r, k = 0, 0, 0
for i in range(1, n):
# if i>R nothing matches so we will calculate.
# Z[i] using naive way.
if i > r:
l, r = i, i
# R-L = 0 in starting, so it will start
# checking from 0'th index. For example,
# for "ababab" and i = 1, the value of R
# remains 0 and Z[i] becomes 0. For string
# "aaaaaa" and i = 1, Z[i] and R become 5
while r < n and string[r - l] == string[r]:
r += 1
z[i] = r - l
r -= 1
else:
# k = i-L so k corresponds to number which
# matches in [L,R] interval.
k = i - l
# if Z[k] is less than remaining interval
# then Z[i] will be equal to Z[k].
# For example, str = "ababab", i = 3, R = 5
# and L = 2
if z[k] < r - i + 1:
z[i] = z[k]
# For example str = "aaaaaa" and i = 2,
# R is 5, L is 0
else:
# else start from R and check manually
l = i
while r < n and string[r - l] == string[r]:
r += 1
z[i] = r - l
r -= 1
def search(text, pattern):
# Create concatenated string "P$T"
concat = pattern + "$" + text
l = len(concat)
z = [0] * l
getZarr(concat, z)
ha = []
for i in range(l):
if z[i] == len(pattern):
ha.append(i - len(pattern) - 1)
return ha
# n,k = map(int,input().split())
# l = list(map(int,input().split()))
#
# n = int(input())
# l = list(map(int,input().split()))
#
# hash = defaultdict(list)
# la = []
#
# for i in range(n):
# la.append([l[i],i+1])
#
# la.sort(key = lambda x: (x[0],-x[1]))
# ans = []
# r = n
# flag = 0
# lo = []
# ha = [i for i in range(n,0,-1)]
# yo = []
# for a,b in la:
#
# if a == 1:
# ans.append([r,b])
# # hash[(1,1)].append([b,r])
# lo.append((r,b))
# ha.pop(0)
# yo.append([r,b])
# r-=1
#
# elif a == 2:
# # print(yo,lo)
# # print(hash[1,1])
# if lo == []:
# flag = 1
# break
# c,d = lo.pop(0)
# yo.pop(0)
# if b>=d:
# flag = 1
# break
# ans.append([c,b])
# yo.append([c,b])
#
#
#
# elif a == 3:
#
# if yo == []:
# flag = 1
# break
# c,d = yo.pop(0)
# if b>=d:
# flag = 1
# break
# if ha == []:
# flag = 1
# break
#
# ka = ha.pop(0)
#
# ans.append([ka,b])
# ans.append([ka,d])
# yo.append([ka,b])
#
# if flag:
# print(-1)
# else:
# print(len(ans))
# for a,b in ans:
# print(a,b)
def mergeIntervals(arr):
# Sorting based on the increasing order
# of the start intervals
arr.sort(key = lambda x: x[0])
# array to hold the merged intervals
m = []
s = -10000
max = -100000
for i in range(len(arr)):
a = arr[i]
if a[0] > max:
if i != 0:
m.append([s,max])
max = a[1]
s = a[0]
else:
if a[1] >= max:
max = a[1]
#'max' value gives the last point of
# that particular interval
# 's' gives the starting point of that interval
# 'm' array contains the list of all merged intervals
if max != -100000 and [s, max] not in m:
m.append([s, max])
return m
s = input()
n = len(s)
stack = []
i = 0
ans = []
pre = [0]
for i in s:
if i == '[':
pre.append(pre[-1]+1)
else:
pre.append(pre[-1])
i = 0
while i<n:
if s[i] == '(' or s[i] == '[':
stack.append(i)
elif stack!=[] and s[i] == ')' and s[stack[-1]] == '(':
z = stack.pop()
ans.append((z,i))
elif stack!=[] and s[i] == ')' and s[stack[-1]] == '[':
stack = []
elif stack!=[] and s[i] == ']' and s[stack[-1]] == '[':
z = stack.pop()
ans.append((z,i))
elif stack!=[] and s[i] == ']' and s[stack[-1]] == '(':
stack = []
i+=1
ans.sort()
x,y = -1,-1
maxi = 0
lo = []
i = 1
# print(ans)
ans = mergeIntervals(ans)
if ans == []:
print(0)
print()
exit()
a,b = ans[i-1]
lo.append([a,b])
# print(ans)
while i<=len(ans):
a,b = ans[i-1]
while i<len(ans) and ans[i][0]-ans[i-1][1] == 1:
i+=1
lo.append([a,ans[i-1][1]])
i+=1
ans = lo
# print(lo)
for i in range(len(ans)):
a,b = ans[i]
a+=1
b+=1
z = pre[b] - pre[a-1]
if z>maxi:
maxi = z
a-=1
b-=1
x,y = a,b
if ans == []:
print(0)
print()
else:
print(maxi)
print(s[x:y+1])
``` | instruction | 0 | 24,105 | 21 | 48,210 |
Yes | output | 1 | 24,105 | 21 | 48,211 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A bracket sequence is a string, containing only characters "(", ")", "[" and "]".
A correct bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()[]", "([])" are correct (the resulting expressions are: "(1)+[1]", "([1+1]+1)"), and "](" and "[" are not. The empty string is a correct bracket sequence by definition.
A substring s[l... r] (1 β€ l β€ r β€ |s|) of string s = s1s2... s|s| (where |s| is the length of string s) is the string slsl + 1... sr. The empty string is a substring of any string by definition.
You are given a bracket sequence, not necessarily correct. Find its substring which is a correct bracket sequence and contains as many opening square brackets Β«[Β» as possible.
Input
The first and the only line contains the bracket sequence as a string, consisting only of characters "(", ")", "[" and "]". It is guaranteed that the string is non-empty and its length doesn't exceed 105 characters.
Output
In the first line print a single integer β the number of brackets Β«[Β» in the required bracket sequence. In the second line print the optimal sequence. If there are more than one optimal solutions print any of them.
Examples
Input
([])
Output
1
([])
Input
(((
Output
0
Submitted Solution:
```
s, st, v, vi, vj, vc = input(), [], [], 0, 0, 0
for i, ch in enumerate(s):
if ch in '[(':
st.append(i)
else:
if st and s[st[-1]] + ch in ('()', '[]'):
b = (st[-1], i + 1)
if v and v[-1][1] == i:
v[-1] = b
else:
v.append(b)
if len(v) >= 2 and v[-2][1] == v[-1][0]:
v[-2:] = [(v[-2][0], v[-1][1])]
st.pop()
else:
st = []
for b in v:
c = s.count('[', b[0], b[1])
if c > vc:
vi, vj, vc = b[0], b[1], c
print(vc)
print(s[vi:vj])
# Made By Mostafa_Khaled
``` | instruction | 0 | 24,106 | 21 | 48,212 |
Yes | output | 1 | 24,106 | 21 | 48,213 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A bracket sequence is a string, containing only characters "(", ")", "[" and "]".
A correct bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()[]", "([])" are correct (the resulting expressions are: "(1)+[1]", "([1+1]+1)"), and "](" and "[" are not. The empty string is a correct bracket sequence by definition.
A substring s[l... r] (1 β€ l β€ r β€ |s|) of string s = s1s2... s|s| (where |s| is the length of string s) is the string slsl + 1... sr. The empty string is a substring of any string by definition.
You are given a bracket sequence, not necessarily correct. Find its substring which is a correct bracket sequence and contains as many opening square brackets Β«[Β» as possible.
Input
The first and the only line contains the bracket sequence as a string, consisting only of characters "(", ")", "[" and "]". It is guaranteed that the string is non-empty and its length doesn't exceed 105 characters.
Output
In the first line print a single integer β the number of brackets Β«[Β» in the required bracket sequence. In the second line print the optimal sequence. If there are more than one optimal solutions print any of them.
Examples
Input
([])
Output
1
([])
Input
(((
Output
0
Submitted Solution:
```
s = input()
st, v, vi, vj, vc = [], [], 0, 0, 0
for i, c in enumerate(s):
if c in '[(':
st.append(i)
continue
if st and s[st[-1]] + c in ('()', '[]'):
b = (st[-1], i+1)
if v and v[-1][1] == i: v[-1] = b
else: v.append(b)
if len(v) >= 2 and v[-2][1] == v[-1][0]:
v[-2:] = [(v[-2][0], v[-1][1])]
st.pop()
else:
st = []
for b in v:
c = s.count('[', b[0], b[1])
if c > vc:
vi, vj, vc = b[0], b[1], c
print(vc)
print(s[vi:vj])
``` | instruction | 0 | 24,107 | 21 | 48,214 |
Yes | output | 1 | 24,107 | 21 | 48,215 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A bracket sequence is a string, containing only characters "(", ")", "[" and "]".
A correct bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()[]", "([])" are correct (the resulting expressions are: "(1)+[1]", "([1+1]+1)"), and "](" and "[" are not. The empty string is a correct bracket sequence by definition.
A substring s[l... r] (1 β€ l β€ r β€ |s|) of string s = s1s2... s|s| (where |s| is the length of string s) is the string slsl + 1... sr. The empty string is a substring of any string by definition.
You are given a bracket sequence, not necessarily correct. Find its substring which is a correct bracket sequence and contains as many opening square brackets Β«[Β» as possible.
Input
The first and the only line contains the bracket sequence as a string, consisting only of characters "(", ")", "[" and "]". It is guaranteed that the string is non-empty and its length doesn't exceed 105 characters.
Output
In the first line print a single integer β the number of brackets Β«[Β» in the required bracket sequence. In the second line print the optimal sequence. If there are more than one optimal solutions print any of them.
Examples
Input
([])
Output
1
([])
Input
(((
Output
0
Submitted Solution:
```
s = '(' + input() + ')'
stack = []
validtemp = []
validseq = []
for i in range(len(s)):
if s[i] == '(' or s[i] == '[':
stack.append([i,-1])
if s[i] == ')':
if stack and s[stack[-1][0]] == '(':
stack[-1][1] = i
validtemp.append(stack[-1])
stack.pop()
else:
for j in validtemp:
validseq.append(j)
stack.clear()
validtemp.clear()
if s[i] == ']':
if stack and s[stack[-1][0]] == '[':
stack[-1][1] = i
validtemp.append(stack[-1])
stack.pop()
else:
for j in validtemp:
validseq.append(j)
stack.clear()
validtemp.clear()
if i == len(s)-1:
for j in validtemp:
validseq.append(j)
if validseq:
for i in range(len(validseq)-1):
if validseq[i+1][0] - validseq[i][1] == 1:
validseq[i+1][0] = validseq[i][0]
brackets = []
ans = 0
for i in validseq:
num = 0
for j in range(i[0], i[1]):
if s[j] == '[':
num += 1
brackets.append(num)
for i in range(len(brackets)):
if brackets[i] > brackets[ans]:
ans = i
elif brackets[i] == brackets[ans]:
if validseq[i][1] - validseq[i][0] > validseq[ans][1] - validseq[ans][0]:
ans = i
if (validseq[ans] == [0,len(s)-1]):
validseq[ans] = [1, len(s)-2]
print(brackets[ans])
print(s[validseq[ans][0]:validseq[ans][1]+1])
else:
print(0)
print()
``` | instruction | 0 | 24,108 | 21 | 48,216 |
No | output | 1 | 24,108 | 21 | 48,217 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A bracket sequence is a string, containing only characters "(", ")", "[" and "]".
A correct bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()[]", "([])" are correct (the resulting expressions are: "(1)+[1]", "([1+1]+1)"), and "](" and "[" are not. The empty string is a correct bracket sequence by definition.
A substring s[l... r] (1 β€ l β€ r β€ |s|) of string s = s1s2... s|s| (where |s| is the length of string s) is the string slsl + 1... sr. The empty string is a substring of any string by definition.
You are given a bracket sequence, not necessarily correct. Find its substring which is a correct bracket sequence and contains as many opening square brackets Β«[Β» as possible.
Input
The first and the only line contains the bracket sequence as a string, consisting only of characters "(", ")", "[" and "]". It is guaranteed that the string is non-empty and its length doesn't exceed 105 characters.
Output
In the first line print a single integer β the number of brackets Β«[Β» in the required bracket sequence. In the second line print the optimal sequence. If there are more than one optimal solutions print any of them.
Examples
Input
([])
Output
1
([])
Input
(((
Output
0
Submitted Solution:
```
x=input()
ans=[]
s=['a']
tmp=''
count=0
co=0
for i in x:
if i==')':
if s[-1]=='(':
tmp+=i
del s[-1]
count=1
else:
if len(s)==2:
ans.append(tmp[:-1])
tmp=''
count=0
s=['a']
elif i==']':
if s[-1]=='[':
tmp+=i
del s[-1]
count=1
else:
if len(s)==2:
ans.append(tmp[:-1])
tmp=''
count=0
s=['a']
else:
tmp+=i
s.append(i)
co+=1
if co==len(x) and count==1:
if len(s)==1:
ans.append(tmp)
elif len(s)==2:
ans.append(tmp[1:])
else:
ans.append(tmp[1:-1])
q=0
w=1
if len(ans)>0:
while w<len(ans):
if ans[q].count('[')>=ans[w].count('['):
w+=1
else:
q=w
w+=1
print(ans[q].count('['))
print(ans[q])
else:
print('0')
``` | instruction | 0 | 24,109 | 21 | 48,218 |
No | output | 1 | 24,109 | 21 | 48,219 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A bracket sequence is a string, containing only characters "(", ")", "[" and "]".
A correct bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()[]", "([])" are correct (the resulting expressions are: "(1)+[1]", "([1+1]+1)"), and "](" and "[" are not. The empty string is a correct bracket sequence by definition.
A substring s[l... r] (1 β€ l β€ r β€ |s|) of string s = s1s2... s|s| (where |s| is the length of string s) is the string slsl + 1... sr. The empty string is a substring of any string by definition.
You are given a bracket sequence, not necessarily correct. Find its substring which is a correct bracket sequence and contains as many opening square brackets Β«[Β» as possible.
Input
The first and the only line contains the bracket sequence as a string, consisting only of characters "(", ")", "[" and "]". It is guaranteed that the string is non-empty and its length doesn't exceed 105 characters.
Output
In the first line print a single integer β the number of brackets Β«[Β» in the required bracket sequence. In the second line print the optimal sequence. If there are more than one optimal solutions print any of them.
Examples
Input
([])
Output
1
([])
Input
(((
Output
0
Submitted Solution:
```
S=input().strip()
subIndex=[]
for i in range(len(S)):
if len(subIndex)!=0 and (((S[subIndex[-1]]=='[' and S[i]==']') or (S[subIndex[-1]]=='(' and S[i]==')'))):
subIndex.pop()
else:
subIndex.append(i)
print(subIndex)
'tamamΔ± doΔru olan S'
if not len(subIndex):
print(S.count('['))
print(S)
else:
'index out of range'
subIndex.append(subIndex[-1])
subString=S[:subIndex[0]]
subStringSquaredBracketCount=subString.count('[')
for i in range(len(subIndex)-1):
temp=S[subIndex[i]:subIndex[i+1]].count('[')
if temp>subStringSquaredBracketCount:
subStringSquaredBracketCount=temp
subString=S[subIndex[i]:subIndex[i+1]]
print(subStringSquaredBracketCount)
print(subString)
``` | instruction | 0 | 24,110 | 21 | 48,220 |
No | output | 1 | 24,110 | 21 | 48,221 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A bracket sequence is a string, containing only characters "(", ")", "[" and "]".
A correct bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()[]", "([])" are correct (the resulting expressions are: "(1)+[1]", "([1+1]+1)"), and "](" and "[" are not. The empty string is a correct bracket sequence by definition.
A substring s[l... r] (1 β€ l β€ r β€ |s|) of string s = s1s2... s|s| (where |s| is the length of string s) is the string slsl + 1... sr. The empty string is a substring of any string by definition.
You are given a bracket sequence, not necessarily correct. Find its substring which is a correct bracket sequence and contains as many opening square brackets Β«[Β» as possible.
Input
The first and the only line contains the bracket sequence as a string, consisting only of characters "(", ")", "[" and "]". It is guaranteed that the string is non-empty and its length doesn't exceed 105 characters.
Output
In the first line print a single integer β the number of brackets Β«[Β» in the required bracket sequence. In the second line print the optimal sequence. If there are more than one optimal solutions print any of them.
Examples
Input
([])
Output
1
([])
Input
(((
Output
0
Submitted Solution:
```
s = input()
stack = []
validtemp = []
validseq = []
for i in range(len(s)):
if s[i] == '(' or s[i] == '[':
stack.append([i,-1])
if s[i] == ')':
if stack and s[stack[-1][0]] == '(':
stack[-1][1] = i
validtemp.append(stack[-1])
stack.pop()
else:
for j in validtemp:
validseq.append(j)
stack.clear()
validtemp.clear()
if s[i] == ']':
if stack and s[stack[-1][0]] == '[':
stack[-1][1] = i
validtemp.append(stack[-1])
stack.pop()
else:
for j in validtemp:
validseq.append(j)
stack.clear()
validtemp.clear()
if i == len(s)-1:
for j in validtemp:
validseq.append(j)
if validseq:
for i in range(len(validseq)-1):
if validseq[i+1][0] - validseq[i][1] == 1:
validseq[i+1][0] = validseq[i][0]
brackets = []
ans = 0
for i in validseq:
num = 0
for j in range(i[0], i[1]):
if s[j] == '[':
num += 1
brackets.append(num)
for i in range(len(brackets)):
if brackets[i] > brackets[ans]:
ans = i
elif brackets[i] == brackets[ans]:
if validseq[i][1] - validseq[i][0] > validseq[ans][1] - validseq[ans][0]:
ans = i
print(brackets[ans])
print(s[validseq[ans][0]:validseq[ans][1]+1])
else:
print(0)
print()
``` | instruction | 0 | 24,111 | 21 | 48,222 |
No | output | 1 | 24,111 | 21 | 48,223 |
Provide a correct Python 3 solution for this coding contest problem.
The Balance of the World
The world should be finely balanced. Positive vs. negative, light vs. shadow, and left vs. right brackets. Your mission is to write a program that judges whether a string is balanced with respect to brackets so that we can observe the balance of the world.
A string that will be given to the program may have two kinds of brackets, round ("( )") and square ("[ ]"). A string is balanced if and only if the following conditions hold.
* For every left round bracket ("("), there is a corresponding right round bracket (")") in the following part of the string.
* For every left square bracket ("["), there is a corresponding right square bracket ("]") in the following part of the string.
* For every right bracket, there is a left bracket corresponding to it.
* Correspondences of brackets have to be one to one, that is, a single bracket never corresponds to two or more brackets.
* For every pair of corresponding left and right brackets, the substring between them is balanced.
Input
The input consists of one or more lines, each of which being a dataset. A dataset is a string that consists of English alphabets, space characters, and two kinds of brackets, round ("( )") and square ("[ ]"), terminated by a period. You can assume that every line has 100 characters or less. The line formed by a single period indicates the end of the input, which is not a dataset.
Output
For each dataset, output "yes" if the string is balanced, or "no" otherwise, in a line. There may not be any extra characters in the output.
Sample Input
So when I die (the [first] I will see in (heaven) is a score list).
[ first in ] ( first out ).
Half Moon tonight (At least it is better than no Moon at all].
A rope may form )( a trail in a maze.
Help( I[m being held prisoner in a fortune cookie factory)].
([ (([( [ ] ) ( ) (( ))] )) ]).
.
.
Output for the Sample Input
yes
yes
no
no
no
yes
yes
Example
Input
Output | instruction | 0 | 24,688 | 21 | 49,376 |
"Correct Solution:
```
def is_balanced(s):
stack = []
for c in s:
if c == '(' or c == '[':
stack.append(c)
elif c == ')':
if not stack:
return "no"
elif stack[-1] == '(':
stack.pop()
else:
return "no"
elif c == ']':
if not stack:
return "no"
elif stack[-1] == '[':
stack.pop()
else:
return "no"
if stack:
return "no"
else:
return "yes"
import sys
file_input = sys.stdin
lines = file_input.readlines()
lines = lines[:-1]
print('\n'.join(map(is_balanced, lines)))
``` | output | 1 | 24,688 | 21 | 49,377 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Balance of the World
The world should be finely balanced. Positive vs. negative, light vs. shadow, and left vs. right brackets. Your mission is to write a program that judges whether a string is balanced with respect to brackets so that we can observe the balance of the world.
A string that will be given to the program may have two kinds of brackets, round ("( )") and square ("[ ]"). A string is balanced if and only if the following conditions hold.
* For every left round bracket ("("), there is a corresponding right round bracket (")") in the following part of the string.
* For every left square bracket ("["), there is a corresponding right square bracket ("]") in the following part of the string.
* For every right bracket, there is a left bracket corresponding to it.
* Correspondences of brackets have to be one to one, that is, a single bracket never corresponds to two or more brackets.
* For every pair of corresponding left and right brackets, the substring between them is balanced.
Input
The input consists of one or more lines, each of which being a dataset. A dataset is a string that consists of English alphabets, space characters, and two kinds of brackets, round ("( )") and square ("[ ]"), terminated by a period. You can assume that every line has 100 characters or less. The line formed by a single period indicates the end of the input, which is not a dataset.
Output
For each dataset, output "yes" if the string is balanced, or "no" otherwise, in a line. There may not be any extra characters in the output.
Sample Input
So when I die (the [first] I will see in (heaven) is a score list).
[ first in ] ( first out ).
Half Moon tonight (At least it is better than no Moon at all].
A rope may form )( a trail in a maze.
Help( I[m being held prisoner in a fortune cookie factory)].
([ (([( [ ] ) ( ) (( ))] )) ]).
.
.
Output for the Sample Input
yes
yes
no
no
no
yes
yes
Example
Input
Output
Submitted Solution:
```
ans_list = []
while True:
s = input()
if s == ".":
break
q_list = ["" for i in range(len(s))]
now = -1
ans = "yes"
for i in list(s):
if i == "(" or i == "[":
now += 1
q_list[now] = i
elif i == ")":
if now == -1:
ans = "no"
elif q_list[now] == "(":
now -= 1
else:
ans = "no"
elif i == "]":
if now == -1:
ans = "no"
elif q_list[now] == "[":
now -= 1
else:
ans = "no"
if ans == "no":
break
if now == 0:
ans = "no"
ans_list.append(ans)
for i in ans_list:
print(i)
``` | instruction | 0 | 24,689 | 21 | 49,378 |
No | output | 1 | 24,689 | 21 | 49,379 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Balance of the World
The world should be finely balanced. Positive vs. negative, light vs. shadow, and left vs. right brackets. Your mission is to write a program that judges whether a string is balanced with respect to brackets so that we can observe the balance of the world.
A string that will be given to the program may have two kinds of brackets, round ("( )") and square ("[ ]"). A string is balanced if and only if the following conditions hold.
* For every left round bracket ("("), there is a corresponding right round bracket (")") in the following part of the string.
* For every left square bracket ("["), there is a corresponding right square bracket ("]") in the following part of the string.
* For every right bracket, there is a left bracket corresponding to it.
* Correspondences of brackets have to be one to one, that is, a single bracket never corresponds to two or more brackets.
* For every pair of corresponding left and right brackets, the substring between them is balanced.
Input
The input consists of one or more lines, each of which being a dataset. A dataset is a string that consists of English alphabets, space characters, and two kinds of brackets, round ("( )") and square ("[ ]"), terminated by a period. You can assume that every line has 100 characters or less. The line formed by a single period indicates the end of the input, which is not a dataset.
Output
For each dataset, output "yes" if the string is balanced, or "no" otherwise, in a line. There may not be any extra characters in the output.
Sample Input
So when I die (the [first] I will see in (heaven) is a score list).
[ first in ] ( first out ).
Half Moon tonight (At least it is better than no Moon at all].
A rope may form )( a trail in a maze.
Help( I[m being held prisoner in a fortune cookie factory)].
([ (([( [ ] ) ( ) (( ))] )) ]).
.
.
Output for the Sample Input
yes
yes
no
no
no
yes
yes
Example
Input
Output
Submitted Solution:
```
ans_list = []
while True:
s = input()
if s == ".":
break
q_list = ["" for i in range(len(s))]
now = -1
ans = "yes"
for i in list(s):
if i == "(" or i == "[":
now += 1
q_list[now] = i
elif i == ")" or i == "]":
if (i == ")" and q_list[now] == "(") or (i == "]" and q_list[now] == "["):
now -= 1
elif now < 0 or i != q_list[now]:
#print(i, now, q_list)
ans = "no"
break
if ans == "no":
break
ans_list.append(ans)
for i in ans_list:
print(i)
``` | instruction | 0 | 24,690 | 21 | 49,380 |
No | output | 1 | 24,690 | 21 | 49,381 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Balance of the World
The world should be finely balanced. Positive vs. negative, light vs. shadow, and left vs. right brackets. Your mission is to write a program that judges whether a string is balanced with respect to brackets so that we can observe the balance of the world.
A string that will be given to the program may have two kinds of brackets, round ("( )") and square ("[ ]"). A string is balanced if and only if the following conditions hold.
* For every left round bracket ("("), there is a corresponding right round bracket (")") in the following part of the string.
* For every left square bracket ("["), there is a corresponding right square bracket ("]") in the following part of the string.
* For every right bracket, there is a left bracket corresponding to it.
* Correspondences of brackets have to be one to one, that is, a single bracket never corresponds to two or more brackets.
* For every pair of corresponding left and right brackets, the substring between them is balanced.
Input
The input consists of one or more lines, each of which being a dataset. A dataset is a string that consists of English alphabets, space characters, and two kinds of brackets, round ("( )") and square ("[ ]"), terminated by a period. You can assume that every line has 100 characters or less. The line formed by a single period indicates the end of the input, which is not a dataset.
Output
For each dataset, output "yes" if the string is balanced, or "no" otherwise, in a line. There may not be any extra characters in the output.
Sample Input
So when I die (the [first] I will see in (heaven) is a score list).
[ first in ] ( first out ).
Half Moon tonight (At least it is better than no Moon at all].
A rope may form )( a trail in a maze.
Help( I[m being held prisoner in a fortune cookie factory)].
([ (([( [ ] ) ( ) (( ))] )) ]).
.
.
Output for the Sample Input
yes
yes
no
no
no
yes
yes
Example
Input
Output
Submitted Solution:
```
while (True):
st = input()
st = [i for i in st if i in ["(",")","[","]"]
han = []
ans = "Yes"
for i in st:
if i == "(":
han.append("maru")
elif i == "[":
han.append("kaku")
elif i == ")":
if han == []:
ans = "No"
break
elif han[-1] == "maru":
del han[-1]
else:
ans = "No"
break
elif i == "[":
if han == []:
ans = "No"
break
elif han[-1] == "kaku":
del han[-1]
else:
ans = "No"
break
if ans == "No" or han != []:
print("No")
else:
print(ans)
``` | instruction | 0 | 24,691 | 21 | 49,382 |
No | output | 1 | 24,691 | 21 | 49,383 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Balance of the World
The world should be finely balanced. Positive vs. negative, light vs. shadow, and left vs. right brackets. Your mission is to write a program that judges whether a string is balanced with respect to brackets so that we can observe the balance of the world.
A string that will be given to the program may have two kinds of brackets, round ("( )") and square ("[ ]"). A string is balanced if and only if the following conditions hold.
* For every left round bracket ("("), there is a corresponding right round bracket (")") in the following part of the string.
* For every left square bracket ("["), there is a corresponding right square bracket ("]") in the following part of the string.
* For every right bracket, there is a left bracket corresponding to it.
* Correspondences of brackets have to be one to one, that is, a single bracket never corresponds to two or more brackets.
* For every pair of corresponding left and right brackets, the substring between them is balanced.
Input
The input consists of one or more lines, each of which being a dataset. A dataset is a string that consists of English alphabets, space characters, and two kinds of brackets, round ("( )") and square ("[ ]"), terminated by a period. You can assume that every line has 100 characters or less. The line formed by a single period indicates the end of the input, which is not a dataset.
Output
For each dataset, output "yes" if the string is balanced, or "no" otherwise, in a line. There may not be any extra characters in the output.
Sample Input
So when I die (the [first] I will see in (heaven) is a score list).
[ first in ] ( first out ).
Half Moon tonight (At least it is better than no Moon at all].
A rope may form )( a trail in a maze.
Help( I[m being held prisoner in a fortune cookie factory)].
([ (([( [ ] ) ( ) (( ))] )) ]).
.
.
Output for the Sample Input
yes
yes
no
no
no
yes
yes
Example
Input
Output
Submitted Solution:
```
while 1:
s=input()
if s==".":
break
l1=0
r1=0
l2=0
r2=0
ans="yes"
for i in range(len(s)):
if s[i]=='(':
l1+=1
if s[i]==')':
r1+=1
if s[i]=='[':
l2+=1
if s[i]==']':
r2+=1
if l1<r1:
ans="no"
if l2<r2:
ans="no"
print(ans)
``` | instruction | 0 | 24,692 | 21 | 49,384 |
No | output | 1 | 24,692 | 21 | 49,385 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is yet another problem on regular bracket sequences.
A bracket sequence is called regular, if by inserting "+" and "1" into it we get a correct mathematical expression. For example, sequences "(())()", "()" and "(()(()))" are regular, while ")(", "(()" and "(()))(" are not. You have a pattern of a bracket sequence that consists of characters "(", ")" and "?". You have to replace each character "?" with a bracket so, that you get a regular bracket sequence.
For each character "?" the cost of its replacement with "(" and ")" is given. Among all the possible variants your should choose the cheapest.
Input
The first line contains a non-empty pattern of even length, consisting of characters "(", ")" and "?". Its length doesn't exceed 5Β·104. Then there follow m lines, where m is the number of characters "?" in the pattern. Each line contains two integer numbers ai and bi (1 β€ ai, bi β€ 106), where ai is the cost of replacing the i-th character "?" with an opening bracket, and bi β with a closing one.
Output
Print the cost of the optimal regular bracket sequence in the first line, and the required sequence in the second.
Print -1, if there is no answer. If the answer is not unique, print any of them.
Examples
Input
(??)
1 2
2 8
Output
4
()() | instruction | 0 | 25,955 | 21 | 51,910 |
Tags: greedy
Correct Solution:
```
from heapq import *
k = d = 0
s, h = [], []
for i, q in enumerate(input()):
if q == '?':
q = ')'
x, y = map(int, input().split())
d += y
heappush(h, (x - y, i))
s.append(q)
if q == '(': k += 1
elif k: k -= 1
elif h:
k = 1
x, i = heappop(h)
d += x
s[i] = '('
else:
k = 1
break
print(-1) if k else print(d, ''.join(s))
``` | output | 1 | 25,955 | 21 | 51,911 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is yet another problem on regular bracket sequences.
A bracket sequence is called regular, if by inserting "+" and "1" into it we get a correct mathematical expression. For example, sequences "(())()", "()" and "(()(()))" are regular, while ")(", "(()" and "(()))(" are not. You have a pattern of a bracket sequence that consists of characters "(", ")" and "?". You have to replace each character "?" with a bracket so, that you get a regular bracket sequence.
For each character "?" the cost of its replacement with "(" and ")" is given. Among all the possible variants your should choose the cheapest.
Input
The first line contains a non-empty pattern of even length, consisting of characters "(", ")" and "?". Its length doesn't exceed 5Β·104. Then there follow m lines, where m is the number of characters "?" in the pattern. Each line contains two integer numbers ai and bi (1 β€ ai, bi β€ 106), where ai is the cost of replacing the i-th character "?" with an opening bracket, and bi β with a closing one.
Output
Print the cost of the optimal regular bracket sequence in the first line, and the required sequence in the second.
Print -1, if there is no answer. If the answer is not unique, print any of them.
Examples
Input
(??)
1 2
2 8
Output
4
()() | instruction | 0 | 25,956 | 21 | 51,912 |
Tags: greedy
Correct Solution:
```
"""
Codeforces
3D - Least Cost Bracket Sequence
http://codeforces.com/problemset/problem/3/D
HΓ©ctor GonzΓ‘lez Belver
../07/2018
"""
import sys
import heapq
def main():
cost = []
pattern = sys.stdin.readline().strip()
unknown = pattern.count('?')
cost = [tuple(int(c) for c in sys.stdin.readline().strip().split()) for _ in range(unknown)]
if pattern[0] == ')' or pattern[-1]=='(':
sys.stdout.write('-1' + '\n')
return
balanced = 0
replace_cost = 0
replaced = []
solution = ''
for i, c in enumerate(pattern):
if c == '(':
balanced += 1
solution += c
elif c == ')':
balanced -= 1
solution += c
else:
if not (unknown == 1 and pattern[-1] == '?'):
heapq.heappush(replaced, ((cost[-unknown][0] - cost[-unknown][1],i)))
balanced -= 1
unknown -= 1
if balanced >= 0:
solution += ')'
replace_cost += cost[-(unknown+1)][1]
if balanced < 0:
if len(replaced)>0:
candidate = heapq.heappop(replaced)
else:
sys.stdout.write('-1' + '\n')
return
balanced += 2
if i == candidate[1]:
solution += '('
replace_cost += cost[-(unknown+1)][0]
else:
solution = solution[:candidate[1]] + '(' + solution[candidate[1]+1:]
replace_cost += candidate[0]
if c == '?':
solution += ')'
replace_cost += cost[-(unknown+1)][1]
if balanced != 0:
sys.stdout.write('-1' + '\n')
else:
sys.stdout.write(str(replace_cost) + '\n' + solution + '\n')
if __name__ == '__main__':
main()
``` | output | 1 | 25,956 | 21 | 51,913 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is yet another problem on regular bracket sequences.
A bracket sequence is called regular, if by inserting "+" and "1" into it we get a correct mathematical expression. For example, sequences "(())()", "()" and "(()(()))" are regular, while ")(", "(()" and "(()))(" are not. You have a pattern of a bracket sequence that consists of characters "(", ")" and "?". You have to replace each character "?" with a bracket so, that you get a regular bracket sequence.
For each character "?" the cost of its replacement with "(" and ")" is given. Among all the possible variants your should choose the cheapest.
Input
The first line contains a non-empty pattern of even length, consisting of characters "(", ")" and "?". Its length doesn't exceed 5Β·104. Then there follow m lines, where m is the number of characters "?" in the pattern. Each line contains two integer numbers ai and bi (1 β€ ai, bi β€ 106), where ai is the cost of replacing the i-th character "?" with an opening bracket, and bi β with a closing one.
Output
Print the cost of the optimal regular bracket sequence in the first line, and the required sequence in the second.
Print -1, if there is no answer. If the answer is not unique, print any of them.
Examples
Input
(??)
1 2
2 8
Output
4
()() | instruction | 0 | 25,957 | 21 | 51,914 |
Tags: greedy
Correct Solution:
```
import heapq
s = input()
l = len(s)
cnt = 0
for i in range(l):
if s[i] == '?':
cnt += 1
a = []
for i in range(cnt):
a.append(list(map(int, input().split())))
idx = 0
res = 0
left = 0
b = []
p = [0] * len(a)
ans = True
for i in range(l):
if s[i] == '(':
left += 1
elif s[i] == '?':
heapq.heappush(b, [a[idx][0] - a[idx][1], idx])
res += a[idx][1]
p[idx] = ')'
idx += 1
left -= 1
elif s[i] == ')':
left -= 1
if left < 0:
flag = False
if len(b) == 0:
ans = False
break
else:
item = heapq.heappop(b)
res += item[0]
left += 2
p[item[1]] = '('
if left == 0 and ans:
print(res)
idx = 0
path = ''
for i in range(l):
if s[i] == '?':
path += p[idx]
idx += 1
else:
path += s[i]
print(path)
else:
print(-1)
``` | output | 1 | 25,957 | 21 | 51,915 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is yet another problem on regular bracket sequences.
A bracket sequence is called regular, if by inserting "+" and "1" into it we get a correct mathematical expression. For example, sequences "(())()", "()" and "(()(()))" are regular, while ")(", "(()" and "(()))(" are not. You have a pattern of a bracket sequence that consists of characters "(", ")" and "?". You have to replace each character "?" with a bracket so, that you get a regular bracket sequence.
For each character "?" the cost of its replacement with "(" and ")" is given. Among all the possible variants your should choose the cheapest.
Input
The first line contains a non-empty pattern of even length, consisting of characters "(", ")" and "?". Its length doesn't exceed 5Β·104. Then there follow m lines, where m is the number of characters "?" in the pattern. Each line contains two integer numbers ai and bi (1 β€ ai, bi β€ 106), where ai is the cost of replacing the i-th character "?" with an opening bracket, and bi β with a closing one.
Output
Print the cost of the optimal regular bracket sequence in the first line, and the required sequence in the second.
Print -1, if there is no answer. If the answer is not unique, print any of them.
Examples
Input
(??)
1 2
2 8
Output
4
()() | instruction | 0 | 25,958 | 21 | 51,916 |
Tags: greedy
Correct Solution:
```
__author__ = 'Darren'
def solve():
import sys
stdin = sys.stdin if True else open('data')
from heapq import heappush, heappop
seq = [c for c in next(stdin).strip()]
n = len(seq)
if n % 2 == 1:
print(-1)
return
min_heap = []
balance, cost = 0, 0
for i in range(n):
if seq[i] == '(':
balance += 1
elif seq[i] == ')':
balance -= 1
else:
cost_left, cost_right = map(int, next(stdin).split())
seq[i] = ')'
balance -= 1
cost += cost_right
heappush(min_heap, (cost_left - cost_right, i))
if balance < 0:
if len(min_heap) <= 0:
print(-1)
return
diff, index = heappop(min_heap)
seq[index] = '('
cost += diff
balance += 2
if balance == 0:
print(cost)
print(''.join(seq))
else:
print(-1)
if __name__ == '__main__':
solve()
``` | output | 1 | 25,958 | 21 | 51,917 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is yet another problem on regular bracket sequences.
A bracket sequence is called regular, if by inserting "+" and "1" into it we get a correct mathematical expression. For example, sequences "(())()", "()" and "(()(()))" are regular, while ")(", "(()" and "(()))(" are not. You have a pattern of a bracket sequence that consists of characters "(", ")" and "?". You have to replace each character "?" with a bracket so, that you get a regular bracket sequence.
For each character "?" the cost of its replacement with "(" and ")" is given. Among all the possible variants your should choose the cheapest.
Input
The first line contains a non-empty pattern of even length, consisting of characters "(", ")" and "?". Its length doesn't exceed 5Β·104. Then there follow m lines, where m is the number of characters "?" in the pattern. Each line contains two integer numbers ai and bi (1 β€ ai, bi β€ 106), where ai is the cost of replacing the i-th character "?" with an opening bracket, and bi β with a closing one.
Output
Print the cost of the optimal regular bracket sequence in the first line, and the required sequence in the second.
Print -1, if there is no answer. If the answer is not unique, print any of them.
Examples
Input
(??)
1 2
2 8
Output
4
()() | instruction | 0 | 25,959 | 21 | 51,918 |
Tags: greedy
Correct Solution:
```
import heapq
s = list(input())
new_s, cost, opens, opens_i = str(), 0, 0, list()
for i in range(len(s)):
opens += int(s[i] == '(') - int(s[i] != '(')
if s[i] == '?':
a, b = [int(i) for i in input().split()]
s[i] = ')'
heapq.heappush(opens_i, [-b + a, i])
cost += b
if opens < 0:
if opens_i:
closed = heapq.heappop(opens_i)
s[closed[1]] = '('
cost += closed[0]
opens += 2
else:
break
if opens == 0:
print(cost)
print(''.join(s))
else:
print(-1)
``` | output | 1 | 25,959 | 21 | 51,919 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is yet another problem on regular bracket sequences.
A bracket sequence is called regular, if by inserting "+" and "1" into it we get a correct mathematical expression. For example, sequences "(())()", "()" and "(()(()))" are regular, while ")(", "(()" and "(()))(" are not. You have a pattern of a bracket sequence that consists of characters "(", ")" and "?". You have to replace each character "?" with a bracket so, that you get a regular bracket sequence.
For each character "?" the cost of its replacement with "(" and ")" is given. Among all the possible variants your should choose the cheapest.
Input
The first line contains a non-empty pattern of even length, consisting of characters "(", ")" and "?". Its length doesn't exceed 5Β·104. Then there follow m lines, where m is the number of characters "?" in the pattern. Each line contains two integer numbers ai and bi (1 β€ ai, bi β€ 106), where ai is the cost of replacing the i-th character "?" with an opening bracket, and bi β with a closing one.
Output
Print the cost of the optimal regular bracket sequence in the first line, and the required sequence in the second.
Print -1, if there is no answer. If the answer is not unique, print any of them.
Examples
Input
(??)
1 2
2 8
Output
4
()() | instruction | 0 | 25,960 | 21 | 51,920 |
Tags: greedy
Correct Solution:
```
import heapq
s = input()
sl = list(s)
ct = 0
cost = 0
flag = True
h = []
for i,c in enumerate(s):
if c == '(':
ct+=1
elif c == ')':
ct-=1
else:
l,r = map(int,input().split())
sl[i] = ')'
cost += r
ct-=1
heapq.heappush(h,(l-r,i))
if ct<0:
if not h:
flag = False
break
# print("Fuck "+"".join(sl))
d,pos = heapq.heappop(h)
sl[pos] = '('
ct+=2
cost += d
if(ct<0):
pass
# flag = False
# break
if ct != 0 or flag == False:
print(-1)
else:
print(cost)
print("".join(sl))
``` | output | 1 | 25,960 | 21 | 51,921 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is yet another problem on regular bracket sequences.
A bracket sequence is called regular, if by inserting "+" and "1" into it we get a correct mathematical expression. For example, sequences "(())()", "()" and "(()(()))" are regular, while ")(", "(()" and "(()))(" are not. You have a pattern of a bracket sequence that consists of characters "(", ")" and "?". You have to replace each character "?" with a bracket so, that you get a regular bracket sequence.
For each character "?" the cost of its replacement with "(" and ")" is given. Among all the possible variants your should choose the cheapest.
Input
The first line contains a non-empty pattern of even length, consisting of characters "(", ")" and "?". Its length doesn't exceed 5Β·104. Then there follow m lines, where m is the number of characters "?" in the pattern. Each line contains two integer numbers ai and bi (1 β€ ai, bi β€ 106), where ai is the cost of replacing the i-th character "?" with an opening bracket, and bi β with a closing one.
Output
Print the cost of the optimal regular bracket sequence in the first line, and the required sequence in the second.
Print -1, if there is no answer. If the answer is not unique, print any of them.
Examples
Input
(??)
1 2
2 8
Output
4
()() | instruction | 0 | 25,961 | 21 | 51,922 |
Tags: greedy
Correct Solution:
```
from heapq import *
#priority queue
#see healp(heapq)
def CF_3D():
line=input()
n=line.count('?')
sequence=list(line)
bracket=[]
for i in range(n):
bracket.append(list(map(int,input().split())))
index=0
cost=0
balance=0
heap=[]
for i in range(len(sequence)):
if sequence[i]=='(':
balance+=1
elif sequence[i]==')':
balance-=1
elif sequence[i]=='?':
#first consider ? as )
sequence[i]=')'
cost+=bracket[index][1]
heappush(heap,(bracket[index][0]-bracket[index][1],i))
index+=1
balance-=1
if balance<0:
if len(heap)==0:
break
#item=heappop(heap)
#In Python, heappop() method returns the smallest item, not the largest.
item=heappop(heap)
cost+=item[0]
sequence[item[1]]='('
#from ) to ( , balance+=2
balance+=2
if balance!=0:
print(-1)
else:
print(cost)
print(''.join(sequence))
return
CF_3D()
``` | output | 1 | 25,961 | 21 | 51,923 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is yet another problem on regular bracket sequences.
A bracket sequence is called regular, if by inserting "+" and "1" into it we get a correct mathematical expression. For example, sequences "(())()", "()" and "(()(()))" are regular, while ")(", "(()" and "(()))(" are not. You have a pattern of a bracket sequence that consists of characters "(", ")" and "?". You have to replace each character "?" with a bracket so, that you get a regular bracket sequence.
For each character "?" the cost of its replacement with "(" and ")" is given. Among all the possible variants your should choose the cheapest.
Input
The first line contains a non-empty pattern of even length, consisting of characters "(", ")" and "?". Its length doesn't exceed 5Β·104. Then there follow m lines, where m is the number of characters "?" in the pattern. Each line contains two integer numbers ai and bi (1 β€ ai, bi β€ 106), where ai is the cost of replacing the i-th character "?" with an opening bracket, and bi β with a closing one.
Output
Print the cost of the optimal regular bracket sequence in the first line, and the required sequence in the second.
Print -1, if there is no answer. If the answer is not unique, print any of them.
Examples
Input
(??)
1 2
2 8
Output
4
()() | instruction | 0 | 25,962 | 21 | 51,924 |
Tags: greedy
Correct Solution:
```
from heapq import heappush, heappop
ans=b=0
d=[]
s=list(input())
for i in range(len(s)):
if s[i]=='(':
b+=1
elif s[i]==')':
b-=1
else:
c=list(map(int,input().split()))
s[i]=')'
b-=1
heappush(d,(c[0]-c[1],i))
ans+=c[1]
if b<0:
if len(d)==0:
print(-1)
exit()
v,index=heappop(d)
s[index]='('
ans+=v
b+=2
if b!=0:print(-1)
else:
print(ans)
print(*s,sep='')
``` | output | 1 | 25,962 | 21 | 51,925 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is yet another problem on regular bracket sequences.
A bracket sequence is called regular, if by inserting "+" and "1" into it we get a correct mathematical expression. For example, sequences "(())()", "()" and "(()(()))" are regular, while ")(", "(()" and "(()))(" are not. You have a pattern of a bracket sequence that consists of characters "(", ")" and "?". You have to replace each character "?" with a bracket so, that you get a regular bracket sequence.
For each character "?" the cost of its replacement with "(" and ")" is given. Among all the possible variants your should choose the cheapest.
Input
The first line contains a non-empty pattern of even length, consisting of characters "(", ")" and "?". Its length doesn't exceed 5Β·104. Then there follow m lines, where m is the number of characters "?" in the pattern. Each line contains two integer numbers ai and bi (1 β€ ai, bi β€ 106), where ai is the cost of replacing the i-th character "?" with an opening bracket, and bi β with a closing one.
Output
Print the cost of the optimal regular bracket sequence in the first line, and the required sequence in the second.
Print -1, if there is no answer. If the answer is not unique, print any of them.
Examples
Input
(??)
1 2
2 8
Output
4
()()
Submitted Solution:
```
from heapq import heappush, heappop
# heapq gives us implementation of priority queue.
scan = list(input())
n = len(scan)
price = 0
balancer = 0
heap = []
for i in range(n):
if scan[i] == '(':
balancer += 1
elif scan[i] == ')':
balancer -= 1
else:
current_value_open, current_value_close = map(int, input().split())
price += current_value_close
heappush(heap, (current_value_open - current_value_close, i))
scan[i] = ')'
balancer -= 1
if balancer < 0:
if len(heap) == 0:
break
value, index = heappop(heap)
price += value
scan[index] = '('
balancer += 2
if balancer != 0:
print(-1)
else:
print(price)
print(''.join(scan))
``` | instruction | 0 | 25,963 | 21 | 51,926 |
Yes | output | 1 | 25,963 | 21 | 51,927 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is yet another problem on regular bracket sequences.
A bracket sequence is called regular, if by inserting "+" and "1" into it we get a correct mathematical expression. For example, sequences "(())()", "()" and "(()(()))" are regular, while ")(", "(()" and "(()))(" are not. You have a pattern of a bracket sequence that consists of characters "(", ")" and "?". You have to replace each character "?" with a bracket so, that you get a regular bracket sequence.
For each character "?" the cost of its replacement with "(" and ")" is given. Among all the possible variants your should choose the cheapest.
Input
The first line contains a non-empty pattern of even length, consisting of characters "(", ")" and "?". Its length doesn't exceed 5Β·104. Then there follow m lines, where m is the number of characters "?" in the pattern. Each line contains two integer numbers ai and bi (1 β€ ai, bi β€ 106), where ai is the cost of replacing the i-th character "?" with an opening bracket, and bi β with a closing one.
Output
Print the cost of the optimal regular bracket sequence in the first line, and the required sequence in the second.
Print -1, if there is no answer. If the answer is not unique, print any of them.
Examples
Input
(??)
1 2
2 8
Output
4
()()
Submitted Solution:
```
# @author: guoyc
# @date: 2018/7/19
from heapq import *
s = input()
m = s.count('?')
costs = []
for i in range(m):
costs.append([int(_) for _ in input().split()])
heap = []
idx = 0
res = []
cnt = 0
total = 0
for i, c in enumerate(s):
if c == '?':
c = ')'
total += costs[idx][1]
heappush(heap, (costs[idx][0] - costs[idx][1], i))
idx += 1
res.append(c)
if c == ')':
if cnt == 0:
if not heap:
cnt = -1
break
cnt = 1
cost, i = heappop(heap)
total += cost
res[i] = '('
else:
cnt -= 1
else:
cnt += 1
if cnt:
print(-1)
else:
print(total)
print(''.join(res))
``` | instruction | 0 | 25,964 | 21 | 51,928 |
Yes | output | 1 | 25,964 | 21 | 51,929 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is yet another problem on regular bracket sequences.
A bracket sequence is called regular, if by inserting "+" and "1" into it we get a correct mathematical expression. For example, sequences "(())()", "()" and "(()(()))" are regular, while ")(", "(()" and "(()))(" are not. You have a pattern of a bracket sequence that consists of characters "(", ")" and "?". You have to replace each character "?" with a bracket so, that you get a regular bracket sequence.
For each character "?" the cost of its replacement with "(" and ")" is given. Among all the possible variants your should choose the cheapest.
Input
The first line contains a non-empty pattern of even length, consisting of characters "(", ")" and "?". Its length doesn't exceed 5Β·104. Then there follow m lines, where m is the number of characters "?" in the pattern. Each line contains two integer numbers ai and bi (1 β€ ai, bi β€ 106), where ai is the cost of replacing the i-th character "?" with an opening bracket, and bi β with a closing one.
Output
Print the cost of the optimal regular bracket sequence in the first line, and the required sequence in the second.
Print -1, if there is no answer. If the answer is not unique, print any of them.
Examples
Input
(??)
1 2
2 8
Output
4
()()
Submitted Solution:
```
from heapq import heappush, heappop
s = list(input())
n = len(s)
ans = 0
k = 0
heap = []
for i in range(n):
if s[i] == '(':
k+=1
elif s[i] == ')':
k-=1
else:
a,b = map(int, input().split())
ans += b
heappush(heap, (a-b, i))
s[i] = ')'
k-=1
if k<0:
if len(heap)==0:
break
v,p = heappop(heap)
ans += v
s[p] = '('
k+=2
if k!=0:
print(-1)
else:
print(ans)
print(''.join(s))
# Made By Mostafa_Khaled
``` | instruction | 0 | 25,965 | 21 | 51,930 |
Yes | output | 1 | 25,965 | 21 | 51,931 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is yet another problem on regular bracket sequences.
A bracket sequence is called regular, if by inserting "+" and "1" into it we get a correct mathematical expression. For example, sequences "(())()", "()" and "(()(()))" are regular, while ")(", "(()" and "(()))(" are not. You have a pattern of a bracket sequence that consists of characters "(", ")" and "?". You have to replace each character "?" with a bracket so, that you get a regular bracket sequence.
For each character "?" the cost of its replacement with "(" and ")" is given. Among all the possible variants your should choose the cheapest.
Input
The first line contains a non-empty pattern of even length, consisting of characters "(", ")" and "?". Its length doesn't exceed 5Β·104. Then there follow m lines, where m is the number of characters "?" in the pattern. Each line contains two integer numbers ai and bi (1 β€ ai, bi β€ 106), where ai is the cost of replacing the i-th character "?" with an opening bracket, and bi β with a closing one.
Output
Print the cost of the optimal regular bracket sequence in the first line, and the required sequence in the second.
Print -1, if there is no answer. If the answer is not unique, print any of them.
Examples
Input
(??)
1 2
2 8
Output
4
()()
Submitted Solution:
```
from heapq import heappush, heappop
s = list(input())
n = len(s)
ans = 0
k = 0
heap = []
for i in range(n):
if s[i] == '(':
k+=1
elif s[i] == ')':
k-=1
else:
a,b = map(int, input().split())
ans += b
heappush(heap, (a-b, i))
s[i] = ')'
k-=1
if k<0:
if len(heap)==0:
break
v,p = heappop(heap)
ans += v
s[p] = '('
k+=2
if k!=0:
print(-1)
else:
print(ans)
print(''.join(s))
``` | instruction | 0 | 25,966 | 21 | 51,932 |
Yes | output | 1 | 25,966 | 21 | 51,933 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is yet another problem on regular bracket sequences.
A bracket sequence is called regular, if by inserting "+" and "1" into it we get a correct mathematical expression. For example, sequences "(())()", "()" and "(()(()))" are regular, while ")(", "(()" and "(()))(" are not. You have a pattern of a bracket sequence that consists of characters "(", ")" and "?". You have to replace each character "?" with a bracket so, that you get a regular bracket sequence.
For each character "?" the cost of its replacement with "(" and ")" is given. Among all the possible variants your should choose the cheapest.
Input
The first line contains a non-empty pattern of even length, consisting of characters "(", ")" and "?". Its length doesn't exceed 5Β·104. Then there follow m lines, where m is the number of characters "?" in the pattern. Each line contains two integer numbers ai and bi (1 β€ ai, bi β€ 106), where ai is the cost of replacing the i-th character "?" with an opening bracket, and bi β with a closing one.
Output
Print the cost of the optimal regular bracket sequence in the first line, and the required sequence in the second.
Print -1, if there is no answer. If the answer is not unique, print any of them.
Examples
Input
(??)
1 2
2 8
Output
4
()()
Submitted Solution:
```
from collections import namedtuple
from heapq import heappush, heappop
Diff = namedtuple("Diff", ["diff", "idx"])
def solver(brackets):
heap = []
opens = 0
cost = 0
for i, c in enumerate(brackets):
opens += int(c == "(") - int(c == ")")
if c == "?":
brackets[i] = ")"
o, c = map(int, input().split())
heappush(heap, Diff(o - c, i))
opens -= 1
cost += c
if opens < 0:
diff, idx = heappop(heap)
brackets[idx] = "("
opens += 2
cost += diff
return (-1, None) if opens < 0 else (cost, brackets)
def main():
cost, brackets = solver(list(input()))
if cost == -1:
print(-1)
else:
print(cost)
print("".join(brackets))
if __name__ == "__main__":
main()
``` | instruction | 0 | 25,967 | 21 | 51,934 |
No | output | 1 | 25,967 | 21 | 51,935 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is yet another problem on regular bracket sequences.
A bracket sequence is called regular, if by inserting "+" and "1" into it we get a correct mathematical expression. For example, sequences "(())()", "()" and "(()(()))" are regular, while ")(", "(()" and "(()))(" are not. You have a pattern of a bracket sequence that consists of characters "(", ")" and "?". You have to replace each character "?" with a bracket so, that you get a regular bracket sequence.
For each character "?" the cost of its replacement with "(" and ")" is given. Among all the possible variants your should choose the cheapest.
Input
The first line contains a non-empty pattern of even length, consisting of characters "(", ")" and "?". Its length doesn't exceed 5Β·104. Then there follow m lines, where m is the number of characters "?" in the pattern. Each line contains two integer numbers ai and bi (1 β€ ai, bi β€ 106), where ai is the cost of replacing the i-th character "?" with an opening bracket, and bi β with a closing one.
Output
Print the cost of the optimal regular bracket sequence in the first line, and the required sequence in the second.
Print -1, if there is no answer. If the answer is not unique, print any of them.
Examples
Input
(??)
1 2
2 8
Output
4
()()
Submitted Solution:
```
import gc
import sys
from typing import List, Union
def rl(int_: bool = True) -> Union[List[str], List[int]]:
if int_:
return [int(w) for w in sys.stdin.readline().split()]
return [w for w in sys.stdin.readline().split()]
s = rl(False)[0]
stack = 0
queue = []
for c in s:
if c == "?":
a, b = rl()
if not queue:
queue.append([["("], 1, a])
continue
new_queue = []
for q in queue:
x, y, z = q
if y > 0:
new_queue.append([x + [")"], y - 1, z + b])
new_queue.append([x + ["("], y + 1, z + a])
queue = new_queue
else:
if not queue:
if c == "(":
queue.append([["("], 1, 0])
continue
else:
break
new_queue = []
for q in queue:
x, y, z = q
if c == "(":
y += 1
new_queue.append([x + ["("], y, z])
elif y > 0:
new_queue.append([x + [")"], y - 1, z])
queue = new_queue
gc.collect()
# print(queue)
regular = list(filter(lambda z: z[1] == 0, queue))
# print(regular)
if not regular:
print(-1)
else:
l = min(regular, key=lambda z: z[2])[2]
# print(l)
r = list(filter(lambda z: z[2] == l, queue))
if not r:
print(-1)
else:
print(r[0][2])
print("".join(r[0][0]))
``` | instruction | 0 | 25,968 | 21 | 51,936 |
No | output | 1 | 25,968 | 21 | 51,937 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is yet another problem on regular bracket sequences.
A bracket sequence is called regular, if by inserting "+" and "1" into it we get a correct mathematical expression. For example, sequences "(())()", "()" and "(()(()))" are regular, while ")(", "(()" and "(()))(" are not. You have a pattern of a bracket sequence that consists of characters "(", ")" and "?". You have to replace each character "?" with a bracket so, that you get a regular bracket sequence.
For each character "?" the cost of its replacement with "(" and ")" is given. Among all the possible variants your should choose the cheapest.
Input
The first line contains a non-empty pattern of even length, consisting of characters "(", ")" and "?". Its length doesn't exceed 5Β·104. Then there follow m lines, where m is the number of characters "?" in the pattern. Each line contains two integer numbers ai and bi (1 β€ ai, bi β€ 106), where ai is the cost of replacing the i-th character "?" with an opening bracket, and bi β with a closing one.
Output
Print the cost of the optimal regular bracket sequence in the first line, and the required sequence in the second.
Print -1, if there is no answer. If the answer is not unique, print any of them.
Examples
Input
(??)
1 2
2 8
Output
4
()()
Submitted Solution:
```
exp=input()
cnt=0
n=len(exp)
lcnt=0
rcnt=0
Lcnt=[0]*(n+1)
Rcnt=[0]*(n+1)
def lowbit(i):
return i&(-i)
def insert(i,flag):
global lcnt,rcnt
while i<=n:
if flag:
Lcnt[i]+=1
else:
Rcnt[i]+=1
i+=lowbit(i)
def search(i,flag):
r=0
while i>0:
if flag: r+=Lcnt[i]
else: r+=Rcnt[i]
i-=lowbit(i)
return r
def check(i,flag):
l=search(i,True)
r=search(i,False)
if flag:
if lcnt<n/2:
return True
else:
return False
else:
if rcnt<n/2 and r<l:
return True
else:
return False
Sum=0
No=[]
for i in range(n):
if exp[i]=='(':
insert(i+1,True)
lcnt+=1
elif exp[i]==')':
insert(i+1,False)
rcnt+=1
else:
No.append(i+1)
cnt+=1
exp='0'+exp
exp=list(exp)
Cost=[]
Delta=[]
Sum=0
for i in range(cnt):
a,b=map(int,input().split())
Cost.append((a,b))
# Delta.append((abs(a-b),i))
for i in range(cnt):
if check(No[i],True):
if check(No[i],False):
Delta.append((abs(Cost[i][0]-Cost[i][1]),i))
else:
exp[No[i]]='('
insert(No[i],True)
lcnt+=1
Sum+=Cost[i][0]
else:
exp[No[i]]=')'
insert(No[i],False)
rcnt+=1
Sum+=Cost[i][1]
Delta.sort(key = lambda x:(-x[0],x[1]))
for i in Delta:
no=i[1]
if Cost[no][0]>Cost[no][1]:
if check(No[no],False):
rcnt+=1
insert(No[no],False)
exp[No[no]]=')'
Sum+=Cost[no][1]
else:
lcnt+=1
insert(No[no],True)
exp[No[no]]='('
Sum+=Cost[no][0]
else:
if check(No[no],True):
lcnt+=1
insert(No[no],True)
exp[No[no]]='('
Sum+=Cost[no][0]
else:
rcnt+=1
insert(No[no],False)
exp[No[no]]=')'
Sum+=Cost[no][1]
if lcnt==rcnt:
print(Sum)
for i in range(1,n+1):
print(exp[i],end='')
print()
else:
print(-1)
``` | instruction | 0 | 25,969 | 21 | 51,938 |
No | output | 1 | 25,969 | 21 | 51,939 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is yet another problem on regular bracket sequences.
A bracket sequence is called regular, if by inserting "+" and "1" into it we get a correct mathematical expression. For example, sequences "(())()", "()" and "(()(()))" are regular, while ")(", "(()" and "(()))(" are not. You have a pattern of a bracket sequence that consists of characters "(", ")" and "?". You have to replace each character "?" with a bracket so, that you get a regular bracket sequence.
For each character "?" the cost of its replacement with "(" and ")" is given. Among all the possible variants your should choose the cheapest.
Input
The first line contains a non-empty pattern of even length, consisting of characters "(", ")" and "?". Its length doesn't exceed 5Β·104. Then there follow m lines, where m is the number of characters "?" in the pattern. Each line contains two integer numbers ai and bi (1 β€ ai, bi β€ 106), where ai is the cost of replacing the i-th character "?" with an opening bracket, and bi β with a closing one.
Output
Print the cost of the optimal regular bracket sequence in the first line, and the required sequence in the second.
Print -1, if there is no answer. If the answer is not unique, print any of them.
Examples
Input
(??)
1 2
2 8
Output
4
()()
Submitted Solution:
```
__author__ = 'linh'
MIN = 10000000000000000
WEIGHT = []
TRACK = ''
STR = ''
def main():
global STR
global WEIGHT
STR = input()
question_n0 = STR.count('?')
for i in range(0, question_n0):
s = list(map(int, input().split()))
WEIGHT.append(s)
position = 0
bracket_n0 = 0
while STR[position] != '?':
if STR[position] == '(':
bracket_n0 += 1
else:
bracket_n0 -= 1
if bracket_n0 < 0:
print(-1)
return
position += 1
i = len(STR) -1
b_n0 = 0
while STR[i] != '?':
if STR[i] == '(':
b_n0 += 1
else:
b_n0 -= 1
if b_n0 > 0:
print(-1)
return
i -= 1
bracket(0, 0, STR[:position],0, question_n0, bracket_n0, position)
bracket(0, 1, STR[:position],0, question_n0, bracket_n0, position)
if TRACK == '':
print(-1)
else:
print(MIN)
print(TRACK + STR[i+1:])
def bracket(i, b, track, s, question_n0, bracket_n0, position):
global MIN
global WEIGHT
global TRACK
global STR
if s + WEIGHT[i][b] >= MIN:
return
if b == 0:
track += '('
bracket_n0 += 1
else:
track += ')'
bracket_n0 -= 1
question_n0 -= 1
position += 1
s += WEIGHT[i][b]
if question_n0 == 0:
while position < len(STR):
if STR[position] == '(':
bracket_n0 += 1
else:
bracket_n0 -= 1
position += 1
if bracket_n0 != 0:
return
if s < MIN:
MIN = s
TRACK = track
return
else:
while STR[position] != '?':
if STR[position] == '(':
bracket_n0 += 1
else:
bracket_n0 -= 1
position += 1
if bracket_n0 <0:
return
elif bracket_n0 == 0:
bracket(i+1,0, track,s, question_n0, bracket_n0, position)
else:
bracket(i+1, 0, track,s, question_n0, bracket_n0, position)
bracket(i+1, 1, track,s, question_n0, bracket_n0, position)
if __name__ == '__main__':
main()
``` | instruction | 0 | 25,970 | 21 | 51,940 |
No | output | 1 | 25,970 | 21 | 51,941 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya's friends made him a birthday present β a bracket sequence. Petya was quite disappointed with his gift, because he dreamed of correct bracket sequence, yet he told his friends nothing about his dreams and decided to fix present himself.
To make everything right, Petya is going to move at most one bracket from its original place in the sequence to any other position. Reversing the bracket (e.g. turning "(" into ")" or vice versa) isn't allowed.
We remind that bracket sequence s is called correct if:
* s is empty;
* s is equal to "(t)", where t is correct bracket sequence;
* s is equal to t_1 t_2, i.e. concatenation of t_1 and t_2, where t_1 and t_2 are correct bracket sequences.
For example, "(()())", "()" are correct, while ")(" and "())" are not. Help Petya to fix his birthday present and understand whether he can move one bracket so that the sequence becomes correct.
Input
First of line of input contains a single number n (1 β€ n β€ 200 000) β length of the sequence which Petya received for his birthday.
Second line of the input contains bracket sequence of length n, containing symbols "(" and ")".
Output
Print "Yes" if Petya can make his sequence correct moving at most one bracket. Otherwise print "No".
Examples
Input
2
)(
Output
Yes
Input
3
(()
Output
No
Input
2
()
Output
Yes
Input
10
)))))(((((
Output
No
Note
In the first example, Petya can move first bracket to the end, thus turning the sequence into "()", which is correct bracket sequence.
In the second example, there is no way to move at most one bracket so that the sequence becomes correct.
In the third example, the sequence is already correct and there's no need to move brackets. | instruction | 0 | 30,145 | 21 | 60,290 |
Tags: data structures, greedy
Correct Solution:
```
def read():
n = int(input())
s = input()
return n, s
def solve(n, s):
st = [s[0]]
for i in range(1, n):
if s[i] == "(":
st.append(s[i])
else:
if len(st) == 0:
st.append(s[i])
elif st[-1] == "(":
st.pop()
else:
st.append(s[i])
if len(st) == 0:
return True
elif len(st) == 2:
return st[0] != st[1]
result = solve(*read())
print("Yes" if result else "No")
``` | output | 1 | 30,145 | 21 | 60,291 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya's friends made him a birthday present β a bracket sequence. Petya was quite disappointed with his gift, because he dreamed of correct bracket sequence, yet he told his friends nothing about his dreams and decided to fix present himself.
To make everything right, Petya is going to move at most one bracket from its original place in the sequence to any other position. Reversing the bracket (e.g. turning "(" into ")" or vice versa) isn't allowed.
We remind that bracket sequence s is called correct if:
* s is empty;
* s is equal to "(t)", where t is correct bracket sequence;
* s is equal to t_1 t_2, i.e. concatenation of t_1 and t_2, where t_1 and t_2 are correct bracket sequences.
For example, "(()())", "()" are correct, while ")(" and "())" are not. Help Petya to fix his birthday present and understand whether he can move one bracket so that the sequence becomes correct.
Input
First of line of input contains a single number n (1 β€ n β€ 200 000) β length of the sequence which Petya received for his birthday.
Second line of the input contains bracket sequence of length n, containing symbols "(" and ")".
Output
Print "Yes" if Petya can make his sequence correct moving at most one bracket. Otherwise print "No".
Examples
Input
2
)(
Output
Yes
Input
3
(()
Output
No
Input
2
()
Output
Yes
Input
10
)))))(((((
Output
No
Note
In the first example, Petya can move first bracket to the end, thus turning the sequence into "()", which is correct bracket sequence.
In the second example, there is no way to move at most one bracket so that the sequence becomes correct.
In the third example, the sequence is already correct and there's no need to move brackets. | instruction | 0 | 30,146 | 21 | 60,292 |
Tags: data structures, greedy
Correct Solution:
```
import sys
import collections
import functools
n = int(input().strip())
s = input().strip()
stack, s2 = [], []
for i in s:
if i == "(":
stack.append(i)
elif i == ")" and stack and stack[-1] == "(":
stack.pop()
else:
s2.append(i)
if len(s2) == 1 and s2[-1] == ")" and len(stack) == 1 and stack[-1] == "(":
print("Yes")
elif len(s2) == 0 and len(stack) == 0:
print("Yes")
else:
print("No")
``` | output | 1 | 30,146 | 21 | 60,293 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya's friends made him a birthday present β a bracket sequence. Petya was quite disappointed with his gift, because he dreamed of correct bracket sequence, yet he told his friends nothing about his dreams and decided to fix present himself.
To make everything right, Petya is going to move at most one bracket from its original place in the sequence to any other position. Reversing the bracket (e.g. turning "(" into ")" or vice versa) isn't allowed.
We remind that bracket sequence s is called correct if:
* s is empty;
* s is equal to "(t)", where t is correct bracket sequence;
* s is equal to t_1 t_2, i.e. concatenation of t_1 and t_2, where t_1 and t_2 are correct bracket sequences.
For example, "(()())", "()" are correct, while ")(" and "())" are not. Help Petya to fix his birthday present and understand whether he can move one bracket so that the sequence becomes correct.
Input
First of line of input contains a single number n (1 β€ n β€ 200 000) β length of the sequence which Petya received for his birthday.
Second line of the input contains bracket sequence of length n, containing symbols "(" and ")".
Output
Print "Yes" if Petya can make his sequence correct moving at most one bracket. Otherwise print "No".
Examples
Input
2
)(
Output
Yes
Input
3
(()
Output
No
Input
2
()
Output
Yes
Input
10
)))))(((((
Output
No
Note
In the first example, Petya can move first bracket to the end, thus turning the sequence into "()", which is correct bracket sequence.
In the second example, there is no way to move at most one bracket so that the sequence becomes correct.
In the third example, the sequence is already correct and there's no need to move brackets. | instruction | 0 | 30,147 | 21 | 60,294 |
Tags: data structures, greedy
Correct Solution:
```
from collections import Counter
n = int(input())
bra = input()
d=Counter(bra)
ans=0
if d['(']==d[')']:
c=0
for i in bra:
if i=='(':
c+=1
else:
if c==0:
ans+=1
else:
c-=1
if ans<=1:
print('Yes')
else:
print('No')
else:
print('No')
``` | output | 1 | 30,147 | 21 | 60,295 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya's friends made him a birthday present β a bracket sequence. Petya was quite disappointed with his gift, because he dreamed of correct bracket sequence, yet he told his friends nothing about his dreams and decided to fix present himself.
To make everything right, Petya is going to move at most one bracket from its original place in the sequence to any other position. Reversing the bracket (e.g. turning "(" into ")" or vice versa) isn't allowed.
We remind that bracket sequence s is called correct if:
* s is empty;
* s is equal to "(t)", where t is correct bracket sequence;
* s is equal to t_1 t_2, i.e. concatenation of t_1 and t_2, where t_1 and t_2 are correct bracket sequences.
For example, "(()())", "()" are correct, while ")(" and "())" are not. Help Petya to fix his birthday present and understand whether he can move one bracket so that the sequence becomes correct.
Input
First of line of input contains a single number n (1 β€ n β€ 200 000) β length of the sequence which Petya received for his birthday.
Second line of the input contains bracket sequence of length n, containing symbols "(" and ")".
Output
Print "Yes" if Petya can make his sequence correct moving at most one bracket. Otherwise print "No".
Examples
Input
2
)(
Output
Yes
Input
3
(()
Output
No
Input
2
()
Output
Yes
Input
10
)))))(((((
Output
No
Note
In the first example, Petya can move first bracket to the end, thus turning the sequence into "()", which is correct bracket sequence.
In the second example, there is no way to move at most one bracket so that the sequence becomes correct.
In the third example, the sequence is already correct and there's no need to move brackets. | instruction | 0 | 30,148 | 21 | 60,296 |
Tags: data structures, greedy
Correct Solution:
```
def countbrackets(string):
if string.replace("(", "").replace(")", ""): return None
string = [x == '(' for x in string]
bopen, extraclose = 0, 0
for x in string:
if x: bopen += 1
else:
if bopen == 0: extraclose += 1
else: bopen -= 1
return bopen, extraclose
input()
bstring = input()
ans = countbrackets(bstring)
if ans == (1,1) or ans == (0,0):
print("Yes")
else:
print("No")
``` | output | 1 | 30,148 | 21 | 60,297 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya's friends made him a birthday present β a bracket sequence. Petya was quite disappointed with his gift, because he dreamed of correct bracket sequence, yet he told his friends nothing about his dreams and decided to fix present himself.
To make everything right, Petya is going to move at most one bracket from its original place in the sequence to any other position. Reversing the bracket (e.g. turning "(" into ")" or vice versa) isn't allowed.
We remind that bracket sequence s is called correct if:
* s is empty;
* s is equal to "(t)", where t is correct bracket sequence;
* s is equal to t_1 t_2, i.e. concatenation of t_1 and t_2, where t_1 and t_2 are correct bracket sequences.
For example, "(()())", "()" are correct, while ")(" and "())" are not. Help Petya to fix his birthday present and understand whether he can move one bracket so that the sequence becomes correct.
Input
First of line of input contains a single number n (1 β€ n β€ 200 000) β length of the sequence which Petya received for his birthday.
Second line of the input contains bracket sequence of length n, containing symbols "(" and ")".
Output
Print "Yes" if Petya can make his sequence correct moving at most one bracket. Otherwise print "No".
Examples
Input
2
)(
Output
Yes
Input
3
(()
Output
No
Input
2
()
Output
Yes
Input
10
)))))(((((
Output
No
Note
In the first example, Petya can move first bracket to the end, thus turning the sequence into "()", which is correct bracket sequence.
In the second example, there is no way to move at most one bracket so that the sequence becomes correct.
In the third example, the sequence is already correct and there's no need to move brackets. | instruction | 0 | 30,149 | 21 | 60,298 |
Tags: data structures, greedy
Correct Solution:
```
def solution():
from sys import stdout, stdin
_input, _print = stdin.readline, stdout.write
_int, _range, _min, _max = int, range, min, max
n = int(input())
arr = [1 if i == '(' else -1 for i in input()]
if sum(arr) != 0:
print("No")
else:
s = [0]*n
for i in range(n):
if i == 0:
s[i] = arr[i]
else:
s[i] = arr[i] + s[i-1]
if s[i] == -2:
print("No")
break
else:
print("Yes")
solution()
``` | output | 1 | 30,149 | 21 | 60,299 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.