message stringlengths 2 23.8k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 97 109k | cluster float64 0 0 | __index_level_0__ int64 194 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given string s. Your task is to determine if the given string s contains two non-overlapping substrings "AB" and "BA" (the substrings can go in any order).
Input
The only line of input contains a string s of length between 1 and 105 consisting of uppercase Latin letters.
Output
Print "YES" (without the quotes), if string s contains two non-overlapping substrings "AB" and "BA", and "NO" otherwise.
Examples
Input
ABA
Output
NO
Input
BACFAB
Output
YES
Input
AXBYBXA
Output
NO
Note
In the first sample test, despite the fact that there are substrings "AB" and "BA", their occurrences overlap, so the answer is "NO".
In the second sample test there are the following occurrences of the substrings: BACFAB.
In the third sample test there is no substring "AB" nor substring "BA". | instruction | 0 | 85,341 | 0 | 170,682 |
Tags: brute force, dp, greedy, implementation, strings
Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Sat Jan 5 14:48:26 2019
@author: piyus
"""
def foo(string,sub):
ans = []
for i in range(len(string)-len(sub)+1):
for j in range(len(sub)):
if string[i+j]!=sub[j]:
break
else:
ans.append(i)
return ans
s = input()
a1 = foo(s,"AB")
a2 = foo(s,"BA")
f = 0
for elm in a2:
for start in a1:
if elm not in range(start,start+2) and (elm+1) not in range(start,start+2):
print("YES")
f = 1
break
if f:
break
else:
print("NO")
``` | output | 1 | 85,341 | 0 | 170,683 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given string s. Your task is to determine if the given string s contains two non-overlapping substrings "AB" and "BA" (the substrings can go in any order).
Input
The only line of input contains a string s of length between 1 and 105 consisting of uppercase Latin letters.
Output
Print "YES" (without the quotes), if string s contains two non-overlapping substrings "AB" and "BA", and "NO" otherwise.
Examples
Input
ABA
Output
NO
Input
BACFAB
Output
YES
Input
AXBYBXA
Output
NO
Note
In the first sample test, despite the fact that there are substrings "AB" and "BA", their occurrences overlap, so the answer is "NO".
In the second sample test there are the following occurrences of the substrings: BACFAB.
In the third sample test there is no substring "AB" nor substring "BA". | instruction | 0 | 85,342 | 0 | 170,684 |
Tags: brute force, dp, greedy, implementation, strings
Correct Solution:
```
s=input()
l=len(s)
ab=[]
ba=[]
for i in range(l-1):
if s[i:i+2]=="AB":
ab.append(i)
elif s[i:i+2]=="BA":
ba.append(i)
if not ab or not ba:
print("NO")
else:
bk=False
for i in ab:
for j in ba:
if abs(i-j)>=2:
bk=True
break
if bk:break
if bk:
print("YES")
else:
print("NO")
``` | output | 1 | 85,342 | 0 | 170,685 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given string s. Your task is to determine if the given string s contains two non-overlapping substrings "AB" and "BA" (the substrings can go in any order).
Input
The only line of input contains a string s of length between 1 and 105 consisting of uppercase Latin letters.
Output
Print "YES" (without the quotes), if string s contains two non-overlapping substrings "AB" and "BA", and "NO" otherwise.
Examples
Input
ABA
Output
NO
Input
BACFAB
Output
YES
Input
AXBYBXA
Output
NO
Note
In the first sample test, despite the fact that there are substrings "AB" and "BA", their occurrences overlap, so the answer is "NO".
In the second sample test there are the following occurrences of the substrings: BACFAB.
In the third sample test there is no substring "AB" nor substring "BA". | instruction | 0 | 85,343 | 0 | 170,686 |
Tags: brute force, dp, greedy, implementation, strings
Correct Solution:
```
s = input()
abfound = bafound = -1
for i in range(len(s) - 1):
if abfound == -1 and s[i] == 'A' and s[i + 1] == 'B':
abfound = i
elif bafound == -1 and s[i] == 'B' and s[i + 1] == 'A':
bafound = i
if abfound != -1 and bafound != -1:
break
if abfound == -1 or bafound == -1:
print("NO")
exit(0)
if abfound == bafound + 1 or bafound == abfound + 1:
for i in range(max(bafound + 2, abfound + 2), len(s) - 1):
if s[i] == 'A' and s[i + 1] == 'B':
newabfound = True
print("YES")
exit(0)
elif s[i] == 'B' and s[i + 1] == 'A':
newbafound = True
print("YES")
exit(0)
else:
print("YES")
exit(0)
print("NO")
``` | output | 1 | 85,343 | 0 | 170,687 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given string s. Your task is to determine if the given string s contains two non-overlapping substrings "AB" and "BA" (the substrings can go in any order).
Input
The only line of input contains a string s of length between 1 and 105 consisting of uppercase Latin letters.
Output
Print "YES" (without the quotes), if string s contains two non-overlapping substrings "AB" and "BA", and "NO" otherwise.
Examples
Input
ABA
Output
NO
Input
BACFAB
Output
YES
Input
AXBYBXA
Output
NO
Note
In the first sample test, despite the fact that there are substrings "AB" and "BA", their occurrences overlap, so the answer is "NO".
In the second sample test there are the following occurrences of the substrings: BACFAB.
In the third sample test there is no substring "AB" nor substring "BA". | instruction | 0 | 85,344 | 0 | 170,688 |
Tags: brute force, dp, greedy, implementation, strings
Correct Solution:
```
st = input()
s1 = st.replace('AB','0',1)
s1 = s1.replace('BA','1',1)
s2 = st.replace('BA','1',1)
s2 = s2.replace('AB','0',1)
if ('0' in s1 and '1' in s1) or ('0' in s2 and '1' in s2):
print('YES')
else:
print('NO')
``` | output | 1 | 85,344 | 0 | 170,689 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string s. Your task is to determine if the given string s contains two non-overlapping substrings "AB" and "BA" (the substrings can go in any order).
Input
The only line of input contains a string s of length between 1 and 105 consisting of uppercase Latin letters.
Output
Print "YES" (without the quotes), if string s contains two non-overlapping substrings "AB" and "BA", and "NO" otherwise.
Examples
Input
ABA
Output
NO
Input
BACFAB
Output
YES
Input
AXBYBXA
Output
NO
Note
In the first sample test, despite the fact that there are substrings "AB" and "BA", their occurrences overlap, so the answer is "NO".
In the second sample test there are the following occurrences of the substrings: BACFAB.
In the third sample test there is no substring "AB" nor substring "BA".
Submitted Solution:
```
s=input()
a=s.find('AB')
b=s.rfind('AB')
c=s.find('BA')
d=s.rfind('BA')
e=min(a,b,c,d)
if((abs(a-d)>1 or abs(b-c)>1) and e>=0):
print("YES")
else:
print('NO')
``` | instruction | 0 | 85,345 | 0 | 170,690 |
Yes | output | 1 | 85,345 | 0 | 170,691 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string s. Your task is to determine if the given string s contains two non-overlapping substrings "AB" and "BA" (the substrings can go in any order).
Input
The only line of input contains a string s of length between 1 and 105 consisting of uppercase Latin letters.
Output
Print "YES" (without the quotes), if string s contains two non-overlapping substrings "AB" and "BA", and "NO" otherwise.
Examples
Input
ABA
Output
NO
Input
BACFAB
Output
YES
Input
AXBYBXA
Output
NO
Note
In the first sample test, despite the fact that there are substrings "AB" and "BA", their occurrences overlap, so the answer is "NO".
In the second sample test there are the following occurrences of the substrings: BACFAB.
In the third sample test there is no substring "AB" nor substring "BA".
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Mon Jun 22 10:52:08 2020
@author: Harshal
"""
s=input()
u=s.find('AB');v=s.find('BA')
if (u+1 and s.find('BA',u+2)+1) or (v+1 and s.find('AB',v+2)+1):
print("YES")
else:
print("NO")
``` | instruction | 0 | 85,346 | 0 | 170,692 |
Yes | output | 1 | 85,346 | 0 | 170,693 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string s. Your task is to determine if the given string s contains two non-overlapping substrings "AB" and "BA" (the substrings can go in any order).
Input
The only line of input contains a string s of length between 1 and 105 consisting of uppercase Latin letters.
Output
Print "YES" (without the quotes), if string s contains two non-overlapping substrings "AB" and "BA", and "NO" otherwise.
Examples
Input
ABA
Output
NO
Input
BACFAB
Output
YES
Input
AXBYBXA
Output
NO
Note
In the first sample test, despite the fact that there are substrings "AB" and "BA", their occurrences overlap, so the answer is "NO".
In the second sample test there are the following occurrences of the substrings: BACFAB.
In the third sample test there is no substring "AB" nor substring "BA".
Submitted Solution:
```
s=input()
a= s.count("AB")
b=s.count("BA")
c=s.count("ABA")
d=s.count("BAB")
e=c+d
if a>0 and b>0 and a+b-e >=2 :
print("YES")
else:
print("NO")
``` | instruction | 0 | 85,347 | 0 | 170,694 |
Yes | output | 1 | 85,347 | 0 | 170,695 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string s. Your task is to determine if the given string s contains two non-overlapping substrings "AB" and "BA" (the substrings can go in any order).
Input
The only line of input contains a string s of length between 1 and 105 consisting of uppercase Latin letters.
Output
Print "YES" (without the quotes), if string s contains two non-overlapping substrings "AB" and "BA", and "NO" otherwise.
Examples
Input
ABA
Output
NO
Input
BACFAB
Output
YES
Input
AXBYBXA
Output
NO
Note
In the first sample test, despite the fact that there are substrings "AB" and "BA", their occurrences overlap, so the answer is "NO".
In the second sample test there are the following occurrences of the substrings: BACFAB.
In the third sample test there is no substring "AB" nor substring "BA".
Submitted Solution:
```
s = input()
m = []
n = []
for i in range (len(s)-1) :
if s[i] == "A" and s[i+1] == "B" :
m.append(i)
if s[i] == "B" and s[i+1] == "A" :
n.append(i)
if min(len(m),len(n)) == 0 :
print("NO")
elif max(len(m),len(n)) > 2 :
print("YES")
elif len(m) == 2 and len(n) == 2 :
print("YES")
elif len(m) == 1 and len(n) == 2 :
if max(m[0]-n[0] , n[0]-m[0]) > 1 or max(m[0]-n[1] , n[1]-m[0]) > 1 :
print("YES")
else :
print("NO")
elif len(n) == 1 and len(m) == 2 :
if max(n[0]-m[0] , m[0]-n[0]) > 1 or max(n[0]-m[1] , -n[0]+m[1]) > 1 :
print("YES")
else :
print("NO")
else :
if m[0] - n[0] > 1 or n[0] - m[0] > 1 :
print("YES")
else :
print("NO")
``` | instruction | 0 | 85,348 | 0 | 170,696 |
Yes | output | 1 | 85,348 | 0 | 170,697 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string s. Your task is to determine if the given string s contains two non-overlapping substrings "AB" and "BA" (the substrings can go in any order).
Input
The only line of input contains a string s of length between 1 and 105 consisting of uppercase Latin letters.
Output
Print "YES" (without the quotes), if string s contains two non-overlapping substrings "AB" and "BA", and "NO" otherwise.
Examples
Input
ABA
Output
NO
Input
BACFAB
Output
YES
Input
AXBYBXA
Output
NO
Note
In the first sample test, despite the fact that there are substrings "AB" and "BA", their occurrences overlap, so the answer is "NO".
In the second sample test there are the following occurrences of the substrings: BACFAB.
In the third sample test there is no substring "AB" nor substring "BA".
Submitted Solution:
```
string= str(input())
answer="NO"
indexAB, indexBA = -1,-1
countAB, countBA = 0,0
for i in range(2,len(string)+1):
sub=string[i-2:i]
if(sub == "AB"):
indexAB= i
countAB+=1
if(sub == "BA"):
indexBA= i
countBA+=1
if(countAB == 1 and countBA == 1):
if(indexAB+1 != indexBA and indexAB != indexBA+1):
answer= "YES"
elif(countAB !=0 and countBA !=0):
answer="YES"
print(answer)
``` | instruction | 0 | 85,349 | 0 | 170,698 |
No | output | 1 | 85,349 | 0 | 170,699 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string s. Your task is to determine if the given string s contains two non-overlapping substrings "AB" and "BA" (the substrings can go in any order).
Input
The only line of input contains a string s of length between 1 and 105 consisting of uppercase Latin letters.
Output
Print "YES" (without the quotes), if string s contains two non-overlapping substrings "AB" and "BA", and "NO" otherwise.
Examples
Input
ABA
Output
NO
Input
BACFAB
Output
YES
Input
AXBYBXA
Output
NO
Note
In the first sample test, despite the fact that there are substrings "AB" and "BA", their occurrences overlap, so the answer is "NO".
In the second sample test there are the following occurrences of the substrings: BACFAB.
In the third sample test there is no substring "AB" nor substring "BA".
Submitted Solution:
```
inputString = input()
indexAB, indexBA = [-1 for i in range(2)], [-1 for i in range(2)]
for i in range(len(inputString)-1):
if (inputString[i] == 'A' and inputString[i+1] == 'B'):
if (indexAB[0] == -1):
indexAB[0] = i
if (indexAB[1] < i):
indexAB[1] = i
elif (inputString[i] == 'B' and inputString[i+1] == 'A'):
if (indexBA[0] == -1):
indexBA[0] = i
if (indexBA[1] < i):
indexBA[1] = i
if ((indexAB[0] == -1) and (indexBA[0] == -1) and ((indexBA[1] - indexAB[0] >= 2) or (indexAB[1] - indexBA[0] >= 2))):
print ("YES")
else:
print ("NO")
``` | instruction | 0 | 85,350 | 0 | 170,700 |
No | output | 1 | 85,350 | 0 | 170,701 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string s. Your task is to determine if the given string s contains two non-overlapping substrings "AB" and "BA" (the substrings can go in any order).
Input
The only line of input contains a string s of length between 1 and 105 consisting of uppercase Latin letters.
Output
Print "YES" (without the quotes), if string s contains two non-overlapping substrings "AB" and "BA", and "NO" otherwise.
Examples
Input
ABA
Output
NO
Input
BACFAB
Output
YES
Input
AXBYBXA
Output
NO
Note
In the first sample test, despite the fact that there are substrings "AB" and "BA", their occurrences overlap, so the answer is "NO".
In the second sample test there are the following occurrences of the substrings: BACFAB.
In the third sample test there is no substring "AB" nor substring "BA".
Submitted Solution:
```
# with open("input.txt","r") as f:
string = input()
abFlag = False
baFlag = False
i = 0
while(i<len(string)-1):
if(string[i]=="A" and string[i+1]=="B" and not abFlag):
abFlag =True
i+=1
elif(string[i]=="B" and string[i+1]=="A" and not baFlag):
baFlag = True
i+=1
i+=1
if(abFlag and baFlag):
break
if(abFlag and baFlag):
print("YES")
else:
print("NO")
``` | instruction | 0 | 85,351 | 0 | 170,702 |
No | output | 1 | 85,351 | 0 | 170,703 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given string s. Your task is to determine if the given string s contains two non-overlapping substrings "AB" and "BA" (the substrings can go in any order).
Input
The only line of input contains a string s of length between 1 and 105 consisting of uppercase Latin letters.
Output
Print "YES" (without the quotes), if string s contains two non-overlapping substrings "AB" and "BA", and "NO" otherwise.
Examples
Input
ABA
Output
NO
Input
BACFAB
Output
YES
Input
AXBYBXA
Output
NO
Note
In the first sample test, despite the fact that there are substrings "AB" and "BA", their occurrences overlap, so the answer is "NO".
In the second sample test there are the following occurrences of the substrings: BACFAB.
In the third sample test there is no substring "AB" nor substring "BA".
Submitted Solution:
```
s=input()
a1=s.count("AB")
a2=s.count("BA")
a3=s.count("ABA")
a4=s.count("BAB")
if a1!=0 and a2!=0:
if a1>1 or a2>1:
print("YES")
else:
if a3==0 and a4==0:
print("YES")
else:
print("NO")
else:
print("NO")
``` | instruction | 0 | 85,352 | 0 | 170,704 |
No | output | 1 | 85,352 | 0 | 170,705 |
Provide a correct Python 3 solution for this coding contest problem.
In this problem, we only consider strings consisting of lowercase English letters.
Strings s and t are said to be isomorphic when the following conditions are satisfied:
* |s| = |t| holds.
* For every pair i, j, one of the following holds:
* s_i = s_j and t_i = t_j.
* s_i \neq s_j and t_i \neq t_j.
For example, `abcac` and `zyxzx` are isomorphic, while `abcac` and `ppppp` are not.
A string s is said to be in normal form when the following condition is satisfied:
* For every string t that is isomorphic to s, s \leq t holds. Here \leq denotes lexicographic comparison.
For example, `abcac` is in normal form, but `zyxzx` is not since it is isomorphic to `abcac`, which is lexicographically smaller than `zyxzx`.
You are given an integer N. Print all strings of length N that are in normal form, in lexicographically ascending order.
Constraints
* 1 \leq N \leq 10
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Examples
Input
1
Output
a
Input
2
Output
aa
ab | instruction | 0 | 86,313 | 0 | 172,626 |
"Correct Solution:
```
N = int(input())
def standard(n, cur):
if n == 0:
print(''.join(cur))
else:
newC = chr(ord(sorted(cur)[-1]) + 1)
for c in sorted(set(cur + [newC])):
standard(n - 1, cur + [c])
standard(N - 1, ['a'])
``` | output | 1 | 86,313 | 0 | 172,627 |
Provide a correct Python 3 solution for this coding contest problem.
In this problem, we only consider strings consisting of lowercase English letters.
Strings s and t are said to be isomorphic when the following conditions are satisfied:
* |s| = |t| holds.
* For every pair i, j, one of the following holds:
* s_i = s_j and t_i = t_j.
* s_i \neq s_j and t_i \neq t_j.
For example, `abcac` and `zyxzx` are isomorphic, while `abcac` and `ppppp` are not.
A string s is said to be in normal form when the following condition is satisfied:
* For every string t that is isomorphic to s, s \leq t holds. Here \leq denotes lexicographic comparison.
For example, `abcac` is in normal form, but `zyxzx` is not since it is isomorphic to `abcac`, which is lexicographically smaller than `zyxzx`.
You are given an integer N. Print all strings of length N that are in normal form, in lexicographically ascending order.
Constraints
* 1 \leq N \leq 10
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Examples
Input
1
Output
a
Input
2
Output
aa
ab | instruction | 0 | 86,314 | 0 | 172,628 |
"Correct Solution:
```
N = int(input())
def calc(n, L, ma):
if n == 0:
print("".join([chr(a+97) for a in L]))
return L
for i in range(ma+2):
l = calc(n-1, L + [i], max(ma, i))
calc(N, [], -1)
``` | output | 1 | 86,314 | 0 | 172,629 |
Provide a correct Python 3 solution for this coding contest problem.
In this problem, we only consider strings consisting of lowercase English letters.
Strings s and t are said to be isomorphic when the following conditions are satisfied:
* |s| = |t| holds.
* For every pair i, j, one of the following holds:
* s_i = s_j and t_i = t_j.
* s_i \neq s_j and t_i \neq t_j.
For example, `abcac` and `zyxzx` are isomorphic, while `abcac` and `ppppp` are not.
A string s is said to be in normal form when the following condition is satisfied:
* For every string t that is isomorphic to s, s \leq t holds. Here \leq denotes lexicographic comparison.
For example, `abcac` is in normal form, but `zyxzx` is not since it is isomorphic to `abcac`, which is lexicographically smaller than `zyxzx`.
You are given an integer N. Print all strings of length N that are in normal form, in lexicographically ascending order.
Constraints
* 1 \leq N \leq 10
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Examples
Input
1
Output
a
Input
2
Output
aa
ab | instruction | 0 | 86,315 | 0 | 172,630 |
"Correct Solution:
```
def dfs(a='', b=chr(ord('a'))):
if len(a) == N:
print(a)
else:
i = chr(ord('a'))
while i < b:
dfs(a + i, b)
i = chr(ord(i) + 1)
dfs(a + b, chr(ord(b) + 1))
N = int(input())
dfs()
``` | output | 1 | 86,315 | 0 | 172,631 |
Provide a correct Python 3 solution for this coding contest problem.
In this problem, we only consider strings consisting of lowercase English letters.
Strings s and t are said to be isomorphic when the following conditions are satisfied:
* |s| = |t| holds.
* For every pair i, j, one of the following holds:
* s_i = s_j and t_i = t_j.
* s_i \neq s_j and t_i \neq t_j.
For example, `abcac` and `zyxzx` are isomorphic, while `abcac` and `ppppp` are not.
A string s is said to be in normal form when the following condition is satisfied:
* For every string t that is isomorphic to s, s \leq t holds. Here \leq denotes lexicographic comparison.
For example, `abcac` is in normal form, but `zyxzx` is not since it is isomorphic to `abcac`, which is lexicographically smaller than `zyxzx`.
You are given an integer N. Print all strings of length N that are in normal form, in lexicographically ascending order.
Constraints
* 1 \leq N \leq 10
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Examples
Input
1
Output
a
Input
2
Output
aa
ab | instruction | 0 | 86,316 | 0 | 172,632 |
"Correct Solution:
```
N = int(input())
def dfs(s, mx):
if len(s) == N:
print(s)
return
for c in 'abcdefghij'[:(ord(mx)-ord('a'))+1]:
dfs(s+c, chr(ord(mx)+1)) if c == mx else dfs(s+c, mx)
dfs('', 'a')
``` | output | 1 | 86,316 | 0 | 172,633 |
Provide a correct Python 3 solution for this coding contest problem.
In this problem, we only consider strings consisting of lowercase English letters.
Strings s and t are said to be isomorphic when the following conditions are satisfied:
* |s| = |t| holds.
* For every pair i, j, one of the following holds:
* s_i = s_j and t_i = t_j.
* s_i \neq s_j and t_i \neq t_j.
For example, `abcac` and `zyxzx` are isomorphic, while `abcac` and `ppppp` are not.
A string s is said to be in normal form when the following condition is satisfied:
* For every string t that is isomorphic to s, s \leq t holds. Here \leq denotes lexicographic comparison.
For example, `abcac` is in normal form, but `zyxzx` is not since it is isomorphic to `abcac`, which is lexicographically smaller than `zyxzx`.
You are given an integer N. Print all strings of length N that are in normal form, in lexicographically ascending order.
Constraints
* 1 \leq N \leq 10
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Examples
Input
1
Output
a
Input
2
Output
aa
ab | instruction | 0 | 86,317 | 0 | 172,634 |
"Correct Solution:
```
n = int(input())
def dfs(s, mx):
if len(s) == n:
print(''.join([chr(ord('a') + i) for i in s]))
else:
for i in range(mx+1):
dfs(s + [i], mx if i != mx else mx + 1)
dfs([], 0)
``` | output | 1 | 86,317 | 0 | 172,635 |
Provide a correct Python 3 solution for this coding contest problem.
In this problem, we only consider strings consisting of lowercase English letters.
Strings s and t are said to be isomorphic when the following conditions are satisfied:
* |s| = |t| holds.
* For every pair i, j, one of the following holds:
* s_i = s_j and t_i = t_j.
* s_i \neq s_j and t_i \neq t_j.
For example, `abcac` and `zyxzx` are isomorphic, while `abcac` and `ppppp` are not.
A string s is said to be in normal form when the following condition is satisfied:
* For every string t that is isomorphic to s, s \leq t holds. Here \leq denotes lexicographic comparison.
For example, `abcac` is in normal form, but `zyxzx` is not since it is isomorphic to `abcac`, which is lexicographically smaller than `zyxzx`.
You are given an integer N. Print all strings of length N that are in normal form, in lexicographically ascending order.
Constraints
* 1 \leq N \leq 10
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Examples
Input
1
Output
a
Input
2
Output
aa
ab | instruction | 0 | 86,318 | 0 | 172,636 |
"Correct Solution:
```
n = int(input())
a = ord('a')
def dfs(s, m):
# print("dfs", s, chr(m))
if len(s) == n:
print(s)
else:
for i in range(m + 1 - a):
dfs(s + chr(a + i), m + 1 if i == m - a else m)
dfs("", a)
``` | output | 1 | 86,318 | 0 | 172,637 |
Provide a correct Python 3 solution for this coding contest problem.
In this problem, we only consider strings consisting of lowercase English letters.
Strings s and t are said to be isomorphic when the following conditions are satisfied:
* |s| = |t| holds.
* For every pair i, j, one of the following holds:
* s_i = s_j and t_i = t_j.
* s_i \neq s_j and t_i \neq t_j.
For example, `abcac` and `zyxzx` are isomorphic, while `abcac` and `ppppp` are not.
A string s is said to be in normal form when the following condition is satisfied:
* For every string t that is isomorphic to s, s \leq t holds. Here \leq denotes lexicographic comparison.
For example, `abcac` is in normal form, but `zyxzx` is not since it is isomorphic to `abcac`, which is lexicographically smaller than `zyxzx`.
You are given an integer N. Print all strings of length N that are in normal form, in lexicographically ascending order.
Constraints
* 1 \leq N \leq 10
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Examples
Input
1
Output
a
Input
2
Output
aa
ab | instruction | 0 | 86,319 | 0 | 172,638 |
"Correct Solution:
```
n=int(input())
l=[["a"]]+[[] for i in range(9)]
for i in range(9):
for j in l[i]:
k=len(set(list(j)))
for h in range(k+1):
l[i+1].append(j+chr(97+h))
for i in l[n-1]:print(i)
``` | output | 1 | 86,319 | 0 | 172,639 |
Provide a correct Python 3 solution for this coding contest problem.
In this problem, we only consider strings consisting of lowercase English letters.
Strings s and t are said to be isomorphic when the following conditions are satisfied:
* |s| = |t| holds.
* For every pair i, j, one of the following holds:
* s_i = s_j and t_i = t_j.
* s_i \neq s_j and t_i \neq t_j.
For example, `abcac` and `zyxzx` are isomorphic, while `abcac` and `ppppp` are not.
A string s is said to be in normal form when the following condition is satisfied:
* For every string t that is isomorphic to s, s \leq t holds. Here \leq denotes lexicographic comparison.
For example, `abcac` is in normal form, but `zyxzx` is not since it is isomorphic to `abcac`, which is lexicographically smaller than `zyxzx`.
You are given an integer N. Print all strings of length N that are in normal form, in lexicographically ascending order.
Constraints
* 1 \leq N \leq 10
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Examples
Input
1
Output
a
Input
2
Output
aa
ab | instruction | 0 | 86,320 | 0 | 172,640 |
"Correct Solution:
```
n = int(input())
def dfs(s, mx):
if len(s) == n:
print(s)
return
for c in range(ord("a"), mx+2):
dfs(s+chr(c), max(mx, c))
dfs("", ord("a")-1)
``` | output | 1 | 86,320 | 0 | 172,641 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this problem, we only consider strings consisting of lowercase English letters.
Strings s and t are said to be isomorphic when the following conditions are satisfied:
* |s| = |t| holds.
* For every pair i, j, one of the following holds:
* s_i = s_j and t_i = t_j.
* s_i \neq s_j and t_i \neq t_j.
For example, `abcac` and `zyxzx` are isomorphic, while `abcac` and `ppppp` are not.
A string s is said to be in normal form when the following condition is satisfied:
* For every string t that is isomorphic to s, s \leq t holds. Here \leq denotes lexicographic comparison.
For example, `abcac` is in normal form, but `zyxzx` is not since it is isomorphic to `abcac`, which is lexicographically smaller than `zyxzx`.
You are given an integer N. Print all strings of length N that are in normal form, in lexicographically ascending order.
Constraints
* 1 \leq N \leq 10
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Examples
Input
1
Output
a
Input
2
Output
aa
ab
Submitted Solution:
```
str = 'abcdefghijklmnop'
def bt(n,m,s):
if n == 0:
print(s)
return
for c in range(m):
bt(n-1,m,s+str[c])
#introduce another character
bt(n-1,m+1,s+str[m])
n = int(input())
bt(n,0,'')
``` | instruction | 0 | 86,321 | 0 | 172,642 |
Yes | output | 1 | 86,321 | 0 | 172,643 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this problem, we only consider strings consisting of lowercase English letters.
Strings s and t are said to be isomorphic when the following conditions are satisfied:
* |s| = |t| holds.
* For every pair i, j, one of the following holds:
* s_i = s_j and t_i = t_j.
* s_i \neq s_j and t_i \neq t_j.
For example, `abcac` and `zyxzx` are isomorphic, while `abcac` and `ppppp` are not.
A string s is said to be in normal form when the following condition is satisfied:
* For every string t that is isomorphic to s, s \leq t holds. Here \leq denotes lexicographic comparison.
For example, `abcac` is in normal form, but `zyxzx` is not since it is isomorphic to `abcac`, which is lexicographically smaller than `zyxzx`.
You are given an integer N. Print all strings of length N that are in normal form, in lexicographically ascending order.
Constraints
* 1 \leq N \leq 10
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Examples
Input
1
Output
a
Input
2
Output
aa
ab
Submitted Solution:
```
n = int(input())
A= 'a'
# 文字数を増やして, その各々の元に対して文字を追加する.
for _ in range(n - 1):
A = {a + s for a in A for s in a + chr(ord(max(a)) + 1)}
# print(A)
# 最後にsortして調整する.
#print(*A, sep = '\n')
print(*sorted(A), sep='\n')
``` | instruction | 0 | 86,322 | 0 | 172,644 |
Yes | output | 1 | 86,322 | 0 | 172,645 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this problem, we only consider strings consisting of lowercase English letters.
Strings s and t are said to be isomorphic when the following conditions are satisfied:
* |s| = |t| holds.
* For every pair i, j, one of the following holds:
* s_i = s_j and t_i = t_j.
* s_i \neq s_j and t_i \neq t_j.
For example, `abcac` and `zyxzx` are isomorphic, while `abcac` and `ppppp` are not.
A string s is said to be in normal form when the following condition is satisfied:
* For every string t that is isomorphic to s, s \leq t holds. Here \leq denotes lexicographic comparison.
For example, `abcac` is in normal form, but `zyxzx` is not since it is isomorphic to `abcac`, which is lexicographically smaller than `zyxzx`.
You are given an integer N. Print all strings of length N that are in normal form, in lexicographically ascending order.
Constraints
* 1 \leq N \leq 10
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Examples
Input
1
Output
a
Input
2
Output
aa
ab
Submitted Solution:
```
n = int(input())
s = "abcdefghij"
def func(a):
if len(a) == n:
print(a)
else:
for i in range(len(set(a))+1):
func(a+s[i])
func("a")
``` | instruction | 0 | 86,323 | 0 | 172,646 |
Yes | output | 1 | 86,323 | 0 | 172,647 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this problem, we only consider strings consisting of lowercase English letters.
Strings s and t are said to be isomorphic when the following conditions are satisfied:
* |s| = |t| holds.
* For every pair i, j, one of the following holds:
* s_i = s_j and t_i = t_j.
* s_i \neq s_j and t_i \neq t_j.
For example, `abcac` and `zyxzx` are isomorphic, while `abcac` and `ppppp` are not.
A string s is said to be in normal form when the following condition is satisfied:
* For every string t that is isomorphic to s, s \leq t holds. Here \leq denotes lexicographic comparison.
For example, `abcac` is in normal form, but `zyxzx` is not since it is isomorphic to `abcac`, which is lexicographically smaller than `zyxzx`.
You are given an integer N. Print all strings of length N that are in normal form, in lexicographically ascending order.
Constraints
* 1 \leq N \leq 10
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Examples
Input
1
Output
a
Input
2
Output
aa
ab
Submitted Solution:
```
N = int(input())
strlist = 'abcdefghij'
def dfs(s, i):
if len(s) == N:
print(s)
else:
for j in range(i+1):
t = s + strlist[j]
if j == i:
dfs(t, i+1)
else:
dfs(t, i)
dfs('', 0)
``` | instruction | 0 | 86,324 | 0 | 172,648 |
Yes | output | 1 | 86,324 | 0 | 172,649 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this problem, we only consider strings consisting of lowercase English letters.
Strings s and t are said to be isomorphic when the following conditions are satisfied:
* |s| = |t| holds.
* For every pair i, j, one of the following holds:
* s_i = s_j and t_i = t_j.
* s_i \neq s_j and t_i \neq t_j.
For example, `abcac` and `zyxzx` are isomorphic, while `abcac` and `ppppp` are not.
A string s is said to be in normal form when the following condition is satisfied:
* For every string t that is isomorphic to s, s \leq t holds. Here \leq denotes lexicographic comparison.
For example, `abcac` is in normal form, but `zyxzx` is not since it is isomorphic to `abcac`, which is lexicographically smaller than `zyxzx`.
You are given an integer N. Print all strings of length N that are in normal form, in lexicographically ascending order.
Constraints
* 1 \leq N \leq 10
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Examples
Input
1
Output
a
Input
2
Output
aa
ab
Submitted Solution:
```
from collections import deque
import sys
N = int(input())
if N == 1:
print('a')
sys.exit()
else:
ans = []
def solve(s):
if len(s) == N:
ans.append(s)
return
cp = s[-1]
o = ord(cp)
for n in range(97, o+2):
solve(s + chr(n))
solve('a')
for a in ans:
print(a)
``` | instruction | 0 | 86,325 | 0 | 172,650 |
No | output | 1 | 86,325 | 0 | 172,651 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this problem, we only consider strings consisting of lowercase English letters.
Strings s and t are said to be isomorphic when the following conditions are satisfied:
* |s| = |t| holds.
* For every pair i, j, one of the following holds:
* s_i = s_j and t_i = t_j.
* s_i \neq s_j and t_i \neq t_j.
For example, `abcac` and `zyxzx` are isomorphic, while `abcac` and `ppppp` are not.
A string s is said to be in normal form when the following condition is satisfied:
* For every string t that is isomorphic to s, s \leq t holds. Here \leq denotes lexicographic comparison.
For example, `abcac` is in normal form, but `zyxzx` is not since it is isomorphic to `abcac`, which is lexicographically smaller than `zyxzx`.
You are given an integer N. Print all strings of length N that are in normal form, in lexicographically ascending order.
Constraints
* 1 \leq N \leq 10
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Examples
Input
1
Output
a
Input
2
Output
aa
ab
Submitted Solution:
```
n = int(input())
tmp_list = list('a' * n)
num_list = [97] * n
target = n - 1
tmp_target=n-1
max_num=97
while tmp_target>0:
print("".join(list(map(chr, num_list))))
if max(num_list[0:target:]) >= num_list[target]:
num_list[target] += 1
else:
num_list[target]=97
tmp_target=target-1
while tmp_target>0:
if max(num_list[0:tmp_target:]) >=num_list[tmp_target]:
num_list[tmp_target]+=1
break
else:
num_list[tmp_target]=97
tmp_target-=1
``` | instruction | 0 | 86,326 | 0 | 172,652 |
No | output | 1 | 86,326 | 0 | 172,653 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this problem, we only consider strings consisting of lowercase English letters.
Strings s and t are said to be isomorphic when the following conditions are satisfied:
* |s| = |t| holds.
* For every pair i, j, one of the following holds:
* s_i = s_j and t_i = t_j.
* s_i \neq s_j and t_i \neq t_j.
For example, `abcac` and `zyxzx` are isomorphic, while `abcac` and `ppppp` are not.
A string s is said to be in normal form when the following condition is satisfied:
* For every string t that is isomorphic to s, s \leq t holds. Here \leq denotes lexicographic comparison.
For example, `abcac` is in normal form, but `zyxzx` is not since it is isomorphic to `abcac`, which is lexicographically smaller than `zyxzx`.
You are given an integer N. Print all strings of length N that are in normal form, in lexicographically ascending order.
Constraints
* 1 \leq N \leq 10
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Examples
Input
1
Output
a
Input
2
Output
aa
ab
Submitted Solution:
```
import string
import itertools
alphabets = string.ascii_lowercase
N = int(input())
def bfs(s, d):
if d == N - 1:
print(s)
return s
res = []
for i in range(ord(s[-1]) - ord("a") + 2):
res.append(bfs(s + alphabets[i], d + 1))
# return res
bfs("a", 0)
# print(list(bfs("a", 0)))
``` | instruction | 0 | 86,327 | 0 | 172,654 |
No | output | 1 | 86,327 | 0 | 172,655 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this problem, we only consider strings consisting of lowercase English letters.
Strings s and t are said to be isomorphic when the following conditions are satisfied:
* |s| = |t| holds.
* For every pair i, j, one of the following holds:
* s_i = s_j and t_i = t_j.
* s_i \neq s_j and t_i \neq t_j.
For example, `abcac` and `zyxzx` are isomorphic, while `abcac` and `ppppp` are not.
A string s is said to be in normal form when the following condition is satisfied:
* For every string t that is isomorphic to s, s \leq t holds. Here \leq denotes lexicographic comparison.
For example, `abcac` is in normal form, but `zyxzx` is not since it is isomorphic to `abcac`, which is lexicographically smaller than `zyxzx`.
You are given an integer N. Print all strings of length N that are in normal form, in lexicographically ascending order.
Constraints
* 1 \leq N \leq 10
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Output
Assume that there are K strings of length N that are in normal form: w_1, \ldots, w_K in lexicographical order. Output should be in the following format:
w_1
:
w_K
Examples
Input
1
Output
a
Input
2
Output
aa
ab
Submitted Solution:
```
n = int(input())
a = [ [] for _ in range(11) ]
a[0].append("a")
alp = "abcdefghijklmn"
for i in range(1, 10):
for aa in a[i-1]:
for c in alp[:i+1]:
if ord(aa[-1])+1 < ord(c): break
a[i].append(aa+c)
for ans in a[n-1]:
print(ans)
``` | instruction | 0 | 86,328 | 0 | 172,656 |
No | output | 1 | 86,328 | 0 | 172,657 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'. | instruction | 0 | 86,688 | 0 | 173,376 |
Tags: strings
Correct Solution:
```
n = int(input())
l = list(input())
count = 0
for i in range(0, n, 2):
if (l[i] == l[i + 1]):
l[i] = chr(1 - ord(l[i]) + 2 * ord('a'))
count += 1
print(count)
print(''.join(l))
``` | output | 1 | 86,688 | 0 | 173,377 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'. | instruction | 0 | 86,689 | 0 | 173,378 |
Tags: strings
Correct Solution:
```
n=int(input())
a=list(input())
k=0
for i in range(n-1):
if((i==n-2) and a[i]==a[i+1]):
k+=1
if(a[i]=="a"):
a[i]="b"
else:
a[i]="a"
elif((i%2!=0) and (a[i]==a[i-1])):
if(a[i]=="a"):
a[i]="b"
else:
a[i]="a"
k+=1
print(k)
print("".join(a))
``` | output | 1 | 86,689 | 0 | 173,379 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'. | instruction | 0 | 86,690 | 0 | 173,380 |
Tags: strings
Correct Solution:
```
n = int(input())
s = input()
ans = 0
for i in range(1, n , 2):
if(s[i] == s[i - 1]):
ans = ans + 1
print(ans)
for i in range(1, n , 2):
print(s[i - 1],end = "")
if(s[i - 1] == s[i]):
if(s[i] == 'a'):
print('b',end = "")
else:
print('a',end = "")
else:
print(s[i], end = "")
``` | output | 1 | 86,690 | 0 | 173,381 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'. | instruction | 0 | 86,691 | 0 | 173,382 |
Tags: strings
Correct Solution:
```
a = int(input())
nlist = input()
str = list(nlist)
i = 0
k = 2
count = 0
while i<=len(str):
n_str = str[i:k]
acnt = n_str.count('a')
bcnt = n_str.count('b')
if acnt!=bcnt:
count +=1
if acnt == 2:
str[i] = 'b'
else:
str[i] = 'a'
i = k
k += 2
print(count)
str = ''.join(str)
print(str)
``` | output | 1 | 86,691 | 0 | 173,383 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'. | instruction | 0 | 86,692 | 0 | 173,384 |
Tags: strings
Correct Solution:
```
n = int(input())
s = list(input())
k = 0
for i in range(0, n, 2):
if(s[i] == s[i+1] and s[i] == "a"):
s[i + 1] = "b"
k += 1
elif(s[i] == s[i+1] and s[i] == "b"):
s[i + 1] = "a"
k += 1
print(k)
print("".join(s))
``` | output | 1 | 86,692 | 0 | 173,385 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'. | instruction | 0 | 86,693 | 0 | 173,386 |
Tags: strings
Correct Solution:
```
import sys
input = sys.stdin.readline
n = int(input())
s = list(input()[:-1])
ans = 0
for i in range(0, n, 2):
if s[i]=='a' and s[i+1]=='a':
s[i] = 'b'
ans += 1
elif s[i]=='b' and s[i+1]=='b':
s[i] = 'a'
ans += 1
print(ans)
print(''.join(s))
``` | output | 1 | 86,693 | 0 | 173,387 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'. | instruction | 0 | 86,694 | 0 | 173,388 |
Tags: strings
Correct Solution:
```
import sys
import math
#to read string
get_string = lambda: sys.stdin.readline().strip()
#to read list of integers
get_int_list = lambda: list( map(int,sys.stdin.readline().strip().split()) )
#to read non spaced string and elements are integers to list of int
get_intList_from_str = lambda: list(map(int,list(sys.stdin.readline().strip())))
#to read non spaced string and elements are character to list of character
get_charList_from_str = lambda: list(sys.stdin.readline().strip())
#get word sepetared list of character
get_char_list = lambda: sys.stdin.readline().strip().split()
#to read integers
get_int = lambda: int(sys.stdin.readline())
#to print faster
pt = lambda x: sys.stdout.write(str(x))
#--------------------------------WhiteHat010--------------------------------------#
n =get_int()
lst = list(get_string())
count = 0
for i in range(0,n,2):
if lst[i] == lst[i+1]:
if lst[i] == 'a':
lst[i] = 'b'
count += 1
else:
lst[i] = 'a'
count += 1
print(count)
print(''.join(lst))
``` | output | 1 | 86,694 | 0 | 173,389 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'. | instruction | 0 | 86,695 | 0 | 173,390 |
Tags: strings
Correct Solution:
```
n = int(input())
string = list(input())
count = 0
for i in range(0,n-1, 2):
if string[i] == 'a' and string[i+1] == 'a':
string[i] = 'b'
count+=1
if string[i] == 'b' and string[i+1] == 'b':
string[i] = 'a'
count+=1
print(str(count))
for i in string:
print(i,end='')
``` | output | 1 | 86,695 | 0 | 173,391 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Submitted Solution:
```
n=int(input())
s=list(input())
res,result=0,''
for i in range(0,n-1,2):
if s[i]=='a' and s[i+1]=='a' or s[i]=='b' and s[i+1]=='b':
res+=1
result+='ab'
else:result+=s[i]+s[i+1]
print(res)
print(result)
``` | instruction | 0 | 86,696 | 0 | 173,392 |
Yes | output | 1 | 86,696 | 0 | 173,393 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Submitted Solution:
```
n = int(input())
s = list(input())
times = 0
for i in range(n):
if i % 2 == 0:
continue
else:
if s[i] == s[i-1]:
times += 1
if s[i] == 'a':
s[i] = 'b'
else:
s[i] = 'a'
print(times)
print(''.join(s))
``` | instruction | 0 | 86,697 | 0 | 173,394 |
Yes | output | 1 | 86,697 | 0 | 173,395 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Submitted Solution:
```
n = int(input())
l = list(input())
ans=0
for i in range(0,n,2):
if(l[i]==l[i+1]):
ans+=1
if(l[i]=='a'):
l[i]='b'
else:
l[i]='a'
print(ans)
print(''.join(l))
``` | instruction | 0 | 86,698 | 0 | 173,396 |
Yes | output | 1 | 86,698 | 0 | 173,397 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Submitted Solution:
```
length = int(input())
string = input()
operations = 0
altered = []
for i in range(0, length, 2):
if string[i] == string[i + 1]:
operations += 1
if string[i] == 'a':
altered.append('ab')
else:
altered.append('ba')
print(operations)
print("".join(altered))
``` | instruction | 0 | 86,699 | 0 | 173,398 |
Yes | output | 1 | 86,699 | 0 | 173,399 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Submitted Solution:
```
# *-* coding=utf-8 *-*
input()
s = input()
ans = 0
l = list(s)
for i in range(len(l)//2):
if l[2*i-1] == l[2*i]:
ans += 1
if l[2*i] == 'a': l[2*i] = 'b'
else: l[2*i] = 'a'
print(ans, ''.join(l), sep='\n')
``` | instruction | 0 | 86,700 | 0 | 173,400 |
No | output | 1 | 86,700 | 0 | 173,401 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Submitted Solution:
```
import sys
n = int(sys.stdin.readline())
string1 = list(sys.stdin.readline().strip())
string2 = string1[:]
cnt_1 = 0
cnt_2 = 0
for i in range(n):
if i % 2 != 0 and string1[i] == 'a': # ab
# print("call1")
cnt_1 += 1
string1[i] = 'b'
elif i % 2 == 0 and string1[i] == 'b':
# print("call2")
cnt_1 += 1
string1[i] = 'a'
for j in range(n): # ba
if j % 2 != 0 and string2[j] == 'b':
# print("call3")
cnt_2 += 1
string2[j] = 'a'
elif j % 2 == 0 and string2[j] == 'a':
# print("call4")
cnt_2 += 1
string2[j] = 'b'
if cnt_1 >= cnt_2:
print(cnt_2)
for i in string2:
print(i, end='')
else:
print(cnt_1)
for j in string1:
print(j, end='')
``` | instruction | 0 | 86,701 | 0 | 173,402 |
No | output | 1 | 86,701 | 0 | 173,403 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Submitted Solution:
```
if __name__ == '__main__':
n = int(input())
txt = list(input())
print(2)
print('abab')
``` | instruction | 0 | 86,702 | 0 | 173,404 |
No | output | 1 | 86,702 | 0 | 173,405 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Submitted Solution:
```
n = int(input())
s = input()
a = [x for x in s]
res = 0
if a[0] == 'a':
for i in range(1, n):
if i % 2 == 1:
if a[i] == 'a':
res += 1
a[i] = 'b'
else:
if a[i] == 'b':
res += 1
a[i] = 'a'
else:
for i in range(1, n):
if i % 2 == 1:
if a[i] == 'b':
res += 1
a[i] = 'a'
else:
if a[i] == 'a':
res += 1
a[i] = 'b'
print(res)
for x in a:
print(x, end="")
``` | instruction | 0 | 86,703 | 0 | 173,406 |
No | output | 1 | 86,703 | 0 | 173,407 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got string s, consisting of small English letters. Some of the English letters are good, the rest are bad.
A substring s[l...r] (1 ≤ l ≤ r ≤ |s|) of string s = s1s2...s|s| (where |s| is the length of string s) is string slsl + 1...sr.
The substring s[l...r] is good, if among the letters sl, sl + 1, ..., sr there are at most k bad ones (look at the sample's explanation to understand it more clear).
Your task is to find the number of distinct good substrings of the given string s. Two substrings s[x...y] and s[p...q] are considered distinct if their content is different, i.e. s[x...y] ≠ s[p...q].
Input
The first line of the input is the non-empty string s, consisting of small English letters, the string's length is at most 1500 characters.
The second line of the input is the string of characters "0" and "1", the length is exactly 26 characters. If the i-th character of this string equals "1", then the i-th English letter is good, otherwise it's bad. That is, the first character of this string corresponds to letter "a", the second one corresponds to letter "b" and so on.
The third line of the input consists a single integer k (0 ≤ k ≤ |s|) — the maximum acceptable number of bad characters in a good substring.
Output
Print a single integer — the number of distinct good substrings of string s.
Examples
Input
ababab
01000000000000000000000000
1
Output
5
Input
acbacbacaa
00000000000000000000000000
2
Output
8
Note
In the first example there are following good substrings: "a", "ab", "b", "ba", "bab".
In the second example there are following good substrings: "a", "aa", "ac", "b", "ba", "c", "ca", "cb". | instruction | 0 | 86,936 | 0 | 173,872 |
Tags: data structures, strings
Correct Solution:
```
# -*- coding:utf-8 -*-
"""
created by shuangquan.huang at 1/7/20
"""
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def solve(S, B, K):
MOD = (1 << 50) + 9
s = set()
N = len(S)
pow = [1 for _ in range(N+1)]
for i in range(1, N+1):
pow[i] = pow[i-1] * 26
pow[i] %= MOD
for i in range(N-1, -1, -1):
k, h = 0, 0
for j in range(i, -1, -1):
ch = S[j]
if B[ch]:
k += 1
if k > K:
# print(i, j, S[i: j+1])
break
h += (ord(ch) - ord('a') + 1) * pow[i-j]
h %= MOD
# print(S[i: j + 1], h)
s.add(h)
return len(s)
S = input()
B = list(input())
K = int(input())
B = {chr(ord('a') + i): False if B[i] == '1' else True for i in range(26)}
print(solve(S, B, K))
``` | output | 1 | 86,936 | 0 | 173,873 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got string s, consisting of small English letters. Some of the English letters are good, the rest are bad.
A substring s[l...r] (1 ≤ l ≤ r ≤ |s|) of string s = s1s2...s|s| (where |s| is the length of string s) is string slsl + 1...sr.
The substring s[l...r] is good, if among the letters sl, sl + 1, ..., sr there are at most k bad ones (look at the sample's explanation to understand it more clear).
Your task is to find the number of distinct good substrings of the given string s. Two substrings s[x...y] and s[p...q] are considered distinct if their content is different, i.e. s[x...y] ≠ s[p...q].
Input
The first line of the input is the non-empty string s, consisting of small English letters, the string's length is at most 1500 characters.
The second line of the input is the string of characters "0" and "1", the length is exactly 26 characters. If the i-th character of this string equals "1", then the i-th English letter is good, otherwise it's bad. That is, the first character of this string corresponds to letter "a", the second one corresponds to letter "b" and so on.
The third line of the input consists a single integer k (0 ≤ k ≤ |s|) — the maximum acceptable number of bad characters in a good substring.
Output
Print a single integer — the number of distinct good substrings of string s.
Examples
Input
ababab
01000000000000000000000000
1
Output
5
Input
acbacbacaa
00000000000000000000000000
2
Output
8
Note
In the first example there are following good substrings: "a", "ab", "b", "ba", "bab".
In the second example there are following good substrings: "a", "aa", "ac", "b", "ba", "c", "ca", "cb". | instruction | 0 | 86,937 | 0 | 173,874 |
Tags: data structures, strings
Correct Solution:
```
s = input()
a = input()
k = int(input())
S=sorted(s[i:] for i in range(len(s)))
p=''
r=0
for e in S:
t=0
s=0
for i in range(len(e)):
if i >= len(p) or e[i] != p[i]: s=1
t+=a[ord(e[i])-ord('a')]=='0'
if t > k:break
if s: r+=1
p = e
print(r)
``` | output | 1 | 86,937 | 0 | 173,875 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got string s, consisting of small English letters. Some of the English letters are good, the rest are bad.
A substring s[l...r] (1 ≤ l ≤ r ≤ |s|) of string s = s1s2...s|s| (where |s| is the length of string s) is string slsl + 1...sr.
The substring s[l...r] is good, if among the letters sl, sl + 1, ..., sr there are at most k bad ones (look at the sample's explanation to understand it more clear).
Your task is to find the number of distinct good substrings of the given string s. Two substrings s[x...y] and s[p...q] are considered distinct if their content is different, i.e. s[x...y] ≠ s[p...q].
Input
The first line of the input is the non-empty string s, consisting of small English letters, the string's length is at most 1500 characters.
The second line of the input is the string of characters "0" and "1", the length is exactly 26 characters. If the i-th character of this string equals "1", then the i-th English letter is good, otherwise it's bad. That is, the first character of this string corresponds to letter "a", the second one corresponds to letter "b" and so on.
The third line of the input consists a single integer k (0 ≤ k ≤ |s|) — the maximum acceptable number of bad characters in a good substring.
Output
Print a single integer — the number of distinct good substrings of string s.
Examples
Input
ababab
01000000000000000000000000
1
Output
5
Input
acbacbacaa
00000000000000000000000000
2
Output
8
Note
In the first example there are following good substrings: "a", "ab", "b", "ba", "bab".
In the second example there are following good substrings: "a", "aa", "ac", "b", "ba", "c", "ca", "cb". | instruction | 0 | 86,938 | 0 | 173,876 |
Tags: data structures, strings
Correct Solution:
```
s = input()
l = input()
k = int(input())
no_bad = []
curr = 0
p =31
m = 67280421310721
hashes = []
currh = 0
cnt = 0
P = [pow(p,i,m) for i in range(len(s)+2)]
for i in s:
currh+=(P[cnt]*ord(i))%m
cnt+=1
hashes.append(currh)
if(l[ord(i) - ord('a')] =='0'):
no_bad.append(curr+1)
curr+=1
else:
no_bad.append(curr)
no_bad.append(0)
hashes.append(0)
ans = set()
for i in range(len(s)):
for j in range(i,len(s)):
if(no_bad[j] - no_bad[i-1]<=k):
has = ((hashes[j] - hashes[i-1])*P[len(s)-i+1])%m
ans.add(has)
print(len(ans))
``` | output | 1 | 86,938 | 0 | 173,877 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got string s, consisting of small English letters. Some of the English letters are good, the rest are bad.
A substring s[l...r] (1 ≤ l ≤ r ≤ |s|) of string s = s1s2...s|s| (where |s| is the length of string s) is string slsl + 1...sr.
The substring s[l...r] is good, if among the letters sl, sl + 1, ..., sr there are at most k bad ones (look at the sample's explanation to understand it more clear).
Your task is to find the number of distinct good substrings of the given string s. Two substrings s[x...y] and s[p...q] are considered distinct if their content is different, i.e. s[x...y] ≠ s[p...q].
Input
The first line of the input is the non-empty string s, consisting of small English letters, the string's length is at most 1500 characters.
The second line of the input is the string of characters "0" and "1", the length is exactly 26 characters. If the i-th character of this string equals "1", then the i-th English letter is good, otherwise it's bad. That is, the first character of this string corresponds to letter "a", the second one corresponds to letter "b" and so on.
The third line of the input consists a single integer k (0 ≤ k ≤ |s|) — the maximum acceptable number of bad characters in a good substring.
Output
Print a single integer — the number of distinct good substrings of string s.
Examples
Input
ababab
01000000000000000000000000
1
Output
5
Input
acbacbacaa
00000000000000000000000000
2
Output
8
Note
In the first example there are following good substrings: "a", "ab", "b", "ba", "bab".
In the second example there are following good substrings: "a", "aa", "ac", "b", "ba", "c", "ca", "cb". | instruction | 0 | 86,939 | 0 | 173,878 |
Tags: data structures, strings
Correct Solution:
```
s = input()
a = input()
k = int(input())
d = sorted(s[i:] for i in range(len(s)))
c = ''
r = 0
for j in d:
pos = 0
s = 0
for i in range(len(j)):
if i >= len(c) or j[i] != c[i]:
s = 1
if a[ord(j[i]) - ord('a')] == '0':
pos += 1
if pos > k:
break
if s:
r += 1
c = j
print(r)
``` | output | 1 | 86,939 | 0 | 173,879 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got string s, consisting of small English letters. Some of the English letters are good, the rest are bad.
A substring s[l...r] (1 ≤ l ≤ r ≤ |s|) of string s = s1s2...s|s| (where |s| is the length of string s) is string slsl + 1...sr.
The substring s[l...r] is good, if among the letters sl, sl + 1, ..., sr there are at most k bad ones (look at the sample's explanation to understand it more clear).
Your task is to find the number of distinct good substrings of the given string s. Two substrings s[x...y] and s[p...q] are considered distinct if their content is different, i.e. s[x...y] ≠ s[p...q].
Input
The first line of the input is the non-empty string s, consisting of small English letters, the string's length is at most 1500 characters.
The second line of the input is the string of characters "0" and "1", the length is exactly 26 characters. If the i-th character of this string equals "1", then the i-th English letter is good, otherwise it's bad. That is, the first character of this string corresponds to letter "a", the second one corresponds to letter "b" and so on.
The third line of the input consists a single integer k (0 ≤ k ≤ |s|) — the maximum acceptable number of bad characters in a good substring.
Output
Print a single integer — the number of distinct good substrings of string s.
Examples
Input
ababab
01000000000000000000000000
1
Output
5
Input
acbacbacaa
00000000000000000000000000
2
Output
8
Note
In the first example there are following good substrings: "a", "ab", "b", "ba", "bab".
In the second example there are following good substrings: "a", "aa", "ac", "b", "ba", "c", "ca", "cb". | instruction | 0 | 86,940 | 0 | 173,880 |
Tags: data structures, strings
Correct Solution:
```
def index(c):
return ord(c) - ord('a')
class Trie:
def __init__(self):
self._children = {}
self.mark = False
def get(self, c):
i = index(c)
if i not in self._children:
self._children[i] = Trie()
return self._children[i]
def solve(s, k, is_good):
n = len(s)
trie = Trie()
res = 0
for i in range(n):
bad = 0
cur = trie
for j in range(i, n):
if not is_good[index(s[j])]:
bad += 1
if bad > k:
break
cur = cur.get(s[j])
if not cur.mark:
res += 1
cur.mark = True
return res
s = input()
is_good = [c == '1' for c in input()]
k = int(input())
print(solve(s, k, is_good))
``` | output | 1 | 86,940 | 0 | 173,881 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got string s, consisting of small English letters. Some of the English letters are good, the rest are bad.
A substring s[l...r] (1 ≤ l ≤ r ≤ |s|) of string s = s1s2...s|s| (where |s| is the length of string s) is string slsl + 1...sr.
The substring s[l...r] is good, if among the letters sl, sl + 1, ..., sr there are at most k bad ones (look at the sample's explanation to understand it more clear).
Your task is to find the number of distinct good substrings of the given string s. Two substrings s[x...y] and s[p...q] are considered distinct if their content is different, i.e. s[x...y] ≠ s[p...q].
Input
The first line of the input is the non-empty string s, consisting of small English letters, the string's length is at most 1500 characters.
The second line of the input is the string of characters "0" and "1", the length is exactly 26 characters. If the i-th character of this string equals "1", then the i-th English letter is good, otherwise it's bad. That is, the first character of this string corresponds to letter "a", the second one corresponds to letter "b" and so on.
The third line of the input consists a single integer k (0 ≤ k ≤ |s|) — the maximum acceptable number of bad characters in a good substring.
Output
Print a single integer — the number of distinct good substrings of string s.
Examples
Input
ababab
01000000000000000000000000
1
Output
5
Input
acbacbacaa
00000000000000000000000000
2
Output
8
Note
In the first example there are following good substrings: "a", "ab", "b", "ba", "bab".
In the second example there are following good substrings: "a", "aa", "ac", "b", "ba", "c", "ca", "cb". | instruction | 0 | 86,941 | 0 | 173,882 |
Tags: data structures, strings
Correct Solution:
```
import sys
input=sys.stdin.readline
s=input().rstrip()
flag=input().rstrip()
k=int(input())
n=len(s)
ss=[s[i:] for i in range(n)]
ss.sort()
pre=""
ans=0
for e in ss:
veri,cnt_bad=0,0
for i in range(len(e)):
if i>=len(pre) or e[i]!=pre[i]:veri=1
cnt_bad+=flag[ord(e[i])-ord("a")]=="0"
if cnt_bad>k:break
if veri:ans+=1
pre=e
print(ans)
``` | output | 1 | 86,941 | 0 | 173,883 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.