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 |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a binary string s (recall that a string is binary if each character is either 0 or 1).
Let f(t) be the decimal representation of integer t written in binary form (possibly with leading zeroes). For example f(011) = 3, f(00101) = 5, f(00001) = 1, f(10) = 2, f(000) = 0 and f(000100) = 4.
The substring s_{l}, s_{l+1}, ... , s_{r} is good if r - l + 1 = f(s_l ... s_r).
For example string s = 1011 has 5 good substrings: s_1 ... s_1 = 1, s_3 ... s_3 = 1, s_4 ... s_4 = 1, s_1 ... s_2 = 10 and s_2 ... s_4 = 011.
Your task is to calculate the number of good substrings of string s.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
The only line of each query contains string s (1 ≤ |s| ≤ 2 ⋅ 10^5), consisting of only digits 0 and 1.
It is guaranteed that ∑_{i=1}^{t} |s_i| ≤ 2 ⋅ 10^5.
Output
For each query print one integer — the number of good substrings of string s.
Example
Input
4
0110
0101
00001000
0001000
Output
4
3
4
3
Submitted Solution:
```
if __name__ == '__main__':
t = int(input())
nm = {}
for i in range(1, 200001):
nm[format(i, 'b')] = i
while t > 0:
s = input()
sm = [0]
for c in s:
sm.append(sm[-1] + (1 if c == '1' else 0))
ans = 0
for sz in range(1, 20):
for i in range(0, len(s) - sz + 1):
if s[i: i + sz] in nm:
num = nm[s[i: i + sz]]
if num == sz:
ans += 1
else:
li = i + sz - num
if li >= 0 == sm[i] - sm[li]:
ans += 1
print(ans)
t -= 1
``` | instruction | 0 | 93,604 | 0 | 187,208 |
Yes | output | 1 | 93,604 | 0 | 187,209 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a binary string s (recall that a string is binary if each character is either 0 or 1).
Let f(t) be the decimal representation of integer t written in binary form (possibly with leading zeroes). For example f(011) = 3, f(00101) = 5, f(00001) = 1, f(10) = 2, f(000) = 0 and f(000100) = 4.
The substring s_{l}, s_{l+1}, ... , s_{r} is good if r - l + 1 = f(s_l ... s_r).
For example string s = 1011 has 5 good substrings: s_1 ... s_1 = 1, s_3 ... s_3 = 1, s_4 ... s_4 = 1, s_1 ... s_2 = 10 and s_2 ... s_4 = 011.
Your task is to calculate the number of good substrings of string s.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
The only line of each query contains string s (1 ≤ |s| ≤ 2 ⋅ 10^5), consisting of only digits 0 and 1.
It is guaranteed that ∑_{i=1}^{t} |s_i| ≤ 2 ⋅ 10^5.
Output
For each query print one integer — the number of good substrings of string s.
Example
Input
4
0110
0101
00001000
0001000
Output
4
3
4
3
Submitted Solution:
```
# cook your dish here
def binaryToDecimal(n):
return int(n,2)
t=int(input())
for _ in range(t):
s=input()
ct=0
zr=0
for i in range(len(s)):
if s[i]=='0':
zr+=1
else:
for j in range(i,len(s)):
#print(zr)
if binaryToDecimal(s[i:j+1])<=zr+j-i+1:
#print(binaryToDecimal(s[i:j+1]))
#print(j-i+1)
ct+=1
else:
break
zr=0
print(ct)
``` | instruction | 0 | 93,605 | 0 | 187,210 |
Yes | output | 1 | 93,605 | 0 | 187,211 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a binary string s (recall that a string is binary if each character is either 0 or 1).
Let f(t) be the decimal representation of integer t written in binary form (possibly with leading zeroes). For example f(011) = 3, f(00101) = 5, f(00001) = 1, f(10) = 2, f(000) = 0 and f(000100) = 4.
The substring s_{l}, s_{l+1}, ... , s_{r} is good if r - l + 1 = f(s_l ... s_r).
For example string s = 1011 has 5 good substrings: s_1 ... s_1 = 1, s_3 ... s_3 = 1, s_4 ... s_4 = 1, s_1 ... s_2 = 10 and s_2 ... s_4 = 011.
Your task is to calculate the number of good substrings of string s.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
The only line of each query contains string s (1 ≤ |s| ≤ 2 ⋅ 10^5), consisting of only digits 0 and 1.
It is guaranteed that ∑_{i=1}^{t} |s_i| ≤ 2 ⋅ 10^5.
Output
For each query print one integer — the number of good substrings of string s.
Example
Input
4
0110
0101
00001000
0001000
Output
4
3
4
3
Submitted Solution:
```
#########################################################################################################\
#########################################################################################################
###################################The_Apurv_Rathore#####################################################
#########################################################################################################
#########################################################################################################
import sys,os,io
from sys import stdin
from math import log, gcd, ceil
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from bisect import bisect_left , bisect_right
import math
alphabets = list('abcdefghijklmnopqrstuvwxyz')
def isPrime(x):
for i in range(2,x):
if i*i>x:
break
if (x%i==0):
return False
return True
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den,
p - 2, p)) % p
def primeFactors(n):
l = []
while n % 2 == 0:
l.append(2)
n = n / 2
for i in range(3,int(math.sqrt(n))+1,2):
while n % i== 0:
l.append(int(i))
n = n / i
if n > 2:
l.append(n)
return list(set(l))
def power(x, y, p) :
res = 1
x = x % p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) :
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def SieveOfEratosthenes(n):
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def si():
return input()
def prefix_sum(arr):
r = [0] * (len(arr)+1)
for i, el in enumerate(arr):
r[i+1] = r[i] + el
return r
def divideCeil(n,x):
if (n%x==0):
return n//x
return n//x+1
def ii():
return int(input())
def li():
return list(map(int,input().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
def power_set(L):
"""
L is a list.
The function returns the power set, but as a list of lists.
"""
cardinality=len(L)
n=2 ** cardinality
powerset = []
for i in range(n):
a=bin(i)[2:]
subset=[]
for j in range(len(a)):
if a[-j-1]=='1':
subset.append(L[j])
powerset.append(subset)
#the function could stop here closing with
#return powerset
powerset_orderred=[]
for k in range(cardinality+1):
for w in powerset:
if len(w)==k:
powerset_orderred.append(w)
return powerset_orderred
def fastPlrintNextLines(a):
# 12
# 3
# 1
#like this
#a is list of strings
print('\n'.join(map(str,a)))
#__________________________TEMPLATE__________________OVER_______________________________________________________
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r") ; sys.stdout = open("output.txt","w")
# else:
# input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def fun(x):
# print(x)
tt1 = x[:]
tt = len(x)
x = ''.join(x)
x = int(x,2)
# print(x,tt,cnt)
if x-tt<=cnt:
# print(tt1)
return True
return False
t = 1
t = int(input())
for _ in range(t):
s = list(si())
n = len(s)
cnt = 0
res = 0
for i in range(n):
if (s[i]=='0'):
cnt+=1
else:
x = []
for j in range(i,n):
x+=s[j]
if fun(x):
res+=1
else:
break
cnt = 0
print(res)
``` | instruction | 0 | 93,606 | 0 | 187,212 |
Yes | output | 1 | 93,606 | 0 | 187,213 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a binary string s (recall that a string is binary if each character is either 0 or 1).
Let f(t) be the decimal representation of integer t written in binary form (possibly with leading zeroes). For example f(011) = 3, f(00101) = 5, f(00001) = 1, f(10) = 2, f(000) = 0 and f(000100) = 4.
The substring s_{l}, s_{l+1}, ... , s_{r} is good if r - l + 1 = f(s_l ... s_r).
For example string s = 1011 has 5 good substrings: s_1 ... s_1 = 1, s_3 ... s_3 = 1, s_4 ... s_4 = 1, s_1 ... s_2 = 10 and s_2 ... s_4 = 011.
Your task is to calculate the number of good substrings of string s.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
The only line of each query contains string s (1 ≤ |s| ≤ 2 ⋅ 10^5), consisting of only digits 0 and 1.
It is guaranteed that ∑_{i=1}^{t} |s_i| ≤ 2 ⋅ 10^5.
Output
For each query print one integer — the number of good substrings of string s.
Example
Input
4
0110
0101
00001000
0001000
Output
4
3
4
3
Submitted Solution:
```
from sys import stdin
from sys import setrecursionlimit as SRL;
SRL(10 ** 7)
rd = stdin.readline
rrd = lambda: map(int, rd().strip().split())
T = int(input())
while T:
s = "".join(map(str, rd().strip()))
ans = 0
max0 = 0
for i in range(len(s)):
if s[i] == '0':
max0 += 1
else:
ans += 1
tot = 1
for j in range(1, 20):
tot = tot << 1
if i + j < len(s):
if s[i + j] == '1':
tot += 1
if max0 >= tot-j-1:
ans += 1
max0 = 0
print(ans)
T -= 1
``` | instruction | 0 | 93,607 | 0 | 187,214 |
Yes | output | 1 | 93,607 | 0 | 187,215 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a binary string s (recall that a string is binary if each character is either 0 or 1).
Let f(t) be the decimal representation of integer t written in binary form (possibly with leading zeroes). For example f(011) = 3, f(00101) = 5, f(00001) = 1, f(10) = 2, f(000) = 0 and f(000100) = 4.
The substring s_{l}, s_{l+1}, ... , s_{r} is good if r - l + 1 = f(s_l ... s_r).
For example string s = 1011 has 5 good substrings: s_1 ... s_1 = 1, s_3 ... s_3 = 1, s_4 ... s_4 = 1, s_1 ... s_2 = 10 and s_2 ... s_4 = 011.
Your task is to calculate the number of good substrings of string s.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
The only line of each query contains string s (1 ≤ |s| ≤ 2 ⋅ 10^5), consisting of only digits 0 and 1.
It is guaranteed that ∑_{i=1}^{t} |s_i| ≤ 2 ⋅ 10^5.
Output
For each query print one integer — the number of good substrings of string s.
Example
Input
4
0110
0101
00001000
0001000
Output
4
3
4
3
Submitted Solution:
```
import sys
t = int(input())
for _ in range(t):
s: str = sys.stdin.readline().rstrip() + "*"
n = len(s)
zero = [0]*n
p = []
for i in range(1, n-1):
if s[i-1] == '0':
zero[i] = zero[i-1] + 1
else:
zero[i] = 0
zero[i+1] = zero[i]
if s[i] == '1':
p.append(i)
ans = 0
for i in range(1, 100):
target = bin(i)[2:]
leading_zero = i - len(target)
suf_len = len(target)
if leading_zero + suf_len > n:
break
for j in p:
if (zero[j] >= leading_zero and target == s[j:j+suf_len]):
ans += 1
print(ans)
``` | instruction | 0 | 93,608 | 0 | 187,216 |
No | output | 1 | 93,608 | 0 | 187,217 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a binary string s (recall that a string is binary if each character is either 0 or 1).
Let f(t) be the decimal representation of integer t written in binary form (possibly with leading zeroes). For example f(011) = 3, f(00101) = 5, f(00001) = 1, f(10) = 2, f(000) = 0 and f(000100) = 4.
The substring s_{l}, s_{l+1}, ... , s_{r} is good if r - l + 1 = f(s_l ... s_r).
For example string s = 1011 has 5 good substrings: s_1 ... s_1 = 1, s_3 ... s_3 = 1, s_4 ... s_4 = 1, s_1 ... s_2 = 10 and s_2 ... s_4 = 011.
Your task is to calculate the number of good substrings of string s.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
The only line of each query contains string s (1 ≤ |s| ≤ 2 ⋅ 10^5), consisting of only digits 0 and 1.
It is guaranteed that ∑_{i=1}^{t} |s_i| ≤ 2 ⋅ 10^5.
Output
For each query print one integer — the number of good substrings of string s.
Example
Input
4
0110
0101
00001000
0001000
Output
4
3
4
3
Submitted Solution:
```
#########################################################################################################\
#########################################################################################################
###################################The_Apurv_Rathore#####################################################
#########################################################################################################
#########################################################################################################
import sys,os,io
from sys import stdin
from math import log, gcd, ceil
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from bisect import bisect_left , bisect_right
import math
alphabets = list('abcdefghijklmnopqrstuvwxyz')
def isPrime(x):
for i in range(2,x):
if i*i>x:
break
if (x%i==0):
return False
return True
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den,
p - 2, p)) % p
def primeFactors(n):
l = []
while n % 2 == 0:
l.append(2)
n = n / 2
for i in range(3,int(math.sqrt(n))+1,2):
while n % i== 0:
l.append(int(i))
n = n / i
if n > 2:
l.append(n)
return list(set(l))
def power(x, y, p) :
res = 1
x = x % p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) :
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def SieveOfEratosthenes(n):
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def si():
return input()
def prefix_sum(arr):
r = [0] * (len(arr)+1)
for i, el in enumerate(arr):
r[i+1] = r[i] + el
return r
def divideCeil(n,x):
if (n%x==0):
return n//x
return n//x+1
def ii():
return int(input())
def li():
return list(map(int,input().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
def power_set(L):
"""
L is a list.
The function returns the power set, but as a list of lists.
"""
cardinality=len(L)
n=2 ** cardinality
powerset = []
for i in range(n):
a=bin(i)[2:]
subset=[]
for j in range(len(a)):
if a[-j-1]=='1':
subset.append(L[j])
powerset.append(subset)
#the function could stop here closing with
#return powerset
powerset_orderred=[]
for k in range(cardinality+1):
for w in powerset:
if len(w)==k:
powerset_orderred.append(w)
return powerset_orderred
def fastPlrintNextLines(a):
# 12
# 3
# 1
#like this
#a is list of strings
print('\n'.join(map(str,a)))
#__________________________TEMPLATE__________________OVER_______________________________________________________
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r") ; sys.stdout = open("output.txt","w")
# else:
# input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def fun(x):
# print(x)
tt1 = x[:]
tt = len(x)
x = ''.join(x)
x = int(x,2)
# print(x,tt,cnt)
if x-tt<=cnt:
# print(tt1)
return True
return False
t = 1
t = int(input())
for _ in range(t):
s = list(si())
n = len(s)
cnt = 0
res = 0
for i in range(n):
if (s[i]=='0'):
cnt+=1
else:
x = []
for j in range(i,n):
x+=s[j]
if fun(x):
res+=1
else:
break
print(res)
``` | instruction | 0 | 93,609 | 0 | 187,218 |
No | output | 1 | 93,609 | 0 | 187,219 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a binary string s (recall that a string is binary if each character is either 0 or 1).
Let f(t) be the decimal representation of integer t written in binary form (possibly with leading zeroes). For example f(011) = 3, f(00101) = 5, f(00001) = 1, f(10) = 2, f(000) = 0 and f(000100) = 4.
The substring s_{l}, s_{l+1}, ... , s_{r} is good if r - l + 1 = f(s_l ... s_r).
For example string s = 1011 has 5 good substrings: s_1 ... s_1 = 1, s_3 ... s_3 = 1, s_4 ... s_4 = 1, s_1 ... s_2 = 10 and s_2 ... s_4 = 011.
Your task is to calculate the number of good substrings of string s.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
The only line of each query contains string s (1 ≤ |s| ≤ 2 ⋅ 10^5), consisting of only digits 0 and 1.
It is guaranteed that ∑_{i=1}^{t} |s_i| ≤ 2 ⋅ 10^5.
Output
For each query print one integer — the number of good substrings of string s.
Example
Input
4
0110
0101
00001000
0001000
Output
4
3
4
3
Submitted Solution:
```
if __name__ == '__main__':
t = int(input())
for _ in range(t):
ln = [int(x) for x in input()]
sz, zc, ans = (len(ln), 0, 0)
for i in range(sz):
if ln[i] == 1:
num, j, rl = (0, i, min(i + 20, sz))
while j < rl:
num, j = (num * 2 + ln[j], j + 1)
if j - i + 1 + zc >= num:
ans += 1
zc = 0
else:
zc += 1
print(ans)
``` | instruction | 0 | 93,610 | 0 | 187,220 |
No | output | 1 | 93,610 | 0 | 187,221 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a binary string s (recall that a string is binary if each character is either 0 or 1).
Let f(t) be the decimal representation of integer t written in binary form (possibly with leading zeroes). For example f(011) = 3, f(00101) = 5, f(00001) = 1, f(10) = 2, f(000) = 0 and f(000100) = 4.
The substring s_{l}, s_{l+1}, ... , s_{r} is good if r - l + 1 = f(s_l ... s_r).
For example string s = 1011 has 5 good substrings: s_1 ... s_1 = 1, s_3 ... s_3 = 1, s_4 ... s_4 = 1, s_1 ... s_2 = 10 and s_2 ... s_4 = 011.
Your task is to calculate the number of good substrings of string s.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
The only line of each query contains string s (1 ≤ |s| ≤ 2 ⋅ 10^5), consisting of only digits 0 and 1.
It is guaranteed that ∑_{i=1}^{t} |s_i| ≤ 2 ⋅ 10^5.
Output
For each query print one integer — the number of good substrings of string s.
Example
Input
4
0110
0101
00001000
0001000
Output
4
3
4
3
Submitted Solution:
```
import sys
def input():
return sys.stdin.readline().rstrip()
def slv():
s = list(input()[::-1])
s = list(map(int, s))
ans = 0
n = len(s)
RPOS = [n]*(n)
for i in range(n):
if s[i] == 1:
RPOS[i] = i
for i in range(n - 1, -1, -1):
if i + 1 < n:
RPOS[i] = min(RPOS[i], RPOS[i + 1])
for l in range(n):
left_comp, right_comp = 0, 0
for r in range(l, min(l + 20, n)):
left_comp += pow(2, r - l) * s[r]
right_comp += 1
if left_comp == right_comp:
ans += 1
m = min(l + 20,n) - 1
if right_comp <= left_comp < RPOS[m] - l:
ans += 1
print(ans)
return
def main():
t = int(input())
for i in range(t):
slv()
return
def main():
t = int(input())
for i in range(t):
slv()
return
if __name__ == "__main__":
main()
``` | instruction | 0 | 93,611 | 0 | 187,222 |
No | output | 1 | 93,611 | 0 | 187,223 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's denote the function f(s) that takes a string s consisting of lowercase Latin letters and dots, and returns a string consisting of lowercase Latin letters as follows:
1. let r be an empty string;
2. process the characters of s from left to right. For each character c, do the following: if c is a lowercase Latin letter, append c at the end of the string r; otherwise, delete the last character from r (if r is empty before deleting the last character — the function crashes);
3. return r as the result of the function.
You are given two strings s and t. You have to delete the minimum possible number of characters from s so that f(s) = t (and the function does not crash). Note that you aren't allowed to insert new characters into s or reorder the existing ones.
Input
The input consists of two lines: the first one contains s — a string consisting of lowercase Latin letters and dots, the second one contains t — a string consisting of lowercase Latin letters (1 ≤ |t| ≤ |s| ≤ 10000).
Additional constraint on the input: it is possible to remove some number of characters from s so that f(s) = t.
Output
Print one integer — the minimum possible number of characters you have to delete from s so f(s) does not crash and returns t as the result of the function.
Examples
Input
a.ba.b.
abb
Output
2
Input
.bbac..a.c.cd
bacd
Output
3
Input
c..code..c...o.d.de
code
Output
3
Submitted Solution:
```
s = input()
t = input()
count = 0
def f(s):
r = ""
for i in range(len(s)):
if s[i] != ".":
r+=s[i]
else:
if r!="":
r=r[:-1]
else:
r = r[1:]
globals()['count'] += 1
return r
r = f(s)
if len(r) == len(t):
for i in range(len(r)):
if r[i] != t[i]:
count +=2
else:
count += abs(len(r)-len(t))
print(count)
``` | instruction | 0 | 93,678 | 0 | 187,356 |
No | output | 1 | 93,678 | 0 | 187,357 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's denote the function f(s) that takes a string s consisting of lowercase Latin letters and dots, and returns a string consisting of lowercase Latin letters as follows:
1. let r be an empty string;
2. process the characters of s from left to right. For each character c, do the following: if c is a lowercase Latin letter, append c at the end of the string r; otherwise, delete the last character from r (if r is empty before deleting the last character — the function crashes);
3. return r as the result of the function.
You are given two strings s and t. You have to delete the minimum possible number of characters from s so that f(s) = t (and the function does not crash). Note that you aren't allowed to insert new characters into s or reorder the existing ones.
Input
The input consists of two lines: the first one contains s — a string consisting of lowercase Latin letters and dots, the second one contains t — a string consisting of lowercase Latin letters (1 ≤ |t| ≤ |s| ≤ 10000).
Additional constraint on the input: it is possible to remove some number of characters from s so that f(s) = t.
Output
Print one integer — the minimum possible number of characters you have to delete from s so f(s) does not crash and returns t as the result of the function.
Examples
Input
a.ba.b.
abb
Output
2
Input
.bbac..a.c.cd
bacd
Output
3
Input
c..code..c...o.d.de
code
Output
3
Submitted Solution:
```
s=input()
new_set=set(s)
aplha=len(new_set)
print(aplha-1)
``` | instruction | 0 | 93,679 | 0 | 187,358 |
No | output | 1 | 93,679 | 0 | 187,359 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's denote the function f(s) that takes a string s consisting of lowercase Latin letters and dots, and returns a string consisting of lowercase Latin letters as follows:
1. let r be an empty string;
2. process the characters of s from left to right. For each character c, do the following: if c is a lowercase Latin letter, append c at the end of the string r; otherwise, delete the last character from r (if r is empty before deleting the last character — the function crashes);
3. return r as the result of the function.
You are given two strings s and t. You have to delete the minimum possible number of characters from s so that f(s) = t (and the function does not crash). Note that you aren't allowed to insert new characters into s or reorder the existing ones.
Input
The input consists of two lines: the first one contains s — a string consisting of lowercase Latin letters and dots, the second one contains t — a string consisting of lowercase Latin letters (1 ≤ |t| ≤ |s| ≤ 10000).
Additional constraint on the input: it is possible to remove some number of characters from s so that f(s) = t.
Output
Print one integer — the minimum possible number of characters you have to delete from s so f(s) does not crash and returns t as the result of the function.
Examples
Input
a.ba.b.
abb
Output
2
Input
.bbac..a.c.cd
bacd
Output
3
Input
c..code..c...o.d.de
code
Output
3
Submitted Solution:
```
l=input()
q=input()
k=''
m=l.replace('.','')
for i in m.lower():
if i not in k:
k=k+i
c=''
for i in k:
if i not in q:
c=c+i
count=0
for i in q:
count+=1
print(count-3)
``` | instruction | 0 | 93,680 | 0 | 187,360 |
No | output | 1 | 93,680 | 0 | 187,361 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's denote the function f(s) that takes a string s consisting of lowercase Latin letters and dots, and returns a string consisting of lowercase Latin letters as follows:
1. let r be an empty string;
2. process the characters of s from left to right. For each character c, do the following: if c is a lowercase Latin letter, append c at the end of the string r; otherwise, delete the last character from r (if r is empty before deleting the last character — the function crashes);
3. return r as the result of the function.
You are given two strings s and t. You have to delete the minimum possible number of characters from s so that f(s) = t (and the function does not crash). Note that you aren't allowed to insert new characters into s or reorder the existing ones.
Input
The input consists of two lines: the first one contains s — a string consisting of lowercase Latin letters and dots, the second one contains t — a string consisting of lowercase Latin letters (1 ≤ |t| ≤ |s| ≤ 10000).
Additional constraint on the input: it is possible to remove some number of characters from s so that f(s) = t.
Output
Print one integer — the minimum possible number of characters you have to delete from s so f(s) does not crash and returns t as the result of the function.
Examples
Input
a.ba.b.
abb
Output
2
Input
.bbac..a.c.cd
bacd
Output
3
Input
c..code..c...o.d.de
code
Output
3
Submitted Solution:
```
def string(s):
r=''
for i in s:
if(i in r or i=='.'):
pass
else:
r+=i
return(r)
s=input()
print(string(s))
``` | instruction | 0 | 93,681 | 0 | 187,362 |
No | output | 1 | 93,681 | 0 | 187,363 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A subsequence of length |x| of string s = s1s2... s|s| (where |s| is the length of string s) is a string x = sk1sk2... sk|x| (1 ≤ k1 < k2 < ... < k|x| ≤ |s|).
You've got two strings — s and t. Let's consider all subsequences of string s, coinciding with string t. Is it true that each character of string s occurs in at least one of these subsequences? In other words, is it true that for all i (1 ≤ i ≤ |s|), there is such subsequence x = sk1sk2... sk|x| of string s, that x = t and for some j (1 ≤ j ≤ |x|) kj = i.
Input
The first line contains string s, the second line contains string t. Each line consists only of lowercase English letters. The given strings are non-empty, the length of each string does not exceed 2·105.
Output
Print "Yes" (without the quotes), if each character of the string s occurs in at least one of the described subsequences, or "No" (without the quotes) otherwise.
Examples
Input
abab
ab
Output
Yes
Input
abacaba
aba
Output
No
Input
abc
ba
Output
No
Note
In the first sample string t can occur in the string s as a subsequence in three ways: abab, abab and abab. In these occurrences each character of string s occurs at least once.
In the second sample the 4-th character of the string s doesn't occur in any occurrence of string t.
In the third sample there is no occurrence of string t in string s. | instruction | 0 | 93,795 | 0 | 187,590 |
Tags: data structures, dp, strings
Correct Solution:
```
import bisect
import string
s = input()
t = input()
max_match = [0 for i in range(len(s))]
min_match = [0 for i in range(len(s))]
char_idx = [0 for i in range(30)]
char_occur = [ [] for i in range(30) ]
for (i, ch) in enumerate(t):
idx = ord(ch) - ord('a')
char_occur[idx].append(i)
for ch in string.ascii_lowercase:
idx = ord(ch) - ord('a')
char_occur[idx].append(len(t)+1)
matched = -1
for (i, ch) in enumerate(s):
if matched==len(t)-1:
max_match[i] = matched
else:
if ch == t[matched+1]:
matched += 1
max_match[i] = matched
matched = len(t)
for (i, ch) in enumerate(s[::-1]):
i = len(s) - i - 1
if matched==0:
min_match[i] = matched
else:
if ch == t[matched-1]:
matched -= 1
min_match[i] = matched
for (i, ch) in enumerate(s):
low = min_match[i]
high = max_match[i]
ch = ord(ch) - ord('a')
idx = char_idx[ch]
while idx<len(char_occur[ch]) and char_occur[ch][idx]<low:
idx += 1
char_idx[ch] = idx
if idx == len(char_occur[ch]):
print("No")
exit()
if char_occur[ch][idx] > high:
print("No")
exit()
print("Yes")
``` | output | 1 | 93,795 | 0 | 187,591 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A subsequence of length |x| of string s = s1s2... s|s| (where |s| is the length of string s) is a string x = sk1sk2... sk|x| (1 ≤ k1 < k2 < ... < k|x| ≤ |s|).
You've got two strings — s and t. Let's consider all subsequences of string s, coinciding with string t. Is it true that each character of string s occurs in at least one of these subsequences? In other words, is it true that for all i (1 ≤ i ≤ |s|), there is such subsequence x = sk1sk2... sk|x| of string s, that x = t and for some j (1 ≤ j ≤ |x|) kj = i.
Input
The first line contains string s, the second line contains string t. Each line consists only of lowercase English letters. The given strings are non-empty, the length of each string does not exceed 2·105.
Output
Print "Yes" (without the quotes), if each character of the string s occurs in at least one of the described subsequences, or "No" (without the quotes) otherwise.
Examples
Input
abab
ab
Output
Yes
Input
abacaba
aba
Output
No
Input
abc
ba
Output
No
Note
In the first sample string t can occur in the string s as a subsequence in three ways: abab, abab and abab. In these occurrences each character of string s occurs at least once.
In the second sample the 4-th character of the string s doesn't occur in any occurrence of string t.
In the third sample there is no occurrence of string t in string s.
Submitted Solution:
```
import bisect
import string
s = input()
t = input()
max_match = [0 for i in range(len(s))]
min_match = [0 for i in range(len(s))]
char_idx = [0 for i in range(30)]
char_occur = [ [] for i in range(30) ]
for ch in string.ascii_lowercase:
idx = ord(ch) - ord('a')
char_occur[idx] = [i for (i,_ch) in enumerate(t) if ch==_ch]
char_occur[idx].append(len(t)+1)
matched = -1
for (i, ch) in enumerate(s):
if matched==len(t)-1:
max_match[i] = matched
else:
if ch == t[matched+1]:
matched += 1
max_match[i] = matched
matched = len(t)
for (i, ch) in enumerate(s[::-1]):
i = len(s) - i - 1
if matched==0:
min_match[i] = matched
else:
if ch == t[matched-1]:
matched -= 1
min_match[i] = matched
if len(t) > 100000:
for (i, ch) in enumerate(s):
low = min_match[i]
high = max_match[i]
ch = ord(ch) - ord('a')
idx = char_idx[ch]
while idx<len(char_occur[ch]) and char_occur[ch][idx]<low:
idx += 1
char_idx[ch] = idx
if idx == len(char_occur[ch]):
print("No")
exit()
if char_occur[ch][idx] > high:
print("No")
exit()
print("Yes")
``` | instruction | 0 | 93,796 | 0 | 187,592 |
No | output | 1 | 93,796 | 0 | 187,593 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A subsequence of length |x| of string s = s1s2... s|s| (where |s| is the length of string s) is a string x = sk1sk2... sk|x| (1 ≤ k1 < k2 < ... < k|x| ≤ |s|).
You've got two strings — s and t. Let's consider all subsequences of string s, coinciding with string t. Is it true that each character of string s occurs in at least one of these subsequences? In other words, is it true that for all i (1 ≤ i ≤ |s|), there is such subsequence x = sk1sk2... sk|x| of string s, that x = t and for some j (1 ≤ j ≤ |x|) kj = i.
Input
The first line contains string s, the second line contains string t. Each line consists only of lowercase English letters. The given strings are non-empty, the length of each string does not exceed 2·105.
Output
Print "Yes" (without the quotes), if each character of the string s occurs in at least one of the described subsequences, or "No" (without the quotes) otherwise.
Examples
Input
abab
ab
Output
Yes
Input
abacaba
aba
Output
No
Input
abc
ba
Output
No
Note
In the first sample string t can occur in the string s as a subsequence in three ways: abab, abab and abab. In these occurrences each character of string s occurs at least once.
In the second sample the 4-th character of the string s doesn't occur in any occurrence of string t.
In the third sample there is no occurrence of string t in string s.
Submitted Solution:
```
import bisect
import string
s = input()
t = input()
max_match = [0 for i in range(len(s))]
min_match = [0 for i in range(len(s))]
char_idx = [0 for i in range(30)]
char_occur = [ [] for i in range(30) ]
matched = -1
for (i, ch) in enumerate(s):
if matched==len(t)-1:
max_match[i] = matched
else:
if ch == t[matched+1]:
matched += 1
max_match[i] = matched
idx = ord(ch) - ord('a')
char_occur[idx].append(i)
for ch in string.ascii_lowercase:
idx = ord(ch) - ord('a')
char_occur[idx].append(len(t)+1)
matched = len(t)
for (i, ch) in enumerate(s[::-1]):
i = len(s) - i - 1
if matched==0:
min_match[i] = matched
else:
if ch == t[matched-1]:
matched -= 1
min_match[i] = matched
for (i, ch) in enumerate(s):
low = min_match[i]
high = max_match[i]
ch = ord(ch) - ord('a')
idx = char_idx[ch]
while idx<len(char_occur[ch]) and char_occur[ch][idx]<low:
idx += 1
char_idx[ch] = idx
if idx == len(char_occur[ch]):
print("No")
exit()
if char_occur[ch][idx] > high:
print("No")
exit()
print("Yes")
``` | instruction | 0 | 93,797 | 0 | 187,594 |
No | output | 1 | 93,797 | 0 | 187,595 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A subsequence of length |x| of string s = s1s2... s|s| (where |s| is the length of string s) is a string x = sk1sk2... sk|x| (1 ≤ k1 < k2 < ... < k|x| ≤ |s|).
You've got two strings — s and t. Let's consider all subsequences of string s, coinciding with string t. Is it true that each character of string s occurs in at least one of these subsequences? In other words, is it true that for all i (1 ≤ i ≤ |s|), there is such subsequence x = sk1sk2... sk|x| of string s, that x = t and for some j (1 ≤ j ≤ |x|) kj = i.
Input
The first line contains string s, the second line contains string t. Each line consists only of lowercase English letters. The given strings are non-empty, the length of each string does not exceed 2·105.
Output
Print "Yes" (without the quotes), if each character of the string s occurs in at least one of the described subsequences, or "No" (without the quotes) otherwise.
Examples
Input
abab
ab
Output
Yes
Input
abacaba
aba
Output
No
Input
abc
ba
Output
No
Note
In the first sample string t can occur in the string s as a subsequence in three ways: abab, abab and abab. In these occurrences each character of string s occurs at least once.
In the second sample the 4-th character of the string s doesn't occur in any occurrence of string t.
In the third sample there is no occurrence of string t in string s.
Submitted Solution:
```
def main():
first = str(input())
second = str(input())
first_size = len(first)
second_size = len(second)
pre, last = 0, second_size
is_valid = True
if first_size % second_size == 0:
while first_size >= last:
if first[pre:last] != second:
is_valid = False
break
pre = last
last = last + second_size
if is_valid:
print("Yes")
else:
print("No")
else:
print("No")
if __name__ == "__main__":
main()
``` | instruction | 0 | 93,798 | 0 | 187,596 |
No | output | 1 | 93,798 | 0 | 187,597 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A subsequence of length |x| of string s = s1s2... s|s| (where |s| is the length of string s) is a string x = sk1sk2... sk|x| (1 ≤ k1 < k2 < ... < k|x| ≤ |s|).
You've got two strings — s and t. Let's consider all subsequences of string s, coinciding with string t. Is it true that each character of string s occurs in at least one of these subsequences? In other words, is it true that for all i (1 ≤ i ≤ |s|), there is such subsequence x = sk1sk2... sk|x| of string s, that x = t and for some j (1 ≤ j ≤ |x|) kj = i.
Input
The first line contains string s, the second line contains string t. Each line consists only of lowercase English letters. The given strings are non-empty, the length of each string does not exceed 2·105.
Output
Print "Yes" (without the quotes), if each character of the string s occurs in at least one of the described subsequences, or "No" (without the quotes) otherwise.
Examples
Input
abab
ab
Output
Yes
Input
abacaba
aba
Output
No
Input
abc
ba
Output
No
Note
In the first sample string t can occur in the string s as a subsequence in three ways: abab, abab and abab. In these occurrences each character of string s occurs at least once.
In the second sample the 4-th character of the string s doesn't occur in any occurrence of string t.
In the third sample there is no occurrence of string t in string s.
Submitted Solution:
```
s=input()
t=input()
n=len(s)
m=len(t)
assert m<=n
s=list(s)
t=list(t)
j=0
bool=True
for c in t:
if c not in s[j:]:
bool=False
break
j+=1
if bool==False:
print('No')
if bool==True:
for c in s:
if c not in t:
bool=False
break
if bool==False:
print('No')
else:
print('Yes')
``` | instruction | 0 | 93,799 | 0 | 187,598 |
No | output | 1 | 93,799 | 0 | 187,599 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mahmoud wrote a message s of length n. He wants to send it as a birthday present to his friend Moaz who likes strings. He wrote it on a magical paper but he was surprised because some characters disappeared while writing the string. That's because this magical paper doesn't allow character number i in the English alphabet to be written on it in a string of length more than ai. For example, if a1 = 2 he can't write character 'a' on this paper in a string of length 3 or more. String "aa" is allowed while string "aaa" is not.
Mahmoud decided to split the message into some non-empty substrings so that he can write every substring on an independent magical paper and fulfill the condition. The sum of their lengths should be n and they shouldn't overlap. For example, if a1 = 2 and he wants to send string "aaa", he can split it into "a" and "aa" and use 2 magical papers, or into "a", "a" and "a" and use 3 magical papers. He can't split it into "aa" and "aa" because the sum of their lengths is greater than n. He can split the message into single string if it fulfills the conditions.
A substring of string s is a string that consists of some consecutive characters from string s, strings "ab", "abc" and "b" are substrings of string "abc", while strings "acb" and "ac" are not. Any string is a substring of itself.
While Mahmoud was thinking of how to split the message, Ehab told him that there are many ways to split it. After that Mahmoud asked you three questions:
* How many ways are there to split the string into substrings such that every substring fulfills the condition of the magical paper, the sum of their lengths is n and they don't overlap? Compute the answer modulo 109 + 7.
* What is the maximum length of a substring that can appear in some valid splitting?
* What is the minimum number of substrings the message can be spit in?
Two ways are considered different, if the sets of split positions differ. For example, splitting "aa|a" and "a|aa" are considered different splittings of message "aaa".
Input
The first line contains an integer n (1 ≤ n ≤ 103) denoting the length of the message.
The second line contains the message s of length n that consists of lowercase English letters.
The third line contains 26 integers a1, a2, ..., a26 (1 ≤ ax ≤ 103) — the maximum lengths of substring each letter can appear in.
Output
Print three lines.
In the first line print the number of ways to split the message into substrings and fulfill the conditions mentioned in the problem modulo 109 + 7.
In the second line print the length of the longest substring over all the ways.
In the third line print the minimum number of substrings over all the ways.
Examples
Input
3
aab
2 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
3
2
2
Input
10
abcdeabcde
5 5 5 5 4 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
401
4
3
Note
In the first example the three ways to split the message are:
* a|a|b
* aa|b
* a|ab
The longest substrings are "aa" and "ab" of length 2.
The minimum number of substrings is 2 in "a|ab" or "aa|b".
Notice that "aab" is not a possible splitting because the letter 'a' appears in a substring of length 3, while a1 = 2. | instruction | 0 | 94,042 | 0 | 188,084 |
Tags: brute force, dp, greedy, strings
Correct Solution:
```
n = int(input())
s = input()
S = [ord(znak) - 97 for znak in s]
a = list(map(int, input().strip().split(' ')))
#print(n, S, a)
MOD = 10**9 + 7
st = [0]*(n+1)
st[0] = 1
maks = [0]*(n+1)
minway = [10**4]*(n+1)
minway[0] = 0
for i in range(1, n + 1):
cnt = 0
maks_dolzina = n
for j in range(i, 0, -1):
maks_dolzina = min(maks_dolzina, a[S[j - 1]])
if i - j + 1 > maks_dolzina:
break
cnt += st[j-1]
maks[i] = max(i-j+1, maks[j-1], maks[i])
minway[i] = min(minway[i], 1 + minway[j-1])
st[i] = cnt
print(st[-1] % MOD)
print(maks[-1])
print(minway[-1])
``` | output | 1 | 94,042 | 0 | 188,085 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mahmoud wrote a message s of length n. He wants to send it as a birthday present to his friend Moaz who likes strings. He wrote it on a magical paper but he was surprised because some characters disappeared while writing the string. That's because this magical paper doesn't allow character number i in the English alphabet to be written on it in a string of length more than ai. For example, if a1 = 2 he can't write character 'a' on this paper in a string of length 3 or more. String "aa" is allowed while string "aaa" is not.
Mahmoud decided to split the message into some non-empty substrings so that he can write every substring on an independent magical paper and fulfill the condition. The sum of their lengths should be n and they shouldn't overlap. For example, if a1 = 2 and he wants to send string "aaa", he can split it into "a" and "aa" and use 2 magical papers, or into "a", "a" and "a" and use 3 magical papers. He can't split it into "aa" and "aa" because the sum of their lengths is greater than n. He can split the message into single string if it fulfills the conditions.
A substring of string s is a string that consists of some consecutive characters from string s, strings "ab", "abc" and "b" are substrings of string "abc", while strings "acb" and "ac" are not. Any string is a substring of itself.
While Mahmoud was thinking of how to split the message, Ehab told him that there are many ways to split it. After that Mahmoud asked you three questions:
* How many ways are there to split the string into substrings such that every substring fulfills the condition of the magical paper, the sum of their lengths is n and they don't overlap? Compute the answer modulo 109 + 7.
* What is the maximum length of a substring that can appear in some valid splitting?
* What is the minimum number of substrings the message can be spit in?
Two ways are considered different, if the sets of split positions differ. For example, splitting "aa|a" and "a|aa" are considered different splittings of message "aaa".
Input
The first line contains an integer n (1 ≤ n ≤ 103) denoting the length of the message.
The second line contains the message s of length n that consists of lowercase English letters.
The third line contains 26 integers a1, a2, ..., a26 (1 ≤ ax ≤ 103) — the maximum lengths of substring each letter can appear in.
Output
Print three lines.
In the first line print the number of ways to split the message into substrings and fulfill the conditions mentioned in the problem modulo 109 + 7.
In the second line print the length of the longest substring over all the ways.
In the third line print the minimum number of substrings over all the ways.
Examples
Input
3
aab
2 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
3
2
2
Input
10
abcdeabcde
5 5 5 5 4 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
401
4
3
Note
In the first example the three ways to split the message are:
* a|a|b
* aa|b
* a|ab
The longest substrings are "aa" and "ab" of length 2.
The minimum number of substrings is 2 in "a|ab" or "aa|b".
Notice that "aab" is not a possible splitting because the letter 'a' appears in a substring of length 3, while a1 = 2. | instruction | 0 | 94,043 | 0 | 188,086 |
Tags: brute force, dp, greedy, strings
Correct Solution:
```
N, s, l = int(input()), [ord(x) - ord('a') for x in input()], [int(x) for x in input().split()]
arr = [[1, l[s[0]]]]
total = 1
ma = 1
t = 1
mi = 1
for c in s[1:]:
tmp = 0
for i in range(len(arr)):
arr[i][1] = min(arr[i][1],l[c])
if i + 1 >= arr[i][1]:
arr = arr[:i]
if(t > i):
t = 0
mi += 1
break
else:
tmp += arr[i][0]
t += 1
arr.insert(0, [total, l[c]])
ma = max(ma, len(arr))
total += tmp
total %= 10 ** 9 + 7;
print(total)
print(ma)
print(mi)
# Made By Mostafa_Khaled
``` | output | 1 | 94,043 | 0 | 188,087 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mahmoud wrote a message s of length n. He wants to send it as a birthday present to his friend Moaz who likes strings. He wrote it on a magical paper but he was surprised because some characters disappeared while writing the string. That's because this magical paper doesn't allow character number i in the English alphabet to be written on it in a string of length more than ai. For example, if a1 = 2 he can't write character 'a' on this paper in a string of length 3 or more. String "aa" is allowed while string "aaa" is not.
Mahmoud decided to split the message into some non-empty substrings so that he can write every substring on an independent magical paper and fulfill the condition. The sum of their lengths should be n and they shouldn't overlap. For example, if a1 = 2 and he wants to send string "aaa", he can split it into "a" and "aa" and use 2 magical papers, or into "a", "a" and "a" and use 3 magical papers. He can't split it into "aa" and "aa" because the sum of their lengths is greater than n. He can split the message into single string if it fulfills the conditions.
A substring of string s is a string that consists of some consecutive characters from string s, strings "ab", "abc" and "b" are substrings of string "abc", while strings "acb" and "ac" are not. Any string is a substring of itself.
While Mahmoud was thinking of how to split the message, Ehab told him that there are many ways to split it. After that Mahmoud asked you three questions:
* How many ways are there to split the string into substrings such that every substring fulfills the condition of the magical paper, the sum of their lengths is n and they don't overlap? Compute the answer modulo 109 + 7.
* What is the maximum length of a substring that can appear in some valid splitting?
* What is the minimum number of substrings the message can be spit in?
Two ways are considered different, if the sets of split positions differ. For example, splitting "aa|a" and "a|aa" are considered different splittings of message "aaa".
Input
The first line contains an integer n (1 ≤ n ≤ 103) denoting the length of the message.
The second line contains the message s of length n that consists of lowercase English letters.
The third line contains 26 integers a1, a2, ..., a26 (1 ≤ ax ≤ 103) — the maximum lengths of substring each letter can appear in.
Output
Print three lines.
In the first line print the number of ways to split the message into substrings and fulfill the conditions mentioned in the problem modulo 109 + 7.
In the second line print the length of the longest substring over all the ways.
In the third line print the minimum number of substrings over all the ways.
Examples
Input
3
aab
2 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
3
2
2
Input
10
abcdeabcde
5 5 5 5 4 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
401
4
3
Note
In the first example the three ways to split the message are:
* a|a|b
* aa|b
* a|ab
The longest substrings are "aa" and "ab" of length 2.
The minimum number of substrings is 2 in "a|ab" or "aa|b".
Notice that "aab" is not a possible splitting because the letter 'a' appears in a substring of length 3, while a1 = 2. | instruction | 0 | 94,044 | 0 | 188,088 |
Tags: brute force, dp, greedy, strings
Correct Solution:
```
from sys import stdin, stdout
n = int(stdin.readline())
s = stdin.readline().strip()
length = list(map(int, stdin.readline().strip().split()))
bn = [2 ** i for i in range(10 ** 3 + 2)]
dp = [0 for i in range(n + 10)]
dp[0] = 1
dp[-1] = 1
ans = [0, 1, 0]
dp1 = [0 for i in range(n + 5)]
dp1[0] = 1
for i in range(1, n):
label = 1
cnt = min(i + 1, length[ord(s[i]) - ord('a')])
while label:
label = 0
for ind in range(i - cnt + 1, i + 1):
if length[ord(s[ind]) - ord('a')] < cnt:
cnt -= 1
label = 1
break
dp1[i] = dp1[i - cnt] + 1
ans[1] = max(ans[1], cnt)
if cnt == i + 1:
dp[i] = bn[cnt - 1]
else:
for j in range(1, cnt + 1):
dp[i] += dp[i - j]
ans[0] = (dp[n - 1] % (10 ** 9 + 7))
ans[2] = dp1[n - 1]
stdout.write('\n'.join(list(map(str, ans))))
``` | output | 1 | 94,044 | 0 | 188,089 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mahmoud wrote a message s of length n. He wants to send it as a birthday present to his friend Moaz who likes strings. He wrote it on a magical paper but he was surprised because some characters disappeared while writing the string. That's because this magical paper doesn't allow character number i in the English alphabet to be written on it in a string of length more than ai. For example, if a1 = 2 he can't write character 'a' on this paper in a string of length 3 or more. String "aa" is allowed while string "aaa" is not.
Mahmoud decided to split the message into some non-empty substrings so that he can write every substring on an independent magical paper and fulfill the condition. The sum of their lengths should be n and they shouldn't overlap. For example, if a1 = 2 and he wants to send string "aaa", he can split it into "a" and "aa" and use 2 magical papers, or into "a", "a" and "a" and use 3 magical papers. He can't split it into "aa" and "aa" because the sum of their lengths is greater than n. He can split the message into single string if it fulfills the conditions.
A substring of string s is a string that consists of some consecutive characters from string s, strings "ab", "abc" and "b" are substrings of string "abc", while strings "acb" and "ac" are not. Any string is a substring of itself.
While Mahmoud was thinking of how to split the message, Ehab told him that there are many ways to split it. After that Mahmoud asked you three questions:
* How many ways are there to split the string into substrings such that every substring fulfills the condition of the magical paper, the sum of their lengths is n and they don't overlap? Compute the answer modulo 109 + 7.
* What is the maximum length of a substring that can appear in some valid splitting?
* What is the minimum number of substrings the message can be spit in?
Two ways are considered different, if the sets of split positions differ. For example, splitting "aa|a" and "a|aa" are considered different splittings of message "aaa".
Input
The first line contains an integer n (1 ≤ n ≤ 103) denoting the length of the message.
The second line contains the message s of length n that consists of lowercase English letters.
The third line contains 26 integers a1, a2, ..., a26 (1 ≤ ax ≤ 103) — the maximum lengths of substring each letter can appear in.
Output
Print three lines.
In the first line print the number of ways to split the message into substrings and fulfill the conditions mentioned in the problem modulo 109 + 7.
In the second line print the length of the longest substring over all the ways.
In the third line print the minimum number of substrings over all the ways.
Examples
Input
3
aab
2 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
3
2
2
Input
10
abcdeabcde
5 5 5 5 4 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
401
4
3
Note
In the first example the three ways to split the message are:
* a|a|b
* aa|b
* a|ab
The longest substrings are "aa" and "ab" of length 2.
The minimum number of substrings is 2 in "a|ab" or "aa|b".
Notice that "aab" is not a possible splitting because the letter 'a' appears in a substring of length 3, while a1 = 2. | instruction | 0 | 94,045 | 0 | 188,090 |
Tags: brute force, dp, greedy, strings
Correct Solution:
```
import math
import sys
from bisect import bisect_right, bisect_left, insort_right
from collections import Counter, defaultdict
from heapq import heappop, heappush
from itertools import accumulate, permutations, combinations
from sys import stdout
R = lambda: map(int, input().split())
n = int(input())
arr = list(map(lambda x: ord(x) - ord('a'), input()))
dis = list(R())
comb = [0] * (1 + n)
cnt = [math.inf] * n
mlen = 0
for i in range(n):
lm = dis[arr[i]]
j = i
while j >= 0 and i - j + 1 <= min(lm, dis[arr[j]]):
lm = min(lm, dis[arr[j]])
comb[i] = (comb[i] + max(1, comb[j - 1])) % (10**9 + 7)
cnt[i] = min(cnt[i], (cnt[j - 1] if j >= 1 else 0) + 1)
j -= 1
mlen = max(mlen, i - j)
print(comb[n - 1])
print(mlen)
print(max(cnt))
``` | output | 1 | 94,045 | 0 | 188,091 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mahmoud wrote a message s of length n. He wants to send it as a birthday present to his friend Moaz who likes strings. He wrote it on a magical paper but he was surprised because some characters disappeared while writing the string. That's because this magical paper doesn't allow character number i in the English alphabet to be written on it in a string of length more than ai. For example, if a1 = 2 he can't write character 'a' on this paper in a string of length 3 or more. String "aa" is allowed while string "aaa" is not.
Mahmoud decided to split the message into some non-empty substrings so that he can write every substring on an independent magical paper and fulfill the condition. The sum of their lengths should be n and they shouldn't overlap. For example, if a1 = 2 and he wants to send string "aaa", he can split it into "a" and "aa" and use 2 magical papers, or into "a", "a" and "a" and use 3 magical papers. He can't split it into "aa" and "aa" because the sum of their lengths is greater than n. He can split the message into single string if it fulfills the conditions.
A substring of string s is a string that consists of some consecutive characters from string s, strings "ab", "abc" and "b" are substrings of string "abc", while strings "acb" and "ac" are not. Any string is a substring of itself.
While Mahmoud was thinking of how to split the message, Ehab told him that there are many ways to split it. After that Mahmoud asked you three questions:
* How many ways are there to split the string into substrings such that every substring fulfills the condition of the magical paper, the sum of their lengths is n and they don't overlap? Compute the answer modulo 109 + 7.
* What is the maximum length of a substring that can appear in some valid splitting?
* What is the minimum number of substrings the message can be spit in?
Two ways are considered different, if the sets of split positions differ. For example, splitting "aa|a" and "a|aa" are considered different splittings of message "aaa".
Input
The first line contains an integer n (1 ≤ n ≤ 103) denoting the length of the message.
The second line contains the message s of length n that consists of lowercase English letters.
The third line contains 26 integers a1, a2, ..., a26 (1 ≤ ax ≤ 103) — the maximum lengths of substring each letter can appear in.
Output
Print three lines.
In the first line print the number of ways to split the message into substrings and fulfill the conditions mentioned in the problem modulo 109 + 7.
In the second line print the length of the longest substring over all the ways.
In the third line print the minimum number of substrings over all the ways.
Examples
Input
3
aab
2 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
3
2
2
Input
10
abcdeabcde
5 5 5 5 4 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
401
4
3
Note
In the first example the three ways to split the message are:
* a|a|b
* aa|b
* a|ab
The longest substrings are "aa" and "ab" of length 2.
The minimum number of substrings is 2 in "a|ab" or "aa|b".
Notice that "aab" is not a possible splitting because the letter 'a' appears in a substring of length 3, while a1 = 2. | instruction | 0 | 94,046 | 0 | 188,092 |
Tags: brute force, dp, greedy, strings
Correct Solution:
```
import sys
from collections import deque
def debug(x, table):
for name, val in table.items():
if x is val:
print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
return None
def get_minsp(message, As):
min_sp = 1
cur_len = 0
capa = 0
for ch in message:
index = ord(ch) - ord('a')
if cur_len == 0:
cur_len += 1
capa = As[index]
else:
capa = min(capa, As[index])
if cur_len + 1 <= capa:
cur_len += 1
else:
min_sp += 1
cur_len = 1
capa = As[index]
return min_sp
def solve():
MOD = 10**9 + 7
n = int(input())
msg = input()
As = [int(i) for i in input().split()]
caps = []
for ch in msg:
idx = ord(ch) - ord('a')
caps.append(As[idx])
dp = [0] * (n + 1)
dp[0] = 1
max_len = 0
lim = 0
for i in range(1, n + 1):
lim = caps[i - 1]
cur_len = 1
for j in range(i - 1, -1, -1):
if cur_len > lim:
break
max_len = max(max_len, cur_len)
dp[i] += dp[j]
dp[i] %= MOD
lim = min(lim, caps[j - 1])
cur_len += 1
min_sp = get_minsp(msg, As)
# debug(dp, locals())
print(dp[n])
print(max_len)
print(min_sp)
if __name__ == '__main__':
solve()
``` | output | 1 | 94,046 | 0 | 188,093 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mahmoud wrote a message s of length n. He wants to send it as a birthday present to his friend Moaz who likes strings. He wrote it on a magical paper but he was surprised because some characters disappeared while writing the string. That's because this magical paper doesn't allow character number i in the English alphabet to be written on it in a string of length more than ai. For example, if a1 = 2 he can't write character 'a' on this paper in a string of length 3 or more. String "aa" is allowed while string "aaa" is not.
Mahmoud decided to split the message into some non-empty substrings so that he can write every substring on an independent magical paper and fulfill the condition. The sum of their lengths should be n and they shouldn't overlap. For example, if a1 = 2 and he wants to send string "aaa", he can split it into "a" and "aa" and use 2 magical papers, or into "a", "a" and "a" and use 3 magical papers. He can't split it into "aa" and "aa" because the sum of their lengths is greater than n. He can split the message into single string if it fulfills the conditions.
A substring of string s is a string that consists of some consecutive characters from string s, strings "ab", "abc" and "b" are substrings of string "abc", while strings "acb" and "ac" are not. Any string is a substring of itself.
While Mahmoud was thinking of how to split the message, Ehab told him that there are many ways to split it. After that Mahmoud asked you three questions:
* How many ways are there to split the string into substrings such that every substring fulfills the condition of the magical paper, the sum of their lengths is n and they don't overlap? Compute the answer modulo 109 + 7.
* What is the maximum length of a substring that can appear in some valid splitting?
* What is the minimum number of substrings the message can be spit in?
Two ways are considered different, if the sets of split positions differ. For example, splitting "aa|a" and "a|aa" are considered different splittings of message "aaa".
Input
The first line contains an integer n (1 ≤ n ≤ 103) denoting the length of the message.
The second line contains the message s of length n that consists of lowercase English letters.
The third line contains 26 integers a1, a2, ..., a26 (1 ≤ ax ≤ 103) — the maximum lengths of substring each letter can appear in.
Output
Print three lines.
In the first line print the number of ways to split the message into substrings and fulfill the conditions mentioned in the problem modulo 109 + 7.
In the second line print the length of the longest substring over all the ways.
In the third line print the minimum number of substrings over all the ways.
Examples
Input
3
aab
2 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
3
2
2
Input
10
abcdeabcde
5 5 5 5 4 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
401
4
3
Note
In the first example the three ways to split the message are:
* a|a|b
* aa|b
* a|ab
The longest substrings are "aa" and "ab" of length 2.
The minimum number of substrings is 2 in "a|ab" or "aa|b".
Notice that "aab" is not a possible splitting because the letter 'a' appears in a substring of length 3, while a1 = 2. | instruction | 0 | 94,047 | 0 | 188,094 |
Tags: brute force, dp, greedy, strings
Correct Solution:
```
import sys
mod = pow(10, 9) + 7
n = int(sys.stdin.readline())
s = sys.stdin.readline()[:-1]
a = [int(x) for x in sys.stdin.readline().split()]
dp = [0 for _ in range(n+1)]
dp[0] = 1
def ci(c):
return ord(c)-ord('a')
l = 0
for i in range(1, n+1):
# f: represents the farther
# we can get from x (going from
# right to left) without breaking
# the splitting rules
f = 0
for x in range(i-1, -1, -1):
f = max(f, i-a[ci(s[x])])
if f > x:
# we broke the rule
continue
dp[i] = (dp[i]+dp[x]) % mod
l = max(l, i-x)
print(dp[n])
print(l)
res = 1
m = 9999
j = 0
for i in range(n):
m = min([a[ci(s[x])] for x in range(j, i+1)])
if m < i-j+1:
res += 1
j = i
print(res)
``` | output | 1 | 94,047 | 0 | 188,095 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mahmoud wrote a message s of length n. He wants to send it as a birthday present to his friend Moaz who likes strings. He wrote it on a magical paper but he was surprised because some characters disappeared while writing the string. That's because this magical paper doesn't allow character number i in the English alphabet to be written on it in a string of length more than ai. For example, if a1 = 2 he can't write character 'a' on this paper in a string of length 3 or more. String "aa" is allowed while string "aaa" is not.
Mahmoud decided to split the message into some non-empty substrings so that he can write every substring on an independent magical paper and fulfill the condition. The sum of their lengths should be n and they shouldn't overlap. For example, if a1 = 2 and he wants to send string "aaa", he can split it into "a" and "aa" and use 2 magical papers, or into "a", "a" and "a" and use 3 magical papers. He can't split it into "aa" and "aa" because the sum of their lengths is greater than n. He can split the message into single string if it fulfills the conditions.
A substring of string s is a string that consists of some consecutive characters from string s, strings "ab", "abc" and "b" are substrings of string "abc", while strings "acb" and "ac" are not. Any string is a substring of itself.
While Mahmoud was thinking of how to split the message, Ehab told him that there are many ways to split it. After that Mahmoud asked you three questions:
* How many ways are there to split the string into substrings such that every substring fulfills the condition of the magical paper, the sum of their lengths is n and they don't overlap? Compute the answer modulo 109 + 7.
* What is the maximum length of a substring that can appear in some valid splitting?
* What is the minimum number of substrings the message can be spit in?
Two ways are considered different, if the sets of split positions differ. For example, splitting "aa|a" and "a|aa" are considered different splittings of message "aaa".
Input
The first line contains an integer n (1 ≤ n ≤ 103) denoting the length of the message.
The second line contains the message s of length n that consists of lowercase English letters.
The third line contains 26 integers a1, a2, ..., a26 (1 ≤ ax ≤ 103) — the maximum lengths of substring each letter can appear in.
Output
Print three lines.
In the first line print the number of ways to split the message into substrings and fulfill the conditions mentioned in the problem modulo 109 + 7.
In the second line print the length of the longest substring over all the ways.
In the third line print the minimum number of substrings over all the ways.
Examples
Input
3
aab
2 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
3
2
2
Input
10
abcdeabcde
5 5 5 5 4 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
401
4
3
Note
In the first example the three ways to split the message are:
* a|a|b
* aa|b
* a|ab
The longest substrings are "aa" and "ab" of length 2.
The minimum number of substrings is 2 in "a|ab" or "aa|b".
Notice that "aab" is not a possible splitting because the letter 'a' appears in a substring of length 3, while a1 = 2. | instruction | 0 | 94,048 | 0 | 188,096 |
Tags: brute force, dp, greedy, strings
Correct Solution:
```
#!/bin/python3
import sys
mod = 10 **9 + 7
n = int(input())
s = input()
cnt = list(map(int, input().split()))
dp = [0]
for i in range(0,n):
dp.append(0)
dp[0] = 1
ans2 = 1
for i in range(1,n + 1):
o = i -1
ml = cnt[ord(s[o]) - ord('a')]
l = 1
while ml >= l and o >= 0:
dp[i] += dp[o]
dp[i] = dp[i] % mod
if l > ans2:
ans2 = l
l += 1
o -= 1
ml = min(ml, cnt[ord(s[o]) - ord('a')])
ans1 = dp[n] % mod
ans3 = 0
ml = n
l = 0
for i in range(n):
ml = min(ml,cnt[ord(s[i]) - ord('a')])
l+=1
if l > ml:
ans3+=1
l = 1
ml = cnt[ord(s[i]) - ord('a')]
ans3 += 1
print(ans1)
print(ans2)
print(ans3)
``` | output | 1 | 94,048 | 0 | 188,097 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mahmoud wrote a message s of length n. He wants to send it as a birthday present to his friend Moaz who likes strings. He wrote it on a magical paper but he was surprised because some characters disappeared while writing the string. That's because this magical paper doesn't allow character number i in the English alphabet to be written on it in a string of length more than ai. For example, if a1 = 2 he can't write character 'a' on this paper in a string of length 3 or more. String "aa" is allowed while string "aaa" is not.
Mahmoud decided to split the message into some non-empty substrings so that he can write every substring on an independent magical paper and fulfill the condition. The sum of their lengths should be n and they shouldn't overlap. For example, if a1 = 2 and he wants to send string "aaa", he can split it into "a" and "aa" and use 2 magical papers, or into "a", "a" and "a" and use 3 magical papers. He can't split it into "aa" and "aa" because the sum of their lengths is greater than n. He can split the message into single string if it fulfills the conditions.
A substring of string s is a string that consists of some consecutive characters from string s, strings "ab", "abc" and "b" are substrings of string "abc", while strings "acb" and "ac" are not. Any string is a substring of itself.
While Mahmoud was thinking of how to split the message, Ehab told him that there are many ways to split it. After that Mahmoud asked you three questions:
* How many ways are there to split the string into substrings such that every substring fulfills the condition of the magical paper, the sum of their lengths is n and they don't overlap? Compute the answer modulo 109 + 7.
* What is the maximum length of a substring that can appear in some valid splitting?
* What is the minimum number of substrings the message can be spit in?
Two ways are considered different, if the sets of split positions differ. For example, splitting "aa|a" and "a|aa" are considered different splittings of message "aaa".
Input
The first line contains an integer n (1 ≤ n ≤ 103) denoting the length of the message.
The second line contains the message s of length n that consists of lowercase English letters.
The third line contains 26 integers a1, a2, ..., a26 (1 ≤ ax ≤ 103) — the maximum lengths of substring each letter can appear in.
Output
Print three lines.
In the first line print the number of ways to split the message into substrings and fulfill the conditions mentioned in the problem modulo 109 + 7.
In the second line print the length of the longest substring over all the ways.
In the third line print the minimum number of substrings over all the ways.
Examples
Input
3
aab
2 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
3
2
2
Input
10
abcdeabcde
5 5 5 5 4 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
401
4
3
Note
In the first example the three ways to split the message are:
* a|a|b
* aa|b
* a|ab
The longest substrings are "aa" and "ab" of length 2.
The minimum number of substrings is 2 in "a|ab" or "aa|b".
Notice that "aab" is not a possible splitting because the letter 'a' appears in a substring of length 3, while a1 = 2. | instruction | 0 | 94,049 | 0 | 188,098 |
Tags: brute force, dp, greedy, strings
Correct Solution:
```
N, s, l = int(input()), [ord(x) - ord('a') for x in input()], [int(x) for x in input().split()]
arr = [[1, l[s[0]]]]
total = 1
ma = 1
t = 1
mi = 1
for c in s[1:]:
tmp = 0
for i in range(len(arr)):
arr[i][1] = min(arr[i][1],l[c])
if i + 1 >= arr[i][1]:
arr = arr[:i]
if(t > i):
t = 0
mi += 1
break
else:
tmp += arr[i][0]
t += 1
arr.insert(0, [total, l[c]])
ma = max(ma, len(arr))
total += tmp
total %= 10 ** 9 + 7;
print(total)
print(ma)
print(mi)
``` | output | 1 | 94,049 | 0 | 188,099 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mahmoud wrote a message s of length n. He wants to send it as a birthday present to his friend Moaz who likes strings. He wrote it on a magical paper but he was surprised because some characters disappeared while writing the string. That's because this magical paper doesn't allow character number i in the English alphabet to be written on it in a string of length more than ai. For example, if a1 = 2 he can't write character 'a' on this paper in a string of length 3 or more. String "aa" is allowed while string "aaa" is not.
Mahmoud decided to split the message into some non-empty substrings so that he can write every substring on an independent magical paper and fulfill the condition. The sum of their lengths should be n and they shouldn't overlap. For example, if a1 = 2 and he wants to send string "aaa", he can split it into "a" and "aa" and use 2 magical papers, or into "a", "a" and "a" and use 3 magical papers. He can't split it into "aa" and "aa" because the sum of their lengths is greater than n. He can split the message into single string if it fulfills the conditions.
A substring of string s is a string that consists of some consecutive characters from string s, strings "ab", "abc" and "b" are substrings of string "abc", while strings "acb" and "ac" are not. Any string is a substring of itself.
While Mahmoud was thinking of how to split the message, Ehab told him that there are many ways to split it. After that Mahmoud asked you three questions:
* How many ways are there to split the string into substrings such that every substring fulfills the condition of the magical paper, the sum of their lengths is n and they don't overlap? Compute the answer modulo 109 + 7.
* What is the maximum length of a substring that can appear in some valid splitting?
* What is the minimum number of substrings the message can be spit in?
Two ways are considered different, if the sets of split positions differ. For example, splitting "aa|a" and "a|aa" are considered different splittings of message "aaa".
Input
The first line contains an integer n (1 ≤ n ≤ 103) denoting the length of the message.
The second line contains the message s of length n that consists of lowercase English letters.
The third line contains 26 integers a1, a2, ..., a26 (1 ≤ ax ≤ 103) — the maximum lengths of substring each letter can appear in.
Output
Print three lines.
In the first line print the number of ways to split the message into substrings and fulfill the conditions mentioned in the problem modulo 109 + 7.
In the second line print the length of the longest substring over all the ways.
In the third line print the minimum number of substrings over all the ways.
Examples
Input
3
aab
2 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
3
2
2
Input
10
abcdeabcde
5 5 5 5 4 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
401
4
3
Note
In the first example the three ways to split the message are:
* a|a|b
* aa|b
* a|ab
The longest substrings are "aa" and "ab" of length 2.
The minimum number of substrings is 2 in "a|ab" or "aa|b".
Notice that "aab" is not a possible splitting because the letter 'a' appears in a substring of length 3, while a1 = 2.
Submitted Solution:
```
from math import inf
n=int(input())
s=input().strip()
a=[int(X) for X in input().split()]
dp=[0]*(n+1)
dp[1]=1
dp[0]=1
dp12=[inf]*(n+1)
dp12[1]=1
dp12[0]=0
c=1
mod=10**9 + 7
for i in range(2,n+1):
m=10000
for j in range(i,0,-1):
m=min(a[ord(s[j-1])-97],m)
if (i-j+1>m):
break
#print(m,i)
dp[i]=(dp[i]+dp[j-1])%mod
dp12[i]=min(dp12[i],dp12[j-1]+1)
c=max(c,i-j+1)
print(dp[n])
print(c)
print(dp12[n])
``` | instruction | 0 | 94,050 | 0 | 188,100 |
Yes | output | 1 | 94,050 | 0 | 188,101 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mahmoud wrote a message s of length n. He wants to send it as a birthday present to his friend Moaz who likes strings. He wrote it on a magical paper but he was surprised because some characters disappeared while writing the string. That's because this magical paper doesn't allow character number i in the English alphabet to be written on it in a string of length more than ai. For example, if a1 = 2 he can't write character 'a' on this paper in a string of length 3 or more. String "aa" is allowed while string "aaa" is not.
Mahmoud decided to split the message into some non-empty substrings so that he can write every substring on an independent magical paper and fulfill the condition. The sum of their lengths should be n and they shouldn't overlap. For example, if a1 = 2 and he wants to send string "aaa", he can split it into "a" and "aa" and use 2 magical papers, or into "a", "a" and "a" and use 3 magical papers. He can't split it into "aa" and "aa" because the sum of their lengths is greater than n. He can split the message into single string if it fulfills the conditions.
A substring of string s is a string that consists of some consecutive characters from string s, strings "ab", "abc" and "b" are substrings of string "abc", while strings "acb" and "ac" are not. Any string is a substring of itself.
While Mahmoud was thinking of how to split the message, Ehab told him that there are many ways to split it. After that Mahmoud asked you three questions:
* How many ways are there to split the string into substrings such that every substring fulfills the condition of the magical paper, the sum of their lengths is n and they don't overlap? Compute the answer modulo 109 + 7.
* What is the maximum length of a substring that can appear in some valid splitting?
* What is the minimum number of substrings the message can be spit in?
Two ways are considered different, if the sets of split positions differ. For example, splitting "aa|a" and "a|aa" are considered different splittings of message "aaa".
Input
The first line contains an integer n (1 ≤ n ≤ 103) denoting the length of the message.
The second line contains the message s of length n that consists of lowercase English letters.
The third line contains 26 integers a1, a2, ..., a26 (1 ≤ ax ≤ 103) — the maximum lengths of substring each letter can appear in.
Output
Print three lines.
In the first line print the number of ways to split the message into substrings and fulfill the conditions mentioned in the problem modulo 109 + 7.
In the second line print the length of the longest substring over all the ways.
In the third line print the minimum number of substrings over all the ways.
Examples
Input
3
aab
2 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
3
2
2
Input
10
abcdeabcde
5 5 5 5 4 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
401
4
3
Note
In the first example the three ways to split the message are:
* a|a|b
* aa|b
* a|ab
The longest substrings are "aa" and "ab" of length 2.
The minimum number of substrings is 2 in "a|ab" or "aa|b".
Notice that "aab" is not a possible splitting because the letter 'a' appears in a substring of length 3, while a1 = 2.
Submitted Solution:
```
import sys
import copy
import os
# sys.stdin = open(os.path.join(os.path.dirname(__file__), '2.in'))
def solve():
MOD = int(1e9+7)
f = 0
n = int(input())
s = input()
alphabet ={ chr(ord('a')+i):num for i,num in enumerate( map(lambda x :int(x),input().split()) ) }
dp =[0 for _ in range(n)]; minlen = 2<<20; maxlen=0
minsplitnum =[2<<20 for _ in range(n)]
def check(newstr,start,end):
nl = end-start
while start < end:
if alphabet[newstr[start]] < nl:
return False
start+=1
# print(newstr)
return True
i = 0
while i < n:
# for i in range(n):
if i == 0:
dp[i] = 1
maxlen = 1
minsplitnum[i] = 1
else:
f = 0
# divide the element to one
dp[i] = (dp[i-1] + dp[i])%MOD
minsplitnum[i] = minsplitnum[i-1]+1 if minsplitnum[i] > minsplitnum[i-1]+1 else minsplitnum[i]
# divide the element to before
j = i-1
f = i + 1 - alphabet[s[i]] if i + 1 - alphabet[s[i]] > f else f
while j >= 0:
# print('j',j)
f = i + 1 - alphabet[s[j]] if i + 1 - alphabet[s[j]] > f else f
if j >= f:
if j == 0:
dp[i] = (1 + dp[i])%MOD
else:
dp[i] = (dp[j-1] + dp[i])%MOD
maxlen = i-j+1 if i -j + 1 > maxlen else maxlen
if j == 0:
minsplitnum[i] = 1 if 1 < minsplitnum[i] else minsplitnum[i]
else:
minsplitnum[i] = minsplitnum[j-1]+1 if minsplitnum[j-1]+1 < minsplitnum[i] else minsplitnum[i]
j -= 1
else:
j -= 1
continue
i += 1
# print(dp[i])
print(int(dp[n-1]))
print(maxlen)
print(int(minsplitnum[n-1]))
solve()
``` | instruction | 0 | 94,051 | 0 | 188,102 |
Yes | output | 1 | 94,051 | 0 | 188,103 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mahmoud wrote a message s of length n. He wants to send it as a birthday present to his friend Moaz who likes strings. He wrote it on a magical paper but he was surprised because some characters disappeared while writing the string. That's because this magical paper doesn't allow character number i in the English alphabet to be written on it in a string of length more than ai. For example, if a1 = 2 he can't write character 'a' on this paper in a string of length 3 or more. String "aa" is allowed while string "aaa" is not.
Mahmoud decided to split the message into some non-empty substrings so that he can write every substring on an independent magical paper and fulfill the condition. The sum of their lengths should be n and they shouldn't overlap. For example, if a1 = 2 and he wants to send string "aaa", he can split it into "a" and "aa" and use 2 magical papers, or into "a", "a" and "a" and use 3 magical papers. He can't split it into "aa" and "aa" because the sum of their lengths is greater than n. He can split the message into single string if it fulfills the conditions.
A substring of string s is a string that consists of some consecutive characters from string s, strings "ab", "abc" and "b" are substrings of string "abc", while strings "acb" and "ac" are not. Any string is a substring of itself.
While Mahmoud was thinking of how to split the message, Ehab told him that there are many ways to split it. After that Mahmoud asked you three questions:
* How many ways are there to split the string into substrings such that every substring fulfills the condition of the magical paper, the sum of their lengths is n and they don't overlap? Compute the answer modulo 109 + 7.
* What is the maximum length of a substring that can appear in some valid splitting?
* What is the minimum number of substrings the message can be spit in?
Two ways are considered different, if the sets of split positions differ. For example, splitting "aa|a" and "a|aa" are considered different splittings of message "aaa".
Input
The first line contains an integer n (1 ≤ n ≤ 103) denoting the length of the message.
The second line contains the message s of length n that consists of lowercase English letters.
The third line contains 26 integers a1, a2, ..., a26 (1 ≤ ax ≤ 103) — the maximum lengths of substring each letter can appear in.
Output
Print three lines.
In the first line print the number of ways to split the message into substrings and fulfill the conditions mentioned in the problem modulo 109 + 7.
In the second line print the length of the longest substring over all the ways.
In the third line print the minimum number of substrings over all the ways.
Examples
Input
3
aab
2 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
3
2
2
Input
10
abcdeabcde
5 5 5 5 4 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
401
4
3
Note
In the first example the three ways to split the message are:
* a|a|b
* aa|b
* a|ab
The longest substrings are "aa" and "ab" of length 2.
The minimum number of substrings is 2 in "a|ab" or "aa|b".
Notice that "aab" is not a possible splitting because the letter 'a' appears in a substring of length 3, while a1 = 2.
Submitted Solution:
```
read = lambda: map(int, input().split())
n = int(input())
s = input()
a = list(read())
dp = [0] * (n + 2)
mn = [10 ** 4] * (n + 2)
dp[0] = dp[n + 1] = 1
mn[n + 1] = 0
mn[0] = 1
Max = 1
mod = 10 ** 9 + 7
for i in range(1, n):
res = 0
cur = 10 ** 4
for j in range(i, -1, -1):
c = ord(s[j]) - ord('a')
cur = min(cur, a[c])
if cur < (i - j + 1):
break
dp[i] = (dp[i] + dp[j - 1]) % mod
mn[i] = min(mn[i], mn[j - 1] + 1)
Max = max(Max, i - j + 1)
print(dp[n - 1])
print(Max)
print(mn[n - 1])
``` | instruction | 0 | 94,052 | 0 | 188,104 |
Yes | output | 1 | 94,052 | 0 | 188,105 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mahmoud wrote a message s of length n. He wants to send it as a birthday present to his friend Moaz who likes strings. He wrote it on a magical paper but he was surprised because some characters disappeared while writing the string. That's because this magical paper doesn't allow character number i in the English alphabet to be written on it in a string of length more than ai. For example, if a1 = 2 he can't write character 'a' on this paper in a string of length 3 or more. String "aa" is allowed while string "aaa" is not.
Mahmoud decided to split the message into some non-empty substrings so that he can write every substring on an independent magical paper and fulfill the condition. The sum of their lengths should be n and they shouldn't overlap. For example, if a1 = 2 and he wants to send string "aaa", he can split it into "a" and "aa" and use 2 magical papers, or into "a", "a" and "a" and use 3 magical papers. He can't split it into "aa" and "aa" because the sum of their lengths is greater than n. He can split the message into single string if it fulfills the conditions.
A substring of string s is a string that consists of some consecutive characters from string s, strings "ab", "abc" and "b" are substrings of string "abc", while strings "acb" and "ac" are not. Any string is a substring of itself.
While Mahmoud was thinking of how to split the message, Ehab told him that there are many ways to split it. After that Mahmoud asked you three questions:
* How many ways are there to split the string into substrings such that every substring fulfills the condition of the magical paper, the sum of their lengths is n and they don't overlap? Compute the answer modulo 109 + 7.
* What is the maximum length of a substring that can appear in some valid splitting?
* What is the minimum number of substrings the message can be spit in?
Two ways are considered different, if the sets of split positions differ. For example, splitting "aa|a" and "a|aa" are considered different splittings of message "aaa".
Input
The first line contains an integer n (1 ≤ n ≤ 103) denoting the length of the message.
The second line contains the message s of length n that consists of lowercase English letters.
The third line contains 26 integers a1, a2, ..., a26 (1 ≤ ax ≤ 103) — the maximum lengths of substring each letter can appear in.
Output
Print three lines.
In the first line print the number of ways to split the message into substrings and fulfill the conditions mentioned in the problem modulo 109 + 7.
In the second line print the length of the longest substring over all the ways.
In the third line print the minimum number of substrings over all the ways.
Examples
Input
3
aab
2 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
3
2
2
Input
10
abcdeabcde
5 5 5 5 4 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
401
4
3
Note
In the first example the three ways to split the message are:
* a|a|b
* aa|b
* a|ab
The longest substrings are "aa" and "ab" of length 2.
The minimum number of substrings is 2 in "a|ab" or "aa|b".
Notice that "aab" is not a possible splitting because the letter 'a' appears in a substring of length 3, while a1 = 2.
Submitted Solution:
```
n=int(input())
d=[0]*(n+1)
way=[n]*(n+1)
s='0'+input()
m=list(map(int,input().split()))
d[1]=1
d[0]=1
way[0]=0
way[1]=1
dic=dict()
dic['0']=1000
i=0
for l in 'abcdefghijklmnopqrstuvwxyz':
dic[l]=m[i]
i+=1
high=1
big=10**9+7
for i in range(2,n+1):
z=i-1
x=i-dic[s[i]]
while z>=0 and x<=z:
x = max(x, i-dic[s[z]])
high = max(high, i - z)
d[i] += d[z]
way[i] = way[z] + 1
z -= 1
d[i]=d[i]%big
z+=1
if not z:
high=i
print(d[-1])
print(high)
print(way[-1])
``` | instruction | 0 | 94,053 | 0 | 188,106 |
Yes | output | 1 | 94,053 | 0 | 188,107 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mahmoud wrote a message s of length n. He wants to send it as a birthday present to his friend Moaz who likes strings. He wrote it on a magical paper but he was surprised because some characters disappeared while writing the string. That's because this magical paper doesn't allow character number i in the English alphabet to be written on it in a string of length more than ai. For example, if a1 = 2 he can't write character 'a' on this paper in a string of length 3 or more. String "aa" is allowed while string "aaa" is not.
Mahmoud decided to split the message into some non-empty substrings so that he can write every substring on an independent magical paper and fulfill the condition. The sum of their lengths should be n and they shouldn't overlap. For example, if a1 = 2 and he wants to send string "aaa", he can split it into "a" and "aa" and use 2 magical papers, or into "a", "a" and "a" and use 3 magical papers. He can't split it into "aa" and "aa" because the sum of their lengths is greater than n. He can split the message into single string if it fulfills the conditions.
A substring of string s is a string that consists of some consecutive characters from string s, strings "ab", "abc" and "b" are substrings of string "abc", while strings "acb" and "ac" are not. Any string is a substring of itself.
While Mahmoud was thinking of how to split the message, Ehab told him that there are many ways to split it. After that Mahmoud asked you three questions:
* How many ways are there to split the string into substrings such that every substring fulfills the condition of the magical paper, the sum of their lengths is n and they don't overlap? Compute the answer modulo 109 + 7.
* What is the maximum length of a substring that can appear in some valid splitting?
* What is the minimum number of substrings the message can be spit in?
Two ways are considered different, if the sets of split positions differ. For example, splitting "aa|a" and "a|aa" are considered different splittings of message "aaa".
Input
The first line contains an integer n (1 ≤ n ≤ 103) denoting the length of the message.
The second line contains the message s of length n that consists of lowercase English letters.
The third line contains 26 integers a1, a2, ..., a26 (1 ≤ ax ≤ 103) — the maximum lengths of substring each letter can appear in.
Output
Print three lines.
In the first line print the number of ways to split the message into substrings and fulfill the conditions mentioned in the problem modulo 109 + 7.
In the second line print the length of the longest substring over all the ways.
In the third line print the minimum number of substrings over all the ways.
Examples
Input
3
aab
2 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
3
2
2
Input
10
abcdeabcde
5 5 5 5 4 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
401
4
3
Note
In the first example the three ways to split the message are:
* a|a|b
* aa|b
* a|ab
The longest substrings are "aa" and "ab" of length 2.
The minimum number of substrings is 2 in "a|ab" or "aa|b".
Notice that "aab" is not a possible splitting because the letter 'a' appears in a substring of length 3, while a1 = 2.
Submitted Solution:
```
n=int(input())
st=input()
a=list(map(int,input().split()))
list=[[] for i in range(n)]
arr=[]
for i in range(n):
arr.append(a[ord(st[i])-97])
ans3=0
add=0
flag=0
for i in range(n):
mini=arr[i]
count=1
j=i
while count <= mini and j<n:
list[i].append(j)
j+=1
count+=1
if j<n:
mini=min(mini,arr[j])
if i==ans3 and flag==0:
add+=1
ans3=j-1
if j==n:
flag=1
counted=[0 for i in range(n)]
for i in list[0]:
counted[i]=1
ans2=len(list[0])
i=0
while i<n-1:
total=counted[i]
ans2=max(ans2,len(list[i]))
for j in list[i+1]:
counted[j]+=total
i+=1
ans2=max(ans2,len(list[i]))
print(counted[n-1])
print(ans2)
print(add)
``` | instruction | 0 | 94,054 | 0 | 188,108 |
No | output | 1 | 94,054 | 0 | 188,109 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mahmoud wrote a message s of length n. He wants to send it as a birthday present to his friend Moaz who likes strings. He wrote it on a magical paper but he was surprised because some characters disappeared while writing the string. That's because this magical paper doesn't allow character number i in the English alphabet to be written on it in a string of length more than ai. For example, if a1 = 2 he can't write character 'a' on this paper in a string of length 3 or more. String "aa" is allowed while string "aaa" is not.
Mahmoud decided to split the message into some non-empty substrings so that he can write every substring on an independent magical paper and fulfill the condition. The sum of their lengths should be n and they shouldn't overlap. For example, if a1 = 2 and he wants to send string "aaa", he can split it into "a" and "aa" and use 2 magical papers, or into "a", "a" and "a" and use 3 magical papers. He can't split it into "aa" and "aa" because the sum of their lengths is greater than n. He can split the message into single string if it fulfills the conditions.
A substring of string s is a string that consists of some consecutive characters from string s, strings "ab", "abc" and "b" are substrings of string "abc", while strings "acb" and "ac" are not. Any string is a substring of itself.
While Mahmoud was thinking of how to split the message, Ehab told him that there are many ways to split it. After that Mahmoud asked you three questions:
* How many ways are there to split the string into substrings such that every substring fulfills the condition of the magical paper, the sum of their lengths is n and they don't overlap? Compute the answer modulo 109 + 7.
* What is the maximum length of a substring that can appear in some valid splitting?
* What is the minimum number of substrings the message can be spit in?
Two ways are considered different, if the sets of split positions differ. For example, splitting "aa|a" and "a|aa" are considered different splittings of message "aaa".
Input
The first line contains an integer n (1 ≤ n ≤ 103) denoting the length of the message.
The second line contains the message s of length n that consists of lowercase English letters.
The third line contains 26 integers a1, a2, ..., a26 (1 ≤ ax ≤ 103) — the maximum lengths of substring each letter can appear in.
Output
Print three lines.
In the first line print the number of ways to split the message into substrings and fulfill the conditions mentioned in the problem modulo 109 + 7.
In the second line print the length of the longest substring over all the ways.
In the third line print the minimum number of substrings over all the ways.
Examples
Input
3
aab
2 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
3
2
2
Input
10
abcdeabcde
5 5 5 5 4 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
401
4
3
Note
In the first example the three ways to split the message are:
* a|a|b
* aa|b
* a|ab
The longest substrings are "aa" and "ab" of length 2.
The minimum number of substrings is 2 in "a|ab" or "aa|b".
Notice that "aab" is not a possible splitting because the letter 'a' appears in a substring of length 3, while a1 = 2.
Submitted Solution:
```
import sys
mod = pow(10, 9) + 7
n = int(sys.stdin.readline())
s = sys.stdin.readline()[:-1]
a = [int(x) for x in sys.stdin.readline().split()]
dp = [0 for _ in range(n+1)]
dp[0] = 1
def ci(c):
return ord(c)-ord('a')
l = 0
for i in range(1, n+1):
# f: represents the farther
# we can get from x (going from
# right to left) without breaking
# the splitting rules
f = 0
for x in range(i-1, -1, -1):
f = max(f, i-a[ci(s[x])])
if f > x:
# we broke the rule
continue
dp[i] = (dp[i]+dp[x]) % mod
l = max(l, i-x)
print(dp[n])
print(l)
res = 1
m = 9999
j = 0
for i in range(n):
m = min(m, a[ci(s[i])])
if m < i-j+1:
res += 1
j = i
print(res)
``` | instruction | 0 | 94,055 | 0 | 188,110 |
No | output | 1 | 94,055 | 0 | 188,111 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mahmoud wrote a message s of length n. He wants to send it as a birthday present to his friend Moaz who likes strings. He wrote it on a magical paper but he was surprised because some characters disappeared while writing the string. That's because this magical paper doesn't allow character number i in the English alphabet to be written on it in a string of length more than ai. For example, if a1 = 2 he can't write character 'a' on this paper in a string of length 3 or more. String "aa" is allowed while string "aaa" is not.
Mahmoud decided to split the message into some non-empty substrings so that he can write every substring on an independent magical paper and fulfill the condition. The sum of their lengths should be n and they shouldn't overlap. For example, if a1 = 2 and he wants to send string "aaa", he can split it into "a" and "aa" and use 2 magical papers, or into "a", "a" and "a" and use 3 magical papers. He can't split it into "aa" and "aa" because the sum of their lengths is greater than n. He can split the message into single string if it fulfills the conditions.
A substring of string s is a string that consists of some consecutive characters from string s, strings "ab", "abc" and "b" are substrings of string "abc", while strings "acb" and "ac" are not. Any string is a substring of itself.
While Mahmoud was thinking of how to split the message, Ehab told him that there are many ways to split it. After that Mahmoud asked you three questions:
* How many ways are there to split the string into substrings such that every substring fulfills the condition of the magical paper, the sum of their lengths is n and they don't overlap? Compute the answer modulo 109 + 7.
* What is the maximum length of a substring that can appear in some valid splitting?
* What is the minimum number of substrings the message can be spit in?
Two ways are considered different, if the sets of split positions differ. For example, splitting "aa|a" and "a|aa" are considered different splittings of message "aaa".
Input
The first line contains an integer n (1 ≤ n ≤ 103) denoting the length of the message.
The second line contains the message s of length n that consists of lowercase English letters.
The third line contains 26 integers a1, a2, ..., a26 (1 ≤ ax ≤ 103) — the maximum lengths of substring each letter can appear in.
Output
Print three lines.
In the first line print the number of ways to split the message into substrings and fulfill the conditions mentioned in the problem modulo 109 + 7.
In the second line print the length of the longest substring over all the ways.
In the third line print the minimum number of substrings over all the ways.
Examples
Input
3
aab
2 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
3
2
2
Input
10
abcdeabcde
5 5 5 5 4 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
401
4
3
Note
In the first example the three ways to split the message are:
* a|a|b
* aa|b
* a|ab
The longest substrings are "aa" and "ab" of length 2.
The minimum number of substrings is 2 in "a|ab" or "aa|b".
Notice that "aab" is not a possible splitting because the letter 'a' appears in a substring of length 3, while a1 = 2.
Submitted Solution:
```
n = int(input())
s = input()
S = [ord(znak) - 97 for znak in s]
a = list(map(int, input().strip().split(' ')))
#print(n, S, a)
st = [0]*(n+1)
st[0] = 1
maks = [0]*(n+1)
minway = [10**4]*(n+1)
minway[0] = 0
for i in range(1, n + 1):
cnt = 0
maks_dolzina = n
for j in range(i, 0, -1):
maks_dolzina = min(maks_dolzina, a[S[j - 1]])
if i - j + 1 > maks_dolzina:
break
cnt += st[j-1]
maks[i] = max(i-j+1, maks[j-1], maks[i])
minway[i] = min(minway[i], 1 + minway[j-1])
st[i] = cnt
print(st[-1])
print(maks[-1])
print(minway[-1])
``` | instruction | 0 | 94,056 | 0 | 188,112 |
No | output | 1 | 94,056 | 0 | 188,113 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mahmoud wrote a message s of length n. He wants to send it as a birthday present to his friend Moaz who likes strings. He wrote it on a magical paper but he was surprised because some characters disappeared while writing the string. That's because this magical paper doesn't allow character number i in the English alphabet to be written on it in a string of length more than ai. For example, if a1 = 2 he can't write character 'a' on this paper in a string of length 3 or more. String "aa" is allowed while string "aaa" is not.
Mahmoud decided to split the message into some non-empty substrings so that he can write every substring on an independent magical paper and fulfill the condition. The sum of their lengths should be n and they shouldn't overlap. For example, if a1 = 2 and he wants to send string "aaa", he can split it into "a" and "aa" and use 2 magical papers, or into "a", "a" and "a" and use 3 magical papers. He can't split it into "aa" and "aa" because the sum of their lengths is greater than n. He can split the message into single string if it fulfills the conditions.
A substring of string s is a string that consists of some consecutive characters from string s, strings "ab", "abc" and "b" are substrings of string "abc", while strings "acb" and "ac" are not. Any string is a substring of itself.
While Mahmoud was thinking of how to split the message, Ehab told him that there are many ways to split it. After that Mahmoud asked you three questions:
* How many ways are there to split the string into substrings such that every substring fulfills the condition of the magical paper, the sum of their lengths is n and they don't overlap? Compute the answer modulo 109 + 7.
* What is the maximum length of a substring that can appear in some valid splitting?
* What is the minimum number of substrings the message can be spit in?
Two ways are considered different, if the sets of split positions differ. For example, splitting "aa|a" and "a|aa" are considered different splittings of message "aaa".
Input
The first line contains an integer n (1 ≤ n ≤ 103) denoting the length of the message.
The second line contains the message s of length n that consists of lowercase English letters.
The third line contains 26 integers a1, a2, ..., a26 (1 ≤ ax ≤ 103) — the maximum lengths of substring each letter can appear in.
Output
Print three lines.
In the first line print the number of ways to split the message into substrings and fulfill the conditions mentioned in the problem modulo 109 + 7.
In the second line print the length of the longest substring over all the ways.
In the third line print the minimum number of substrings over all the ways.
Examples
Input
3
aab
2 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
3
2
2
Input
10
abcdeabcde
5 5 5 5 4 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Output
401
4
3
Note
In the first example the three ways to split the message are:
* a|a|b
* aa|b
* a|ab
The longest substrings are "aa" and "ab" of length 2.
The minimum number of substrings is 2 in "a|ab" or "aa|b".
Notice that "aab" is not a possible splitting because the letter 'a' appears in a substring of length 3, while a1 = 2.
Submitted Solution:
```
from sys import stdin, stdout
MOD = 10 ** 9 + 7
n = int(stdin.readline())
s = '#' + stdin.readline().strip()
length = [0] + list(map(int, stdin.readline().strip().split()))
dp = [0 for i in range(n + 10)]
dp[0] = 1
dp[-1] = 1
ans = [0, 1, 0]
dp1 = [0 for i in range(n + 5)]
dp1[0] = 0
for i in range(1, n + 1):
cnt = min(i, length[ord(s[i]) - ord('a')])
ind = i - cnt + 1
while ind <= i:
if length[ord(s[ind]) - ord('a')] < cnt:
cnt -= 1
else:
ind += 1
dp1[i] = dp1[i - cnt] + 1
ans[1] = max(ans[1], cnt)
if cnt == i + 1:
dp[i] = bn[cnt - 1] % MOD
else:
for j in range(1, cnt + 1):
dp[i] += dp[i - j]
dp[i] %= MOD
ans[0] = dp[n - 1] % MOD
ans[2] = dp1[n - 1]
stdout.write('\n'.join(list(map(str, ans))))
``` | instruction | 0 | 94,057 | 0 | 188,114 |
No | output | 1 | 94,057 | 0 | 188,115 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S consisting of uppercase English letters. Find the length of the longest ACGT string that is a substring (see Notes) of S.
Here, a ACGT string is a string that contains no characters other than `A`, `C`, `G` and `T`.
Constraints
* S is a string of length between 1 and 10 (inclusive).
* Each character in S is an uppercase English letter.
Input
Input is given from Standard Input in the following format:
S
Output
Print the length of the longest ACGT string that is a substring of S.
Examples
Input
ATCODER
Output
3
Input
HATAGAYA
Output
5
Input
SHINJUKU
Output
0 | instruction | 0 | 94,195 | 0 | 188,390 |
"Correct Solution:
```
import re
ans = max(map(len, re.findall("[ACGT]*", input())))
print(ans)
``` | output | 1 | 94,195 | 0 | 188,391 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S consisting of uppercase English letters. Find the length of the longest ACGT string that is a substring (see Notes) of S.
Here, a ACGT string is a string that contains no characters other than `A`, `C`, `G` and `T`.
Constraints
* S is a string of length between 1 and 10 (inclusive).
* Each character in S is an uppercase English letter.
Input
Input is given from Standard Input in the following format:
S
Output
Print the length of the longest ACGT string that is a substring of S.
Examples
Input
ATCODER
Output
3
Input
HATAGAYA
Output
5
Input
SHINJUKU
Output
0 | instruction | 0 | 94,196 | 0 | 188,392 |
"Correct Solution:
```
a="".join(["1" if s in ["A","C","G","T"] else "0" for s in input()])
ans=[len(s) for s in a.split("0")]
print(max(ans))
``` | output | 1 | 94,196 | 0 | 188,393 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S consisting of uppercase English letters. Find the length of the longest ACGT string that is a substring (see Notes) of S.
Here, a ACGT string is a string that contains no characters other than `A`, `C`, `G` and `T`.
Constraints
* S is a string of length between 1 and 10 (inclusive).
* Each character in S is an uppercase English letter.
Input
Input is given from Standard Input in the following format:
S
Output
Print the length of the longest ACGT string that is a substring of S.
Examples
Input
ATCODER
Output
3
Input
HATAGAYA
Output
5
Input
SHINJUKU
Output
0 | instruction | 0 | 94,197 | 0 | 188,394 |
"Correct Solution:
```
import re
data = input()
t = re.split('[^ACGT]+', data)
t.sort(key=len, reverse=True)
print(len(t[0]))
``` | output | 1 | 94,197 | 0 | 188,395 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S consisting of uppercase English letters. Find the length of the longest ACGT string that is a substring (see Notes) of S.
Here, a ACGT string is a string that contains no characters other than `A`, `C`, `G` and `T`.
Constraints
* S is a string of length between 1 and 10 (inclusive).
* Each character in S is an uppercase English letter.
Input
Input is given from Standard Input in the following format:
S
Output
Print the length of the longest ACGT string that is a substring of S.
Examples
Input
ATCODER
Output
3
Input
HATAGAYA
Output
5
Input
SHINJUKU
Output
0 | instruction | 0 | 94,198 | 0 | 188,396 |
"Correct Solution:
```
import re
ll = list(map(len,re.sub('[^ACGT]',' ', input()).split()))
if len(ll) == 0:print(0)
else:print(max(ll))
``` | output | 1 | 94,198 | 0 | 188,397 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S consisting of uppercase English letters. Find the length of the longest ACGT string that is a substring (see Notes) of S.
Here, a ACGT string is a string that contains no characters other than `A`, `C`, `G` and `T`.
Constraints
* S is a string of length between 1 and 10 (inclusive).
* Each character in S is an uppercase English letter.
Input
Input is given from Standard Input in the following format:
S
Output
Print the length of the longest ACGT string that is a substring of S.
Examples
Input
ATCODER
Output
3
Input
HATAGAYA
Output
5
Input
SHINJUKU
Output
0 | instruction | 0 | 94,199 | 0 | 188,398 |
"Correct Solution:
```
import re
result = re.findall('[ATCG]+',input(),re.S)
if len(result)>0:
print(max(list(map(len,result))))
else:
print(0)
``` | output | 1 | 94,199 | 0 | 188,399 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S consisting of uppercase English letters. Find the length of the longest ACGT string that is a substring (see Notes) of S.
Here, a ACGT string is a string that contains no characters other than `A`, `C`, `G` and `T`.
Constraints
* S is a string of length between 1 and 10 (inclusive).
* Each character in S is an uppercase English letter.
Input
Input is given from Standard Input in the following format:
S
Output
Print the length of the longest ACGT string that is a substring of S.
Examples
Input
ATCODER
Output
3
Input
HATAGAYA
Output
5
Input
SHINJUKU
Output
0 | instruction | 0 | 94,200 | 0 | 188,400 |
"Correct Solution:
```
s = input()
m = 0
count = 0
for i in s:
if i in ["A","C","G","T"]: count+=1
else: count=0
m = max(m,count)
print(m)
``` | output | 1 | 94,200 | 0 | 188,401 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S consisting of uppercase English letters. Find the length of the longest ACGT string that is a substring (see Notes) of S.
Here, a ACGT string is a string that contains no characters other than `A`, `C`, `G` and `T`.
Constraints
* S is a string of length between 1 and 10 (inclusive).
* Each character in S is an uppercase English letter.
Input
Input is given from Standard Input in the following format:
S
Output
Print the length of the longest ACGT string that is a substring of S.
Examples
Input
ATCODER
Output
3
Input
HATAGAYA
Output
5
Input
SHINJUKU
Output
0 | instruction | 0 | 94,201 | 0 | 188,402 |
"Correct Solution:
```
print(max(map(lambda x:len(x), "".join([_ if _ in "ACGT" else "_" for _ in str(input())]).split("_"))))
``` | output | 1 | 94,201 | 0 | 188,403 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S consisting of uppercase English letters. Find the length of the longest ACGT string that is a substring (see Notes) of S.
Here, a ACGT string is a string that contains no characters other than `A`, `C`, `G` and `T`.
Constraints
* S is a string of length between 1 and 10 (inclusive).
* Each character in S is an uppercase English letter.
Input
Input is given from Standard Input in the following format:
S
Output
Print the length of the longest ACGT string that is a substring of S.
Examples
Input
ATCODER
Output
3
Input
HATAGAYA
Output
5
Input
SHINJUKU
Output
0 | instruction | 0 | 94,202 | 0 | 188,404 |
"Correct Solution:
```
import re
s=re.split("[^ACGT]", input())
a=[]
for i in range(len(s)):
a.append(len(s[i]))
print(max(a))
``` | output | 1 | 94,202 | 0 | 188,405 |
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 consisting of uppercase English letters. Find the length of the longest ACGT string that is a substring (see Notes) of S.
Here, a ACGT string is a string that contains no characters other than `A`, `C`, `G` and `T`.
Constraints
* S is a string of length between 1 and 10 (inclusive).
* Each character in S is an uppercase English letter.
Input
Input is given from Standard Input in the following format:
S
Output
Print the length of the longest ACGT string that is a substring of S.
Examples
Input
ATCODER
Output
3
Input
HATAGAYA
Output
5
Input
SHINJUKU
Output
0
Submitted Solution:
```
S = input()
l= len(S)
ans = 0
for i in range(l):
for j in range(l-i):
seq = S[i:i+j]
seq2 = seq.replace("A","").replace("G","").replace("T","").replace("C","")
if seq2 == "":
ans = max(ans, len(seq))
print(ans)
``` | instruction | 0 | 94,209 | 0 | 188,418 |
No | output | 1 | 94,209 | 0 | 188,419 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S of length N and another string T of length M. These strings consist of lowercase English letters.
A string X is called a good string when the following conditions are all met:
* Let L be the length of X. L is divisible by both N and M.
* Concatenating the 1-st, (\frac{L}{N}+1)-th, (2 \times \frac{L}{N}+1)-th, ..., ((N-1)\times\frac{L}{N}+1)-th characters of X, without changing the order, results in S.
* Concatenating the 1-st, (\frac{L}{M}+1)-th, (2 \times \frac{L}{M}+1)-th, ..., ((M-1)\times\frac{L}{M}+1)-th characters of X, without changing the order, results in T.
Determine if there exists a good string. If it exists, find the length of the shortest such string.
Constraints
* 1 \leq N,M \leq 10^5
* S and T consist of lowercase English letters.
* |S|=N
* |T|=M
Input
Input is given from Standard Input in the following format:
N M
S
T
Output
If a good string does not exist, print `-1`; if it exists, print the length of the shortest such string.
Examples
Input
3 2
acp
ae
Output
6
Input
6 3
abcdef
abc
Output
-1
Input
15 9
dnsusrayukuaiia
dujrunuma
Output
45 | instruction | 0 | 94,211 | 0 | 188,422 |
"Correct Solution:
```
N,M=map(int,input().split());import fractions;L=M//fractions.gcd(M,N)*N;print((-1,L)[input()[::L//M]==input()[::L//N]])
``` | output | 1 | 94,211 | 0 | 188,423 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S of length N and another string T of length M. These strings consist of lowercase English letters.
A string X is called a good string when the following conditions are all met:
* Let L be the length of X. L is divisible by both N and M.
* Concatenating the 1-st, (\frac{L}{N}+1)-th, (2 \times \frac{L}{N}+1)-th, ..., ((N-1)\times\frac{L}{N}+1)-th characters of X, without changing the order, results in S.
* Concatenating the 1-st, (\frac{L}{M}+1)-th, (2 \times \frac{L}{M}+1)-th, ..., ((M-1)\times\frac{L}{M}+1)-th characters of X, without changing the order, results in T.
Determine if there exists a good string. If it exists, find the length of the shortest such string.
Constraints
* 1 \leq N,M \leq 10^5
* S and T consist of lowercase English letters.
* |S|=N
* |T|=M
Input
Input is given from Standard Input in the following format:
N M
S
T
Output
If a good string does not exist, print `-1`; if it exists, print the length of the shortest such string.
Examples
Input
3 2
acp
ae
Output
6
Input
6 3
abcdef
abc
Output
-1
Input
15 9
dnsusrayukuaiia
dujrunuma
Output
45 | instruction | 0 | 94,212 | 0 | 188,424 |
"Correct Solution:
```
N,M=map(int,input().split())
n,m=N,M
s=input()
t=input()
while m:
n,m=m,n%m
gcd=n
lcm=N*M//gcd
step1=N//gcd
step2=M//gcd
if all(s[i*step1]==t[i*step2] for i in range(gcd)):
print(lcm)
else:
print(-1)
``` | output | 1 | 94,212 | 0 | 188,425 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S of length N and another string T of length M. These strings consist of lowercase English letters.
A string X is called a good string when the following conditions are all met:
* Let L be the length of X. L is divisible by both N and M.
* Concatenating the 1-st, (\frac{L}{N}+1)-th, (2 \times \frac{L}{N}+1)-th, ..., ((N-1)\times\frac{L}{N}+1)-th characters of X, without changing the order, results in S.
* Concatenating the 1-st, (\frac{L}{M}+1)-th, (2 \times \frac{L}{M}+1)-th, ..., ((M-1)\times\frac{L}{M}+1)-th characters of X, without changing the order, results in T.
Determine if there exists a good string. If it exists, find the length of the shortest such string.
Constraints
* 1 \leq N,M \leq 10^5
* S and T consist of lowercase English letters.
* |S|=N
* |T|=M
Input
Input is given from Standard Input in the following format:
N M
S
T
Output
If a good string does not exist, print `-1`; if it exists, print the length of the shortest such string.
Examples
Input
3 2
acp
ae
Output
6
Input
6 3
abcdef
abc
Output
-1
Input
15 9
dnsusrayukuaiia
dujrunuma
Output
45 | instruction | 0 | 94,213 | 0 | 188,426 |
"Correct Solution:
```
from fractions import gcd
N, M = map(int, input().split())
S = input()
T = input()
g = gcd(N, M)
lcm = N * M // g
for i in range(g):
if S[i*N//g] != T[i*M//g]:
print(-1)
exit()
print(lcm)
``` | output | 1 | 94,213 | 0 | 188,427 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S of length N and another string T of length M. These strings consist of lowercase English letters.
A string X is called a good string when the following conditions are all met:
* Let L be the length of X. L is divisible by both N and M.
* Concatenating the 1-st, (\frac{L}{N}+1)-th, (2 \times \frac{L}{N}+1)-th, ..., ((N-1)\times\frac{L}{N}+1)-th characters of X, without changing the order, results in S.
* Concatenating the 1-st, (\frac{L}{M}+1)-th, (2 \times \frac{L}{M}+1)-th, ..., ((M-1)\times\frac{L}{M}+1)-th characters of X, without changing the order, results in T.
Determine if there exists a good string. If it exists, find the length of the shortest such string.
Constraints
* 1 \leq N,M \leq 10^5
* S and T consist of lowercase English letters.
* |S|=N
* |T|=M
Input
Input is given from Standard Input in the following format:
N M
S
T
Output
If a good string does not exist, print `-1`; if it exists, print the length of the shortest such string.
Examples
Input
3 2
acp
ae
Output
6
Input
6 3
abcdef
abc
Output
-1
Input
15 9
dnsusrayukuaiia
dujrunuma
Output
45 | instruction | 0 | 94,214 | 0 | 188,428 |
"Correct Solution:
```
import fractions
n, m = map(int, input().split())
s = input()
t = input()
sr = fractions.gcd(n, m)
sg, tg = n // sr, m // sr
for i in range(sr):
if s[i * sg] != t[i * tg]:
print(-1)
exit()
print(sg * m)
``` | output | 1 | 94,214 | 0 | 188,429 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S of length N and another string T of length M. These strings consist of lowercase English letters.
A string X is called a good string when the following conditions are all met:
* Let L be the length of X. L is divisible by both N and M.
* Concatenating the 1-st, (\frac{L}{N}+1)-th, (2 \times \frac{L}{N}+1)-th, ..., ((N-1)\times\frac{L}{N}+1)-th characters of X, without changing the order, results in S.
* Concatenating the 1-st, (\frac{L}{M}+1)-th, (2 \times \frac{L}{M}+1)-th, ..., ((M-1)\times\frac{L}{M}+1)-th characters of X, without changing the order, results in T.
Determine if there exists a good string. If it exists, find the length of the shortest such string.
Constraints
* 1 \leq N,M \leq 10^5
* S and T consist of lowercase English letters.
* |S|=N
* |T|=M
Input
Input is given from Standard Input in the following format:
N M
S
T
Output
If a good string does not exist, print `-1`; if it exists, print the length of the shortest such string.
Examples
Input
3 2
acp
ae
Output
6
Input
6 3
abcdef
abc
Output
-1
Input
15 9
dnsusrayukuaiia
dujrunuma
Output
45 | instruction | 0 | 94,215 | 0 | 188,430 |
"Correct Solution:
```
from math import gcd
def lcm(a,b):
return a*b//gcd(a,b)
N,M = map(int,input().split())
S = input()
T = input()
g = gcd(N,M)
l = lcm(N,M)
for i in range(g):
if S[l//M*i] != T[l//N*i]:
print(-1)
exit()
print(l)
``` | output | 1 | 94,215 | 0 | 188,431 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S of length N and another string T of length M. These strings consist of lowercase English letters.
A string X is called a good string when the following conditions are all met:
* Let L be the length of X. L is divisible by both N and M.
* Concatenating the 1-st, (\frac{L}{N}+1)-th, (2 \times \frac{L}{N}+1)-th, ..., ((N-1)\times\frac{L}{N}+1)-th characters of X, without changing the order, results in S.
* Concatenating the 1-st, (\frac{L}{M}+1)-th, (2 \times \frac{L}{M}+1)-th, ..., ((M-1)\times\frac{L}{M}+1)-th characters of X, without changing the order, results in T.
Determine if there exists a good string. If it exists, find the length of the shortest such string.
Constraints
* 1 \leq N,M \leq 10^5
* S and T consist of lowercase English letters.
* |S|=N
* |T|=M
Input
Input is given from Standard Input in the following format:
N M
S
T
Output
If a good string does not exist, print `-1`; if it exists, print the length of the shortest such string.
Examples
Input
3 2
acp
ae
Output
6
Input
6 3
abcdef
abc
Output
-1
Input
15 9
dnsusrayukuaiia
dujrunuma
Output
45 | instruction | 0 | 94,216 | 0 | 188,432 |
"Correct Solution:
```
n,m=map(int,input().split())
s=input()
t=input()
import fractions
g=fractions.gcd(n,m)
m0=m//g
n0=n//g
i=0
while i*n0<n and i*m0<m:
if s[i*n0]==t[i*m0]:
pass
else:
print(-1)
exit()
i+=1
print(n*m//g)
``` | output | 1 | 94,216 | 0 | 188,433 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S of length N and another string T of length M. These strings consist of lowercase English letters.
A string X is called a good string when the following conditions are all met:
* Let L be the length of X. L is divisible by both N and M.
* Concatenating the 1-st, (\frac{L}{N}+1)-th, (2 \times \frac{L}{N}+1)-th, ..., ((N-1)\times\frac{L}{N}+1)-th characters of X, without changing the order, results in S.
* Concatenating the 1-st, (\frac{L}{M}+1)-th, (2 \times \frac{L}{M}+1)-th, ..., ((M-1)\times\frac{L}{M}+1)-th characters of X, without changing the order, results in T.
Determine if there exists a good string. If it exists, find the length of the shortest such string.
Constraints
* 1 \leq N,M \leq 10^5
* S and T consist of lowercase English letters.
* |S|=N
* |T|=M
Input
Input is given from Standard Input in the following format:
N M
S
T
Output
If a good string does not exist, print `-1`; if it exists, print the length of the shortest such string.
Examples
Input
3 2
acp
ae
Output
6
Input
6 3
abcdef
abc
Output
-1
Input
15 9
dnsusrayukuaiia
dujrunuma
Output
45 | instruction | 0 | 94,217 | 0 | 188,434 |
"Correct Solution:
```
from fractions import gcd
N, M = map(int, input().split(" "))
S = input()
T = input()
G = gcd(N, M)
L = N * M // G
for i in range(G):
if S[i*N//G] != T[i*M//G]:
print(-1)
exit(0)
print(L)
``` | output | 1 | 94,217 | 0 | 188,435 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a string S of length N and another string T of length M. These strings consist of lowercase English letters.
A string X is called a good string when the following conditions are all met:
* Let L be the length of X. L is divisible by both N and M.
* Concatenating the 1-st, (\frac{L}{N}+1)-th, (2 \times \frac{L}{N}+1)-th, ..., ((N-1)\times\frac{L}{N}+1)-th characters of X, without changing the order, results in S.
* Concatenating the 1-st, (\frac{L}{M}+1)-th, (2 \times \frac{L}{M}+1)-th, ..., ((M-1)\times\frac{L}{M}+1)-th characters of X, without changing the order, results in T.
Determine if there exists a good string. If it exists, find the length of the shortest such string.
Constraints
* 1 \leq N,M \leq 10^5
* S and T consist of lowercase English letters.
* |S|=N
* |T|=M
Input
Input is given from Standard Input in the following format:
N M
S
T
Output
If a good string does not exist, print `-1`; if it exists, print the length of the shortest such string.
Examples
Input
3 2
acp
ae
Output
6
Input
6 3
abcdef
abc
Output
-1
Input
15 9
dnsusrayukuaiia
dujrunuma
Output
45 | instruction | 0 | 94,218 | 0 | 188,436 |
"Correct Solution:
```
from fractions import gcd
N, M = map(int, input().split())
S, T = [input() for _ in range(2)]
L = gcd(N, M)
print(N*M//L if all([S[i*N//L] == T[i*M//L] for i in range(L)]) else -1)
``` | output | 1 | 94,218 | 0 | 188,437 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.