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.
As you probably know, Anton goes to school. One of the school subjects that Anton studies is Bracketology. On the Bracketology lessons students usually learn different sequences that consist of round brackets (characters "(" and ")" (without quotes)).
On the last lesson Anton learned about the regular simple bracket sequences (RSBS). A bracket sequence s of length n is an RSBS if the following conditions are met:
* It is not empty (that is n ≠ 0).
* The length of the sequence is even.
* First <image> charactes of the sequence are equal to "(".
* Last <image> charactes of the sequence are equal to ")".
For example, the sequence "((()))" is an RSBS but the sequences "((())" and "(()())" are not RSBS.
Elena Ivanovna, Anton's teacher, gave him the following task as a homework. Given a bracket sequence s. Find the number of its distinct subsequences such that they are RSBS. Note that a subsequence of s is a string that can be obtained from s by deleting some of its elements. Two subsequences are considered distinct if distinct sets of positions are deleted.
Because the answer can be very big and Anton's teacher doesn't like big numbers, she asks Anton to find the answer modulo 109 + 7.
Anton thought of this task for a very long time, but he still doesn't know how to solve it. Help Anton to solve this task and write a program that finds the answer for it!
Input
The only line of the input contains a string s — the bracket sequence given in Anton's homework. The string consists only of characters "(" and ")" (without quotes). It's guaranteed that the string is not empty and its length doesn't exceed 200 000.
Output
Output one number — the answer for the task modulo 109 + 7.
Examples
Input
)(()()
Output
6
Input
()()()
Output
7
Input
)))
Output
0
Note
In the first sample the following subsequences are possible:
* If we delete characters at the positions 1 and 5 (numbering starts with one), we will get the subsequence "(())".
* If we delete characters at the positions 1, 2, 3 and 4, we will get the subsequence "()".
* If we delete characters at the positions 1, 2, 4 and 5, we will get the subsequence "()".
* If we delete characters at the positions 1, 2, 5 and 6, we will get the subsequence "()".
* If we delete characters at the positions 1, 3, 4 and 5, we will get the subsequence "()".
* If we delete characters at the positions 1, 3, 5 and 6, we will get the subsequence "()".
The rest of the subsequnces are not RSBS. So we got 6 distinct subsequences that are RSBS, so the answer is 6. | instruction | 0 | 90,602 | 21 | 181,204 |
Tags: combinatorics, dp, math, number theory
Correct Solution:
```
t = input()
n, m = len(t) + 1, 1000000007
x, y = 0, t.count(')') - 1
fact = [1] * n
for i in range(2, n): fact[i] = i * fact[i - 1] % m
invMult = [pow(x, m - 2, m) for x in fact]
s = 0
for b in t:
if y < 0: break
if b == '(':
x += 1
s += fact[x + y] * invMult[x] * invMult[y] % m
else: y -= 1
print(s % m)
``` | output | 1 | 90,602 | 21 | 181,205 |
Provide tags and a correct Python 3 solution for this coding contest problem.
As you probably know, Anton goes to school. One of the school subjects that Anton studies is Bracketology. On the Bracketology lessons students usually learn different sequences that consist of round brackets (characters "(" and ")" (without quotes)).
On the last lesson Anton learned about the regular simple bracket sequences (RSBS). A bracket sequence s of length n is an RSBS if the following conditions are met:
* It is not empty (that is n ≠ 0).
* The length of the sequence is even.
* First <image> charactes of the sequence are equal to "(".
* Last <image> charactes of the sequence are equal to ")".
For example, the sequence "((()))" is an RSBS but the sequences "((())" and "(()())" are not RSBS.
Elena Ivanovna, Anton's teacher, gave him the following task as a homework. Given a bracket sequence s. Find the number of its distinct subsequences such that they are RSBS. Note that a subsequence of s is a string that can be obtained from s by deleting some of its elements. Two subsequences are considered distinct if distinct sets of positions are deleted.
Because the answer can be very big and Anton's teacher doesn't like big numbers, she asks Anton to find the answer modulo 109 + 7.
Anton thought of this task for a very long time, but he still doesn't know how to solve it. Help Anton to solve this task and write a program that finds the answer for it!
Input
The only line of the input contains a string s — the bracket sequence given in Anton's homework. The string consists only of characters "(" and ")" (without quotes). It's guaranteed that the string is not empty and its length doesn't exceed 200 000.
Output
Output one number — the answer for the task modulo 109 + 7.
Examples
Input
)(()()
Output
6
Input
()()()
Output
7
Input
)))
Output
0
Note
In the first sample the following subsequences are possible:
* If we delete characters at the positions 1 and 5 (numbering starts with one), we will get the subsequence "(())".
* If we delete characters at the positions 1, 2, 3 and 4, we will get the subsequence "()".
* If we delete characters at the positions 1, 2, 4 and 5, we will get the subsequence "()".
* If we delete characters at the positions 1, 2, 5 and 6, we will get the subsequence "()".
* If we delete characters at the positions 1, 3, 4 and 5, we will get the subsequence "()".
* If we delete characters at the positions 1, 3, 5 and 6, we will get the subsequence "()".
The rest of the subsequnces are not RSBS. So we got 6 distinct subsequences that are RSBS, so the answer is 6. | instruction | 0 | 90,603 | 21 | 181,206 |
Tags: combinatorics, dp, math, number theory
Correct Solution:
```
s = input()
MOD = 10 ** 9 + 7
num = 0
N = len(s)
R = [0] * (N + 1)
L = [0] * (N + 1)
d = []
for i in range(N):
if s[i] == ')':
R[i + 1] = 1
else:
L[i + 1] = 1
d.append(i)
for i in range(1, N + 1):
R[i] += R[i - 1]
L[i] += L[i - 1]
M = 200005
fact = [0] * M
fact[0] = 1
for i in range(1, M):
fact[i] = fact[i - 1] * i
fact[i] %= MOD
rfact = [0] * M
rfact[M - 1] = pow(fact[M - 1], MOD - 2, MOD)
for i in range(M - 2, -1, -1):
rfact[i] = rfact[i + 1] * (i + 1)
rfact[i] %= MOD
def comb(n, k):
if k < 0 or k > n:
return 0
return fact[n] * rfact[n - k] * rfact[k] % MOD
for i in d:
if s[i] == '(':
l = L[i + 1] - 1
r = R[N] - R[i + 1]
num += comb(l + r, l + 1)
num %= MOD
print(num)
``` | output | 1 | 90,603 | 21 | 181,207 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As you probably know, Anton goes to school. One of the school subjects that Anton studies is Bracketology. On the Bracketology lessons students usually learn different sequences that consist of round brackets (characters "(" and ")" (without quotes)).
On the last lesson Anton learned about the regular simple bracket sequences (RSBS). A bracket sequence s of length n is an RSBS if the following conditions are met:
* It is not empty (that is n ≠ 0).
* The length of the sequence is even.
* First <image> charactes of the sequence are equal to "(".
* Last <image> charactes of the sequence are equal to ")".
For example, the sequence "((()))" is an RSBS but the sequences "((())" and "(()())" are not RSBS.
Elena Ivanovna, Anton's teacher, gave him the following task as a homework. Given a bracket sequence s. Find the number of its distinct subsequences such that they are RSBS. Note that a subsequence of s is a string that can be obtained from s by deleting some of its elements. Two subsequences are considered distinct if distinct sets of positions are deleted.
Because the answer can be very big and Anton's teacher doesn't like big numbers, she asks Anton to find the answer modulo 109 + 7.
Anton thought of this task for a very long time, but he still doesn't know how to solve it. Help Anton to solve this task and write a program that finds the answer for it!
Input
The only line of the input contains a string s — the bracket sequence given in Anton's homework. The string consists only of characters "(" and ")" (without quotes). It's guaranteed that the string is not empty and its length doesn't exceed 200 000.
Output
Output one number — the answer for the task modulo 109 + 7.
Examples
Input
)(()()
Output
6
Input
()()()
Output
7
Input
)))
Output
0
Note
In the first sample the following subsequences are possible:
* If we delete characters at the positions 1 and 5 (numbering starts with one), we will get the subsequence "(())".
* If we delete characters at the positions 1, 2, 3 and 4, we will get the subsequence "()".
* If we delete characters at the positions 1, 2, 4 and 5, we will get the subsequence "()".
* If we delete characters at the positions 1, 2, 5 and 6, we will get the subsequence "()".
* If we delete characters at the positions 1, 3, 4 and 5, we will get the subsequence "()".
* If we delete characters at the positions 1, 3, 5 and 6, we will get the subsequence "()".
The rest of the subsequnces are not RSBS. So we got 6 distinct subsequences that are RSBS, so the answer is 6.
Submitted Solution:
```
mod = 10 ** 9 + 7
F, inv, iF = [1,1], [0, 1], [1, 1]
for i in range(2, 200005):
F.append(F[-1] * i % mod)
inv.append(inv[mod%i] * (mod - mod // i) % mod)
iF.append(iF[-1] * inv[-1] % mod)
def C(n, k):
if k < 0 or k > n:
return 0
return F[n] * iF[k] * iF[n - k]
s = input()
open, close = 0, s.count(')')
ans = 0
for c in s:
if c == '(':
open += 1
ans += C(close + open - 1, open)
else:
close -= 1
print(ans % mod)
``` | instruction | 0 | 90,604 | 21 | 181,208 |
Yes | output | 1 | 90,604 | 21 | 181,209 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As you probably know, Anton goes to school. One of the school subjects that Anton studies is Bracketology. On the Bracketology lessons students usually learn different sequences that consist of round brackets (characters "(" and ")" (without quotes)).
On the last lesson Anton learned about the regular simple bracket sequences (RSBS). A bracket sequence s of length n is an RSBS if the following conditions are met:
* It is not empty (that is n ≠ 0).
* The length of the sequence is even.
* First <image> charactes of the sequence are equal to "(".
* Last <image> charactes of the sequence are equal to ")".
For example, the sequence "((()))" is an RSBS but the sequences "((())" and "(()())" are not RSBS.
Elena Ivanovna, Anton's teacher, gave him the following task as a homework. Given a bracket sequence s. Find the number of its distinct subsequences such that they are RSBS. Note that a subsequence of s is a string that can be obtained from s by deleting some of its elements. Two subsequences are considered distinct if distinct sets of positions are deleted.
Because the answer can be very big and Anton's teacher doesn't like big numbers, she asks Anton to find the answer modulo 109 + 7.
Anton thought of this task for a very long time, but he still doesn't know how to solve it. Help Anton to solve this task and write a program that finds the answer for it!
Input
The only line of the input contains a string s — the bracket sequence given in Anton's homework. The string consists only of characters "(" and ")" (without quotes). It's guaranteed that the string is not empty and its length doesn't exceed 200 000.
Output
Output one number — the answer for the task modulo 109 + 7.
Examples
Input
)(()()
Output
6
Input
()()()
Output
7
Input
)))
Output
0
Note
In the first sample the following subsequences are possible:
* If we delete characters at the positions 1 and 5 (numbering starts with one), we will get the subsequence "(())".
* If we delete characters at the positions 1, 2, 3 and 4, we will get the subsequence "()".
* If we delete characters at the positions 1, 2, 4 and 5, we will get the subsequence "()".
* If we delete characters at the positions 1, 2, 5 and 6, we will get the subsequence "()".
* If we delete characters at the positions 1, 3, 4 and 5, we will get the subsequence "()".
* If we delete characters at the positions 1, 3, 5 and 6, we will get the subsequence "()".
The rest of the subsequnces are not RSBS. So we got 6 distinct subsequences that are RSBS, so the answer is 6.
Submitted Solution:
```
mod = 10 ** 9 + 7
maxn = 200001
def C(n, k):
if k < 0 or k > n:
return 0
return fact[n] * invfact[k] * invfact[n - k] % mod
fact = [1, 1]
inv = [0, 1]
invfact = [1, 1]
for i in range(2, maxn):
fact.append(fact[-1] * i % mod)
inv.append(inv[mod % i] * (mod - mod // i) % mod)
invfact.append(invfact[-1] * inv[-1] % mod)
s = input()
op = 0
cl = s.count(')')
ans = 0
for x in s:
if x == '(':
op += 1
cur = C(cl + op - 1, op) % mod
ans += cur % mod
else:
cl -= 1
print(ans % mod)
``` | instruction | 0 | 90,605 | 21 | 181,210 |
Yes | output | 1 | 90,605 | 21 | 181,211 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As you probably know, Anton goes to school. One of the school subjects that Anton studies is Bracketology. On the Bracketology lessons students usually learn different sequences that consist of round brackets (characters "(" and ")" (without quotes)).
On the last lesson Anton learned about the regular simple bracket sequences (RSBS). A bracket sequence s of length n is an RSBS if the following conditions are met:
* It is not empty (that is n ≠ 0).
* The length of the sequence is even.
* First <image> charactes of the sequence are equal to "(".
* Last <image> charactes of the sequence are equal to ")".
For example, the sequence "((()))" is an RSBS but the sequences "((())" and "(()())" are not RSBS.
Elena Ivanovna, Anton's teacher, gave him the following task as a homework. Given a bracket sequence s. Find the number of its distinct subsequences such that they are RSBS. Note that a subsequence of s is a string that can be obtained from s by deleting some of its elements. Two subsequences are considered distinct if distinct sets of positions are deleted.
Because the answer can be very big and Anton's teacher doesn't like big numbers, she asks Anton to find the answer modulo 109 + 7.
Anton thought of this task for a very long time, but he still doesn't know how to solve it. Help Anton to solve this task and write a program that finds the answer for it!
Input
The only line of the input contains a string s — the bracket sequence given in Anton's homework. The string consists only of characters "(" and ")" (without quotes). It's guaranteed that the string is not empty and its length doesn't exceed 200 000.
Output
Output one number — the answer for the task modulo 109 + 7.
Examples
Input
)(()()
Output
6
Input
()()()
Output
7
Input
)))
Output
0
Note
In the first sample the following subsequences are possible:
* If we delete characters at the positions 1 and 5 (numbering starts with one), we will get the subsequence "(())".
* If we delete characters at the positions 1, 2, 3 and 4, we will get the subsequence "()".
* If we delete characters at the positions 1, 2, 4 and 5, we will get the subsequence "()".
* If we delete characters at the positions 1, 2, 5 and 6, we will get the subsequence "()".
* If we delete characters at the positions 1, 3, 4 and 5, we will get the subsequence "()".
* If we delete characters at the positions 1, 3, 5 and 6, we will get the subsequence "()".
The rest of the subsequnces are not RSBS. So we got 6 distinct subsequences that are RSBS, so the answer is 6.
Submitted Solution:
```
from datetime import datetime
cache = {}
def pascal(n, k):
if k == 0 or k == n:
return 1
elif (n,k) in cache:
return cache[(n,k)]
else:
value = pascal(n-1, k-1) + pascal(n-1, k)
cache[(n,k)] = value
return value
sentence=input()
startTime = datetime.now()
s=0
x=0
for i in range(len(sentence)):
if sentence[i]=="(":
x+=1
cut=sentence[i+1:]
y=cut.count(")")
if y>=1:
m=min(x,y)
for a in range(m+1):
if a!=0:
add=int(pascal(y,a))*int(pascal(x-1,a-1))
s+=add
print(s)
print(datetime.now() - startTime)
``` | instruction | 0 | 90,606 | 21 | 181,212 |
No | output | 1 | 90,606 | 21 | 181,213 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As you probably know, Anton goes to school. One of the school subjects that Anton studies is Bracketology. On the Bracketology lessons students usually learn different sequences that consist of round brackets (characters "(" and ")" (without quotes)).
On the last lesson Anton learned about the regular simple bracket sequences (RSBS). A bracket sequence s of length n is an RSBS if the following conditions are met:
* It is not empty (that is n ≠ 0).
* The length of the sequence is even.
* First <image> charactes of the sequence are equal to "(".
* Last <image> charactes of the sequence are equal to ")".
For example, the sequence "((()))" is an RSBS but the sequences "((())" and "(()())" are not RSBS.
Elena Ivanovna, Anton's teacher, gave him the following task as a homework. Given a bracket sequence s. Find the number of its distinct subsequences such that they are RSBS. Note that a subsequence of s is a string that can be obtained from s by deleting some of its elements. Two subsequences are considered distinct if distinct sets of positions are deleted.
Because the answer can be very big and Anton's teacher doesn't like big numbers, she asks Anton to find the answer modulo 109 + 7.
Anton thought of this task for a very long time, but he still doesn't know how to solve it. Help Anton to solve this task and write a program that finds the answer for it!
Input
The only line of the input contains a string s — the bracket sequence given in Anton's homework. The string consists only of characters "(" and ")" (without quotes). It's guaranteed that the string is not empty and its length doesn't exceed 200 000.
Output
Output one number — the answer for the task modulo 109 + 7.
Examples
Input
)(()()
Output
6
Input
()()()
Output
7
Input
)))
Output
0
Note
In the first sample the following subsequences are possible:
* If we delete characters at the positions 1 and 5 (numbering starts with one), we will get the subsequence "(())".
* If we delete characters at the positions 1, 2, 3 and 4, we will get the subsequence "()".
* If we delete characters at the positions 1, 2, 4 and 5, we will get the subsequence "()".
* If we delete characters at the positions 1, 2, 5 and 6, we will get the subsequence "()".
* If we delete characters at the positions 1, 3, 4 and 5, we will get the subsequence "()".
* If we delete characters at the positions 1, 3, 5 and 6, we will get the subsequence "()".
The rest of the subsequnces are not RSBS. So we got 6 distinct subsequences that are RSBS, so the answer is 6.
Submitted Solution:
```
p = 10**9+7
def power(x, y, p):
b = bin(y)[2:]
answer = 1
start = x % p
for i in range(len(b)):
if b[len(b)-1-i]=='1':
answer = (answer*start) % p
start = (start*start) % p
return answer
def process(S):
answer = 0
n = len(S)
left_count = 0
right_count = 0
p_lc = 1
p_rc = 1
p_num = 1
num = 0
for c in S:
if c==')':
right_count+=1
p_rc = (p_rc*(right_count+1)) % p
num+=1
p_num = (p_num*num) % p
for i in range(n):
if S[i]=='(':
left_count+=1
if left_count > 1:
p_lc = (p_lc*(left_count-1)) % p
num+=1
p_num = (p_num*num) % p
else:
p_rc = (p_rc*power(right_count+1, p-2, p)) % p
p_num = (p_num*power(num, p-2, p)) % p
right_count-=1
num-=1
#(left_count choose n, right_count choose n-1)
#(left_count choose n, right_count choose rc-n+1))
#(lc+rc choose rc+1)
if left_count > 0:
entry = (p_num*power(p_lc, p-2, p)*power(p_rc, p-2, p)) % p
answer = (answer+entry) % p
return answer
``` | instruction | 0 | 90,607 | 21 | 181,214 |
No | output | 1 | 90,607 | 21 | 181,215 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As you probably know, Anton goes to school. One of the school subjects that Anton studies is Bracketology. On the Bracketology lessons students usually learn different sequences that consist of round brackets (characters "(" and ")" (without quotes)).
On the last lesson Anton learned about the regular simple bracket sequences (RSBS). A bracket sequence s of length n is an RSBS if the following conditions are met:
* It is not empty (that is n ≠ 0).
* The length of the sequence is even.
* First <image> charactes of the sequence are equal to "(".
* Last <image> charactes of the sequence are equal to ")".
For example, the sequence "((()))" is an RSBS but the sequences "((())" and "(()())" are not RSBS.
Elena Ivanovna, Anton's teacher, gave him the following task as a homework. Given a bracket sequence s. Find the number of its distinct subsequences such that they are RSBS. Note that a subsequence of s is a string that can be obtained from s by deleting some of its elements. Two subsequences are considered distinct if distinct sets of positions are deleted.
Because the answer can be very big and Anton's teacher doesn't like big numbers, she asks Anton to find the answer modulo 109 + 7.
Anton thought of this task for a very long time, but he still doesn't know how to solve it. Help Anton to solve this task and write a program that finds the answer for it!
Input
The only line of the input contains a string s — the bracket sequence given in Anton's homework. The string consists only of characters "(" and ")" (without quotes). It's guaranteed that the string is not empty and its length doesn't exceed 200 000.
Output
Output one number — the answer for the task modulo 109 + 7.
Examples
Input
)(()()
Output
6
Input
()()()
Output
7
Input
)))
Output
0
Note
In the first sample the following subsequences are possible:
* If we delete characters at the positions 1 and 5 (numbering starts with one), we will get the subsequence "(())".
* If we delete characters at the positions 1, 2, 3 and 4, we will get the subsequence "()".
* If we delete characters at the positions 1, 2, 4 and 5, we will get the subsequence "()".
* If we delete characters at the positions 1, 2, 5 and 6, we will get the subsequence "()".
* If we delete characters at the positions 1, 3, 4 and 5, we will get the subsequence "()".
* If we delete characters at the positions 1, 3, 5 and 6, we will get the subsequence "()".
The rest of the subsequnces are not RSBS. So we got 6 distinct subsequences that are RSBS, so the answer is 6.
Submitted Solution:
```
s = input()
MAXN = 200005
MOD = 1000000007
Fac = [ 1 for i in range(0, MAXN)]
for i in range(1, MAXN): Fac[i] = (i*Fac[i-1])%MOD
f = lambda n : Fac[n] if n >= 0 else 0
suf = [ 0 for i in range(0, len(s)+1)]
for i in range(len(s)-1, -1, -1):
suf[i] = suf[i+1] + 1 if s[i] is ')' else suf[i+1]
def ncr(n, k):
return 0 if (f(n-k)*f(k)) == 0 else (f(n)* pow(f(n-k)*f(k), MOD-2, MOD) ) % MOD
ans = 0
pre = 0
for i in range(0, len(s)):
if s[i] is not '(':
continue
pre += 1
ans += ncr(suf[i+1]+pre-1, pre)
print(ans % MOD)
``` | instruction | 0 | 90,608 | 21 | 181,216 |
No | output | 1 | 90,608 | 21 | 181,217 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As you probably know, Anton goes to school. One of the school subjects that Anton studies is Bracketology. On the Bracketology lessons students usually learn different sequences that consist of round brackets (characters "(" and ")" (without quotes)).
On the last lesson Anton learned about the regular simple bracket sequences (RSBS). A bracket sequence s of length n is an RSBS if the following conditions are met:
* It is not empty (that is n ≠ 0).
* The length of the sequence is even.
* First <image> charactes of the sequence are equal to "(".
* Last <image> charactes of the sequence are equal to ")".
For example, the sequence "((()))" is an RSBS but the sequences "((())" and "(()())" are not RSBS.
Elena Ivanovna, Anton's teacher, gave him the following task as a homework. Given a bracket sequence s. Find the number of its distinct subsequences such that they are RSBS. Note that a subsequence of s is a string that can be obtained from s by deleting some of its elements. Two subsequences are considered distinct if distinct sets of positions are deleted.
Because the answer can be very big and Anton's teacher doesn't like big numbers, she asks Anton to find the answer modulo 109 + 7.
Anton thought of this task for a very long time, but he still doesn't know how to solve it. Help Anton to solve this task and write a program that finds the answer for it!
Input
The only line of the input contains a string s — the bracket sequence given in Anton's homework. The string consists only of characters "(" and ")" (without quotes). It's guaranteed that the string is not empty and its length doesn't exceed 200 000.
Output
Output one number — the answer for the task modulo 109 + 7.
Examples
Input
)(()()
Output
6
Input
()()()
Output
7
Input
)))
Output
0
Note
In the first sample the following subsequences are possible:
* If we delete characters at the positions 1 and 5 (numbering starts with one), we will get the subsequence "(())".
* If we delete characters at the positions 1, 2, 3 and 4, we will get the subsequence "()".
* If we delete characters at the positions 1, 2, 4 and 5, we will get the subsequence "()".
* If we delete characters at the positions 1, 2, 5 and 6, we will get the subsequence "()".
* If we delete characters at the positions 1, 3, 4 and 5, we will get the subsequence "()".
* If we delete characters at the positions 1, 3, 5 and 6, we will get the subsequence "()".
The rest of the subsequnces are not RSBS. So we got 6 distinct subsequences that are RSBS, so the answer is 6.
Submitted Solution:
```
#!/usr/bin/env python3
def ri():
return map(int, input().split())
def prefac(n):
fac[0] = 1
for i in range(1,n):
fac[i] = fac[i-1]*i%(10**9+7)
s = input()
n = len(s)
o = [0 for i in range(len(s))]
c = [0 for i in range(len(s))]
fac = [0 for i in range(n)]
prefac(n)
if s[0] == '(':
o[0] = 1
for i in range(1,n):
if s[i] == '(':
o[i] = o[i-1] + 1
else:
o[i] = o[i-1]
if s[n-1] == ')':
c[n-1] = 1
for i in range(n-2, -1, -1):
if s[i] == ')':
c[i] = c[i+1] + 1
else:
c[i] = c[i+1]
ans = 0
for i in range(n):
if s[i] == '(':
a = o[i]
b = c[i]
if a != 0 and b != 0:
ans += fac[a+b-1]//fac[a]//fac[b-1]
ans %= 10**9+7
print(ans)
``` | instruction | 0 | 90,609 | 21 | 181,218 |
No | output | 1 | 90,609 | 21 | 181,219 |
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 | 92,758 | 21 | 185,516 |
Tags: greedy
Correct Solution:
```
import sys
input = sys.stdin.readline
N = int(input())
S = input().rstrip()
A = [0]
for s in S:
a = 1 if s == "(" else -1
A.append(A[-1]+a)
isOK = True
ans = 0
last0 = 0
for i, a in enumerate(A):
if a == 0:
if not isOK:
ans += i - last0
last0 = i
isOK = True
if a < 0:
isOK = False
if A[-1] != 0:
print(-1)
else:
print(ans)
``` | output | 1 | 92,758 | 21 | 185,517 |
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 | 92,759 | 21 | 185,518 |
Tags: greedy
Correct Solution:
```
n = int(input())
a = input()
if a.count('(') != a.count(')'):
print("-1")
else :
c=0
d=0
for i in a :
if i == '(' :
c+=1
else:
c-=1
if c<0:
d+=2
print(d)
``` | output | 1 | 92,759 | 21 | 185,519 |
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 | 92,760 | 21 | 185,520 |
Tags: greedy
Correct Solution:
```
import sys
#import math
#from collections import deque
#import heapq
input=sys.stdin.readline
n=int(input())
s=input()
l=list()
open=list()
close=list()
for i in range(n):
if(s[i]=='('):
open.append(i)
else:
close.append(i)
if(len(open)!=len(close)):
print(-1)
else:
ans=0
for i in range(len(open)):
if(open[i]>close[i]):
ans+=2
print(ans)
``` | output | 1 | 92,760 | 21 | 185,521 |
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 | 92,761 | 21 | 185,522 |
Tags: greedy
Correct Solution:
```
t=int(input())
s=input()
if s.count('(') != s.count(')'):
print(-1)
else:
ans=[]
negval=0
val=0
for i in range(len(s)):
if s[i] == '(':
val+=1
if val == 0:
ans.append(-1)
else:
ans.append(val)
else:
val-=1
ans.append(val)
a=0
for i in ans:
if i < 0:
a+=1
print(a)
``` | output | 1 | 92,761 | 21 | 185,523 |
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 | 92,762 | 21 | 185,524 |
Tags: greedy
Correct Solution:
```
#import io,os
#input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
import sys
input = sys.stdin.readline
from collections import defaultdict
def main():
#for _ in range(int(input())):
n = int(input())
s = input()
cnt = defaultdict(int)
for i in range(n):
cnt[s[i]] += 1
if cnt["("] != cnt[")"]:
print(-1)
exit()
ans = 0
bal = 0
bad = False
last = 0
for i in range(n):
if s[i] == "(":
bal += 1
else:
bal -= 1
if bal == 0:
if bad:
ans += i - last + 1
last = i + 1
bad = False
else:
last = i + 1
bad = False
elif bal < 0:
bad = True
print(min(n, ans))
main()
``` | output | 1 | 92,762 | 21 | 185,525 |
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 | 92,763 | 21 | 185,526 |
Tags: greedy
Correct Solution:
```
p=int(input())
q=input()
x=q.count(')')
y=q.count('(')
c=0
l=0
r=0
z=0
sum=0
if x!=y :
print(-1)
c=1
if c==0 :
for i in range(p) :
if q[i]=='(' :
l+=1
else :
r+=1
if r>l :
z=1
if l==r and z==0 :
# print("xxxxxxxxxx",l,r)
l=0
r=0
if l==r and z==1 :
# print("yyyyyyyyy",l,r)
sum+=l+r
l=0
r=0
z=0
print(sum)
``` | output | 1 | 92,763 | 21 | 185,527 |
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 | 92,764 | 21 | 185,528 |
Tags: greedy
Correct Solution:
```
n = int(input())
s = input()
stack = []
stack2 = []
pair = 0
if s.count(')') != s.count('('):
print(-1)
else:
for i in s:
if i == '(':
stack2.append(i)
if i == ')':
if stack2:
del stack2[-1]
else:
stack.append(i)
elif stack and i == '(':
del stack[-1]
del stack2[-1]
pair += 2
print(pair)
``` | output | 1 | 92,764 | 21 | 185,529 |
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 | 92,765 | 21 | 185,530 |
Tags: greedy
Correct Solution:
```
n=int(input())
s=input()
a=0
b=0
for i in range(0,len(s)):
if s[i]==')':
a+=1
else:
b+=1
if a!=b:
print(-1)
else:
count=0
stack=[]
i=0
while i<len(s):
a=0
b=0
if s[i]=='(':
stack.append(s[i])
else:
if stack==[]:
for j in range(i,len(s)):
if s[j]==')':
a+=1
else:
b+=1
if a==b:
k=j
break
count=count+k+1-i
i=k
else:
stack.pop(-1)
i+=1
print(count)
``` | output | 1 | 92,765 | 21 | 185,531 |
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:
```
from bisect import bisect_left as bl, bisect_right as br, insort
import sys
import heapq
from math import *
from collections import defaultdict as dd, deque
def data(): return sys.stdin.readline().strip()
def mdata(): return map(int, data().split())
#sys.setrecursionlimit(100000)
n=int(data())
s=data()
l=[]
o=c=0
k=0
ans=0
for i in range(n):
if s[i]=='(':
o+=1
l.append('(')
else:
c+=1
if len(l)>0:
if l[-1]=='(':
l.pop()
else:
l.append(')')
else:
l.append(')')
if o==c and len(l)!=0:
ans+=o+c
l=[]
o=c=0
if len(l)==0:
o=c=0
if o!=c:
print(-1)
else:
print(ans)
``` | instruction | 0 | 92,766 | 21 | 185,532 |
Yes | output | 1 | 92,766 | 21 | 185,533 |
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:
```
def check(s):
st=[]
for i in s:
if i=="(":
st.append("(")
else:
if len(st)==0:
return False
st.pop()
else:
return True
n=int(input())
s=list(input())
if s.count("(")!=s.count(")"):
print(-1)
exit()
if check(s):
print(0)
exit()
c=0
x=0
y=0
for i in range(n):
if s[i]=="(":
if x==0 and y==0:
j=i
x+=1
else:
if x==0 and y==0:
j=i
y+=1
if x==y:
if not check(s[j:i+1]):
c+=(x+y)
x=0
y=0
print(c)
``` | instruction | 0 | 92,767 | 21 | 185,534 |
Yes | output | 1 | 92,767 | 21 | 185,535 |
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())
z = input()
pravych = 0
lavych = 0
for i in range(n):
if z[i] == ')':
pravych += 1
else:
lavych += 1
def najdi_usek_viac_lavych(index):
pp = 0
ll = 0
for i in range(index,n):
if z[i] == ')':
pp = pp+1
else:
ll = ll+1
if ll > pp:
return i-index
def prehadzuj(z,n,spolu):
p = 0
l = 0
i = 0
while(i<n):
if z[i] == ')':
p = p+1
else:
l = l+1
if l < p:
out = najdi_usek_viac_lavych(i+1)
spolu = spolu + out + 2
i = i+2+out
p=0
l=0
else:
i = i+1
return spolu
if n%2 == 1:
print(-1)
elif pravych != lavych:
print(-1)
else:
print(prehadzuj(z,n,0))
``` | instruction | 0 | 92,768 | 21 | 185,536 |
Yes | output | 1 | 92,768 | 21 | 185,537 |
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()
op,cl=0,0
ind=0
flag=0
for i in range(len(s)):
if(op<0):flag=1
else:flag=0
if(s[i]=='('):op+=1
else:op-=1
if(op==-1 and s[i]==')'):
ind=i
#print(i)
if(flag and op==0):
#print(i,ind)
cl+=((i-ind)+1)
if(op!=0):
print(-1)
else:
print(cl)
``` | instruction | 0 | 92,769 | 21 | 185,538 |
Yes | output | 1 | 92,769 | 21 | 185,539 |
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())
a = input()
if a.count('(') != a.count(')'):
print("-1")
else :
b = []
c = 0
for i in range(n):
if len(b) == 0:
b.append(a[i])
else:
if b[len(b)-1] == '(' and a[i] == ')' and len(b)%2 != 0 :
b.pop()
elif b[len(b)-1] == '(' and a[i] == ')' and len(b)%2 == 0 :
b.append(a[i])
elif b[len(b)-1] == '(' and a[i] == '(' :
b.append(a[i])
elif b[len(b)-1] == ')' and a[i] == '(' :
b.append(a[i])
elif b[len(b)-1] == ')' and a[i] == ')' :
b.append(a[i])
print(len(b))
``` | instruction | 0 | 92,770 | 21 | 185,540 |
No | output | 1 | 92,770 | 21 | 185,541 |
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:
```
# Author Name: Ajay Meena
# Codeforce : https://codeforces.com/profile/majay1638
import sys
import math
import bisect
import heapq
from bisect import bisect_right
from sys import stdin, stdout
# -------------- INPUT FUNCTIONS ------------------
def get_ints_in_variables(): return map(
int, sys.stdin.readline().strip().split())
def get_int(): return int(sys.stdin.readline())
def get_ints_in_list(): return list(
map(int, sys.stdin.readline().strip().split()))
def get_list_of_list(n): return [list(
map(int, sys.stdin.readline().strip().split())) for _ in range(n)]
def get_string(): return sys.stdin.readline().strip()
# -------- SOME CUSTOMIZED FUNCTIONS-----------
def myceil(x, y): return (x + y - 1) // y
# -------------- SOLUTION FUNCTION ------------------
def Solution(s, n):
# Write Your Code Here
opn = 0
close = 0
for c in s:
if c == "(":
opn += 1
else:
close += 1
if n % 2 or opn != close:
print(-1)
return
i = 0
ans = 0
while i < n:
opn = 0
clse = 0
l = i
firstOpen = True
if s[i] == "(":
while i < n and s[i] == "(":
i += 1
opn += 1
else:
firstOpen = False
while i < n and s[i] == ")":
i += 1
clse += 1
flg = True
if firstOpen:
while i < n and clse != opn:
if s[i] == "(":
opn += 1
flg = False
else:
clse += 1
i += 1
else:
while i < n and clse != opn:
if s[i] == ")":
clse += 1
flg = False
else:
opn += 1
i += 1
if (not flg) or (not firstOpen):
ans += (i-l)
print(ans)
def main():
# Take input Here and Call solution function
n = get_int()
Solution(get_string(), n)
# calling main Function
if __name__ == '__main__':
main()
``` | instruction | 0 | 92,771 | 21 | 185,542 |
No | output | 1 | 92,771 | 21 | 185,543 |
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:
```
import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
if __name__ == '__main__':
n=int(input())
brackets=input()
wrongbra=0
tl,tr=0,0
l,r=0,0
wrongNow=False
for i,bra in enumerate(brackets):
if bra==")":
r+=1
tr+=1
else:
l+=1
tl+=1
if l<r:
wrongNow=True
if wrongNow:
if l==r:
wrongNow=False
wrongbra+=(l+r)
l,r=0,0
else:
if l==r:
l,r=0,0
print(wrongbra)
``` | instruction | 0 | 92,772 | 21 | 185,544 |
No | output | 1 | 92,772 | 21 | 185,545 |
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=list(input())
if s.count("(")!=s.count(")"):
print(-1)
exit()
st=[]
for i in s:
if i=="(":
st.append("(")
else:
if len(st)==0:
break
st.pop()
else:
print(0)
exit()
c=0
for i in range(0,n,2):
if s[i]!="(" or s[i+1]!=")":
c+=2
print(c)
``` | instruction | 0 | 92,773 | 21 | 185,546 |
No | output | 1 | 92,773 | 21 | 185,547 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S of length N consisting of `(` and `)`. Your task is to insert some number of `(` and `)` into S to obtain a correct bracket sequence.
Here, a correct bracket sequence is defined as follows:
* `()` is a correct bracket sequence.
* If X is a correct bracket sequence, the concatenation of `(`, X and `)` in this order is also a correct bracket sequence.
* If X and Y are correct bracket sequences, the concatenation of X and Y in this order is also a correct bracket sequence.
* Every correct bracket sequence can be derived from the rules above.
Find the shortest correct bracket sequence that can be obtained. If there is more than one such sequence, find the lexicographically smallest one.
Constraints
* The length of S is N.
* 1 ≤ N ≤ 100
* S consists of `(` and `)`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the lexicographically smallest string among the shortest correct bracket sequences that can be obtained by inserting some number of `(` and `)` into S.
Examples
Input
3
())
Output
(())
Input
6
)))())
Output
(((()))())
Input
8
))))((((
Output
(((())))(((()))) | instruction | 0 | 98,485 | 21 | 196,970 |
"Correct Solution:
```
N = int(input())
S = input()
s = S[:]
while '()' in s:
s = s.replace('()', '')
ans = '(' * s.count(')') + S + ')' * s.count('(')
print(ans)
``` | output | 1 | 98,485 | 21 | 196,971 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S of length N consisting of `(` and `)`. Your task is to insert some number of `(` and `)` into S to obtain a correct bracket sequence.
Here, a correct bracket sequence is defined as follows:
* `()` is a correct bracket sequence.
* If X is a correct bracket sequence, the concatenation of `(`, X and `)` in this order is also a correct bracket sequence.
* If X and Y are correct bracket sequences, the concatenation of X and Y in this order is also a correct bracket sequence.
* Every correct bracket sequence can be derived from the rules above.
Find the shortest correct bracket sequence that can be obtained. If there is more than one such sequence, find the lexicographically smallest one.
Constraints
* The length of S is N.
* 1 ≤ N ≤ 100
* S consists of `(` and `)`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the lexicographically smallest string among the shortest correct bracket sequences that can be obtained by inserting some number of `(` and `)` into S.
Examples
Input
3
())
Output
(())
Input
6
)))())
Output
(((()))())
Input
8
))))((((
Output
(((())))(((()))) | instruction | 0 | 98,486 | 21 | 196,972 |
"Correct Solution:
```
N=int(input())
S=input()
a=[0]
for c in S:
a.append(a[-1]+(1 if c=='(' else -1))
k=-min(a)
l=S.count('(')+k-S.count(')')
ans='('*k+S+')'*l
print(ans)
``` | output | 1 | 98,486 | 21 | 196,973 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S of length N consisting of `(` and `)`. Your task is to insert some number of `(` and `)` into S to obtain a correct bracket sequence.
Here, a correct bracket sequence is defined as follows:
* `()` is a correct bracket sequence.
* If X is a correct bracket sequence, the concatenation of `(`, X and `)` in this order is also a correct bracket sequence.
* If X and Y are correct bracket sequences, the concatenation of X and Y in this order is also a correct bracket sequence.
* Every correct bracket sequence can be derived from the rules above.
Find the shortest correct bracket sequence that can be obtained. If there is more than one such sequence, find the lexicographically smallest one.
Constraints
* The length of S is N.
* 1 ≤ N ≤ 100
* S consists of `(` and `)`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the lexicographically smallest string among the shortest correct bracket sequences that can be obtained by inserting some number of `(` and `)` into S.
Examples
Input
3
())
Output
(())
Input
6
)))())
Output
(((()))())
Input
8
))))((((
Output
(((())))(((()))) | instruction | 0 | 98,487 | 21 | 196,974 |
"Correct Solution:
```
input()
t=s=input()
p,q=o="()"
while o in s:s=s.replace(o,"")
print(p*s.count(q)+t+q*s.count(p))
``` | output | 1 | 98,487 | 21 | 196,975 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S of length N consisting of `(` and `)`. Your task is to insert some number of `(` and `)` into S to obtain a correct bracket sequence.
Here, a correct bracket sequence is defined as follows:
* `()` is a correct bracket sequence.
* If X is a correct bracket sequence, the concatenation of `(`, X and `)` in this order is also a correct bracket sequence.
* If X and Y are correct bracket sequences, the concatenation of X and Y in this order is also a correct bracket sequence.
* Every correct bracket sequence can be derived from the rules above.
Find the shortest correct bracket sequence that can be obtained. If there is more than one such sequence, find the lexicographically smallest one.
Constraints
* The length of S is N.
* 1 ≤ N ≤ 100
* S consists of `(` and `)`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the lexicographically smallest string among the shortest correct bracket sequences that can be obtained by inserting some number of `(` and `)` into S.
Examples
Input
3
())
Output
(())
Input
6
)))())
Output
(((()))())
Input
8
))))((((
Output
(((())))(((()))) | instruction | 0 | 98,488 | 21 | 196,976 |
"Correct Solution:
```
N = int(input())
X = input()
L, R = 0, 0
for x in X:
if x == "(":
R += 1
else:
if R == 0:
L += 1
else:
R -= 1
print(L*"("+X+R*")")
``` | output | 1 | 98,488 | 21 | 196,977 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S of length N consisting of `(` and `)`. Your task is to insert some number of `(` and `)` into S to obtain a correct bracket sequence.
Here, a correct bracket sequence is defined as follows:
* `()` is a correct bracket sequence.
* If X is a correct bracket sequence, the concatenation of `(`, X and `)` in this order is also a correct bracket sequence.
* If X and Y are correct bracket sequences, the concatenation of X and Y in this order is also a correct bracket sequence.
* Every correct bracket sequence can be derived from the rules above.
Find the shortest correct bracket sequence that can be obtained. If there is more than one such sequence, find the lexicographically smallest one.
Constraints
* The length of S is N.
* 1 ≤ N ≤ 100
* S consists of `(` and `)`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the lexicographically smallest string among the shortest correct bracket sequences that can be obtained by inserting some number of `(` and `)` into S.
Examples
Input
3
())
Output
(())
Input
6
)))())
Output
(((()))())
Input
8
))))((((
Output
(((())))(((()))) | instruction | 0 | 98,489 | 21 | 196,978 |
"Correct Solution:
```
N = int(input())
S = input()
R=0;L=0
for i in range(N):
if S[i] == ')':
if L == 0:
R+=1
else:
L -= 1
else:
L += 1
Answer = '(' * R + S + ')' * L
print(Answer)
``` | output | 1 | 98,489 | 21 | 196,979 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S of length N consisting of `(` and `)`. Your task is to insert some number of `(` and `)` into S to obtain a correct bracket sequence.
Here, a correct bracket sequence is defined as follows:
* `()` is a correct bracket sequence.
* If X is a correct bracket sequence, the concatenation of `(`, X and `)` in this order is also a correct bracket sequence.
* If X and Y are correct bracket sequences, the concatenation of X and Y in this order is also a correct bracket sequence.
* Every correct bracket sequence can be derived from the rules above.
Find the shortest correct bracket sequence that can be obtained. If there is more than one such sequence, find the lexicographically smallest one.
Constraints
* The length of S is N.
* 1 ≤ N ≤ 100
* S consists of `(` and `)`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the lexicographically smallest string among the shortest correct bracket sequences that can be obtained by inserting some number of `(` and `)` into S.
Examples
Input
3
())
Output
(())
Input
6
)))())
Output
(((()))())
Input
8
))))((((
Output
(((())))(((()))) | instruction | 0 | 98,490 | 21 | 196,980 |
"Correct Solution:
```
n=int(input())
s=input()
l=0
r=0
for c in s:
if c=='(':
r+=1
elif c==')':
if r>0:
r-=1
else:
l+=1
print('('*l+s+')'*r)
``` | output | 1 | 98,490 | 21 | 196,981 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S of length N consisting of `(` and `)`. Your task is to insert some number of `(` and `)` into S to obtain a correct bracket sequence.
Here, a correct bracket sequence is defined as follows:
* `()` is a correct bracket sequence.
* If X is a correct bracket sequence, the concatenation of `(`, X and `)` in this order is also a correct bracket sequence.
* If X and Y are correct bracket sequences, the concatenation of X and Y in this order is also a correct bracket sequence.
* Every correct bracket sequence can be derived from the rules above.
Find the shortest correct bracket sequence that can be obtained. If there is more than one such sequence, find the lexicographically smallest one.
Constraints
* The length of S is N.
* 1 ≤ N ≤ 100
* S consists of `(` and `)`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the lexicographically smallest string among the shortest correct bracket sequences that can be obtained by inserting some number of `(` and `)` into S.
Examples
Input
3
())
Output
(())
Input
6
)))())
Output
(((()))())
Input
8
))))((((
Output
(((())))(((()))) | instruction | 0 | 98,491 | 21 | 196,982 |
"Correct Solution:
```
n=int(input())
s=input()
a=b=0
k=0
for i in range(n):
if s[i]=="(":
a+=1
else:
b+=1
if a<b:
k+=1
a+=1
s=k*("(")+s
if a>b:
s+=")"*(a-b)
print(s)
``` | output | 1 | 98,491 | 21 | 196,983 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S of length N consisting of `(` and `)`. Your task is to insert some number of `(` and `)` into S to obtain a correct bracket sequence.
Here, a correct bracket sequence is defined as follows:
* `()` is a correct bracket sequence.
* If X is a correct bracket sequence, the concatenation of `(`, X and `)` in this order is also a correct bracket sequence.
* If X and Y are correct bracket sequences, the concatenation of X and Y in this order is also a correct bracket sequence.
* Every correct bracket sequence can be derived from the rules above.
Find the shortest correct bracket sequence that can be obtained. If there is more than one such sequence, find the lexicographically smallest one.
Constraints
* The length of S is N.
* 1 ≤ N ≤ 100
* S consists of `(` and `)`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the lexicographically smallest string among the shortest correct bracket sequences that can be obtained by inserting some number of `(` and `)` into S.
Examples
Input
3
())
Output
(())
Input
6
)))())
Output
(((()))())
Input
8
))))((((
Output
(((())))(((()))) | instruction | 0 | 98,492 | 21 | 196,984 |
"Correct Solution:
```
input();s=input();r=l=0
for c in s:r=max(r-1+2*(c=='('),0)
for c in s[::-1]:l=max(l-1+2*(c==')'),0)
print(l*'('+s+')'*r)
``` | output | 1 | 98,492 | 21 | 196,985 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string S of length N consisting of `(` and `)`. Your task is to insert some number of `(` and `)` into S to obtain a correct bracket sequence.
Here, a correct bracket sequence is defined as follows:
* `()` is a correct bracket sequence.
* If X is a correct bracket sequence, the concatenation of `(`, X and `)` in this order is also a correct bracket sequence.
* If X and Y are correct bracket sequences, the concatenation of X and Y in this order is also a correct bracket sequence.
* Every correct bracket sequence can be derived from the rules above.
Find the shortest correct bracket sequence that can be obtained. If there is more than one such sequence, find the lexicographically smallest one.
Constraints
* The length of S is N.
* 1 ≤ N ≤ 100
* S consists of `(` and `)`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the lexicographically smallest string among the shortest correct bracket sequences that can be obtained by inserting some number of `(` and `)` into S.
Examples
Input
3
())
Output
(())
Input
6
)))())
Output
(((()))())
Input
8
))))((((
Output
(((())))(((())))
Submitted Solution:
```
n=int(input())
s=input()
X=[0]
r=0
for i in range(n):
if s[i]=="(":
r+=1
else:
r-=1
X.append(r)
left=-min(X)
right=X[-1]+left
print("("*left+s+")"*right)
``` | instruction | 0 | 98,493 | 21 | 196,986 |
Yes | output | 1 | 98,493 | 21 | 196,987 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string S of length N consisting of `(` and `)`. Your task is to insert some number of `(` and `)` into S to obtain a correct bracket sequence.
Here, a correct bracket sequence is defined as follows:
* `()` is a correct bracket sequence.
* If X is a correct bracket sequence, the concatenation of `(`, X and `)` in this order is also a correct bracket sequence.
* If X and Y are correct bracket sequences, the concatenation of X and Y in this order is also a correct bracket sequence.
* Every correct bracket sequence can be derived from the rules above.
Find the shortest correct bracket sequence that can be obtained. If there is more than one such sequence, find the lexicographically smallest one.
Constraints
* The length of S is N.
* 1 ≤ N ≤ 100
* S consists of `(` and `)`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the lexicographically smallest string among the shortest correct bracket sequences that can be obtained by inserting some number of `(` and `)` into S.
Examples
Input
3
())
Output
(())
Input
6
)))())
Output
(((()))())
Input
8
))))((((
Output
(((())))(((())))
Submitted Solution:
```
n=int(input())
s=input()
a=0
l=0
for i in range(n):
if s[i]=='(':
a+=1
else:
a-=1
if a<0:
l+=1
a+=1
print('('*l+s+')'*a)
``` | instruction | 0 | 98,494 | 21 | 196,988 |
Yes | output | 1 | 98,494 | 21 | 196,989 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string S of length N consisting of `(` and `)`. Your task is to insert some number of `(` and `)` into S to obtain a correct bracket sequence.
Here, a correct bracket sequence is defined as follows:
* `()` is a correct bracket sequence.
* If X is a correct bracket sequence, the concatenation of `(`, X and `)` in this order is also a correct bracket sequence.
* If X and Y are correct bracket sequences, the concatenation of X and Y in this order is also a correct bracket sequence.
* Every correct bracket sequence can be derived from the rules above.
Find the shortest correct bracket sequence that can be obtained. If there is more than one such sequence, find the lexicographically smallest one.
Constraints
* The length of S is N.
* 1 ≤ N ≤ 100
* S consists of `(` and `)`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the lexicographically smallest string among the shortest correct bracket sequences that can be obtained by inserting some number of `(` and `)` into S.
Examples
Input
3
())
Output
(())
Input
6
)))())
Output
(((()))())
Input
8
))))((((
Output
(((())))(((())))
Submitted Solution:
```
n = int(input())
s = input()
i = 0
k = 0
while i < len(s):
if s[i] == "(":
k += 1
else:
if k > 0:
k -= 1
else:
s = "(" + s
i += 1
i += 1
print(s+")"*k)
``` | instruction | 0 | 98,495 | 21 | 196,990 |
Yes | output | 1 | 98,495 | 21 | 196,991 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string S of length N consisting of `(` and `)`. Your task is to insert some number of `(` and `)` into S to obtain a correct bracket sequence.
Here, a correct bracket sequence is defined as follows:
* `()` is a correct bracket sequence.
* If X is a correct bracket sequence, the concatenation of `(`, X and `)` in this order is also a correct bracket sequence.
* If X and Y are correct bracket sequences, the concatenation of X and Y in this order is also a correct bracket sequence.
* Every correct bracket sequence can be derived from the rules above.
Find the shortest correct bracket sequence that can be obtained. If there is more than one such sequence, find the lexicographically smallest one.
Constraints
* The length of S is N.
* 1 ≤ N ≤ 100
* S consists of `(` and `)`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the lexicographically smallest string among the shortest correct bracket sequences that can be obtained by inserting some number of `(` and `)` into S.
Examples
Input
3
())
Output
(())
Input
6
)))())
Output
(((()))())
Input
8
))))((((
Output
(((())))(((())))
Submitted Solution:
```
n = int(input())
s = input()
a=0
b=0
c=0
for c in s:
if c=='(':
a+=1
else:
if a>0:
a-=1
else:
b+=1
s+=')'*a
s = '('*b+s
print(s)
``` | instruction | 0 | 98,496 | 21 | 196,992 |
Yes | output | 1 | 98,496 | 21 | 196,993 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string S of length N consisting of `(` and `)`. Your task is to insert some number of `(` and `)` into S to obtain a correct bracket sequence.
Here, a correct bracket sequence is defined as follows:
* `()` is a correct bracket sequence.
* If X is a correct bracket sequence, the concatenation of `(`, X and `)` in this order is also a correct bracket sequence.
* If X and Y are correct bracket sequences, the concatenation of X and Y in this order is also a correct bracket sequence.
* Every correct bracket sequence can be derived from the rules above.
Find the shortest correct bracket sequence that can be obtained. If there is more than one such sequence, find the lexicographically smallest one.
Constraints
* The length of S is N.
* 1 ≤ N ≤ 100
* S consists of `(` and `)`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the lexicographically smallest string among the shortest correct bracket sequences that can be obtained by inserting some number of `(` and `)` into S.
Examples
Input
3
())
Output
(())
Input
6
)))())
Output
(((()))())
Input
8
))))((((
Output
(((())))(((())))
Submitted Solution:
```
n = int(input())
s = input()
lv = [0] * n
lvi = 0
for i,v in enumerate(s):
if v == '(' :
lvi += 1
else:
lvi -= 1
lv[i] = lvi
l = min(lv)
r = -lv[-1] + l
print('('*(-l) + s + ')'*(-r))
``` | instruction | 0 | 98,497 | 21 | 196,994 |
No | output | 1 | 98,497 | 21 | 196,995 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string S of length N consisting of `(` and `)`. Your task is to insert some number of `(` and `)` into S to obtain a correct bracket sequence.
Here, a correct bracket sequence is defined as follows:
* `()` is a correct bracket sequence.
* If X is a correct bracket sequence, the concatenation of `(`, X and `)` in this order is also a correct bracket sequence.
* If X and Y are correct bracket sequences, the concatenation of X and Y in this order is also a correct bracket sequence.
* Every correct bracket sequence can be derived from the rules above.
Find the shortest correct bracket sequence that can be obtained. If there is more than one such sequence, find the lexicographically smallest one.
Constraints
* The length of S is N.
* 1 ≤ N ≤ 100
* S consists of `(` and `)`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the lexicographically smallest string among the shortest correct bracket sequences that can be obtained by inserting some number of `(` and `)` into S.
Examples
Input
3
())
Output
(())
Input
6
)))())
Output
(((()))())
Input
8
))))((((
Output
(((())))(((())))
Submitted Solution:
```
N = int(input())
S = input()
ss = S.replace(')(', ') (').split()
ans = ''
for s in ss:
a = s.count('(')
b = s.count(')')
ans = '(' * (b - a) + ans + s + ')' * (a - b)
print(ans)
``` | instruction | 0 | 98,498 | 21 | 196,996 |
No | output | 1 | 98,498 | 21 | 196,997 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string S of length N consisting of `(` and `)`. Your task is to insert some number of `(` and `)` into S to obtain a correct bracket sequence.
Here, a correct bracket sequence is defined as follows:
* `()` is a correct bracket sequence.
* If X is a correct bracket sequence, the concatenation of `(`, X and `)` in this order is also a correct bracket sequence.
* If X and Y are correct bracket sequences, the concatenation of X and Y in this order is also a correct bracket sequence.
* Every correct bracket sequence can be derived from the rules above.
Find the shortest correct bracket sequence that can be obtained. If there is more than one such sequence, find the lexicographically smallest one.
Constraints
* The length of S is N.
* 1 ≤ N ≤ 100
* S consists of `(` and `)`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the lexicographically smallest string among the shortest correct bracket sequences that can be obtained by inserting some number of `(` and `)` into S.
Examples
Input
3
())
Output
(())
Input
6
)))())
Output
(((()))())
Input
8
))))((((
Output
(((())))(((())))
Submitted Solution:
```
n=int(input())
s=input()
stack=[]
for c in s:
if len(stack)>0 and stack[-1]=='(' and c==')':
stack.pop()
else:
stack.append(c)
if len(stack)==0:
print(s)
else:
l=0
r=0
for c in stack:
if c==')':
l+=1
else:
r+=1
print('('*l+s+')'*r)
``` | instruction | 0 | 98,499 | 21 | 196,998 |
No | output | 1 | 98,499 | 21 | 196,999 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string S of length N consisting of `(` and `)`. Your task is to insert some number of `(` and `)` into S to obtain a correct bracket sequence.
Here, a correct bracket sequence is defined as follows:
* `()` is a correct bracket sequence.
* If X is a correct bracket sequence, the concatenation of `(`, X and `)` in this order is also a correct bracket sequence.
* If X and Y are correct bracket sequences, the concatenation of X and Y in this order is also a correct bracket sequence.
* Every correct bracket sequence can be derived from the rules above.
Find the shortest correct bracket sequence that can be obtained. If there is more than one such sequence, find the lexicographically smallest one.
Constraints
* The length of S is N.
* 1 ≤ N ≤ 100
* S consists of `(` and `)`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the lexicographically smallest string among the shortest correct bracket sequences that can be obtained by inserting some number of `(` and `)` into S.
Examples
Input
3
())
Output
(())
Input
6
)))())
Output
(((()))())
Input
8
))))((((
Output
(((())))(((())))
Submitted Solution:
```
def main():
#input data
import sys
input = lambda:sys.stdin.readline().strip()
N = int(input())
S = input()
#solve
right=0
left=0
for i in range(N):
if S[i]=='(':
right+=1
else:
left+=1
ans=S
if left<right:
ans=S+(right-left)*')'
if left>right:
ans='('*(left-right)+S
if left==right:
ans='('*(right)+S+')'*(left)
print(ans)
if __name__=='__main__':
main()
``` | instruction | 0 | 98,500 | 21 | 197,000 |
No | output | 1 | 98,500 | 21 | 197,001 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As you know, Vova has recently become a new shaman in the city of Ultima Thule. So, he has received the shaman knowledge about the correct bracket sequences. The shamans of Ultima Thule have been using lots of different types of brackets since prehistoric times. A bracket type is a positive integer. The shamans define a correct bracket sequence as follows:
* An empty sequence is a correct bracket sequence.
* If {a1, a2, ..., al} and {b1, b2, ..., bk} are correct bracket sequences, then sequence {a1, a2, ..., al, b1, b2, ..., bk} (their concatenation) also is a correct bracket sequence.
* If {a1, a2, ..., al} — is a correct bracket sequence, then sequence <image> also is a correct bracket sequence, where v (v > 0) is an integer.
For example, sequences {1, 1, - 1, 2, - 2, - 1} and {3, - 3} are correct bracket sequences, and {2, - 3} is not.
Moreover, after Vova became a shaman, he learned the most important correct bracket sequence {x1, x2, ..., xn}, consisting of n integers. As sequence x is the most important, Vova decided to encrypt it just in case.
Encrypting consists of two sequences. The first sequence {p1, p2, ..., pn} contains types of brackets, that is, pi = |xi| (1 ≤ i ≤ n). The second sequence {q1, q2, ..., qt} contains t integers — some positions (possibly, not all of them), which had negative numbers in sequence {x1, x2, ..., xn}.
Unfortunately, Vova forgot the main sequence. But he was lucky enough to keep the encryption: sequences {p1, p2, ..., pn} and {q1, q2, ..., qt}. Help Vova restore sequence x by the encryption. If there are multiple sequences that correspond to the encryption, restore any of them. If there are no such sequences, you should tell so.
Input
The first line of the input contains integer n (1 ≤ n ≤ 106). The second line contains n integers: p1, p2, ..., pn (1 ≤ pi ≤ 109).
The third line contains integer t (0 ≤ t ≤ n), followed by t distinct integers q1, q2, ..., qt (1 ≤ qi ≤ n).
The numbers in each line are separated by spaces.
Output
Print a single string "NO" (without the quotes) if Vova is mistaken and a suitable sequence {x1, x2, ..., xn} doesn't exist.
Otherwise, in the first line print "YES" (without the quotes) and in the second line print n integers x1, x2, ..., xn (|xi| = pi; xqj < 0). If there are multiple sequences that correspond to the encrypting, you are allowed to print any of them.
Examples
Input
2
1 1
0
Output
YES
1 -1
Input
4
1 1 1 1
1 3
Output
YES
1 1 -1 -1
Input
3
1 1 1
0
Output
NO
Input
4
1 2 2 1
2 3 4
Output
YES
1 2 -2 -1
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
##########################################################
#q.sort(key=lambda x:((x[1]-x[0]),-x[0]))
#from collections import Counter
#from fractions import Fraction
from bisect import bisect_left
from collections import Counter
#s=iter(input())
#from collections import deque
#ls=list(map(int,input().split()))
#for in range(m):
#for _ in range(int(input())):
#n=int(input())
# n,k=map(int,input().split())
# arr=list(map(int,input().split()))
#for i in range(int(input())):
#n=int(input())
#arr=sorted([(x,i) for i,x in enumerate(map(int,input().split()))])[::-1]
#print(arr)
#arr=sorted(list(map(int,input().split())))[::-1]
n=int(input())
if n==1:
print(1)
elif n==2:
print(-1)
else:
print(n-1,end=" ")
print(1,end=" ")
for i in range(2,n+1):
if i==n-1:
continue
print(i,end=" ")
``` | instruction | 0 | 100,632 | 21 | 201,264 |
No | output | 1 | 100,632 | 21 | 201,265 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(". | instruction | 0 | 107,079 | 21 | 214,158 |
Tags: greedy, strings
Correct Solution:
```
_str = str
n, str = int(input()), list(input())
if str[0] == '?': str[0] = '('
if str[-1] == '?': str[-1] = ')'
pp, nn = n//2, n//2
for ch in str:
if ch == '(': pp -= 1
if ch == ')': nn -= 1
if n%2 == 1 or str[0] != '(' or str[-1] != ')' or pp < 0 or nn < 0:
print(':(')
exit(0)
res, sum = [], 0
for ch in str:
if ch == '(':
res.append('(')
sum += 1
elif ch == ')':
res.append(')')
sum -= 1
elif pp > 0:
res.append('(')
sum += 1
pp -= 1
elif nn > 0:
res.append(')')
sum -= 1
nn -= 1
else:
print(':(')
exit(0)
if sum <= 0:
break
if sum == 0 and len(res) == n:
print(_str(res).replace(', ', '').replace('[', '').replace(']', '').replace('\'', ''))
else:
print(':(')
``` | output | 1 | 107,079 | 21 | 214,159 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(". | instruction | 0 | 107,080 | 21 | 214,160 |
Tags: greedy, strings
Correct Solution:
```
import sys
#comment these out later
#sys.stdin = open("in.in", "r")
#sys.stdout = open("out.out", "w")
def main():
inp = sys.stdin.read().split(); ii = 0
n = int(inp[ii]); ii += 1
s = list(inp[ii])
if n%2:
print(":(")
sys.exit()
a = n//2 - s.count("(")
b = n//2 - s.count(")")
if a < 0 or b < 0:
print(":(")
sys.exit()
for i in range(n):
if s[i] == "?":
if a:
s[i] = "("
a -= 1
else:
s[i] = ")"
b -= 1
check = 0
bad = False
for i in range(n-1):
if s[i] == "(":
check += 1
else:
check -= 1
if check <= 0:
bad = True
break
if bad:
print(":(")
else:
print("".join(s))
main()
``` | output | 1 | 107,080 | 21 | 214,161 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(". | instruction | 0 | 107,081 | 21 | 214,162 |
Tags: greedy, strings
Correct Solution:
```
n = int(input())
if n % 2:
print(':(')
exit(0)
s = list(input())
ans = ''
c1, c2 = s.count('('), s.count(')')
cnt90 = 0
cnt9, cnt0 = 0, 0
for i in s[:-1]:
if i == '(':
cnt90 += 1
if cnt9 + cnt90 > n // 2:
print(':(')
exit(0)
ans += i
elif i == ')':
cnt0 += 1
if cnt0 > n // 2:
print(':(')
exit(0)
ans += i
else:
if cnt9 + c1 < n // 2:
ans += '('
cnt9 += 1
else:
ans += ')'
cnt0 += 1
if cnt90 + cnt9 <= cnt0:
print(':(')
exit(0)
if s[-1] == '(' or cnt9 + cnt90 != n // 2:
print(':(')
exit(0)
print(ans + ')')
``` | output | 1 | 107,081 | 21 | 214,163 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(". | instruction | 0 | 107,082 | 21 | 214,164 |
Tags: greedy, strings
Correct Solution:
```
import sys
input=sys.stdin.readline
n=int(input())
a=list(input())
if n%2!=0:
print(":(")
else:
b=a.count("(")
c=a.count(")")
if b>n//2 or c>n//2:
print(":(")
else:
b=n//2-b
c=n//2-c
d=0
for i in range(n):
if a[i]=="?":
a[i]="("
d+=1
if d==b:
break
d=0
for i in range(n):
if a[i]=="?":
a[i]=")"
d+=1
if d==c:
break
d=0
e=0
f=[]
for i in range(n-1):
if a[i]=="(":
d+=1
else:
d+=-1
f.append(d)
if min(f)<1:
e=1
if e==0:
print("".join(a))
else:
print(":(")
``` | output | 1 | 107,082 | 21 | 214,165 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(". | instruction | 0 | 107,083 | 21 | 214,166 |
Tags: greedy, strings
Correct Solution:
```
from __future__ import print_function, division
from sys import stdin, exit
def no_ans():
print(":(")
exit(0)
n = int(stdin.readline())
s = [ch for ch in stdin.readline()[:n]]
if n % 2 == 1 or s[0] == ')' or s[-1] == '(':
no_ans()
s[0] = '('
s[-1] = ')'
cur_open = 0
open_left = (n - 1) // 2 - s[1:n - 1].count('(')
for i, char in enumerate(s[1:n - 1], 1):
if char == '(':
cur_open += 1
elif char == '?' and open_left > 0:
cur_open += 1
open_left -= 1
s[i] = '('
else:
cur_open -= 1
s[i] = ')'
if cur_open < 0:
no_ans()
if cur_open != 0:
no_ans()
print(''.join(s))
``` | output | 1 | 107,083 | 21 | 214,167 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(". | instruction | 0 | 107,084 | 21 | 214,168 |
Tags: greedy, strings
Correct Solution:
```
n = int(input())
s = input()
open = 0
closed = 0
for i in range(n):
if s[i] == '(':
open += 1
elif s[i] == ')':
closed += 1
a = n/2 - open
b = n/2 - closed
ans = ""
openct = 0
closedct = 0
can = True
if n%2 or open > n/2:
can = False
can = False
if can:
for i in range(n):
if s[i] == '?':
if a:
openct += 1
ans += '('
a -= 1
else:
closedct += 1
ans += ')'
elif s[i] == '(':
ans += '('
openct += 1
elif s[i] == ')':
ans += ')'
closedct += 1
if i != n-1:
if closedct >= openct:
can = False
break
if can:
print(ans)
else:
print(':(')
``` | output | 1 | 107,084 | 21 | 214,169 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(". | instruction | 0 | 107,085 | 21 | 214,170 |
Tags: greedy, strings
Correct Solution:
```
n = int(input())
s = [i for i in input()]
o = 0
z = 0
O = s.count('(')
Z = s.count(')')
V = s.count('?')
on = (V - (O - Z)) // 2
flag = 0
if on >= 0:
for i in range(n):
if s[i] == '(':
o += 1
if s[i] == ')':
z += 1
if s[i] == '?':
if on > 0:
s[i] = '('
o += 1
on -= 1
else:
s[i] = ')'
z += 1
if z == o and i != len(s) - 1:
flag = 1
break
if z > o:
flag = 1
break
else:
flag = 1
if z != o:
flag = 1
if flag == 0:
print(*s, sep='')
else:
print(':(')
``` | output | 1 | 107,085 | 21 | 214,171 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(". | instruction | 0 | 107,086 | 21 | 214,172 |
Tags: greedy, strings
Correct Solution:
```
n = int(input())
s = input()
a = []
for i in range(n):
if s[i] == '?':
a.append('(')
else:
a.append(s[i])
cnt = 0
ans = 0
for i in range(n):
if a[i] == '(':
cnt+=1
else:
cnt -= 1
ans = min(ans, cnt)
for i in range(n-1, -1, -1):
if cnt > 0 and s[i] == '?':
cnt -= 2
a[i] = ')'
cnt = 0
b = []
for i in range(n):
if a[i] == '(':
cnt += 1
else:
cnt -= 1
b.append(cnt)
if len(b) == 1 or min(b[:-1]) <= 0 or b[-1] != 0:
ans = -1
if ans < 0:
print(':(')
else:
print(''.join(a))
``` | output | 1 | 107,086 | 21 | 214,173 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School.
In his favorite math class, the teacher taught him the following interesting definitions.
A parenthesis sequence is a string, containing only characters "(" and ")".
A correct parenthesis sequence is a parenthesis sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, parenthesis sequences "()()", "(())" are correct (the resulting expressions are: "(1+1)+(1+1)", "((1+1)+1)"), while ")(" and ")" are not. Note that the empty string is a correct parenthesis sequence by definition.
We define that |s| as the length of string s. A strict prefix s[1... l] (1≤ l< |s|) of a string s = s_1s_2... s_{|s|} is string s_1s_2... s_l. Note that the empty string and the whole string are not strict prefixes of any string by the definition.
Having learned these definitions, he comes up with a new problem. He writes down a string s containing only characters "(", ")" and "?". And what he is going to do, is to replace each of the "?" in s independently by one of "(" and ")" to make all strict prefixes of the new sequence not a correct parenthesis sequence, while the new sequence should be a correct parenthesis sequence.
After all, he is just a primary school student so this problem is too hard for him to solve. As his best friend, can you help him to replace the question marks? If there are many solutions, any of them is acceptable.
Input
The first line contains a single integer |s| (1≤ |s|≤ 3 ⋅ 10^5), the length of the string.
The second line contains a string s, containing only "(", ")" and "?".
Output
A single line contains a string representing the answer.
If there are many solutions, any of them is acceptable.
If there is no answer, print a single line containing ":(" (without the quotes).
Examples
Input
6
(?????
Output
(()())
Input
10
(???(???(?
Output
:(
Note
It can be proved that there is no solution for the second sample, so print ":(".
Submitted Solution:
```
n = int(input(''))
s = list(input(''))
x = 0
y = 0
p = 0
q = 0
z = 0
m = 0
for i in range(n):
if s[i] == '(':
m += 1
if n % 2 == 1:
print(':(')
else:
for i in range(n-1):
if s[-i-1] == '(':
x += 1
else:
y += 1
if s[i] == ')':
p += 1
else:
q += 1
if x >= y:
z = 1
break
if p >= q:
z = 1
break
if z == 1:
print(':(')
else:
for i in range(n):
if s[i] == '?':
if m >= n//2:
s[i] = ')'
else:
s[i] = '('
m += 1
print(s[i], end='')
``` | instruction | 0 | 107,087 | 21 | 214,174 |
Yes | output | 1 | 107,087 | 21 | 214,175 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.