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.
Your classmate, whom you do not like because he is boring, but whom you respect for his intellect, has two strings: s of length n and t of length m.
A sequence p_1, p_2, β¦, p_m, where 1 β€ p_1 < p_2 < β¦ < p_m β€ n, is called beautiful, if s_{p_i} = t_i for all i from 1 to m. The width of a sequence is defined as max_{1 β€ i < m} \left(p_{i + 1} - p_i\right).
Please help your classmate to identify the beautiful sequence with the maximum width. Your classmate promised you that for the given strings s and t there is at least one beautiful sequence.
Input
The first input line contains two integers n and m (2 β€ m β€ n β€ 2 β
10^5) β the lengths of the strings s and t.
The following line contains a single string s of length n, consisting of lowercase letters of the Latin alphabet.
The last line contains a single string t of length m, consisting of lowercase letters of the Latin alphabet.
It is guaranteed that there is at least one beautiful sequence for the given strings.
Output
Output one integer β the maximum width of a beautiful sequence.
Examples
Input
5 3
abbbc
abc
Output
3
Input
5 2
aaaaa
aa
Output
4
Input
5 5
abcdf
abcdf
Output
1
Input
2 2
ab
ab
Output
1
Note
In the first example there are two beautiful sequences of width 3: they are \{1, 2, 5\} and \{1, 4, 5\}.
In the second example the beautiful sequence with the maximum width is \{1, 5\}.
In the third example there is exactly one beautiful sequence β it is \{1, 2, 3, 4, 5\}.
In the fourth example there is exactly one beautiful sequence β it is \{1, 2\}.
Submitted Solution:
```
from os import path;import sys,time
mod = int(1e9 + 7)
from math import ceil, floor,gcd,log,log2 ,factorial,sqrt
from collections import defaultdict ,Counter , OrderedDict , deque;from itertools import combinations,permutations , groupby
# from string import ascii_lowercase ,ascii_uppercase
from bisect import *;from functools import reduce;from operator import mul;maxx = float('inf')
I = lambda :int(sys.stdin.buffer.readline())
lint = lambda :[int(x) for x in sys.stdin.buffer.readline().split()]
S = lambda: sys.stdin.readline().strip('\n')
localsys = 0
start_time = time.time()
#left shift --- num*(2**k) --(k - shift)
nCr = lambda n, r: reduce(mul, range(n - r + 1, n + 1), 1) // factorial(r)
def ceill(n,x):
return (n+x -1 )//x
T =0
def solve():
n , m = map(int , input().split())
s = input().strip() ; t = input().strip()
i , l = 0 , []
for j in t:
while s[i] != j:
i+=1
l.append(i)
i+=1
# l --- calculating first of every character
i , r = n-1 , []
for c in t[::-1] :
while s[i] != c:
i-=1
r.append(i)
i-=1
#r --- calculating last character of every character
print(max( j-i for i , j in zip(l , r[::-1][1:])))
def run():
if (path.exists('input.txt')):
sys.stdin=open('input.txt','r')
sys.stdout=open('output.txt','w')
localsys = 1
run()
T = I() if T else 1
for _ in range(T):
solve()
if localsys:
print("\n\nTime Elased :",time.time() - start_time,"seconds")
``` | instruction | 0 | 47,247 | 0 | 94,494 |
Yes | output | 1 | 47,247 | 0 | 94,495 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your classmate, whom you do not like because he is boring, but whom you respect for his intellect, has two strings: s of length n and t of length m.
A sequence p_1, p_2, β¦, p_m, where 1 β€ p_1 < p_2 < β¦ < p_m β€ n, is called beautiful, if s_{p_i} = t_i for all i from 1 to m. The width of a sequence is defined as max_{1 β€ i < m} \left(p_{i + 1} - p_i\right).
Please help your classmate to identify the beautiful sequence with the maximum width. Your classmate promised you that for the given strings s and t there is at least one beautiful sequence.
Input
The first input line contains two integers n and m (2 β€ m β€ n β€ 2 β
10^5) β the lengths of the strings s and t.
The following line contains a single string s of length n, consisting of lowercase letters of the Latin alphabet.
The last line contains a single string t of length m, consisting of lowercase letters of the Latin alphabet.
It is guaranteed that there is at least one beautiful sequence for the given strings.
Output
Output one integer β the maximum width of a beautiful sequence.
Examples
Input
5 3
abbbc
abc
Output
3
Input
5 2
aaaaa
aa
Output
4
Input
5 5
abcdf
abcdf
Output
1
Input
2 2
ab
ab
Output
1
Note
In the first example there are two beautiful sequences of width 3: they are \{1, 2, 5\} and \{1, 4, 5\}.
In the second example the beautiful sequence with the maximum width is \{1, 5\}.
In the third example there is exactly one beautiful sequence β it is \{1, 2, 3, 4, 5\}.
In the fourth example there is exactly one beautiful sequence β it is \{1, 2\}.
Submitted Solution:
```
# cook your dish here
n,m=map(int,input().split())
s=input()
t=input()
forward=[]
cur=0
curr=0
while curr<len(s) and cur<len(t):
if s[curr]==t[cur]:
forward.append(curr)
cur+=1
curr+=1
backward=[]
cur=len(s)-1
curr=len(t)-1
while cur>=0 and curr>=0:
if s[cur]==t[curr]:
backward.append(cur)
curr-=1
cur-=1
backward=backward[::-1]
ans=0
for i in range(1,len(t)):
ans=max(ans,backward[i]-forward[i-1],forward[i]-backward[i-1])
print(ans)
``` | instruction | 0 | 47,248 | 0 | 94,496 |
Yes | output | 1 | 47,248 | 0 | 94,497 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your classmate, whom you do not like because he is boring, but whom you respect for his intellect, has two strings: s of length n and t of length m.
A sequence p_1, p_2, β¦, p_m, where 1 β€ p_1 < p_2 < β¦ < p_m β€ n, is called beautiful, if s_{p_i} = t_i for all i from 1 to m. The width of a sequence is defined as max_{1 β€ i < m} \left(p_{i + 1} - p_i\right).
Please help your classmate to identify the beautiful sequence with the maximum width. Your classmate promised you that for the given strings s and t there is at least one beautiful sequence.
Input
The first input line contains two integers n and m (2 β€ m β€ n β€ 2 β
10^5) β the lengths of the strings s and t.
The following line contains a single string s of length n, consisting of lowercase letters of the Latin alphabet.
The last line contains a single string t of length m, consisting of lowercase letters of the Latin alphabet.
It is guaranteed that there is at least one beautiful sequence for the given strings.
Output
Output one integer β the maximum width of a beautiful sequence.
Examples
Input
5 3
abbbc
abc
Output
3
Input
5 2
aaaaa
aa
Output
4
Input
5 5
abcdf
abcdf
Output
1
Input
2 2
ab
ab
Output
1
Note
In the first example there are two beautiful sequences of width 3: they are \{1, 2, 5\} and \{1, 4, 5\}.
In the second example the beautiful sequence with the maximum width is \{1, 5\}.
In the third example there is exactly one beautiful sequence β it is \{1, 2, 3, 4, 5\}.
In the fourth example there is exactly one beautiful sequence β it is \{1, 2\}.
Submitted Solution:
```
import sys
from queue import PriorityQueue
input = sys.stdin.readline
def get_ret_1(n, m, s, t):
cache = {c: dict(max=-1, min=200001) for c in t}
for idx in range(n):
c = s[idx]
d = cache.get(c)
if d is None:
continue
d['max'] = max(d['max'], idx)
d['min'] = min(d['min'], idx)
prev_d = cache[t[0]]
result = -1
for idx in range(1, m):
c = t[idx]
d = cache[c]
result = max(result, abs(prev_d['min'] - d['max']))
prev_d = d
return result
def get_ret_2(n, m, s, t):
s_left = t_left = 0
s_right = n - 1
t_right = m - 1
prev_left = prev_right = -1
ret = -1
while t_left <= t_right:
is_same = t_left == t_right
while True:
if s[s_left] == t[t_left]:
if prev_left == -1:
prev_left = s_left
else:
if is_same:
ret = max(ret, prev_right - s_left)
else:
ret = max(ret, s_left - prev_left)
prev_left = s_left
t_left += 1
break
s_left += 1
while True:
if s[s_right] == t[t_right]:
if prev_right == -1:
prev_right = s_right
else:
if is_same:
ret = max(ret, s_right - prev_left)
else:
ret = max(ret, prev_right - s_right)
prev_right = s_right
t_right -= 1
break
s_right -= 1
if ret == -1:
return s_right - s_left
return ret
def main():
n, m = map(int, input().split())
s = input().strip()
t = input().strip()
print(get_ret_2(n, m, s, t))
if __name__ == '__main__':
main()
``` | instruction | 0 | 47,249 | 0 | 94,498 |
No | output | 1 | 47,249 | 0 | 94,499 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your classmate, whom you do not like because he is boring, but whom you respect for his intellect, has two strings: s of length n and t of length m.
A sequence p_1, p_2, β¦, p_m, where 1 β€ p_1 < p_2 < β¦ < p_m β€ n, is called beautiful, if s_{p_i} = t_i for all i from 1 to m. The width of a sequence is defined as max_{1 β€ i < m} \left(p_{i + 1} - p_i\right).
Please help your classmate to identify the beautiful sequence with the maximum width. Your classmate promised you that for the given strings s and t there is at least one beautiful sequence.
Input
The first input line contains two integers n and m (2 β€ m β€ n β€ 2 β
10^5) β the lengths of the strings s and t.
The following line contains a single string s of length n, consisting of lowercase letters of the Latin alphabet.
The last line contains a single string t of length m, consisting of lowercase letters of the Latin alphabet.
It is guaranteed that there is at least one beautiful sequence for the given strings.
Output
Output one integer β the maximum width of a beautiful sequence.
Examples
Input
5 3
abbbc
abc
Output
3
Input
5 2
aaaaa
aa
Output
4
Input
5 5
abcdf
abcdf
Output
1
Input
2 2
ab
ab
Output
1
Note
In the first example there are two beautiful sequences of width 3: they are \{1, 2, 5\} and \{1, 4, 5\}.
In the second example the beautiful sequence with the maximum width is \{1, 5\}.
In the third example there is exactly one beautiful sequence β it is \{1, 2, 3, 4, 5\}.
In the fourth example there is exactly one beautiful sequence β it is \{1, 2\}.
Submitted Solution:
```
from os import path;import sys,time
mod = int(1e9 + 7)
from math import ceil, floor,gcd,log,log2 ,factorial,sqrt
from collections import defaultdict ,Counter , OrderedDict , deque;from itertools import combinations,permutations , groupby
# from string import ascii_lowercase ,ascii_uppercase
from bisect import *;from functools import reduce;from operator import mul;maxx = float('inf')
I = lambda :int(sys.stdin.buffer.readline())
lint = lambda :[int(x) for x in sys.stdin.buffer.readline().split()]
S = lambda: sys.stdin.readline().strip('\n')
localsys = 0
start_time = time.time()
#left shift --- num*(2**k) --(k - shift)
nCr = lambda n, r: reduce(mul, range(n - r + 1, n + 1), 1) // factorial(r)
def ceill(n,x):
return (n+x -1 )//x
T =0
def solve():
n , m = map(int , input().split())
s = input().strip() ; t = input().strip()
if len(set(s)) == len(set(t)) == 1:
return print(n-1)
c , ok , ans =0 , True , 1
f , l = None , None
for i in range(n):
if s[i] == t[c]:
if not f:
f = i
l = i
else:
if ok :
ans = max(ans , l- f)
ok = False
ar = [f , l]
else:
ans = max(ans , l- f , l - ar[-1] , l -ar[-2])
f = i
c+=1
if c == m :
c-=1
print(ans)
def run():
if (path.exists('input.txt')):
sys.stdin=open('input.txt','r')
sys.stdout=open('output.txt','w')
localsys = 1
run()
T = I() if T else 1
for _ in range(T):
solve()
if localsys:
print("\n\nTime Elased :",time.time() - start_time,"seconds")
``` | instruction | 0 | 47,250 | 0 | 94,500 |
No | output | 1 | 47,250 | 0 | 94,501 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your classmate, whom you do not like because he is boring, but whom you respect for his intellect, has two strings: s of length n and t of length m.
A sequence p_1, p_2, β¦, p_m, where 1 β€ p_1 < p_2 < β¦ < p_m β€ n, is called beautiful, if s_{p_i} = t_i for all i from 1 to m. The width of a sequence is defined as max_{1 β€ i < m} \left(p_{i + 1} - p_i\right).
Please help your classmate to identify the beautiful sequence with the maximum width. Your classmate promised you that for the given strings s and t there is at least one beautiful sequence.
Input
The first input line contains two integers n and m (2 β€ m β€ n β€ 2 β
10^5) β the lengths of the strings s and t.
The following line contains a single string s of length n, consisting of lowercase letters of the Latin alphabet.
The last line contains a single string t of length m, consisting of lowercase letters of the Latin alphabet.
It is guaranteed that there is at least one beautiful sequence for the given strings.
Output
Output one integer β the maximum width of a beautiful sequence.
Examples
Input
5 3
abbbc
abc
Output
3
Input
5 2
aaaaa
aa
Output
4
Input
5 5
abcdf
abcdf
Output
1
Input
2 2
ab
ab
Output
1
Note
In the first example there are two beautiful sequences of width 3: they are \{1, 2, 5\} and \{1, 4, 5\}.
In the second example the beautiful sequence with the maximum width is \{1, 5\}.
In the third example there is exactly one beautiful sequence β it is \{1, 2, 3, 4, 5\}.
In the fourth example there is exactly one beautiful sequence β it is \{1, 2\}.
Submitted Solution:
```
n, m = map(int,input().split())
s = input()
t = input()
j = 0
indices ={i:[] for i in list(set(s))}
for i in range(n):
indices[s[i]].append(i)
memo = []
index = indices[t[m-1]]
a = index[-1]
b = index[0]
memo.append([a,b])
for i in range(m-2, -1, -1):
index = indices[t[i]]
j = 0
a = index[0]
while j < len(index) and index[j] < b:
j += 1
b = index[j-1]
memo.append([a,b])
ans = []
memo = memo[::-1]
for i in range(m-1):
ans.append(memo[i+1][1] - memo[i][0])
print(max(ans))
``` | instruction | 0 | 47,251 | 0 | 94,502 |
No | output | 1 | 47,251 | 0 | 94,503 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your classmate, whom you do not like because he is boring, but whom you respect for his intellect, has two strings: s of length n and t of length m.
A sequence p_1, p_2, β¦, p_m, where 1 β€ p_1 < p_2 < β¦ < p_m β€ n, is called beautiful, if s_{p_i} = t_i for all i from 1 to m. The width of a sequence is defined as max_{1 β€ i < m} \left(p_{i + 1} - p_i\right).
Please help your classmate to identify the beautiful sequence with the maximum width. Your classmate promised you that for the given strings s and t there is at least one beautiful sequence.
Input
The first input line contains two integers n and m (2 β€ m β€ n β€ 2 β
10^5) β the lengths of the strings s and t.
The following line contains a single string s of length n, consisting of lowercase letters of the Latin alphabet.
The last line contains a single string t of length m, consisting of lowercase letters of the Latin alphabet.
It is guaranteed that there is at least one beautiful sequence for the given strings.
Output
Output one integer β the maximum width of a beautiful sequence.
Examples
Input
5 3
abbbc
abc
Output
3
Input
5 2
aaaaa
aa
Output
4
Input
5 5
abcdf
abcdf
Output
1
Input
2 2
ab
ab
Output
1
Note
In the first example there are two beautiful sequences of width 3: they are \{1, 2, 5\} and \{1, 4, 5\}.
In the second example the beautiful sequence with the maximum width is \{1, 5\}.
In the third example there is exactly one beautiful sequence β it is \{1, 2, 3, 4, 5\}.
In the fourth example there is exactly one beautiful sequence β it is \{1, 2\}.
Submitted Solution:
```
n,m = map(int, input().split())
s = input()
t = input()
w = 0
si = 0
startsi = 0
p = []
for ti in range(m):
si = s.find(t[ti], startsi)
p.append(si)
startsi = si+1
p[m-1] = s.rfind(t[m-1])
for i in range(1, len(p)):
if abs(p[i] - p[i-1]) > w:
w = abs(p[i] - p[i-1])
si = n
startsi = n
p = []
for ti in range(m-1, -1, -1):
si = s.rfind(t[ti], 0, startsi)
p.append(si)
startsi = si
p[m-1] = s.find(t[0])
for i in range(1, len(p)):
if abs(p[i] - p[i-1]) > w:
w = abs(p[i] - p[i-1])
print(w)
``` | instruction | 0 | 47,252 | 0 | 94,504 |
No | output | 1 | 47,252 | 0 | 94,505 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya became interested in bioinformatics. He's going to write an article about similar cyclic DNA sequences, so he invented a new method for determining the similarity of cyclic sequences.
Let's assume that strings s and t have the same length n, then the function h(s, t) is defined as the number of positions in which the respective symbols of s and t are the same. Function h(s, t) can be used to define the function of Vasya distance Ο(s, t):
<image> where <image> is obtained from string s, by applying left circular shift i times. For example, Ο("AGC", "CGT") = h("AGC", "CGT") + h("AGC", "GTC") + h("AGC", "TCG") + h("GCA", "CGT") + h("GCA", "GTC") + h("GCA", "TCG") + h("CAG", "CGT") + h("CAG", "GTC") + h("CAG", "TCG") = 1 + 1 + 0 + 0 + 1 + 1 + 1 + 0 + 1 = 6
Vasya found a string s of length n on the Internet. Now he wants to count how many strings t there are such that the Vasya distance from the string s attains maximum possible value. Formally speaking, t must satisfy the equation: <image>.
Vasya could not try all possible strings to find an answer, so he needs your help. As the answer may be very large, count the number of such strings modulo 109 + 7.
Input
The first line of the input contains a single integer n (1 β€ n β€ 105).
The second line of the input contains a single string of length n, consisting of characters "ACGT".
Output
Print a single number β the answer modulo 109 + 7.
Examples
Input
1
C
Output
1
Input
2
AG
Output
4
Input
3
TTT
Output
1
Note
Please note that if for two distinct strings t1 and t2 values Ο(s, t1) ΠΈ Ο(s, t2) are maximum among all possible t, then both strings must be taken into account in the answer even if one of them can be obtained by a circular shift of another one.
In the first sample, there is Ο("C", "C") = 1, for the remaining strings t of length 1 the value of Ο(s, t) is 0.
In the second sample, Ο("AG", "AG") = Ο("AG", "GA") = Ο("AG", "AA") = Ο("AG", "GG") = 4.
In the third sample, Ο("TTT", "TTT") = 27 | instruction | 0 | 47,446 | 0 | 94,892 |
Tags: math, strings
Correct Solution:
```
from collections import Counter
n = int(input())
c = Counter(input())
commons = c.most_common()
max_cnt = 0
for x in commons:
if commons[0][1] == x[1]:
max_cnt += 1
ans = 1
for i in range(n):
ans *= max_cnt
ans = ans % (1000000007)
print(ans)
``` | output | 1 | 47,446 | 0 | 94,893 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya became interested in bioinformatics. He's going to write an article about similar cyclic DNA sequences, so he invented a new method for determining the similarity of cyclic sequences.
Let's assume that strings s and t have the same length n, then the function h(s, t) is defined as the number of positions in which the respective symbols of s and t are the same. Function h(s, t) can be used to define the function of Vasya distance Ο(s, t):
<image> where <image> is obtained from string s, by applying left circular shift i times. For example, Ο("AGC", "CGT") = h("AGC", "CGT") + h("AGC", "GTC") + h("AGC", "TCG") + h("GCA", "CGT") + h("GCA", "GTC") + h("GCA", "TCG") + h("CAG", "CGT") + h("CAG", "GTC") + h("CAG", "TCG") = 1 + 1 + 0 + 0 + 1 + 1 + 1 + 0 + 1 = 6
Vasya found a string s of length n on the Internet. Now he wants to count how many strings t there are such that the Vasya distance from the string s attains maximum possible value. Formally speaking, t must satisfy the equation: <image>.
Vasya could not try all possible strings to find an answer, so he needs your help. As the answer may be very large, count the number of such strings modulo 109 + 7.
Input
The first line of the input contains a single integer n (1 β€ n β€ 105).
The second line of the input contains a single string of length n, consisting of characters "ACGT".
Output
Print a single number β the answer modulo 109 + 7.
Examples
Input
1
C
Output
1
Input
2
AG
Output
4
Input
3
TTT
Output
1
Note
Please note that if for two distinct strings t1 and t2 values Ο(s, t1) ΠΈ Ο(s, t2) are maximum among all possible t, then both strings must be taken into account in the answer even if one of them can be obtained by a circular shift of another one.
In the first sample, there is Ο("C", "C") = 1, for the remaining strings t of length 1 the value of Ο(s, t) is 0.
In the second sample, Ο("AG", "AG") = Ο("AG", "GA") = Ο("AG", "AA") = Ο("AG", "GG") = 4.
In the third sample, Ο("TTT", "TTT") = 27 | instruction | 0 | 47,447 | 0 | 94,894 |
Tags: math, strings
Correct Solution:
```
n = int(input())
s = input()
a = s.count('A')
c = s.count('C')
g = s.count('G')
t = s.count('T')
q = max(a,c,g,t)
cnt = [a,c,g,t].count(q)
print(pow(cnt, n, 1000000007))
``` | output | 1 | 47,447 | 0 | 94,895 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya became interested in bioinformatics. He's going to write an article about similar cyclic DNA sequences, so he invented a new method for determining the similarity of cyclic sequences.
Let's assume that strings s and t have the same length n, then the function h(s, t) is defined as the number of positions in which the respective symbols of s and t are the same. Function h(s, t) can be used to define the function of Vasya distance Ο(s, t):
<image> where <image> is obtained from string s, by applying left circular shift i times. For example, Ο("AGC", "CGT") = h("AGC", "CGT") + h("AGC", "GTC") + h("AGC", "TCG") + h("GCA", "CGT") + h("GCA", "GTC") + h("GCA", "TCG") + h("CAG", "CGT") + h("CAG", "GTC") + h("CAG", "TCG") = 1 + 1 + 0 + 0 + 1 + 1 + 1 + 0 + 1 = 6
Vasya found a string s of length n on the Internet. Now he wants to count how many strings t there are such that the Vasya distance from the string s attains maximum possible value. Formally speaking, t must satisfy the equation: <image>.
Vasya could not try all possible strings to find an answer, so he needs your help. As the answer may be very large, count the number of such strings modulo 109 + 7.
Input
The first line of the input contains a single integer n (1 β€ n β€ 105).
The second line of the input contains a single string of length n, consisting of characters "ACGT".
Output
Print a single number β the answer modulo 109 + 7.
Examples
Input
1
C
Output
1
Input
2
AG
Output
4
Input
3
TTT
Output
1
Note
Please note that if for two distinct strings t1 and t2 values Ο(s, t1) ΠΈ Ο(s, t2) are maximum among all possible t, then both strings must be taken into account in the answer even if one of them can be obtained by a circular shift of another one.
In the first sample, there is Ο("C", "C") = 1, for the remaining strings t of length 1 the value of Ο(s, t) is 0.
In the second sample, Ο("AG", "AG") = Ο("AG", "GA") = Ο("AG", "AA") = Ο("AG", "GG") = 4.
In the third sample, Ο("TTT", "TTT") = 27 | instruction | 0 | 47,448 | 0 | 94,896 |
Tags: math, strings
Correct Solution:
```
n = int(input())
s = input()
l = [s.count('A'), s.count('C'), s.count('G'), s.count('T')]
print((l.count(max(l)) ** n) % 1000000007)
``` | output | 1 | 47,448 | 0 | 94,897 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya became interested in bioinformatics. He's going to write an article about similar cyclic DNA sequences, so he invented a new method for determining the similarity of cyclic sequences.
Let's assume that strings s and t have the same length n, then the function h(s, t) is defined as the number of positions in which the respective symbols of s and t are the same. Function h(s, t) can be used to define the function of Vasya distance Ο(s, t):
<image> where <image> is obtained from string s, by applying left circular shift i times. For example, Ο("AGC", "CGT") = h("AGC", "CGT") + h("AGC", "GTC") + h("AGC", "TCG") + h("GCA", "CGT") + h("GCA", "GTC") + h("GCA", "TCG") + h("CAG", "CGT") + h("CAG", "GTC") + h("CAG", "TCG") = 1 + 1 + 0 + 0 + 1 + 1 + 1 + 0 + 1 = 6
Vasya found a string s of length n on the Internet. Now he wants to count how many strings t there are such that the Vasya distance from the string s attains maximum possible value. Formally speaking, t must satisfy the equation: <image>.
Vasya could not try all possible strings to find an answer, so he needs your help. As the answer may be very large, count the number of such strings modulo 109 + 7.
Input
The first line of the input contains a single integer n (1 β€ n β€ 105).
The second line of the input contains a single string of length n, consisting of characters "ACGT".
Output
Print a single number β the answer modulo 109 + 7.
Examples
Input
1
C
Output
1
Input
2
AG
Output
4
Input
3
TTT
Output
1
Note
Please note that if for two distinct strings t1 and t2 values Ο(s, t1) ΠΈ Ο(s, t2) are maximum among all possible t, then both strings must be taken into account in the answer even if one of them can be obtained by a circular shift of another one.
In the first sample, there is Ο("C", "C") = 1, for the remaining strings t of length 1 the value of Ο(s, t) is 0.
In the second sample, Ο("AG", "AG") = Ο("AG", "GA") = Ο("AG", "AA") = Ο("AG", "GG") = 4.
In the third sample, Ο("TTT", "TTT") = 27 | instruction | 0 | 47,449 | 0 | 94,898 |
Tags: math, strings
Correct Solution:
```
# problem statement: https://codeforces.com/problemset/problem/520/C
modulo = 1000000007
n = int(input())
char_count = [0] * 256
s = input()
for i in range(n):
char_count[ord(s[i])] += 1
max_char_count = max(char_count)
num_max_char = 0
for i in range(256):
if char_count[i] == max_char_count:
num_max_char += 1
print(pow(num_max_char, n) % modulo)
``` | output | 1 | 47,449 | 0 | 94,899 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya became interested in bioinformatics. He's going to write an article about similar cyclic DNA sequences, so he invented a new method for determining the similarity of cyclic sequences.
Let's assume that strings s and t have the same length n, then the function h(s, t) is defined as the number of positions in which the respective symbols of s and t are the same. Function h(s, t) can be used to define the function of Vasya distance Ο(s, t):
<image> where <image> is obtained from string s, by applying left circular shift i times. For example, Ο("AGC", "CGT") = h("AGC", "CGT") + h("AGC", "GTC") + h("AGC", "TCG") + h("GCA", "CGT") + h("GCA", "GTC") + h("GCA", "TCG") + h("CAG", "CGT") + h("CAG", "GTC") + h("CAG", "TCG") = 1 + 1 + 0 + 0 + 1 + 1 + 1 + 0 + 1 = 6
Vasya found a string s of length n on the Internet. Now he wants to count how many strings t there are such that the Vasya distance from the string s attains maximum possible value. Formally speaking, t must satisfy the equation: <image>.
Vasya could not try all possible strings to find an answer, so he needs your help. As the answer may be very large, count the number of such strings modulo 109 + 7.
Input
The first line of the input contains a single integer n (1 β€ n β€ 105).
The second line of the input contains a single string of length n, consisting of characters "ACGT".
Output
Print a single number β the answer modulo 109 + 7.
Examples
Input
1
C
Output
1
Input
2
AG
Output
4
Input
3
TTT
Output
1
Note
Please note that if for two distinct strings t1 and t2 values Ο(s, t1) ΠΈ Ο(s, t2) are maximum among all possible t, then both strings must be taken into account in the answer even if one of them can be obtained by a circular shift of another one.
In the first sample, there is Ο("C", "C") = 1, for the remaining strings t of length 1 the value of Ο(s, t) is 0.
In the second sample, Ο("AG", "AG") = Ο("AG", "GA") = Ο("AG", "AA") = Ο("AG", "GG") = 4.
In the third sample, Ο("TTT", "TTT") = 27 | instruction | 0 | 47,450 | 0 | 94,900 |
Tags: math, strings
Correct Solution:
```
x = int(input())
y = input()
a, b, c, d = y.count('A'), y.count('C'), y.count('G'), y.count('T')
z=[a,b,c,d]
z.sort()
z.reverse()
same = 1
if z[0] == z[1]:
same = 2
if z[1] == z[2]:
same = 3
if z[2] == z[3]:
same = 4
print(pow(same, x, 10**9+7))
``` | output | 1 | 47,450 | 0 | 94,901 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya became interested in bioinformatics. He's going to write an article about similar cyclic DNA sequences, so he invented a new method for determining the similarity of cyclic sequences.
Let's assume that strings s and t have the same length n, then the function h(s, t) is defined as the number of positions in which the respective symbols of s and t are the same. Function h(s, t) can be used to define the function of Vasya distance Ο(s, t):
<image> where <image> is obtained from string s, by applying left circular shift i times. For example, Ο("AGC", "CGT") = h("AGC", "CGT") + h("AGC", "GTC") + h("AGC", "TCG") + h("GCA", "CGT") + h("GCA", "GTC") + h("GCA", "TCG") + h("CAG", "CGT") + h("CAG", "GTC") + h("CAG", "TCG") = 1 + 1 + 0 + 0 + 1 + 1 + 1 + 0 + 1 = 6
Vasya found a string s of length n on the Internet. Now he wants to count how many strings t there are such that the Vasya distance from the string s attains maximum possible value. Formally speaking, t must satisfy the equation: <image>.
Vasya could not try all possible strings to find an answer, so he needs your help. As the answer may be very large, count the number of such strings modulo 109 + 7.
Input
The first line of the input contains a single integer n (1 β€ n β€ 105).
The second line of the input contains a single string of length n, consisting of characters "ACGT".
Output
Print a single number β the answer modulo 109 + 7.
Examples
Input
1
C
Output
1
Input
2
AG
Output
4
Input
3
TTT
Output
1
Note
Please note that if for two distinct strings t1 and t2 values Ο(s, t1) ΠΈ Ο(s, t2) are maximum among all possible t, then both strings must be taken into account in the answer even if one of them can be obtained by a circular shift of another one.
In the first sample, there is Ο("C", "C") = 1, for the remaining strings t of length 1 the value of Ο(s, t) is 0.
In the second sample, Ο("AG", "AG") = Ο("AG", "GA") = Ο("AG", "AA") = Ο("AG", "GG") = 4.
In the third sample, Ο("TTT", "TTT") = 27 | instruction | 0 | 47,451 | 0 | 94,902 |
Tags: math, strings
Correct Solution:
```
n = int(input()) #input
s = input()
MOD = 1000000007
A = s.count('A')
C = s.count('C')
G = s.count('G')
T = s.count('T')
m = max(A, C, G, T)
count = (A == m) + (C == m) + (G == m) + (T == m)
print ((count**n) % MOD)
``` | output | 1 | 47,451 | 0 | 94,903 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya became interested in bioinformatics. He's going to write an article about similar cyclic DNA sequences, so he invented a new method for determining the similarity of cyclic sequences.
Let's assume that strings s and t have the same length n, then the function h(s, t) is defined as the number of positions in which the respective symbols of s and t are the same. Function h(s, t) can be used to define the function of Vasya distance Ο(s, t):
<image> where <image> is obtained from string s, by applying left circular shift i times. For example, Ο("AGC", "CGT") = h("AGC", "CGT") + h("AGC", "GTC") + h("AGC", "TCG") + h("GCA", "CGT") + h("GCA", "GTC") + h("GCA", "TCG") + h("CAG", "CGT") + h("CAG", "GTC") + h("CAG", "TCG") = 1 + 1 + 0 + 0 + 1 + 1 + 1 + 0 + 1 = 6
Vasya found a string s of length n on the Internet. Now he wants to count how many strings t there are such that the Vasya distance from the string s attains maximum possible value. Formally speaking, t must satisfy the equation: <image>.
Vasya could not try all possible strings to find an answer, so he needs your help. As the answer may be very large, count the number of such strings modulo 109 + 7.
Input
The first line of the input contains a single integer n (1 β€ n β€ 105).
The second line of the input contains a single string of length n, consisting of characters "ACGT".
Output
Print a single number β the answer modulo 109 + 7.
Examples
Input
1
C
Output
1
Input
2
AG
Output
4
Input
3
TTT
Output
1
Note
Please note that if for two distinct strings t1 and t2 values Ο(s, t1) ΠΈ Ο(s, t2) are maximum among all possible t, then both strings must be taken into account in the answer even if one of them can be obtained by a circular shift of another one.
In the first sample, there is Ο("C", "C") = 1, for the remaining strings t of length 1 the value of Ο(s, t) is 0.
In the second sample, Ο("AG", "AG") = Ο("AG", "GA") = Ο("AG", "AA") = Ο("AG", "GG") = 4.
In the third sample, Ο("TTT", "TTT") = 27 | instruction | 0 | 47,452 | 0 | 94,904 |
Tags: math, strings
Correct Solution:
```
n = int(input().rstrip())
s = str(input().rstrip())
kol = 0
mx = 0
mas = [0] * 4
for i in range(n):
if s[i] == 'A': mas[0] += 1
if s[i] == 'C': mas[1] += 1
if s[i] == 'G': mas[2] += 1
if s[i] == 'T': mas[3] += 1
mx = max(mas)
kol = mas.count(mx)
print(kol ** n % 1000000007)
``` | output | 1 | 47,452 | 0 | 94,905 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya became interested in bioinformatics. He's going to write an article about similar cyclic DNA sequences, so he invented a new method for determining the similarity of cyclic sequences.
Let's assume that strings s and t have the same length n, then the function h(s, t) is defined as the number of positions in which the respective symbols of s and t are the same. Function h(s, t) can be used to define the function of Vasya distance Ο(s, t):
<image> where <image> is obtained from string s, by applying left circular shift i times. For example, Ο("AGC", "CGT") = h("AGC", "CGT") + h("AGC", "GTC") + h("AGC", "TCG") + h("GCA", "CGT") + h("GCA", "GTC") + h("GCA", "TCG") + h("CAG", "CGT") + h("CAG", "GTC") + h("CAG", "TCG") = 1 + 1 + 0 + 0 + 1 + 1 + 1 + 0 + 1 = 6
Vasya found a string s of length n on the Internet. Now he wants to count how many strings t there are such that the Vasya distance from the string s attains maximum possible value. Formally speaking, t must satisfy the equation: <image>.
Vasya could not try all possible strings to find an answer, so he needs your help. As the answer may be very large, count the number of such strings modulo 109 + 7.
Input
The first line of the input contains a single integer n (1 β€ n β€ 105).
The second line of the input contains a single string of length n, consisting of characters "ACGT".
Output
Print a single number β the answer modulo 109 + 7.
Examples
Input
1
C
Output
1
Input
2
AG
Output
4
Input
3
TTT
Output
1
Note
Please note that if for two distinct strings t1 and t2 values Ο(s, t1) ΠΈ Ο(s, t2) are maximum among all possible t, then both strings must be taken into account in the answer even if one of them can be obtained by a circular shift of another one.
In the first sample, there is Ο("C", "C") = 1, for the remaining strings t of length 1 the value of Ο(s, t) is 0.
In the second sample, Ο("AG", "AG") = Ο("AG", "GA") = Ο("AG", "AA") = Ο("AG", "GG") = 4.
In the third sample, Ο("TTT", "TTT") = 27 | instruction | 0 | 47,453 | 0 | 94,906 |
Tags: math, strings
Correct Solution:
```
input()
s = input()
k = [s.count(x) for x in 'ACGT']
print(pow(k.count(max(k)), len(s), 10 ** 9 + 7))
``` | output | 1 | 47,453 | 0 | 94,907 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya became interested in bioinformatics. He's going to write an article about similar cyclic DNA sequences, so he invented a new method for determining the similarity of cyclic sequences.
Let's assume that strings s and t have the same length n, then the function h(s, t) is defined as the number of positions in which the respective symbols of s and t are the same. Function h(s, t) can be used to define the function of Vasya distance Ο(s, t):
<image> where <image> is obtained from string s, by applying left circular shift i times. For example, Ο("AGC", "CGT") = h("AGC", "CGT") + h("AGC", "GTC") + h("AGC", "TCG") + h("GCA", "CGT") + h("GCA", "GTC") + h("GCA", "TCG") + h("CAG", "CGT") + h("CAG", "GTC") + h("CAG", "TCG") = 1 + 1 + 0 + 0 + 1 + 1 + 1 + 0 + 1 = 6
Vasya found a string s of length n on the Internet. Now he wants to count how many strings t there are such that the Vasya distance from the string s attains maximum possible value. Formally speaking, t must satisfy the equation: <image>.
Vasya could not try all possible strings to find an answer, so he needs your help. As the answer may be very large, count the number of such strings modulo 109 + 7.
Input
The first line of the input contains a single integer n (1 β€ n β€ 105).
The second line of the input contains a single string of length n, consisting of characters "ACGT".
Output
Print a single number β the answer modulo 109 + 7.
Examples
Input
1
C
Output
1
Input
2
AG
Output
4
Input
3
TTT
Output
1
Note
Please note that if for two distinct strings t1 and t2 values Ο(s, t1) ΠΈ Ο(s, t2) are maximum among all possible t, then both strings must be taken into account in the answer even if one of them can be obtained by a circular shift of another one.
In the first sample, there is Ο("C", "C") = 1, for the remaining strings t of length 1 the value of Ο(s, t) is 0.
In the second sample, Ο("AG", "AG") = Ο("AG", "GA") = Ο("AG", "AA") = Ο("AG", "GG") = 4.
In the third sample, Ο("TTT", "TTT") = 27
Submitted Solution:
```
n=int(input())
s=input()
x=[s.count(i) for i in ['A','C','G','T']]
z=x.count(max(x))
print((z**n)%(10**9+7))
``` | instruction | 0 | 47,454 | 0 | 94,908 |
Yes | output | 1 | 47,454 | 0 | 94,909 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya became interested in bioinformatics. He's going to write an article about similar cyclic DNA sequences, so he invented a new method for determining the similarity of cyclic sequences.
Let's assume that strings s and t have the same length n, then the function h(s, t) is defined as the number of positions in which the respective symbols of s and t are the same. Function h(s, t) can be used to define the function of Vasya distance Ο(s, t):
<image> where <image> is obtained from string s, by applying left circular shift i times. For example, Ο("AGC", "CGT") = h("AGC", "CGT") + h("AGC", "GTC") + h("AGC", "TCG") + h("GCA", "CGT") + h("GCA", "GTC") + h("GCA", "TCG") + h("CAG", "CGT") + h("CAG", "GTC") + h("CAG", "TCG") = 1 + 1 + 0 + 0 + 1 + 1 + 1 + 0 + 1 = 6
Vasya found a string s of length n on the Internet. Now he wants to count how many strings t there are such that the Vasya distance from the string s attains maximum possible value. Formally speaking, t must satisfy the equation: <image>.
Vasya could not try all possible strings to find an answer, so he needs your help. As the answer may be very large, count the number of such strings modulo 109 + 7.
Input
The first line of the input contains a single integer n (1 β€ n β€ 105).
The second line of the input contains a single string of length n, consisting of characters "ACGT".
Output
Print a single number β the answer modulo 109 + 7.
Examples
Input
1
C
Output
1
Input
2
AG
Output
4
Input
3
TTT
Output
1
Note
Please note that if for two distinct strings t1 and t2 values Ο(s, t1) ΠΈ Ο(s, t2) are maximum among all possible t, then both strings must be taken into account in the answer even if one of them can be obtained by a circular shift of another one.
In the first sample, there is Ο("C", "C") = 1, for the remaining strings t of length 1 the value of Ο(s, t) is 0.
In the second sample, Ο("AG", "AG") = Ο("AG", "GA") = Ο("AG", "AA") = Ο("AG", "GG") = 4.
In the third sample, Ο("TTT", "TTT") = 27
Submitted Solution:
```
n = int(input())
s = input()
MOD = 1000000007
A = s.count('A')
C = s.count('C')
G = s.count('G')
T = s.count('T')
m = max(A, C, G, T)
count = (A == m) + (C == m) + (G == m) + (T == m)
print ((count**n) % MOD)
``` | instruction | 0 | 47,455 | 0 | 94,910 |
Yes | output | 1 | 47,455 | 0 | 94,911 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya became interested in bioinformatics. He's going to write an article about similar cyclic DNA sequences, so he invented a new method for determining the similarity of cyclic sequences.
Let's assume that strings s and t have the same length n, then the function h(s, t) is defined as the number of positions in which the respective symbols of s and t are the same. Function h(s, t) can be used to define the function of Vasya distance Ο(s, t):
<image> where <image> is obtained from string s, by applying left circular shift i times. For example, Ο("AGC", "CGT") = h("AGC", "CGT") + h("AGC", "GTC") + h("AGC", "TCG") + h("GCA", "CGT") + h("GCA", "GTC") + h("GCA", "TCG") + h("CAG", "CGT") + h("CAG", "GTC") + h("CAG", "TCG") = 1 + 1 + 0 + 0 + 1 + 1 + 1 + 0 + 1 = 6
Vasya found a string s of length n on the Internet. Now he wants to count how many strings t there are such that the Vasya distance from the string s attains maximum possible value. Formally speaking, t must satisfy the equation: <image>.
Vasya could not try all possible strings to find an answer, so he needs your help. As the answer may be very large, count the number of such strings modulo 109 + 7.
Input
The first line of the input contains a single integer n (1 β€ n β€ 105).
The second line of the input contains a single string of length n, consisting of characters "ACGT".
Output
Print a single number β the answer modulo 109 + 7.
Examples
Input
1
C
Output
1
Input
2
AG
Output
4
Input
3
TTT
Output
1
Note
Please note that if for two distinct strings t1 and t2 values Ο(s, t1) ΠΈ Ο(s, t2) are maximum among all possible t, then both strings must be taken into account in the answer even if one of them can be obtained by a circular shift of another one.
In the first sample, there is Ο("C", "C") = 1, for the remaining strings t of length 1 the value of Ο(s, t) is 0.
In the second sample, Ο("AG", "AG") = Ο("AG", "GA") = Ο("AG", "AA") = Ο("AG", "GG") = 4.
In the third sample, Ο("TTT", "TTT") = 27
Submitted Solution:
```
numero=int(input())
letras = input()
lista=list(letras)
a=lista.count("A")
t=lista.count("T")
g=lista.count("G")
c=lista.count("C")
numeroSig=max(a,t,g,c)
listaACGT=[a,t,g,c]
z=0
for i in listaACGT:
if(i==numeroSig):
z+=1
print(pow(z, numero, 1000000007))
``` | instruction | 0 | 47,456 | 0 | 94,912 |
Yes | output | 1 | 47,456 | 0 | 94,913 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya became interested in bioinformatics. He's going to write an article about similar cyclic DNA sequences, so he invented a new method for determining the similarity of cyclic sequences.
Let's assume that strings s and t have the same length n, then the function h(s, t) is defined as the number of positions in which the respective symbols of s and t are the same. Function h(s, t) can be used to define the function of Vasya distance Ο(s, t):
<image> where <image> is obtained from string s, by applying left circular shift i times. For example, Ο("AGC", "CGT") = h("AGC", "CGT") + h("AGC", "GTC") + h("AGC", "TCG") + h("GCA", "CGT") + h("GCA", "GTC") + h("GCA", "TCG") + h("CAG", "CGT") + h("CAG", "GTC") + h("CAG", "TCG") = 1 + 1 + 0 + 0 + 1 + 1 + 1 + 0 + 1 = 6
Vasya found a string s of length n on the Internet. Now he wants to count how many strings t there are such that the Vasya distance from the string s attains maximum possible value. Formally speaking, t must satisfy the equation: <image>.
Vasya could not try all possible strings to find an answer, so he needs your help. As the answer may be very large, count the number of such strings modulo 109 + 7.
Input
The first line of the input contains a single integer n (1 β€ n β€ 105).
The second line of the input contains a single string of length n, consisting of characters "ACGT".
Output
Print a single number β the answer modulo 109 + 7.
Examples
Input
1
C
Output
1
Input
2
AG
Output
4
Input
3
TTT
Output
1
Note
Please note that if for two distinct strings t1 and t2 values Ο(s, t1) ΠΈ Ο(s, t2) are maximum among all possible t, then both strings must be taken into account in the answer even if one of them can be obtained by a circular shift of another one.
In the first sample, there is Ο("C", "C") = 1, for the remaining strings t of length 1 the value of Ο(s, t) is 0.
In the second sample, Ο("AG", "AG") = Ο("AG", "GA") = Ο("AG", "AA") = Ο("AG", "GG") = 4.
In the third sample, Ο("TTT", "TTT") = 27
Submitted Solution:
```
n, s = int(input()), input()
c = sorted(s.count(b) for b in 'ACGT')
print(c.count(c[-1]) ** n % (10 ** 9 + 7))
# Made By Mostafa_Khaled
``` | instruction | 0 | 47,457 | 0 | 94,914 |
Yes | output | 1 | 47,457 | 0 | 94,915 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya became interested in bioinformatics. He's going to write an article about similar cyclic DNA sequences, so he invented a new method for determining the similarity of cyclic sequences.
Let's assume that strings s and t have the same length n, then the function h(s, t) is defined as the number of positions in which the respective symbols of s and t are the same. Function h(s, t) can be used to define the function of Vasya distance Ο(s, t):
<image> where <image> is obtained from string s, by applying left circular shift i times. For example, Ο("AGC", "CGT") = h("AGC", "CGT") + h("AGC", "GTC") + h("AGC", "TCG") + h("GCA", "CGT") + h("GCA", "GTC") + h("GCA", "TCG") + h("CAG", "CGT") + h("CAG", "GTC") + h("CAG", "TCG") = 1 + 1 + 0 + 0 + 1 + 1 + 1 + 0 + 1 = 6
Vasya found a string s of length n on the Internet. Now he wants to count how many strings t there are such that the Vasya distance from the string s attains maximum possible value. Formally speaking, t must satisfy the equation: <image>.
Vasya could not try all possible strings to find an answer, so he needs your help. As the answer may be very large, count the number of such strings modulo 109 + 7.
Input
The first line of the input contains a single integer n (1 β€ n β€ 105).
The second line of the input contains a single string of length n, consisting of characters "ACGT".
Output
Print a single number β the answer modulo 109 + 7.
Examples
Input
1
C
Output
1
Input
2
AG
Output
4
Input
3
TTT
Output
1
Note
Please note that if for two distinct strings t1 and t2 values Ο(s, t1) ΠΈ Ο(s, t2) are maximum among all possible t, then both strings must be taken into account in the answer even if one of them can be obtained by a circular shift of another one.
In the first sample, there is Ο("C", "C") = 1, for the remaining strings t of length 1 the value of Ο(s, t) is 0.
In the second sample, Ο("AG", "AG") = Ο("AG", "GA") = Ο("AG", "AA") = Ο("AG", "GG") = 4.
In the third sample, Ο("TTT", "TTT") = 27
Submitted Solution:
```
length = int(input())
originalDNA = input()
NumA = 0
NumT = 0
NumC = 0
NumG = 0
for letter in originalDNA:
if letter == 'A':
NumA += 1
elif letter == 'C':
NumC += 1
elif letter == 'G':
NumG += 1
else:
NumT += 1
countnums = [NumA, NumC, NumG, NumT]
totalcount = NumA + NumC + NumG + NumT
alloneDNA = False
for num in countnums:
if totalcount - num == 0:
alloneDNA = True
bignum = 0
test = False
for i in countnums:
if ((i > countnums[0] and countnums[0] > 0) or (i > countnums[1] and countnums[1] > 0) or (i > countnums[2] and countnums[2] > 0) or (i > countnums[3] and countnums[3] > 0)):
print(1)
break
elif alloneDNA:
print(1)
break
else:
if i > bignum:
bignum = i
test = True
continue
if test == True:
print(bignum * length**2)
``` | instruction | 0 | 47,458 | 0 | 94,916 |
No | output | 1 | 47,458 | 0 | 94,917 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya became interested in bioinformatics. He's going to write an article about similar cyclic DNA sequences, so he invented a new method for determining the similarity of cyclic sequences.
Let's assume that strings s and t have the same length n, then the function h(s, t) is defined as the number of positions in which the respective symbols of s and t are the same. Function h(s, t) can be used to define the function of Vasya distance Ο(s, t):
<image> where <image> is obtained from string s, by applying left circular shift i times. For example, Ο("AGC", "CGT") = h("AGC", "CGT") + h("AGC", "GTC") + h("AGC", "TCG") + h("GCA", "CGT") + h("GCA", "GTC") + h("GCA", "TCG") + h("CAG", "CGT") + h("CAG", "GTC") + h("CAG", "TCG") = 1 + 1 + 0 + 0 + 1 + 1 + 1 + 0 + 1 = 6
Vasya found a string s of length n on the Internet. Now he wants to count how many strings t there are such that the Vasya distance from the string s attains maximum possible value. Formally speaking, t must satisfy the equation: <image>.
Vasya could not try all possible strings to find an answer, so he needs your help. As the answer may be very large, count the number of such strings modulo 109 + 7.
Input
The first line of the input contains a single integer n (1 β€ n β€ 105).
The second line of the input contains a single string of length n, consisting of characters "ACGT".
Output
Print a single number β the answer modulo 109 + 7.
Examples
Input
1
C
Output
1
Input
2
AG
Output
4
Input
3
TTT
Output
1
Note
Please note that if for two distinct strings t1 and t2 values Ο(s, t1) ΠΈ Ο(s, t2) are maximum among all possible t, then both strings must be taken into account in the answer even if one of them can be obtained by a circular shift of another one.
In the first sample, there is Ο("C", "C") = 1, for the remaining strings t of length 1 the value of Ο(s, t) is 0.
In the second sample, Ο("AG", "AG") = Ο("AG", "GA") = Ο("AG", "AA") = Ο("AG", "GG") = 4.
In the third sample, Ο("TTT", "TTT") = 27
Submitted Solution:
```
from collections import Counter
n = int(input())
c = Counter(input())
commons = c.most_common()
max_cnt = 0
for x in commons:
if commons[0][1] == x[1]:
max_cnt += x[1]
ans = 1
for i in range(n):
ans *= max_cnt
ans = ans % (1000000007)
print(ans)
``` | instruction | 0 | 47,459 | 0 | 94,918 |
No | output | 1 | 47,459 | 0 | 94,919 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya became interested in bioinformatics. He's going to write an article about similar cyclic DNA sequences, so he invented a new method for determining the similarity of cyclic sequences.
Let's assume that strings s and t have the same length n, then the function h(s, t) is defined as the number of positions in which the respective symbols of s and t are the same. Function h(s, t) can be used to define the function of Vasya distance Ο(s, t):
<image> where <image> is obtained from string s, by applying left circular shift i times. For example, Ο("AGC", "CGT") = h("AGC", "CGT") + h("AGC", "GTC") + h("AGC", "TCG") + h("GCA", "CGT") + h("GCA", "GTC") + h("GCA", "TCG") + h("CAG", "CGT") + h("CAG", "GTC") + h("CAG", "TCG") = 1 + 1 + 0 + 0 + 1 + 1 + 1 + 0 + 1 = 6
Vasya found a string s of length n on the Internet. Now he wants to count how many strings t there are such that the Vasya distance from the string s attains maximum possible value. Formally speaking, t must satisfy the equation: <image>.
Vasya could not try all possible strings to find an answer, so he needs your help. As the answer may be very large, count the number of such strings modulo 109 + 7.
Input
The first line of the input contains a single integer n (1 β€ n β€ 105).
The second line of the input contains a single string of length n, consisting of characters "ACGT".
Output
Print a single number β the answer modulo 109 + 7.
Examples
Input
1
C
Output
1
Input
2
AG
Output
4
Input
3
TTT
Output
1
Note
Please note that if for two distinct strings t1 and t2 values Ο(s, t1) ΠΈ Ο(s, t2) are maximum among all possible t, then both strings must be taken into account in the answer even if one of them can be obtained by a circular shift of another one.
In the first sample, there is Ο("C", "C") = 1, for the remaining strings t of length 1 the value of Ο(s, t) is 0.
In the second sample, Ο("AG", "AG") = Ο("AG", "GA") = Ο("AG", "AA") = Ο("AG", "GG") = 4.
In the third sample, Ο("TTT", "TTT") = 27
Submitted Solution:
```
_, dna = input(), input(); l = [dna.count(x) for x in set(dna)]
print(l.count(l[0]) ** len(dna) % (10**9 + 7))
``` | instruction | 0 | 47,460 | 0 | 94,920 |
No | output | 1 | 47,460 | 0 | 94,921 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya became interested in bioinformatics. He's going to write an article about similar cyclic DNA sequences, so he invented a new method for determining the similarity of cyclic sequences.
Let's assume that strings s and t have the same length n, then the function h(s, t) is defined as the number of positions in which the respective symbols of s and t are the same. Function h(s, t) can be used to define the function of Vasya distance Ο(s, t):
<image> where <image> is obtained from string s, by applying left circular shift i times. For example, Ο("AGC", "CGT") = h("AGC", "CGT") + h("AGC", "GTC") + h("AGC", "TCG") + h("GCA", "CGT") + h("GCA", "GTC") + h("GCA", "TCG") + h("CAG", "CGT") + h("CAG", "GTC") + h("CAG", "TCG") = 1 + 1 + 0 + 0 + 1 + 1 + 1 + 0 + 1 = 6
Vasya found a string s of length n on the Internet. Now he wants to count how many strings t there are such that the Vasya distance from the string s attains maximum possible value. Formally speaking, t must satisfy the equation: <image>.
Vasya could not try all possible strings to find an answer, so he needs your help. As the answer may be very large, count the number of such strings modulo 109 + 7.
Input
The first line of the input contains a single integer n (1 β€ n β€ 105).
The second line of the input contains a single string of length n, consisting of characters "ACGT".
Output
Print a single number β the answer modulo 109 + 7.
Examples
Input
1
C
Output
1
Input
2
AG
Output
4
Input
3
TTT
Output
1
Note
Please note that if for two distinct strings t1 and t2 values Ο(s, t1) ΠΈ Ο(s, t2) are maximum among all possible t, then both strings must be taken into account in the answer even if one of them can be obtained by a circular shift of another one.
In the first sample, there is Ο("C", "C") = 1, for the remaining strings t of length 1 the value of Ο(s, t) is 0.
In the second sample, Ο("AG", "AG") = Ο("AG", "GA") = Ο("AG", "AA") = Ο("AG", "GG") = 4.
In the third sample, Ο("TTT", "TTT") = 27
Submitted Solution:
```
n = int(input())
s = input()
lst = {'A' : 0, 'C' : 0, 'G' : 0, 'T' : 0}
k, l = 0, 1
for i in s:
lst[i] += 1
if k < lst[i]:
k = lst[i]
l = 1
else:
if k == lst[i]:
l += 1
print(l ** n)
``` | instruction | 0 | 47,461 | 0 | 94,922 |
No | output | 1 | 47,461 | 0 | 94,923 |
Provide tags and a correct Python 3 solution for this coding contest problem.
zscoder loves simple strings! A string t is called simple if every pair of adjacent characters are distinct. For example ab, aba, zscoder are simple whereas aa, add are not simple.
zscoder is given a string s. He wants to change a minimum number of characters so that the string s becomes simple. Help him with this task!
Input
The only line contains the string s (1 β€ |s| β€ 2Β·105) β the string given to zscoder. The string s consists of only lowercase English letters.
Output
Print the simple string s' β the string s after the minimal number of changes. If there are multiple solutions, you may output any of them.
Note that the string s' should also consist of only lowercase English letters.
Examples
Input
aab
Output
bab
Input
caaab
Output
cabab
Input
zscoder
Output
zscoder | instruction | 0 | 47,518 | 0 | 95,036 |
Tags: dp, greedy, strings
Correct Solution:
```
a = list(input())
if(len(a)>2):
for i in range(1,len(a)-1):
if(a[i]==a[i-1] and a[i]==a[i+1]):
for j in range(97,123):
if(a[i-1]!=chr(j) and a[i+1]!=chr(j)):
a[i] = chr(j)
break
for i in range(1,len(a)-1):
if(a[i]==a[i-1] and a[i]!=a[i+1]):
for j in range(97,123):
if(a[i-1]!=chr(j) and a[i+1]!=chr(j)):
a[i] = chr(j)
break
elif(a[i]!=a[i-1] and a[i]==a[i+1]):
for j in range(97,123):
if(a[i-1]!=chr(j) and a[i+1]!=chr(j)):
a[i] = chr(j)
break
print(''.join(a))
elif(len(a)==1):
print(''.join(a))
else:
if(a[0]==a[1]):
for j in range(97,123):
if(a[0]!=chr(j)):
a[1] = chr(j)
break
print(''.join(a))
else:
print(''.join(a))
``` | output | 1 | 47,518 | 0 | 95,037 |
Provide tags and a correct Python 3 solution for this coding contest problem.
zscoder loves simple strings! A string t is called simple if every pair of adjacent characters are distinct. For example ab, aba, zscoder are simple whereas aa, add are not simple.
zscoder is given a string s. He wants to change a minimum number of characters so that the string s becomes simple. Help him with this task!
Input
The only line contains the string s (1 β€ |s| β€ 2Β·105) β the string given to zscoder. The string s consists of only lowercase English letters.
Output
Print the simple string s' β the string s after the minimal number of changes. If there are multiple solutions, you may output any of them.
Note that the string s' should also consist of only lowercase English letters.
Examples
Input
aab
Output
bab
Input
caaab
Output
cabab
Input
zscoder
Output
zscoder | instruction | 0 | 47,519 | 0 | 95,038 |
Tags: dp, greedy, strings
Correct Solution:
```
s = input()
mini = "qwertyuiopasdfghjklzxcvbnm"
res = list(s)
def change(ind) :
global res, mini
for j in mini :
if ind == 0 and j != s[ind+1] :
res[ind] = j
return
elif ind == len(s) - 1 and j != res[ind-1] :
res[ind] = j
return
elif j != res[ind-1] and j != s[ind+1] :
res[ind] = j
return
res[ind] = s[ind]
change(ind+1)
if len(s) == 1 : res = s
else :
i = 0
while i < len(s) :
if i + 2 < len(s) and s[i] == s[i+1] and s[i] == s[i+2] :
res[i] = s[i]
change(i+1)
i += 1
elif i + 1 < len(s) and s[i] == s[i+1] :
change(i)
elif res[i-1] == s[i-1] : res[i] = s[i]
i += 1
print("".join(res))
``` | output | 1 | 47,519 | 0 | 95,039 |
Provide tags and a correct Python 3 solution for this coding contest problem.
zscoder loves simple strings! A string t is called simple if every pair of adjacent characters are distinct. For example ab, aba, zscoder are simple whereas aa, add are not simple.
zscoder is given a string s. He wants to change a minimum number of characters so that the string s becomes simple. Help him with this task!
Input
The only line contains the string s (1 β€ |s| β€ 2Β·105) β the string given to zscoder. The string s consists of only lowercase English letters.
Output
Print the simple string s' β the string s after the minimal number of changes. If there are multiple solutions, you may output any of them.
Note that the string s' should also consist of only lowercase English letters.
Examples
Input
aab
Output
bab
Input
caaab
Output
cabab
Input
zscoder
Output
zscoder | instruction | 0 | 47,520 | 0 | 95,040 |
Tags: dp, greedy, strings
Correct Solution:
```
def get_next_char(char):
return "a" if char == "z" else chr(ord(char) + 1)
string_array = []
string_array.extend(input())
for i in range(1,len(string_array)-1):
char = string_array[i]
prev_char = string_array[i-1]
next_char = string_array[i+1]
if char == prev_char:
# z back to a
char = get_next_char(char)
if char == next_char:
char = get_next_char(char)
string_array[i] = char
if len(string_array) >= 2 and string_array[-1] == string_array[-2]:
string_array[-1] = get_next_char(string_array[-1])
answer = ''
for i in string_array:
answer += i
print(answer)
``` | output | 1 | 47,520 | 0 | 95,041 |
Provide tags and a correct Python 3 solution for this coding contest problem.
zscoder loves simple strings! A string t is called simple if every pair of adjacent characters are distinct. For example ab, aba, zscoder are simple whereas aa, add are not simple.
zscoder is given a string s. He wants to change a minimum number of characters so that the string s becomes simple. Help him with this task!
Input
The only line contains the string s (1 β€ |s| β€ 2Β·105) β the string given to zscoder. The string s consists of only lowercase English letters.
Output
Print the simple string s' β the string s after the minimal number of changes. If there are multiple solutions, you may output any of them.
Note that the string s' should also consist of only lowercase English letters.
Examples
Input
aab
Output
bab
Input
caaab
Output
cabab
Input
zscoder
Output
zscoder | instruction | 0 | 47,521 | 0 | 95,042 |
Tags: dp, greedy, strings
Correct Solution:
```
s = input()+' '
r = s[0]
for i in range(1, len(s)-1):
if s[i] == r[i-1]:
for q in 'abc':
if s[i] != q != s[i+1]:
r += q
break
else: r += s[i]
print(r)
``` | output | 1 | 47,521 | 0 | 95,043 |
Provide tags and a correct Python 3 solution for this coding contest problem.
zscoder loves simple strings! A string t is called simple if every pair of adjacent characters are distinct. For example ab, aba, zscoder are simple whereas aa, add are not simple.
zscoder is given a string s. He wants to change a minimum number of characters so that the string s becomes simple. Help him with this task!
Input
The only line contains the string s (1 β€ |s| β€ 2Β·105) β the string given to zscoder. The string s consists of only lowercase English letters.
Output
Print the simple string s' β the string s after the minimal number of changes. If there are multiple solutions, you may output any of them.
Note that the string s' should also consist of only lowercase English letters.
Examples
Input
aab
Output
bab
Input
caaab
Output
cabab
Input
zscoder
Output
zscoder | instruction | 0 | 47,522 | 0 | 95,044 |
Tags: dp, greedy, strings
Correct Solution:
```
s = list(input())
l = len(s)
for i in range(1, l):
if s[i] == s[i-1] and i != l-1:
if s[i-1] != "a" and s[i+1] != "a":
s[i] = "a"
elif s[i-1] != "b" and s[i+1] != "b":
s[i] = "b"
elif s[i-1] != "c" and s[i+1] != "c":
s[i] = "c"
elif s[i-1] != "d" and s[i+1] != "d":
s[i] = "d"
if i == l-1 and s[i] == s[i-1]:
if s[i-1] != "a":
s[i] = "a"
else:
s[i] = "b"
print("".join(s))
``` | output | 1 | 47,522 | 0 | 95,045 |
Provide tags and a correct Python 3 solution for this coding contest problem.
zscoder loves simple strings! A string t is called simple if every pair of adjacent characters are distinct. For example ab, aba, zscoder are simple whereas aa, add are not simple.
zscoder is given a string s. He wants to change a minimum number of characters so that the string s becomes simple. Help him with this task!
Input
The only line contains the string s (1 β€ |s| β€ 2Β·105) β the string given to zscoder. The string s consists of only lowercase English letters.
Output
Print the simple string s' β the string s after the minimal number of changes. If there are multiple solutions, you may output any of them.
Note that the string s' should also consist of only lowercase English letters.
Examples
Input
aab
Output
bab
Input
caaab
Output
cabab
Input
zscoder
Output
zscoder | instruction | 0 | 47,523 | 0 | 95,046 |
Tags: dp, greedy, strings
Correct Solution:
```
s=list(input())
x=''
c='abcdefghijklmnopqrstuvwxyz'
for i in range(len(s)-1):
if s[i]==x:
j=c[0]
a=0
while s[i]==j or j==s[i+1]:
a+=1
j=c[a]
s[i]=j
x=s[i]
if len(s)>1:
if s[-1]==s[-2]:
if s[-2]=='a':
s[-1]='b'
else:
s[-1]='a'
print(''.join(s))
``` | output | 1 | 47,523 | 0 | 95,047 |
Provide tags and a correct Python 3 solution for this coding contest problem.
zscoder loves simple strings! A string t is called simple if every pair of adjacent characters are distinct. For example ab, aba, zscoder are simple whereas aa, add are not simple.
zscoder is given a string s. He wants to change a minimum number of characters so that the string s becomes simple. Help him with this task!
Input
The only line contains the string s (1 β€ |s| β€ 2Β·105) β the string given to zscoder. The string s consists of only lowercase English letters.
Output
Print the simple string s' β the string s after the minimal number of changes. If there are multiple solutions, you may output any of them.
Note that the string s' should also consist of only lowercase English letters.
Examples
Input
aab
Output
bab
Input
caaab
Output
cabab
Input
zscoder
Output
zscoder | instruction | 0 | 47,524 | 0 | 95,048 |
Tags: dp, greedy, strings
Correct Solution:
```
from sys import stdin
input=lambda : stdin.readline()
from math import ceil,sqrt,gcd
s=list(input().strip())
for i in range(1,len(s)):
if s[i]==s[i-1]:
s[i]='0'
l=['a','c','b']
# print(s)
for i in range(len(s)):
if s[i]=='0':
a=0
for j in range(3):
if s[i-1]==l[a] or (i<len(s)-1 and s[i+1]==l[a]):
a+=1
else:
break
s[i]=l[a]
print(s[i],end='')
``` | output | 1 | 47,524 | 0 | 95,049 |
Provide tags and a correct Python 3 solution for this coding contest problem.
zscoder loves simple strings! A string t is called simple if every pair of adjacent characters are distinct. For example ab, aba, zscoder are simple whereas aa, add are not simple.
zscoder is given a string s. He wants to change a minimum number of characters so that the string s becomes simple. Help him with this task!
Input
The only line contains the string s (1 β€ |s| β€ 2Β·105) β the string given to zscoder. The string s consists of only lowercase English letters.
Output
Print the simple string s' β the string s after the minimal number of changes. If there are multiple solutions, you may output any of them.
Note that the string s' should also consist of only lowercase English letters.
Examples
Input
aab
Output
bab
Input
caaab
Output
cabab
Input
zscoder
Output
zscoder | instruction | 0 | 47,525 | 0 | 95,050 |
Tags: dp, greedy, strings
Correct Solution:
```
s=str(input())
l,n=list(s),len(s)
for i in range(1,n-1):
if l[i-1]==l[i]:
if l[i-1]!="z" and l[i+1]!="z":
l[i]="z"
elif l[i-1]!="y" and l[i+1]!="y":
l[i]="y"
elif l[i-1]!="x" and l[i+1]!="x":
l[i]="x"
elif l[i-1]!="u" and l[i+1]!="u":
l[i]="u"
if n>=2:
if l[-1]==l[-2]:
if l[-1]=="z":
l[-1]="y"
else:
l[-1]="z"
print("".join(l))
``` | output | 1 | 47,525 | 0 | 95,051 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
zscoder loves simple strings! A string t is called simple if every pair of adjacent characters are distinct. For example ab, aba, zscoder are simple whereas aa, add are not simple.
zscoder is given a string s. He wants to change a minimum number of characters so that the string s becomes simple. Help him with this task!
Input
The only line contains the string s (1 β€ |s| β€ 2Β·105) β the string given to zscoder. The string s consists of only lowercase English letters.
Output
Print the simple string s' β the string s after the minimal number of changes. If there are multiple solutions, you may output any of them.
Note that the string s' should also consist of only lowercase English letters.
Examples
Input
aab
Output
bab
Input
caaab
Output
cabab
Input
zscoder
Output
zscoder
Submitted Solution:
```
s = list(map(lambda c: ord(c), input()))
for i in range(1, len(s)):
if s[i - 1] != s[i]:
continue
left = s[i - 1]
right = s[i + 1] if i + 1 < len(s) else -1
for x in range(ord('a'), ord('z') + 1):
if x != left and x != right:
s[i] = x
break
print(''.join((map(lambda c: chr(c), s))))
``` | instruction | 0 | 47,527 | 0 | 95,054 |
Yes | output | 1 | 47,527 | 0 | 95,055 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
zscoder loves simple strings! A string t is called simple if every pair of adjacent characters are distinct. For example ab, aba, zscoder are simple whereas aa, add are not simple.
zscoder is given a string s. He wants to change a minimum number of characters so that the string s becomes simple. Help him with this task!
Input
The only line contains the string s (1 β€ |s| β€ 2Β·105) β the string given to zscoder. The string s consists of only lowercase English letters.
Output
Print the simple string s' β the string s after the minimal number of changes. If there are multiple solutions, you may output any of them.
Note that the string s' should also consist of only lowercase English letters.
Examples
Input
aab
Output
bab
Input
caaab
Output
cabab
Input
zscoder
Output
zscoder
Submitted Solution:
```
def get_next_char(char):
return "a" if char == "z" else chr(ord(char) + 1)
string_array = []
string_array.extend(input())
for i in range(1,len(string_array)-1):
char = string_array[i]
prev_char = string_array[i-1]
next_char = string_array[i+1]
if char == prev_char:
# z back to a
char = get_next_char(char)
if char == next_char:
char = get_next_char(char)
string_array[i] = char
if len(string_array) > 2 and string_array[-1] == string_array[-2]:
string_array[-1] = get_next_char(string_array[-1])
answer = ''
for i in string_array:
answer += i
print(answer)
``` | instruction | 0 | 47,530 | 0 | 95,060 |
No | output | 1 | 47,530 | 0 | 95,061 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
zscoder loves simple strings! A string t is called simple if every pair of adjacent characters are distinct. For example ab, aba, zscoder are simple whereas aa, add are not simple.
zscoder is given a string s. He wants to change a minimum number of characters so that the string s becomes simple. Help him with this task!
Input
The only line contains the string s (1 β€ |s| β€ 2Β·105) β the string given to zscoder. The string s consists of only lowercase English letters.
Output
Print the simple string s' β the string s after the minimal number of changes. If there are multiple solutions, you may output any of them.
Note that the string s' should also consist of only lowercase English letters.
Examples
Input
aab
Output
bab
Input
caaab
Output
cabab
Input
zscoder
Output
zscoder
Submitted Solution:
```
s=[i for i in input()]
n=len(s)
a=[0]*n
if n==1:
print(s[0])
else:
for i in range(n):
if i==0:
if s[i]==s[i+1]:
a[i]=1
elif i==n-1:
if s[i-1]==s[i]:
a[i]=1
else:
if s[i-1]==s[i] or s[i+1]==s[i]:
a[i]=1
f=0
for i in range(n):
if a[i]==1:
if f==0:
f=1
else:
f=0
z=97
if i-1>-1 and ord(s[i-1])==z:
z+=1
if i+1<n and ord(s[i+1])==z:
z+=1
s[i]=chr(z)
else:
f=0
for i in range(n):
print(s[i],end="")
``` | instruction | 0 | 47,531 | 0 | 95,062 |
No | output | 1 | 47,531 | 0 | 95,063 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
zscoder loves simple strings! A string t is called simple if every pair of adjacent characters are distinct. For example ab, aba, zscoder are simple whereas aa, add are not simple.
zscoder is given a string s. He wants to change a minimum number of characters so that the string s becomes simple. Help him with this task!
Input
The only line contains the string s (1 β€ |s| β€ 2Β·105) β the string given to zscoder. The string s consists of only lowercase English letters.
Output
Print the simple string s' β the string s after the minimal number of changes. If there are multiple solutions, you may output any of them.
Note that the string s' should also consist of only lowercase English letters.
Examples
Input
aab
Output
bab
Input
caaab
Output
cabab
Input
zscoder
Output
zscoder
Submitted Solution:
```
#n,a,b,c = map(int, input().strip().split(' '))
#n=int(input())
#lst = list(map(str, input().strip().split(' ')))
s=input()
n=len(s)
if n==1:
print(s)
elif n==2:
if s[0]!=s[1]:
print(s)
else:
s=list(s)
if s[0]=='a':
print('b',s[1],end="")
else:
print('a',s[1],end="")
else:
s=list(s)
i=1
while(i<n):
if i==n-1:
if s[i]!=s[i-1]:
break
else:
if s[i]=='a':
s[i]='b'
else:
s[i]='a'
else:
if s[i]!=s[i-1] and s[i]!=s[i+1]:
i+=2
elif s[i]==s[i-1] and s[i]!=s[i+1]:
if s[i]=='a':
if s[i+1]!='b':
s[i]='b'
else:
s[i]='c'
else:
if s[i+1]!='a':
s[i]='a'
else:
if s[i]=='b':
s[i]='c'
else:
s[i]='b'
i+=2
elif s[i]==s[i+1] and s[i]!=s[i-1]:
i+=1
else:
if s[i]=='a':
s[i]='b'
else:
s[i]='a'
i+=2
for j in range(n):
print(s[j],end="")
``` | instruction | 0 | 47,532 | 0 | 95,064 |
No | output | 1 | 47,532 | 0 | 95,065 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
zscoder loves simple strings! A string t is called simple if every pair of adjacent characters are distinct. For example ab, aba, zscoder are simple whereas aa, add are not simple.
zscoder is given a string s. He wants to change a minimum number of characters so that the string s becomes simple. Help him with this task!
Input
The only line contains the string s (1 β€ |s| β€ 2Β·105) β the string given to zscoder. The string s consists of only lowercase English letters.
Output
Print the simple string s' β the string s after the minimal number of changes. If there are multiple solutions, you may output any of them.
Note that the string s' should also consist of only lowercase English letters.
Examples
Input
aab
Output
bab
Input
caaab
Output
cabab
Input
zscoder
Output
zscoder
Submitted Solution:
```
mod = 1000000007
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
s=ls()
n=len(s)
for i in range(1,n-1):
if s[i]==s[i-1]:
for j in 'abc':
if j!=s[i+1] and j!=s[i-1]:
s[i]=j
if n>1 and s[-1]==s[-2]:
for i in 'abc':
if s[-2]!=i:
s[-2]=i
print(''.join(s))
``` | instruction | 0 | 47,533 | 0 | 95,066 |
No | output | 1 | 47,533 | 0 | 95,067 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S. Let T be the concatenation of K copies of S. We can repeatedly perform the following operation: choose a character in T and replace it with a different character. Find the minimum number of operations required to satisfy the following condition: any two adjacent characters in T are different.
Constraints
* 1 \leq |S| \leq 100
* S consists of lowercase English letters.
* 1 \leq K \leq 10^9
* K is an integer.
Input
Input is given from Standard Input in the following format:
S
K
Output
Print the minimum number of operations required.
Examples
Input
issii
2
Output
4
Input
qq
81
Output
81
Input
cooooooooonteeeeeeeeeest
999993333
Output
8999939997 | instruction | 0 | 47,720 | 0 | 95,440 |
"Correct Solution:
```
from itertools import groupby
S = input()
K = int(input())
A = [len(tuple(v)) for _, v in groupby(S)]
if len(A) == 1:
print((A[0] * K) // 2)
quit()
if S[0] == S[-1]:
m = sum(a // 2 for a in A) - A[0] // 2 - A[-1] // 2
print(K * m + (K - 1) * ((A[0] + A[-1]) // 2) + A[0] // 2 + A[-1] // 2)
else:
print(sum(a // 2 for a in A) * K)
``` | output | 1 | 47,720 | 0 | 95,441 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S. Let T be the concatenation of K copies of S. We can repeatedly perform the following operation: choose a character in T and replace it with a different character. Find the minimum number of operations required to satisfy the following condition: any two adjacent characters in T are different.
Constraints
* 1 \leq |S| \leq 100
* S consists of lowercase English letters.
* 1 \leq K \leq 10^9
* K is an integer.
Input
Input is given from Standard Input in the following format:
S
K
Output
Print the minimum number of operations required.
Examples
Input
issii
2
Output
4
Input
qq
81
Output
81
Input
cooooooooonteeeeeeeeeest
999993333
Output
8999939997 | instruction | 0 | 47,721 | 0 | 95,442 |
"Correct Solution:
```
from itertools import groupby
s = list(input())
k = int(input())
G = []
for key, group in groupby(s):
G += [list(group)]
count = 0
if len(G)==1:
print(len(s)*k//2)
elif s[0]!=s[-1]:
for g in G:
count += len(g)//2
print(count*k)
else:
d = len(G[0]+G[-1])//2-(len(G[0])//2)-(len(G[-1])//2)
for g in G:
count += len(g)//2
print(count*k + d*(k-1))
``` | output | 1 | 47,721 | 0 | 95,443 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S. Let T be the concatenation of K copies of S. We can repeatedly perform the following operation: choose a character in T and replace it with a different character. Find the minimum number of operations required to satisfy the following condition: any two adjacent characters in T are different.
Constraints
* 1 \leq |S| \leq 100
* S consists of lowercase English letters.
* 1 \leq K \leq 10^9
* K is an integer.
Input
Input is given from Standard Input in the following format:
S
K
Output
Print the minimum number of operations required.
Examples
Input
issii
2
Output
4
Input
qq
81
Output
81
Input
cooooooooonteeeeeeeeeest
999993333
Output
8999939997 | instruction | 0 | 47,722 | 0 | 95,444 |
"Correct Solution:
```
from itertools import groupby
s = input()
k = int(input())
r = len(s) * k // 2
a = [sum(1 for _ in g) & 1 for _, g in groupby(s)]
if len(a) > 1:
r -= sum(a) * k // 2
if s[0] == s[-1] and a[0] & a[-1]:
r += k - 1
print(r)
``` | output | 1 | 47,722 | 0 | 95,445 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S. Let T be the concatenation of K copies of S. We can repeatedly perform the following operation: choose a character in T and replace it with a different character. Find the minimum number of operations required to satisfy the following condition: any two adjacent characters in T are different.
Constraints
* 1 \leq |S| \leq 100
* S consists of lowercase English letters.
* 1 \leq K \leq 10^9
* K is an integer.
Input
Input is given from Standard Input in the following format:
S
K
Output
Print the minimum number of operations required.
Examples
Input
issii
2
Output
4
Input
qq
81
Output
81
Input
cooooooooonteeeeeeeeeest
999993333
Output
8999939997 | instruction | 0 | 47,723 | 0 | 95,446 |
"Correct Solution:
```
S=input()
N=int(input())
a=len(S)
b=0
for i in range(a-1):
if S[i]==S[i+1]:
b+=0.5
else:
b=int(b+0.5)
b=int(b+0.5)
S2=S*3
a2=a*3
b2=0
for i in range(a2-1):
if S2[i]==S2[i+1]:
b2+=0.5
else:
b2=int(b2+0.5)
b2=int(b2+0.5)
c=int((b2-b*3)/2*(N-1)+0.5)+b*N
print(c)
``` | output | 1 | 47,723 | 0 | 95,447 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S. Let T be the concatenation of K copies of S. We can repeatedly perform the following operation: choose a character in T and replace it with a different character. Find the minimum number of operations required to satisfy the following condition: any two adjacent characters in T are different.
Constraints
* 1 \leq |S| \leq 100
* S consists of lowercase English letters.
* 1 \leq K \leq 10^9
* K is an integer.
Input
Input is given from Standard Input in the following format:
S
K
Output
Print the minimum number of operations required.
Examples
Input
issii
2
Output
4
Input
qq
81
Output
81
Input
cooooooooonteeeeeeeeeest
999993333
Output
8999939997 | instruction | 0 | 47,724 | 0 | 95,448 |
"Correct Solution:
```
S = input()
K = int(input())
ss = []
seq = 1
for a,b in zip(S,S[1:]):
if a==b:
seq += 1
else:
ss.append(seq)
seq = 1
ss.append(seq)
if len(ss)==1:
print(len(S)*K//2)
exit()
if S[0] != S[-1]:
ans = sum([v//2 for v in ss]) * K
print(ans)
else:
ans = sum([v//2 for v in ss[1:-1]]) * K
ans += (ss[0]+ss[-1])//2 * (K-1)
ans += ss[0]//2 + ss[-1]//2
print(ans)
``` | output | 1 | 47,724 | 0 | 95,449 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S. Let T be the concatenation of K copies of S. We can repeatedly perform the following operation: choose a character in T and replace it with a different character. Find the minimum number of operations required to satisfy the following condition: any two adjacent characters in T are different.
Constraints
* 1 \leq |S| \leq 100
* S consists of lowercase English letters.
* 1 \leq K \leq 10^9
* K is an integer.
Input
Input is given from Standard Input in the following format:
S
K
Output
Print the minimum number of operations required.
Examples
Input
issii
2
Output
4
Input
qq
81
Output
81
Input
cooooooooonteeeeeeeeeest
999993333
Output
8999939997 | instruction | 0 | 47,725 | 0 | 95,450 |
"Correct Solution:
```
S = input()
K = int(input())
if len(set(S)) == 1:
print(len(S)*K//2)
exit()
b = [1]
for i in range(len(S)-1):
if S[i] == S[i+1]:
b[-1] += 1
else:
b.append(1)
ans = 0
for i in b:
ans += i//2
ans *= K
if S[0] == S[-1] and b[0]%2 == b[-1]%2 == 1:
ans += K - 1
print(ans)
``` | output | 1 | 47,725 | 0 | 95,451 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S. Let T be the concatenation of K copies of S. We can repeatedly perform the following operation: choose a character in T and replace it with a different character. Find the minimum number of operations required to satisfy the following condition: any two adjacent characters in T are different.
Constraints
* 1 \leq |S| \leq 100
* S consists of lowercase English letters.
* 1 \leq K \leq 10^9
* K is an integer.
Input
Input is given from Standard Input in the following format:
S
K
Output
Print the minimum number of operations required.
Examples
Input
issii
2
Output
4
Input
qq
81
Output
81
Input
cooooooooonteeeeeeeeeest
999993333
Output
8999939997 | instruction | 0 | 47,726 | 0 | 95,452 |
"Correct Solution:
```
s = input()
n = len(s)
flg = 0
ans1 = 0
ans2 = 0
for i in range(1,n):
if s[i] == s[i-1] and flg == 0:
flg = 1
ans1 += 1
else:
flg = 0
s = s*2
n *= 2
flg = 0
for i in range(1,n):
if s[i] == s[i-1] and flg == 0:
flg = 1
ans2 += 1
else:
flg = 0
k = int(input())
if len(set(list(s))) == 1:
print(n*k//4)
elif ans2>ans1*2:
print((k//2)*ans2+(k%2)*ans1+(k-1)//2)
else:
print((k//2)*ans2+(k%2)*ans1)
``` | output | 1 | 47,726 | 0 | 95,453 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S. Let T be the concatenation of K copies of S. We can repeatedly perform the following operation: choose a character in T and replace it with a different character. Find the minimum number of operations required to satisfy the following condition: any two adjacent characters in T are different.
Constraints
* 1 \leq |S| \leq 100
* S consists of lowercase English letters.
* 1 \leq K \leq 10^9
* K is an integer.
Input
Input is given from Standard Input in the following format:
S
K
Output
Print the minimum number of operations required.
Examples
Input
issii
2
Output
4
Input
qq
81
Output
81
Input
cooooooooonteeeeeeeeeest
999993333
Output
8999939997 | instruction | 0 | 47,727 | 0 | 95,454 |
"Correct Solution:
```
from itertools import groupby
s = input()
k = int(input())
n = len(s)
if n > 1:
a = [len(list(g)) for _, g in groupby(s)]
if len(a) == 1:
print(n * k // 2)
else:
answer = sum([i // 2 for i in a]) * k
if s[0] == s[-1] and a[0] % 2 == 1 and a[-1] % 2 == 1:
answer += k - 1
print(answer)
else:
print(k // 2)
``` | output | 1 | 47,727 | 0 | 95,455 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S. Let T be the concatenation of K copies of S. We can repeatedly perform the following operation: choose a character in T and replace it with a different character. Find the minimum number of operations required to satisfy the following condition: any two adjacent characters in T are different.
Constraints
* 1 \leq |S| \leq 100
* S consists of lowercase English letters.
* 1 \leq K \leq 10^9
* K is an integer.
Input
Input is given from Standard Input in the following format:
S
K
Output
Print the minimum number of operations required.
Examples
Input
issii
2
Output
4
Input
qq
81
Output
81
Input
cooooooooonteeeeeeeeeest
999993333
Output
8999939997
Submitted Solution:
```
S=list(input())
K=int(input())
cnt=cnt2=0
s=S*2
if len(set(S))==1:
print(len(S)*K//2);exit()
for i in range(len(S)-1):
if S[i+1]==S[i]:
cnt+=1
S[i+1]="#"
for i in range(len(s)-1):
if s[i+1]==s[i]:
cnt2+=1
s[i+1]="#"
print(cnt+(cnt2-cnt)*(K-1))
``` | instruction | 0 | 47,729 | 0 | 95,458 |
Yes | output | 1 | 47,729 | 0 | 95,459 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S. Let T be the concatenation of K copies of S. We can repeatedly perform the following operation: choose a character in T and replace it with a different character. Find the minimum number of operations required to satisfy the following condition: any two adjacent characters in T are different.
Constraints
* 1 \leq |S| \leq 100
* S consists of lowercase English letters.
* 1 \leq K \leq 10^9
* K is an integer.
Input
Input is given from Standard Input in the following format:
S
K
Output
Print the minimum number of operations required.
Examples
Input
issii
2
Output
4
Input
qq
81
Output
81
Input
cooooooooonteeeeeeeeeest
999993333
Output
8999939997
Submitted Solution:
```
from itertools import groupby
s1=input()
k=int(input())
s2=[[h, len(list(g))] for h, g in groupby(s1)]
c=0
if len(s2)!=1:
for i in range(len(s2)):
if i!=0 and i!=len(s2)-1:
c+=(s2[i][1]//2)*k
if s2[0][0]==s2[-1][0]:
c+=((s2[0][1]+s2[-1][1])//2)*(k-1)
c+=(s2[0][1]//2+s2[-1][1]//2)
else:
c+=(s2[0][1]//2+s2[-1][1]//2)*k
else:
c+=(s2[0][1]*k)//2
print(c)
``` | instruction | 0 | 47,730 | 0 | 95,460 |
Yes | output | 1 | 47,730 | 0 | 95,461 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S. Let T be the concatenation of K copies of S. We can repeatedly perform the following operation: choose a character in T and replace it with a different character. Find the minimum number of operations required to satisfy the following condition: any two adjacent characters in T are different.
Constraints
* 1 \leq |S| \leq 100
* S consists of lowercase English letters.
* 1 \leq K \leq 10^9
* K is an integer.
Input
Input is given from Standard Input in the following format:
S
K
Output
Print the minimum number of operations required.
Examples
Input
issii
2
Output
4
Input
qq
81
Output
81
Input
cooooooooonteeeeeeeeeest
999993333
Output
8999939997
Submitted Solution:
```
#coding: utf-8
s = input()
k = int(input())
if len(set(s))==1:
print((len(s)*k)//2)
exit()
dup = [1]
for i in range(1,len(s)):
if s[i-1]==s[i]:
dup[-1]+=1
else:
dup.append(1)
ans = 0
for i in dup:
ans += (i//2)*k
if s[0]==s[-1]:
ans += ((dup[0]+dup[-1])//2 - (dup[0]//2+dup[-1]//2))*(k-1)
print(ans)
``` | instruction | 0 | 47,731 | 0 | 95,462 |
Yes | output | 1 | 47,731 | 0 | 95,463 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S. Let T be the concatenation of K copies of S. We can repeatedly perform the following operation: choose a character in T and replace it with a different character. Find the minimum number of operations required to satisfy the following condition: any two adjacent characters in T are different.
Constraints
* 1 \leq |S| \leq 100
* S consists of lowercase English letters.
* 1 \leq K \leq 10^9
* K is an integer.
Input
Input is given from Standard Input in the following format:
S
K
Output
Print the minimum number of operations required.
Examples
Input
issii
2
Output
4
Input
qq
81
Output
81
Input
cooooooooonteeeeeeeeeest
999993333
Output
8999939997
Submitted Solution:
```
S = list(input())
K = int(input())
l = len(S)
if len(set(S)) == 1:
print(l*K//2)
exit()
else:
ans = 0
tmp = ""
count = [1]
for i in range(l-1):
if S[i] == S[i+1]:
count[-1] += 1
else:
count.append(1)
for i in count:
ans += i//2*K
if S[0] == S[-1]:
ans += K-1
print(ans)
``` | instruction | 0 | 47,733 | 0 | 95,466 |
No | output | 1 | 47,733 | 0 | 95,467 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S. Let T be the concatenation of K copies of S. We can repeatedly perform the following operation: choose a character in T and replace it with a different character. Find the minimum number of operations required to satisfy the following condition: any two adjacent characters in T are different.
Constraints
* 1 \leq |S| \leq 100
* S consists of lowercase English letters.
* 1 \leq K \leq 10^9
* K is an integer.
Input
Input is given from Standard Input in the following format:
S
K
Output
Print the minimum number of operations required.
Examples
Input
issii
2
Output
4
Input
qq
81
Output
81
Input
cooooooooonteeeeeeeeeest
999993333
Output
8999939997
Submitted Solution:
```
from sys import stdin
from itertools import groupby
s = stdin.readline().rstrip()
k = int(stdin.readline().rstrip())
if len(s) == 1:
print(k//2)
exit()
li = []
point = 1
for i in range(len(s)-1):
if s[i] == s[i+1]:
point += 1
if i == len(s)-2:
li.append(point)
else:
li.append(point)
point = 1
if s[-1] != s[-2]:
li.append(1)
print(li)
if s[0] != s[-1]:
co = 0
for j in range(len(li)):
co += li[j]//2
print(co*k)
exit()
else:
co = 0
for i in range(1,-1):
co += li[i]//2
co *= k
co += ((li[0]+li[-1])//2)+(k-1)
co += li[0]//2
co += li[-1]//2
``` | instruction | 0 | 47,734 | 0 | 95,468 |
No | output | 1 | 47,734 | 0 | 95,469 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S. Let T be the concatenation of K copies of S. We can repeatedly perform the following operation: choose a character in T and replace it with a different character. Find the minimum number of operations required to satisfy the following condition: any two adjacent characters in T are different.
Constraints
* 1 \leq |S| \leq 100
* S consists of lowercase English letters.
* 1 \leq K \leq 10^9
* K is an integer.
Input
Input is given from Standard Input in the following format:
S
K
Output
Print the minimum number of operations required.
Examples
Input
issii
2
Output
4
Input
qq
81
Output
81
Input
cooooooooonteeeeeeeeeest
999993333
Output
8999939997
Submitted Solution:
```
S = list(input())
K = int(input())
ans = 0
for i in range(len(S)-1):
if(S[i] == S[i+1]):
S[i+1] = "3"
ans += 1
print(ans * K)
``` | instruction | 0 | 47,735 | 0 | 95,470 |
No | output | 1 | 47,735 | 0 | 95,471 |
Provide a correct Python 3 solution for this coding contest problem.
Problem J String Puzzle
Amazing Coding Magazine is popular among young programmers for its puzzle solving contests offering catchy digital gadgets as the prizes. The magazine for programmers naturally encourages the readers to solve the puzzles by writing programs. Let's give it a try!
The puzzle in the latest issue is on deciding some of the letters in a string (the secret string, in what follows) based on a variety of hints. The figure below depicts an example of the given hints.
<image>
The first hint is the number of letters in the secret string. In the example of the figure above, it is nine, and the nine boxes correspond to nine letters. The letter positions (boxes) are numbered starting from 1, from the left to the right.
The hints of the next kind simply tell the letters in the secret string at some speci c positions. In the example, the hints tell that the letters in the 3rd, 4th, 7th, and 9th boxes are C, I, C, and P
The hints of the final kind are on duplicated substrings in the secret string. The bar immediately below the boxes in the figure is partitioned into some sections corresponding to substrings of the secret string. Each of the sections may be connected by a line running to the left with another bar also showing an extent of a substring. Each of the connected pairs indicates that substrings of the two extents are identical. One of this kind of hints in the example tells that the letters in boxes 8 and 9 are identical to those in boxes 4 and 5, respectively. From this, you can easily deduce that the substring is IP.
Note that, not necessarily all of the identical substring pairs in the secret string are given in the hints; some identical substring pairs may not be mentioned.
Note also that two extents of a pair may overlap each other. In the example, the two-letter substring in boxes 2 and 3 is told to be identical to one in boxes 1 and 2, and these two extents share the box 2.
In this example, you can decide letters at all the positions of the secret string, which are "CCCIPCCIP". In general, the hints may not be enough to decide all the letters in the secret string.
The answer of the puzzle should be letters at the specified positions of the secret string. When the letter at the position specified cannot be decided with the given hints, the symbol ? should be answered.
Input
The input consists of a single test case in the following format.
$n$ $a$ $b$ $q$
$x_1$ $c_1$
...
$x_a$ $c_a$
$y_1$ $h_1$
...
$y_b$ $h_b$
$z_1$
...
$z_q$
The first line contains four integers $n$, $a$, $b$, and $q$. $n$ ($1 \leq n \leq 10^9$) is the length of the secret string, $a$ ($0 \leq a \leq 1000$) is the number of the hints on letters in specified positions, $b$ ($0 \leq b \leq 1000$) is the number of the hints on duplicated substrings, and $q$ ($1 \leq q \leq 1000$) is the number of positions asked.
The $i$-th line of the following a lines contains an integer $x_i$ and an uppercase letter $c_i$ meaning that the letter at the position $x_i$ of the secret string is $c_i$. These hints are ordered in their positions, i.e., $1 \leq x_1 < ... < x_a \leq n$.
The $i$-th line of the following $b$ lines contains two integers, $y_i$ and $h_i$. It is guaranteed that they satisfy $2 \leq y_1 < ... < y_b \leq n$ and $0 \leq h_i < y_i$. When $h_i$ is not 0, the substring of the secret string starting from the position $y_i$ with the length $y_{i+1} - y_i$ (or $n+1-y_i$ when $i = b$) is identical to the substring with the same length starting from the position $h_i$. Lines with $h_i = 0$ does not tell any hints except that $y_i$ in the line indicates the end of the substring specified in the line immediately above.
Each of the following $q$ lines has an integer $z_i$ ($1 \leq z_i \leq n$), specifying the position of the letter in the secret string to output.
It is ensured that there exists at least one secret string that matches all the given information. In other words, the given hints have no contradiction.
Output
The output should be a single line consisting only of $q$ characters. The character at position $i$ of the output should be the letter at position $z_i$ of the the secret string if it is uniquely determined from the hints, or ? otherwise.
Sample Input 1
9 4 5 4
3 C
4 I
7 C
9 P
2 1
4 0
6 2
7 0
8 4
8
1
9
6
Sample Output 1
ICPC
Sample Input 2
1000000000 1 1 2
20171217 A
3 1
42
987654321
Sample Output 2
?A
Example
Input
9 4 5 4
3 C
4 I
7 C
9 P
2 1
4 0
6 2
7 0
8 4
8
1
9
6
Output
ICPC | instruction | 0 | 47,892 | 0 | 95,784 |
"Correct Solution:
```
from bisect import bisect
n, a, b, q = map(int, input().split())
W = [input().split() for i in range(a)]
X = [int(x) for x, c in W]
C = [c for x, c in W]
P = [list(map(int, input().split())) for i in range(b)]
Y = [y for y, h in P] + [n+1]
D = [0]*b
for i in range(b):
y0, h = P[i]; y1 = Y[i+1]
l = y1 - y0
D[i] = min(y0 - h, l)
idx = 0
S = {}
for i in range(a):
x = X[i]; c = C[i]
S[x] = c
if x < Y[0]:
continue
while Y[idx+1] <= x: idx += 1
i = idx; j = i
while Y[0] <= x:
while x < Y[i]: i -= 1
y0, h = P[i]; y1 = Y[i+1]
if h == 0: break
x = h + ((x - y0) % D[i])
assert x < y0
S[x] = c
def check(z):
if z in S:
return S[z]
i = bisect(Y, z)-1
while Y[0] <= z:
while z < Y[i]: i -= 1
y0, h = P[i]; y1 = Y[i+1]
if h == 0: break
z = h + ((z - y0) % D[i])
assert z < y0
if z in S:
return S[z]
return '?'
Z = [int(input()) for i in range(q)]
print(*map(check, Z), sep='')
``` | output | 1 | 47,892 | 0 | 95,785 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.