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.
Sometimes it is hard to prepare tests for programming problems. Now Bob is preparing tests to new problem about strings — input data to his problem is one string. Bob has 3 wrong solutions to this problem. The first gives the wrong answer if the input data contains the substring s1, the second enters an infinite loop if the input data contains the substring s2, and the third requires too much memory if the input data contains the substring s3. Bob wants these solutions to fail single test. What is the minimal length of test, which couldn't be passed by all three Bob's solutions?
Input
There are exactly 3 lines in the input data. The i-th line contains string si. All the strings are non-empty, consists of lowercase Latin letters, the length of each string doesn't exceed 105.
Output
Output one number — what is minimal length of the string, containing s1, s2 and s3 as substrings.
Examples
Input
ab
bc
cd
Output
4
Input
abacaba
abaaba
x
Output
11 | instruction | 0 | 65,143 | 0 | 130,286 |
Tags: hashing, strings
Correct Solution:
```
from itertools import permutations
from sys import stdin
from functools import lru_cache
input = stdin.readline
s1, s2, s3 = input().strip(), input().strip(), input().strip()
@lru_cache(None)
def findPattern(s):
#print(s)
slen = len(s)
p = [0]*slen
ci = 0
for i in range(1, slen):
if(s[ci] == s[i]):
ci+=1
p[i] = ci
else:
while(ci):
ci = p[ci-1]
if(s[ci]==s[i]):
ci+=1
p[i] = ci
break
return tuple(p)
@lru_cache(None)
def searchPattern(s, ps, p):
#print(s, ps, p)
slen = len(s)
plen = len(p)
smatch = [0]*slen
pi = 0
for i in range(slen):
if(s[i] == ps[pi]):
pi+=1
smatch[i] = pi
else:
while(pi):
pi = p[pi-1]
if(s[i] == ps[pi]):
pi+=1
smatch[i] = pi
break
if(pi==plen):
pi = p[pi-1]
return smatch
def calcLength(a, b, c):
pb = findPattern(b)
amatchb = searchPattern(a, b, pb)
if(len(b) not in amatchb): ab = a[:max(0, len(a) - amatchb[-1])] + b
else: ab = a
pc = findPattern(c)
abmatchc = searchPattern(ab, c, pc)
return max(0, len(ab) - abmatchc[-1]) + len(c) if len(c) not in abmatchc else len(ab)
ans = float('inf')
s = [s1, s2, s3]
for ai, bi, ci in permutations(list(range(3)), 3):
ans = min(ans, calcLength(s[ai], s[bi], s[ci]))
print(ans)
``` | output | 1 | 65,143 | 0 | 130,287 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sometimes it is hard to prepare tests for programming problems. Now Bob is preparing tests to new problem about strings — input data to his problem is one string. Bob has 3 wrong solutions to this problem. The first gives the wrong answer if the input data contains the substring s1, the second enters an infinite loop if the input data contains the substring s2, and the third requires too much memory if the input data contains the substring s3. Bob wants these solutions to fail single test. What is the minimal length of test, which couldn't be passed by all three Bob's solutions?
Input
There are exactly 3 lines in the input data. The i-th line contains string si. All the strings are non-empty, consists of lowercase Latin letters, the length of each string doesn't exceed 105.
Output
Output one number — what is minimal length of the string, containing s1, s2 and s3 as substrings.
Examples
Input
ab
bc
cd
Output
4
Input
abacaba
abaaba
x
Output
11
Submitted Solution:
```
"""
#If FastIO not needed, use this and don't forget to strip
#import sys, math
#input = sys.stdin.readline
"""
import os
import sys
from io import BytesIO, IOBase
import heapq as h
from bisect import bisect_left, bisect_right
import time
from types import GeneratorType
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
self.os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
from collections import defaultdict as dd, deque as dq, Counter as dc
import math, string
start_time = time.time()
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
def getMat(n):
return [getInts() for _ in range(n)]
def isInt(s):
return '0' <= s[0] <= '9'
MOD = 998244353
"""
find front and back overlaps between each string
012
021
102
120
201
210
"""
from itertools import permutations as pp
def solve():
S = [listStr(), listStr(), listStr()]
overlap = [[0 for j in range(3)] for i in range(3)]
def calc(x,y):
s1, s2 = S[y], S[x]
if not s1 or not s2:
return 0, False
#tail of s1 with head of s2
N = len(s1)
T = [0]*N
pos = 1
cnd = 0
flag = False
while pos < N:
if s1[pos] == s2[cnd]:
cnd += 1
#print(T,pos)
T[pos] = cnd
pos += 1
if cnd == len(s2):
flag = True
cnd = T[cnd-1]
else:
if cnd:
cnd = T[cnd-1]
else:
T[pos] = 0
pos += 1
return T[-1], flag
for ii in range(3):
for jj in range(ii+1,3):
X, flag = calc(ii,jj)
if flag:
S[ii] = ''
for k in range(3):
overlap[ii][k] = overlap[k][ii] = 0
else:
overlap[ii][jj] = X
X, flag = calc(jj,ii)
if flag:
S[jj] = ''
for k in range(3):
overlap[jj][k] = overlap[k][jj] = 0
else:
overlap[jj][ii] = X
ops = pp('012')
ans = len(S[0])+len(S[1])+len(S[2])
best = ans
for op in ops:
tmp = ans
tmp -= overlap[int(op[0])][int(op[1])]
tmp -= overlap[int(op[1])][int(op[2])]
best = min(best,tmp)
return best
#for _ in range(getInt()):
print(solve())
#solve()
#print(time.time()-start_time)á
``` | instruction | 0 | 65,144 | 0 | 130,288 |
No | output | 1 | 65,144 | 0 | 130,289 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sometimes it is hard to prepare tests for programming problems. Now Bob is preparing tests to new problem about strings — input data to his problem is one string. Bob has 3 wrong solutions to this problem. The first gives the wrong answer if the input data contains the substring s1, the second enters an infinite loop if the input data contains the substring s2, and the third requires too much memory if the input data contains the substring s3. Bob wants these solutions to fail single test. What is the minimal length of test, which couldn't be passed by all three Bob's solutions?
Input
There are exactly 3 lines in the input data. The i-th line contains string si. All the strings are non-empty, consists of lowercase Latin letters, the length of each string doesn't exceed 105.
Output
Output one number — what is minimal length of the string, containing s1, s2 and s3 as substrings.
Examples
Input
ab
bc
cd
Output
4
Input
abacaba
abaaba
x
Output
11
Submitted Solution:
```
"""
#If FastIO not needed, use this and don't forget to strip
#import sys, math
#input = sys.stdin.readline
"""
import os
import sys
from io import BytesIO, IOBase
import heapq as h
from bisect import bisect_left, bisect_right
import time
from types import GeneratorType
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
self.os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
from collections import defaultdict as dd, deque as dq, Counter as dc
import math, string
start_time = time.time()
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
def getMat(n):
return [getInts() for _ in range(n)]
def isInt(s):
return '0' <= s[0] <= '9'
MOD = 998244353
"""
find front and back overlaps between each string
012
021
102
120
201
210
"""
from itertools import permutations as pp
def solve():
S = [listStr(), listStr(), listStr()]
#s = 'ab'*50000
#s = list(s)
#S = [s]*3
overlap = [[0 for j in range(3)] for i in range(3)]
def calc(x,y):
s1, s2 = S[y], S[x]
if not s1 or not s2:
return 0, False
if s1 == s2:
return len(s1), True
#tail of s1 with head of s2
s1 = ['?']+s1
N = len(s1)
T = [0]*N
pos = 1
cnd = 0
flag = False
while pos < N:
if s1[pos] == s2[cnd]:
cnd += 1
#print(T,pos)
T[pos] = cnd
pos += 1
if cnd == len(s2):
flag = True
cnd = T[cnd-1]
else:
if cnd:
cnd = T[cnd-1]
else:
T[pos] = 0
pos += 1
return T[-1], flag
for ii in range(3):
for jj in range(ii+1,3):
X, flag = calc(ii,jj)
if flag:
S[ii] = ''
for k in range(3):
overlap[ii][k] = overlap[k][ii] = 0
else:
overlap[ii][jj] = X
X, flag = calc(jj,ii)
if flag:
S[jj] = ''
for k in range(3):
overlap[jj][k] = overlap[k][jj] = 0
else:
overlap[jj][ii] = X
ops = pp('012')
ans = len(S[0])+len(S[1])+len(S[2])
best = ans
if S[0][:60] == 'svssvssvssssssssvsvssvsvssvvsssvvssvsvsvvsssvvsvvssvvvssssvs':
print(S[0][:60],S[1][:60],S[2][:60])
for op in ops:
tmp = ans
tmp -= overlap[int(op[0])][int(op[1])]
tmp -= overlap[int(op[1])][int(op[2])]
best = min(best,tmp)
return best
#for _ in range(getInt()):
print(solve())
#solve()
#print(time.time()-start_time)á
``` | instruction | 0 | 65,145 | 0 | 130,290 |
No | output | 1 | 65,145 | 0 | 130,291 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sometimes it is hard to prepare tests for programming problems. Now Bob is preparing tests to new problem about strings — input data to his problem is one string. Bob has 3 wrong solutions to this problem. The first gives the wrong answer if the input data contains the substring s1, the second enters an infinite loop if the input data contains the substring s2, and the third requires too much memory if the input data contains the substring s3. Bob wants these solutions to fail single test. What is the minimal length of test, which couldn't be passed by all three Bob's solutions?
Input
There are exactly 3 lines in the input data. The i-th line contains string si. All the strings are non-empty, consists of lowercase Latin letters, the length of each string doesn't exceed 105.
Output
Output one number — what is minimal length of the string, containing s1, s2 and s3 as substrings.
Examples
Input
ab
bc
cd
Output
4
Input
abacaba
abaaba
x
Output
11
Submitted Solution:
```
def prefixFunction(s):
n = len(s)
pi = [0 for _ in range(n)]
for i in range(1,n):
j = pi[i-1]
while(j>0 and s[i]!=s[j]):
j = pi[j-1]
if(s[i]==s[j]): j+=1
pi[i] = j
return pi
def solve(a,b,c):
ab = b+a
bc = c+b
prfab = prefixFunction(ab)
prfbc = prefixFunction(bc)
int1 = min(min(len(a),len(b)),prfab[-1])
int2 = min(min(len(c),len(b)),prfbc[-1])
return len(a)+len(b)-int1+len(c)+len(b)-int2-len(b)
a = input()
b = input()
c = input()
ans = 1000000009
ans = min(ans,solve(a,b,c))
ans = min(ans,solve(a,c,b))
ans = min(ans,solve(b,a,c))
ans = min(ans,solve(b,c,a))
ans = min(ans,solve(c,a,b))
ans = min(ans,solve(c,b,a))
print(ans)
``` | instruction | 0 | 65,146 | 0 | 130,292 |
No | output | 1 | 65,146 | 0 | 130,293 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sometimes it is hard to prepare tests for programming problems. Now Bob is preparing tests to new problem about strings — input data to his problem is one string. Bob has 3 wrong solutions to this problem. The first gives the wrong answer if the input data contains the substring s1, the second enters an infinite loop if the input data contains the substring s2, and the third requires too much memory if the input data contains the substring s3. Bob wants these solutions to fail single test. What is the minimal length of test, which couldn't be passed by all three Bob's solutions?
Input
There are exactly 3 lines in the input data. The i-th line contains string si. All the strings are non-empty, consists of lowercase Latin letters, the length of each string doesn't exceed 105.
Output
Output one number — what is minimal length of the string, containing s1, s2 and s3 as substrings.
Examples
Input
ab
bc
cd
Output
4
Input
abacaba
abaaba
x
Output
11
Submitted Solution:
```
a = input()
b = input()
c = input()
continha = len(a)+len(b)+len(c)
cont1 = 0
cont2 = 0
cont3 = 0
cont4 = 0
cont5 = 0
cont6 = 0
cont7 = 0
cont8 = 0
cont9 = 0
cont10 = 0
cont11 = 0
cont12 = 0
# abc
for i in range(1,len(b)):
if(a.endswith(b[0:i])):
cont1 = i
for i in range(1,len(c)):
if(b.endswith(c[0:i])):
cont2 = i
# acb
for i in range(1,len(c)):
if(a.endswith(c[0:i])):
cont3 = i
for i in range(1,len(b)):
if(c.endswith(b[0:i])):
cont4 = i
# bca
for i in range(1,len(c)):
if(b.endswith(c[0:i])):
cont5 = i
for i in range(1,len(a)):
if(c.endswith(a[0:i])):
cont6 = i
# bac
for i in range(1,len(a)):
if(b.endswith(a[0:i])):
cont7 = i
for i in range(1,len(c)):
if(a.endswith(c[0:i])):
cont8 = i
# cba
for i in range(1,len(b)):
if(c.endswith(b[0:i])):
cont9 = i
for i in range(1,len(a)):
if(b.endswith(a[0:i])):
cont10 = i
#cab
for i in range(1,len(a)):
if(c.endswith(a[0:i])):
cont11 = i
for i in range(1,len(b)):
if(a.endswith(b[0:i])):
cont12 = i
conta1 = continha-cont1-cont2
conta2 = continha-cont3-cont4
conta3 = continha-cont5-cont6
conta4 = continha-cont7-cont8
conta5 = continha-cont9-cont10
conta6 = continha-cont11-cont12
#print(conta1,conta2,conta3,conta4,conta5,conta6)
valor = min(conta1,conta2,conta3,conta4,conta5,conta6)
if(valor > 100):
print(100)
elif(valor > 200):
print(1000)
else:
print(valor)
``` | instruction | 0 | 65,147 | 0 | 130,294 |
No | output | 1 | 65,147 | 0 | 130,295 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hamed has recently found a string t and suddenly became quite fond of it. He spent several days trying to find all occurrences of t in other strings he had. Finally he became tired and started thinking about the following problem. Given a string s how many ways are there to extract k ≥ 1 non-overlapping substrings from it such that each of them contains string t as a substring? More formally, you need to calculate the number of ways to choose two sequences a1, a2, ..., ak and b1, b2, ..., bk satisfying the following requirements:
* k ≥ 1
* <image>
* <image>
* <image>
* <image> t is a substring of string saisai + 1... sbi (string s is considered as 1-indexed).
As the number of ways can be rather large print it modulo 109 + 7.
Input
Input consists of two lines containing strings s and t (1 ≤ |s|, |t| ≤ 105). Each string consists of lowercase Latin letters.
Output
Print the answer in a single line.
Examples
Input
ababa
aba
Output
5
Input
welcometoroundtwohundredandeightytwo
d
Output
274201
Input
ddd
d
Output
12 | instruction | 0 | 65,176 | 0 | 130,352 |
Tags: dp, strings
Correct Solution:
```
s, t = input(), input()
n, m = len(t), len(s) + 1
d = 1000000007
g = [1] * m
f = k = 0
for i in range(1, m):
if s[i - n:i] == t: k = i
if k: f = (f + g[k - n]) % d
g[i] += (g[i - 1] + f) % d
print(f)
``` | output | 1 | 65,176 | 0 | 130,353 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hamed has recently found a string t and suddenly became quite fond of it. He spent several days trying to find all occurrences of t in other strings he had. Finally he became tired and started thinking about the following problem. Given a string s how many ways are there to extract k ≥ 1 non-overlapping substrings from it such that each of them contains string t as a substring? More formally, you need to calculate the number of ways to choose two sequences a1, a2, ..., ak and b1, b2, ..., bk satisfying the following requirements:
* k ≥ 1
* <image>
* <image>
* <image>
* <image> t is a substring of string saisai + 1... sbi (string s is considered as 1-indexed).
As the number of ways can be rather large print it modulo 109 + 7.
Input
Input consists of two lines containing strings s and t (1 ≤ |s|, |t| ≤ 105). Each string consists of lowercase Latin letters.
Output
Print the answer in a single line.
Examples
Input
ababa
aba
Output
5
Input
welcometoroundtwohundredandeightytwo
d
Output
274201
Input
ddd
d
Output
12 | instruction | 0 | 65,177 | 0 | 130,354 |
Tags: dp, strings
Correct Solution:
```
s = input()
t = input()
n = len(s)
m = len(t)
t = t + '$' + s
p = [0] * (n + m + 1)
k = 0
for i in range(1, n + m + 1):
while k > 0 and t[k] != t[i]:
k = p[k - 1]
if t[k] == t[i]:
k += 1
p[i] = k
ans = [0] * n
sums = [0] * (n + 1)
curs = 0
was = False
j = 0
MOD = 10 ** 9 + 7
for i in range(n):
if p[i + m + 1] == m:
if not was:
was = True
curs = 1
while j <= i - m:
curs = (curs + sums[j] + 1) % MOD
j += 1
ans[i] = curs
sums[i] = (sums[i - 1] + ans[i]) % MOD
print(sum(ans) % MOD)
``` | output | 1 | 65,177 | 0 | 130,355 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hamed has recently found a string t and suddenly became quite fond of it. He spent several days trying to find all occurrences of t in other strings he had. Finally he became tired and started thinking about the following problem. Given a string s how many ways are there to extract k ≥ 1 non-overlapping substrings from it such that each of them contains string t as a substring? More formally, you need to calculate the number of ways to choose two sequences a1, a2, ..., ak and b1, b2, ..., bk satisfying the following requirements:
* k ≥ 1
* <image>
* <image>
* <image>
* <image> t is a substring of string saisai + 1... sbi (string s is considered as 1-indexed).
As the number of ways can be rather large print it modulo 109 + 7.
Input
Input consists of two lines containing strings s and t (1 ≤ |s|, |t| ≤ 105). Each string consists of lowercase Latin letters.
Output
Print the answer in a single line.
Examples
Input
ababa
aba
Output
5
Input
welcometoroundtwohundredandeightytwo
d
Output
274201
Input
ddd
d
Output
12 | instruction | 0 | 65,178 | 0 | 130,356 |
Tags: dp, strings
Correct Solution:
```
MOD = 10 ** 9 + 7
s, t = input(), input()
p = t + '#' + s
z = [0] * len(p)
l = r = 0
for i in range(1, len(p)):
if i <= r:
z[i] = min(r - i + 1, z[i - l])
while i + z[i] < len(p) and p[z[i]] == p[i + z[i]]:
z[i] += 1
if i + z[i] - 1 > r:
l, r = i, i + z[i] - 1
f = [0] * (len(p) + 1)
fsum = [0] * (len(p) + 1)
fsum2 = [0] * (len(p) + 1)
for i in range(len(p) - 1, len(t), -1):
if z[i] == len(t):
f[i] = fsum2[i + z[i]] + len(p) - i - z[i] + 1
else:
f[i] = f[i + 1]
fsum[i] = (fsum[i + 1] + f[i]) % MOD
fsum2[i] = (fsum2[i + 1] + fsum[i]) % MOD
print(fsum[len(t) + 1])
``` | output | 1 | 65,178 | 0 | 130,357 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hamed has recently found a string t and suddenly became quite fond of it. He spent several days trying to find all occurrences of t in other strings he had. Finally he became tired and started thinking about the following problem. Given a string s how many ways are there to extract k ≥ 1 non-overlapping substrings from it such that each of them contains string t as a substring? More formally, you need to calculate the number of ways to choose two sequences a1, a2, ..., ak and b1, b2, ..., bk satisfying the following requirements:
* k ≥ 1
* <image>
* <image>
* <image>
* <image> t is a substring of string saisai + 1... sbi (string s is considered as 1-indexed).
As the number of ways can be rather large print it modulo 109 + 7.
Input
Input consists of two lines containing strings s and t (1 ≤ |s|, |t| ≤ 105). Each string consists of lowercase Latin letters.
Output
Print the answer in a single line.
Examples
Input
ababa
aba
Output
5
Input
welcometoroundtwohundredandeightytwo
d
Output
274201
Input
ddd
d
Output
12 | instruction | 0 | 65,179 | 0 | 130,358 |
Tags: dp, strings
Correct Solution:
```
s, t = input(), input()
n, m = len(t), len(s)
d = 10 ** 9 + 7
p = [0] * (n + 1)
i, j = 0, 1
while j < n:
if t[i] == t[j]:
j += 1
i += 1
p[j] = i
elif i: i = p[i]
else: j += 1
i = j = 0
f = [0] * (m + 1)
while j < m:
if t[i] == s[j]:
i += 1
j += 1
if i == n:
i = p[i]
f[j - n] = 1
elif i: i = p[i]
else: j += 1
s = [0] * (m + 1)
k = m
for j in range(m - 1, -1, -1):
if f[j]: k = j
if k < m:
f[j] = (f[j + 1] + s[k + n] + m - k - n + 1) % d
s[j] = (s[j + 1] + f[j]) % d
print(f[0])
``` | output | 1 | 65,179 | 0 | 130,359 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hamed has recently found a string t and suddenly became quite fond of it. He spent several days trying to find all occurrences of t in other strings he had. Finally he became tired and started thinking about the following problem. Given a string s how many ways are there to extract k ≥ 1 non-overlapping substrings from it such that each of them contains string t as a substring? More formally, you need to calculate the number of ways to choose two sequences a1, a2, ..., ak and b1, b2, ..., bk satisfying the following requirements:
* k ≥ 1
* <image>
* <image>
* <image>
* <image> t is a substring of string saisai + 1... sbi (string s is considered as 1-indexed).
As the number of ways can be rather large print it modulo 109 + 7.
Input
Input consists of two lines containing strings s and t (1 ≤ |s|, |t| ≤ 105). Each string consists of lowercase Latin letters.
Output
Print the answer in a single line.
Examples
Input
ababa
aba
Output
5
Input
welcometoroundtwohundredandeightytwo
d
Output
274201
Input
ddd
d
Output
12 | instruction | 0 | 65,180 | 0 | 130,360 |
Tags: dp, strings
Correct Solution:
```
def main():
s, t = input(), input()
n, m = len(s), len(t)
t = '$'.join((t, s))
p = [0]
k = 0
for i in range(1, n + m + 1):
while k and t[k] != t[i]:
k = p[k - 1]
if t[k] == t[i]:
k += 1
p.append(k)
ans = [0] * n
sums = [0] * (n + 1)
curs = 0
was = False
j = 0
MOD = 1000000007
for i in range(n):
if p[i + m + 1] == m:
if not was:
was = True
curs = 1
while j <= i - m:
curs = (curs + sums[j] + 1) % MOD
j += 1
ans[i] = curs
sums[i] = (sums[i - 1] + ans[i]) % MOD
print(sum(ans) % MOD)
if __name__ == '__main__':
main()
``` | output | 1 | 65,180 | 0 | 130,361 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hamed has recently found a string t and suddenly became quite fond of it. He spent several days trying to find all occurrences of t in other strings he had. Finally he became tired and started thinking about the following problem. Given a string s how many ways are there to extract k ≥ 1 non-overlapping substrings from it such that each of them contains string t as a substring? More formally, you need to calculate the number of ways to choose two sequences a1, a2, ..., ak and b1, b2, ..., bk satisfying the following requirements:
* k ≥ 1
* <image>
* <image>
* <image>
* <image> t is a substring of string saisai + 1... sbi (string s is considered as 1-indexed).
As the number of ways can be rather large print it modulo 109 + 7.
Input
Input consists of two lines containing strings s and t (1 ≤ |s|, |t| ≤ 105). Each string consists of lowercase Latin letters.
Output
Print the answer in a single line.
Examples
Input
ababa
aba
Output
5
Input
welcometoroundtwohundredandeightytwo
d
Output
274201
Input
ddd
d
Output
12 | instruction | 0 | 65,181 | 0 | 130,362 |
Tags: dp, strings
Correct Solution:
```
s, t = input(), input()
n, m = len(t), len(s) + 1
d = 1000000007
g = [1] * m
f = k = 0
for i in range(1, m):
if s[i - n:i] == t: k = i
if k: f = (f + g[k - n]) % d
g[i] += (g[i - 1] + f) % d
print(f)
# Made By Mostafa_Khaled
``` | output | 1 | 65,181 | 0 | 130,363 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hamed has recently found a string t and suddenly became quite fond of it. He spent several days trying to find all occurrences of t in other strings he had. Finally he became tired and started thinking about the following problem. Given a string s how many ways are there to extract k ≥ 1 non-overlapping substrings from it such that each of them contains string t as a substring? More formally, you need to calculate the number of ways to choose two sequences a1, a2, ..., ak and b1, b2, ..., bk satisfying the following requirements:
* k ≥ 1
* <image>
* <image>
* <image>
* <image> t is a substring of string saisai + 1... sbi (string s is considered as 1-indexed).
As the number of ways can be rather large print it modulo 109 + 7.
Input
Input consists of two lines containing strings s and t (1 ≤ |s|, |t| ≤ 105). Each string consists of lowercase Latin letters.
Output
Print the answer in a single line.
Examples
Input
ababa
aba
Output
5
Input
welcometoroundtwohundredandeightytwo
d
Output
274201
Input
ddd
d
Output
12 | instruction | 0 | 65,182 | 0 | 130,364 |
Tags: dp, strings
Correct Solution:
```
#!/usr/bin/env python
# coding=utf-8
s, t = input(), input()
n, m = len(s), len(t)
t = '$'.join((t, s))
p = [0]
k = 0
for i in range(1, n + m + 1):
while k and t[k] != t[i]:
k = p[k - 1]
if t[k] == t[i]:
k += 1
p.append(k)
ans = [0] * n
sums = [0] * (n + 1)
curs = 0
was = False
j = 0
mod = 1000000007
for i in range(n):
if p[i + m + 1] == m:
if not was:
was = True
curs = 1
while j <= i - m:
curs = (curs + sums[j] + 1) % mod
j += 1
ans[i]= curs;
sums[i] = (sums[i - 1] + ans[i]) % mod;
print(sum(ans) % mod)
``` | output | 1 | 65,182 | 0 | 130,365 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hamed has recently found a string t and suddenly became quite fond of it. He spent several days trying to find all occurrences of t in other strings he had. Finally he became tired and started thinking about the following problem. Given a string s how many ways are there to extract k ≥ 1 non-overlapping substrings from it such that each of them contains string t as a substring? More formally, you need to calculate the number of ways to choose two sequences a1, a2, ..., ak and b1, b2, ..., bk satisfying the following requirements:
* k ≥ 1
* <image>
* <image>
* <image>
* <image> t is a substring of string saisai + 1... sbi (string s is considered as 1-indexed).
As the number of ways can be rather large print it modulo 109 + 7.
Input
Input consists of two lines containing strings s and t (1 ≤ |s|, |t| ≤ 105). Each string consists of lowercase Latin letters.
Output
Print the answer in a single line.
Examples
Input
ababa
aba
Output
5
Input
welcometoroundtwohundredandeightytwo
d
Output
274201
Input
ddd
d
Output
12 | instruction | 0 | 65,183 | 0 | 130,366 |
Tags: dp, strings
Correct Solution:
```
s, t = input(), input()
n, m = len(t), len(s) + 1
h = t + ' ' + s
d = 1000000007
f = [0] * m
s = [1] * m
i = k = 0
p = [-1] + [0] * len(h)
for j in range(1, n + m):
while i + 1 and h[i] != h[j]: i = p[i]
i += 1
p[j + 1] = i
if j > n:
j -= n
if i == n: k = j
if k: f[j] = (f[j - 1] + s[k - n]) % d
s[j] += (s[j - 1] + f[j]) % d
print(f[-1])
``` | output | 1 | 65,183 | 0 | 130,367 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Hamed has recently found a string t and suddenly became quite fond of it. He spent several days trying to find all occurrences of t in other strings he had. Finally he became tired and started thinking about the following problem. Given a string s how many ways are there to extract k ≥ 1 non-overlapping substrings from it such that each of them contains string t as a substring? More formally, you need to calculate the number of ways to choose two sequences a1, a2, ..., ak and b1, b2, ..., bk satisfying the following requirements:
* k ≥ 1
* <image>
* <image>
* <image>
* <image> t is a substring of string saisai + 1... sbi (string s is considered as 1-indexed).
As the number of ways can be rather large print it modulo 109 + 7.
Input
Input consists of two lines containing strings s and t (1 ≤ |s|, |t| ≤ 105). Each string consists of lowercase Latin letters.
Output
Print the answer in a single line.
Examples
Input
ababa
aba
Output
5
Input
welcometoroundtwohundredandeightytwo
d
Output
274201
Input
ddd
d
Output
12
Submitted Solution:
```
s, t = input(), input()
n, m = len(t), len(s) + 1
h = t + ' ' + s
d = 1000000007
s = [1] * m
f = i = k = 0
p = [-1] + [0] * len(h)
for j in range(1, n + m):
while i + 1 and h[i] != h[j]: i = p[i]
i += 1
p[j + 1] = i
if j > n:
j -= n
if i == n: k = j
if k: f = (f + s[k - n]) % d
s[j] += (s[j - 1] + f) % d
print(f)
``` | instruction | 0 | 65,184 | 0 | 130,368 |
Yes | output | 1 | 65,184 | 0 | 130,369 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Hamed has recently found a string t and suddenly became quite fond of it. He spent several days trying to find all occurrences of t in other strings he had. Finally he became tired and started thinking about the following problem. Given a string s how many ways are there to extract k ≥ 1 non-overlapping substrings from it such that each of them contains string t as a substring? More formally, you need to calculate the number of ways to choose two sequences a1, a2, ..., ak and b1, b2, ..., bk satisfying the following requirements:
* k ≥ 1
* <image>
* <image>
* <image>
* <image> t is a substring of string saisai + 1... sbi (string s is considered as 1-indexed).
As the number of ways can be rather large print it modulo 109 + 7.
Input
Input consists of two lines containing strings s and t (1 ≤ |s|, |t| ≤ 105). Each string consists of lowercase Latin letters.
Output
Print the answer in a single line.
Examples
Input
ababa
aba
Output
5
Input
welcometoroundtwohundredandeightytwo
d
Output
274201
Input
ddd
d
Output
12
Submitted Solution:
```
s, t = input(), input()
n, m = len(t), len(s)
p = [0] * (n + 1)
i, j = 0, 1
while j < n:
if t[i] == t[j]:
j += 1
i += 1
p[j] = i
elif i: i = p[i]
else: j += 1
i = j = 0
f = [0] * (m + 1)
while j < m:
if t[i] == s[j]:
i += 1
j += 1
if i == n:
i = p[i]
f[j - n] = 1
elif i: i = p[i]
else: j += 1
s = [0] * (m + 1)
k = m
for j in range(m - 1, -1, -1):
if f[j]: k = j
if k < m:
f[j] = f[j + 1] + s[k + n] + m - k - n + 1
s[j] = s[j + 1] + f[j]
print(f[0])
``` | instruction | 0 | 65,185 | 0 | 130,370 |
No | output | 1 | 65,185 | 0 | 130,371 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Hamed has recently found a string t and suddenly became quite fond of it. He spent several days trying to find all occurrences of t in other strings he had. Finally he became tired and started thinking about the following problem. Given a string s how many ways are there to extract k ≥ 1 non-overlapping substrings from it such that each of them contains string t as a substring? More formally, you need to calculate the number of ways to choose two sequences a1, a2, ..., ak and b1, b2, ..., bk satisfying the following requirements:
* k ≥ 1
* <image>
* <image>
* <image>
* <image> t is a substring of string saisai + 1... sbi (string s is considered as 1-indexed).
As the number of ways can be rather large print it modulo 109 + 7.
Input
Input consists of two lines containing strings s and t (1 ≤ |s|, |t| ≤ 105). Each string consists of lowercase Latin letters.
Output
Print the answer in a single line.
Examples
Input
ababa
aba
Output
5
Input
welcometoroundtwohundredandeightytwo
d
Output
274201
Input
ddd
d
Output
12
Submitted Solution:
```
s, t = input(), input()
n, m = len(t), len(s)
d = 1000000007
g = [1] * m
f = k = 0
for i in range(m):
if i >= n and s[i - n:i] == t: k = i
if k: f = (f + g[k - n]) % d
g[i] += (g[i - 1] + f) % d
print(f)
``` | instruction | 0 | 65,186 | 0 | 130,372 |
No | output | 1 | 65,186 | 0 | 130,373 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Hamed has recently found a string t and suddenly became quite fond of it. He spent several days trying to find all occurrences of t in other strings he had. Finally he became tired and started thinking about the following problem. Given a string s how many ways are there to extract k ≥ 1 non-overlapping substrings from it such that each of them contains string t as a substring? More formally, you need to calculate the number of ways to choose two sequences a1, a2, ..., ak and b1, b2, ..., bk satisfying the following requirements:
* k ≥ 1
* <image>
* <image>
* <image>
* <image> t is a substring of string saisai + 1... sbi (string s is considered as 1-indexed).
As the number of ways can be rather large print it modulo 109 + 7.
Input
Input consists of two lines containing strings s and t (1 ≤ |s|, |t| ≤ 105). Each string consists of lowercase Latin letters.
Output
Print the answer in a single line.
Examples
Input
ababa
aba
Output
5
Input
welcometoroundtwohundredandeightytwo
d
Output
274201
Input
ddd
d
Output
12
Submitted Solution:
```
s = input()
t = input()
n = len(s)
m = len(t)
t = t + '$' + s
p = [0] * (n + m + 1)
k = 0
for i in range(1, n + m + 1):
while k > 0 and t[k] != t[i]:
k = p[k - 1]
if t[k] == t[i]:
k += 1
p[i] = k
ans = [0] * n
sums = [0] * (n + 1)
curs = 0
was = False
j = 0
MOD = 10 ** 9 + 7
for i in range(n):
if p[i + m + 1] == m:
if not was:
was = True
curs = 1
while j <= i - m:
curs = (curs + sums[j] + 1) % MOD
j += 1
ans[i] = curs
sums[i] = sums[i - 1] + ans[i]
print(sum(ans))
``` | instruction | 0 | 65,187 | 0 | 130,374 |
No | output | 1 | 65,187 | 0 | 130,375 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Hamed has recently found a string t and suddenly became quite fond of it. He spent several days trying to find all occurrences of t in other strings he had. Finally he became tired and started thinking about the following problem. Given a string s how many ways are there to extract k ≥ 1 non-overlapping substrings from it such that each of them contains string t as a substring? More formally, you need to calculate the number of ways to choose two sequences a1, a2, ..., ak and b1, b2, ..., bk satisfying the following requirements:
* k ≥ 1
* <image>
* <image>
* <image>
* <image> t is a substring of string saisai + 1... sbi (string s is considered as 1-indexed).
As the number of ways can be rather large print it modulo 109 + 7.
Input
Input consists of two lines containing strings s and t (1 ≤ |s|, |t| ≤ 105). Each string consists of lowercase Latin letters.
Output
Print the answer in a single line.
Examples
Input
ababa
aba
Output
5
Input
welcometoroundtwohundredandeightytwo
d
Output
274201
Input
ddd
d
Output
12
Submitted Solution:
```
s = input()
t = input()
near = 0
tot = 1
totsum = 1
for i in range(len(s)-len(t),-1,-1):
if s[i:i+len(t)] == t:
near = totsum
tot += near
totsum += tot
print(tot-1)
``` | instruction | 0 | 65,188 | 0 | 130,376 |
No | output | 1 | 65,188 | 0 | 130,377 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Stepan had a favorite string s which consisted of the lowercase letters of the Latin alphabet.
After graduation, he decided to remember it, but it was a long time ago, so he can't now remember it. But Stepan remembers some information about the string, namely the sequence of integers c1, c2, ..., cn, where n equals the length of the string s, and ci equals the number of substrings in the string s with the length i, consisting of the same letters. The substring is a sequence of consecutive characters in the string s.
For example, if the Stepan's favorite string is equal to "tttesst", the sequence c looks like: c = [7, 3, 1, 0, 0, 0, 0].
Stepan asks you to help to repair his favorite string s according to the given sequence c1, c2, ..., cn.
Input
The first line contains the integer n (1 ≤ n ≤ 2000) — the length of the Stepan's favorite string.
The second line contains the sequence of integers c1, c2, ..., cn (0 ≤ ci ≤ 2000), where ci equals the number of substrings of the string s with the length i, consisting of the same letters.
It is guaranteed that the input data is such that the answer always exists.
Output
Print the repaired Stepan's favorite string. If there are several answers, it is allowed to print any of them. The string should contain only lowercase letters of the English alphabet.
Examples
Input
6
6 3 1 0 0 0
Output
kkrrrq
Input
4
4 0 0 0
Output
abcd
Note
In the first test Stepan's favorite string, for example, can be the string "kkrrrq", because it contains 6 substrings with the length 1, consisting of identical letters (they begin in positions 1, 2, 3, 4, 5 and 6), 3 substrings with the length 2, consisting of identical letters (they begin in positions 1, 3 and 4), and 1 substring with the length 3, consisting of identical letters (it begins in the position 3). | instruction | 0 | 66,087 | 0 | 132,174 |
Tags: *special, constructive algorithms
Correct Solution:
```
import sys
data = sys.stdin.read().split()
data.reverse()
def read(): return int(data.pop())
def readStr(): return data.pop()
n = read()
C = [0] + [read() for i in range(n)]
ans = ""
ch, cht = 'a', 'b'
for i in range(n, 0, -1) :
while C[i] > 0 :
for j in range(i) :
ans += ch
ch, cht = cht, ch
for j in range(1, i+1) :
C[j] -= i-j+1
print(ans)
``` | output | 1 | 66,087 | 0 | 132,175 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Stepan had a favorite string s which consisted of the lowercase letters of the Latin alphabet.
After graduation, he decided to remember it, but it was a long time ago, so he can't now remember it. But Stepan remembers some information about the string, namely the sequence of integers c1, c2, ..., cn, where n equals the length of the string s, and ci equals the number of substrings in the string s with the length i, consisting of the same letters. The substring is a sequence of consecutive characters in the string s.
For example, if the Stepan's favorite string is equal to "tttesst", the sequence c looks like: c = [7, 3, 1, 0, 0, 0, 0].
Stepan asks you to help to repair his favorite string s according to the given sequence c1, c2, ..., cn.
Input
The first line contains the integer n (1 ≤ n ≤ 2000) — the length of the Stepan's favorite string.
The second line contains the sequence of integers c1, c2, ..., cn (0 ≤ ci ≤ 2000), where ci equals the number of substrings of the string s with the length i, consisting of the same letters.
It is guaranteed that the input data is such that the answer always exists.
Output
Print the repaired Stepan's favorite string. If there are several answers, it is allowed to print any of them. The string should contain only lowercase letters of the English alphabet.
Examples
Input
6
6 3 1 0 0 0
Output
kkrrrq
Input
4
4 0 0 0
Output
abcd
Note
In the first test Stepan's favorite string, for example, can be the string "kkrrrq", because it contains 6 substrings with the length 1, consisting of identical letters (they begin in positions 1, 2, 3, 4, 5 and 6), 3 substrings with the length 2, consisting of identical letters (they begin in positions 1, 3 and 4), and 1 substring with the length 3, consisting of identical letters (it begins in the position 3). | instruction | 0 | 66,088 | 0 | 132,176 |
Tags: *special, constructive algorithms
Correct Solution:
```
n = int(input())
c = list(map(int, input().strip().split()))
subStrings = []
alt = 0
for i in range(n-1,-1,-1):
while c[i] > 0:
alt = (alt + 1) % 2
if alt == 1:
substr = 'a'*(i+1)
subStrings.append(substr)
else:
substr = 'b'*(i+1)
subStrings.append(substr)
for j in range(i,-1,-1):
c[j] -= i-j + 1
print(''.join(subStrings))
``` | output | 1 | 66,088 | 0 | 132,177 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Stepan had a favorite string s which consisted of the lowercase letters of the Latin alphabet.
After graduation, he decided to remember it, but it was a long time ago, so he can't now remember it. But Stepan remembers some information about the string, namely the sequence of integers c1, c2, ..., cn, where n equals the length of the string s, and ci equals the number of substrings in the string s with the length i, consisting of the same letters. The substring is a sequence of consecutive characters in the string s.
For example, if the Stepan's favorite string is equal to "tttesst", the sequence c looks like: c = [7, 3, 1, 0, 0, 0, 0].
Stepan asks you to help to repair his favorite string s according to the given sequence c1, c2, ..., cn.
Input
The first line contains the integer n (1 ≤ n ≤ 2000) — the length of the Stepan's favorite string.
The second line contains the sequence of integers c1, c2, ..., cn (0 ≤ ci ≤ 2000), where ci equals the number of substrings of the string s with the length i, consisting of the same letters.
It is guaranteed that the input data is such that the answer always exists.
Output
Print the repaired Stepan's favorite string. If there are several answers, it is allowed to print any of them. The string should contain only lowercase letters of the English alphabet.
Examples
Input
6
6 3 1 0 0 0
Output
kkrrrq
Input
4
4 0 0 0
Output
abcd
Note
In the first test Stepan's favorite string, for example, can be the string "kkrrrq", because it contains 6 substrings with the length 1, consisting of identical letters (they begin in positions 1, 2, 3, 4, 5 and 6), 3 substrings with the length 2, consisting of identical letters (they begin in positions 1, 3 and 4), and 1 substring with the length 3, consisting of identical letters (it begins in the position 3). | instruction | 0 | 66,089 | 0 | 132,178 |
Tags: *special, constructive algorithms
Correct Solution:
```
n = int(input())
arr = list(map(int, input().split()))
for i in range(n-1, 0, -1):
for j in range(i-1, -1, -1):
arr[j] -= arr[i]*(i-j+1)
s = "a"
def rev(c):
if c == "a":
return "b"
else:
return "a"
for i in range(n):
for j in range(arr[i]):
s += rev(s[-1])*(i+1)
print(s[1:])
``` | output | 1 | 66,089 | 0 | 132,179 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Stepan had a favorite string s which consisted of the lowercase letters of the Latin alphabet.
After graduation, he decided to remember it, but it was a long time ago, so he can't now remember it. But Stepan remembers some information about the string, namely the sequence of integers c1, c2, ..., cn, where n equals the length of the string s, and ci equals the number of substrings in the string s with the length i, consisting of the same letters. The substring is a sequence of consecutive characters in the string s.
For example, if the Stepan's favorite string is equal to "tttesst", the sequence c looks like: c = [7, 3, 1, 0, 0, 0, 0].
Stepan asks you to help to repair his favorite string s according to the given sequence c1, c2, ..., cn.
Input
The first line contains the integer n (1 ≤ n ≤ 2000) — the length of the Stepan's favorite string.
The second line contains the sequence of integers c1, c2, ..., cn (0 ≤ ci ≤ 2000), where ci equals the number of substrings of the string s with the length i, consisting of the same letters.
It is guaranteed that the input data is such that the answer always exists.
Output
Print the repaired Stepan's favorite string. If there are several answers, it is allowed to print any of them. The string should contain only lowercase letters of the English alphabet.
Examples
Input
6
6 3 1 0 0 0
Output
kkrrrq
Input
4
4 0 0 0
Output
abcd
Note
In the first test Stepan's favorite string, for example, can be the string "kkrrrq", because it contains 6 substrings with the length 1, consisting of identical letters (they begin in positions 1, 2, 3, 4, 5 and 6), 3 substrings with the length 2, consisting of identical letters (they begin in positions 1, 3 and 4), and 1 substring with the length 3, consisting of identical letters (it begins in the position 3). | instruction | 0 | 66,090 | 0 | 132,180 |
Tags: *special, constructive algorithms
Correct Solution:
```
import sys
n = int(input())
c = list(map(int, input().split()))
cc = ord('a')
ans = ""
cur = n - 1
if 1:
cur = n - 1
while cur >= 0:
while c[cur] > 0:
if chr(cc) > 'z':
cc = ord('a')
ans += chr(cc) * (cur + 1)
c[cur] -= 1
for i in range(cur):
c[i] -= (cur - i + 1)
cc += 1
cur -= 1
print(ans)
``` | output | 1 | 66,090 | 0 | 132,181 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Stepan had a favorite string s which consisted of the lowercase letters of the Latin alphabet.
After graduation, he decided to remember it, but it was a long time ago, so he can't now remember it. But Stepan remembers some information about the string, namely the sequence of integers c1, c2, ..., cn, where n equals the length of the string s, and ci equals the number of substrings in the string s with the length i, consisting of the same letters. The substring is a sequence of consecutive characters in the string s.
For example, if the Stepan's favorite string is equal to "tttesst", the sequence c looks like: c = [7, 3, 1, 0, 0, 0, 0].
Stepan asks you to help to repair his favorite string s according to the given sequence c1, c2, ..., cn.
Input
The first line contains the integer n (1 ≤ n ≤ 2000) — the length of the Stepan's favorite string.
The second line contains the sequence of integers c1, c2, ..., cn (0 ≤ ci ≤ 2000), where ci equals the number of substrings of the string s with the length i, consisting of the same letters.
It is guaranteed that the input data is such that the answer always exists.
Output
Print the repaired Stepan's favorite string. If there are several answers, it is allowed to print any of them. The string should contain only lowercase letters of the English alphabet.
Examples
Input
6
6 3 1 0 0 0
Output
kkrrrq
Input
4
4 0 0 0
Output
abcd
Note
In the first test Stepan's favorite string, for example, can be the string "kkrrrq", because it contains 6 substrings with the length 1, consisting of identical letters (they begin in positions 1, 2, 3, 4, 5 and 6), 3 substrings with the length 2, consisting of identical letters (they begin in positions 1, 3 and 4), and 1 substring with the length 3, consisting of identical letters (it begins in the position 3). | instruction | 0 | 66,091 | 0 | 132,182 |
Tags: *special, constructive algorithms
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
cur = 0
k = 0
for i in range(n - 1, -1, -1):
k += cur
a[i] -= k
k += a[i]
cur += a[i]
b = [[0, 0]] * n;
for i in range(n - 1, -1, -1):
b[i] = [ a[i], i + 1 ]
b.sort()
b.reverse()
"""
for i in range(n):
for j in range(0, n - 1):
if b[j][0] < b[j + 1][0]:
temp = b[j]
b[j] = b[j + 1]
b[j + 1] = temp
"""
pos = 0
cur = 'a'
ans = [' '] * n;
while b[0][0] > 0:
for i in range(pos, pos + b[0][1]):
ans[i] = cur
if cur == 'a':
cur = 'b'
else:
cur = 'a'
pos += b[0][1]
b[0][0] -= 1;
for j in range(0, n - 1):
if b[j][0] < b[j + 1][0]:
temp = b[j]
b[j] = b[j + 1]
b[j + 1] = temp
for i in range(0, n):
print(ans[i], end = '')
``` | output | 1 | 66,091 | 0 | 132,183 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Stepan had a favorite string s which consisted of the lowercase letters of the Latin alphabet.
After graduation, he decided to remember it, but it was a long time ago, so he can't now remember it. But Stepan remembers some information about the string, namely the sequence of integers c1, c2, ..., cn, where n equals the length of the string s, and ci equals the number of substrings in the string s with the length i, consisting of the same letters. The substring is a sequence of consecutive characters in the string s.
For example, if the Stepan's favorite string is equal to "tttesst", the sequence c looks like: c = [7, 3, 1, 0, 0, 0, 0].
Stepan asks you to help to repair his favorite string s according to the given sequence c1, c2, ..., cn.
Input
The first line contains the integer n (1 ≤ n ≤ 2000) — the length of the Stepan's favorite string.
The second line contains the sequence of integers c1, c2, ..., cn (0 ≤ ci ≤ 2000), where ci equals the number of substrings of the string s with the length i, consisting of the same letters.
It is guaranteed that the input data is such that the answer always exists.
Output
Print the repaired Stepan's favorite string. If there are several answers, it is allowed to print any of them. The string should contain only lowercase letters of the English alphabet.
Examples
Input
6
6 3 1 0 0 0
Output
kkrrrq
Input
4
4 0 0 0
Output
abcd
Note
In the first test Stepan's favorite string, for example, can be the string "kkrrrq", because it contains 6 substrings with the length 1, consisting of identical letters (they begin in positions 1, 2, 3, 4, 5 and 6), 3 substrings with the length 2, consisting of identical letters (they begin in positions 1, 3 and 4), and 1 substring with the length 3, consisting of identical letters (it begins in the position 3). | instruction | 0 | 66,092 | 0 | 132,184 |
Tags: *special, constructive algorithms
Correct Solution:
```
n = int(input())
arr = list(map(int, input().split()))
c = 'a'
s = ""
for i in range(n - 1, -1, -1):
for j in range(arr[i]):
for k in range(0, i + 1):
s += c
if(c == 'a'):
c = 'b'
else:
c = 'a'
for l in range(i - 1, -1, -1):
arr[l] -= (i - l + 1) * arr[i]
print(s)
``` | output | 1 | 66,092 | 0 | 132,185 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Stepan had a favorite string s which consisted of the lowercase letters of the Latin alphabet.
After graduation, he decided to remember it, but it was a long time ago, so he can't now remember it. But Stepan remembers some information about the string, namely the sequence of integers c1, c2, ..., cn, where n equals the length of the string s, and ci equals the number of substrings in the string s with the length i, consisting of the same letters. The substring is a sequence of consecutive characters in the string s.
For example, if the Stepan's favorite string is equal to "tttesst", the sequence c looks like: c = [7, 3, 1, 0, 0, 0, 0].
Stepan asks you to help to repair his favorite string s according to the given sequence c1, c2, ..., cn.
Input
The first line contains the integer n (1 ≤ n ≤ 2000) — the length of the Stepan's favorite string.
The second line contains the sequence of integers c1, c2, ..., cn (0 ≤ ci ≤ 2000), where ci equals the number of substrings of the string s with the length i, consisting of the same letters.
It is guaranteed that the input data is such that the answer always exists.
Output
Print the repaired Stepan's favorite string. If there are several answers, it is allowed to print any of them. The string should contain only lowercase letters of the English alphabet.
Examples
Input
6
6 3 1 0 0 0
Output
kkrrrq
Input
4
4 0 0 0
Output
abcd
Note
In the first test Stepan's favorite string, for example, can be the string "kkrrrq", because it contains 6 substrings with the length 1, consisting of identical letters (they begin in positions 1, 2, 3, 4, 5 and 6), 3 substrings with the length 2, consisting of identical letters (they begin in positions 1, 3 and 4), and 1 substring with the length 3, consisting of identical letters (it begins in the position 3). | instruction | 0 | 66,093 | 0 | 132,186 |
Tags: *special, constructive algorithms
Correct Solution:
```
n=int(input())
c=[0]+list(map(int,input().split()))
ans=[]
for i in reversed(range(1,n+1)):
for x in ans:
c[i]-=x-i+1
ans+=[i]*c[i]
a=True
for x in ans:
print(end=('a' if a else 'b')*x)
a=not a
``` | output | 1 | 66,093 | 0 | 132,187 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Stepan had a favorite string s which consisted of the lowercase letters of the Latin alphabet.
After graduation, he decided to remember it, but it was a long time ago, so he can't now remember it. But Stepan remembers some information about the string, namely the sequence of integers c1, c2, ..., cn, where n equals the length of the string s, and ci equals the number of substrings in the string s with the length i, consisting of the same letters. The substring is a sequence of consecutive characters in the string s.
For example, if the Stepan's favorite string is equal to "tttesst", the sequence c looks like: c = [7, 3, 1, 0, 0, 0, 0].
Stepan asks you to help to repair his favorite string s according to the given sequence c1, c2, ..., cn.
Input
The first line contains the integer n (1 ≤ n ≤ 2000) — the length of the Stepan's favorite string.
The second line contains the sequence of integers c1, c2, ..., cn (0 ≤ ci ≤ 2000), where ci equals the number of substrings of the string s with the length i, consisting of the same letters.
It is guaranteed that the input data is such that the answer always exists.
Output
Print the repaired Stepan's favorite string. If there are several answers, it is allowed to print any of them. The string should contain only lowercase letters of the English alphabet.
Examples
Input
6
6 3 1 0 0 0
Output
kkrrrq
Input
4
4 0 0 0
Output
abcd
Note
In the first test Stepan's favorite string, for example, can be the string "kkrrrq", because it contains 6 substrings with the length 1, consisting of identical letters (they begin in positions 1, 2, 3, 4, 5 and 6), 3 substrings with the length 2, consisting of identical letters (they begin in positions 1, 3 and 4), and 1 substring with the length 3, consisting of identical letters (it begins in the position 3). | instruction | 0 | 66,094 | 0 | 132,188 |
Tags: *special, constructive algorithms
Correct Solution:
```
n = int(input())
a = [0] + list(map(int, input().split()))
for i in range(n, 0, -1):
for j in range(i + 1, n + 1):
a[i] -= a[j] * (j - i + 1)
x = 'b'
for i in range(1, n + 1):
for _ in range(a[i]):
for __ in range(i):
print(x, end = '')
x = chr(ord(x) ^ 1)
``` | output | 1 | 66,094 | 0 | 132,189 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Stepan had a favorite string s which consisted of the lowercase letters of the Latin alphabet.
After graduation, he decided to remember it, but it was a long time ago, so he can't now remember it. But Stepan remembers some information about the string, namely the sequence of integers c1, c2, ..., cn, where n equals the length of the string s, and ci equals the number of substrings in the string s with the length i, consisting of the same letters. The substring is a sequence of consecutive characters in the string s.
For example, if the Stepan's favorite string is equal to "tttesst", the sequence c looks like: c = [7, 3, 1, 0, 0, 0, 0].
Stepan asks you to help to repair his favorite string s according to the given sequence c1, c2, ..., cn.
Input
The first line contains the integer n (1 ≤ n ≤ 2000) — the length of the Stepan's favorite string.
The second line contains the sequence of integers c1, c2, ..., cn (0 ≤ ci ≤ 2000), where ci equals the number of substrings of the string s with the length i, consisting of the same letters.
It is guaranteed that the input data is such that the answer always exists.
Output
Print the repaired Stepan's favorite string. If there are several answers, it is allowed to print any of them. The string should contain only lowercase letters of the English alphabet.
Examples
Input
6
6 3 1 0 0 0
Output
kkrrrq
Input
4
4 0 0 0
Output
abcd
Note
In the first test Stepan's favorite string, for example, can be the string "kkrrrq", because it contains 6 substrings with the length 1, consisting of identical letters (they begin in positions 1, 2, 3, 4, 5 and 6), 3 substrings with the length 2, consisting of identical letters (they begin in positions 1, 3 and 4), and 1 substring with the length 3, consisting of identical letters (it begins in the position 3).
Submitted Solution:
```
n = int(input())
a = [int(x) for x in input().split()]
cur = 'a'
s=""
for i in reversed(range(n)):
for j in range(0,a[i]):
s+=cur*(i+1)
cur=('a','b')[cur=='a']
for j in reversed(range(i)):
a[j]-=(i-j+1)*a[i]
a[i]=0
print(s)
``` | instruction | 0 | 66,095 | 0 | 132,190 |
Yes | output | 1 | 66,095 | 0 | 132,191 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Stepan had a favorite string s which consisted of the lowercase letters of the Latin alphabet.
After graduation, he decided to remember it, but it was a long time ago, so he can't now remember it. But Stepan remembers some information about the string, namely the sequence of integers c1, c2, ..., cn, where n equals the length of the string s, and ci equals the number of substrings in the string s with the length i, consisting of the same letters. The substring is a sequence of consecutive characters in the string s.
For example, if the Stepan's favorite string is equal to "tttesst", the sequence c looks like: c = [7, 3, 1, 0, 0, 0, 0].
Stepan asks you to help to repair his favorite string s according to the given sequence c1, c2, ..., cn.
Input
The first line contains the integer n (1 ≤ n ≤ 2000) — the length of the Stepan's favorite string.
The second line contains the sequence of integers c1, c2, ..., cn (0 ≤ ci ≤ 2000), where ci equals the number of substrings of the string s with the length i, consisting of the same letters.
It is guaranteed that the input data is such that the answer always exists.
Output
Print the repaired Stepan's favorite string. If there are several answers, it is allowed to print any of them. The string should contain only lowercase letters of the English alphabet.
Examples
Input
6
6 3 1 0 0 0
Output
kkrrrq
Input
4
4 0 0 0
Output
abcd
Note
In the first test Stepan's favorite string, for example, can be the string "kkrrrq", because it contains 6 substrings with the length 1, consisting of identical letters (they begin in positions 1, 2, 3, 4, 5 and 6), 3 substrings with the length 2, consisting of identical letters (they begin in positions 1, 3 and 4), and 1 substring with the length 3, consisting of identical letters (it begins in the position 3).
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
cur = 0
k = 0
for i in range(n - 1, -1, -1):
k += cur
a[i] -= k
cur += a[i]
b = [[0, 0]] * n;
for i in range(n - 1, -1, -1):
b[i] = [ a[i], i + 1 ]
for i in range(n):
for j in range(0, n - 1):
if b[j][0] < b[j + 1][0]:
swap(b[j][0], b[j + 1][0])
pos = 0
cur = 'a'
ans = [' '] * n;
while b[0][0] > 0:
for i in range(pos, pos + b[0][1]):
ans[i] = cur
if cur == 'a':
cur = 'b'
else:
cur = 'a'
pos += b[0][1]
b[0][0] -= 1;
for i in range(0, n - 1):
if b[j][0] < b[j + 1][0]:
swap(b[j][0], b[j + 1][0])
for i in range(0, n):
print(ans[i])
``` | instruction | 0 | 66,096 | 0 | 132,192 |
No | output | 1 | 66,096 | 0 | 132,193 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Stepan had a favorite string s which consisted of the lowercase letters of the Latin alphabet.
After graduation, he decided to remember it, but it was a long time ago, so he can't now remember it. But Stepan remembers some information about the string, namely the sequence of integers c1, c2, ..., cn, where n equals the length of the string s, and ci equals the number of substrings in the string s with the length i, consisting of the same letters. The substring is a sequence of consecutive characters in the string s.
For example, if the Stepan's favorite string is equal to "tttesst", the sequence c looks like: c = [7, 3, 1, 0, 0, 0, 0].
Stepan asks you to help to repair his favorite string s according to the given sequence c1, c2, ..., cn.
Input
The first line contains the integer n (1 ≤ n ≤ 2000) — the length of the Stepan's favorite string.
The second line contains the sequence of integers c1, c2, ..., cn (0 ≤ ci ≤ 2000), where ci equals the number of substrings of the string s with the length i, consisting of the same letters.
It is guaranteed that the input data is such that the answer always exists.
Output
Print the repaired Stepan's favorite string. If there are several answers, it is allowed to print any of them. The string should contain only lowercase letters of the English alphabet.
Examples
Input
6
6 3 1 0 0 0
Output
kkrrrq
Input
4
4 0 0 0
Output
abcd
Note
In the first test Stepan's favorite string, for example, can be the string "kkrrrq", because it contains 6 substrings with the length 1, consisting of identical letters (they begin in positions 1, 2, 3, 4, 5 and 6), 3 substrings with the length 2, consisting of identical letters (they begin in positions 1, 3 and 4), and 1 substring with the length 3, consisting of identical letters (it begins in the position 3).
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
cur = 0
k = 0
for i in range(n - 1, -1, -1):
k += cur
a[i] -= k
cur += a[i]
b = [[0, 0]] * n;
for i in range(n - 1, -1, -1):
b[i] = [ a[i], i + 1 ]
for i in range(n):
for j in range(n - 1):
if b[j][0] < b[j + 1][0]:
swap(b[j][0], b[j + 1][0])
pos = 0
cur = 'a'
ans = [' '] * n;
while b[0][0] > 0:
for i in range(pos, pos + b[0][1]):
ans[i] = cur
if cur == 'a':
cur = 'b'
else:
cur = 'a'
pos += b[0][1]
b[0][0] -= 1;
for i in range(n - 1):
if b[j][0] < b[j + 1][0]:
swap(b[j][0], b[j + 1][0])
for i in range(n):
print(ans[i])
``` | instruction | 0 | 66,097 | 0 | 132,194 |
No | output | 1 | 66,097 | 0 | 132,195 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S of length N-1. Each character in S is `<` or `>`.
A sequence of N non-negative integers, a_1,a_2,\cdots,a_N, is said to be good when the following condition is satisfied for all i (1 \leq i \leq N-1):
* If S_i= `<`: a_i<a_{i+1}
* If S_i= `>`: a_i>a_{i+1}
Find the minimum possible sum of the elements of a good sequence of N non-negative integers.
Constraints
* 2 \leq N \leq 5 \times 10^5
* S is a string of length N-1 consisting of `<` and `>`.
Input
Input is given from Standard Input in the following format:
S
Output
Find the minimum possible sum of the elements of a good sequence of N non-negative integers.
Examples
Input
<>>
Output
3
Input
<>>><<><<<<<>>><
Output
28 | instruction | 0 | 66,243 | 0 | 132,486 |
"Correct Solution:
```
s = input().replace('><','> <').split()
ans = 0
#print(list(s))
for st in s:
lt = st.count('<')
gt = len(st) - lt
if lt > gt:
gt -= 1
else:
lt -= 1
ans += (lt*lt+lt)//2 + (gt*gt+gt)//2
print(ans)
``` | output | 1 | 66,243 | 0 | 132,487 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S of length N-1. Each character in S is `<` or `>`.
A sequence of N non-negative integers, a_1,a_2,\cdots,a_N, is said to be good when the following condition is satisfied for all i (1 \leq i \leq N-1):
* If S_i= `<`: a_i<a_{i+1}
* If S_i= `>`: a_i>a_{i+1}
Find the minimum possible sum of the elements of a good sequence of N non-negative integers.
Constraints
* 2 \leq N \leq 5 \times 10^5
* S is a string of length N-1 consisting of `<` and `>`.
Input
Input is given from Standard Input in the following format:
S
Output
Find the minimum possible sum of the elements of a good sequence of N non-negative integers.
Examples
Input
<>>
Output
3
Input
<>>><<><<<<<>>><
Output
28 | instruction | 0 | 66,248 | 0 | 132,496 |
"Correct Solution:
```
s=input()
sl=len(s)
l=[0 for i in range(sl+1)]
for i in range(sl):
if s[i]=='<':
l[i+1]=max(l[i]+1, l[i+1])
for i in reversed(range(sl)): # reversed(range(sl))
if s[i]=='>':
l[i]=max(l[i+1]+1, l[i])
print(sum(l))
``` | output | 1 | 66,248 | 0 | 132,497 |
Provide a correct Python 3 solution for this coding contest problem.
The ABC number of a string T is the number of triples of integers (i, j, k) that satisfy all of the following conditions:
* 1 ≤ i < j < k ≤ |T| (|T| is the length of T.)
* T_i = `A` (T_i is the i-th character of T from the beginning.)
* T_j = `B`
* T_k = `C`
For example, when T = `ABCBC`, there are three triples of integers (i, j, k) that satisfy the conditions: (1, 2, 3), (1, 2, 5), (1, 4, 5). Thus, the ABC number of T is 3.
You are given a string S. Each character of S is `A`, `B`, `C` or `?`.
Let Q be the number of occurrences of `?` in S. We can make 3^Q strings by replacing each occurrence of `?` in S with `A`, `B` or `C`. Find the sum of the ABC numbers of all these strings.
This sum can be extremely large, so print the sum modulo 10^9 + 7.
Constraints
* 3 ≤ |S| ≤ 10^5
* Each character of S is `A`, `B`, `C` or `?`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the sum of the ABC numbers of all the 3^Q strings, modulo 10^9 + 7.
Examples
Input
A??C
Output
8
Input
ABCBC
Output
3
Input
????C?????B??????A???????
Output
979596887 | instruction | 0 | 66,290 | 0 | 132,580 |
"Correct Solution:
```
S = input()
N = len(S)
MOD = 10**9 + 7
DP = [[1] * 4 for _ in range(N + 1)]
# initialize
DP[N][3] = 1
DP[N][0] = 0
DP[N][1] = 0
DP[N][2] = 0
for i in range(N-1, -1, -1):
for j in range(3, -1, -1):
DP[i][j] = DP[i+1][j] * (3 if S[i]=='?' else 1)
if j<3:
DP[i][j] += DP[i + 1][j + 1] * (1 if (S[i]=='ABC'[j] or S[i]=='?') else 0)
DP[i][j] %= MOD
ans = DP[0][0]
print(ans)
``` | output | 1 | 66,290 | 0 | 132,581 |
Provide a correct Python 3 solution for this coding contest problem.
The ABC number of a string T is the number of triples of integers (i, j, k) that satisfy all of the following conditions:
* 1 ≤ i < j < k ≤ |T| (|T| is the length of T.)
* T_i = `A` (T_i is the i-th character of T from the beginning.)
* T_j = `B`
* T_k = `C`
For example, when T = `ABCBC`, there are three triples of integers (i, j, k) that satisfy the conditions: (1, 2, 3), (1, 2, 5), (1, 4, 5). Thus, the ABC number of T is 3.
You are given a string S. Each character of S is `A`, `B`, `C` or `?`.
Let Q be the number of occurrences of `?` in S. We can make 3^Q strings by replacing each occurrence of `?` in S with `A`, `B` or `C`. Find the sum of the ABC numbers of all these strings.
This sum can be extremely large, so print the sum modulo 10^9 + 7.
Constraints
* 3 ≤ |S| ≤ 10^5
* Each character of S is `A`, `B`, `C` or `?`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the sum of the ABC numbers of all the 3^Q strings, modulo 10^9 + 7.
Examples
Input
A??C
Output
8
Input
ABCBC
Output
3
Input
????C?????B??????A???????
Output
979596887 | instruction | 0 | 66,291 | 0 | 132,582 |
"Correct Solution:
```
mod = 1000000007
S = input()
n = 1
a = 0
ab = 0
abc = 0
for s in S:
if s in "A":
a += n
if s in "B":
ab += a
if s == "C":
abc += ab
if s in "?":
n, a, ab, abc = 3 * n, 3 * a + n, 3 * ab + a, 3 * abc + ab
n %= mod
a %= mod
ab %= mod
abc %= mod
print(abc % mod)
``` | output | 1 | 66,291 | 0 | 132,583 |
Provide a correct Python 3 solution for this coding contest problem.
The ABC number of a string T is the number of triples of integers (i, j, k) that satisfy all of the following conditions:
* 1 ≤ i < j < k ≤ |T| (|T| is the length of T.)
* T_i = `A` (T_i is the i-th character of T from the beginning.)
* T_j = `B`
* T_k = `C`
For example, when T = `ABCBC`, there are three triples of integers (i, j, k) that satisfy the conditions: (1, 2, 3), (1, 2, 5), (1, 4, 5). Thus, the ABC number of T is 3.
You are given a string S. Each character of S is `A`, `B`, `C` or `?`.
Let Q be the number of occurrences of `?` in S. We can make 3^Q strings by replacing each occurrence of `?` in S with `A`, `B` or `C`. Find the sum of the ABC numbers of all these strings.
This sum can be extremely large, so print the sum modulo 10^9 + 7.
Constraints
* 3 ≤ |S| ≤ 10^5
* Each character of S is `A`, `B`, `C` or `?`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the sum of the ABC numbers of all the 3^Q strings, modulo 10^9 + 7.
Examples
Input
A??C
Output
8
Input
ABCBC
Output
3
Input
????C?????B??????A???????
Output
979596887 | instruction | 0 | 66,292 | 0 | 132,584 |
"Correct Solution:
```
S = input(); N = len(S)
a,b,c,d = 0,0,0,1
mod = 10**9+7
for x in reversed(S):
if x == "?":
a,b,c,d = (3*a+b)%mod, (3*b+c)%mod, (3*c+d)%mod, 3*d%mod
elif x == "A": a = (a+b)%mod
elif x == "B": b = (b+c)%mod
elif x == "C": c = (c+d)%mod
print(a)
``` | output | 1 | 66,292 | 0 | 132,585 |
Provide a correct Python 3 solution for this coding contest problem.
The ABC number of a string T is the number of triples of integers (i, j, k) that satisfy all of the following conditions:
* 1 ≤ i < j < k ≤ |T| (|T| is the length of T.)
* T_i = `A` (T_i is the i-th character of T from the beginning.)
* T_j = `B`
* T_k = `C`
For example, when T = `ABCBC`, there are three triples of integers (i, j, k) that satisfy the conditions: (1, 2, 3), (1, 2, 5), (1, 4, 5). Thus, the ABC number of T is 3.
You are given a string S. Each character of S is `A`, `B`, `C` or `?`.
Let Q be the number of occurrences of `?` in S. We can make 3^Q strings by replacing each occurrence of `?` in S with `A`, `B` or `C`. Find the sum of the ABC numbers of all these strings.
This sum can be extremely large, so print the sum modulo 10^9 + 7.
Constraints
* 3 ≤ |S| ≤ 10^5
* Each character of S is `A`, `B`, `C` or `?`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the sum of the ABC numbers of all the 3^Q strings, modulo 10^9 + 7.
Examples
Input
A??C
Output
8
Input
ABCBC
Output
3
Input
????C?????B??????A???????
Output
979596887 | instruction | 0 | 66,293 | 0 | 132,586 |
"Correct Solution:
```
MOD = 10 ** 9 + 7
S = input()
N = len(S)
dp = [[0] * 4 for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for j in range(4):
s = S[i]
m1 = 3 if s == '?' else 1
m2 = 1 if j != 0 and (s == '?' or s == 'ABC'[j - 1]) else 0
dp[i + 1][j] = (m1 * dp[i][j] + m2 * dp[i][j - 1]) % MOD
print(dp[N][3])
``` | output | 1 | 66,293 | 0 | 132,587 |
Provide a correct Python 3 solution for this coding contest problem.
The ABC number of a string T is the number of triples of integers (i, j, k) that satisfy all of the following conditions:
* 1 ≤ i < j < k ≤ |T| (|T| is the length of T.)
* T_i = `A` (T_i is the i-th character of T from the beginning.)
* T_j = `B`
* T_k = `C`
For example, when T = `ABCBC`, there are three triples of integers (i, j, k) that satisfy the conditions: (1, 2, 3), (1, 2, 5), (1, 4, 5). Thus, the ABC number of T is 3.
You are given a string S. Each character of S is `A`, `B`, `C` or `?`.
Let Q be the number of occurrences of `?` in S. We can make 3^Q strings by replacing each occurrence of `?` in S with `A`, `B` or `C`. Find the sum of the ABC numbers of all these strings.
This sum can be extremely large, so print the sum modulo 10^9 + 7.
Constraints
* 3 ≤ |S| ≤ 10^5
* Each character of S is `A`, `B`, `C` or `?`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the sum of the ABC numbers of all the 3^Q strings, modulo 10^9 + 7.
Examples
Input
A??C
Output
8
Input
ABCBC
Output
3
Input
????C?????B??????A???????
Output
979596887 | instruction | 0 | 66,294 | 0 | 132,588 |
"Correct Solution:
```
s = input()
n = len(s)
mod = 10**9+7
cnt = 0
dp = [[0 for i in range(4)] for j in range(n+1)]
dp[0][0] = 1
for i in range(1,n+1):
if s[i-1] in "A?":
dp[i][1] += dp[i-1][0]
if s[i-1] in "B?":
dp[i][2] += dp[i-1][1]
if s[i-1] in "C?":
dp[i][3] += dp[i-1][2]
for j in range(4):
if s[i-1] == "?":
dp[i][j] += dp[i-1][j]*3
else:
dp[i][j] += dp[i-1][j]
dp[i][j] %= mod
print(dp[-1][-1])
``` | output | 1 | 66,294 | 0 | 132,589 |
Provide a correct Python 3 solution for this coding contest problem.
The ABC number of a string T is the number of triples of integers (i, j, k) that satisfy all of the following conditions:
* 1 ≤ i < j < k ≤ |T| (|T| is the length of T.)
* T_i = `A` (T_i is the i-th character of T from the beginning.)
* T_j = `B`
* T_k = `C`
For example, when T = `ABCBC`, there are three triples of integers (i, j, k) that satisfy the conditions: (1, 2, 3), (1, 2, 5), (1, 4, 5). Thus, the ABC number of T is 3.
You are given a string S. Each character of S is `A`, `B`, `C` or `?`.
Let Q be the number of occurrences of `?` in S. We can make 3^Q strings by replacing each occurrence of `?` in S with `A`, `B` or `C`. Find the sum of the ABC numbers of all these strings.
This sum can be extremely large, so print the sum modulo 10^9 + 7.
Constraints
* 3 ≤ |S| ≤ 10^5
* Each character of S is `A`, `B`, `C` or `?`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the sum of the ABC numbers of all the 3^Q strings, modulo 10^9 + 7.
Examples
Input
A??C
Output
8
Input
ABCBC
Output
3
Input
????C?????B??????A???????
Output
979596887 | instruction | 0 | 66,295 | 0 | 132,590 |
"Correct Solution:
```
s=input()
mod=10**9+7
a=0
ab=0
abc=0
q=1
for i in s:
if i=="?":
abc*=3
abc+=ab
ab*=3
ab+=a
a*=3
a+=q
q*=3
q%=mod
elif i=="A":
a+=q
elif i=="B":
ab+=a
else:
abc+=ab
abc%=mod
ab%=mod
a%=mod
print(abc)
``` | output | 1 | 66,295 | 0 | 132,591 |
Provide a correct Python 3 solution for this coding contest problem.
The ABC number of a string T is the number of triples of integers (i, j, k) that satisfy all of the following conditions:
* 1 ≤ i < j < k ≤ |T| (|T| is the length of T.)
* T_i = `A` (T_i is the i-th character of T from the beginning.)
* T_j = `B`
* T_k = `C`
For example, when T = `ABCBC`, there are three triples of integers (i, j, k) that satisfy the conditions: (1, 2, 3), (1, 2, 5), (1, 4, 5). Thus, the ABC number of T is 3.
You are given a string S. Each character of S is `A`, `B`, `C` or `?`.
Let Q be the number of occurrences of `?` in S. We can make 3^Q strings by replacing each occurrence of `?` in S with `A`, `B` or `C`. Find the sum of the ABC numbers of all these strings.
This sum can be extremely large, so print the sum modulo 10^9 + 7.
Constraints
* 3 ≤ |S| ≤ 10^5
* Each character of S is `A`, `B`, `C` or `?`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the sum of the ABC numbers of all the 3^Q strings, modulo 10^9 + 7.
Examples
Input
A??C
Output
8
Input
ABCBC
Output
3
Input
????C?????B??????A???????
Output
979596887 | instruction | 0 | 66,296 | 0 | 132,592 |
"Correct Solution:
```
s=input()
mod=10**9+7
n,a,b,c=1,0,0,0
for i in s:
if i=="A":
a+=n
if i=="B":
b+=a
if i=="C":
c+=b
if i=="?":
n,a,b,c=3*n,3*a+n,3*b+a,3*c+b
n%=mod
a%=mod
b%=mod
c%=mod
print(c)
``` | output | 1 | 66,296 | 0 | 132,593 |
Provide a correct Python 3 solution for this coding contest problem.
The ABC number of a string T is the number of triples of integers (i, j, k) that satisfy all of the following conditions:
* 1 ≤ i < j < k ≤ |T| (|T| is the length of T.)
* T_i = `A` (T_i is the i-th character of T from the beginning.)
* T_j = `B`
* T_k = `C`
For example, when T = `ABCBC`, there are three triples of integers (i, j, k) that satisfy the conditions: (1, 2, 3), (1, 2, 5), (1, 4, 5). Thus, the ABC number of T is 3.
You are given a string S. Each character of S is `A`, `B`, `C` or `?`.
Let Q be the number of occurrences of `?` in S. We can make 3^Q strings by replacing each occurrence of `?` in S with `A`, `B` or `C`. Find the sum of the ABC numbers of all these strings.
This sum can be extremely large, so print the sum modulo 10^9 + 7.
Constraints
* 3 ≤ |S| ≤ 10^5
* Each character of S is `A`, `B`, `C` or `?`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the sum of the ABC numbers of all the 3^Q strings, modulo 10^9 + 7.
Examples
Input
A??C
Output
8
Input
ABCBC
Output
3
Input
????C?????B??????A???????
Output
979596887 | instruction | 0 | 66,297 | 0 | 132,594 |
"Correct Solution:
```
# D - We Love ABC
S = list(input())
MOD = 10**9 + 7
n_possible = 1 # その場所以前の文字列としてあり得るパターン
A = 0 # その場所以前の文字列におけるA数
B = 0
C = 0
for s in S:
if s == "A":
A += n_possible
elif s == "B":
B += A
elif s == "C":
C += B
else:
# X = 3*X + Y
# この場所の？を (AorABorABCの一部に含めない場合) + (AorABorABCの一部に含める場合)
C = 3*C + B
B = 3*B + A
A = 3*A + n_possible
n_possible *= 3
n_possible %= MOD
A %= MOD
B %= MOD
C %= MOD
print(C)
``` | output | 1 | 66,297 | 0 | 132,595 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The ABC number of a string T is the number of triples of integers (i, j, k) that satisfy all of the following conditions:
* 1 ≤ i < j < k ≤ |T| (|T| is the length of T.)
* T_i = `A` (T_i is the i-th character of T from the beginning.)
* T_j = `B`
* T_k = `C`
For example, when T = `ABCBC`, there are three triples of integers (i, j, k) that satisfy the conditions: (1, 2, 3), (1, 2, 5), (1, 4, 5). Thus, the ABC number of T is 3.
You are given a string S. Each character of S is `A`, `B`, `C` or `?`.
Let Q be the number of occurrences of `?` in S. We can make 3^Q strings by replacing each occurrence of `?` in S with `A`, `B` or `C`. Find the sum of the ABC numbers of all these strings.
This sum can be extremely large, so print the sum modulo 10^9 + 7.
Constraints
* 3 ≤ |S| ≤ 10^5
* Each character of S is `A`, `B`, `C` or `?`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the sum of the ABC numbers of all the 3^Q strings, modulo 10^9 + 7.
Examples
Input
A??C
Output
8
Input
ABCBC
Output
3
Input
????C?????B??????A???????
Output
979596887
Submitted Solution:
```
s = input()
mod = 10 ** 9 + 7
l = len(s)
dp = [[0] * 4 for _ in range(l + 1)]
dp[0][0] = 1
for i, e in enumerate(s, 1):
# do not use in ABC
for j in range(4):
if e == "?":
dp[i][j] += dp[i-1][j] * 3
else:
dp[i][j] += dp[i-1][j]
# use in ABC
if e == "A" or e == "?":
dp[i][1] += dp[i-1][0]
if e == "B" or e == "?":
dp[i][2] += dp[i-1][1]
if e == "C" or e == "?":
dp[i][3] += dp[i-1][2]
for j in range(4):
dp[i][j] %= mod
ans = dp[l][3]
print(ans)
``` | instruction | 0 | 66,298 | 0 | 132,596 |
Yes | output | 1 | 66,298 | 0 | 132,597 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The ABC number of a string T is the number of triples of integers (i, j, k) that satisfy all of the following conditions:
* 1 ≤ i < j < k ≤ |T| (|T| is the length of T.)
* T_i = `A` (T_i is the i-th character of T from the beginning.)
* T_j = `B`
* T_k = `C`
For example, when T = `ABCBC`, there are three triples of integers (i, j, k) that satisfy the conditions: (1, 2, 3), (1, 2, 5), (1, 4, 5). Thus, the ABC number of T is 3.
You are given a string S. Each character of S is `A`, `B`, `C` or `?`.
Let Q be the number of occurrences of `?` in S. We can make 3^Q strings by replacing each occurrence of `?` in S with `A`, `B` or `C`. Find the sum of the ABC numbers of all these strings.
This sum can be extremely large, so print the sum modulo 10^9 + 7.
Constraints
* 3 ≤ |S| ≤ 10^5
* Each character of S is `A`, `B`, `C` or `?`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the sum of the ABC numbers of all the 3^Q strings, modulo 10^9 + 7.
Examples
Input
A??C
Output
8
Input
ABCBC
Output
3
Input
????C?????B??????A???????
Output
979596887
Submitted Solution:
```
def index(c):return ord(c)-ord('A')+1
s=' '+input()
m=10**9+7
dp=[[0]*4 for _ in range(len(s))]
dp[0][0]=1
for i in range(1,len(s)):
for j in range(4):
dp[i][j]=dp[i-1][j]
if s[i]=='?':
dp[i][0]=dp[i-1][0]*3%m
for j in range(1,4):
dp[i][j]=(dp[i-1][j-1]+dp[i-1][j]*3)%m
else:
k=index(s[i])
dp[i][k]=(dp[i-1][k-1]+dp[i-1][k])%m
print(dp[-1][3])
``` | instruction | 0 | 66,299 | 0 | 132,598 |
Yes | output | 1 | 66,299 | 0 | 132,599 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The ABC number of a string T is the number of triples of integers (i, j, k) that satisfy all of the following conditions:
* 1 ≤ i < j < k ≤ |T| (|T| is the length of T.)
* T_i = `A` (T_i is the i-th character of T from the beginning.)
* T_j = `B`
* T_k = `C`
For example, when T = `ABCBC`, there are three triples of integers (i, j, k) that satisfy the conditions: (1, 2, 3), (1, 2, 5), (1, 4, 5). Thus, the ABC number of T is 3.
You are given a string S. Each character of S is `A`, `B`, `C` or `?`.
Let Q be the number of occurrences of `?` in S. We can make 3^Q strings by replacing each occurrence of `?` in S with `A`, `B` or `C`. Find the sum of the ABC numbers of all these strings.
This sum can be extremely large, so print the sum modulo 10^9 + 7.
Constraints
* 3 ≤ |S| ≤ 10^5
* Each character of S is `A`, `B`, `C` or `?`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the sum of the ABC numbers of all the 3^Q strings, modulo 10^9 + 7.
Examples
Input
A??C
Output
8
Input
ABCBC
Output
3
Input
????C?????B??????A???????
Output
979596887
Submitted Solution:
```
M = 10**9 + 7
N, A, AB, ABC = 1, 0, 0, 0
idx = {'A': 1, 'B': 2, 'C': 3}
for c in input():
if c == '?':
N, A, AB, ABC = (N * 3) % M, (A * 3 + N) % M, (AB * 3 + A) % M, (ABC * 3 + AB) % M
elif c == 'A':
A += N
elif c == 'B':
AB += A
else:
ABC += AB
print(ABC % M)
``` | instruction | 0 | 66,300 | 0 | 132,600 |
Yes | output | 1 | 66,300 | 0 | 132,601 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The ABC number of a string T is the number of triples of integers (i, j, k) that satisfy all of the following conditions:
* 1 ≤ i < j < k ≤ |T| (|T| is the length of T.)
* T_i = `A` (T_i is the i-th character of T from the beginning.)
* T_j = `B`
* T_k = `C`
For example, when T = `ABCBC`, there are three triples of integers (i, j, k) that satisfy the conditions: (1, 2, 3), (1, 2, 5), (1, 4, 5). Thus, the ABC number of T is 3.
You are given a string S. Each character of S is `A`, `B`, `C` or `?`.
Let Q be the number of occurrences of `?` in S. We can make 3^Q strings by replacing each occurrence of `?` in S with `A`, `B` or `C`. Find the sum of the ABC numbers of all these strings.
This sum can be extremely large, so print the sum modulo 10^9 + 7.
Constraints
* 3 ≤ |S| ≤ 10^5
* Each character of S is `A`, `B`, `C` or `?`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the sum of the ABC numbers of all the 3^Q strings, modulo 10^9 + 7.
Examples
Input
A??C
Output
8
Input
ABCBC
Output
3
Input
????C?????B??????A???????
Output
979596887
Submitted Solution:
```
MOD = 10**9 + 7
S = input()
res = 0
dp0 = 1 # ''
dp1 = 0 # 'a'
dp2 = 0 # 'ab'
dp3 = 0 # 'abc'
for c in S:
if c == 'A':
dp1 += dp0
elif c == 'B':
dp2 += dp1
elif c == 'C':
dp3 += dp2
else:
dp0,dp1,dp2,dp3 = dp0*3,dp1*3+dp0,dp2*3+dp1,dp3*3+dp2
dp0 %= MOD
dp1 %= MOD
dp2 %= MOD
dp3 %= MOD
print(dp3)
``` | instruction | 0 | 66,301 | 0 | 132,602 |
Yes | output | 1 | 66,301 | 0 | 132,603 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The ABC number of a string T is the number of triples of integers (i, j, k) that satisfy all of the following conditions:
* 1 ≤ i < j < k ≤ |T| (|T| is the length of T.)
* T_i = `A` (T_i is the i-th character of T from the beginning.)
* T_j = `B`
* T_k = `C`
For example, when T = `ABCBC`, there are three triples of integers (i, j, k) that satisfy the conditions: (1, 2, 3), (1, 2, 5), (1, 4, 5). Thus, the ABC number of T is 3.
You are given a string S. Each character of S is `A`, `B`, `C` or `?`.
Let Q be the number of occurrences of `?` in S. We can make 3^Q strings by replacing each occurrence of `?` in S with `A`, `B` or `C`. Find the sum of the ABC numbers of all these strings.
This sum can be extremely large, so print the sum modulo 10^9 + 7.
Constraints
* 3 ≤ |S| ≤ 10^5
* Each character of S is `A`, `B`, `C` or `?`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the sum of the ABC numbers of all the 3^Q strings, modulo 10^9 + 7.
Examples
Input
A??C
Output
8
Input
ABCBC
Output
3
Input
????C?????B??????A???????
Output
979596887
Submitted Solution:
```
ABC = 'ABC'
S = input()
dp = [0, 0, 0, 0]
dp[3] = 1
for i in range(len(S))[::-1]:
c = S[i]
if c == '?':
dp[0] = 3 * dp[0] + dp[1]
dp[1] = 3 * dp[1] + dp[2]
dp[2] = 3 * dp[2] + dp[3]
dp[3] = 3 * dp[3]
elif c == 'A':
dp[0] = 1 * dp[0] + dp[1]
dp[1] = 1 * dp[1]
dp[2] = 1 * dp[2]
dp[3] = 1 * dp[3]
elif c == 'B':
dp[0] = 1 * dp[0]
dp[1] = 1 * dp[1] + dp[2]
dp[2] = 1 * dp[2]
dp[3] = 1 * dp[3]
elif c == 'C':
dp[0] = 1 * dp[0]
dp[1] = 1 * dp[1]
dp[2] = 1 * dp[2] + dp[3]
dp[3] = 1 * dp[3]
print(dp[0] % 1000000007)
``` | instruction | 0 | 66,302 | 0 | 132,604 |
No | output | 1 | 66,302 | 0 | 132,605 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The ABC number of a string T is the number of triples of integers (i, j, k) that satisfy all of the following conditions:
* 1 ≤ i < j < k ≤ |T| (|T| is the length of T.)
* T_i = `A` (T_i is the i-th character of T from the beginning.)
* T_j = `B`
* T_k = `C`
For example, when T = `ABCBC`, there are three triples of integers (i, j, k) that satisfy the conditions: (1, 2, 3), (1, 2, 5), (1, 4, 5). Thus, the ABC number of T is 3.
You are given a string S. Each character of S is `A`, `B`, `C` or `?`.
Let Q be the number of occurrences of `?` in S. We can make 3^Q strings by replacing each occurrence of `?` in S with `A`, `B` or `C`. Find the sum of the ABC numbers of all these strings.
This sum can be extremely large, so print the sum modulo 10^9 + 7.
Constraints
* 3 ≤ |S| ≤ 10^5
* Each character of S is `A`, `B`, `C` or `?`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the sum of the ABC numbers of all the 3^Q strings, modulo 10^9 + 7.
Examples
Input
A??C
Output
8
Input
ABCBC
Output
3
Input
????C?????B??????A???????
Output
979596887
Submitted Solution:
```
s=input()
a=[1,0,0,0]
for i in range(len(s)):
c=s[i]
if c=="A":
a[1]+=a[0]
elif c=="B":
a[2]+=a[1]
elif c=="C":
a[3]+=a[2]
elif c=="?":
tmp=[a[i] for i in range(4)]
a[0]=tmp[0]*3
for j in range(3):
a[j+1]=tmp[j+1]*3+tmp[j]
print(a[3]%1000000007)
``` | instruction | 0 | 66,303 | 0 | 132,606 |
No | output | 1 | 66,303 | 0 | 132,607 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The ABC number of a string T is the number of triples of integers (i, j, k) that satisfy all of the following conditions:
* 1 ≤ i < j < k ≤ |T| (|T| is the length of T.)
* T_i = `A` (T_i is the i-th character of T from the beginning.)
* T_j = `B`
* T_k = `C`
For example, when T = `ABCBC`, there are three triples of integers (i, j, k) that satisfy the conditions: (1, 2, 3), (1, 2, 5), (1, 4, 5). Thus, the ABC number of T is 3.
You are given a string S. Each character of S is `A`, `B`, `C` or `?`.
Let Q be the number of occurrences of `?` in S. We can make 3^Q strings by replacing each occurrence of `?` in S with `A`, `B` or `C`. Find the sum of the ABC numbers of all these strings.
This sum can be extremely large, so print the sum modulo 10^9 + 7.
Constraints
* 3 ≤ |S| ≤ 10^5
* Each character of S is `A`, `B`, `C` or `?`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the sum of the ABC numbers of all the 3^Q strings, modulo 10^9 + 7.
Examples
Input
A??C
Output
8
Input
ABCBC
Output
3
Input
????C?????B??????A???????
Output
979596887
Submitted Solution:
```
S = ''
def we_love_abc()->int:
global S
ABC = 'ABC'
dp = [0, 0, 0, 0]
dp[3] = 1
for c in reversed(S):
if c == '?':
m, m1 = 3, 3
else:
m, m1 = 1, 1
for j in range(3):
m2 = 1 if c == '?' or c == ABC[j] else 0
dp[j] = m1 * dp[j] + m2 * dp[j+1]
dp[3] = m * dp[3]
return dp[0] % 1000000007
if __name__ == "__main__":
S = input()
ans = we_love_abc() # S)
print(ans)
``` | instruction | 0 | 66,304 | 0 | 132,608 |
No | output | 1 | 66,304 | 0 | 132,609 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The ABC number of a string T is the number of triples of integers (i, j, k) that satisfy all of the following conditions:
* 1 ≤ i < j < k ≤ |T| (|T| is the length of T.)
* T_i = `A` (T_i is the i-th character of T from the beginning.)
* T_j = `B`
* T_k = `C`
For example, when T = `ABCBC`, there are three triples of integers (i, j, k) that satisfy the conditions: (1, 2, 3), (1, 2, 5), (1, 4, 5). Thus, the ABC number of T is 3.
You are given a string S. Each character of S is `A`, `B`, `C` or `?`.
Let Q be the number of occurrences of `?` in S. We can make 3^Q strings by replacing each occurrence of `?` in S with `A`, `B` or `C`. Find the sum of the ABC numbers of all these strings.
This sum can be extremely large, so print the sum modulo 10^9 + 7.
Constraints
* 3 ≤ |S| ≤ 10^5
* Each character of S is `A`, `B`, `C` or `?`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the sum of the ABC numbers of all the 3^Q strings, modulo 10^9 + 7.
Examples
Input
A??C
Output
8
Input
ABCBC
Output
3
Input
????C?????B??????A???????
Output
979596887
Submitted Solution:
```
mod = 10**9+7
def pow(n,p):
res=1
while p >0:
if p%2==0:
n = n**2 % mod
p //= 2
else:
res = res * n % mod
p -= 1
return res % mod
def main():
s=input()
res = 0
ca = 0
cc = s.count("C")
cw = 0
aw = s.count("?")
for c in s:
if c == "A":
ca += 1
elif c == "C":
cc -= 1
elif c == "B":
res += ca*cc*pow(3,aw)+ca*(aw-cw)*pow(3,aw-1)+cw*cc*pow(3,aw-1)+cw*(aw-cw)*pow(3,aw-2)
res %= mod
elif c == "?":
res += ca*cc*pow(3,aw-1)+ca*(aw-cw-1)*pow(3,aw-2)+cw*cc*pow(3,aw-2)+cw*(aw-cw-1)*pow(3,aw-3)
res %= mod
cw += 1
print(res)
main()
``` | instruction | 0 | 66,305 | 0 | 132,610 |
No | output | 1 | 66,305 | 0 | 132,611 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s of length n consisting of lowercase Latin letters. You may apply some operations to this string: in one operation you can delete some contiguous substring of this string, if all letters in the substring you delete are equal. For example, after deleting substring bbbb from string abbbbaccdd we get the string aaccdd.
Calculate the minimum number of operations to delete the whole string s.
Input
The first line contains one integer n (1 ≤ n ≤ 500) — the length of string s.
The second line contains the string s (|s| = n) consisting of lowercase Latin letters.
Output
Output a single integer — the minimal number of operation to delete string s.
Examples
Input
5
abaca
Output
3
Input
8
abcddcba
Output
4
Submitted Solution:
```
def compress(s): # abbccbdaab -> abcbdab -> abbab (+2) -> abab
s1 = ''.join(s[i] for i in range(len(s)) if i == 0 or s[i] != s[i-1])
counts = {}
for i, c in enumerate(s1):
if c not in counts: counts[c] = 0
counts[c] += 1
sout = ''
ops = 0
for c in s1:
if counts[c] == 1:
ops += 1
elif not sout or c != sout[-1]:
sout += c
return sout, ops
def get_indices(s):
out = {}
for i, c in enumerate(s):
if c not in out: out[c] = set()
out[c].add(i)
return out
def _solve(s, indices, i, j, memo):
if i > j: return 0
if i == j: return 1
if (i,j) in memo: return memo[(i,j)]
memo[(i,j)] = _solve(s, indices, i, j-1, memo)+1
for k in indices[s[j]]:
if i <= k < j:
memo[(i,j)] = min(memo[(i,j)], _solve(s, indices, i, k-1, memo) + _solve(s, indices, k+1, j-1, memo)+1)
return memo[(i,j)]
def solve(s):
s, ops = compress(s)
indices = get_indices(s)
ops += _solve(s, indices, 0, len(s)-1, {})
return ops
def main():
from sys import stdin
s = stdin.readline().strip()
out = solve(s)
print('{}'.format(out))
if __name__ == '__main__':
main()
``` | instruction | 0 | 66,492 | 0 | 132,984 |
No | output | 1 | 66,492 | 0 | 132,985 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s of length n consisting of lowercase Latin letters. You may apply some operations to this string: in one operation you can delete some contiguous substring of this string, if all letters in the substring you delete are equal. For example, after deleting substring bbbb from string abbbbaccdd we get the string aaccdd.
Calculate the minimum number of operations to delete the whole string s.
Input
The first line contains one integer n (1 ≤ n ≤ 500) — the length of string s.
The second line contains the string s (|s| = n) consisting of lowercase Latin letters.
Output
Output a single integer — the minimal number of operation to delete string s.
Examples
Input
5
abaca
Output
3
Input
8
abcddcba
Output
4
Submitted Solution:
```
n = int(input())
s = input()
cnt = 0
bayan = set()
for i in range(n):
for j in range(n):
if s[i] == s[j] and s[i] not in bayan and len(set(s[i:j])) == 2:
cnt += 1
bayan.add(s[i])
print(len(set(s)) * cnt)
``` | instruction | 0 | 66,493 | 0 | 132,986 |
No | output | 1 | 66,493 | 0 | 132,987 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s of length n consisting of lowercase Latin letters. You may apply some operations to this string: in one operation you can delete some contiguous substring of this string, if all letters in the substring you delete are equal. For example, after deleting substring bbbb from string abbbbaccdd we get the string aaccdd.
Calculate the minimum number of operations to delete the whole string s.
Input
The first line contains one integer n (1 ≤ n ≤ 500) — the length of string s.
The second line contains the string s (|s| = n) consisting of lowercase Latin letters.
Output
Output a single integer — the minimal number of operation to delete string s.
Examples
Input
5
abaca
Output
3
Input
8
abcddcba
Output
4
Submitted Solution:
```
input()
s = input()
# print(min(list(s)))
def f(x):
if len(x) == 1:
return 1
if len(x) == 0:
return 0
return sum([f(c) for c in x.split( min(list(x)) ) ]) + 1
print(f(s))
``` | instruction | 0 | 66,494 | 0 | 132,988 |
No | output | 1 | 66,494 | 0 | 132,989 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.