message
stringlengths 2
23.8k
| message_type
stringclasses 2
values | message_id
int64 0
1
| conversation_id
int64 97
109k
| cluster
float64 0
0
| __index_level_0__
int64 194
217k
|
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string q. A sequence of k strings s1, s2, ..., sk is called beautiful, if the concatenation of these strings is string q (formally, s1 + s2 + ... + sk = q) and the first characters of these strings are distinct.
Find any beautiful sequence of strings or determine that the beautiful sequence doesn't exist.
Input
The first line contains a positive integer k (1 β€ k β€ 26) β the number of strings that should be in a beautiful sequence.
The second line contains string q, consisting of lowercase Latin letters. The length of the string is within range from 1 to 100, inclusive.
Output
If such sequence doesn't exist, then print in a single line "NO" (without the quotes). Otherwise, print in the first line "YES" (without the quotes) and in the next k lines print the beautiful sequence of strings s1, s2, ..., sk.
If there are multiple possible answers, print any of them.
Examples
Input
1
abca
Output
YES
abca
Input
2
aaacas
Output
YES
aaa
cas
Input
4
abc
Output
NO
Note
In the second sample there are two possible answers: {"aaaca", "s"} and {"aaa", "cas"}.
|
instruction
| 0
| 2,027
| 0
| 4,054
|
Tags: implementation, strings
Correct Solution:
```
k = int(input())
s = input()
ans = []
cur = ""
se = set()
for i in range(len(s)):
if s[i] not in se:
if len(cur) > 0:
ans.append(cur)
cur = ""
cur = s[i]
se.add(s[i])
else:
cur += s[i]
if cur:
ans.append(cur)
l = len(ans)
if len(ans) < k:
print("NO")
else:
print("YES")
for i in range(k, len(ans)):
ans[k-1] += ans[i]
print("\n".join(ans[:k]))
```
|
output
| 1
| 2,027
| 0
| 4,055
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string q. A sequence of k strings s1, s2, ..., sk is called beautiful, if the concatenation of these strings is string q (formally, s1 + s2 + ... + sk = q) and the first characters of these strings are distinct.
Find any beautiful sequence of strings or determine that the beautiful sequence doesn't exist.
Input
The first line contains a positive integer k (1 β€ k β€ 26) β the number of strings that should be in a beautiful sequence.
The second line contains string q, consisting of lowercase Latin letters. The length of the string is within range from 1 to 100, inclusive.
Output
If such sequence doesn't exist, then print in a single line "NO" (without the quotes). Otherwise, print in the first line "YES" (without the quotes) and in the next k lines print the beautiful sequence of strings s1, s2, ..., sk.
If there are multiple possible answers, print any of them.
Examples
Input
1
abca
Output
YES
abca
Input
2
aaacas
Output
YES
aaa
cas
Input
4
abc
Output
NO
Note
In the second sample there are two possible answers: {"aaaca", "s"} and {"aaa", "cas"}.
|
instruction
| 0
| 2,028
| 0
| 4,056
|
Tags: implementation, strings
Correct Solution:
```
# 544A
# O(|q|) time
# O(|q|) space
__author__ = 'artyom'
# SOLUTION
def main():
b = [False] * 26
n = read()
s = read(0)
if n == 1:
return ['YES', s]
tokens = ['YES']
token = ''
i = 1
p = 0
for c in s:
if not b[ord(c) - 97]:
b[ord(c) - 97] = True
if token:
tokens.append(token)
i += 1
if i == n:
break
else:
token = ''
token += c
p += 1
tokens.append(s[p:])
if len(tokens) - 1 < n:
return 'NO'
return tokens
# HELPERS
def read(mode=1, size=None):
# 0: String
# 1: Integer
# 2: List of strings
# 3: List of integers
# 4: Matrix of integers
if mode == 0: return input().strip()
if mode == 1: return int(input().strip())
if mode == 2: return input().strip().split()
if mode == 3: return list(map(int, input().strip().split()))
a = []
for _ in range(size):
a.append(read(3))
return a
def write(s="\n"):
if s is None: s = ''
if isinstance(s, tuple) or isinstance(s, list): s = '\n'.join(map(str, s))
s = str(s)
print(s, end="\n")
write(main())
```
|
output
| 1
| 2,028
| 0
| 4,057
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string q. A sequence of k strings s1, s2, ..., sk is called beautiful, if the concatenation of these strings is string q (formally, s1 + s2 + ... + sk = q) and the first characters of these strings are distinct.
Find any beautiful sequence of strings or determine that the beautiful sequence doesn't exist.
Input
The first line contains a positive integer k (1 β€ k β€ 26) β the number of strings that should be in a beautiful sequence.
The second line contains string q, consisting of lowercase Latin letters. The length of the string is within range from 1 to 100, inclusive.
Output
If such sequence doesn't exist, then print in a single line "NO" (without the quotes). Otherwise, print in the first line "YES" (without the quotes) and in the next k lines print the beautiful sequence of strings s1, s2, ..., sk.
If there are multiple possible answers, print any of them.
Examples
Input
1
abca
Output
YES
abca
Input
2
aaacas
Output
YES
aaa
cas
Input
4
abc
Output
NO
Note
In the second sample there are two possible answers: {"aaaca", "s"} and {"aaa", "cas"}.
|
instruction
| 0
| 2,029
| 0
| 4,058
|
Tags: implementation, strings
Correct Solution:
```
import sys
import math
import bisect
def solve(s, k):
d = dict()
for i in range(len(s)):
if s[i] not in d:
d[s[i]] = i
A = list(d.values())
#print('s: %s, k: %d, A: %s' % (s, k, A))
if len(A) < k:
return None
B = []
for i in range(k):
if i == k - 1:
B.append(s[A[i]:])
else:
B.append(s[A[i]:A[i+1]])
return B
def main():
k = int(input())
s = input()
ans = solve(s, k)
if ans:
print('YES')
for a in ans:
print(a)
else:
print('NO')
if __name__ == "__main__":
main()
```
|
output
| 1
| 2,029
| 0
| 4,059
|
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 q. A sequence of k strings s1, s2, ..., sk is called beautiful, if the concatenation of these strings is string q (formally, s1 + s2 + ... + sk = q) and the first characters of these strings are distinct.
Find any beautiful sequence of strings or determine that the beautiful sequence doesn't exist.
Input
The first line contains a positive integer k (1 β€ k β€ 26) β the number of strings that should be in a beautiful sequence.
The second line contains string q, consisting of lowercase Latin letters. The length of the string is within range from 1 to 100, inclusive.
Output
If such sequence doesn't exist, then print in a single line "NO" (without the quotes). Otherwise, print in the first line "YES" (without the quotes) and in the next k lines print the beautiful sequence of strings s1, s2, ..., sk.
If there are multiple possible answers, print any of them.
Examples
Input
1
abca
Output
YES
abca
Input
2
aaacas
Output
YES
aaa
cas
Input
4
abc
Output
NO
Note
In the second sample there are two possible answers: {"aaaca", "s"} and {"aaa", "cas"}.
Submitted Solution:
```
n = int(input())
q = input()
if n > len(q):
print("NO")
else:
if n == 1:
print("YES")
print(q)
else:
arr = [0]*len(q)
for x in range(0, len(q)):
arr[x] = q[x]
con = arr[0]
res = []
count = 0
x = 0
used = ["-1"]*len(q)
used[0] = con
usedCount = 0
while count < n-1:
if x + 1 < len(arr) and (arr[x] == arr[x+1] or arr[x+1] in used):
con += arr[x+1]
x += 1
else:
res.append(con)
usedCount += 1
if x + 1 < len(arr):
used[usedCount] = arr[x+1]
con = arr[x+1]
count +=1
x += 1
totalLen = 0
for x in range(0, count):
totalLen += len(res[x])
res.append(q[totalLen:])
for x in res:
if x.isspace() or x == "":
res.remove(x)
res1 = set(res)
length = 0
for each in res1:
length += 1
if res[len(res) - 1] == "-1" or length < n:
print("NO")
else:
print("YES")
for x in res:
print(x)
```
|
instruction
| 0
| 2,030
| 0
| 4,060
|
Yes
|
output
| 1
| 2,030
| 0
| 4,061
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string q. A sequence of k strings s1, s2, ..., sk is called beautiful, if the concatenation of these strings is string q (formally, s1 + s2 + ... + sk = q) and the first characters of these strings are distinct.
Find any beautiful sequence of strings or determine that the beautiful sequence doesn't exist.
Input
The first line contains a positive integer k (1 β€ k β€ 26) β the number of strings that should be in a beautiful sequence.
The second line contains string q, consisting of lowercase Latin letters. The length of the string is within range from 1 to 100, inclusive.
Output
If such sequence doesn't exist, then print in a single line "NO" (without the quotes). Otherwise, print in the first line "YES" (without the quotes) and in the next k lines print the beautiful sequence of strings s1, s2, ..., sk.
If there are multiple possible answers, print any of them.
Examples
Input
1
abca
Output
YES
abca
Input
2
aaacas
Output
YES
aaa
cas
Input
4
abc
Output
NO
Note
In the second sample there are two possible answers: {"aaaca", "s"} and {"aaa", "cas"}.
Submitted Solution:
```
n = int(input())
s = input()
a = []
if len(s) < n:
print ("NO")
else:
for i in s:
if len(a) == n:
break
if i in a:
continue
else:
a.append(i)
l = []
for i in range(len(a)):
if i == len(a)-1:
l.append(s[s.index(a[i]):])
else:
l.append(s[s.index(a[i]):s.index(a[i+1])])
if len(a) == n:
print ("YES")
for i in l:
print (i)
else:
print ("NO")
```
|
instruction
| 0
| 2,031
| 0
| 4,062
|
Yes
|
output
| 1
| 2,031
| 0
| 4,063
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string q. A sequence of k strings s1, s2, ..., sk is called beautiful, if the concatenation of these strings is string q (formally, s1 + s2 + ... + sk = q) and the first characters of these strings are distinct.
Find any beautiful sequence of strings or determine that the beautiful sequence doesn't exist.
Input
The first line contains a positive integer k (1 β€ k β€ 26) β the number of strings that should be in a beautiful sequence.
The second line contains string q, consisting of lowercase Latin letters. The length of the string is within range from 1 to 100, inclusive.
Output
If such sequence doesn't exist, then print in a single line "NO" (without the quotes). Otherwise, print in the first line "YES" (without the quotes) and in the next k lines print the beautiful sequence of strings s1, s2, ..., sk.
If there are multiple possible answers, print any of them.
Examples
Input
1
abca
Output
YES
abca
Input
2
aaacas
Output
YES
aaa
cas
Input
4
abc
Output
NO
Note
In the second sample there are two possible answers: {"aaaca", "s"} and {"aaa", "cas"}.
Submitted Solution:
```
K = int(input())
used = set()
S = input()
indexes = []
ind = 0
while len(indexes) < K and ind < len(S):
if S[ind] not in used:
indexes += [ind]
used.add(S[ind])
ind += 1
if len(indexes) < K:
print("NO")
else:
print("YES")
for i, v in enumerate(indexes):
if i == len(indexes) - 1:
print(S[v:])
else:
print(S[v:indexes[i+1]])
```
|
instruction
| 0
| 2,032
| 0
| 4,064
|
Yes
|
output
| 1
| 2,032
| 0
| 4,065
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string q. A sequence of k strings s1, s2, ..., sk is called beautiful, if the concatenation of these strings is string q (formally, s1 + s2 + ... + sk = q) and the first characters of these strings are distinct.
Find any beautiful sequence of strings or determine that the beautiful sequence doesn't exist.
Input
The first line contains a positive integer k (1 β€ k β€ 26) β the number of strings that should be in a beautiful sequence.
The second line contains string q, consisting of lowercase Latin letters. The length of the string is within range from 1 to 100, inclusive.
Output
If such sequence doesn't exist, then print in a single line "NO" (without the quotes). Otherwise, print in the first line "YES" (without the quotes) and in the next k lines print the beautiful sequence of strings s1, s2, ..., sk.
If there are multiple possible answers, print any of them.
Examples
Input
1
abca
Output
YES
abca
Input
2
aaacas
Output
YES
aaa
cas
Input
4
abc
Output
NO
Note
In the second sample there are two possible answers: {"aaaca", "s"} and {"aaa", "cas"}.
Submitted Solution:
```
r = lambda : map(int,input().split())
import sys
n = int(input())
s = input()
q = set()
if n>len(set(s)) :
print('NO')
else :
print('YES')
k = 0
ans = []
for i in range(len(s)) :
if k==n : break
if s[i] not in q :
ans.append(i)
q.add(s[i])
k+=1
ans.append(len(s))
for i in range(len(ans)-1) :
print(s[ans[i]:ans[i+1]])
```
|
instruction
| 0
| 2,033
| 0
| 4,066
|
Yes
|
output
| 1
| 2,033
| 0
| 4,067
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string q. A sequence of k strings s1, s2, ..., sk is called beautiful, if the concatenation of these strings is string q (formally, s1 + s2 + ... + sk = q) and the first characters of these strings are distinct.
Find any beautiful sequence of strings or determine that the beautiful sequence doesn't exist.
Input
The first line contains a positive integer k (1 β€ k β€ 26) β the number of strings that should be in a beautiful sequence.
The second line contains string q, consisting of lowercase Latin letters. The length of the string is within range from 1 to 100, inclusive.
Output
If such sequence doesn't exist, then print in a single line "NO" (without the quotes). Otherwise, print in the first line "YES" (without the quotes) and in the next k lines print the beautiful sequence of strings s1, s2, ..., sk.
If there are multiple possible answers, print any of them.
Examples
Input
1
abca
Output
YES
abca
Input
2
aaacas
Output
YES
aaa
cas
Input
4
abc
Output
NO
Note
In the second sample there are two possible answers: {"aaaca", "s"} and {"aaa", "cas"}.
Submitted Solution:
```
n = int(input())
q = input()
if n > len(q):
print("NO")
else:
if n == 1:
print("YES")
print(q)
else:
arr = [0]*len(q)
for x in range(0, len(q)):
arr[x] = q[x]
con = arr[0]
res = ["-1"]*n
count = 0
x = 0
while(count < n-1):
if arr[x] == arr[x+1]:
con += arr[x+1]
x += 1
else:
res[count] = con
con = arr[x+1]
count +=1
x += 1
res[count] = q[3:]
res1 = set(res)
length = 0
for each in res1:
length += 1
if res[len(res) - 1] == "-1" or length < n:
print("NO")
else:
print("YES")
for x in res:
print(x)
```
|
instruction
| 0
| 2,034
| 0
| 4,068
|
No
|
output
| 1
| 2,034
| 0
| 4,069
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string q. A sequence of k strings s1, s2, ..., sk is called beautiful, if the concatenation of these strings is string q (formally, s1 + s2 + ... + sk = q) and the first characters of these strings are distinct.
Find any beautiful sequence of strings or determine that the beautiful sequence doesn't exist.
Input
The first line contains a positive integer k (1 β€ k β€ 26) β the number of strings that should be in a beautiful sequence.
The second line contains string q, consisting of lowercase Latin letters. The length of the string is within range from 1 to 100, inclusive.
Output
If such sequence doesn't exist, then print in a single line "NO" (without the quotes). Otherwise, print in the first line "YES" (without the quotes) and in the next k lines print the beautiful sequence of strings s1, s2, ..., sk.
If there are multiple possible answers, print any of them.
Examples
Input
1
abca
Output
YES
abca
Input
2
aaacas
Output
YES
aaa
cas
Input
4
abc
Output
NO
Note
In the second sample there are two possible answers: {"aaaca", "s"} and {"aaa", "cas"}.
Submitted Solution:
```
from collections import defaultdict
def cutter(a, cuts):
if cuts == 1:
return [a]
comparador = set([a[0]])
aux = a[0]
ans = []
flag = True
for i in range(1, len(a)):
# print(a[i])
if a[i] not in comparador:
ans.append(aux)
aux = a[i]
comparador.union(set([a[i]]))
else:
aux += a[i]
# print(aux)
if len(ans) == cuts - 1 :
ans.append(a[i:])
break
return ans
def isBeautiful(a):
mapa = defaultdict(int)
for i in a:
mapa[i[0]] += 1
if mapa[i[0]] > 1:
return False
return True
def func():
n = int(input())
p = input()
if len(p) < n:
print('NO')
return
lista = cutter(p, n)
# print(lista)
if len(lista) < n:
print('NO')
return
if isBeautiful(lista):
print('YES')
for i in lista:
print(i)
else:
print('NO')
return
func()
```
|
instruction
| 0
| 2,035
| 0
| 4,070
|
No
|
output
| 1
| 2,035
| 0
| 4,071
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string q. A sequence of k strings s1, s2, ..., sk is called beautiful, if the concatenation of these strings is string q (formally, s1 + s2 + ... + sk = q) and the first characters of these strings are distinct.
Find any beautiful sequence of strings or determine that the beautiful sequence doesn't exist.
Input
The first line contains a positive integer k (1 β€ k β€ 26) β the number of strings that should be in a beautiful sequence.
The second line contains string q, consisting of lowercase Latin letters. The length of the string is within range from 1 to 100, inclusive.
Output
If such sequence doesn't exist, then print in a single line "NO" (without the quotes). Otherwise, print in the first line "YES" (without the quotes) and in the next k lines print the beautiful sequence of strings s1, s2, ..., sk.
If there are multiple possible answers, print any of them.
Examples
Input
1
abca
Output
YES
abca
Input
2
aaacas
Output
YES
aaa
cas
Input
4
abc
Output
NO
Note
In the second sample there are two possible answers: {"aaaca", "s"} and {"aaa", "cas"}.
Submitted Solution:
```
N = int(input())
S = input()
found = set()
for i in range(len(S)):
k = S[i]
if(not (k in found)):
found.add(k)
if(len(found)>=N):
print("YES")
ptr1 = 0
count = 0
found.remove(S[ptr1])
for i in range(len(S)):
#print (found)
if(count==N-1):
print(S[ptr1:])
break
if(i>0 and (S[i] in found)):
print(S[ptr1:i])
ptr1=i
count+=1
found.remove(S[ptr1])
else:
print("NO")
```
|
instruction
| 0
| 2,036
| 0
| 4,072
|
No
|
output
| 1
| 2,036
| 0
| 4,073
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string q. A sequence of k strings s1, s2, ..., sk is called beautiful, if the concatenation of these strings is string q (formally, s1 + s2 + ... + sk = q) and the first characters of these strings are distinct.
Find any beautiful sequence of strings or determine that the beautiful sequence doesn't exist.
Input
The first line contains a positive integer k (1 β€ k β€ 26) β the number of strings that should be in a beautiful sequence.
The second line contains string q, consisting of lowercase Latin letters. The length of the string is within range from 1 to 100, inclusive.
Output
If such sequence doesn't exist, then print in a single line "NO" (without the quotes). Otherwise, print in the first line "YES" (without the quotes) and in the next k lines print the beautiful sequence of strings s1, s2, ..., sk.
If there are multiple possible answers, print any of them.
Examples
Input
1
abca
Output
YES
abca
Input
2
aaacas
Output
YES
aaa
cas
Input
4
abc
Output
NO
Note
In the second sample there are two possible answers: {"aaaca", "s"} and {"aaa", "cas"}.
Submitted Solution:
```
# http://codeforces.com/problemset/problem/544/A
def main():
n = int(input())
s = str(input())
if n > len(s):
print('NO')
return
elif n == 1:
print('YES')
print(s)
else:
strings = []
letters = len(set(list(s)))
if letters < n:
print('NO')
return
curr = s[0]
comp = s[0]
used = {s[0]: 1}
cant = 0
for i in range(1, len(s)):
if s[i] == comp:
curr += s[i]
else:
check = used.get(s[i], -1)
if check != -1:
curr += s[i]
if i == len(s) - 1:
strings.append(curr)
break
continue
else:
strings.append(curr)
cant += 1
if cant == n:
strings[-1] = strings[-1] + s[i:]
break
curr = s[i]
comp = s[i]
used[comp] = 1
if i == len(s) - 1:
strings.append(curr)
break
print('YES')
for i in strings:
print(i)
main()
```
|
instruction
| 0
| 2,037
| 0
| 4,074
|
No
|
output
| 1
| 2,037
| 0
| 4,075
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Daniel has a string s, consisting of lowercase English letters and period signs (characters '.'). Let's define the operation of replacement as the following sequence of steps: find a substring ".." (two consecutive periods) in string s, of all occurrences of the substring let's choose the first one, and replace this substring with string ".". In other words, during the replacement operation, the first two consecutive periods are replaced by one. If string s contains no two consecutive periods, then nothing happens.
Let's define f(s) as the minimum number of operations of replacement to perform, so that the string does not have any two consecutive periods left.
You need to process m queries, the i-th results in that the character at position xi (1 β€ xi β€ n) of string s is assigned value ci. After each operation you have to calculate and output the value of f(s).
Help Daniel to process all queries.
Input
The first line contains two integers n and m (1 β€ n, m β€ 300 000) the length of the string and the number of queries.
The second line contains string s, consisting of n lowercase English letters and period signs.
The following m lines contain the descriptions of queries. The i-th line contains integer xi and ci (1 β€ xi β€ n, ci β a lowercas English letter or a period sign), describing the query of assigning symbol ci to position xi.
Output
Print m numbers, one per line, the i-th of these numbers must be equal to the value of f(s) after performing the i-th assignment.
Examples
Input
10 3
.b..bz....
1 h
3 c
9 f
Output
4
3
1
Input
4 4
.cc.
2 .
3 .
2 a
1 a
Output
1
3
1
1
Note
Note to the first sample test (replaced periods are enclosed in square brackets).
The original string is ".b..bz....".
* after the first query f(hb..bz....) = 4 ("hb[..]bz...." β "hb.bz[..].." β "hb.bz[..]." β "hb.bz[..]" β "hb.bz.")
* after the second query f(hbΡ.bz....) = 3 ("hbΡ.bz[..].." β "hbΡ.bz[..]." β "hbΡ.bz[..]" β "hbΡ.bz.")
* after the third query f(hbΡ.bz..f.) = 1 ("hbΡ.bz[..]f." β "hbΡ.bz.f.")
Note to the second sample test.
The original string is ".cc.".
* after the first query: f(..c.) = 1 ("[..]c." β ".c.")
* after the second query: f(....) = 3 ("[..].." β "[..]." β "[..]" β ".")
* after the third query: f(.a..) = 1 (".a[..]" β ".a.")
* after the fourth query: f(aa..) = 1 ("aa[..]" β "aa.")
|
instruction
| 0
| 2,038
| 0
| 4,076
|
Tags: constructive algorithms, data structures, implementation
Correct Solution:
```
(n, m) = (int(t) for t in input().split())
s = [c for c in input()]
fs = 0
for i in range(1, len(s)):
if s[i] == '.' and s[i - 1] == '.':
fs += 1
out = []
for k in range(m):
t = input().split()
i = int(t[0]) - 1
c = t[1]
if (c == '.') != (s[i] == '.'):
if i - 1 > -1 and s[i - 1] == '.':
fs += 1 if c == '.' else -1
if i + 1 < len(s) and s[i + 1] == '.':
fs += 1 if c == '.' else -1
s[i] = c
out.append(str(fs))
out.append('\n')
print(''.join(out), end='')
```
|
output
| 1
| 2,038
| 0
| 4,077
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Daniel has a string s, consisting of lowercase English letters and period signs (characters '.'). Let's define the operation of replacement as the following sequence of steps: find a substring ".." (two consecutive periods) in string s, of all occurrences of the substring let's choose the first one, and replace this substring with string ".". In other words, during the replacement operation, the first two consecutive periods are replaced by one. If string s contains no two consecutive periods, then nothing happens.
Let's define f(s) as the minimum number of operations of replacement to perform, so that the string does not have any two consecutive periods left.
You need to process m queries, the i-th results in that the character at position xi (1 β€ xi β€ n) of string s is assigned value ci. After each operation you have to calculate and output the value of f(s).
Help Daniel to process all queries.
Input
The first line contains two integers n and m (1 β€ n, m β€ 300 000) the length of the string and the number of queries.
The second line contains string s, consisting of n lowercase English letters and period signs.
The following m lines contain the descriptions of queries. The i-th line contains integer xi and ci (1 β€ xi β€ n, ci β a lowercas English letter or a period sign), describing the query of assigning symbol ci to position xi.
Output
Print m numbers, one per line, the i-th of these numbers must be equal to the value of f(s) after performing the i-th assignment.
Examples
Input
10 3
.b..bz....
1 h
3 c
9 f
Output
4
3
1
Input
4 4
.cc.
2 .
3 .
2 a
1 a
Output
1
3
1
1
Note
Note to the first sample test (replaced periods are enclosed in square brackets).
The original string is ".b..bz....".
* after the first query f(hb..bz....) = 4 ("hb[..]bz...." β "hb.bz[..].." β "hb.bz[..]." β "hb.bz[..]" β "hb.bz.")
* after the second query f(hbΡ.bz....) = 3 ("hbΡ.bz[..].." β "hbΡ.bz[..]." β "hbΡ.bz[..]" β "hbΡ.bz.")
* after the third query f(hbΡ.bz..f.) = 1 ("hbΡ.bz[..]f." β "hbΡ.bz.f.")
Note to the second sample test.
The original string is ".cc.".
* after the first query: f(..c.) = 1 ("[..]c." β ".c.")
* after the second query: f(....) = 3 ("[..].." β "[..]." β "[..]" β ".")
* after the third query: f(.a..) = 1 (".a[..]" β ".a.")
* after the fourth query: f(aa..) = 1 ("aa[..]" β "aa.")
|
instruction
| 0
| 2,039
| 0
| 4,078
|
Tags: constructive algorithms, data structures, implementation
Correct Solution:
```
import math,sys,bisect,heapq
from collections import defaultdict,Counter,deque
from itertools import groupby,accumulate
from functools import lru_cache
from heapq import heapify,heappop,heappush
#sys.setrecursionlimit(200000000)
int1 = lambda x: int(x) - 1
#def input(): return sys.stdin.readline().strip()m
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
aj = lambda: list(map(int, input().split()))
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
#MOD = 1000000000 + 7
def Y(c): print(["NO","YES"][c])
def y(c): print(["no","yes"][c])
def Yy(c): print(["No","Yes"][c])
n,m = aj()
s = ['$'] + [*input()] + ['$']
count = 0
for i in range(len(s)-1):
if s[i] == s[i+1] == '.':
count += 1
for i in range(m):
a,b = input().split()
a = int(a)
if s[a] == b == '.':
print(count)
elif s[a] != '.' and b!= '.':
print(count)
elif s[a] == '.':
if s[a-1] == '.':
count -= 1
if s[a+1] == '.':
count -= 1
print(count)
s[a] = b
else:
if s[a-1] == '.':
count += 1
if s[a+1] == '.':
count += 1
print(count)
s[a] = b
```
|
output
| 1
| 2,039
| 0
| 4,079
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Daniel has a string s, consisting of lowercase English letters and period signs (characters '.'). Let's define the operation of replacement as the following sequence of steps: find a substring ".." (two consecutive periods) in string s, of all occurrences of the substring let's choose the first one, and replace this substring with string ".". In other words, during the replacement operation, the first two consecutive periods are replaced by one. If string s contains no two consecutive periods, then nothing happens.
Let's define f(s) as the minimum number of operations of replacement to perform, so that the string does not have any two consecutive periods left.
You need to process m queries, the i-th results in that the character at position xi (1 β€ xi β€ n) of string s is assigned value ci. After each operation you have to calculate and output the value of f(s).
Help Daniel to process all queries.
Input
The first line contains two integers n and m (1 β€ n, m β€ 300 000) the length of the string and the number of queries.
The second line contains string s, consisting of n lowercase English letters and period signs.
The following m lines contain the descriptions of queries. The i-th line contains integer xi and ci (1 β€ xi β€ n, ci β a lowercas English letter or a period sign), describing the query of assigning symbol ci to position xi.
Output
Print m numbers, one per line, the i-th of these numbers must be equal to the value of f(s) after performing the i-th assignment.
Examples
Input
10 3
.b..bz....
1 h
3 c
9 f
Output
4
3
1
Input
4 4
.cc.
2 .
3 .
2 a
1 a
Output
1
3
1
1
Note
Note to the first sample test (replaced periods are enclosed in square brackets).
The original string is ".b..bz....".
* after the first query f(hb..bz....) = 4 ("hb[..]bz...." β "hb.bz[..].." β "hb.bz[..]." β "hb.bz[..]" β "hb.bz.")
* after the second query f(hbΡ.bz....) = 3 ("hbΡ.bz[..].." β "hbΡ.bz[..]." β "hbΡ.bz[..]" β "hbΡ.bz.")
* after the third query f(hbΡ.bz..f.) = 1 ("hbΡ.bz[..]f." β "hbΡ.bz.f.")
Note to the second sample test.
The original string is ".cc.".
* after the first query: f(..c.) = 1 ("[..]c." β ".c.")
* after the second query: f(....) = 3 ("[..].." β "[..]." β "[..]" β ".")
* after the third query: f(.a..) = 1 (".a[..]" β ".a.")
* after the fourth query: f(aa..) = 1 ("aa[..]" β "aa.")
|
instruction
| 0
| 2,040
| 0
| 4,080
|
Tags: constructive algorithms, data structures, implementation
Correct Solution:
```
def solve(string, updates):
count = sum(string) - sum([not string[i] and string[i + 1]
for i in range(len(string) - 1)])
for (pos, val) in updates:
if string[pos] != val:
sign = 1 if val else -1
count += sign
count += sign * (string[pos - 1] and string[pos + 1])
count -= sign * (not string[pos - 1] and not string[pos + 1])
string[pos] = val
yield count
def read_input():
from sys import stdin
input_lines = stdin.readline
(n, m) = map(int, input_lines().split())
string = [False] + [c == '.' for c in input_lines()] + [False]
def parse_update(line):
pos, val = line.split()
return int(pos), val == '.'
updates = (parse_update(input_lines()) for _ in range(m))
return string, updates
def main():
string, updates = read_input()
for x in solve(string, updates):
print(x)
main()
```
|
output
| 1
| 2,040
| 0
| 4,081
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Daniel has a string s, consisting of lowercase English letters and period signs (characters '.'). Let's define the operation of replacement as the following sequence of steps: find a substring ".." (two consecutive periods) in string s, of all occurrences of the substring let's choose the first one, and replace this substring with string ".". In other words, during the replacement operation, the first two consecutive periods are replaced by one. If string s contains no two consecutive periods, then nothing happens.
Let's define f(s) as the minimum number of operations of replacement to perform, so that the string does not have any two consecutive periods left.
You need to process m queries, the i-th results in that the character at position xi (1 β€ xi β€ n) of string s is assigned value ci. After each operation you have to calculate and output the value of f(s).
Help Daniel to process all queries.
Input
The first line contains two integers n and m (1 β€ n, m β€ 300 000) the length of the string and the number of queries.
The second line contains string s, consisting of n lowercase English letters and period signs.
The following m lines contain the descriptions of queries. The i-th line contains integer xi and ci (1 β€ xi β€ n, ci β a lowercas English letter or a period sign), describing the query of assigning symbol ci to position xi.
Output
Print m numbers, one per line, the i-th of these numbers must be equal to the value of f(s) after performing the i-th assignment.
Examples
Input
10 3
.b..bz....
1 h
3 c
9 f
Output
4
3
1
Input
4 4
.cc.
2 .
3 .
2 a
1 a
Output
1
3
1
1
Note
Note to the first sample test (replaced periods are enclosed in square brackets).
The original string is ".b..bz....".
* after the first query f(hb..bz....) = 4 ("hb[..]bz...." β "hb.bz[..].." β "hb.bz[..]." β "hb.bz[..]" β "hb.bz.")
* after the second query f(hbΡ.bz....) = 3 ("hbΡ.bz[..].." β "hbΡ.bz[..]." β "hbΡ.bz[..]" β "hbΡ.bz.")
* after the third query f(hbΡ.bz..f.) = 1 ("hbΡ.bz[..]f." β "hbΡ.bz.f.")
Note to the second sample test.
The original string is ".cc.".
* after the first query: f(..c.) = 1 ("[..]c." β ".c.")
* after the second query: f(....) = 3 ("[..].." β "[..]." β "[..]" β ".")
* after the third query: f(.a..) = 1 (".a[..]" β ".a.")
* after the fourth query: f(aa..) = 1 ("aa[..]" β "aa.")
|
instruction
| 0
| 2,041
| 0
| 4,082
|
Tags: constructive algorithms, data structures, implementation
Correct Solution:
```
n, m = map(int, input().split())
a = list(input())
res=0
b = []
for i in range(1, n):
if a[i]+a[i-1] =='..':
res += 1
for i in range(m):
g, c = input().split()
p = int(g)-1
if p > 0 and a[p-1] + a[p] == '..':
res -= 1
if p + 1 < n and a[p+1] + a[p] == '..':
res -= 1
a[p] = c
if p > 0 and a[p-1] + a[p] == '..':
res += 1
if p + 1 < n and a[p+1] + a[p] == '..':
res += 1
b.append(str(res))
print(' '.join(b))
```
|
output
| 1
| 2,041
| 0
| 4,083
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Daniel has a string s, consisting of lowercase English letters and period signs (characters '.'). Let's define the operation of replacement as the following sequence of steps: find a substring ".." (two consecutive periods) in string s, of all occurrences of the substring let's choose the first one, and replace this substring with string ".". In other words, during the replacement operation, the first two consecutive periods are replaced by one. If string s contains no two consecutive periods, then nothing happens.
Let's define f(s) as the minimum number of operations of replacement to perform, so that the string does not have any two consecutive periods left.
You need to process m queries, the i-th results in that the character at position xi (1 β€ xi β€ n) of string s is assigned value ci. After each operation you have to calculate and output the value of f(s).
Help Daniel to process all queries.
Input
The first line contains two integers n and m (1 β€ n, m β€ 300 000) the length of the string and the number of queries.
The second line contains string s, consisting of n lowercase English letters and period signs.
The following m lines contain the descriptions of queries. The i-th line contains integer xi and ci (1 β€ xi β€ n, ci β a lowercas English letter or a period sign), describing the query of assigning symbol ci to position xi.
Output
Print m numbers, one per line, the i-th of these numbers must be equal to the value of f(s) after performing the i-th assignment.
Examples
Input
10 3
.b..bz....
1 h
3 c
9 f
Output
4
3
1
Input
4 4
.cc.
2 .
3 .
2 a
1 a
Output
1
3
1
1
Note
Note to the first sample test (replaced periods are enclosed in square brackets).
The original string is ".b..bz....".
* after the first query f(hb..bz....) = 4 ("hb[..]bz...." β "hb.bz[..].." β "hb.bz[..]." β "hb.bz[..]" β "hb.bz.")
* after the second query f(hbΡ.bz....) = 3 ("hbΡ.bz[..].." β "hbΡ.bz[..]." β "hbΡ.bz[..]" β "hbΡ.bz.")
* after the third query f(hbΡ.bz..f.) = 1 ("hbΡ.bz[..]f." β "hbΡ.bz.f.")
Note to the second sample test.
The original string is ".cc.".
* after the first query: f(..c.) = 1 ("[..]c." β ".c.")
* after the second query: f(....) = 3 ("[..].." β "[..]." β "[..]" β ".")
* after the third query: f(.a..) = 1 (".a[..]" β ".a.")
* after the fourth query: f(aa..) = 1 ("aa[..]" β "aa.")
|
instruction
| 0
| 2,042
| 0
| 4,084
|
Tags: constructive algorithms, data structures, implementation
Correct Solution:
```
import sys
n, m = map(int, sys.stdin.readline().split())
s = input()
left = 0
right = 0
ans = 0
while True:
left = s.find('.', right)
if left < 0:
break
right = left+1
while right < n and s[right] == '.':
right += 1
if right - left > 1:
ans += right-left-1
l = list(s)
ans_list = []
for i in range(m):
query = list(sys.stdin.readline().split())
xi = int(query[0]) - 1
ci = query[1]
if (ci == '.' and l[xi] == '.') or (ci != '.' and l[xi] != '.'):
pass
elif ci == '.' and l[xi] != '.':
if xi > 0 and l[xi-1] == '.':
ans += 1
if xi < n-1 and l[xi+1] == '.':
ans += 1
elif ci != '.' and l[xi] == '.':
if xi > 0 and l[xi-1] == '.':
ans -= 1
if xi < n-1 and l[xi+1] == '.':
ans -= 1
ans_list.append(ans)
l[xi] = ci
print('\n'.join(map(str, ans_list)))
```
|
output
| 1
| 2,042
| 0
| 4,085
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Daniel has a string s, consisting of lowercase English letters and period signs (characters '.'). Let's define the operation of replacement as the following sequence of steps: find a substring ".." (two consecutive periods) in string s, of all occurrences of the substring let's choose the first one, and replace this substring with string ".". In other words, during the replacement operation, the first two consecutive periods are replaced by one. If string s contains no two consecutive periods, then nothing happens.
Let's define f(s) as the minimum number of operations of replacement to perform, so that the string does not have any two consecutive periods left.
You need to process m queries, the i-th results in that the character at position xi (1 β€ xi β€ n) of string s is assigned value ci. After each operation you have to calculate and output the value of f(s).
Help Daniel to process all queries.
Input
The first line contains two integers n and m (1 β€ n, m β€ 300 000) the length of the string and the number of queries.
The second line contains string s, consisting of n lowercase English letters and period signs.
The following m lines contain the descriptions of queries. The i-th line contains integer xi and ci (1 β€ xi β€ n, ci β a lowercas English letter or a period sign), describing the query of assigning symbol ci to position xi.
Output
Print m numbers, one per line, the i-th of these numbers must be equal to the value of f(s) after performing the i-th assignment.
Examples
Input
10 3
.b..bz....
1 h
3 c
9 f
Output
4
3
1
Input
4 4
.cc.
2 .
3 .
2 a
1 a
Output
1
3
1
1
Note
Note to the first sample test (replaced periods are enclosed in square brackets).
The original string is ".b..bz....".
* after the first query f(hb..bz....) = 4 ("hb[..]bz...." β "hb.bz[..].." β "hb.bz[..]." β "hb.bz[..]" β "hb.bz.")
* after the second query f(hbΡ.bz....) = 3 ("hbΡ.bz[..].." β "hbΡ.bz[..]." β "hbΡ.bz[..]" β "hbΡ.bz.")
* after the third query f(hbΡ.bz..f.) = 1 ("hbΡ.bz[..]f." β "hbΡ.bz.f.")
Note to the second sample test.
The original string is ".cc.".
* after the first query: f(..c.) = 1 ("[..]c." β ".c.")
* after the second query: f(....) = 3 ("[..].." β "[..]." β "[..]" β ".")
* after the third query: f(.a..) = 1 (".a[..]" β ".a.")
* after the fourth query: f(aa..) = 1 ("aa[..]" β "aa.")
|
instruction
| 0
| 2,043
| 0
| 4,086
|
Tags: constructive algorithms, data structures, implementation
Correct Solution:
```
n, m = map(int, input().split())
s = [c != '.' for c in input()] + [1]
k = sum(s[i] == s[i + 1] == 0 for i in range(n - 1))
t = [0] * m
for i in range(m):
x, c = input().split()
x, c = int(x) - 1, c != '.'
if not s[x]:
if c: k += s[x - 1] + s[x + 1] - 2
elif not c: k += 2 - s[x - 1] - s[x + 1]
s[x] = c
t[i] = k
print('\n'.join(map(str, t)))
```
|
output
| 1
| 2,043
| 0
| 4,087
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Daniel has a string s, consisting of lowercase English letters and period signs (characters '.'). Let's define the operation of replacement as the following sequence of steps: find a substring ".." (two consecutive periods) in string s, of all occurrences of the substring let's choose the first one, and replace this substring with string ".". In other words, during the replacement operation, the first two consecutive periods are replaced by one. If string s contains no two consecutive periods, then nothing happens.
Let's define f(s) as the minimum number of operations of replacement to perform, so that the string does not have any two consecutive periods left.
You need to process m queries, the i-th results in that the character at position xi (1 β€ xi β€ n) of string s is assigned value ci. After each operation you have to calculate and output the value of f(s).
Help Daniel to process all queries.
Input
The first line contains two integers n and m (1 β€ n, m β€ 300 000) the length of the string and the number of queries.
The second line contains string s, consisting of n lowercase English letters and period signs.
The following m lines contain the descriptions of queries. The i-th line contains integer xi and ci (1 β€ xi β€ n, ci β a lowercas English letter or a period sign), describing the query of assigning symbol ci to position xi.
Output
Print m numbers, one per line, the i-th of these numbers must be equal to the value of f(s) after performing the i-th assignment.
Examples
Input
10 3
.b..bz....
1 h
3 c
9 f
Output
4
3
1
Input
4 4
.cc.
2 .
3 .
2 a
1 a
Output
1
3
1
1
Note
Note to the first sample test (replaced periods are enclosed in square brackets).
The original string is ".b..bz....".
* after the first query f(hb..bz....) = 4 ("hb[..]bz...." β "hb.bz[..].." β "hb.bz[..]." β "hb.bz[..]" β "hb.bz.")
* after the second query f(hbΡ.bz....) = 3 ("hbΡ.bz[..].." β "hbΡ.bz[..]." β "hbΡ.bz[..]" β "hbΡ.bz.")
* after the third query f(hbΡ.bz..f.) = 1 ("hbΡ.bz[..]f." β "hbΡ.bz.f.")
Note to the second sample test.
The original string is ".cc.".
* after the first query: f(..c.) = 1 ("[..]c." β ".c.")
* after the second query: f(....) = 3 ("[..].." β "[..]." β "[..]" β ".")
* after the third query: f(.a..) = 1 (".a[..]" β ".a.")
* after the fourth query: f(aa..) = 1 ("aa[..]" β "aa.")
|
instruction
| 0
| 2,044
| 0
| 4,088
|
Tags: constructive algorithms, data structures, implementation
Correct Solution:
```
from sys import stdin
input = stdin.readline
n,m = map(int,input().split())
s = list((0,1)[c == '.'] for c in list(input()))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt-1,0)
cnt = 0
res += max(0,cnt-1)
for i in range(m):
x,c = input().split()
x = int(x)
nc = (0,1)[c == '.']
if s[x-1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1: diff += 1
if x > 1:
if s[int(x-2)] == 1: diff += 1
if nc == 1:
res += diff
else:
res -= diff
s[x-1] = nc
print(res)
```
|
output
| 1
| 2,044
| 0
| 4,089
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Daniel has a string s, consisting of lowercase English letters and period signs (characters '.'). Let's define the operation of replacement as the following sequence of steps: find a substring ".." (two consecutive periods) in string s, of all occurrences of the substring let's choose the first one, and replace this substring with string ".". In other words, during the replacement operation, the first two consecutive periods are replaced by one. If string s contains no two consecutive periods, then nothing happens.
Let's define f(s) as the minimum number of operations of replacement to perform, so that the string does not have any two consecutive periods left.
You need to process m queries, the i-th results in that the character at position xi (1 β€ xi β€ n) of string s is assigned value ci. After each operation you have to calculate and output the value of f(s).
Help Daniel to process all queries.
Input
The first line contains two integers n and m (1 β€ n, m β€ 300 000) the length of the string and the number of queries.
The second line contains string s, consisting of n lowercase English letters and period signs.
The following m lines contain the descriptions of queries. The i-th line contains integer xi and ci (1 β€ xi β€ n, ci β a lowercas English letter or a period sign), describing the query of assigning symbol ci to position xi.
Output
Print m numbers, one per line, the i-th of these numbers must be equal to the value of f(s) after performing the i-th assignment.
Examples
Input
10 3
.b..bz....
1 h
3 c
9 f
Output
4
3
1
Input
4 4
.cc.
2 .
3 .
2 a
1 a
Output
1
3
1
1
Note
Note to the first sample test (replaced periods are enclosed in square brackets).
The original string is ".b..bz....".
* after the first query f(hb..bz....) = 4 ("hb[..]bz...." β "hb.bz[..].." β "hb.bz[..]." β "hb.bz[..]" β "hb.bz.")
* after the second query f(hbΡ.bz....) = 3 ("hbΡ.bz[..].." β "hbΡ.bz[..]." β "hbΡ.bz[..]" β "hbΡ.bz.")
* after the third query f(hbΡ.bz..f.) = 1 ("hbΡ.bz[..]f." β "hbΡ.bz.f.")
Note to the second sample test.
The original string is ".cc.".
* after the first query: f(..c.) = 1 ("[..]c." β ".c.")
* after the second query: f(....) = 3 ("[..].." β "[..]." β "[..]" β ".")
* after the third query: f(.a..) = 1 (".a[..]" β ".a.")
* after the fourth query: f(aa..) = 1 ("aa[..]" β "aa.")
|
instruction
| 0
| 2,045
| 0
| 4,090
|
Tags: constructive algorithms, data structures, implementation
Correct Solution:
```
from sys import stdin,stdout
input = stdin.readline
import operator
from array import array
n,m = map(int,input().split())
def calc():
s = array('B',[0])
s.extend(c == '.' for c in input())
res = sum(map(operator.mul,s[1:],s))
for i in range(m):
x,c = input().split()
x = int(x)
nc = c == '.'
if s[x] != nc:
diff = s[x-1] + s[x+1]
res += (-diff,diff) [nc]
s[x] = nc
yield str(res)
stdout.write('\n'.join(calc()))
```
|
output
| 1
| 2,045
| 0
| 4,091
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Daniel has a string s, consisting of lowercase English letters and period signs (characters '.'). Let's define the operation of replacement as the following sequence of steps: find a substring ".." (two consecutive periods) in string s, of all occurrences of the substring let's choose the first one, and replace this substring with string ".". In other words, during the replacement operation, the first two consecutive periods are replaced by one. If string s contains no two consecutive periods, then nothing happens.
Let's define f(s) as the minimum number of operations of replacement to perform, so that the string does not have any two consecutive periods left.
You need to process m queries, the i-th results in that the character at position xi (1 β€ xi β€ n) of string s is assigned value ci. After each operation you have to calculate and output the value of f(s).
Help Daniel to process all queries.
Input
The first line contains two integers n and m (1 β€ n, m β€ 300 000) the length of the string and the number of queries.
The second line contains string s, consisting of n lowercase English letters and period signs.
The following m lines contain the descriptions of queries. The i-th line contains integer xi and ci (1 β€ xi β€ n, ci β a lowercas English letter or a period sign), describing the query of assigning symbol ci to position xi.
Output
Print m numbers, one per line, the i-th of these numbers must be equal to the value of f(s) after performing the i-th assignment.
Examples
Input
10 3
.b..bz....
1 h
3 c
9 f
Output
4
3
1
Input
4 4
.cc.
2 .
3 .
2 a
1 a
Output
1
3
1
1
Note
Note to the first sample test (replaced periods are enclosed in square brackets).
The original string is ".b..bz....".
* after the first query f(hb..bz....) = 4 ("hb[..]bz...." β "hb.bz[..].." β "hb.bz[..]." β "hb.bz[..]" β "hb.bz.")
* after the second query f(hbΡ.bz....) = 3 ("hbΡ.bz[..].." β "hbΡ.bz[..]." β "hbΡ.bz[..]" β "hbΡ.bz.")
* after the third query f(hbΡ.bz..f.) = 1 ("hbΡ.bz[..]f." β "hbΡ.bz.f.")
Note to the second sample test.
The original string is ".cc.".
* after the first query: f(..c.) = 1 ("[..]c." β ".c.")
* after the second query: f(....) = 3 ("[..].." β "[..]." β "[..]" β ".")
* after the third query: f(.a..) = 1 (".a[..]" β ".a.")
* after the fourth query: f(aa..) = 1 ("aa[..]" β "aa.")
Submitted Solution:
```
import sys
input = sys.stdin.readline
def segtree(i,a,tree,l,r):
if l==r:
tree[i]=a[l]
return tree[i]
m=(l+r)//2
tree[i]= segtree(2*i+1,a,tree,l,m) + segtree(2*i+2,a,tree,m+1,r)
return tree[i]
def update(i,a,tree,l,r,ind):
if ind<l or ind>r:
return
elif l==r:
tree[i]=a[l]
return
m=(l+r)//2
update(2*i+1,a,tree,l,m,ind)
update(2*i+2,a,tree,m+1,r,ind)
tree[i]=tree[2*i+1]+tree[2*i+2]
n,m=map(int,input().split())
s=list(input())
a=[0]*n
for i in range(1,n):
if s[i]=='.' and s[i-1]=='.':
a[i]=1
i=0
while 2**i<=n:
i=i+1
tree=[0]*(2**(i+1)-1)
segtree(0,a,tree,0,n-1)
for _ in range(m):
i,c=input().split()
i=int(i)-1
if c=='.':
if s[i]!='.':
if i>0:
if s[i-1]=='.':
a[i]=1
update(0,a,tree,0,n-1,i)
if i+1<n:
if s[i+1]=='.' and a[i+1]==0:
a[i+1]=1
update(0,a,tree,0,n-1,i+1)
else:
if s[i]=='.':
a[i]=0
update(0,a,tree,0,n-1,i)
if i+1<n and a[i+1]==1:
a[i+1]=0
update(0,a,tree,0,n-1,i+1)
s[i]=c
sys.stdout.write(str(tree[0]) + "\n")
```
|
instruction
| 0
| 2,046
| 0
| 4,092
|
Yes
|
output
| 1
| 2,046
| 0
| 4,093
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Daniel has a string s, consisting of lowercase English letters and period signs (characters '.'). Let's define the operation of replacement as the following sequence of steps: find a substring ".." (two consecutive periods) in string s, of all occurrences of the substring let's choose the first one, and replace this substring with string ".". In other words, during the replacement operation, the first two consecutive periods are replaced by one. If string s contains no two consecutive periods, then nothing happens.
Let's define f(s) as the minimum number of operations of replacement to perform, so that the string does not have any two consecutive periods left.
You need to process m queries, the i-th results in that the character at position xi (1 β€ xi β€ n) of string s is assigned value ci. After each operation you have to calculate and output the value of f(s).
Help Daniel to process all queries.
Input
The first line contains two integers n and m (1 β€ n, m β€ 300 000) the length of the string and the number of queries.
The second line contains string s, consisting of n lowercase English letters and period signs.
The following m lines contain the descriptions of queries. The i-th line contains integer xi and ci (1 β€ xi β€ n, ci β a lowercas English letter or a period sign), describing the query of assigning symbol ci to position xi.
Output
Print m numbers, one per line, the i-th of these numbers must be equal to the value of f(s) after performing the i-th assignment.
Examples
Input
10 3
.b..bz....
1 h
3 c
9 f
Output
4
3
1
Input
4 4
.cc.
2 .
3 .
2 a
1 a
Output
1
3
1
1
Note
Note to the first sample test (replaced periods are enclosed in square brackets).
The original string is ".b..bz....".
* after the first query f(hb..bz....) = 4 ("hb[..]bz...." β "hb.bz[..].." β "hb.bz[..]." β "hb.bz[..]" β "hb.bz.")
* after the second query f(hbΡ.bz....) = 3 ("hbΡ.bz[..].." β "hbΡ.bz[..]." β "hbΡ.bz[..]" β "hbΡ.bz.")
* after the third query f(hbΡ.bz..f.) = 1 ("hbΡ.bz[..]f." β "hbΡ.bz.f.")
Note to the second sample test.
The original string is ".cc.".
* after the first query: f(..c.) = 1 ("[..]c." β ".c.")
* after the second query: f(....) = 3 ("[..].." β "[..]." β "[..]" β ".")
* after the third query: f(.a..) = 1 (".a[..]" β ".a.")
* after the fourth query: f(aa..) = 1 ("aa[..]" β "aa.")
Submitted Solution:
```
import sys
def count(s):
sm = 0
ln = 0
i = 0
while i < len(s):
cnt = 0
while i < len(s) and s[i] == '.':
cnt += 1
i += 1
if cnt > 1:
sm += cnt
ln += 1
i += 1
return sm - ln
n, m = map(int, sys.stdin.readline().split())
string = ['#'] + list(input()) + ['#']
ans = count(string)
arans = [0 for i in range(m)]
for _ in range(m):
i, s = sys.stdin.readline().split()
i = int(i)
if s == '.':
if string[i] == s:
sys.stdout.write(str(ans)+'\n')
continue
string[i] = s
if string[i + 1] == '.': ans += 1
if string[i - 1] == '.': ans += 1
else:
if '.' != string[i]:
sys.stdout.write(str(ans)+'\n')
continue
string[i] = s
if string[i + 1] == '.': ans -= 1
if string[i - 1] == '.': ans -= 1
sys.stdout.write(str(ans)+'\n')
```
|
instruction
| 0
| 2,047
| 0
| 4,094
|
Yes
|
output
| 1
| 2,047
| 0
| 4,095
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Daniel has a string s, consisting of lowercase English letters and period signs (characters '.'). Let's define the operation of replacement as the following sequence of steps: find a substring ".." (two consecutive periods) in string s, of all occurrences of the substring let's choose the first one, and replace this substring with string ".". In other words, during the replacement operation, the first two consecutive periods are replaced by one. If string s contains no two consecutive periods, then nothing happens.
Let's define f(s) as the minimum number of operations of replacement to perform, so that the string does not have any two consecutive periods left.
You need to process m queries, the i-th results in that the character at position xi (1 β€ xi β€ n) of string s is assigned value ci. After each operation you have to calculate and output the value of f(s).
Help Daniel to process all queries.
Input
The first line contains two integers n and m (1 β€ n, m β€ 300 000) the length of the string and the number of queries.
The second line contains string s, consisting of n lowercase English letters and period signs.
The following m lines contain the descriptions of queries. The i-th line contains integer xi and ci (1 β€ xi β€ n, ci β a lowercas English letter or a period sign), describing the query of assigning symbol ci to position xi.
Output
Print m numbers, one per line, the i-th of these numbers must be equal to the value of f(s) after performing the i-th assignment.
Examples
Input
10 3
.b..bz....
1 h
3 c
9 f
Output
4
3
1
Input
4 4
.cc.
2 .
3 .
2 a
1 a
Output
1
3
1
1
Note
Note to the first sample test (replaced periods are enclosed in square brackets).
The original string is ".b..bz....".
* after the first query f(hb..bz....) = 4 ("hb[..]bz...." β "hb.bz[..].." β "hb.bz[..]." β "hb.bz[..]" β "hb.bz.")
* after the second query f(hbΡ.bz....) = 3 ("hbΡ.bz[..].." β "hbΡ.bz[..]." β "hbΡ.bz[..]" β "hbΡ.bz.")
* after the third query f(hbΡ.bz..f.) = 1 ("hbΡ.bz[..]f." β "hbΡ.bz.f.")
Note to the second sample test.
The original string is ".cc.".
* after the first query: f(..c.) = 1 ("[..]c." β ".c.")
* after the second query: f(....) = 3 ("[..].." β "[..]." β "[..]" β ".")
* after the third query: f(.a..) = 1 (".a[..]" β ".a.")
* after the fourth query: f(aa..) = 1 ("aa[..]" β "aa.")
Submitted Solution:
```
n, m = map(int, input().split())
s = [True] + [c != '.' for c in input()] + [True]
ans = sum(s[i] == s[i + 1] == 0 for i in range(1, n + 1))
out = [0] * m
for i in range(m):
pos, c = input().split()
pos, c = int(pos), c != '.'
if not s[pos]:
if c: ans -= 2 - (s[pos - 1] + s[pos + 1])
else:
if not c: ans += 2 - (s[pos - 1] + s[pos + 1])
s[pos] = c
out[i] = ans
print('\n'.join(map(str, out)))
import time, sys
sys.stderr.write('{0:.3f} ms\n'.format(time.clock() * 1000));
# by Andrey Kim
```
|
instruction
| 0
| 2,048
| 0
| 4,096
|
Yes
|
output
| 1
| 2,048
| 0
| 4,097
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Daniel has a string s, consisting of lowercase English letters and period signs (characters '.'). Let's define the operation of replacement as the following sequence of steps: find a substring ".." (two consecutive periods) in string s, of all occurrences of the substring let's choose the first one, and replace this substring with string ".". In other words, during the replacement operation, the first two consecutive periods are replaced by one. If string s contains no two consecutive periods, then nothing happens.
Let's define f(s) as the minimum number of operations of replacement to perform, so that the string does not have any two consecutive periods left.
You need to process m queries, the i-th results in that the character at position xi (1 β€ xi β€ n) of string s is assigned value ci. After each operation you have to calculate and output the value of f(s).
Help Daniel to process all queries.
Input
The first line contains two integers n and m (1 β€ n, m β€ 300 000) the length of the string and the number of queries.
The second line contains string s, consisting of n lowercase English letters and period signs.
The following m lines contain the descriptions of queries. The i-th line contains integer xi and ci (1 β€ xi β€ n, ci β a lowercas English letter or a period sign), describing the query of assigning symbol ci to position xi.
Output
Print m numbers, one per line, the i-th of these numbers must be equal to the value of f(s) after performing the i-th assignment.
Examples
Input
10 3
.b..bz....
1 h
3 c
9 f
Output
4
3
1
Input
4 4
.cc.
2 .
3 .
2 a
1 a
Output
1
3
1
1
Note
Note to the first sample test (replaced periods are enclosed in square brackets).
The original string is ".b..bz....".
* after the first query f(hb..bz....) = 4 ("hb[..]bz...." β "hb.bz[..].." β "hb.bz[..]." β "hb.bz[..]" β "hb.bz.")
* after the second query f(hbΡ.bz....) = 3 ("hbΡ.bz[..].." β "hbΡ.bz[..]." β "hbΡ.bz[..]" β "hbΡ.bz.")
* after the third query f(hbΡ.bz..f.) = 1 ("hbΡ.bz[..]f." β "hbΡ.bz.f.")
Note to the second sample test.
The original string is ".cc.".
* after the first query: f(..c.) = 1 ("[..]c." β ".c.")
* after the second query: f(....) = 3 ("[..].." β "[..]." β "[..]" β ".")
* after the third query: f(.a..) = 1 (".a[..]" β ".a.")
* after the fourth query: f(aa..) = 1 ("aa[..]" β "aa.")
Submitted Solution:
```
n, m = map(int, input().split())
s = [c != '.' for c in input()] + [1]
f = sum(s[i] == 0 and s[i + 1] != 1 for i in range(n))
t = [0] * m
for i in range(m):
x, c = input().split()
x, c = int(x) - 1, c != '.'
d = s[x - 1] + s[x + 1] - 2
f += (c - s[x]) * d
s[x], t[i] = c, f
print('\n'.join(map(str, t)))
```
|
instruction
| 0
| 2,049
| 0
| 4,098
|
Yes
|
output
| 1
| 2,049
| 0
| 4,099
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Daniel has a string s, consisting of lowercase English letters and period signs (characters '.'). Let's define the operation of replacement as the following sequence of steps: find a substring ".." (two consecutive periods) in string s, of all occurrences of the substring let's choose the first one, and replace this substring with string ".". In other words, during the replacement operation, the first two consecutive periods are replaced by one. If string s contains no two consecutive periods, then nothing happens.
Let's define f(s) as the minimum number of operations of replacement to perform, so that the string does not have any two consecutive periods left.
You need to process m queries, the i-th results in that the character at position xi (1 β€ xi β€ n) of string s is assigned value ci. After each operation you have to calculate and output the value of f(s).
Help Daniel to process all queries.
Input
The first line contains two integers n and m (1 β€ n, m β€ 300 000) the length of the string and the number of queries.
The second line contains string s, consisting of n lowercase English letters and period signs.
The following m lines contain the descriptions of queries. The i-th line contains integer xi and ci (1 β€ xi β€ n, ci β a lowercas English letter or a period sign), describing the query of assigning symbol ci to position xi.
Output
Print m numbers, one per line, the i-th of these numbers must be equal to the value of f(s) after performing the i-th assignment.
Examples
Input
10 3
.b..bz....
1 h
3 c
9 f
Output
4
3
1
Input
4 4
.cc.
2 .
3 .
2 a
1 a
Output
1
3
1
1
Note
Note to the first sample test (replaced periods are enclosed in square brackets).
The original string is ".b..bz....".
* after the first query f(hb..bz....) = 4 ("hb[..]bz...." β "hb.bz[..].." β "hb.bz[..]." β "hb.bz[..]" β "hb.bz.")
* after the second query f(hbΡ.bz....) = 3 ("hbΡ.bz[..].." β "hbΡ.bz[..]." β "hbΡ.bz[..]" β "hbΡ.bz.")
* after the third query f(hbΡ.bz..f.) = 1 ("hbΡ.bz[..]f." β "hbΡ.bz.f.")
Note to the second sample test.
The original string is ".cc.".
* after the first query: f(..c.) = 1 ("[..]c." β ".c.")
* after the second query: f(....) = 3 ("[..].." β "[..]." β "[..]" β ".")
* after the third query: f(.a..) = 1 (".a[..]" β ".a.")
* after the fourth query: f(aa..) = 1 ("aa[..]" β "aa.")
Submitted Solution:
```
n, m = [int(x) for x in input().split()]
s = [x for x in input()]
ans = 0
c = 0
for i in range(len(s)):
if s[i] == '.':
c += 1
else:
if c > 1:
ans += c - 1
c = 0
if c != 0:
ans += c - 1
for i in range(m):
n, sym = [x for x in input().split()]
if sym == ".":
if int(n) != len(s) and s[int(n)] == '.':
ans += 1
if int(n) != 1 and s[int(n) - 2] == '.':
ans += 1
else:
if s[int(n) - 1] == '.':
if int(n) != len(s) and s[int(n)] == '.':
ans -= 1
if int(n) != 1 and s[int(n) - 2] == '.':
ans -= 1
s[int(n) - 1] = sym
print(ans)
```
|
instruction
| 0
| 2,050
| 0
| 4,100
|
No
|
output
| 1
| 2,050
| 0
| 4,101
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Daniel has a string s, consisting of lowercase English letters and period signs (characters '.'). Let's define the operation of replacement as the following sequence of steps: find a substring ".." (two consecutive periods) in string s, of all occurrences of the substring let's choose the first one, and replace this substring with string ".". In other words, during the replacement operation, the first two consecutive periods are replaced by one. If string s contains no two consecutive periods, then nothing happens.
Let's define f(s) as the minimum number of operations of replacement to perform, so that the string does not have any two consecutive periods left.
You need to process m queries, the i-th results in that the character at position xi (1 β€ xi β€ n) of string s is assigned value ci. After each operation you have to calculate and output the value of f(s).
Help Daniel to process all queries.
Input
The first line contains two integers n and m (1 β€ n, m β€ 300 000) the length of the string and the number of queries.
The second line contains string s, consisting of n lowercase English letters and period signs.
The following m lines contain the descriptions of queries. The i-th line contains integer xi and ci (1 β€ xi β€ n, ci β a lowercas English letter or a period sign), describing the query of assigning symbol ci to position xi.
Output
Print m numbers, one per line, the i-th of these numbers must be equal to the value of f(s) after performing the i-th assignment.
Examples
Input
10 3
.b..bz....
1 h
3 c
9 f
Output
4
3
1
Input
4 4
.cc.
2 .
3 .
2 a
1 a
Output
1
3
1
1
Note
Note to the first sample test (replaced periods are enclosed in square brackets).
The original string is ".b..bz....".
* after the first query f(hb..bz....) = 4 ("hb[..]bz...." β "hb.bz[..].." β "hb.bz[..]." β "hb.bz[..]" β "hb.bz.")
* after the second query f(hbΡ.bz....) = 3 ("hbΡ.bz[..].." β "hbΡ.bz[..]." β "hbΡ.bz[..]" β "hbΡ.bz.")
* after the third query f(hbΡ.bz..f.) = 1 ("hbΡ.bz[..]f." β "hbΡ.bz.f.")
Note to the second sample test.
The original string is ".cc.".
* after the first query: f(..c.) = 1 ("[..]c." β ".c.")
* after the second query: f(....) = 3 ("[..].." β "[..]." β "[..]" β ".")
* after the third query: f(.a..) = 1 (".a[..]" β ".a.")
* after the fourth query: f(aa..) = 1 ("aa[..]" β "aa.")
Submitted Solution:
```
# -*- coding: utf-8 -*-
# Baqir Khan
# Software Engineer (Backend)
n, m = map(int, input().split())
s = list(str(input()))
ans = 0
for i in range(n - 1):
if s[i] == "." and s[i + 1] == ".":
ans += 1
while m:
m -= 1
inp = input().split()
index = int(inp[0]) - 1
char = inp[1]
if char == ".":
if index != 0 and index != n - 1 and s[index + 1] == "." and s[index - 1] == ".":
ans += 2
elif (index != 0 and s[index - 1] == ".") or (index != n - 1 and s[index + 1] == "."):
ans += 1
elif s[index] == ".":
if index != 0 and index != n - 1 and s[index + 1] == "." and s[index - 1] == ".":
ans -= 2
elif (index != 0 and s[index - 1] == ".") or (index != n - 1 and s[index + 1] == "."):
ans -= 1
s[index] = char
print(ans)
```
|
instruction
| 0
| 2,051
| 0
| 4,102
|
No
|
output
| 1
| 2,051
| 0
| 4,103
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Daniel has a string s, consisting of lowercase English letters and period signs (characters '.'). Let's define the operation of replacement as the following sequence of steps: find a substring ".." (two consecutive periods) in string s, of all occurrences of the substring let's choose the first one, and replace this substring with string ".". In other words, during the replacement operation, the first two consecutive periods are replaced by one. If string s contains no two consecutive periods, then nothing happens.
Let's define f(s) as the minimum number of operations of replacement to perform, so that the string does not have any two consecutive periods left.
You need to process m queries, the i-th results in that the character at position xi (1 β€ xi β€ n) of string s is assigned value ci. After each operation you have to calculate and output the value of f(s).
Help Daniel to process all queries.
Input
The first line contains two integers n and m (1 β€ n, m β€ 300 000) the length of the string and the number of queries.
The second line contains string s, consisting of n lowercase English letters and period signs.
The following m lines contain the descriptions of queries. The i-th line contains integer xi and ci (1 β€ xi β€ n, ci β a lowercas English letter or a period sign), describing the query of assigning symbol ci to position xi.
Output
Print m numbers, one per line, the i-th of these numbers must be equal to the value of f(s) after performing the i-th assignment.
Examples
Input
10 3
.b..bz....
1 h
3 c
9 f
Output
4
3
1
Input
4 4
.cc.
2 .
3 .
2 a
1 a
Output
1
3
1
1
Note
Note to the first sample test (replaced periods are enclosed in square brackets).
The original string is ".b..bz....".
* after the first query f(hb..bz....) = 4 ("hb[..]bz...." β "hb.bz[..].." β "hb.bz[..]." β "hb.bz[..]" β "hb.bz.")
* after the second query f(hbΡ.bz....) = 3 ("hbΡ.bz[..].." β "hbΡ.bz[..]." β "hbΡ.bz[..]" β "hbΡ.bz.")
* after the third query f(hbΡ.bz..f.) = 1 ("hbΡ.bz[..]f." β "hbΡ.bz.f.")
Note to the second sample test.
The original string is ".cc.".
* after the first query: f(..c.) = 1 ("[..]c." β ".c.")
* after the second query: f(....) = 3 ("[..].." β "[..]." β "[..]" β ".")
* after the third query: f(.a..) = 1 (".a[..]" β ".a.")
* after the fourth query: f(aa..) = 1 ("aa[..]" β "aa.")
Submitted Solution:
```
import sys,os,io
import math,bisect,operator
inf,mod = float('inf'),10**9+7
# sys.setrecursionlimit(10 ** 6)
from itertools import groupby,accumulate
from heapq import heapify,heappop,heappush
from collections import deque,Counter,defaultdict
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
Neo = lambda : list(map(int,input().split()))
# test, = Neo()
n,m = Neo()
s = ['*']+list(input())+['*']
t = 0
for i,j in zip(s,s[1:]):
if i+j == '..':
t += 1
for i in range(m):
ind,c = input().split()
ind = int(ind)
if c == '.':
if s[ind] != '.':
if s[ind-1]+s[ind+1] == '..':
t += 2
s[ind] = c
elif s[ind-1] == '.' or s[ind+1] == '.':
t += 1
s[ind] = c
else:
if s[ind-1]+s[ind]+s[ind+1] == '...':
t -= 2
s[ind] = c
elif s[ind-1]+s[ind] == '..' or s[ind]+s[ind+1] == '..':
t -= 1
s[ind] = c
else:
s[ind] = c
print(t)
```
|
instruction
| 0
| 2,052
| 0
| 4,104
|
No
|
output
| 1
| 2,052
| 0
| 4,105
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Daniel has a string s, consisting of lowercase English letters and period signs (characters '.'). Let's define the operation of replacement as the following sequence of steps: find a substring ".." (two consecutive periods) in string s, of all occurrences of the substring let's choose the first one, and replace this substring with string ".". In other words, during the replacement operation, the first two consecutive periods are replaced by one. If string s contains no two consecutive periods, then nothing happens.
Let's define f(s) as the minimum number of operations of replacement to perform, so that the string does not have any two consecutive periods left.
You need to process m queries, the i-th results in that the character at position xi (1 β€ xi β€ n) of string s is assigned value ci. After each operation you have to calculate and output the value of f(s).
Help Daniel to process all queries.
Input
The first line contains two integers n and m (1 β€ n, m β€ 300 000) the length of the string and the number of queries.
The second line contains string s, consisting of n lowercase English letters and period signs.
The following m lines contain the descriptions of queries. The i-th line contains integer xi and ci (1 β€ xi β€ n, ci β a lowercas English letter or a period sign), describing the query of assigning symbol ci to position xi.
Output
Print m numbers, one per line, the i-th of these numbers must be equal to the value of f(s) after performing the i-th assignment.
Examples
Input
10 3
.b..bz....
1 h
3 c
9 f
Output
4
3
1
Input
4 4
.cc.
2 .
3 .
2 a
1 a
Output
1
3
1
1
Note
Note to the first sample test (replaced periods are enclosed in square brackets).
The original string is ".b..bz....".
* after the first query f(hb..bz....) = 4 ("hb[..]bz...." β "hb.bz[..].." β "hb.bz[..]." β "hb.bz[..]" β "hb.bz.")
* after the second query f(hbΡ.bz....) = 3 ("hbΡ.bz[..].." β "hbΡ.bz[..]." β "hbΡ.bz[..]" β "hbΡ.bz.")
* after the third query f(hbΡ.bz..f.) = 1 ("hbΡ.bz[..]f." β "hbΡ.bz.f.")
Note to the second sample test.
The original string is ".cc.".
* after the first query: f(..c.) = 1 ("[..]c." β ".c.")
* after the second query: f(....) = 3 ("[..].." β "[..]." β "[..]" β ".")
* after the third query: f(.a..) = 1 (".a[..]" β ".a.")
* after the fourth query: f(aa..) = 1 ("aa[..]" β "aa.")
Submitted Solution:
```
from sys import stdin, stdout
input = stdin.readline
n, m = map(int, input().split())
s = list(input())
f = 0
ans = []
for i in range(1,n):
if s[i] == s[i-1] and s[i] == '.':
f+= 1
for i in range(m):
x, ch = input().split()
x = int(x) - 1
if s[x] != ch:
if ch == '.':
if x > 0 and s[x-1] == '.':
f += 1
if x < n - 1 and s[x+1] == '.':
f += 1
else:
if x > 0 and s[x-1] == '.':
f -= 1
if x < n - 1 and s[x+1] == '.':
f -= 1
s[x] = ch
ans.append(f)
stdout.write("\n".join(map(str,ans)))
```
|
instruction
| 0
| 2,053
| 0
| 4,106
|
No
|
output
| 1
| 2,053
| 0
| 4,107
|
Provide a correct Python 3 solution for this coding contest problem.
You are a treasure hunter traveling around the world. Finally, youβve got an ancient text indicating the place where the treasure was hidden. The ancient text looks like a meaningless string of characters at first glance. Actually, the secret place is embedded as the longest repeated subsequence of the text.
Well, then, what is the longest repeated subsequence of a string? First, you split the given string S into two parts F and R. Then, you take the longest common subsequence L of F and R (longest string L that is a subsequence of both F and R). Since there are many possible ways to split S into two parts, there are many possible L's. The longest repeated subsequence is the longest one among them. For example, the longest repeated subsequence of βABCABCABABβ is βABABβ, which is obtained when you split βABCABCABABβ into βABCABCβ and βABABβ.
Now your task is clear. Please find the longest repeated subsequence and get the hidden treasure!
Input
The input consists of multiple data sets. Each data set comes with a single line that contains one string of up to 300 capital letters. It is guaranteed that there is at least one repeated subsequence in each string.
The end of input is indicated by a line that contains β#ENDβ. This line should not be processed.
Output
For each data set, print the longest repeated subsequence on a line. If there are multiple longest subsequence, print any one of them.
Examples
Input
ABCABCABAB
ZZZZZZZZZZZZ
#END
Output
ABAB
ZZZZZZ
Input
ABCABCABAB
ZZZZZZZZZZZZ
END
Output
ABAB
ZZZZZZ
|
instruction
| 0
| 2,417
| 0
| 4,834
|
"Correct Solution:
```
def lcs(x, y, pre_lcs, pre_lcs_len):
pm = dict((zip('ABCDEFGHIJKLMNOPQRSTUVWXYZ', [0] * 26)))
for c in pm:
for i, xc in enumerate(x):
if c == xc:
pm[c] |= (1 << i)
V = (1 << len(x)) - 1
rec = []
for yc in y:
V = ((V + (V & pm[yc])) | (V & ~pm[yc]))
rec.append(bin(V)[-len(x):])
lcs_len = bin(V)[-len(x):].count('0')
if lcs_len > pre_lcs_len:
rx = x[::-1]
lcs = ''
idx = 0
for v, yc in zip(rec[::-1], reversed(y)):
idx = v.find('0', idx)
if yc == rx[idx]:
lcs += yc
if len(lcs) == lcs_len:
return (lcs[::-1], lcs_len)
idx += 1
else:
return (pre_lcs, pre_lcs_len)
from sys import stdin
def solve():
file_input = stdin
ans_out = []
for s in file_input:
s = s.rstrip()
if s[0] == '#':
break
s_len = len(s)
sep = s_len // 2
ans, ans_len = lcs(s[:sep], s[sep:], '', 0)
while sep > ans_len:
ans, ans_len = lcs(s[:-sep], s[-sep:], ans, ans_len)
sep -= 1
ans, ans_len = lcs(s[:sep], s[sep:], ans, ans_len)
ans_out.append(ans)
print(*ans_out, sep='\n')
solve()
```
|
output
| 1
| 2,417
| 0
| 4,835
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are a treasure hunter traveling around the world. Finally, youβve got an ancient text indicating the place where the treasure was hidden. The ancient text looks like a meaningless string of characters at first glance. Actually, the secret place is embedded as the longest repeated subsequence of the text.
Well, then, what is the longest repeated subsequence of a string? First, you split the given string S into two parts F and R. Then, you take the longest common subsequence L of F and R (longest string L that is a subsequence of both F and R). Since there are many possible ways to split S into two parts, there are many possible L's. The longest repeated subsequence is the longest one among them. For example, the longest repeated subsequence of βABCABCABABβ is βABABβ, which is obtained when you split βABCABCABABβ into βABCABCβ and βABABβ.
Now your task is clear. Please find the longest repeated subsequence and get the hidden treasure!
Input
The input consists of multiple data sets. Each data set comes with a single line that contains one string of up to 300 capital letters. It is guaranteed that there is at least one repeated subsequence in each string.
The end of input is indicated by a line that contains β#ENDβ. This line should not be processed.
Output
For each data set, print the longest repeated subsequence on a line. If there are multiple longest subsequence, print any one of them.
Examples
Input
ABCABCABAB
ZZZZZZZZZZZZ
#END
Output
ABAB
ZZZZZZ
Input
ABCABCABAB
ZZZZZZZZZZZZ
END
Output
ABAB
ZZZZZZ
Submitted Solution:
```
def lcs(x, y):
rec = []
idx = []
for c in y:
s = 0
for i, k in enumerate(idx):
t = x.find(c, s) + 1
if t < 1:
break
if t < k:
idx[i] = t
s = k
else:
t = x.find(c, s) + 1
if t:
idx.append(t)
rec.append(idx.copy())
lcs = ''
pos = len(idx) - 1
for line, yc in zip(rec[::-1], y[::-1]):
i = line[pos] - 1
xc = x[i]
if xc == yc:
lcs += xc
if pos == 0:
return lcs[::-1]
pos -= 1
def solve():
import sys
file_input = sys.stdin
for s in file_input:
s = s.rstrip()
if s == '#END':
break
sep = len(s) // 2
ans = lcs(s[:sep], s[sep:])
ans_len = len(ans)
while sep > len(ans):
sep -= 1
a1 = lcs(s[:sep], s[sep:])
a2 = lcs(s[:-sep], s[-sep:])
if ans_len < len(a1):
ans = a1
ans_len = len(ans)
if ans_len < len(a2):
ans = a2
ans_len = len(ans)
print(ans)
solve()
```
|
instruction
| 0
| 2,418
| 0
| 4,836
|
No
|
output
| 1
| 2,418
| 0
| 4,837
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are a treasure hunter traveling around the world. Finally, youβve got an ancient text indicating the place where the treasure was hidden. The ancient text looks like a meaningless string of characters at first glance. Actually, the secret place is embedded as the longest repeated subsequence of the text.
Well, then, what is the longest repeated subsequence of a string? First, you split the given string S into two parts F and R. Then, you take the longest common subsequence L of F and R (longest string L that is a subsequence of both F and R). Since there are many possible ways to split S into two parts, there are many possible L's. The longest repeated subsequence is the longest one among them. For example, the longest repeated subsequence of βABCABCABABβ is βABABβ, which is obtained when you split βABCABCABABβ into βABCABCβ and βABABβ.
Now your task is clear. Please find the longest repeated subsequence and get the hidden treasure!
Input
The input consists of multiple data sets. Each data set comes with a single line that contains one string of up to 300 capital letters. It is guaranteed that there is at least one repeated subsequence in each string.
The end of input is indicated by a line that contains β#ENDβ. This line should not be processed.
Output
For each data set, print the longest repeated subsequence on a line. If there are multiple longest subsequence, print any one of them.
Examples
Input
ABCABCABAB
ZZZZZZZZZZZZ
#END
Output
ABAB
ZZZZZZ
Input
ABCABCABAB
ZZZZZZZZZZZZ
END
Output
ABAB
ZZZZZZ
Submitted Solution:
```
def lcs(x, y, pre_lcs, pre_lcs_len):
rec = []
idx = []
for c in y:
s = 0
for i, k in enumerate(idx):
t = x.find(c, s) + 1
if t < 1:
break
if t < k:
idx[i] = t
s = k
else:
t = x.find(c, s) + 1
if t:
idx.append(t)
rec.append(idx.copy())
lcs_len = len(idx)
if lcs_len > pre_lcs_len:
lcs = ''
pos = len(idx) - 1
for line, yc in zip(rec[::-1], y[::-1]):
i = line[pos] - 1
xc = x[i]
if xc == yc:
lcs += xc
if pos == 0:
return (lcs[::-1], lcs_len)
pos -= 1
else:
return (pre_lcs, pre_lcs_len)
def solve():
import sys
#file_input = sys.stdin
file_input = open('2090_in', 'r')#
ans_out = []
for s in file_input:
s = s.rstrip()
if s == '#END':
break
s_len = len(s)
sep = s_len // 2
ans, ans_len = lcs(s[:sep], s[sep:], '', 0)
while sep > ans_len:
ans, ans_len = lcs(s[:-sep], s[-sep:], ans, ans_len)
sep -= 1
ans, ans_len = lcs(s[:sep], s[sep:], ans, ans_len)
print(ans)
solve()
```
|
instruction
| 0
| 2,419
| 0
| 4,838
|
No
|
output
| 1
| 2,419
| 0
| 4,839
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are a treasure hunter traveling around the world. Finally, youβve got an ancient text indicating the place where the treasure was hidden. The ancient text looks like a meaningless string of characters at first glance. Actually, the secret place is embedded as the longest repeated subsequence of the text.
Well, then, what is the longest repeated subsequence of a string? First, you split the given string S into two parts F and R. Then, you take the longest common subsequence L of F and R (longest string L that is a subsequence of both F and R). Since there are many possible ways to split S into two parts, there are many possible L's. The longest repeated subsequence is the longest one among them. For example, the longest repeated subsequence of βABCABCABABβ is βABABβ, which is obtained when you split βABCABCABABβ into βABCABCβ and βABABβ.
Now your task is clear. Please find the longest repeated subsequence and get the hidden treasure!
Input
The input consists of multiple data sets. Each data set comes with a single line that contains one string of up to 300 capital letters. It is guaranteed that there is at least one repeated subsequence in each string.
The end of input is indicated by a line that contains β#ENDβ. This line should not be processed.
Output
For each data set, print the longest repeated subsequence on a line. If there are multiple longest subsequence, print any one of them.
Examples
Input
ABCABCABAB
ZZZZZZZZZZZZ
#END
Output
ABAB
ZZZZZZ
Input
ABCABCABAB
ZZZZZZZZZZZZ
END
Output
ABAB
ZZZZZZ
Submitted Solution:
```
def lcs(x, y, pre_lcs, pre_lcs_len):
rec = []
idx = []
for c in y:
s = 0
for i, k in enumerate(idx):
t = x.find(c, s) + 1
if t < 1:
break
if t < k:
idx[i] = t
s = k
else:
t = x.find(c, s) + 1
if t:
idx.append(t)
rec.append(idx.copy())
lcs_len = len(idx)
if lcs_len > pre_lcs_len:
lcs = ''
pos = len(idx) - 1
for line, yc in zip(rec[::-1], y[::-1]):
i = line[pos] - 1
xc = x[i]
if xc == yc:
lcs += xc
if pos == 0:
return (lcs[::-1], lcs_len)
pos -= 1
else:
return (pre_lcs, pre_lcs_len)
def lrs(s):
s = s.rstrip()
s_len = len(s)
sep = s_len // 2
ans, ans_len = lcs(s[:sep], s[sep:], '', 0)
while sep > ans_len:
ans, ans_len = lcs(s[:-sep], s[-sep:], ans, ans_len)
sep -= 1
ans, ans_len = lcs(s[:sep], s[sep:], ans, ans_len)
return ans
import sys
input_lines = sys.stdin.readlines()
for line in input_lines[:-1]:
print(lrs(line))
```
|
instruction
| 0
| 2,420
| 0
| 4,840
|
No
|
output
| 1
| 2,420
| 0
| 4,841
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are a treasure hunter traveling around the world. Finally, youβve got an ancient text indicating the place where the treasure was hidden. The ancient text looks like a meaningless string of characters at first glance. Actually, the secret place is embedded as the longest repeated subsequence of the text.
Well, then, what is the longest repeated subsequence of a string? First, you split the given string S into two parts F and R. Then, you take the longest common subsequence L of F and R (longest string L that is a subsequence of both F and R). Since there are many possible ways to split S into two parts, there are many possible L's. The longest repeated subsequence is the longest one among them. For example, the longest repeated subsequence of βABCABCABABβ is βABABβ, which is obtained when you split βABCABCABABβ into βABCABCβ and βABABβ.
Now your task is clear. Please find the longest repeated subsequence and get the hidden treasure!
Input
The input consists of multiple data sets. Each data set comes with a single line that contains one string of up to 300 capital letters. It is guaranteed that there is at least one repeated subsequence in each string.
The end of input is indicated by a line that contains β#ENDβ. This line should not be processed.
Output
For each data set, print the longest repeated subsequence on a line. If there are multiple longest subsequence, print any one of them.
Examples
Input
ABCABCABAB
ZZZZZZZZZZZZ
#END
Output
ABAB
ZZZZZZ
Input
ABCABCABAB
ZZZZZZZZZZZZ
END
Output
ABAB
ZZZZZZ
Submitted Solution:
```
def lcs(x, y, pre_lcs, pre_lcs_len):
rec = []
idx = []
for c in y:
s = 0
for i, k in enumerate(idx):
t = x.find(c, s) + 1
if t < 1:
break
if t < k:
idx[i] = t
s = k
else:
t = x.find(c, s) + 1
if t:
idx.append(t)
rec.append(idx.copy())
lcs_len = len(idx)
if lcs_len > pre_lcs_len:
lcs = ''
pos = len(idx) - 1
for line, yc in zip(rec[::-1], y[::-1]):
i = line[pos] - 1
xc = x[i]
if xc == yc:
lcs += xc
if pos == 0:
return (lcs[::-1], lcs_len)
pos -= 1
else:
return (pre_lcs, pre_lcs_len)
def solve():
import sys
file_input = sys.stdin
ans_out = []
for s in file_input:
s = s.rstrip()
if s == '#END':
break
s_len = len(s)
sep = s_len // 2
ans, ans_len = lcs(s[:sep], s[sep:], '', 0)
while sep > ans_len:
ans, ans_len = lcs(s[:-sep], s[-sep:], ans, ans_len)
sep -= 1
ans, ans_len = lcs(s[:sep], s[sep:], ans, ans_len)
print(ans)
solve()
```
|
instruction
| 0
| 2,421
| 0
| 4,842
|
No
|
output
| 1
| 2,421
| 0
| 4,843
|
Provide a correct Python 3 solution for this coding contest problem.
Problem
Taro has N character strings, each of which is L in length. Taro loves palindromes, so I want to make palindromes as long as possible by selecting some of the N character strings and arranging them in any order.
Find the longest palindrome that Taro can make. If there are more than one, output the smallest one in lexicographical order. If you can't make a palindrome no matter how you choose and arrange them, output a blank line.
Constraints
The input satisfies the following conditions.
* 1 β€ N β€ 1000
* 1 β€ L β€ 30
* s_i is a character string consisting of lowercase letters.
Input
The input is given in the following format.
N L
s1
s2
..
..
..
sN
The number N of strings and the length L of strings are given on the first line. From the second line that follows, N & plus; The character string s_i that Taro has is given to the first line.
Output
Output the longest palindrome with the smallest dictionary order. If you cannot make a palindrome, output a blank line.
Examples
Input
4 2
oi
io
rr
rr
Output
iorrrroi
Input
5 1
a
b
c
a
c
Output
acbca
Input
3 3
uki
uku
uke
Output
uku
|
instruction
| 0
| 2,433
| 0
| 4,866
|
"Correct Solution:
```
from functools import cmp_to_key
n, l = map(int, input().split())
ss = {}
for i in range(n):
s = input()
ss[s] = ss.get(s, 0) + 1
ans = ""
ma = ""
for s in sorted(ss):
if s[::-1] == s:
ans += s * (ss[s]//2)
ss[s] -= 2*(ss[s]//2)
if ss[s] > 0 and len(ma) < len(s):
ma = s
else:
rev = s[::-1]
if rev in ss:
cnt = min(ss[s], ss[rev])
ans += s * cnt
ss[s] -= cnt
ss[rev] -= cnt
print(ans + ma + ans[::-1])
```
|
output
| 1
| 2,433
| 0
| 4,867
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's denote (yet again) the sequence of Fibonacci strings:
F(0) = 0, F(1) = 1, F(i) = F(i - 2) + F(i - 1), where the plus sign denotes the concatenation of two strings.
Let's denote the lexicographically sorted sequence of suffixes of string F(i) as A(F(i)). For example, F(4) is 01101, and A(F(4)) is the following sequence: 01, 01101, 1, 101, 1101. Elements in this sequence are numbered from 1.
Your task is to print m first characters of k-th element of A(F(n)). If there are less than m characters in this suffix, then output the whole suffix.
Input
The only line of the input contains three numbers n, k and m (1 β€ n, m β€ 200, 1 β€ k β€ 10^{18}) denoting the index of the Fibonacci string you have to consider, the index of the element of A(F(n)) and the number of characters you have to output, respectively.
It is guaranteed that k does not exceed the length of F(n).
Output
Output m first characters of k-th element of A(F(n)), or the whole element if its length is less than m.
Examples
Input
4 5 3
Output
110
Input
4 3 3
Output
1
Submitted Solution:
```
import sys
def test(n,k,m):
res1 = f2(f1(n))
r = res1[k-1][:m]
print(r)
return r
def f1(n):
strHash = {0:"0",1:"1",2:"01",3:"101"}
for i in range(3,n+1) :
strHash[i] = strHash[i-2] + strHash[i -1]
#print(strHash)
#print(strHash[n])
return(strHash[n])
def f2(str):
lenq = len(str)
print("this is {} ".format(str))
result = []
i = 0;
while(i < lenq ):
result.append(str[i:])
i+=1
print(sorted(result))
return sorted(result)
#return result.sort()
if __name__ == '__main__':
str_list = sys.stdin.readline().strip("\n").split(" ")
number_list = [int(str(i)) for i in str_list]
a = number_list[0]
b = number_list[1]
c = number_list[2]
print(test(a,b,c))
```
|
instruction
| 0
| 2,483
| 0
| 4,966
|
No
|
output
| 1
| 2,483
| 0
| 4,967
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's denote (yet again) the sequence of Fibonacci strings:
F(0) = 0, F(1) = 1, F(i) = F(i - 2) + F(i - 1), where the plus sign denotes the concatenation of two strings.
Let's denote the lexicographically sorted sequence of suffixes of string F(i) as A(F(i)). For example, F(4) is 01101, and A(F(4)) is the following sequence: 01, 01101, 1, 101, 1101. Elements in this sequence are numbered from 1.
Your task is to print m first characters of k-th element of A(F(n)). If there are less than m characters in this suffix, then output the whole suffix.
Input
The only line of the input contains three numbers n, k and m (1 β€ n, m β€ 200, 1 β€ k β€ 10^{18}) denoting the index of the Fibonacci string you have to consider, the index of the element of A(F(n)) and the number of characters you have to output, respectively.
It is guaranteed that k does not exceed the length of F(n).
Output
Output m first characters of k-th element of A(F(n)), or the whole element if its length is less than m.
Examples
Input
4 5 3
Output
110
Input
4 3 3
Output
1
Submitted Solution:
```
import itertools
def fib(i):
if(i==0):
return '0'
elif i==1:
return '1'
else:
return fib(i-2)+fib(i-1)
n,k,m=list(map(int,input().split()))
ans=fib(n)
ans=ans[::-1]
ans=list(ans)
mainl=list(itertools.accumulate(ans,lambda x,y : x+y))
mainl2=[]
mainl2=[i[::-1] for i in mainl]
mainl2.sort(key=len)
mainl2.sort(key=lambda x:int(x[0]))
s=mainl2[k-1]
print(s[:m])
```
|
instruction
| 0
| 2,484
| 0
| 4,968
|
No
|
output
| 1
| 2,484
| 0
| 4,969
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's denote (yet again) the sequence of Fibonacci strings:
F(0) = 0, F(1) = 1, F(i) = F(i - 2) + F(i - 1), where the plus sign denotes the concatenation of two strings.
Let's denote the lexicographically sorted sequence of suffixes of string F(i) as A(F(i)). For example, F(4) is 01101, and A(F(4)) is the following sequence: 01, 01101, 1, 101, 1101. Elements in this sequence are numbered from 1.
Your task is to print m first characters of k-th element of A(F(n)). If there are less than m characters in this suffix, then output the whole suffix.
Input
The only line of the input contains three numbers n, k and m (1 β€ n, m β€ 200, 1 β€ k β€ 10^{18}) denoting the index of the Fibonacci string you have to consider, the index of the element of A(F(n)) and the number of characters you have to output, respectively.
It is guaranteed that k does not exceed the length of F(n).
Output
Output m first characters of k-th element of A(F(n)), or the whole element if its length is less than m.
Examples
Input
4 5 3
Output
110
Input
4 3 3
Output
1
Submitted Solution:
```
n,m,k=map(int,input().split())
prev=1
next=1
l=[]
while(len(l)<n+1):
temp=next
next=next+prev
prev=temp
l.append(next)
b=bin(l[-1])
b=b[2:]
if(m>len(b)):
m1=m-len(b)
b=m1*'0'+b
else:
b='0'+b
#print(b)
l1=[]
for i in range(0,len(b)):
l1.append(b[i:])
l1.sort()
#print(l1)
s=l1[m-1]
#print(s)
if(len(s)>k):
print(s[:k])
else:
print(s)
```
|
instruction
| 0
| 2,485
| 0
| 4,970
|
No
|
output
| 1
| 2,485
| 0
| 4,971
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's denote (yet again) the sequence of Fibonacci strings:
F(0) = 0, F(1) = 1, F(i) = F(i - 2) + F(i - 1), where the plus sign denotes the concatenation of two strings.
Let's denote the lexicographically sorted sequence of suffixes of string F(i) as A(F(i)). For example, F(4) is 01101, and A(F(4)) is the following sequence: 01, 01101, 1, 101, 1101. Elements in this sequence are numbered from 1.
Your task is to print m first characters of k-th element of A(F(n)). If there are less than m characters in this suffix, then output the whole suffix.
Input
The only line of the input contains three numbers n, k and m (1 β€ n, m β€ 200, 1 β€ k β€ 10^{18}) denoting the index of the Fibonacci string you have to consider, the index of the element of A(F(n)) and the number of characters you have to output, respectively.
It is guaranteed that k does not exceed the length of F(n).
Output
Output m first characters of k-th element of A(F(n)), or the whole element if its length is less than m.
Examples
Input
4 5 3
Output
110
Input
4 3 3
Output
1
Submitted Solution:
```
import itertools
def fib(i):
if(i==0):
return '0'
elif i==1:
return '1'
else:
return fib(i-2)+fib(i-1)
n,k,m=list(map(int,input().split()))
ans=fib(n)
ans=ans[::-1]
ans=list(ans)
mainl=list(itertools.accumulate(ans,lambda x,y : x+y))
mainl2=[]
for i in mainl:
mainl2.append(i[::-1])
mainl2.sort(key=len)
mainl2.sort(key=lambda x:int(x[0]))
s=mainl2[k-1]
print(s[:m])
```
|
instruction
| 0
| 2,486
| 0
| 4,972
|
No
|
output
| 1
| 2,486
| 0
| 4,973
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has a string s of length n consisting only of digits 0 and 1. Also he has an array a of length n.
Vasya performs the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue together the remaining parts (any of them can be empty). For example, if he erases substring 111 from string 111110 he will get the string 110. Vasya gets a_x points for erasing substring of length x.
Vasya wants to maximize his total points, so help him with this!
Input
The first line contains one integer n (1 β€ n β€ 100) β the length of string s.
The second line contains string s, consisting only of digits 0 and 1.
The third line contains n integers a_1, a_2, ... a_n (1 β€ a_i β€ 10^9), where a_i is the number of points for erasing the substring of length i.
Output
Print one integer β the maximum total points Vasya can get.
Examples
Input
7
1101001
3 4 9 100 1 2 3
Output
109
Input
5
10101
3 10 15 15 15
Output
23
Note
In the first example the optimal sequence of erasings is: 1101001 β 111001 β 11101 β 1111 β β
.
In the second example the optimal sequence of erasings is: 10101 β 1001 β 11 β β
.
|
instruction
| 0
| 2,487
| 0
| 4,974
|
Tags: dp
Correct Solution:
```
from sys import stdin
uu=0
n=int(stdin.readline().strip())
s1=stdin.readline().strip()
s=list(map(int,stdin.readline().strip().split()))
dp=[-1 for i in range(n+1)]
def sol1(x):
if dp[x]!=-1:
return dp[x]
if x==0:
return 0
ans=0
for i in range(x):
ans=max(ans,s[i]+sol1(x-i-1))
dp[x]=ans
for i in range(n):
sol1(i+1)
dp[0]=0
s2=[]
x=1
for i in range(1,len(s)):
if s1[i]!=s1[i-1]:
s2.append(x)
x=1
else:
x+=1
s2.append(x)
dp1=[[[-1 for i in range(n+1)]for j in range(n+1)] for k in range(n+1)]
n=len(s2)
s=s2.copy()
def sol(l,r,k):
if l==r:
return dp[s[l]+k]
if l>r:
return 0
if dp1[l][r][k]!=-1:
return dp1[l][r][k]
ans=0
for i in range(l,r+1,2):
if i!=l:
ans=max(ans,sol(l+1,i-1,0)+sol(i,r,s[l]+k))
else:
ans=max(ans,sol(i+1,r,0)+dp[s[l]+k])
dp1[l][r][k]=ans
return ans
print(sol(0,len(s)-1,0))
```
|
output
| 1
| 2,487
| 0
| 4,975
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has a string s of length n consisting only of digits 0 and 1. Also he has an array a of length n.
Vasya performs the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue together the remaining parts (any of them can be empty). For example, if he erases substring 111 from string 111110 he will get the string 110. Vasya gets a_x points for erasing substring of length x.
Vasya wants to maximize his total points, so help him with this!
Input
The first line contains one integer n (1 β€ n β€ 100) β the length of string s.
The second line contains string s, consisting only of digits 0 and 1.
The third line contains n integers a_1, a_2, ... a_n (1 β€ a_i β€ 10^9), where a_i is the number of points for erasing the substring of length i.
Output
Print one integer β the maximum total points Vasya can get.
Examples
Input
7
1101001
3 4 9 100 1 2 3
Output
109
Input
5
10101
3 10 15 15 15
Output
23
Note
In the first example the optimal sequence of erasings is: 1101001 β 111001 β 11101 β 1111 β β
.
In the second example the optimal sequence of erasings is: 10101 β 1001 β 11 β β
.
|
instruction
| 0
| 2,488
| 0
| 4,976
|
Tags: dp
Correct Solution:
```
# returns answer to the subproblem with interval range [start, end],
# but with a total of "extra" additional stuff on the end
# that must be deleted last.
memo = {}
def f(dat, rewards, start, end, extra):
curr = (start, end, extra)
if curr in memo:
return memo[curr]
if start > end:
return 0
if start == end:
memo[curr] = rewards[dat[start] + extra]
return memo[curr]
# test all possible "cut points".
# "cut" is the earliest index to die in the same deletion as "end".
out = 0
for cut in range(end, start-1, -2):
if cut == end:
# in this case, we're deleting the last interval right away.
out_curr = rewards[dat[cut] + extra]
out_curr += f(dat, rewards, start, cut-1, 0)
else:
# split into 2 pieces:
# 1) slots [start, cut] plus [end + extra]
# 2) slots [cut+1, end-1] (with no extra, this needs to get deleted first).
out_curr = f(dat, rewards, start, cut, extra + dat[end])
out_curr += f(dat, rewards, cut+1, end-1, 0)
out = max(out, out_curr)
memo[curr] = out
return memo[curr]
def solve(dat_str, rewards_orig):
# break into intervals.
dat = []
pos = 0
while pos < len(dat_str):
end = pos
while end < len(dat_str) and dat_str[pos] == dat_str[end]:
end += 1
dat.append(end - pos)
pos = end
# compute the highest-value way to remove a run of size k.
# (google translated from C++ thinking)
rewards = [0, rewards_orig[0]]
for k in range(2, len(rewards_orig) + 1):
# print(
# "{}: {}".format(
# k,
# [
# rewards[k-j] + rewards_orig[j-1]
# for j in range(1, k+1)
# ]
# )
# )
rewards.append(
max(
rewards[k-j] + rewards_orig[j-1]
for j in range(1, k+1)
)
)
# print("dat: {}".format(dat))
# print("rewards: {}".format(rewards))
return f(dat, rewards, 0, len(dat)-1, 0)
# get the integer
int_dummy = input()
# get the string
dat_str = input().strip()
# get the array
rewards_input = input().strip().split()
rewards_ints = [int(x) for x in rewards_input]
# print(dat_str)
# print(rewards_ints)
print(
solve(
dat_str,
rewards_ints,
)
)
# dat_test = "10101"
# rewards_test = [3, 10, 15, 15, 15]
# print(solve(dat_test, rewards_test))
```
|
output
| 1
| 2,488
| 0
| 4,977
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has a string s of length n consisting only of digits 0 and 1. Also he has an array a of length n.
Vasya performs the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue together the remaining parts (any of them can be empty). For example, if he erases substring 111 from string 111110 he will get the string 110. Vasya gets a_x points for erasing substring of length x.
Vasya wants to maximize his total points, so help him with this!
Input
The first line contains one integer n (1 β€ n β€ 100) β the length of string s.
The second line contains string s, consisting only of digits 0 and 1.
The third line contains n integers a_1, a_2, ... a_n (1 β€ a_i β€ 10^9), where a_i is the number of points for erasing the substring of length i.
Output
Print one integer β the maximum total points Vasya can get.
Examples
Input
7
1101001
3 4 9 100 1 2 3
Output
109
Input
5
10101
3 10 15 15 15
Output
23
Note
In the first example the optimal sequence of erasings is: 1101001 β 111001 β 11101 β 1111 β β
.
In the second example the optimal sequence of erasings is: 10101 β 1001 β 11 β β
.
|
instruction
| 0
| 2,489
| 0
| 4,978
|
Tags: dp
Correct Solution:
```
n = int(input())
s = input()
a = [int(x) for x in input().split()]
dp = [[[False for i in range(101)] for j in range(101)] for k in range(101)]
def f(i, j, k):
if not dp[i][j][k]:
if i == j:
dp[i][j][k] = 0
else:
dp[i][j][k] = f(i+1, j, 0) + a[k]
for m in range(i+1, j):
if s[i] == s[m]:
dp[i][j][k] = max(dp[i][j][k], f(i+1, m, 0) + f(m, j, k+1))
return dp[i][j][k]
answer = f(0, n, 0)
print(answer)
```
|
output
| 1
| 2,489
| 0
| 4,979
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has a string s of length n consisting only of digits 0 and 1. Also he has an array a of length n.
Vasya performs the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue together the remaining parts (any of them can be empty). For example, if he erases substring 111 from string 111110 he will get the string 110. Vasya gets a_x points for erasing substring of length x.
Vasya wants to maximize his total points, so help him with this!
Input
The first line contains one integer n (1 β€ n β€ 100) β the length of string s.
The second line contains string s, consisting only of digits 0 and 1.
The third line contains n integers a_1, a_2, ... a_n (1 β€ a_i β€ 10^9), where a_i is the number of points for erasing the substring of length i.
Output
Print one integer β the maximum total points Vasya can get.
Examples
Input
7
1101001
3 4 9 100 1 2 3
Output
109
Input
5
10101
3 10 15 15 15
Output
23
Note
In the first example the optimal sequence of erasings is: 1101001 β 111001 β 11101 β 1111 β β
.
In the second example the optimal sequence of erasings is: 10101 β 1001 β 11 β β
.
|
instruction
| 0
| 2,490
| 0
| 4,980
|
Tags: dp
Correct Solution:
```
import sys
sys.setrecursionlimit(10 ** 6)
n = int(input())
s = input().strip()
a = [0] + list(map(int, input().split()))
MX = 105
dp = [0] * (MX ** 3)
def f(i, j, k):
if i == j: return 0
idx = i * MX * MX + j * MX + k
if not dp[idx]:
dp[idx] = f(i + 1, j, 1) + a[k]
for m in range(i + 1, j):
if s[i] == s[m]:
dp[idx] = max(dp[idx], f(i + 1, m, 1) + f(m, j, k + 1))
return dp[idx]
print(f(0, n, 1))
```
|
output
| 1
| 2,490
| 0
| 4,981
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has a string s of length n consisting only of digits 0 and 1. Also he has an array a of length n.
Vasya performs the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue together the remaining parts (any of them can be empty). For example, if he erases substring 111 from string 111110 he will get the string 110. Vasya gets a_x points for erasing substring of length x.
Vasya wants to maximize his total points, so help him with this!
Input
The first line contains one integer n (1 β€ n β€ 100) β the length of string s.
The second line contains string s, consisting only of digits 0 and 1.
The third line contains n integers a_1, a_2, ... a_n (1 β€ a_i β€ 10^9), where a_i is the number of points for erasing the substring of length i.
Output
Print one integer β the maximum total points Vasya can get.
Examples
Input
7
1101001
3 4 9 100 1 2 3
Output
109
Input
5
10101
3 10 15 15 15
Output
23
Note
In the first example the optimal sequence of erasings is: 1101001 β 111001 β 11101 β 1111 β β
.
In the second example the optimal sequence of erasings is: 10101 β 1001 β 11 β β
.
|
instruction
| 0
| 2,491
| 0
| 4,982
|
Tags: dp
Correct Solution:
```
n = int(input())
s = input()
ai = [0] + list(map(int,input().split()))
ar = [ai[i] for i in range(n+1)]
for i in range(1,n):
num = 0
for j in range(0,(i+1) // 2 + 1):
ar[i] = max(ar[i],ar[j] + ar[i-j])
ar2 = []
num = 1
for i in range(1,n):
if s[i] == s[i-1]:
num += 1
else:
ar2 += [num]
num = 1
ar2 += [num]
n2 = len(ar2)
ar = ar
ar3 = [[-1] * (n2 + 5) for i in range(n2+5)]
ar4 = [[[-1] * (102) for i in range(102)] for i in range(102)]
num5 = 0
def fun(i, n3, num3):
if i > n3 - 1:
return 0
ans = 0
num = num3
num2 = 0
for j in range(i,n3,2):
num += ar2[j]
if ar3[j+1][n3] == -1:
ar3[j+1][n3] = fun(j+1,n3,0)
ans = max(ans, ar3[j+1][n3] + ar[num] + num2)
for z in range(j+3,n3,2):
if ar3[j+1][z+1] == -1:
ar3[j+1][z+1] = fun(j+1,z+1,0)
if ar4[z+1][n3][num] == -1:
ar4[z+1][n3][num] = fun(z+1,n3,num)
ans = max(ans, ar3[j+1][z+1] + ar4[z+1][n3][num] + num2)
if j < n3 - 1:
num2 += ar[ar2[j+1]]
return ans
print(fun(0, n2, 0))
```
|
output
| 1
| 2,491
| 0
| 4,983
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has a string s of length n consisting only of digits 0 and 1. Also he has an array a of length n.
Vasya performs the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue together the remaining parts (any of them can be empty). For example, if he erases substring 111 from string 111110 he will get the string 110. Vasya gets a_x points for erasing substring of length x.
Vasya wants to maximize his total points, so help him with this!
Input
The first line contains one integer n (1 β€ n β€ 100) β the length of string s.
The second line contains string s, consisting only of digits 0 and 1.
The third line contains n integers a_1, a_2, ... a_n (1 β€ a_i β€ 10^9), where a_i is the number of points for erasing the substring of length i.
Output
Print one integer β the maximum total points Vasya can get.
Examples
Input
7
1101001
3 4 9 100 1 2 3
Output
109
Input
5
10101
3 10 15 15 15
Output
23
Note
In the first example the optimal sequence of erasings is: 1101001 β 111001 β 11101 β 1111 β β
.
In the second example the optimal sequence of erasings is: 10101 β 1001 β 11 β β
.
|
instruction
| 0
| 2,492
| 0
| 4,984
|
Tags: dp
Correct Solution:
```
# 545 ms
from functools import lru_cache
n = int(input())
s = input()
A = [0] + list(map(int, input().split()))
dp = [0] * (n + 1)
for i in range(1, n + 1):
dp[i] = max(dp[j] + A[i - j] for j in range(0, i))
@lru_cache(None)
def score(s):
length = len(s)
if length == 0:
return 0
ans = 0
start = 0
i = 1
while i < length and s[i] == s[start]:
i += 1
ans = dp[i] + score(s[i:])
for j in range(i, length):
if s[j] == s[start]:
ans = max(ans, score(s[i:j]) + score(s[:i] + s[j:]))
return ans
print(score(s))
```
|
output
| 1
| 2,492
| 0
| 4,985
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has a string s of length n consisting only of digits 0 and 1. Also he has an array a of length n.
Vasya performs the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue together the remaining parts (any of them can be empty). For example, if he erases substring 111 from string 111110 he will get the string 110. Vasya gets a_x points for erasing substring of length x.
Vasya wants to maximize his total points, so help him with this!
Input
The first line contains one integer n (1 β€ n β€ 100) β the length of string s.
The second line contains string s, consisting only of digits 0 and 1.
The third line contains n integers a_1, a_2, ... a_n (1 β€ a_i β€ 10^9), where a_i is the number of points for erasing the substring of length i.
Output
Print one integer β the maximum total points Vasya can get.
Examples
Input
7
1101001
3 4 9 100 1 2 3
Output
109
Input
5
10101
3 10 15 15 15
Output
23
Note
In the first example the optimal sequence of erasings is: 1101001 β 111001 β 11101 β 1111 β β
.
In the second example the optimal sequence of erasings is: 10101 β 1001 β 11 β β
.
|
instruction
| 0
| 2,493
| 0
| 4,986
|
Tags: dp
Correct Solution:
```
import sys
from math import *
from fractions import gcd
readints=lambda:map(int, input().strip('\n').split())
n=int(input())
s=input()
a=list(readints())
a=[0]+a #1-index
cache={}
def solve(i,j,k):
if i>j: return 0
if i==j: return a[k]
if (i,j,k) in cache: return cache[(i,j,k)]
best=a[k]+solve(i+1,j,1)
for x in range(i+1,j+1):
if s[i]==s[x]:
best=max(best,solve(i+1,x-1,1)+solve(x,j,k+1))
#print(i,j,best)
cache[(i,j,k)]=best
return best
ans=solve(0,n-1,1)
print(ans)
```
|
output
| 1
| 2,493
| 0
| 4,987
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has a string s of length n consisting only of digits 0 and 1. Also he has an array a of length n.
Vasya performs the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue together the remaining parts (any of them can be empty). For example, if he erases substring 111 from string 111110 he will get the string 110. Vasya gets a_x points for erasing substring of length x.
Vasya wants to maximize his total points, so help him with this!
Input
The first line contains one integer n (1 β€ n β€ 100) β the length of string s.
The second line contains string s, consisting only of digits 0 and 1.
The third line contains n integers a_1, a_2, ... a_n (1 β€ a_i β€ 10^9), where a_i is the number of points for erasing the substring of length i.
Output
Print one integer β the maximum total points Vasya can get.
Examples
Input
7
1101001
3 4 9 100 1 2 3
Output
109
Input
5
10101
3 10 15 15 15
Output
23
Note
In the first example the optimal sequence of erasings is: 1101001 β 111001 β 11101 β 1111 β β
.
In the second example the optimal sequence of erasings is: 10101 β 1001 β 11 β β
.
|
instruction
| 0
| 2,494
| 0
| 4,988
|
Tags: dp
Correct Solution:
```
from functools import lru_cache
n = int(input())
s = input()
A = [0] + list(map(int, input().split()))
dp = [0] * (n + 1)
for i in range(1, n + 1):
dp[i] = max(dp[j] + A[i - j] for j in range(0, i))
res = {}
@lru_cache(None)
def score(s):
length = len(s)
if length == 0:
return 0
ans = 0
start = 0
i = 1
while i < length and s[i] == s[start]:
i += 1
ans = dp[i] + score(s[i:])
for j in range(i, length):
if s[j] == s[start]:
ans = max(ans, score(s[i:j]) + score(s[:i] + s[j:]))
return ans
print(score(s))
```
|
output
| 1
| 2,494
| 0
| 4,989
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has a string s of length n consisting only of digits 0 and 1. Also he has an array a of length n.
Vasya performs the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue together the remaining parts (any of them can be empty). For example, if he erases substring 111 from string 111110 he will get the string 110. Vasya gets a_x points for erasing substring of length x.
Vasya wants to maximize his total points, so help him with this!
Input
The first line contains one integer n (1 β€ n β€ 100) β the length of string s.
The second line contains string s, consisting only of digits 0 and 1.
The third line contains n integers a_1, a_2, ... a_n (1 β€ a_i β€ 10^9), where a_i is the number of points for erasing the substring of length i.
Output
Print one integer β the maximum total points Vasya can get.
Examples
Input
7
1101001
3 4 9 100 1 2 3
Output
109
Input
5
10101
3 10 15 15 15
Output
23
Note
In the first example the optimal sequence of erasings is: 1101001 β 111001 β 11101 β 1111 β β
.
In the second example the optimal sequence of erasings is: 10101 β 1001 β 11 β β
.
Submitted Solution:
```
from sys import stdin
n=int(stdin.readline().strip())
s1=stdin.readline().strip()
s=list(map(int,stdin.readline().strip().split()))
dp=[-1 for i in range(n+1)]
def sol1(x):
if dp[x]!=-1:
return dp[x]
if x==0:
return 0
ans=0
for i in range(x):
ans=max(ans,s[i]+sol1(x-i-1))
dp[x]=ans
for i in range(n):
sol1(i+1)
dp[0]=0
s2=[]
x=1
for i in range(1,len(s)):
if s1[i]!=s1[i-1]:
s2.append(x)
x=1
else:
x+=1
s2.append(x)
dp1=[[[-1 for i in range(n+1)]for j in range(n+1)] for k in range(n+1)]
n=len(s2)
s=s2.copy()
def sol(l,r,k):
if l==r:
return dp[s[l]+k]
if l>r:
return 0
if dp1[l][r][k]!=-1:
return dp1[l][r][k]
ans=0
for i in range(l,r+1,2):
if i!=l:
ans=max(ans,sol(l+1,i-1,0)+sol(i,r,s[l]+k))
else:
ans=max(ans,sol(i+1,r,0)+dp[s[l]+k])
dp1[l][r][k]=ans
return ans
print(sol(0,len(s)-1,0))
```
|
instruction
| 0
| 2,495
| 0
| 4,990
|
Yes
|
output
| 1
| 2,495
| 0
| 4,991
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has a string s of length n consisting only of digits 0 and 1. Also he has an array a of length n.
Vasya performs the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue together the remaining parts (any of them can be empty). For example, if he erases substring 111 from string 111110 he will get the string 110. Vasya gets a_x points for erasing substring of length x.
Vasya wants to maximize his total points, so help him with this!
Input
The first line contains one integer n (1 β€ n β€ 100) β the length of string s.
The second line contains string s, consisting only of digits 0 and 1.
The third line contains n integers a_1, a_2, ... a_n (1 β€ a_i β€ 10^9), where a_i is the number of points for erasing the substring of length i.
Output
Print one integer β the maximum total points Vasya can get.
Examples
Input
7
1101001
3 4 9 100 1 2 3
Output
109
Input
5
10101
3 10 15 15 15
Output
23
Note
In the first example the optimal sequence of erasings is: 1101001 β 111001 β 11101 β 1111 β β
.
In the second example the optimal sequence of erasings is: 10101 β 1001 β 11 β β
.
Submitted Solution:
```
import sys
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
n = int(input())
s = input()
a = list(map(int, input().split()))
N = len(a)
dp = [[[-1] * N for i in range(N)] for j in range(N)]
def calc(l, r, k):
if dp[l][r][k] != -1:
return dp[l][r][k]
if l == r:
return a[k]
tmp = 0
for i in range(l, r):
tmp = max(tmp, calc(l, i, 0) + calc(i + 1, r, k))
if s[i] == s[r]:
tmp = max(tmp, calc(i + 1, r - 1, 0) + calc(l, i, k + 1))
dp[l][r][k] = tmp
return tmp
print(calc(0, n - 1, 0))
```
|
instruction
| 0
| 2,496
| 0
| 4,992
|
Yes
|
output
| 1
| 2,496
| 0
| 4,993
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has a string s of length n consisting only of digits 0 and 1. Also he has an array a of length n.
Vasya performs the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue together the remaining parts (any of them can be empty). For example, if he erases substring 111 from string 111110 he will get the string 110. Vasya gets a_x points for erasing substring of length x.
Vasya wants to maximize his total points, so help him with this!
Input
The first line contains one integer n (1 β€ n β€ 100) β the length of string s.
The second line contains string s, consisting only of digits 0 and 1.
The third line contains n integers a_1, a_2, ... a_n (1 β€ a_i β€ 10^9), where a_i is the number of points for erasing the substring of length i.
Output
Print one integer β the maximum total points Vasya can get.
Examples
Input
7
1101001
3 4 9 100 1 2 3
Output
109
Input
5
10101
3 10 15 15 15
Output
23
Note
In the first example the optimal sequence of erasings is: 1101001 β 111001 β 11101 β 1111 β β
.
In the second example the optimal sequence of erasings is: 10101 β 1001 β 11 β β
.
Submitted Solution:
```
n = int(input())
s = input()
A = [0] + list(map(int, input().split()))
dp = [0] * (n + 1)
for i in range(1, n + 1):
dp[i] = max(dp[j] + A[i - j] for j in range(0, i))
res = {}
def score(s):
length = len(s)
if length == 0:
return 0
if s not in res.keys():
ans = 0
start = 0
i = 1
while i < length and s[i] == s[start]:
i += 1
ans = dp[i] + score(s[i:])
for j in range(i, length):
if s[j] == s[start]:
ans = max(ans, score(s[i:j]) + score(s[:i] + s[j:]))
res[s] = ans
return res[s]
print(score(s))
```
|
instruction
| 0
| 2,497
| 0
| 4,994
|
Yes
|
output
| 1
| 2,497
| 0
| 4,995
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has a string s of length n consisting only of digits 0 and 1. Also he has an array a of length n.
Vasya performs the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue together the remaining parts (any of them can be empty). For example, if he erases substring 111 from string 111110 he will get the string 110. Vasya gets a_x points for erasing substring of length x.
Vasya wants to maximize his total points, so help him with this!
Input
The first line contains one integer n (1 β€ n β€ 100) β the length of string s.
The second line contains string s, consisting only of digits 0 and 1.
The third line contains n integers a_1, a_2, ... a_n (1 β€ a_i β€ 10^9), where a_i is the number of points for erasing the substring of length i.
Output
Print one integer β the maximum total points Vasya can get.
Examples
Input
7
1101001
3 4 9 100 1 2 3
Output
109
Input
5
10101
3 10 15 15 15
Output
23
Note
In the first example the optimal sequence of erasings is: 1101001 β 111001 β 11101 β 1111 β β
.
In the second example the optimal sequence of erasings is: 10101 β 1001 β 11 β β
.
Submitted Solution:
```
n = int(input())
s = input().strip()
a = [0] + list(map(int, input().split()))
MX = 105
dp = [0] * (MX ** 3)
idx = lambda i, j, k: i * MX * MX + j * MX + k
for i in range(n + 1):
for k in range(1, n + 1):
dp[idx(i, i, k)] = 0
for gap in range(1, n + 1):
for i in range(n):
j = i + gap
if j > n: break
for k in range(1, n + 1):
cur = idx(i, j, k)
dp[cur] = dp[idx(i + 1, j, 1)] + a[k]
for m in range(i + 1, j):
if s[i] == s[m]:
dp[cur] = max(dp[cur], dp[idx(i + 1, m, 1)] + dp[idx(m, j, k + 1)])
print(dp[idx(0, n, 1)])
```
|
instruction
| 0
| 2,498
| 0
| 4,996
|
Yes
|
output
| 1
| 2,498
| 0
| 4,997
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has a string s of length n consisting only of digits 0 and 1. Also he has an array a of length n.
Vasya performs the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue together the remaining parts (any of them can be empty). For example, if he erases substring 111 from string 111110 he will get the string 110. Vasya gets a_x points for erasing substring of length x.
Vasya wants to maximize his total points, so help him with this!
Input
The first line contains one integer n (1 β€ n β€ 100) β the length of string s.
The second line contains string s, consisting only of digits 0 and 1.
The third line contains n integers a_1, a_2, ... a_n (1 β€ a_i β€ 10^9), where a_i is the number of points for erasing the substring of length i.
Output
Print one integer β the maximum total points Vasya can get.
Examples
Input
7
1101001
3 4 9 100 1 2 3
Output
109
Input
5
10101
3 10 15 15 15
Output
23
Note
In the first example the optimal sequence of erasings is: 1101001 β 111001 β 11101 β 1111 β β
.
In the second example the optimal sequence of erasings is: 10101 β 1001 β 11 β β
.
Submitted Solution:
```
# returns answer to the subproblem with first N intervals,
# but with last interval extended by 'extra'.
memo = {}
def f(dat, rewards, N, extra):
curr = (N, extra)
if curr in memo:
return memo[curr]
if N == -1:
memo[curr] = rewards[extra]
# print(
# "for {} {}, return {}.".format(
# N,
# extra,
# memo[curr],
# )
# )
return memo[curr]
if N == 0:
memo[curr] = rewards[dat[0] + extra]
# print(
# "for {} {}, return {}.".format(
# N,
# extra,
# memo[curr],
# )
# )
return memo[curr]
##### Ben, you're in charge of stopping me as soon as you realize what I'm doing + can explain why it doesn't work.
### deal
##### I always start by coding stuff fast with bugs everywhere. I think the current version contains my full idea but probably has off by ones?
# method 1: discard interval N-1 first.
#i think it looks right. Thinking this is n*n?
### I agree N^2. N^3 would make more sense for limit 100 though... for N^2 I'd expect bound like 2e3 or something
### yeah I feel mostly convinced. I'm bad at python though.
#haha that's beautiful. all the errors
## what is?
method1 = rewards[ dat[N-1] ] + f(dat, rewards, N-2, extra + dat[N])
# method 2: discard interval N first.
method2 = rewards[ dat[N] + extra ] + f(dat, rewards, N-1, 0)
if method1 >= method2:
memo[curr] = method1
# print("better to discard N-1 first from {} {}, score is {}".format(N, extra, memo[curr]))
# print(
# "contributions were {} + {}".format(
# rewards[ dat[N-1] ],
# f(dat, rewards, N-2, extra + dat[N]),
# )
# )
else:
memo[curr] = method2
# print("better to discard N first from {} {}, score is {}".format(N, extra, memo[curr]))
# print(
# "contributions were {} + {}".format(
# rewards[ dat[N] + extra ],
# f(dat, rewards, N-1, 0),
# )
# )
return memo[curr]
def solve(dat_str, rewards_orig):
# break into intervals.
dat = []
pos = 0
while pos < len(dat_str):
end = pos
while end < len(dat_str) and dat_str[pos] == dat_str[end]:
end += 1
dat.append(end - pos)
pos = end
# compute the highest-value way to remove a run of size k.
# (google translated from C++ thinking)
rewards = [0, rewards_orig[0]]
for k in range(2, len(rewards_orig)):
# print(
# "{}: {}".format(
# k,
# [
# rewards[k-j] + rewards_orig[j-1]
# for j in range(1, k+1)
# ]
# )
# )
rewards.append(
max(
rewards[k-j] + rewards_orig[j-1]
for j in range(1, k+1)
)
)
# print("dat: {}".format(dat))
# print("rewards: {}".format(rewards))
return f(dat, rewards, len(dat)-1, 0)
# get the integer
int_dummy = input()
# get the string
dat_str = input().strip()
# get the array
rewards_input = input().strip().split()
rewards_ints = [int(x) for x in rewards_input]
# print(dat_str)
# print(rewards_ints)
print(
solve(
dat_str,
rewards_ints,
)
)
# dat_test = "1101001"
# rewards_test = [3, 4, 9, 100, 1, 2, 3]
# print(solve(dat_test, rewards_test))
```
|
instruction
| 0
| 2,499
| 0
| 4,998
|
No
|
output
| 1
| 2,499
| 0
| 4,999
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.