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 |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja has a bracket sequence s1, s2, ..., sn, or, in other words, a string s of length n, consisting of characters "(" and ")".
Sereja needs to answer m queries, each of them is described by two integers li, ri (1 ≤ li ≤ ri ≤ n). The answer to the i-th query is the length of the maximum correct bracket subsequence of sequence sli, sli + 1, ..., sri. Help Sereja answer all queries.
You can find the definitions for a subsequence and a correct bracket sequence in the notes.
Input
The first line contains a sequence of characters s1, s2, ..., sn (1 ≤ n ≤ 106) without any spaces. Each character is either a "(" or a ")". The second line contains integer m (1 ≤ m ≤ 105) — the number of queries. Each of the next m lines contains a pair of integers. The i-th line contains integers li, ri (1 ≤ li ≤ ri ≤ n) — the description of the i-th query.
Output
Print the answer to each question on a single line. Print the answers in the order they go in the input.
Examples
Input
())(())(())(
7
1 1
2 3
1 2
1 12
8 12
5 11
2 10
Output
0
0
2
10
4
6
6
Note
A subsequence of length |x| of string s = s1s2... s|s| (where |s| is the length of string s) is string x = sk1sk2... sk|x| (1 ≤ k1 < k2 < ... < k|x| ≤ |s|).
A correct bracket sequence is a bracket sequence that can be transformed into a correct aryphmetic expression by inserting characters "1" and "+" between the characters of the string. For example, bracket sequences "()()", "(())" are correct (the resulting expressions "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
For the third query required sequence will be «()».
For the fourth query required sequence will be «()(())(())». | instruction | 0 | 64,330 | 21 | 128,660 |
Tags: data structures, schedules
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
from array import array
def construct(n,x,si):
left = array('i',[0]*(si<<1))
right = array('i',[0]*(si<<1))
tree = array('i',[0]*(si<<1))
for i in range(si,si+n):
if x[i-si] == '(':
left[i] = 1
else:
right[i] = 1
a,b = si>>1,si
while a:
for i in range(a,b):
z = min(left[i<<1],right[i<<1|1])
tree[i] = tree[i<<1]+tree[i<<1|1]+2*z
left[i] = left[i<<1]+left[i<<1|1]-z
right[i] = right[i<<1]+right[i<<1|1]-z
a,b = a>>1,b>>1
return left,right,tree
def query(tree,left,right,l,r,si):
l,r = l+si-1,r+si-1
partl,partr = [],[]
while l < r:
if l&1:
partl.append(l)
l += 1
if not r&1:
partr.append(r)
r -= 1
l,r = l>>1,r>>1
if l == r:
partl.append(l)
ans,le = 0,0
for i in partl+partr[::-1]:
tk = min(le,right[i])
ans += 2*tk+tree[i]
le += left[i]-tk
return ans
def main():
s = input().strip()
n = len(s)
si = 1<<n.bit_length()-(not n&n-1)
left,right,tree = construct(n,s,si)
for _ in range(int(input())):
l,r = map(int,input().split())
print(query(tree,left,right,l,r,si))
# Fast IO Region
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")
if __name__ == "__main__":
main()
``` | output | 1 | 64,330 | 21 | 128,661 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja has a bracket sequence s1, s2, ..., sn, or, in other words, a string s of length n, consisting of characters "(" and ")".
Sereja needs to answer m queries, each of them is described by two integers li, ri (1 ≤ li ≤ ri ≤ n). The answer to the i-th query is the length of the maximum correct bracket subsequence of sequence sli, sli + 1, ..., sri. Help Sereja answer all queries.
You can find the definitions for a subsequence and a correct bracket sequence in the notes.
Input
The first line contains a sequence of characters s1, s2, ..., sn (1 ≤ n ≤ 106) without any spaces. Each character is either a "(" or a ")". The second line contains integer m (1 ≤ m ≤ 105) — the number of queries. Each of the next m lines contains a pair of integers. The i-th line contains integers li, ri (1 ≤ li ≤ ri ≤ n) — the description of the i-th query.
Output
Print the answer to each question on a single line. Print the answers in the order they go in the input.
Examples
Input
())(())(())(
7
1 1
2 3
1 2
1 12
8 12
5 11
2 10
Output
0
0
2
10
4
6
6
Note
A subsequence of length |x| of string s = s1s2... s|s| (where |s| is the length of string s) is string x = sk1sk2... sk|x| (1 ≤ k1 < k2 < ... < k|x| ≤ |s|).
A correct bracket sequence is a bracket sequence that can be transformed into a correct aryphmetic expression by inserting characters "1" and "+" between the characters of the string. For example, bracket sequences "()()", "(())" are correct (the resulting expressions "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
For the third query required sequence will be «()».
For the fourth query required sequence will be «()(())(())». | instruction | 0 | 64,331 | 21 | 128,662 |
Tags: data structures, schedules
Correct Solution:
```
import sys
input = sys.stdin.readline
s = input()
n = len(s)
# Max size of tree
tree = [0] * (2 * n)
closed = [0] * (2 * n)
opened = [0] * (2 * n)
# function to build the tree
def build(arr):
# insert leaf nodes in tree
for i in range(n):
tree[n + i] = 0
closed[i + n] = int(s[i] == ')')
opened[i + n] = int(s[i] == '(')
# print(tree)
# build the tree by calculating parents
for i in range(n - 1, 0, -1):
to_add = min(closed[i << 1 | 1], opened[i << 1])
tree[i] = tree[i << 1] + tree[i << 1 | 1] + 2 * to_add
closed[i] = closed[i << 1] + closed[i << 1 | 1] - to_add
opened[i] = opened[i << 1] + opened[i << 1 | 1] - to_add
# print(i, closed[i], opened[i], tree[i])
def query(l, r):
left = []
right = []
l += n
r += n
while l <= r:
if (l & 1):
left.append((tree[l], opened[l], closed[l]))
l += 1
if not (r & 1):
right.append((tree[r], opened[r], closed[r]))
r -= 1
l >>= 1
r >>= 1
a1 = b1 = c1 = 0
for a2, b2, c2 in left + right[::-1]:
to_match = min(b1, c2)
a1 += a2 + 2 * to_match
b1 += b2 - to_match
c1 += c2 - to_match
return a1
build(s)
# print(query(1, 5))
for _ in range(int(input())):
a, b = map(int, input().split())
print(query(a - 1, b - 1));
``` | output | 1 | 64,331 | 21 | 128,663 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja has a bracket sequence s1, s2, ..., sn, or, in other words, a string s of length n, consisting of characters "(" and ")".
Sereja needs to answer m queries, each of them is described by two integers li, ri (1 ≤ li ≤ ri ≤ n). The answer to the i-th query is the length of the maximum correct bracket subsequence of sequence sli, sli + 1, ..., sri. Help Sereja answer all queries.
You can find the definitions for a subsequence and a correct bracket sequence in the notes.
Input
The first line contains a sequence of characters s1, s2, ..., sn (1 ≤ n ≤ 106) without any spaces. Each character is either a "(" or a ")". The second line contains integer m (1 ≤ m ≤ 105) — the number of queries. Each of the next m lines contains a pair of integers. The i-th line contains integers li, ri (1 ≤ li ≤ ri ≤ n) — the description of the i-th query.
Output
Print the answer to each question on a single line. Print the answers in the order they go in the input.
Examples
Input
())(())(())(
7
1 1
2 3
1 2
1 12
8 12
5 11
2 10
Output
0
0
2
10
4
6
6
Note
A subsequence of length |x| of string s = s1s2... s|s| (where |s| is the length of string s) is string x = sk1sk2... sk|x| (1 ≤ k1 < k2 < ... < k|x| ≤ |s|).
A correct bracket sequence is a bracket sequence that can be transformed into a correct aryphmetic expression by inserting characters "1" and "+" between the characters of the string. For example, bracket sequences "()()", "(())" are correct (the resulting expressions "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
For the third query required sequence will be «()».
For the fourth query required sequence will be «()(())(())». | instruction | 0 | 64,332 | 21 | 128,664 |
Tags: data structures, schedules
Correct Solution:
```
import sys
input = sys.stdin.readline
s = input()
M = int(input())
def next_pow_2(n):
p = 1
while p < n:
p <<= 1
return p
def represented_range(node, size):
l = node
r = node
while l < size:
l = 2*l
r = 2*r + 1
return l-size, r-size
class SegTree:
def __init__(self, size):
self.size = next_pow_2(size)
self.answer = [0] * (2*self.size)
self.opened = [0] * (2*self.size)
self.closed = [0] * (2*self.size)
# O(size * (O(func) + O(init))
def build(self, s):
for i in range(self.size):
self.answer[self.size + i] = 0
self.opened[self.size + i] = 1 if i < len(s) and s[i] == '(' else 0
self.closed[self.size + i] = 1 if i < len(s) and s[i] == ')' else 0
for i in range(self.size - 1, 0, -1):
matched = min(self.opened[2*i], self.closed[2*i+1])
self.answer[i] = self.answer[2*i] + self.answer[2*i+1] + matched
self.opened[i] = self.opened[2*i] + self.opened[2*i+1] - matched
self.closed[i] = self.closed[2*i] + self.closed[2*i+1] - matched
# O(log(size)), [l,r]
def query(self, l, r):
l += self.size
r += self.size
eventsL = []
eventsR = []
while l <= r:
if l & 1:
eventsL.append((self.answer[l], self.opened[l], self.closed[l]))
l += 1
if not (r & 1):
eventsR.append((self.answer[r], self.opened[r], self.closed[r]))
r -= 1
l >>= 1
r >>= 1
answer = 0
opened = 0
for a, o, c in eventsL + eventsR[::-1]:
matched = min(c, opened)
answer += a + matched
opened += o - matched
return answer
seg = SegTree(len(s))
seg.build(s)
for i in range(M):
l, r = [int(_) for _ in input().split()]
print(2*seg.query(l-1, r-1))
``` | output | 1 | 64,332 | 21 | 128,665 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja has a bracket sequence s1, s2, ..., sn, or, in other words, a string s of length n, consisting of characters "(" and ")".
Sereja needs to answer m queries, each of them is described by two integers li, ri (1 ≤ li ≤ ri ≤ n). The answer to the i-th query is the length of the maximum correct bracket subsequence of sequence sli, sli + 1, ..., sri. Help Sereja answer all queries.
You can find the definitions for a subsequence and a correct bracket sequence in the notes.
Input
The first line contains a sequence of characters s1, s2, ..., sn (1 ≤ n ≤ 106) without any spaces. Each character is either a "(" or a ")". The second line contains integer m (1 ≤ m ≤ 105) — the number of queries. Each of the next m lines contains a pair of integers. The i-th line contains integers li, ri (1 ≤ li ≤ ri ≤ n) — the description of the i-th query.
Output
Print the answer to each question on a single line. Print the answers in the order they go in the input.
Examples
Input
())(())(())(
7
1 1
2 3
1 2
1 12
8 12
5 11
2 10
Output
0
0
2
10
4
6
6
Note
A subsequence of length |x| of string s = s1s2... s|s| (where |s| is the length of string s) is string x = sk1sk2... sk|x| (1 ≤ k1 < k2 < ... < k|x| ≤ |s|).
A correct bracket sequence is a bracket sequence that can be transformed into a correct aryphmetic expression by inserting characters "1" and "+" between the characters of the string. For example, bracket sequences "()()", "(())" are correct (the resulting expressions "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
For the third query required sequence will be «()».
For the fourth query required sequence will be «()(())(())». | instruction | 0 | 64,333 | 21 | 128,666 |
Tags: data structures, schedules
Correct Solution:
```
import sys
input = sys.stdin.readline
s = input()
M = int(input())
def next_pow_2(n):
p = 1
while p < n:
p <<= 1
return p
def represented_range(node, size):
l = node
r = node
while l < size:
l = 2*l
r = 2*r + 1
return l-size, r-size
class SegTree:
def __init__(self, size):
self.size = next_pow_2(size)
self.answer = [0] * (2*self.size)
self.opened = [0] * (2*self.size)
self.closed = [0] * (2*self.size)
# O(size * (O(func) + O(init))
def build(self, s):
for i in range(self.size):
self.answer[self.size + i] = 0
self.opened[self.size + i] = 1 if i < len(s) and s[i] == '(' else 0
self.closed[self.size + i] = 1 if i < len(s) and s[i] == ')' else 0
for i in range(self.size - 1, 0, -1):
matched = min(self.opened[2*i], self.closed[2*i+1])
self.answer[i] = self.answer[2*i] + self.answer[2*i+1] + matched
self.opened[i] = self.opened[2*i] + self.opened[2*i+1] - matched
self.closed[i] = self.closed[2*i] + self.closed[2*i+1] - matched
# O(log(size)), [l,r]
def query(self, l, r):
l += self.size
r += self.size
eventsR = []
answer = 0
opened = 0
while l <= r:
if l & 1:
matched = min(self.closed[l], opened)
answer += self.answer[l] + matched
opened += self.opened[l] - matched
l += 1
if not (r & 1):
eventsR.append((self.answer[r], self.opened[r], self.closed[r]))
r -= 1
l >>= 1
r >>= 1
for i in range(len(eventsR)-1, -1, -1):
a, o, c = eventsR[i]
matched = min(c, opened)
answer += a + matched
opened += o - matched
return answer
seg = SegTree(len(s))
seg.build(s)
for i in range(M):
l, r = [int(_) for _ in input().split()]
print(2*seg.query(l-1, r-1))
``` | output | 1 | 64,333 | 21 | 128,667 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja has a bracket sequence s1, s2, ..., sn, or, in other words, a string s of length n, consisting of characters "(" and ")".
Sereja needs to answer m queries, each of them is described by two integers li, ri (1 ≤ li ≤ ri ≤ n). The answer to the i-th query is the length of the maximum correct bracket subsequence of sequence sli, sli + 1, ..., sri. Help Sereja answer all queries.
You can find the definitions for a subsequence and a correct bracket sequence in the notes.
Input
The first line contains a sequence of characters s1, s2, ..., sn (1 ≤ n ≤ 106) without any spaces. Each character is either a "(" or a ")". The second line contains integer m (1 ≤ m ≤ 105) — the number of queries. Each of the next m lines contains a pair of integers. The i-th line contains integers li, ri (1 ≤ li ≤ ri ≤ n) — the description of the i-th query.
Output
Print the answer to each question on a single line. Print the answers in the order they go in the input.
Examples
Input
())(())(())(
7
1 1
2 3
1 2
1 12
8 12
5 11
2 10
Output
0
0
2
10
4
6
6
Note
A subsequence of length |x| of string s = s1s2... s|s| (where |s| is the length of string s) is string x = sk1sk2... sk|x| (1 ≤ k1 < k2 < ... < k|x| ≤ |s|).
A correct bracket sequence is a bracket sequence that can be transformed into a correct aryphmetic expression by inserting characters "1" and "+" between the characters of the string. For example, bracket sequences "()()", "(())" are correct (the resulting expressions "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
For the third query required sequence will be «()».
For the fourth query required sequence will be «()(())(())». | instruction | 0 | 64,334 | 21 | 128,668 |
Tags: data structures, schedules
Correct Solution:
```
#If FastIO not needed, use this and don't forget to strip
import sys, math
input = sys.stdin.readline
"""
In each subsequence:
-
"""
S = input().strip()
two_pows = set()
"""for i in range(31):
two_pows.add(pow(2,i))
while len(S) not in two_pows:
S = S + '('"""
n = len(S)
M = int(input())
class segTree:
def __init__(self):
self.a = [0]*(2*n)
self.b = [0]*(2*n)
self.c = [0]*(2*n)
def build(self, arr):
for i in range(n):
self.a[i+n] = 0
self.b[i+n] = 1 if arr[i] == '(' else 0
self.c[i+n] = 1 if arr[i] == ')' else 0
for i in range(n-1,0,-1):
to_match = min(self.b[i << 1],self.c[i << 1 | 1])
self.a[i] = self.a[i << 1] + self.a[i << 1 | 1] + 2*to_match
self.b[i] = self.b[i << 1] + self.b[i << 1 | 1] - to_match
self.c[i] = self.c[i << 1] + self.c[i << 1 | 1] - to_match
def query(self, l, r):
left = []
right = []
l += n
r += n
while l <= r:
if (l & 1):
left.append((self.a[l],self.b[l],self.c[l]))
l += 1
if not (r & 1):
right.append((self.a[r],self.b[r],self.c[r]))
r -= 1
l >>= 1
r >>= 1
a1 = b1 = c1 = 0
for a2, b2, c2 in left + right[::-1]:
to_match = min(b1,c2)
a1 += a2 + 2*to_match
b1 += b2 - to_match
c1 += c2 - to_match
return a1
tree = segTree()
tree.build(S)
#print(tree)
for m in range(M):
l, r = [int(s) for s in input().split()]
l -= 1
r -= 1
print(tree.query(l,r))
#for _ in range(getInt()):
#print(solve())
#print(time.time()-start_time)
``` | output | 1 | 64,334 | 21 | 128,669 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sereja has a bracket sequence s1, s2, ..., sn, or, in other words, a string s of length n, consisting of characters "(" and ")".
Sereja needs to answer m queries, each of them is described by two integers li, ri (1 ≤ li ≤ ri ≤ n). The answer to the i-th query is the length of the maximum correct bracket subsequence of sequence sli, sli + 1, ..., sri. Help Sereja answer all queries.
You can find the definitions for a subsequence and a correct bracket sequence in the notes.
Input
The first line contains a sequence of characters s1, s2, ..., sn (1 ≤ n ≤ 106) without any spaces. Each character is either a "(" or a ")". The second line contains integer m (1 ≤ m ≤ 105) — the number of queries. Each of the next m lines contains a pair of integers. The i-th line contains integers li, ri (1 ≤ li ≤ ri ≤ n) — the description of the i-th query.
Output
Print the answer to each question on a single line. Print the answers in the order they go in the input.
Examples
Input
())(())(())(
7
1 1
2 3
1 2
1 12
8 12
5 11
2 10
Output
0
0
2
10
4
6
6
Note
A subsequence of length |x| of string s = s1s2... s|s| (where |s| is the length of string s) is string x = sk1sk2... sk|x| (1 ≤ k1 < k2 < ... < k|x| ≤ |s|).
A correct bracket sequence is a bracket sequence that can be transformed into a correct aryphmetic expression by inserting characters "1" and "+" between the characters of the string. For example, bracket sequences "()()", "(())" are correct (the resulting expressions "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
For the third query required sequence will be «()».
For the fourth query required sequence will be «()(())(())».
Submitted Solution:
```
#n , m = map(int, input().split())
def check(sr,n):
k=0;
for i in range(int(len(sr)-2*n+1)):
a = sr[i:i+n]
b = sr[i+n:i+n+n]
a = list(set(a))
b = list(set(b))
if (len(a) == 1 and len(b) == 1):
if (sum(a) == 1 and sum(b) == 0):
k=k+1
return k
s = input()
seq = [char for char in s]
seqInt = [1 if x =='(' else 0 for x in seq]
n = int(input())
for i in range(n):
l , r = map(int, input().split())
sp = seqInt[l-1:r]
#print(sp)
S = 0
for count in range(int(len(sp)/2)):
S = S + check(sp, count+1)
print(S*2)
``` | instruction | 0 | 64,335 | 21 | 128,670 |
No | output | 1 | 64,335 | 21 | 128,671 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sereja has a bracket sequence s1, s2, ..., sn, or, in other words, a string s of length n, consisting of characters "(" and ")".
Sereja needs to answer m queries, each of them is described by two integers li, ri (1 ≤ li ≤ ri ≤ n). The answer to the i-th query is the length of the maximum correct bracket subsequence of sequence sli, sli + 1, ..., sri. Help Sereja answer all queries.
You can find the definitions for a subsequence and a correct bracket sequence in the notes.
Input
The first line contains a sequence of characters s1, s2, ..., sn (1 ≤ n ≤ 106) without any spaces. Each character is either a "(" or a ")". The second line contains integer m (1 ≤ m ≤ 105) — the number of queries. Each of the next m lines contains a pair of integers. The i-th line contains integers li, ri (1 ≤ li ≤ ri ≤ n) — the description of the i-th query.
Output
Print the answer to each question on a single line. Print the answers in the order they go in the input.
Examples
Input
())(())(())(
7
1 1
2 3
1 2
1 12
8 12
5 11
2 10
Output
0
0
2
10
4
6
6
Note
A subsequence of length |x| of string s = s1s2... s|s| (where |s| is the length of string s) is string x = sk1sk2... sk|x| (1 ≤ k1 < k2 < ... < k|x| ≤ |s|).
A correct bracket sequence is a bracket sequence that can be transformed into a correct aryphmetic expression by inserting characters "1" and "+" between the characters of the string. For example, bracket sequences "()()", "(())" are correct (the resulting expressions "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
For the third query required sequence will be «()».
For the fourth query required sequence will be «()(())(())».
Submitted Solution:
```
x = input()
while x[len(x) - 1] == '(':
x = x[:-1]
while x[0] == ')':
x = x[1:]
n = int(input())
for i in range(n):
a, b = input().split()
a, b = int(a), int(b)
nr = 0
aux = x[a-1:b]
okay = True
while okay:
numar = aux.count('()')
if numar:
aux = aux.replace('()', '')
nr += numar*2
else:
okay = False
print(nr)
``` | instruction | 0 | 64,336 | 21 | 128,672 |
No | output | 1 | 64,336 | 21 | 128,673 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sereja has a bracket sequence s1, s2, ..., sn, or, in other words, a string s of length n, consisting of characters "(" and ")".
Sereja needs to answer m queries, each of them is described by two integers li, ri (1 ≤ li ≤ ri ≤ n). The answer to the i-th query is the length of the maximum correct bracket subsequence of sequence sli, sli + 1, ..., sri. Help Sereja answer all queries.
You can find the definitions for a subsequence and a correct bracket sequence in the notes.
Input
The first line contains a sequence of characters s1, s2, ..., sn (1 ≤ n ≤ 106) without any spaces. Each character is either a "(" or a ")". The second line contains integer m (1 ≤ m ≤ 105) — the number of queries. Each of the next m lines contains a pair of integers. The i-th line contains integers li, ri (1 ≤ li ≤ ri ≤ n) — the description of the i-th query.
Output
Print the answer to each question on a single line. Print the answers in the order they go in the input.
Examples
Input
())(())(())(
7
1 1
2 3
1 2
1 12
8 12
5 11
2 10
Output
0
0
2
10
4
6
6
Note
A subsequence of length |x| of string s = s1s2... s|s| (where |s| is the length of string s) is string x = sk1sk2... sk|x| (1 ≤ k1 < k2 < ... < k|x| ≤ |s|).
A correct bracket sequence is a bracket sequence that can be transformed into a correct aryphmetic expression by inserting characters "1" and "+" between the characters of the string. For example, bracket sequences "()()", "(())" are correct (the resulting expressions "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
For the third query required sequence will be «()».
For the fourth query required sequence will be «()(())(())».
Submitted Solution:
```
s=input()
cnt=[] ; op=0 ; cls=0 ; aop=[0] ; acls=[0] ; st=[]
for i in range(len(s)):
if s[i]=='(':
st.append('(')
op+=1
if s[i]==')':
if st:
cls+=1
st.pop()
aop.append(op)
acls.append(cls)
for _ in range(int(input())):
l,r=[int(i) for i in input().split()]
print(min(aop[r-1]-aop[l-1],acls[r]-acls[l])*2)
``` | instruction | 0 | 64,337 | 21 | 128,674 |
No | output | 1 | 64,337 | 21 | 128,675 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sereja has a bracket sequence s1, s2, ..., sn, or, in other words, a string s of length n, consisting of characters "(" and ")".
Sereja needs to answer m queries, each of them is described by two integers li, ri (1 ≤ li ≤ ri ≤ n). The answer to the i-th query is the length of the maximum correct bracket subsequence of sequence sli, sli + 1, ..., sri. Help Sereja answer all queries.
You can find the definitions for a subsequence and a correct bracket sequence in the notes.
Input
The first line contains a sequence of characters s1, s2, ..., sn (1 ≤ n ≤ 106) without any spaces. Each character is either a "(" or a ")". The second line contains integer m (1 ≤ m ≤ 105) — the number of queries. Each of the next m lines contains a pair of integers. The i-th line contains integers li, ri (1 ≤ li ≤ ri ≤ n) — the description of the i-th query.
Output
Print the answer to each question on a single line. Print the answers in the order they go in the input.
Examples
Input
())(())(())(
7
1 1
2 3
1 2
1 12
8 12
5 11
2 10
Output
0
0
2
10
4
6
6
Note
A subsequence of length |x| of string s = s1s2... s|s| (where |s| is the length of string s) is string x = sk1sk2... sk|x| (1 ≤ k1 < k2 < ... < k|x| ≤ |s|).
A correct bracket sequence is a bracket sequence that can be transformed into a correct aryphmetic expression by inserting characters "1" and "+" between the characters of the string. For example, bracket sequences "()()", "(())" are correct (the resulting expressions "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
For the third query required sequence will be «()».
For the fourth query required sequence will be «()(())(())».
Submitted Solution:
```
def g(a, b): return (a[0], b[1] + a[1] - b[0]) if a[1] > b[0] else (a[0] + b[0] - a[1], b[1])
def f(l, r):
a, b = (0, 0), (0, 0)
while r > l:
if l & 1:
a = g(p[l], a)
l += 1
if r & 1 == 0:
b = g(b, p[r])
r -= 1
l >>= 1
r >>= 1
if r == l: a = g(a, p[l])
a = g(a, b)
return a[0] + a[1]
q = input()
t, n = 1, len(q)
while t < n: t <<= 1
p = [(0, 0)] * (t << 1)
for i, j in enumerate(q):
if j == '(': p[i | t] = (0, 1)
else: p[i | t] = (1, 0)
for i in range(t - 1, 0, -1): p[i] = g(p[i << 1], p[(i << 1) | 1])
m = int(input())
s = [0] * m
for i in range(m):
l, r = map(int, input().split())
s[i] = r - l + 1 - f((l - 1) | t, (r - 1) | t)
print('\n'.join(map(str, s)))
``` | instruction | 0 | 64,338 | 21 | 128,676 |
No | output | 1 | 64,338 | 21 | 128,677 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a bracket sequence s of length n, where n is even (divisible by two). The string s consists of n/2 opening brackets '(' and n/2 closing brackets ')'.
In one move, you can choose exactly one bracket and move it to the beginning of the string or to the end of the string (i.e. you choose some index i, remove the i-th character of s and insert it before or after all remaining characters of s).
Your task is to find the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Recall what the regular bracket sequence is:
* "()" is regular bracket sequence;
* if s is regular bracket sequence then "(" + s + ")" is regular bracket sequence;
* if s and t are regular bracket sequences then s + t is regular bracket sequence.
For example, "()()", "(())()", "(())" and "()" are regular bracket sequences, but ")(", "()(" and ")))" are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2000) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 50) — the length of s. It is guaranteed that n is even. The second line of the test case containg the string s consisting of n/2 opening and n/2 closing brackets.
Output
For each test case, print the answer — the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Example
Input
4
2
)(
4
()()
8
())()()(
10
)))((((())
Output
1
0
1
3
Note
In the first test case of the example, it is sufficient to move the first bracket to the end of the string.
In the third test case of the example, it is sufficient to move the last bracket to the beginning of the string.
In the fourth test case of the example, we can choose last three openning brackets, move them to the beginning of the string and obtain "((()))(())". | instruction | 0 | 65,023 | 21 | 130,046 |
Tags: greedy, strings
Correct Solution:
```
# ===============================================================================================
# importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import *
from copy import *
from collections import deque
from collections import Counter as counter # Counter(list) return a dict with {key: count}
from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
from itertools import permutations as permutate
from bisect import bisect_left as bl
# If the element is already present in the list,
# the left most position where element has to be inserted is returned.
from bisect import bisect_right as br
from bisect import bisect
# If the element is already present in the list,
# the right most position where element has to be inserted is returned
# ==============================================================================================
# fast I/O region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
# ===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
###### END ITERATE RECURSION ####
# ===============================================================================================
# some shortcuts
mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") # for fast input
def integer(): return int(inp())
def out(var): sys.stdout.write(str(var)) # for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
def zerolist(n): return [0] * n
def nextline(): out("\n") # as stdout.write always print sring.
def testcase(t):
for p in range(t):
solve()
def printlist(a):
for p in range(0, len(a)):
out(str(a[p]) + ' ')
from functools import reduce
def factors(n):
return set(reduce(list.__add__,
([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
def solve():
n=integer()
s=inp()
co=0
ans=0
for i in s:
if i==")":
if co<=0:
ans+=1
else:
co-=1
else:
co+=1
print(ans)
testcase(int(inp()))
#solve()
``` | output | 1 | 65,023 | 21 | 130,047 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a bracket sequence s of length n, where n is even (divisible by two). The string s consists of n/2 opening brackets '(' and n/2 closing brackets ')'.
In one move, you can choose exactly one bracket and move it to the beginning of the string or to the end of the string (i.e. you choose some index i, remove the i-th character of s and insert it before or after all remaining characters of s).
Your task is to find the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Recall what the regular bracket sequence is:
* "()" is regular bracket sequence;
* if s is regular bracket sequence then "(" + s + ")" is regular bracket sequence;
* if s and t are regular bracket sequences then s + t is regular bracket sequence.
For example, "()()", "(())()", "(())" and "()" are regular bracket sequences, but ")(", "()(" and ")))" are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2000) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 50) — the length of s. It is guaranteed that n is even. The second line of the test case containg the string s consisting of n/2 opening and n/2 closing brackets.
Output
For each test case, print the answer — the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Example
Input
4
2
)(
4
()()
8
())()()(
10
)))((((())
Output
1
0
1
3
Note
In the first test case of the example, it is sufficient to move the first bracket to the end of the string.
In the third test case of the example, it is sufficient to move the last bracket to the beginning of the string.
In the fourth test case of the example, we can choose last three openning brackets, move them to the beginning of the string and obtain "((()))(())". | instruction | 0 | 65,024 | 21 | 130,048 |
Tags: greedy, strings
Correct Solution:
```
T = int(input())
for t in range(T):
N = int(input())
s = input()
a = 0
level = 0
for c in s:
if c == '(':
level += 1
elif c == ')':
if level == 0:
a += 1
else:
level -= 1
print(a)
``` | output | 1 | 65,024 | 21 | 130,049 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a bracket sequence s of length n, where n is even (divisible by two). The string s consists of n/2 opening brackets '(' and n/2 closing brackets ')'.
In one move, you can choose exactly one bracket and move it to the beginning of the string or to the end of the string (i.e. you choose some index i, remove the i-th character of s and insert it before or after all remaining characters of s).
Your task is to find the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Recall what the regular bracket sequence is:
* "()" is regular bracket sequence;
* if s is regular bracket sequence then "(" + s + ")" is regular bracket sequence;
* if s and t are regular bracket sequences then s + t is regular bracket sequence.
For example, "()()", "(())()", "(())" and "()" are regular bracket sequences, but ")(", "()(" and ")))" are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2000) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 50) — the length of s. It is guaranteed that n is even. The second line of the test case containg the string s consisting of n/2 opening and n/2 closing brackets.
Output
For each test case, print the answer — the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Example
Input
4
2
)(
4
()()
8
())()()(
10
)))((((())
Output
1
0
1
3
Note
In the first test case of the example, it is sufficient to move the first bracket to the end of the string.
In the third test case of the example, it is sufficient to move the last bracket to the beginning of the string.
In the fourth test case of the example, we can choose last three openning brackets, move them to the beginning of the string and obtain "((()))(())". | instruction | 0 | 65,025 | 21 | 130,050 |
Tags: greedy, strings
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
s=input()
ans=0
c=0
for i in s:
if(i==')'):
c+=1
else:
c-=1
ans=max(ans,c)
print(ans)
``` | output | 1 | 65,025 | 21 | 130,051 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a bracket sequence s of length n, where n is even (divisible by two). The string s consists of n/2 opening brackets '(' and n/2 closing brackets ')'.
In one move, you can choose exactly one bracket and move it to the beginning of the string or to the end of the string (i.e. you choose some index i, remove the i-th character of s and insert it before or after all remaining characters of s).
Your task is to find the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Recall what the regular bracket sequence is:
* "()" is regular bracket sequence;
* if s is regular bracket sequence then "(" + s + ")" is regular bracket sequence;
* if s and t are regular bracket sequences then s + t is regular bracket sequence.
For example, "()()", "(())()", "(())" and "()" are regular bracket sequences, but ")(", "()(" and ")))" are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2000) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 50) — the length of s. It is guaranteed that n is even. The second line of the test case containg the string s consisting of n/2 opening and n/2 closing brackets.
Output
For each test case, print the answer — the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Example
Input
4
2
)(
4
()()
8
())()()(
10
)))((((())
Output
1
0
1
3
Note
In the first test case of the example, it is sufficient to move the first bracket to the end of the string.
In the third test case of the example, it is sufficient to move the last bracket to the beginning of the string.
In the fourth test case of the example, we can choose last three openning brackets, move them to the beginning of the string and obtain "((()))(())". | instruction | 0 | 65,026 | 21 | 130,052 |
Tags: greedy, strings
Correct Solution:
```
t=int(input())
while(t):
k=int(input())
n=input()
xopen=0
yclose=0
count=0
flag=0
prefix=[0]*k
for i in range(len(n)):
if(i==0):
if(n[i]=="("):
prefix[i]=-1
else:
prefix[i]=1
else:
if(n[i]=="("):
prefix[i]=prefix[i-1]-1
else:
prefix[i]=prefix[i-1]+1
print(max(prefix))
t=t-1
``` | output | 1 | 65,026 | 21 | 130,053 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a bracket sequence s of length n, where n is even (divisible by two). The string s consists of n/2 opening brackets '(' and n/2 closing brackets ')'.
In one move, you can choose exactly one bracket and move it to the beginning of the string or to the end of the string (i.e. you choose some index i, remove the i-th character of s and insert it before or after all remaining characters of s).
Your task is to find the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Recall what the regular bracket sequence is:
* "()" is regular bracket sequence;
* if s is regular bracket sequence then "(" + s + ")" is regular bracket sequence;
* if s and t are regular bracket sequences then s + t is regular bracket sequence.
For example, "()()", "(())()", "(())" and "()" are regular bracket sequences, but ")(", "()(" and ")))" are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2000) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 50) — the length of s. It is guaranteed that n is even. The second line of the test case containg the string s consisting of n/2 opening and n/2 closing brackets.
Output
For each test case, print the answer — the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Example
Input
4
2
)(
4
()()
8
())()()(
10
)))((((())
Output
1
0
1
3
Note
In the first test case of the example, it is sufficient to move the first bracket to the end of the string.
In the third test case of the example, it is sufficient to move the last bracket to the beginning of the string.
In the fourth test case of the example, we can choose last three openning brackets, move them to the beginning of the string and obtain "((()))(())". | instruction | 0 | 65,027 | 21 | 130,054 |
Tags: greedy, strings
Correct Solution:
```
import math
from sys import stdin
from collections import Counter,defaultdict,deque
input=stdin.readline
mod=pow(10,9)+7
def solve():
n=int(input())
s=input()
c=0
l1=[]
for i in range(n):
if(s[i]=="("):
l1.append(1)
else:
if(len(l1)==0):
c=c+1
else:
l1.pop()
print(c)
for _ in range(int(input())):
solve()
``` | output | 1 | 65,027 | 21 | 130,055 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a bracket sequence s of length n, where n is even (divisible by two). The string s consists of n/2 opening brackets '(' and n/2 closing brackets ')'.
In one move, you can choose exactly one bracket and move it to the beginning of the string or to the end of the string (i.e. you choose some index i, remove the i-th character of s and insert it before or after all remaining characters of s).
Your task is to find the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Recall what the regular bracket sequence is:
* "()" is regular bracket sequence;
* if s is regular bracket sequence then "(" + s + ")" is regular bracket sequence;
* if s and t are regular bracket sequences then s + t is regular bracket sequence.
For example, "()()", "(())()", "(())" and "()" are regular bracket sequences, but ")(", "()(" and ")))" are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2000) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 50) — the length of s. It is guaranteed that n is even. The second line of the test case containg the string s consisting of n/2 opening and n/2 closing brackets.
Output
For each test case, print the answer — the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Example
Input
4
2
)(
4
()()
8
())()()(
10
)))((((())
Output
1
0
1
3
Note
In the first test case of the example, it is sufficient to move the first bracket to the end of the string.
In the third test case of the example, it is sufficient to move the last bracket to the beginning of the string.
In the fourth test case of the example, we can choose last three openning brackets, move them to the beginning of the string and obtain "((()))(())". | instruction | 0 | 65,028 | 21 | 130,056 |
Tags: greedy, strings
Correct Solution:
```
import string
t = int(input())
for _ in range(t):
n = int(input())
s = input()
openn=0
close=0
wrong=0
for i in s:
if i=="(":
openn+=1
elif i==")":
close+=1
if close>openn:
wrong+=close-openn
openn=0
close=0
if close==openn:
openn=0
close=0
print(wrong)
``` | output | 1 | 65,028 | 21 | 130,057 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a bracket sequence s of length n, where n is even (divisible by two). The string s consists of n/2 opening brackets '(' and n/2 closing brackets ')'.
In one move, you can choose exactly one bracket and move it to the beginning of the string or to the end of the string (i.e. you choose some index i, remove the i-th character of s and insert it before or after all remaining characters of s).
Your task is to find the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Recall what the regular bracket sequence is:
* "()" is regular bracket sequence;
* if s is regular bracket sequence then "(" + s + ")" is regular bracket sequence;
* if s and t are regular bracket sequences then s + t is regular bracket sequence.
For example, "()()", "(())()", "(())" and "()" are regular bracket sequences, but ")(", "()(" and ")))" are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2000) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 50) — the length of s. It is guaranteed that n is even. The second line of the test case containg the string s consisting of n/2 opening and n/2 closing brackets.
Output
For each test case, print the answer — the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Example
Input
4
2
)(
4
()()
8
())()()(
10
)))((((())
Output
1
0
1
3
Note
In the first test case of the example, it is sufficient to move the first bracket to the end of the string.
In the third test case of the example, it is sufficient to move the last bracket to the beginning of the string.
In the fourth test case of the example, we can choose last three openning brackets, move them to the beginning of the string and obtain "((()))(())". | instruction | 0 | 65,029 | 21 | 130,058 |
Tags: greedy, strings
Correct Solution:
```
t = int(input())
for i in range(t):
n = int(input())
s = input()
suma = minimum = 0
for znak in s:
if znak == ')' and suma == 0:
minimum += 1
elif znak == '(':
suma += 1
elif znak == ')':
suma -= 1
print(minimum)
``` | output | 1 | 65,029 | 21 | 130,059 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a bracket sequence s of length n, where n is even (divisible by two). The string s consists of n/2 opening brackets '(' and n/2 closing brackets ')'.
In one move, you can choose exactly one bracket and move it to the beginning of the string or to the end of the string (i.e. you choose some index i, remove the i-th character of s and insert it before or after all remaining characters of s).
Your task is to find the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Recall what the regular bracket sequence is:
* "()" is regular bracket sequence;
* if s is regular bracket sequence then "(" + s + ")" is regular bracket sequence;
* if s and t are regular bracket sequences then s + t is regular bracket sequence.
For example, "()()", "(())()", "(())" and "()" are regular bracket sequences, but ")(", "()(" and ")))" are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2000) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 50) — the length of s. It is guaranteed that n is even. The second line of the test case containg the string s consisting of n/2 opening and n/2 closing brackets.
Output
For each test case, print the answer — the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Example
Input
4
2
)(
4
()()
8
())()()(
10
)))((((())
Output
1
0
1
3
Note
In the first test case of the example, it is sufficient to move the first bracket to the end of the string.
In the third test case of the example, it is sufficient to move the last bracket to the beginning of the string.
In the fourth test case of the example, we can choose last three openning brackets, move them to the beginning of the string and obtain "((()))(())". | instruction | 0 | 65,030 | 21 | 130,060 |
Tags: greedy, strings
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
s=input()
a="("
aa=0
b=")"
bb=0
for e in s:
if(aa>0 and e==b):
aa-=1
elif(e==a):
aa+=1
print(aa)
``` | output | 1 | 65,030 | 21 | 130,061 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a bracket sequence s of length n, where n is even (divisible by two). The string s consists of n/2 opening brackets '(' and n/2 closing brackets ')'.
In one move, you can choose exactly one bracket and move it to the beginning of the string or to the end of the string (i.e. you choose some index i, remove the i-th character of s and insert it before or after all remaining characters of s).
Your task is to find the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Recall what the regular bracket sequence is:
* "()" is regular bracket sequence;
* if s is regular bracket sequence then "(" + s + ")" is regular bracket sequence;
* if s and t are regular bracket sequences then s + t is regular bracket sequence.
For example, "()()", "(())()", "(())" and "()" are regular bracket sequences, but ")(", "()(" and ")))" are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2000) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 50) — the length of s. It is guaranteed that n is even. The second line of the test case containg the string s consisting of n/2 opening and n/2 closing brackets.
Output
For each test case, print the answer — the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Example
Input
4
2
)(
4
()()
8
())()()(
10
)))((((())
Output
1
0
1
3
Note
In the first test case of the example, it is sufficient to move the first bracket to the end of the string.
In the third test case of the example, it is sufficient to move the last bracket to the beginning of the string.
In the fourth test case of the example, we can choose last three openning brackets, move them to the beginning of the string and obtain "((()))(())".
Submitted Solution:
```
def f(x,k):
x1 = list(x)
i = 0
while i < len(x1) - 1:
if x1[i] == "(" and x1[i+1]==")":
x1.pop(i+1)
x1.pop(i)
i=0
else:
i += 1
print(len(x1)//2)
n = int(input())
for i in range(n):
k = int(input())
x = input()
f(x,k)
``` | instruction | 0 | 65,031 | 21 | 130,062 |
Yes | output | 1 | 65,031 | 21 | 130,063 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a bracket sequence s of length n, where n is even (divisible by two). The string s consists of n/2 opening brackets '(' and n/2 closing brackets ')'.
In one move, you can choose exactly one bracket and move it to the beginning of the string or to the end of the string (i.e. you choose some index i, remove the i-th character of s and insert it before or after all remaining characters of s).
Your task is to find the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Recall what the regular bracket sequence is:
* "()" is regular bracket sequence;
* if s is regular bracket sequence then "(" + s + ")" is regular bracket sequence;
* if s and t are regular bracket sequences then s + t is regular bracket sequence.
For example, "()()", "(())()", "(())" and "()" are regular bracket sequences, but ")(", "()(" and ")))" are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2000) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 50) — the length of s. It is guaranteed that n is even. The second line of the test case containg the string s consisting of n/2 opening and n/2 closing brackets.
Output
For each test case, print the answer — the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Example
Input
4
2
)(
4
()()
8
())()()(
10
)))((((())
Output
1
0
1
3
Note
In the first test case of the example, it is sufficient to move the first bracket to the end of the string.
In the third test case of the example, it is sufficient to move the last bracket to the beginning of the string.
In the fourth test case of the example, we can choose last three openning brackets, move them to the beginning of the string and obtain "((()))(())".
Submitted Solution:
```
import math, sys
from collections import defaultdict, Counter, deque
INF = float('inf')
def gcd(a, b):
while b:
a, b = b, a%b
return a
def isPrime(n):
if (n <= 1):
return False
i = 2
while i ** 2 <= n:
if n % i == 0:
return False
i += 1
return True
def primeFactors(n):
factors = []
i = 2
while i ** 2 <= n:
while n % i == 0:
factors.append(i)
n //= i
i += 1
if n > 1:
factors.append(n)
return factors
def vars():
return map(int, input().split())
def array():
return list(map(int, input().split()))
def main():
n = int(input())
stack = []
s = input()
for i in range(n):
if s[i] == '(':
stack.append('(')
elif stack and s[i] == ')':
stack.pop(-1)
if stack:
nc = len(stack)
print(nc)
else:
print(0)
if __name__ == "__main__":
t = int(input())
# t = 1
for _ in range(t):
main()
``` | instruction | 0 | 65,032 | 21 | 130,064 |
Yes | output | 1 | 65,032 | 21 | 130,065 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a bracket sequence s of length n, where n is even (divisible by two). The string s consists of n/2 opening brackets '(' and n/2 closing brackets ')'.
In one move, you can choose exactly one bracket and move it to the beginning of the string or to the end of the string (i.e. you choose some index i, remove the i-th character of s and insert it before or after all remaining characters of s).
Your task is to find the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Recall what the regular bracket sequence is:
* "()" is regular bracket sequence;
* if s is regular bracket sequence then "(" + s + ")" is regular bracket sequence;
* if s and t are regular bracket sequences then s + t is regular bracket sequence.
For example, "()()", "(())()", "(())" and "()" are regular bracket sequences, but ")(", "()(" and ")))" are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2000) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 50) — the length of s. It is guaranteed that n is even. The second line of the test case containg the string s consisting of n/2 opening and n/2 closing brackets.
Output
For each test case, print the answer — the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Example
Input
4
2
)(
4
()()
8
())()()(
10
)))((((())
Output
1
0
1
3
Note
In the first test case of the example, it is sufficient to move the first bracket to the end of the string.
In the third test case of the example, it is sufficient to move the last bracket to the beginning of the string.
In the fourth test case of the example, we can choose last three openning brackets, move them to the beginning of the string and obtain "((()))(())".
Submitted Solution:
```
t=int(input())
for _ in range(0,t):
n=int(input())
st=str(input())
ans=0
stack=[]
for i in range(0,len(st)):
if st[i]=='(':
stack.append(st[i])
else:
if len(stack)>0:
stack.pop()
else:
ans+=1
print(ans)
``` | instruction | 0 | 65,033 | 21 | 130,066 |
Yes | output | 1 | 65,033 | 21 | 130,067 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a bracket sequence s of length n, where n is even (divisible by two). The string s consists of n/2 opening brackets '(' and n/2 closing brackets ')'.
In one move, you can choose exactly one bracket and move it to the beginning of the string or to the end of the string (i.e. you choose some index i, remove the i-th character of s and insert it before or after all remaining characters of s).
Your task is to find the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Recall what the regular bracket sequence is:
* "()" is regular bracket sequence;
* if s is regular bracket sequence then "(" + s + ")" is regular bracket sequence;
* if s and t are regular bracket sequences then s + t is regular bracket sequence.
For example, "()()", "(())()", "(())" and "()" are regular bracket sequences, but ")(", "()(" and ")))" are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2000) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 50) — the length of s. It is guaranteed that n is even. The second line of the test case containg the string s consisting of n/2 opening and n/2 closing brackets.
Output
For each test case, print the answer — the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Example
Input
4
2
)(
4
()()
8
())()()(
10
)))((((())
Output
1
0
1
3
Note
In the first test case of the example, it is sufficient to move the first bracket to the end of the string.
In the third test case of the example, it is sufficient to move the last bracket to the beginning of the string.
In the fourth test case of the example, we can choose last three openning brackets, move them to the beginning of the string and obtain "((()))(())".
Submitted Solution:
```
from sys import stdin,stdout
from itertools import combinations
from collections import defaultdict,Counter
import math
def listIn():
return list((map(int,stdin.readline().strip().split())))
def stringListIn():
return([x for x in stdin.readline().split()])
def intIn():
return (int(stdin.readline()))
def stringIn():
return (stdin.readline().strip())
if __name__=="__main__":
t=intIn()
while(t>0):
t-=1
n=intIn()
bracket=input()
li=[]
for i in range(n):
if bracket[i]==')':
if len(li)>0:
if li[-1]=='(':
li.pop(-1)
else:
li.append(')')
else:
li.append(')')
else:
li.append('(')
print(len(li)//2)
``` | instruction | 0 | 65,034 | 21 | 130,068 |
Yes | output | 1 | 65,034 | 21 | 130,069 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a bracket sequence s of length n, where n is even (divisible by two). The string s consists of n/2 opening brackets '(' and n/2 closing brackets ')'.
In one move, you can choose exactly one bracket and move it to the beginning of the string or to the end of the string (i.e. you choose some index i, remove the i-th character of s and insert it before or after all remaining characters of s).
Your task is to find the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Recall what the regular bracket sequence is:
* "()" is regular bracket sequence;
* if s is regular bracket sequence then "(" + s + ")" is regular bracket sequence;
* if s and t are regular bracket sequences then s + t is regular bracket sequence.
For example, "()()", "(())()", "(())" and "()" are regular bracket sequences, but ")(", "()(" and ")))" are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2000) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 50) — the length of s. It is guaranteed that n is even. The second line of the test case containg the string s consisting of n/2 opening and n/2 closing brackets.
Output
For each test case, print the answer — the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Example
Input
4
2
)(
4
()()
8
())()()(
10
)))((((())
Output
1
0
1
3
Note
In the first test case of the example, it is sufficient to move the first bracket to the end of the string.
In the third test case of the example, it is sufficient to move the last bracket to the beginning of the string.
In the fourth test case of the example, we can choose last three openning brackets, move them to the beginning of the string and obtain "((()))(())".
Submitted Solution:
```
def regularbrakets(n, s):
lst = []
m = n//2
count1 = 0
count2 = 0
for i in range(m):
if s[i] == '(':
count1 += 1
elif s[i] == ')':
count2 += 1
if s[0] == ')' :
return count2
else:
return count1 - 1
t = int(input())
for _ in range(t):
n = int(input())
s = input()
print(regularbrakets(n, s))
``` | instruction | 0 | 65,035 | 21 | 130,070 |
No | output | 1 | 65,035 | 21 | 130,071 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a bracket sequence s of length n, where n is even (divisible by two). The string s consists of n/2 opening brackets '(' and n/2 closing brackets ')'.
In one move, you can choose exactly one bracket and move it to the beginning of the string or to the end of the string (i.e. you choose some index i, remove the i-th character of s and insert it before or after all remaining characters of s).
Your task is to find the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Recall what the regular bracket sequence is:
* "()" is regular bracket sequence;
* if s is regular bracket sequence then "(" + s + ")" is regular bracket sequence;
* if s and t are regular bracket sequences then s + t is regular bracket sequence.
For example, "()()", "(())()", "(())" and "()" are regular bracket sequences, but ")(", "()(" and ")))" are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2000) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 50) — the length of s. It is guaranteed that n is even. The second line of the test case containg the string s consisting of n/2 opening and n/2 closing brackets.
Output
For each test case, print the answer — the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Example
Input
4
2
)(
4
()()
8
())()()(
10
)))((((())
Output
1
0
1
3
Note
In the first test case of the example, it is sufficient to move the first bracket to the end of the string.
In the third test case of the example, it is sufficient to move the last bracket to the beginning of the string.
In the fourth test case of the example, we can choose last three openning brackets, move them to the beginning of the string and obtain "((()))(())".
Submitted Solution:
```
n = int(input())
for i in range(n):
count = 0
m = int(input())
x = input()
for j in range(m//2):
if x[j]==")":
count += 1
print(count)
``` | instruction | 0 | 65,036 | 21 | 130,072 |
No | output | 1 | 65,036 | 21 | 130,073 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a bracket sequence s of length n, where n is even (divisible by two). The string s consists of n/2 opening brackets '(' and n/2 closing brackets ')'.
In one move, you can choose exactly one bracket and move it to the beginning of the string or to the end of the string (i.e. you choose some index i, remove the i-th character of s and insert it before or after all remaining characters of s).
Your task is to find the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Recall what the regular bracket sequence is:
* "()" is regular bracket sequence;
* if s is regular bracket sequence then "(" + s + ")" is regular bracket sequence;
* if s and t are regular bracket sequences then s + t is regular bracket sequence.
For example, "()()", "(())()", "(())" and "()" are regular bracket sequences, but ")(", "()(" and ")))" are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2000) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 50) — the length of s. It is guaranteed that n is even. The second line of the test case containg the string s consisting of n/2 opening and n/2 closing brackets.
Output
For each test case, print the answer — the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Example
Input
4
2
)(
4
()()
8
())()()(
10
)))((((())
Output
1
0
1
3
Note
In the first test case of the example, it is sufficient to move the first bracket to the end of the string.
In the third test case of the example, it is sufficient to move the last bracket to the beginning of the string.
In the fourth test case of the example, we can choose last three openning brackets, move them to the beginning of the string and obtain "((()))(())".
Submitted Solution:
```
t=int(input())
while t!=0:
lst=[]
count=0
n=int(input())
s=input()
for i in range(n):
if s[i]=='(':
lst.append(-1)
else:
lst.append(1)
res=0
i=0
while i<n:
res+=lst[i]
if res<0:
lst.append(lst[i])
lst.pop(i)
count+=1
i-=1
res=0
i+=1
print(count)
t-=1
``` | instruction | 0 | 65,037 | 21 | 130,074 |
No | output | 1 | 65,037 | 21 | 130,075 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a bracket sequence s of length n, where n is even (divisible by two). The string s consists of n/2 opening brackets '(' and n/2 closing brackets ')'.
In one move, you can choose exactly one bracket and move it to the beginning of the string or to the end of the string (i.e. you choose some index i, remove the i-th character of s and insert it before or after all remaining characters of s).
Your task is to find the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Recall what the regular bracket sequence is:
* "()" is regular bracket sequence;
* if s is regular bracket sequence then "(" + s + ")" is regular bracket sequence;
* if s and t are regular bracket sequences then s + t is regular bracket sequence.
For example, "()()", "(())()", "(())" and "()" are regular bracket sequences, but ")(", "()(" and ")))" are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2000) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (2 ≤ n ≤ 50) — the length of s. It is guaranteed that n is even. The second line of the test case containg the string s consisting of n/2 opening and n/2 closing brackets.
Output
For each test case, print the answer — the minimum number of moves required to obtain regular bracket sequence from s. It can be proved that the answer always exists under the given constraints.
Example
Input
4
2
)(
4
()()
8
())()()(
10
)))((((())
Output
1
0
1
3
Note
In the first test case of the example, it is sufficient to move the first bracket to the end of the string.
In the third test case of the example, it is sufficient to move the last bracket to the beginning of the string.
In the fourth test case of the example, we can choose last three openning brackets, move them to the beginning of the string and obtain "((()))(())".
Submitted Solution:
```
import sys
input = sys.stdin.buffer.readline
def iinp() -> int: return int(input())
def linp() -> list: return [int(p) for p in input().split()]
def sinp() : return input().decode('unicode_escape')
# M = int(1e9 + 7)
for _ in range(iinp()):
n = iinp()
s = sinp()
sums, ans = 0, 0
for c in s:
if c == '(':
sums -= 1
else:
sums += 1
ans = max(ans, sums)
print(ans)
``` | instruction | 0 | 65,038 | 21 | 130,076 |
No | output | 1 | 65,038 | 21 | 130,077 |
Provide tags and a correct Python 3 solution for this coding contest problem.
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 "()()", "(())" are regular (the resulting expressions are: "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
You are given n bracket sequences s_1, s_2, ... , s_n. Calculate the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence. Operation + means concatenation i.e. "()(" + ")()" = "()()()".
If s_i + s_j and s_j + s_i are regular bracket sequences and i ≠ j, then both pairs (i, j) and (j, i) must be counted in the answer. Also, if s_i + s_i is a regular bracket sequence, the pair (i, i) must be counted in the answer.
Input
The first line contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of bracket sequences. The following n lines contain bracket sequences — non-empty strings consisting only of characters "(" and ")". The sum of lengths of all bracket sequences does not exceed 3 ⋅ 10^5.
Output
In the single line print a single integer — the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence.
Examples
Input
3
)
()
(
Output
2
Input
2
()
()
Output
4
Note
In the first example, suitable pairs are (3, 1) and (2, 2).
In the second example, any pair is suitable, namely (1, 1), (1, 2), (2, 1), (2, 2). | instruction | 0 | 65,395 | 21 | 130,790 |
Tags: implementation
Correct Solution:
```
def string_value(str):
ans=0
valid = True
neg=False
after_neg = 0
for char in str:
if char==")":
ans-=1
if after_neg>0:
after_neg-=1
else:
ans+=1
after_neg+=1
if ans<0:
neg = True
if (after_neg>0 and neg):
valid=False
return valid, ans
num = int(input())
vals = []
for i in range(num):
valid, ans = string_value(input())
if valid:
vals.append(ans)
ans=0
if len(vals)>0:
vals = sorted(vals)
prev=vals[0]
occured=1
occurances = {}
keys=[]
for i in vals[1:]:
if prev!=i:
keys.append(prev)
occurances[prev] = occured
occured = 1
prev=i
else:
occured += 1
occurances[prev] = occured
keys.append(prev)
j=0
k=len(keys)-1
while j<=k:
if -keys[j]==keys[k]:
ans+=occurances[keys[j]]*occurances[keys[k]]
if abs(keys[j])>abs(keys[k]):
j+=1
else:
k-=1
print(ans)
``` | output | 1 | 65,395 | 21 | 130,791 |
Provide tags and a correct Python 3 solution for this coding contest problem.
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 "()()", "(())" are regular (the resulting expressions are: "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
You are given n bracket sequences s_1, s_2, ... , s_n. Calculate the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence. Operation + means concatenation i.e. "()(" + ")()" = "()()()".
If s_i + s_j and s_j + s_i are regular bracket sequences and i ≠ j, then both pairs (i, j) and (j, i) must be counted in the answer. Also, if s_i + s_i is a regular bracket sequence, the pair (i, i) must be counted in the answer.
Input
The first line contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of bracket sequences. The following n lines contain bracket sequences — non-empty strings consisting only of characters "(" and ")". The sum of lengths of all bracket sequences does not exceed 3 ⋅ 10^5.
Output
In the single line print a single integer — the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence.
Examples
Input
3
)
()
(
Output
2
Input
2
()
()
Output
4
Note
In the first example, suitable pairs are (3, 1) and (2, 2).
In the second example, any pair is suitable, namely (1, 1), (1, 2), (2, 1), (2, 2). | instruction | 0 | 65,396 | 21 | 130,792 |
Tags: implementation
Correct Solution:
```
#!/usr/bin/env python3
from collections import defaultdict
def hd(s):
d, h = 0, 0
dmax = 0
for c in s:
if c == '(':
h += 1
d -= 1
else:
h -= 1
d += 1
dmax = max(d, dmax)
return h, dmax
n = int(input().strip())
h0 = 0
hp = defaultdict(int)
hm = defaultdict(int)
for _ in range(n):
s = input().strip()
h, d = hd(s)
if h == d == 0:
h0 += 1
elif h > 0 and d == 0:
hp[h] += 1
elif h < 0 and h + d <= 0:
hm[-h] += 1
res = h0 ** 2
for k, v in hp.items():
if k in hm:
res += v * hm[k]
print (res)
``` | output | 1 | 65,396 | 21 | 130,793 |
Provide tags and a correct Python 3 solution for this coding contest problem.
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 "()()", "(())" are regular (the resulting expressions are: "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
You are given n bracket sequences s_1, s_2, ... , s_n. Calculate the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence. Operation + means concatenation i.e. "()(" + ")()" = "()()()".
If s_i + s_j and s_j + s_i are regular bracket sequences and i ≠ j, then both pairs (i, j) and (j, i) must be counted in the answer. Also, if s_i + s_i is a regular bracket sequence, the pair (i, i) must be counted in the answer.
Input
The first line contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of bracket sequences. The following n lines contain bracket sequences — non-empty strings consisting only of characters "(" and ")". The sum of lengths of all bracket sequences does not exceed 3 ⋅ 10^5.
Output
In the single line print a single integer — the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence.
Examples
Input
3
)
()
(
Output
2
Input
2
()
()
Output
4
Note
In the first example, suitable pairs are (3, 1) and (2, 2).
In the second example, any pair is suitable, namely (1, 1), (1, 2), (2, 1), (2, 2). | instruction | 0 | 65,397 | 21 | 130,794 |
Tags: implementation
Correct Solution:
```
n=int(input())
openw=[0 for i in range(300001)]
closew=[0 for j in range(300001)]
reg=0
for i in range(n):
r=input()
c=0
o=0
e=1
for y in r:
if y==")":
c=c+1
else:
o=o+1
if c>o:
e=2
r1=r[::-1]
c1=0
o1=0
e1=0
for u in r1:
if u==")":
c1=c1+1
else:
o1=o1+1
if (o1>c1):
e1=1
if (o==c and e==1):
reg=reg+1
elif (o>c and e==1):
openw[o-c]=openw[o-c]+1
elif (o<c and e1==0):
closew[c-o]=closew[c-o]+1
else:
continue
ans=0
for j in range(0,300001):
ans=ans+closew[j]*openw[j]
ans=ans+reg**2
print (ans)
``` | output | 1 | 65,397 | 21 | 130,795 |
Provide tags and a correct Python 3 solution for this coding contest problem.
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 "()()", "(())" are regular (the resulting expressions are: "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
You are given n bracket sequences s_1, s_2, ... , s_n. Calculate the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence. Operation + means concatenation i.e. "()(" + ")()" = "()()()".
If s_i + s_j and s_j + s_i are regular bracket sequences and i ≠ j, then both pairs (i, j) and (j, i) must be counted in the answer. Also, if s_i + s_i is a regular bracket sequence, the pair (i, i) must be counted in the answer.
Input
The first line contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of bracket sequences. The following n lines contain bracket sequences — non-empty strings consisting only of characters "(" and ")". The sum of lengths of all bracket sequences does not exceed 3 ⋅ 10^5.
Output
In the single line print a single integer — the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence.
Examples
Input
3
)
()
(
Output
2
Input
2
()
()
Output
4
Note
In the first example, suitable pairs are (3, 1) and (2, 2).
In the second example, any pair is suitable, namely (1, 1), (1, 2), (2, 1), (2, 2). | instruction | 0 | 65,398 | 21 | 130,796 |
Tags: implementation
Correct Solution:
```
import configparser
import math
import sys
input = sys.stdin.readline
def f_close(str):
s = [str[0]]
for i in str[1:]:
if i == '(':
s.append('(')
else:
if len(s) == 0 or s[-1] == ')':
s.append(')')
else:
s.pop()
if len(s)==0:
return 0
elif s[-1] == '(':
return -1
else:
return len(s)
def f_op(str):
s = []
i = 0
while i < len(str):
if str[i] == '(':
s.append('(')
else:
if len(s)==0:
return -1
else:
s.pop()
i += 1
return len(s)
def main():
n = int(input())
bracks = []
for i in range(n):
bracks.append(input().strip())
op = [0 for i in range(300020)]
close = [0 for i in range(300200)]
for i in bracks:
opening_parity = f_op(i)
close_parity = f_close(i)
if opening_parity != -1:
op[opening_parity] += 1
if close_parity != -1:
close[close_parity] += 1
ans = 0
for i in range(len(op)):
ans += close[i]*op[i]
print(ans)
if __name__ == '__main__':
main()
``` | output | 1 | 65,398 | 21 | 130,797 |
Provide tags and a correct Python 3 solution for this coding contest problem.
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 "()()", "(())" are regular (the resulting expressions are: "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
You are given n bracket sequences s_1, s_2, ... , s_n. Calculate the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence. Operation + means concatenation i.e. "()(" + ")()" = "()()()".
If s_i + s_j and s_j + s_i are regular bracket sequences and i ≠ j, then both pairs (i, j) and (j, i) must be counted in the answer. Also, if s_i + s_i is a regular bracket sequence, the pair (i, i) must be counted in the answer.
Input
The first line contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of bracket sequences. The following n lines contain bracket sequences — non-empty strings consisting only of characters "(" and ")". The sum of lengths of all bracket sequences does not exceed 3 ⋅ 10^5.
Output
In the single line print a single integer — the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence.
Examples
Input
3
)
()
(
Output
2
Input
2
()
()
Output
4
Note
In the first example, suitable pairs are (3, 1) and (2, 2).
In the second example, any pair is suitable, namely (1, 1), (1, 2), (2, 1), (2, 2). | instruction | 0 | 65,399 | 21 | 130,798 |
Tags: implementation
Correct Solution:
```
#This code sucks, you know it and I know it.
#Move on and call me an idiot later.
def check(symbolString):
s = []
tcnt = 0
balanced = True
index = 0
while index < len(symbolString):
symbol = symbolString[index]
if symbol == "(":
s.append(symbol)
else:
if len(s) == 0:
balanced = False
tcnt += 1
else:
s.pop()
index = index + 1
if balanced and len(s) == 0:
return ("()", True)
else:
if len(s) > 0 and tcnt > 0:
return (")(", ")(")
else:
if len(s) > 0:
return ('(', len(s))
else:
return(')', tcnt)
n = int(input())
op = {}
cl = {}
b = 0
for i in range(n):
a = input()
x = check(a)
# print(x)
if x[0] == "()":
b += 1
elif x[0] == '(':
if x[1] in op:
op[x[1]] += 1
else:
op[x[1]] = 0
op[x[1]] += 1
else:
if x[1] in cl:
cl[x[1]] += 1
else:
cl[x[1]] = 0
cl[x[1]] += 1
b = b ** 2
for i in op:
if i in cl:
b += op[i] * cl[i]
print(b)
``` | output | 1 | 65,399 | 21 | 130,799 |
Provide tags and a correct Python 3 solution for this coding contest problem.
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 "()()", "(())" are regular (the resulting expressions are: "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
You are given n bracket sequences s_1, s_2, ... , s_n. Calculate the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence. Operation + means concatenation i.e. "()(" + ")()" = "()()()".
If s_i + s_j and s_j + s_i are regular bracket sequences and i ≠ j, then both pairs (i, j) and (j, i) must be counted in the answer. Also, if s_i + s_i is a regular bracket sequence, the pair (i, i) must be counted in the answer.
Input
The first line contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of bracket sequences. The following n lines contain bracket sequences — non-empty strings consisting only of characters "(" and ")". The sum of lengths of all bracket sequences does not exceed 3 ⋅ 10^5.
Output
In the single line print a single integer — the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence.
Examples
Input
3
)
()
(
Output
2
Input
2
()
()
Output
4
Note
In the first example, suitable pairs are (3, 1) and (2, 2).
In the second example, any pair is suitable, namely (1, 1), (1, 2), (2, 1), (2, 2). | instruction | 0 | 65,400 | 21 | 130,800 |
Tags: implementation
Correct Solution:
```
n = int(input())
arr = []
for i in range(n):
arr.append(input())
l ={}
r = {}
z=0
for i in arr:
s = 0
g = 0
for j in i:
if j =='(':
s+=1
else:
s-=1
if s <0:
g+=1
s=0
if s==0 and g==0:
z+=1
if s<=0 and g:
if g in r.keys():
r[g]+=1
else:
r[g]=1
if s>0 and g==0:
if s in l.keys():
l[s]+=1
else:
l[s]=1
res1 = z*z
for i in l.keys():
if i in r.keys():
res1+=l[i]*r[i]
print(res1)
``` | output | 1 | 65,400 | 21 | 130,801 |
Provide tags and a correct Python 3 solution for this coding contest problem.
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 "()()", "(())" are regular (the resulting expressions are: "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
You are given n bracket sequences s_1, s_2, ... , s_n. Calculate the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence. Operation + means concatenation i.e. "()(" + ")()" = "()()()".
If s_i + s_j and s_j + s_i are regular bracket sequences and i ≠ j, then both pairs (i, j) and (j, i) must be counted in the answer. Also, if s_i + s_i is a regular bracket sequence, the pair (i, i) must be counted in the answer.
Input
The first line contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of bracket sequences. The following n lines contain bracket sequences — non-empty strings consisting only of characters "(" and ")". The sum of lengths of all bracket sequences does not exceed 3 ⋅ 10^5.
Output
In the single line print a single integer — the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence.
Examples
Input
3
)
()
(
Output
2
Input
2
()
()
Output
4
Note
In the first example, suitable pairs are (3, 1) and (2, 2).
In the second example, any pair is suitable, namely (1, 1), (1, 2), (2, 1), (2, 2). | instruction | 0 | 65,401 | 21 | 130,802 |
Tags: implementation
Correct Solution:
```
n=int(input().strip())
c1=0
f={}
s={}
for i in range(n):
c=0
minm=1000000
st=input().strip()
for j in st:
if j=='(':
c+=1
else:
c-=1
minm=min(minm,c)
#maxm=max(maxm,c)
if(c==0 and minm>=0):
c1+=1
elif c<0 and minm==c:
if c in s:
s[c]+=1
else:
s[c]=1
elif c>0 and minm>=0:
if c in f:
f[c]+=1
else:
f[c]=1
c2=0
for i in f.keys():
if (-1*i) in s:
c2+=f[i]*s[(-1*i)]
print((c1*c1) + c2)
``` | output | 1 | 65,401 | 21 | 130,803 |
Provide tags and a correct Python 3 solution for this coding contest problem.
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 "()()", "(())" are regular (the resulting expressions are: "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
You are given n bracket sequences s_1, s_2, ... , s_n. Calculate the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence. Operation + means concatenation i.e. "()(" + ")()" = "()()()".
If s_i + s_j and s_j + s_i are regular bracket sequences and i ≠ j, then both pairs (i, j) and (j, i) must be counted in the answer. Also, if s_i + s_i is a regular bracket sequence, the pair (i, i) must be counted in the answer.
Input
The first line contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of bracket sequences. The following n lines contain bracket sequences — non-empty strings consisting only of characters "(" and ")". The sum of lengths of all bracket sequences does not exceed 3 ⋅ 10^5.
Output
In the single line print a single integer — the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence.
Examples
Input
3
)
()
(
Output
2
Input
2
()
()
Output
4
Note
In the first example, suitable pairs are (3, 1) and (2, 2).
In the second example, any pair is suitable, namely (1, 1), (1, 2), (2, 1), (2, 2). | instruction | 0 | 65,402 | 21 | 130,804 |
Tags: implementation
Correct Solution:
```
from collections import deque, defaultdict
remains = defaultdict(int)
N = int(input())
for _ in range(N):
line = input()
stack = deque()
for brace in line:
if len(stack) == 0 or (stack[-1] == ')' and brace == '(') or stack[-1] == brace:
stack.append(brace)
else:
stack.pop()
if not ('(' in stack and ')' in stack):
if len(stack) == 0:
remains[0] += 1
elif stack[0] == '(':
remains[len(stack)] += 1
else:
remains[-len(stack)] += 1
combinations = 0
for remaining in remains:
if remaining >= 0:
combinations += remains[remaining] * remains.get(-remaining, 0)
print(combinations)
``` | output | 1 | 65,402 | 21 | 130,805 |
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 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 "()()", "(())" are regular (the resulting expressions are: "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
You are given n bracket sequences s_1, s_2, ... , s_n. Calculate the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence. Operation + means concatenation i.e. "()(" + ")()" = "()()()".
If s_i + s_j and s_j + s_i are regular bracket sequences and i ≠ j, then both pairs (i, j) and (j, i) must be counted in the answer. Also, if s_i + s_i is a regular bracket sequence, the pair (i, i) must be counted in the answer.
Input
The first line contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of bracket sequences. The following n lines contain bracket sequences — non-empty strings consisting only of characters "(" and ")". The sum of lengths of all bracket sequences does not exceed 3 ⋅ 10^5.
Output
In the single line print a single integer — the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence.
Examples
Input
3
)
()
(
Output
2
Input
2
()
()
Output
4
Note
In the first example, suitable pairs are (3, 1) and (2, 2).
In the second example, any pair is suitable, namely (1, 1), (1, 2), (2, 1), (2, 2).
Submitted Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 998244353
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
n = I()
a = [S() for _ in range(n)]
d = collections.defaultdict(int)
for c in a:
k = 0
lk = 0
for t in c:
if t == ')':
k += 1
if lk < k:
lk = k
else:
k -= 1
k = 0
rk = 0
for t in c[::-1]:
if t == '(':
k += 1
if rk < k:
rk = k
else:
k -= 1
if lk > 0 and rk > 0:
continue
if lk == 0 and rk == 0:
d[0] += 1
if lk > 0:
d[-lk] += 1
if rk > 0:
d[rk] += 1
r = d[0] ** 2
for k in list(d.keys()):
if k <= 0:
continue
r += d[k] * d[-k]
return r
print(main())
``` | instruction | 0 | 65,403 | 21 | 130,806 |
Yes | output | 1 | 65,403 | 21 | 130,807 |
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 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 "()()", "(())" are regular (the resulting expressions are: "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
You are given n bracket sequences s_1, s_2, ... , s_n. Calculate the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence. Operation + means concatenation i.e. "()(" + ")()" = "()()()".
If s_i + s_j and s_j + s_i are regular bracket sequences and i ≠ j, then both pairs (i, j) and (j, i) must be counted in the answer. Also, if s_i + s_i is a regular bracket sequence, the pair (i, i) must be counted in the answer.
Input
The first line contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of bracket sequences. The following n lines contain bracket sequences — non-empty strings consisting only of characters "(" and ")". The sum of lengths of all bracket sequences does not exceed 3 ⋅ 10^5.
Output
In the single line print a single integer — the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence.
Examples
Input
3
)
()
(
Output
2
Input
2
()
()
Output
4
Note
In the first example, suitable pairs are (3, 1) and (2, 2).
In the second example, any pair is suitable, namely (1, 1), (1, 2), (2, 1), (2, 2).
Submitted Solution:
```
def reverse(st):
aux = ""
for x in range(len(st)-1,-1,-1):
aux = aux + st[x]
res = ""
for x in aux:
if x == '(':
res = res + ')'
else:
res = res + '('
return res
def balance(st):
b = 0
for x in st:
if x == '(':
b = b +1
else:
b = b-1
if b < 0:
return -1
return b
n = int(input())
words = []
count = [0 for x in range(0,3*100000 + 10)]
for x in range(0,n):
aux = input().strip()
words.append(aux)
for x in words:
res = balance(x)
if res != -1:
count[res] = count[res] + 1
result = 0
for x in words:
aux = reverse(x)
r = balance(aux)
if r != -1:
result = result + count[r]
print(result)
``` | instruction | 0 | 65,404 | 21 | 130,808 |
Yes | output | 1 | 65,404 | 21 | 130,809 |
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 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 "()()", "(())" are regular (the resulting expressions are: "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
You are given n bracket sequences s_1, s_2, ... , s_n. Calculate the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence. Operation + means concatenation i.e. "()(" + ")()" = "()()()".
If s_i + s_j and s_j + s_i are regular bracket sequences and i ≠ j, then both pairs (i, j) and (j, i) must be counted in the answer. Also, if s_i + s_i is a regular bracket sequence, the pair (i, i) must be counted in the answer.
Input
The first line contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of bracket sequences. The following n lines contain bracket sequences — non-empty strings consisting only of characters "(" and ")". The sum of lengths of all bracket sequences does not exceed 3 ⋅ 10^5.
Output
In the single line print a single integer — the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence.
Examples
Input
3
)
()
(
Output
2
Input
2
()
()
Output
4
Note
In the first example, suitable pairs are (3, 1) and (2, 2).
In the second example, any pair is suitable, namely (1, 1), (1, 2), (2, 1), (2, 2).
Submitted Solution:
```
import sys
n=int(input())
d=dict()
ans=0
a=[]
for j in range(n):
a.append(sys.stdin.readline().strip())
for j in range(n):
s=a[j]
o=0
c=0
for v in s:
if v==')':
if o>0:
o=o-1
else:
c=c+1
else:
o=o+1
#print(o,c)
if o>0 and c>0:
continue
elif o>0:
if o in d:
d[o]+=1
else:
d[o]=1
else:
if -c in d:
d[-c]+=1
else:
d[-c]=1
#print(d)
for v in d:
if v>0:
if -v in d:
ans=ans+(d[v]*d[-v])
if 0 in d:
ans+=(d[0]*d[0])
print(ans)
``` | instruction | 0 | 65,405 | 21 | 130,810 |
Yes | output | 1 | 65,405 | 21 | 130,811 |
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 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 "()()", "(())" are regular (the resulting expressions are: "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
You are given n bracket sequences s_1, s_2, ... , s_n. Calculate the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence. Operation + means concatenation i.e. "()(" + ")()" = "()()()".
If s_i + s_j and s_j + s_i are regular bracket sequences and i ≠ j, then both pairs (i, j) and (j, i) must be counted in the answer. Also, if s_i + s_i is a regular bracket sequence, the pair (i, i) must be counted in the answer.
Input
The first line contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of bracket sequences. The following n lines contain bracket sequences — non-empty strings consisting only of characters "(" and ")". The sum of lengths of all bracket sequences does not exceed 3 ⋅ 10^5.
Output
In the single line print a single integer — the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence.
Examples
Input
3
)
()
(
Output
2
Input
2
()
()
Output
4
Note
In the first example, suitable pairs are (3, 1) and (2, 2).
In the second example, any pair is suitable, namely (1, 1), (1, 2), (2, 1), (2, 2).
Submitted Solution:
```
from collections import defaultdict
from sys import stdin
input = stdin.readline
if __name__ == '__main__':
bs = defaultdict(lambda: 0)
for _ in range(int(input())):
s = list(map(lambda o: 1 if o == '(' else -1, input().strip()))
sm = sum(s)
dp = [s[0]]
for i in range(1, len(s)):
dp.append(s[i] + dp[-1])
ms = min(dp)
if ms < 0 and sm > ms:
continue
bs[sm] += 1
cnt = 0
for k, v in bs.items():
if k < 1 and -k in bs:
cnt += v * bs[-k]
print(cnt)
``` | instruction | 0 | 65,406 | 21 | 130,812 |
Yes | output | 1 | 65,406 | 21 | 130,813 |
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 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 "()()", "(())" are regular (the resulting expressions are: "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
You are given n bracket sequences s_1, s_2, ... , s_n. Calculate the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence. Operation + means concatenation i.e. "()(" + ")()" = "()()()".
If s_i + s_j and s_j + s_i are regular bracket sequences and i ≠ j, then both pairs (i, j) and (j, i) must be counted in the answer. Also, if s_i + s_i is a regular bracket sequence, the pair (i, i) must be counted in the answer.
Input
The first line contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of bracket sequences. The following n lines contain bracket sequences — non-empty strings consisting only of characters "(" and ")". The sum of lengths of all bracket sequences does not exceed 3 ⋅ 10^5.
Output
In the single line print a single integer — the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence.
Examples
Input
3
)
()
(
Output
2
Input
2
()
()
Output
4
Note
In the first example, suitable pairs are (3, 1) and (2, 2).
In the second example, any pair is suitable, namely (1, 1), (1, 2), (2, 1), (2, 2).
Submitted Solution:
```
import math
def parseS(s):
r = 0
was_negative = False
for k in s:
r += 1 if k == '(' else -1
if r < 0: was_negative = True
elif was_negative: return ''
return r
n = int(input())
s = []
for _ in range(n): s.append(list(input()))
a = [x for x in [parseS(seq) for seq in s] if x != '']
c = {}
for i, k in enumerate(a):
if k not in c: c[k] = 0
c[k] += 1
result = 0
for k in c:
count = c[k]
if k == 0: result += 1 if count == 1 else count * count * (count - 1)
elif k > 0 and -k in c: result += count * c[-k]
print(int(result))
# 7
# ()(
# )
# )(
# ())
# (((
# ()()()
# ()
# 9
# (()
# ((())
# (
# )
# (()()(()())))
# )
# )(()(
# )())(
# )()(
``` | instruction | 0 | 65,407 | 21 | 130,814 |
No | output | 1 | 65,407 | 21 | 130,815 |
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 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 "()()", "(())" are regular (the resulting expressions are: "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
You are given n bracket sequences s_1, s_2, ... , s_n. Calculate the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence. Operation + means concatenation i.e. "()(" + ")()" = "()()()".
If s_i + s_j and s_j + s_i are regular bracket sequences and i ≠ j, then both pairs (i, j) and (j, i) must be counted in the answer. Also, if s_i + s_i is a regular bracket sequence, the pair (i, i) must be counted in the answer.
Input
The first line contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of bracket sequences. The following n lines contain bracket sequences — non-empty strings consisting only of characters "(" and ")". The sum of lengths of all bracket sequences does not exceed 3 ⋅ 10^5.
Output
In the single line print a single integer — the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence.
Examples
Input
3
)
()
(
Output
2
Input
2
()
()
Output
4
Note
In the first example, suitable pairs are (3, 1) and (2, 2).
In the second example, any pair is suitable, namely (1, 1), (1, 2), (2, 1), (2, 2).
Submitted Solution:
```
n=int(input())
dict1={}
for i in range(n):
s=str(input())
x=0
y=0
z=0
for j in s:
if(j=='('):
x+=1
z+=1
else:
y+=1
z-=1
try:
dict1[z]+=1
except:
KeyError
dict1[z]=1
ans=0
for i in dict1:
if(i>=0):
try:
if(i==0):
ans+=dict1[0]+(dict1[0]*(dict1[0]-1))
else:
ans+=(dict1[i]*dict1[-i])
except:
KeyError
print(ans)
``` | instruction | 0 | 65,408 | 21 | 130,816 |
No | output | 1 | 65,408 | 21 | 130,817 |
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 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 "()()", "(())" are regular (the resulting expressions are: "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
You are given n bracket sequences s_1, s_2, ... , s_n. Calculate the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence. Operation + means concatenation i.e. "()(" + ")()" = "()()()".
If s_i + s_j and s_j + s_i are regular bracket sequences and i ≠ j, then both pairs (i, j) and (j, i) must be counted in the answer. Also, if s_i + s_i is a regular bracket sequence, the pair (i, i) must be counted in the answer.
Input
The first line contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of bracket sequences. The following n lines contain bracket sequences — non-empty strings consisting only of characters "(" and ")". The sum of lengths of all bracket sequences does not exceed 3 ⋅ 10^5.
Output
In the single line print a single integer — the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence.
Examples
Input
3
)
()
(
Output
2
Input
2
()
()
Output
4
Note
In the first example, suitable pairs are (3, 1) and (2, 2).
In the second example, any pair is suitable, namely (1, 1), (1, 2), (2, 1), (2, 2).
Submitted Solution:
```
__file__ = __file__.startswith('/home/a_farazei')
def input_():
global __file__
if not __file__:
return input()
if not hasattr(__file__, 'readline'):
__file__ = open('input.txt', 'r')
return __file__.readline()
from collections import defaultdict
n = int(input_())
d = defaultdict(lambda: 0)
for _ in range(n):
s = input_().strip()
t = 0
for x in s:
if x == '(':
t += 1
else:
t -= 1
if s[0] == ')' and s[-1] == '(':
pass
else:
d[t] += 1
ans = 0
for k in d.keys():
if k >= 0:
ans += d.get(k, 0) * d.get(-k, 0)
print(ans)
``` | instruction | 0 | 65,409 | 21 | 130,818 |
No | output | 1 | 65,409 | 21 | 130,819 |
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 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 "()()", "(())" are regular (the resulting expressions are: "(1)+(1)", "((1+1)+1)"), and ")(" and "(" are not.
You are given n bracket sequences s_1, s_2, ... , s_n. Calculate the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence. Operation + means concatenation i.e. "()(" + ")()" = "()()()".
If s_i + s_j and s_j + s_i are regular bracket sequences and i ≠ j, then both pairs (i, j) and (j, i) must be counted in the answer. Also, if s_i + s_i is a regular bracket sequence, the pair (i, i) must be counted in the answer.
Input
The first line contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5) — the number of bracket sequences. The following n lines contain bracket sequences — non-empty strings consisting only of characters "(" and ")". The sum of lengths of all bracket sequences does not exceed 3 ⋅ 10^5.
Output
In the single line print a single integer — the number of pairs i, j (1 ≤ i, j ≤ n) such that the bracket sequence s_i + s_j is a regular bracket sequence.
Examples
Input
3
)
()
(
Output
2
Input
2
()
()
Output
4
Note
In the first example, suitable pairs are (3, 1) and (2, 2).
In the second example, any pair is suitable, namely (1, 1), (1, 2), (2, 1), (2, 2).
Submitted Solution:
```
def check(a):
os=[]
o=0
p=0
n=len(a)
for i in a:
if i==')':
o+=1
else:
break
if o>0:
os.append(o)
for j in range(n-1,-1,-1):
if a[j]=='(':
p+=1
else:
break
if p>0:
os.append(-p)
re=0
h=0
for j in a:
if j=='(':
re+=1
else:
re-=1
if len(os)==0:
os.append(re)
if len(os)==1:
return os
else:
return []
per=0
final=0
u={}
for i in range(int(input())):
t= input()
res = check(t)
#print(res, i)
if len(res)>0:
for j in res:
if j==0:
per+=1
else:
if j not in u:
u[j]=1
else:
u[j]+=1
for j in u.keys():
if -j in u:
final+= u[j]*u[-j]
print(final//2+ per + per*(per-1))
``` | instruction | 0 | 65,410 | 21 | 130,820 |
No | output | 1 | 65,410 | 21 | 130,821 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A bracketed sequence is called correct (regular) if by inserting "+" and "1" you can get a well-formed mathematical expression from it. For example, sequences "(())()", "()" and "(()(()))" are correct, while ")(", "(()" and "(()))(" are not.
The teacher gave Dmitry's class a very strange task — she asked every student to come up with a sequence of arbitrary length, consisting only of opening and closing brackets. After that all the students took turns naming the sequences they had invented. When Dima's turn came, he suddenly realized that all his classmates got the correct bracketed sequence, and whether he got the correct bracketed sequence, he did not know.
Dima suspects now that he simply missed the word "correct" in the task statement, so now he wants to save the situation by modifying his sequence slightly. More precisely, he can the arbitrary number of times (possibly zero) perform the reorder operation.
The reorder operation consists of choosing an arbitrary consecutive subsegment (substring) of the sequence and then reordering all the characters in it in an arbitrary way. Such operation takes l nanoseconds, where l is the length of the subsegment being reordered. It's easy to see that reorder operation doesn't change the number of opening and closing brackets. For example for "))((" he can choose the substring ")(" and do reorder ")()(" (this operation will take 2 nanoseconds).
Since Dima will soon have to answer, he wants to make his sequence correct as fast as possible. Help him to do this, or determine that it's impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of Dima's sequence.
The second line contains string of length n, consisting of characters "(" and ")" only.
Output
Print a single integer — the minimum number of nanoseconds to make the sequence correct or "-1" if it is impossible to do so.
Examples
Input
8
))((())(
Output
6
Input
3
(()
Output
-1
Note
In the first example we can firstly reorder the segment from first to the fourth character, replacing it with "()()", the whole sequence will be "()()())(". And then reorder the segment from the seventh to eighth character, replacing it with "()". In the end the sequence will be "()()()()", while the total time spent is 4 + 2 = 6 nanoseconds. | instruction | 0 | 67,426 | 21 | 134,852 |
Tags: greedy
Correct Solution:
```
n = int(input())
s = str(input())
res,bf = 0,0
flag=True
if(n%2!=0):
print("-1")
else:
for i in range(n):
if(s[i] == ')'):
bf = bf-1
else:
bf =bf+ 1
if bf == 0:
res= res+1
flag=False
if(bf<0):
res=res+1
if(bf==0):
print(res)
else:
print("-1")
``` | output | 1 | 67,426 | 21 | 134,853 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A bracketed sequence is called correct (regular) if by inserting "+" and "1" you can get a well-formed mathematical expression from it. For example, sequences "(())()", "()" and "(()(()))" are correct, while ")(", "(()" and "(()))(" are not.
The teacher gave Dmitry's class a very strange task — she asked every student to come up with a sequence of arbitrary length, consisting only of opening and closing brackets. After that all the students took turns naming the sequences they had invented. When Dima's turn came, he suddenly realized that all his classmates got the correct bracketed sequence, and whether he got the correct bracketed sequence, he did not know.
Dima suspects now that he simply missed the word "correct" in the task statement, so now he wants to save the situation by modifying his sequence slightly. More precisely, he can the arbitrary number of times (possibly zero) perform the reorder operation.
The reorder operation consists of choosing an arbitrary consecutive subsegment (substring) of the sequence and then reordering all the characters in it in an arbitrary way. Such operation takes l nanoseconds, where l is the length of the subsegment being reordered. It's easy to see that reorder operation doesn't change the number of opening and closing brackets. For example for "))((" he can choose the substring ")(" and do reorder ")()(" (this operation will take 2 nanoseconds).
Since Dima will soon have to answer, he wants to make his sequence correct as fast as possible. Help him to do this, or determine that it's impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of Dima's sequence.
The second line contains string of length n, consisting of characters "(" and ")" only.
Output
Print a single integer — the minimum number of nanoseconds to make the sequence correct or "-1" if it is impossible to do so.
Examples
Input
8
))((())(
Output
6
Input
3
(()
Output
-1
Note
In the first example we can firstly reorder the segment from first to the fourth character, replacing it with "()()", the whole sequence will be "()()())(". And then reorder the segment from the seventh to eighth character, replacing it with "()". In the end the sequence will be "()()()()", while the total time spent is 4 + 2 = 6 nanoseconds. | instruction | 0 | 67,427 | 21 | 134,854 |
Tags: greedy
Correct Solution:
```
'''
Auther: ghoshashis545 Ashis Ghosh
college: jalpaiguri Govt Enggineering College
Date:07/03/2020
'''
from math import ceil,sqrt,gcd,log,floor
from collections import deque
def ii(): return int(input())
def si(): return input()
def mi(): return map(int,input().strip().split(" "))
def li(): return list(mi())
def msi(): return map(str,input().strip().split(" "))
def lsi(): return list(msi())
#for _ in range(ii()):
n=ii()
s=si()
ans=0
c=0
prev=0
q=[]
for i in range(n):
if(s[i]==')'):
if(len(q)!=0):
if(q[len(q)-1]=='('):
q.pop()
else:
q.append(')')
else:
q.append(')')
else:
if(len(q)!=0):
if(q[len(q)-1]=='('):
q.append('(')
else:
q.pop()
ans+=2
else:
q.append('(')
if(len(q)):
print('-1')
else:
print(ans)
``` | output | 1 | 67,427 | 21 | 134,855 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A bracketed sequence is called correct (regular) if by inserting "+" and "1" you can get a well-formed mathematical expression from it. For example, sequences "(())()", "()" and "(()(()))" are correct, while ")(", "(()" and "(()))(" are not.
The teacher gave Dmitry's class a very strange task — she asked every student to come up with a sequence of arbitrary length, consisting only of opening and closing brackets. After that all the students took turns naming the sequences they had invented. When Dima's turn came, he suddenly realized that all his classmates got the correct bracketed sequence, and whether he got the correct bracketed sequence, he did not know.
Dima suspects now that he simply missed the word "correct" in the task statement, so now he wants to save the situation by modifying his sequence slightly. More precisely, he can the arbitrary number of times (possibly zero) perform the reorder operation.
The reorder operation consists of choosing an arbitrary consecutive subsegment (substring) of the sequence and then reordering all the characters in it in an arbitrary way. Such operation takes l nanoseconds, where l is the length of the subsegment being reordered. It's easy to see that reorder operation doesn't change the number of opening and closing brackets. For example for "))((" he can choose the substring ")(" and do reorder ")()(" (this operation will take 2 nanoseconds).
Since Dima will soon have to answer, he wants to make his sequence correct as fast as possible. Help him to do this, or determine that it's impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of Dima's sequence.
The second line contains string of length n, consisting of characters "(" and ")" only.
Output
Print a single integer — the minimum number of nanoseconds to make the sequence correct or "-1" if it is impossible to do so.
Examples
Input
8
))((())(
Output
6
Input
3
(()
Output
-1
Note
In the first example we can firstly reorder the segment from first to the fourth character, replacing it with "()()", the whole sequence will be "()()())(". And then reorder the segment from the seventh to eighth character, replacing it with "()". In the end the sequence will be "()()()()", while the total time spent is 4 + 2 = 6 nanoseconds. | instruction | 0 | 67,428 | 21 | 134,856 |
Tags: greedy
Correct Solution:
```
n = int(input())
s = input()
cnt = 0
flag = 0
ans = 0
pre = 0
i = 1
for c in s:
if c == '(':
cnt += 1
else:
cnt -= 1
if cnt == 0 and c == '(':
ans += i-pre+1
if cnt == -1 and c == ')':
pre = i
i += 1
if cnt == 0:
print(ans)
else:
print(-1)
``` | output | 1 | 67,428 | 21 | 134,857 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A bracketed sequence is called correct (regular) if by inserting "+" and "1" you can get a well-formed mathematical expression from it. For example, sequences "(())()", "()" and "(()(()))" are correct, while ")(", "(()" and "(()))(" are not.
The teacher gave Dmitry's class a very strange task — she asked every student to come up with a sequence of arbitrary length, consisting only of opening and closing brackets. After that all the students took turns naming the sequences they had invented. When Dima's turn came, he suddenly realized that all his classmates got the correct bracketed sequence, and whether he got the correct bracketed sequence, he did not know.
Dima suspects now that he simply missed the word "correct" in the task statement, so now he wants to save the situation by modifying his sequence slightly. More precisely, he can the arbitrary number of times (possibly zero) perform the reorder operation.
The reorder operation consists of choosing an arbitrary consecutive subsegment (substring) of the sequence and then reordering all the characters in it in an arbitrary way. Such operation takes l nanoseconds, where l is the length of the subsegment being reordered. It's easy to see that reorder operation doesn't change the number of opening and closing brackets. For example for "))((" he can choose the substring ")(" and do reorder ")()(" (this operation will take 2 nanoseconds).
Since Dima will soon have to answer, he wants to make his sequence correct as fast as possible. Help him to do this, or determine that it's impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of Dima's sequence.
The second line contains string of length n, consisting of characters "(" and ")" only.
Output
Print a single integer — the minimum number of nanoseconds to make the sequence correct or "-1" if it is impossible to do so.
Examples
Input
8
))((())(
Output
6
Input
3
(()
Output
-1
Note
In the first example we can firstly reorder the segment from first to the fourth character, replacing it with "()()", the whole sequence will be "()()())(". And then reorder the segment from the seventh to eighth character, replacing it with "()". In the end the sequence will be "()()()()", while the total time spent is 4 + 2 = 6 nanoseconds. | instruction | 0 | 67,429 | 21 | 134,858 |
Tags: greedy
Correct Solution:
```
a=int(input())
b=input()
op=b.count("(")
cl=a-op
if op!=cl :
print (-1)
else :
closrn=0
oprn=0
flag=0
tot=0
for i in range (a) :
if b[i]=="(" :
oprn=oprn+1
else :
closrn=closrn+1
if closrn>oprn and flag!=1 :
start=i
#print ("start",i)
flag=1
if flag==1 and closrn==oprn :
#print ("end",i)
tot=tot+i-start+1
flag=0
print (tot)
``` | output | 1 | 67,429 | 21 | 134,859 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A bracketed sequence is called correct (regular) if by inserting "+" and "1" you can get a well-formed mathematical expression from it. For example, sequences "(())()", "()" and "(()(()))" are correct, while ")(", "(()" and "(()))(" are not.
The teacher gave Dmitry's class a very strange task — she asked every student to come up with a sequence of arbitrary length, consisting only of opening and closing brackets. After that all the students took turns naming the sequences they had invented. When Dima's turn came, he suddenly realized that all his classmates got the correct bracketed sequence, and whether he got the correct bracketed sequence, he did not know.
Dima suspects now that he simply missed the word "correct" in the task statement, so now he wants to save the situation by modifying his sequence slightly. More precisely, he can the arbitrary number of times (possibly zero) perform the reorder operation.
The reorder operation consists of choosing an arbitrary consecutive subsegment (substring) of the sequence and then reordering all the characters in it in an arbitrary way. Such operation takes l nanoseconds, where l is the length of the subsegment being reordered. It's easy to see that reorder operation doesn't change the number of opening and closing brackets. For example for "))((" he can choose the substring ")(" and do reorder ")()(" (this operation will take 2 nanoseconds).
Since Dima will soon have to answer, he wants to make his sequence correct as fast as possible. Help him to do this, or determine that it's impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of Dima's sequence.
The second line contains string of length n, consisting of characters "(" and ")" only.
Output
Print a single integer — the minimum number of nanoseconds to make the sequence correct or "-1" if it is impossible to do so.
Examples
Input
8
))((())(
Output
6
Input
3
(()
Output
-1
Note
In the first example we can firstly reorder the segment from first to the fourth character, replacing it with "()()", the whole sequence will be "()()())(". And then reorder the segment from the seventh to eighth character, replacing it with "()". In the end the sequence will be "()()()()", while the total time spent is 4 + 2 = 6 nanoseconds. | instruction | 0 | 67,430 | 21 | 134,860 |
Tags: greedy
Correct Solution:
```
def balance(list):
if(len(list)%2==1):
return False
temp=[]
for i in list:
if(i=='('):
temp.append('(')
else:
if(len(temp)==0):
return False
temp.pop(-1)
return len(temp)==0
def func(inp,n):
open,close=0,0
ans=0
list=[]
prev=0
for i in range(n):
if(inp[i]=='('):
open+=1
elif(inp[i]==')'):
close+=1
if(open==close):
open=0
close=0
list.append(inp[prev:i+1])
prev=i+1
for i in list:
if(not balance(i)):
ans+=len(i)
return ans
t=int(input())
inp=input()
count=0
for i in inp:
if(i=='('):
count+=1
else:
count-=1
if(count!=0):
print(-1)
else:
print(func(inp,t))
``` | output | 1 | 67,430 | 21 | 134,861 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A bracketed sequence is called correct (regular) if by inserting "+" and "1" you can get a well-formed mathematical expression from it. For example, sequences "(())()", "()" and "(()(()))" are correct, while ")(", "(()" and "(()))(" are not.
The teacher gave Dmitry's class a very strange task — she asked every student to come up with a sequence of arbitrary length, consisting only of opening and closing brackets. After that all the students took turns naming the sequences they had invented. When Dima's turn came, he suddenly realized that all his classmates got the correct bracketed sequence, and whether he got the correct bracketed sequence, he did not know.
Dima suspects now that he simply missed the word "correct" in the task statement, so now he wants to save the situation by modifying his sequence slightly. More precisely, he can the arbitrary number of times (possibly zero) perform the reorder operation.
The reorder operation consists of choosing an arbitrary consecutive subsegment (substring) of the sequence and then reordering all the characters in it in an arbitrary way. Such operation takes l nanoseconds, where l is the length of the subsegment being reordered. It's easy to see that reorder operation doesn't change the number of opening and closing brackets. For example for "))((" he can choose the substring ")(" and do reorder ")()(" (this operation will take 2 nanoseconds).
Since Dima will soon have to answer, he wants to make his sequence correct as fast as possible. Help him to do this, or determine that it's impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of Dima's sequence.
The second line contains string of length n, consisting of characters "(" and ")" only.
Output
Print a single integer — the minimum number of nanoseconds to make the sequence correct or "-1" if it is impossible to do so.
Examples
Input
8
))((())(
Output
6
Input
3
(()
Output
-1
Note
In the first example we can firstly reorder the segment from first to the fourth character, replacing it with "()()", the whole sequence will be "()()())(". And then reorder the segment from the seventh to eighth character, replacing it with "()". In the end the sequence will be "()()()()", while the total time spent is 4 + 2 = 6 nanoseconds. | instruction | 0 | 67,431 | 21 | 134,862 |
Tags: greedy
Correct Solution:
```
# (())
def solve(n, s):
i = 0
ans = 0
while i < n:
cnt = s[i]
j = i + 1
while j < n and cnt != 0:
cnt += s[j]
j += 1
if s[i] == -1:
ans += j - i
i = j
return ans
def main():
n = int(input())
s = [1 if x == '(' else -1 for x in input()]
if sum(s) != 0:
print(-1)
else:
print(solve(n, s))
if __name__ == '__main__':
main()
``` | output | 1 | 67,431 | 21 | 134,863 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A bracketed sequence is called correct (regular) if by inserting "+" and "1" you can get a well-formed mathematical expression from it. For example, sequences "(())()", "()" and "(()(()))" are correct, while ")(", "(()" and "(()))(" are not.
The teacher gave Dmitry's class a very strange task — she asked every student to come up with a sequence of arbitrary length, consisting only of opening and closing brackets. After that all the students took turns naming the sequences they had invented. When Dima's turn came, he suddenly realized that all his classmates got the correct bracketed sequence, and whether he got the correct bracketed sequence, he did not know.
Dima suspects now that he simply missed the word "correct" in the task statement, so now he wants to save the situation by modifying his sequence slightly. More precisely, he can the arbitrary number of times (possibly zero) perform the reorder operation.
The reorder operation consists of choosing an arbitrary consecutive subsegment (substring) of the sequence and then reordering all the characters in it in an arbitrary way. Such operation takes l nanoseconds, where l is the length of the subsegment being reordered. It's easy to see that reorder operation doesn't change the number of opening and closing brackets. For example for "))((" he can choose the substring ")(" and do reorder ")()(" (this operation will take 2 nanoseconds).
Since Dima will soon have to answer, he wants to make his sequence correct as fast as possible. Help him to do this, or determine that it's impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of Dima's sequence.
The second line contains string of length n, consisting of characters "(" and ")" only.
Output
Print a single integer — the minimum number of nanoseconds to make the sequence correct or "-1" if it is impossible to do so.
Examples
Input
8
))((())(
Output
6
Input
3
(()
Output
-1
Note
In the first example we can firstly reorder the segment from first to the fourth character, replacing it with "()()", the whole sequence will be "()()())(". And then reorder the segment from the seventh to eighth character, replacing it with "()". In the end the sequence will be "()()()()", while the total time spent is 4 + 2 = 6 nanoseconds. | instruction | 0 | 67,432 | 21 | 134,864 |
Tags: greedy
Correct Solution:
```
n, s, be, ans, l, r = int(input()), input(), 0, 0, 0, 0
if s.count('(') != s.count(')'):
exit(print(-1))
for j, i in enumerate(s):
if i == '(':
l += 1
else:
if l:
l -= 1
else:
r += 1
if l == r:
if l:
ans += j - be + 1
l = r = 0
be = j + 1
print(ans)
``` | output | 1 | 67,432 | 21 | 134,865 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A bracketed sequence is called correct (regular) if by inserting "+" and "1" you can get a well-formed mathematical expression from it. For example, sequences "(())()", "()" and "(()(()))" are correct, while ")(", "(()" and "(()))(" are not.
The teacher gave Dmitry's class a very strange task — she asked every student to come up with a sequence of arbitrary length, consisting only of opening and closing brackets. After that all the students took turns naming the sequences they had invented. When Dima's turn came, he suddenly realized that all his classmates got the correct bracketed sequence, and whether he got the correct bracketed sequence, he did not know.
Dima suspects now that he simply missed the word "correct" in the task statement, so now he wants to save the situation by modifying his sequence slightly. More precisely, he can the arbitrary number of times (possibly zero) perform the reorder operation.
The reorder operation consists of choosing an arbitrary consecutive subsegment (substring) of the sequence and then reordering all the characters in it in an arbitrary way. Such operation takes l nanoseconds, where l is the length of the subsegment being reordered. It's easy to see that reorder operation doesn't change the number of opening and closing brackets. For example for "))((" he can choose the substring ")(" and do reorder ")()(" (this operation will take 2 nanoseconds).
Since Dima will soon have to answer, he wants to make his sequence correct as fast as possible. Help him to do this, or determine that it's impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of Dima's sequence.
The second line contains string of length n, consisting of characters "(" and ")" only.
Output
Print a single integer — the minimum number of nanoseconds to make the sequence correct or "-1" if it is impossible to do so.
Examples
Input
8
))((())(
Output
6
Input
3
(()
Output
-1
Note
In the first example we can firstly reorder the segment from first to the fourth character, replacing it with "()()", the whole sequence will be "()()())(". And then reorder the segment from the seventh to eighth character, replacing it with "()". In the end the sequence will be "()()()()", while the total time spent is 4 + 2 = 6 nanoseconds. | instruction | 0 | 67,433 | 21 | 134,866 |
Tags: greedy
Correct Solution:
```
n=int(input())
l=list(input())
if n%2!=0:
print(-1)
else:
count=0
brack=0
for i in range(n):
if l[i]=='(':
brack+=1
else:
brack-=1
if brack<0:
count+=2
if brack!=0:
print(-1)
else:
print(count)
``` | output | 1 | 67,433 | 21 | 134,867 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A bracketed sequence is called correct (regular) if by inserting "+" and "1" you can get a well-formed mathematical expression from it. For example, sequences "(())()", "()" and "(()(()))" are correct, while ")(", "(()" and "(()))(" are not.
The teacher gave Dmitry's class a very strange task — she asked every student to come up with a sequence of arbitrary length, consisting only of opening and closing brackets. After that all the students took turns naming the sequences they had invented. When Dima's turn came, he suddenly realized that all his classmates got the correct bracketed sequence, and whether he got the correct bracketed sequence, he did not know.
Dima suspects now that he simply missed the word "correct" in the task statement, so now he wants to save the situation by modifying his sequence slightly. More precisely, he can the arbitrary number of times (possibly zero) perform the reorder operation.
The reorder operation consists of choosing an arbitrary consecutive subsegment (substring) of the sequence and then reordering all the characters in it in an arbitrary way. Such operation takes l nanoseconds, where l is the length of the subsegment being reordered. It's easy to see that reorder operation doesn't change the number of opening and closing brackets. For example for "))((" he can choose the substring ")(" and do reorder ")()(" (this operation will take 2 nanoseconds).
Since Dima will soon have to answer, he wants to make his sequence correct as fast as possible. Help him to do this, or determine that it's impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^6) — the length of Dima's sequence.
The second line contains string of length n, consisting of characters "(" and ")" only.
Output
Print a single integer — the minimum number of nanoseconds to make the sequence correct or "-1" if it is impossible to do so.
Examples
Input
8
))((())(
Output
6
Input
3
(()
Output
-1
Note
In the first example we can firstly reorder the segment from first to the fourth character, replacing it with "()()", the whole sequence will be "()()())(". And then reorder the segment from the seventh to eighth character, replacing it with "()". In the end the sequence will be "()()()()", while the total time spent is 4 + 2 = 6 nanoseconds.
Submitted Solution:
```
n = int(input())
s = input()
t = 0
r = 0
cs = 0
for i, c in enumerate(s):
if c == '(':
t += 1
else:
t -= 1
if t < 0:
cs += 1
elif t == 0 and cs > 0:
r += cs + 1
cs = 0
#print(t, cs, r)
#print("---")
if t != 0:
print(-1)
else:
print(r)
``` | instruction | 0 | 67,434 | 21 | 134,868 |
Yes | output | 1 | 67,434 | 21 | 134,869 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.