message
stringlengths 2
23.8k
| message_type
stringclasses 2
values | message_id
int64 0
1
| conversation_id
int64 97
109k
| cluster
float64 0
0
| __index_level_0__
int64 194
217k
|
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of lowercase Latin letters. Let the length of s be |s|. You may perform several operations on this string.
In one operation, you can choose some index i and remove the i-th character of s (s_i) if at least one of its adjacent characters is the previous letter in the Latin alphabet for s_i. For example, the previous letter for b is a, the previous letter for s is r, the letter a has no previous letters. Note that after each removal the length of the string decreases by one. So, the index i should satisfy the condition 1 ≤ i ≤ |s| during each operation.
For the character s_i adjacent characters are s_{i-1} and s_{i+1}. The first and the last characters of s both have only one adjacent character (unless |s| = 1).
Consider the following example. Let s= bacabcab.
1. During the first move, you can remove the first character s_1= b because s_2= a. Then the string becomes s= acabcab.
2. During the second move, you can remove the fifth character s_5= c because s_4= b. Then the string becomes s= acabab.
3. During the third move, you can remove the sixth character s_6='b' because s_5= a. Then the string becomes s= acaba.
4. During the fourth move, the only character you can remove is s_4= b, because s_3= a (or s_5= a). The string becomes s= acaa and you cannot do anything with it.
Your task is to find the maximum possible number of characters you can remove if you choose the sequence of operations optimally.
Input
The first line of the input contains one integer |s| (1 ≤ |s| ≤ 100) — the length of s.
The second line of the input contains one string s consisting of |s| lowercase Latin letters.
Output
Print one integer — the maximum possible number of characters you can remove if you choose the sequence of moves optimally.
Examples
Input
8
bacabcab
Output
4
Input
4
bcda
Output
3
Input
6
abbbbb
Output
5
Note
The first example is described in the problem statement. Note that the sequence of moves provided in the statement is not the only, but it can be shown that the maximum possible answer to this test is 4.
In the second example, you can remove all but one character of s. The only possible answer follows.
1. During the first move, remove the third character s_3= d, s becomes bca.
2. During the second move, remove the second character s_2= c, s becomes ba.
3. And during the third move, remove the first character s_1= b, s becomes a.
|
instruction
| 0
| 10,075
| 0
| 20,150
|
Tags: brute force, constructive algorithms, greedy, strings
Correct Solution:
```
import sys
# from math
import bisect
import heapq
# from collections import deque
# from types import GeneratorType
# def bootstrap(func, stack=[]):
# def wrapped_function(*args, **kwargs):
# if stack:
# return func(*args, **kwargs)
# else:
# call = func(*args, **kwargs)
# while True:
# if type(call) is GeneratorType:
# stack.append(call)
# call = next(call)
# else:
# stack.pop()
# if not stack:
# break
# call = stack[-1].send(call)
# return call
# return wrapped_function
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 10**9+7
n = int(ri())
s = ri()
maxx= -1
maxxind = -1
flag = True
cnt = 0
while (flag ):
flag = False
maxx= -1
maxxind = -1
for i in range(len(s)):
# print(i)
if i-1>= 0 and ord(s[i]) == ord(s[i-1])+1:
if ord(s[i]) > maxx:
maxx = ord(s[i])
maxxind = i
flag = True
if i+1 <=len(s)-1 and ord(s[i]) == ord(s[i+1])+1:
if ord(s[i]) > maxx:
maxx = ord(s[i])
maxxind = i
flag = True
if flag :
s = s[0:maxxind] + s[maxxind+1:]
cnt+=1
print(cnt)
```
|
output
| 1
| 10,075
| 0
| 20,151
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of lowercase Latin letters. Let the length of s be |s|. You may perform several operations on this string.
In one operation, you can choose some index i and remove the i-th character of s (s_i) if at least one of its adjacent characters is the previous letter in the Latin alphabet for s_i. For example, the previous letter for b is a, the previous letter for s is r, the letter a has no previous letters. Note that after each removal the length of the string decreases by one. So, the index i should satisfy the condition 1 ≤ i ≤ |s| during each operation.
For the character s_i adjacent characters are s_{i-1} and s_{i+1}. The first and the last characters of s both have only one adjacent character (unless |s| = 1).
Consider the following example. Let s= bacabcab.
1. During the first move, you can remove the first character s_1= b because s_2= a. Then the string becomes s= acabcab.
2. During the second move, you can remove the fifth character s_5= c because s_4= b. Then the string becomes s= acabab.
3. During the third move, you can remove the sixth character s_6='b' because s_5= a. Then the string becomes s= acaba.
4. During the fourth move, the only character you can remove is s_4= b, because s_3= a (or s_5= a). The string becomes s= acaa and you cannot do anything with it.
Your task is to find the maximum possible number of characters you can remove if you choose the sequence of operations optimally.
Input
The first line of the input contains one integer |s| (1 ≤ |s| ≤ 100) — the length of s.
The second line of the input contains one string s consisting of |s| lowercase Latin letters.
Output
Print one integer — the maximum possible number of characters you can remove if you choose the sequence of moves optimally.
Examples
Input
8
bacabcab
Output
4
Input
4
bcda
Output
3
Input
6
abbbbb
Output
5
Note
The first example is described in the problem statement. Note that the sequence of moves provided in the statement is not the only, but it can be shown that the maximum possible answer to this test is 4.
In the second example, you can remove all but one character of s. The only possible answer follows.
1. During the first move, remove the third character s_3= d, s becomes bca.
2. During the second move, remove the second character s_2= c, s becomes ba.
3. And during the third move, remove the first character s_1= b, s becomes a.
|
instruction
| 0
| 10,076
| 0
| 20,152
|
Tags: brute force, constructive algorithms, greedy, strings
Correct Solution:
```
#from bisect import bisect_left as bl #c++ lowerbound bl(array,element)
#from bisect import bisect_right as br #c++ upperbound br(array,element)
#from __future__ import print_function, division #while using python2
def modinv(n,p):
return pow(n,p-2,p)
def is_next_inc(x, y):
if x == 'z':
return False
return y == chr(ord(x) + 1)
def is_next_dec(x, y):
if x == 'a':
return False
return y == chr(ord(x) - 1)
def main():
#sys.stdin = open('input.txt', 'r')
#sys.stdout = open('output.txt', 'w')
l = int(input())
s = input()
while True:
n = len(s)
max_char = 'a'
max_char_ind = -1
for i in range(n):
if i > 0 and (is_next_inc(s[i], s[i-1]) or is_next_dec(s[i], s[i-1])):
if ord(s[i]) >= ord(max_char):
max_char_ind = i
max_char = s[i]
if i < n-1 and (is_next_inc(s[i], s[i+1]) or is_next_dec(s[i], s[i+1])):
if ord(s[i]) >= ord(max_char):
max_char_ind = i
max_char = s[i]
if max_char_ind == -1:
break
s = s[:max_char_ind] + s[max_char_ind+1:]
# print(max_char, s)
# input()
print(l -len(s))
#------------------ Python 2 and 3 footer by Pajenegod and c1729-----------------------------------------
py2 = round(0.5)
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192
class FastIO(BytesIO):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.writable = "x" in file.mode or "w" in file.mode
self.write = super(FastIO, self).write if self.writable else None
def _fill(self):
s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
return s
def read(self):
while self._fill(): pass
return super(FastIO,self).read()
def readline(self):
while self.newlines == 0:
s = self._fill(); self.newlines = s.count(b"\n") + (not s)
self.newlines -= 1
return super(FastIO, self).readline()
def flush(self):
if self.writable:
os.write(self._fd, self.getvalue())
self.truncate(0), self.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
if py2:
self.write = self.buffer.write
self.read = self.buffer.read
self.readline = self.buffer.readline
else:
self.write = lambda s:self.buffer.write(s.encode('ascii'))
self.read = lambda:self.buffer.read().decode('ascii')
self.readline = lambda:self.buffer.readline().decode('ascii')
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')
if __name__ == '__main__':
main()
```
|
output
| 1
| 10,076
| 0
| 20,153
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of lowercase Latin letters. Let the length of s be |s|. You may perform several operations on this string.
In one operation, you can choose some index i and remove the i-th character of s (s_i) if at least one of its adjacent characters is the previous letter in the Latin alphabet for s_i. For example, the previous letter for b is a, the previous letter for s is r, the letter a has no previous letters. Note that after each removal the length of the string decreases by one. So, the index i should satisfy the condition 1 ≤ i ≤ |s| during each operation.
For the character s_i adjacent characters are s_{i-1} and s_{i+1}. The first and the last characters of s both have only one adjacent character (unless |s| = 1).
Consider the following example. Let s= bacabcab.
1. During the first move, you can remove the first character s_1= b because s_2= a. Then the string becomes s= acabcab.
2. During the second move, you can remove the fifth character s_5= c because s_4= b. Then the string becomes s= acabab.
3. During the third move, you can remove the sixth character s_6='b' because s_5= a. Then the string becomes s= acaba.
4. During the fourth move, the only character you can remove is s_4= b, because s_3= a (or s_5= a). The string becomes s= acaa and you cannot do anything with it.
Your task is to find the maximum possible number of characters you can remove if you choose the sequence of operations optimally.
Input
The first line of the input contains one integer |s| (1 ≤ |s| ≤ 100) — the length of s.
The second line of the input contains one string s consisting of |s| lowercase Latin letters.
Output
Print one integer — the maximum possible number of characters you can remove if you choose the sequence of moves optimally.
Examples
Input
8
bacabcab
Output
4
Input
4
bcda
Output
3
Input
6
abbbbb
Output
5
Note
The first example is described in the problem statement. Note that the sequence of moves provided in the statement is not the only, but it can be shown that the maximum possible answer to this test is 4.
In the second example, you can remove all but one character of s. The only possible answer follows.
1. During the first move, remove the third character s_3= d, s becomes bca.
2. During the second move, remove the second character s_2= c, s becomes ba.
3. And during the third move, remove the first character s_1= b, s becomes a.
|
instruction
| 0
| 10,077
| 0
| 20,154
|
Tags: brute force, constructive algorithms, greedy, strings
Correct Solution:
```
n = int(input())
s = [ord(i) for i in input()]
for mx in range(122, 96, -1):
i = 0
while i < len(s):
flag = 1
if s[i] == mx:
if i < len(s) - 1:
if s[i + 1] == s[i] - 1:
j = i
while s[j] == mx:
del s[j]
j -= 1
i -= 1
if j == -1:
break
i += 1
flag = 0
if i:
if s[i - 1] == s[i] - 1 and flag:
j = i
while s[j] == mx:
del s[j]
if j == len(s):
break
flag = 0
if flag:
i += 1
print(n - len(s))
```
|
output
| 1
| 10,077
| 0
| 20,155
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of lowercase Latin letters. Let the length of s be |s|. You may perform several operations on this string.
In one operation, you can choose some index i and remove the i-th character of s (s_i) if at least one of its adjacent characters is the previous letter in the Latin alphabet for s_i. For example, the previous letter for b is a, the previous letter for s is r, the letter a has no previous letters. Note that after each removal the length of the string decreases by one. So, the index i should satisfy the condition 1 ≤ i ≤ |s| during each operation.
For the character s_i adjacent characters are s_{i-1} and s_{i+1}. The first and the last characters of s both have only one adjacent character (unless |s| = 1).
Consider the following example. Let s= bacabcab.
1. During the first move, you can remove the first character s_1= b because s_2= a. Then the string becomes s= acabcab.
2. During the second move, you can remove the fifth character s_5= c because s_4= b. Then the string becomes s= acabab.
3. During the third move, you can remove the sixth character s_6='b' because s_5= a. Then the string becomes s= acaba.
4. During the fourth move, the only character you can remove is s_4= b, because s_3= a (or s_5= a). The string becomes s= acaa and you cannot do anything with it.
Your task is to find the maximum possible number of characters you can remove if you choose the sequence of operations optimally.
Input
The first line of the input contains one integer |s| (1 ≤ |s| ≤ 100) — the length of s.
The second line of the input contains one string s consisting of |s| lowercase Latin letters.
Output
Print one integer — the maximum possible number of characters you can remove if you choose the sequence of moves optimally.
Examples
Input
8
bacabcab
Output
4
Input
4
bcda
Output
3
Input
6
abbbbb
Output
5
Note
The first example is described in the problem statement. Note that the sequence of moves provided in the statement is not the only, but it can be shown that the maximum possible answer to this test is 4.
In the second example, you can remove all but one character of s. The only possible answer follows.
1. During the first move, remove the third character s_3= d, s becomes bca.
2. During the second move, remove the second character s_2= c, s becomes ba.
3. And during the third move, remove the first character s_1= b, s becomes a.
|
instruction
| 0
| 10,078
| 0
| 20,156
|
Tags: brute force, constructive algorithms, greedy, strings
Correct Solution:
```
import sys
#input = sys.stdin.readline
#for _ in range(int(input())):
n=int(input())
s=input()
temp=[]
for i in range(n):
temp.append(s[i])
s=temp
v=set()
for i in s:
v.add(i)
ans=0
for i in range(25,-1,-1):
curr=chr(i+ord('a'))
temp=set()
if curr in v:
l=len(s)
for k in range(l):
if s[k]==curr:
if k-1>=0:
if ord(s[k-1])+1==ord(curr):
ans+=1
#s=s[:k]+s[k+1:]
temp.add(k)
s[k]=s[k-1]
#print(i,k,s)
for k in range(l-1,-1,-1):
if s[k]==curr:
if k+1<l:
if ord(s[k+1])+1==ord(curr):
ans+=1
temp.add(k)
#s=s[:k]+s[k+1:]
s[k]=s[k+1]
#print(i,k,s)
q=[]
for k in range(l):
if k not in temp:
q.append(s[k])
s=q
print(ans)
```
|
output
| 1
| 10,078
| 0
| 20,157
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of lowercase Latin letters. Let the length of s be |s|. You may perform several operations on this string.
In one operation, you can choose some index i and remove the i-th character of s (s_i) if at least one of its adjacent characters is the previous letter in the Latin alphabet for s_i. For example, the previous letter for b is a, the previous letter for s is r, the letter a has no previous letters. Note that after each removal the length of the string decreases by one. So, the index i should satisfy the condition 1 ≤ i ≤ |s| during each operation.
For the character s_i adjacent characters are s_{i-1} and s_{i+1}. The first and the last characters of s both have only one adjacent character (unless |s| = 1).
Consider the following example. Let s= bacabcab.
1. During the first move, you can remove the first character s_1= b because s_2= a. Then the string becomes s= acabcab.
2. During the second move, you can remove the fifth character s_5= c because s_4= b. Then the string becomes s= acabab.
3. During the third move, you can remove the sixth character s_6='b' because s_5= a. Then the string becomes s= acaba.
4. During the fourth move, the only character you can remove is s_4= b, because s_3= a (or s_5= a). The string becomes s= acaa and you cannot do anything with it.
Your task is to find the maximum possible number of characters you can remove if you choose the sequence of operations optimally.
Input
The first line of the input contains one integer |s| (1 ≤ |s| ≤ 100) — the length of s.
The second line of the input contains one string s consisting of |s| lowercase Latin letters.
Output
Print one integer — the maximum possible number of characters you can remove if you choose the sequence of moves optimally.
Examples
Input
8
bacabcab
Output
4
Input
4
bcda
Output
3
Input
6
abbbbb
Output
5
Note
The first example is described in the problem statement. Note that the sequence of moves provided in the statement is not the only, but it can be shown that the maximum possible answer to this test is 4.
In the second example, you can remove all but one character of s. The only possible answer follows.
1. During the first move, remove the third character s_3= d, s becomes bca.
2. During the second move, remove the second character s_2= c, s becomes ba.
3. And during the third move, remove the first character s_1= b, s becomes a.
|
instruction
| 0
| 10,079
| 0
| 20,158
|
Tags: brute force, constructive algorithms, greedy, strings
Correct Solution:
```
n = int(input())
s = input()
res = 0
for _ in range(n):
max_char, max_index = 'A', -1
for i in range(len(s)):
is_ok = False
if i > 0 and (ord(s[i]) == ord(s[i-1])+1):
is_ok = True
if i < len(s)-1 and ord(s[i]) == ord(s[i+1])+1:
is_ok = True
if is_ok and s[i] >= max_char:
max_index = i
max_char = s[i]
if max_index > -1:
s = s[: max_index] + s[max_index+1:]
res += 1
else:
break
print(res)
```
|
output
| 1
| 10,079
| 0
| 20,159
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of lowercase Latin letters. Let the length of s be |s|. You may perform several operations on this string.
In one operation, you can choose some index i and remove the i-th character of s (s_i) if at least one of its adjacent characters is the previous letter in the Latin alphabet for s_i. For example, the previous letter for b is a, the previous letter for s is r, the letter a has no previous letters. Note that after each removal the length of the string decreases by one. So, the index i should satisfy the condition 1 ≤ i ≤ |s| during each operation.
For the character s_i adjacent characters are s_{i-1} and s_{i+1}. The first and the last characters of s both have only one adjacent character (unless |s| = 1).
Consider the following example. Let s= bacabcab.
1. During the first move, you can remove the first character s_1= b because s_2= a. Then the string becomes s= acabcab.
2. During the second move, you can remove the fifth character s_5= c because s_4= b. Then the string becomes s= acabab.
3. During the third move, you can remove the sixth character s_6='b' because s_5= a. Then the string becomes s= acaba.
4. During the fourth move, the only character you can remove is s_4= b, because s_3= a (or s_5= a). The string becomes s= acaa and you cannot do anything with it.
Your task is to find the maximum possible number of characters you can remove if you choose the sequence of operations optimally.
Input
The first line of the input contains one integer |s| (1 ≤ |s| ≤ 100) — the length of s.
The second line of the input contains one string s consisting of |s| lowercase Latin letters.
Output
Print one integer — the maximum possible number of characters you can remove if you choose the sequence of moves optimally.
Examples
Input
8
bacabcab
Output
4
Input
4
bcda
Output
3
Input
6
abbbbb
Output
5
Note
The first example is described in the problem statement. Note that the sequence of moves provided in the statement is not the only, but it can be shown that the maximum possible answer to this test is 4.
In the second example, you can remove all but one character of s. The only possible answer follows.
1. During the first move, remove the third character s_3= d, s becomes bca.
2. During the second move, remove the second character s_2= c, s becomes ba.
3. And during the third move, remove the first character s_1= b, s becomes a.
|
instruction
| 0
| 10,080
| 0
| 20,160
|
Tags: brute force, constructive algorithms, greedy, strings
Correct Solution:
```
n=int(input())
s=list(input())
for i in range(n):
s[i]=ord(s[i])-97
ch=[i for i in range(26,-1,-1)]
s=[-100]+s+[-100]
for i in ch:
j=1
while j<len(s)-1:
if s[j]==i:
if s[j]==s[j-1]+1 or s[j]==s[j+1]+1:
s.pop(j)
j=1
else:
j+=1
else:
j+=1
print(n+2-len(s))
```
|
output
| 1
| 10,080
| 0
| 20,161
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of lowercase Latin letters. Let the length of s be |s|. You may perform several operations on this string.
In one operation, you can choose some index i and remove the i-th character of s (s_i) if at least one of its adjacent characters is the previous letter in the Latin alphabet for s_i. For example, the previous letter for b is a, the previous letter for s is r, the letter a has no previous letters. Note that after each removal the length of the string decreases by one. So, the index i should satisfy the condition 1 ≤ i ≤ |s| during each operation.
For the character s_i adjacent characters are s_{i-1} and s_{i+1}. The first and the last characters of s both have only one adjacent character (unless |s| = 1).
Consider the following example. Let s= bacabcab.
1. During the first move, you can remove the first character s_1= b because s_2= a. Then the string becomes s= acabcab.
2. During the second move, you can remove the fifth character s_5= c because s_4= b. Then the string becomes s= acabab.
3. During the third move, you can remove the sixth character s_6='b' because s_5= a. Then the string becomes s= acaba.
4. During the fourth move, the only character you can remove is s_4= b, because s_3= a (or s_5= a). The string becomes s= acaa and you cannot do anything with it.
Your task is to find the maximum possible number of characters you can remove if you choose the sequence of operations optimally.
Input
The first line of the input contains one integer |s| (1 ≤ |s| ≤ 100) — the length of s.
The second line of the input contains one string s consisting of |s| lowercase Latin letters.
Output
Print one integer — the maximum possible number of characters you can remove if you choose the sequence of moves optimally.
Examples
Input
8
bacabcab
Output
4
Input
4
bcda
Output
3
Input
6
abbbbb
Output
5
Note
The first example is described in the problem statement. Note that the sequence of moves provided in the statement is not the only, but it can be shown that the maximum possible answer to this test is 4.
In the second example, you can remove all but one character of s. The only possible answer follows.
1. During the first move, remove the third character s_3= d, s becomes bca.
2. During the second move, remove the second character s_2= c, s becomes ba.
3. And during the third move, remove the first character s_1= b, s becomes a.
|
instruction
| 0
| 10,081
| 0
| 20,162
|
Tags: brute force, constructive algorithms, greedy, strings
Correct Solution:
```
n=int(input())
s=str(input())
s=list(s)
n=len(s)
count = [[] for i in range(26)]
for i in range(n):
count[ord(s[i])-ord('a')].append(i)
start = 25
total = 0
while True:
if start<=0:
break
if len(count[start])==0:
start=start-1
continue
for i in range(len(count[start])):
indexStart = count[start][i]
#print(indexStart,s[indexStart])
indexBack = indexStart-1
indexFront = indexStart + 1
b1=0
b2=0
while(indexBack>=0):
if s[indexBack]!='.' and ord(s[indexBack])-ord('a')!=start:
b1=1
break
indexBack=indexBack-1
while(indexFront<n):
if s[indexFront]!='.' and ord(s[indexFront])-ord('a')!=start:
b2=1
break
indexFront = indexFront +1
if (b1==1):
if ord(s[indexBack])-ord('a')==start-1:
s[indexStart]='.'
total=total+1
continue
if (b2==1):
if ord(s[indexFront])-ord('a')==start-1:
s[indexStart]='.'
total=total+1
4
start = start - 1
#print(s)
print(total)
```
|
output
| 1
| 10,081
| 0
| 20,163
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of lowercase Latin letters. Let the length of s be |s|. You may perform several operations on this string.
In one operation, you can choose some index i and remove the i-th character of s (s_i) if at least one of its adjacent characters is the previous letter in the Latin alphabet for s_i. For example, the previous letter for b is a, the previous letter for s is r, the letter a has no previous letters. Note that after each removal the length of the string decreases by one. So, the index i should satisfy the condition 1 ≤ i ≤ |s| during each operation.
For the character s_i adjacent characters are s_{i-1} and s_{i+1}. The first and the last characters of s both have only one adjacent character (unless |s| = 1).
Consider the following example. Let s= bacabcab.
1. During the first move, you can remove the first character s_1= b because s_2= a. Then the string becomes s= acabcab.
2. During the second move, you can remove the fifth character s_5= c because s_4= b. Then the string becomes s= acabab.
3. During the third move, you can remove the sixth character s_6='b' because s_5= a. Then the string becomes s= acaba.
4. During the fourth move, the only character you can remove is s_4= b, because s_3= a (or s_5= a). The string becomes s= acaa and you cannot do anything with it.
Your task is to find the maximum possible number of characters you can remove if you choose the sequence of operations optimally.
Input
The first line of the input contains one integer |s| (1 ≤ |s| ≤ 100) — the length of s.
The second line of the input contains one string s consisting of |s| lowercase Latin letters.
Output
Print one integer — the maximum possible number of characters you can remove if you choose the sequence of moves optimally.
Examples
Input
8
bacabcab
Output
4
Input
4
bcda
Output
3
Input
6
abbbbb
Output
5
Note
The first example is described in the problem statement. Note that the sequence of moves provided in the statement is not the only, but it can be shown that the maximum possible answer to this test is 4.
In the second example, you can remove all but one character of s. The only possible answer follows.
1. During the first move, remove the third character s_3= d, s becomes bca.
2. During the second move, remove the second character s_2= c, s becomes ba.
3. And during the third move, remove the first character s_1= b, s becomes a.
|
instruction
| 0
| 10,082
| 0
| 20,164
|
Tags: brute force, constructive algorithms, greedy, strings
Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Tue Mar 3 19:29:45 2020
@author: hp
"""
n = int(input())
s = input()
count= 0
lst=[]
for i in s:
lst.append(ord(i))
for j in range(123,97,-1):
for k in range(n):
for i in range(len(lst)-1):
if lst[i]==lst[i+1]-1:
if(lst[i+1]==j):
lst.pop(i+1)
count+=1
break
elif(lst[i]-1==lst[i+1]):
if(lst[i]==j):
lst.pop(i)
count+=1
break
print(count)
```
|
output
| 1
| 10,082
| 0
| 20,165
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of lowercase Latin letters. Let the length of s be |s|. You may perform several operations on this string.
In one operation, you can choose some index i and remove the i-th character of s (s_i) if at least one of its adjacent characters is the previous letter in the Latin alphabet for s_i. For example, the previous letter for b is a, the previous letter for s is r, the letter a has no previous letters. Note that after each removal the length of the string decreases by one. So, the index i should satisfy the condition 1 ≤ i ≤ |s| during each operation.
For the character s_i adjacent characters are s_{i-1} and s_{i+1}. The first and the last characters of s both have only one adjacent character (unless |s| = 1).
Consider the following example. Let s= bacabcab.
1. During the first move, you can remove the first character s_1= b because s_2= a. Then the string becomes s= acabcab.
2. During the second move, you can remove the fifth character s_5= c because s_4= b. Then the string becomes s= acabab.
3. During the third move, you can remove the sixth character s_6='b' because s_5= a. Then the string becomes s= acaba.
4. During the fourth move, the only character you can remove is s_4= b, because s_3= a (or s_5= a). The string becomes s= acaa and you cannot do anything with it.
Your task is to find the maximum possible number of characters you can remove if you choose the sequence of operations optimally.
Input
The first line of the input contains one integer |s| (1 ≤ |s| ≤ 100) — the length of s.
The second line of the input contains one string s consisting of |s| lowercase Latin letters.
Output
Print one integer — the maximum possible number of characters you can remove if you choose the sequence of moves optimally.
Examples
Input
8
bacabcab
Output
4
Input
4
bcda
Output
3
Input
6
abbbbb
Output
5
Note
The first example is described in the problem statement. Note that the sequence of moves provided in the statement is not the only, but it can be shown that the maximum possible answer to this test is 4.
In the second example, you can remove all but one character of s. The only possible answer follows.
1. During the first move, remove the third character s_3= d, s becomes bca.
2. During the second move, remove the second character s_2= c, s becomes ba.
3. And during the third move, remove the first character s_1= b, s becomes a.
Submitted Solution:
```
# import io, os
# input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
import sys
# sys.stdin=open('input.txt','r')
# sys.stdout=open('output.txt','w')
input=sys.stdin.readline
# sys.setrecursionlimit(300010)
MOD = 1000000007
MOD2 = 998244353
ii = lambda: int(input().strip('\n'))
si = lambda: input().strip('\n')
dgl = lambda: list(map(int,input().strip('\n')))
f = lambda: map(int, input().strip('\n').split())
il = lambda: list(map(int, input().strip('\n').split()))
ls = lambda: list(input().strip('\n'))
lsi = lambda: [int(i) for i in ls()]
let = 'abcdefghijklmnopqrstuvwxyz'
for _ in range(1):
n=ii()
s=ls()
for j in reversed(let):
fg=1
while fg:
fg1=0
if len(s)>1:
for i in range(len(s)):
if s[i]==j:
if i==0 and ord(j)-ord(s[i+1])==1:
s.pop(0)
fg1=1
break
elif i==len(s)-1 and ord(j)-ord(s[i-1])==1:
s.pop(len(s)-1)
fg1=1
break
elif 0<i<len(s)-1 and (ord(j)-ord(s[i+1])==1 or ord(j)-ord(s[i-1])==1):
s.pop(i)
fg1=1
break
fg=fg1
print(n-len(s))
```
|
instruction
| 0
| 10,083
| 0
| 20,166
|
Yes
|
output
| 1
| 10,083
| 0
| 20,167
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of lowercase Latin letters. Let the length of s be |s|. You may perform several operations on this string.
In one operation, you can choose some index i and remove the i-th character of s (s_i) if at least one of its adjacent characters is the previous letter in the Latin alphabet for s_i. For example, the previous letter for b is a, the previous letter for s is r, the letter a has no previous letters. Note that after each removal the length of the string decreases by one. So, the index i should satisfy the condition 1 ≤ i ≤ |s| during each operation.
For the character s_i adjacent characters are s_{i-1} and s_{i+1}. The first and the last characters of s both have only one adjacent character (unless |s| = 1).
Consider the following example. Let s= bacabcab.
1. During the first move, you can remove the first character s_1= b because s_2= a. Then the string becomes s= acabcab.
2. During the second move, you can remove the fifth character s_5= c because s_4= b. Then the string becomes s= acabab.
3. During the third move, you can remove the sixth character s_6='b' because s_5= a. Then the string becomes s= acaba.
4. During the fourth move, the only character you can remove is s_4= b, because s_3= a (or s_5= a). The string becomes s= acaa and you cannot do anything with it.
Your task is to find the maximum possible number of characters you can remove if you choose the sequence of operations optimally.
Input
The first line of the input contains one integer |s| (1 ≤ |s| ≤ 100) — the length of s.
The second line of the input contains one string s consisting of |s| lowercase Latin letters.
Output
Print one integer — the maximum possible number of characters you can remove if you choose the sequence of moves optimally.
Examples
Input
8
bacabcab
Output
4
Input
4
bcda
Output
3
Input
6
abbbbb
Output
5
Note
The first example is described in the problem statement. Note that the sequence of moves provided in the statement is not the only, but it can be shown that the maximum possible answer to this test is 4.
In the second example, you can remove all but one character of s. The only possible answer follows.
1. During the first move, remove the third character s_3= d, s becomes bca.
2. During the second move, remove the second character s_2= c, s becomes ba.
3. And during the third move, remove the first character s_1= b, s becomes a.
Submitted Solution:
```
import math
from collections import *
n = int(input())
s = input()
flag = True
ans = 0
while flag and len(s) > 1:
flag = False
for i in range(len(s)):
if i == 0:
tst = False
for j in range(1,len(s)):
if ord(s[j])-ord(s[i]) == 1:
tst = True
break
if tst == False and ord(s[i])-ord(s[i+1]) == 1:
s = s[1:len(s)]
flag = True
ans+=1
break
elif i == len(s)-1:
tst = False
for j in range(0,len(s)-1):
if ord(s[j])-ord(s[i]) == 1:
tst = True
break
if tst == False and ord(s[i])-ord(s[i-1]) == 1:
flag = True
s = s[0:len(s)-1]
ans+=1
break
else:
tst = False
for j in range(0,i):
if ord(s[j])-ord(s[i]) == 1:
tst = True
break
for j in range(i+1,len(s)):
if ord(s[j])-ord(s[i]) == 1:
tst = True
break
chk = ord(s[i])-ord(s[i-1]) == 1 or ord(s[i])-ord(s[i+1]) == 1
if tst == False and chk:
flag = True
ans+=1
s1 = s[0:i]
s2 = s[i+1:len(s)]
s = s1+s2
break
flag = True
while flag and len(s)>1:
flag = False
for i in range(len(s)-1,-1,-1):
if i == 0:
if ord(s[i])-ord(s[i+1]) == 1:
ans+=1
flag = True
s = s[1:len(s)]
break
elif i == len(s)-1:
if ord(s[i])-ord(s[i-1]) == 1:
ans+=1
flag = True
s = s[0:len(s)-1]
break
else:
if ord(s[i+1])-ord(s[i]) !=1 and ord(s[i-1])-ord(s[i]) !=1:
if ord(s[i+1])-ord(s[i]) ==-1 or ord(s[i-1])-ord(s[i]) ==-1:
flag = True
ans+=1
s1 = s[0:i]
s2 = s[i+1:len(s)]
s = s1+s2
break
print(ans)
```
|
instruction
| 0
| 10,084
| 0
| 20,168
|
Yes
|
output
| 1
| 10,084
| 0
| 20,169
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of lowercase Latin letters. Let the length of s be |s|. You may perform several operations on this string.
In one operation, you can choose some index i and remove the i-th character of s (s_i) if at least one of its adjacent characters is the previous letter in the Latin alphabet for s_i. For example, the previous letter for b is a, the previous letter for s is r, the letter a has no previous letters. Note that after each removal the length of the string decreases by one. So, the index i should satisfy the condition 1 ≤ i ≤ |s| during each operation.
For the character s_i adjacent characters are s_{i-1} and s_{i+1}. The first and the last characters of s both have only one adjacent character (unless |s| = 1).
Consider the following example. Let s= bacabcab.
1. During the first move, you can remove the first character s_1= b because s_2= a. Then the string becomes s= acabcab.
2. During the second move, you can remove the fifth character s_5= c because s_4= b. Then the string becomes s= acabab.
3. During the third move, you can remove the sixth character s_6='b' because s_5= a. Then the string becomes s= acaba.
4. During the fourth move, the only character you can remove is s_4= b, because s_3= a (or s_5= a). The string becomes s= acaa and you cannot do anything with it.
Your task is to find the maximum possible number of characters you can remove if you choose the sequence of operations optimally.
Input
The first line of the input contains one integer |s| (1 ≤ |s| ≤ 100) — the length of s.
The second line of the input contains one string s consisting of |s| lowercase Latin letters.
Output
Print one integer — the maximum possible number of characters you can remove if you choose the sequence of moves optimally.
Examples
Input
8
bacabcab
Output
4
Input
4
bcda
Output
3
Input
6
abbbbb
Output
5
Note
The first example is described in the problem statement. Note that the sequence of moves provided in the statement is not the only, but it can be shown that the maximum possible answer to this test is 4.
In the second example, you can remove all but one character of s. The only possible answer follows.
1. During the first move, remove the third character s_3= d, s becomes bca.
2. During the second move, remove the second character s_2= c, s becomes ba.
3. And during the third move, remove the first character s_1= b, s becomes a.
Submitted Solution:
```
q = int(input())
arr = [ord(i) for i in input()]
count = 0
max1 = max(arr)
#print(arr)
while max1 != 0:
max1 = max(arr)
temp = []
for x in range(len(arr)):
if x == 0:
if arr[x] == max1 and len(arr) != 1:
if arr[x + 1] == max1 - 1:
temp.append(x)
count += 1
#else:
#arr[x] = 0
elif x == len(arr)-1:
if arr[x] == max1 and len(arr) != 1:
if arr[x - 1] == max1 - 1:
temp.append(x)
count += 1
#else:
#arr[x] = 0
else:
if arr[x] == max1:
if arr[x-1] == max1-1 or arr[x+1] == max1-1:
temp.append(x)
count += 1
#else:
#arr[x] = 0
for each in reversed(temp):
arr.pop(each)
#print(temp)
#print(arr)
if len(temp) == 0:
for x in range(len(arr)):
if arr[x] == max1:
arr[x] = 0
print(count)
```
|
instruction
| 0
| 10,085
| 0
| 20,170
|
Yes
|
output
| 1
| 10,085
| 0
| 20,171
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of lowercase Latin letters. Let the length of s be |s|. You may perform several operations on this string.
In one operation, you can choose some index i and remove the i-th character of s (s_i) if at least one of its adjacent characters is the previous letter in the Latin alphabet for s_i. For example, the previous letter for b is a, the previous letter for s is r, the letter a has no previous letters. Note that after each removal the length of the string decreases by one. So, the index i should satisfy the condition 1 ≤ i ≤ |s| during each operation.
For the character s_i adjacent characters are s_{i-1} and s_{i+1}. The first and the last characters of s both have only one adjacent character (unless |s| = 1).
Consider the following example. Let s= bacabcab.
1. During the first move, you can remove the first character s_1= b because s_2= a. Then the string becomes s= acabcab.
2. During the second move, you can remove the fifth character s_5= c because s_4= b. Then the string becomes s= acabab.
3. During the third move, you can remove the sixth character s_6='b' because s_5= a. Then the string becomes s= acaba.
4. During the fourth move, the only character you can remove is s_4= b, because s_3= a (or s_5= a). The string becomes s= acaa and you cannot do anything with it.
Your task is to find the maximum possible number of characters you can remove if you choose the sequence of operations optimally.
Input
The first line of the input contains one integer |s| (1 ≤ |s| ≤ 100) — the length of s.
The second line of the input contains one string s consisting of |s| lowercase Latin letters.
Output
Print one integer — the maximum possible number of characters you can remove if you choose the sequence of moves optimally.
Examples
Input
8
bacabcab
Output
4
Input
4
bcda
Output
3
Input
6
abbbbb
Output
5
Note
The first example is described in the problem statement. Note that the sequence of moves provided in the statement is not the only, but it can be shown that the maximum possible answer to this test is 4.
In the second example, you can remove all but one character of s. The only possible answer follows.
1. During the first move, remove the third character s_3= d, s becomes bca.
2. During the second move, remove the second character s_2= c, s becomes ba.
3. And during the third move, remove the first character s_1= b, s becomes a.
Submitted Solution:
```
from collections import *
n, s, d = int(input()), input(), deque()
for i in range(ord('z'), ord('a'), -1):
for c, j in enumerate(s):
if j == chr(i):
if (c < len(s) - 1 and s[c + 1] == chr(i - 1)) or (d and d[-1] == chr(i - 1)):
continue
else:
d.append(j)
else:
d.append(j)
s = ''.join(d)[::-1]
d = deque()
for c, j in enumerate(s):
if j == chr(i):
if (c < len(s) - 1 and s[c + 1] == chr(i - 1)) or (d and d[-1] == chr(i - 1)):
continue
else:
d.append(j)
else:
d.append(j)
s = ''.join(d)
d = deque()
# print(s)
print(n - len(s))
```
|
instruction
| 0
| 10,086
| 0
| 20,172
|
Yes
|
output
| 1
| 10,086
| 0
| 20,173
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of lowercase Latin letters. Let the length of s be |s|. You may perform several operations on this string.
In one operation, you can choose some index i and remove the i-th character of s (s_i) if at least one of its adjacent characters is the previous letter in the Latin alphabet for s_i. For example, the previous letter for b is a, the previous letter for s is r, the letter a has no previous letters. Note that after each removal the length of the string decreases by one. So, the index i should satisfy the condition 1 ≤ i ≤ |s| during each operation.
For the character s_i adjacent characters are s_{i-1} and s_{i+1}. The first and the last characters of s both have only one adjacent character (unless |s| = 1).
Consider the following example. Let s= bacabcab.
1. During the first move, you can remove the first character s_1= b because s_2= a. Then the string becomes s= acabcab.
2. During the second move, you can remove the fifth character s_5= c because s_4= b. Then the string becomes s= acabab.
3. During the third move, you can remove the sixth character s_6='b' because s_5= a. Then the string becomes s= acaba.
4. During the fourth move, the only character you can remove is s_4= b, because s_3= a (or s_5= a). The string becomes s= acaa and you cannot do anything with it.
Your task is to find the maximum possible number of characters you can remove if you choose the sequence of operations optimally.
Input
The first line of the input contains one integer |s| (1 ≤ |s| ≤ 100) — the length of s.
The second line of the input contains one string s consisting of |s| lowercase Latin letters.
Output
Print one integer — the maximum possible number of characters you can remove if you choose the sequence of moves optimally.
Examples
Input
8
bacabcab
Output
4
Input
4
bcda
Output
3
Input
6
abbbbb
Output
5
Note
The first example is described in the problem statement. Note that the sequence of moves provided in the statement is not the only, but it can be shown that the maximum possible answer to this test is 4.
In the second example, you can remove all but one character of s. The only possible answer follows.
1. During the first move, remove the third character s_3= d, s becomes bca.
2. During the second move, remove the second character s_2= c, s becomes ba.
3. And during the third move, remove the first character s_1= b, s becomes a.
Submitted Solution:
```
ans = 0
def check1(seq, i):
if i == 0 or i == len(seq)-1:
return False
if seq[i] - seq[i-1] == 1 and seq[i] - seq[i+1] == 2:
return True
if seq[i] - seq[i+1] == 1 and seq[i] - seq[i-1] == 2:
return True
if seq[i] - seq[i-1] == 1 and seq[i] == seq[i+1]:
return True
if seq[i] - seq[i+1] == 1 and seq[i] == seq[i-1]:
return True
return False
def check2(seq, i):
if i == 0 or i == len(seq)-1:
return True
if seq[i] - seq[i - 1] == 1 and seq[i + 1] - seq[i] >= 2:
return True
if seq[i] - seq[i + 1] == 1 and seq[i - 1] - seq[i] >= 2:
return True
if seq[i] - seq[i - 1] == 1 and seq[i] - seq[i + 1] >= 3:
return True
if seq[i] - seq[i + 1] == 1 and seq[i] - seq[i - 1] >= 3:
return True
if seq[i] - seq[i - 1] == 1 and seq[i] - seq[i + 1] == 1:
return True
if seq[i] - seq[i + 1] == 1 and seq[i] - seq[i - 1] == 1:
return True
return False
def check3(seq, i):
if i == 0 or i == len(seq)-1:
return False
if seq[i] - seq[i - 1] == 1 and seq[i + 1] - seq[i] == 1:
return True
if seq[i] - seq[i + 1] == 1 and seq[i - 1] - seq[i] == 1:
return True
return False
def make_move(seq):
global ans
candidates = []
if len(seq) > 1:
# Check first
if seq[0] - seq[1] == 1:
candidates.append(0)
# Check others
for i in range(1, len(seq) - 1):
if seq[i]-seq[i+1] == 1 or seq[i]-seq[i-1] == 1:
candidates.append(i)
# Check last
if seq[-1] - seq[-2] == 1:
candidates.append(len(seq) - 1)
#print(seq, candidates)
if len(candidates) > 0:
# Use priority
priopity1 = list()
priopity2 = list()
priopity3 = list()
for cand in candidates:
if check1(seq, cand):
priopity1.append(cand)
elif check2(seq, cand):
priopity2.append(cand)
elif check3(seq, cand):
priopity3.append(cand)
candidates_sorted = priopity1 + priopity2 + priopity3
to_del_index = candidates_sorted[0]
ans += 1
make_move(seq[0:to_del_index]+seq[to_del_index+1:])
_ = int(input())
seq = [ord(s) - ord('a') for s in input()]
make_move(seq)
print(ans)
```
|
instruction
| 0
| 10,087
| 0
| 20,174
|
No
|
output
| 1
| 10,087
| 0
| 20,175
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of lowercase Latin letters. Let the length of s be |s|. You may perform several operations on this string.
In one operation, you can choose some index i and remove the i-th character of s (s_i) if at least one of its adjacent characters is the previous letter in the Latin alphabet for s_i. For example, the previous letter for b is a, the previous letter for s is r, the letter a has no previous letters. Note that after each removal the length of the string decreases by one. So, the index i should satisfy the condition 1 ≤ i ≤ |s| during each operation.
For the character s_i adjacent characters are s_{i-1} and s_{i+1}. The first and the last characters of s both have only one adjacent character (unless |s| = 1).
Consider the following example. Let s= bacabcab.
1. During the first move, you can remove the first character s_1= b because s_2= a. Then the string becomes s= acabcab.
2. During the second move, you can remove the fifth character s_5= c because s_4= b. Then the string becomes s= acabab.
3. During the third move, you can remove the sixth character s_6='b' because s_5= a. Then the string becomes s= acaba.
4. During the fourth move, the only character you can remove is s_4= b, because s_3= a (or s_5= a). The string becomes s= acaa and you cannot do anything with it.
Your task is to find the maximum possible number of characters you can remove if you choose the sequence of operations optimally.
Input
The first line of the input contains one integer |s| (1 ≤ |s| ≤ 100) — the length of s.
The second line of the input contains one string s consisting of |s| lowercase Latin letters.
Output
Print one integer — the maximum possible number of characters you can remove if you choose the sequence of moves optimally.
Examples
Input
8
bacabcab
Output
4
Input
4
bcda
Output
3
Input
6
abbbbb
Output
5
Note
The first example is described in the problem statement. Note that the sequence of moves provided in the statement is not the only, but it can be shown that the maximum possible answer to this test is 4.
In the second example, you can remove all but one character of s. The only possible answer follows.
1. During the first move, remove the third character s_3= d, s becomes bca.
2. During the second move, remove the second character s_2= c, s becomes ba.
3. And during the third move, remove the first character s_1= b, s becomes a.
Submitted Solution:
```
n = int(input())
s = input()
s_nums = [ord(s[i]) for i in range(n)]
# print(s_nums)
# letter_count = {}
# for letter in range(ord('a'), ord('z') + 1):
# letter_count[letter] = 0
# for i in range(n):
# letter_count[s_nums[i]] += 1
ans = 0
for biggest_number in range(ord('z'), ord('a')-1, -1):
biggest_number = ord('z')
while biggest_number >= ord('a'):
# print("biggest_number:", biggest_number)
can_delete = True
while can_delete:
can_delete = False
j = 0
while len(s_nums) > 1 and j < len(s_nums):
# print("21", "s_nums: ", s_nums)
can_delete = False
if s_nums[j] == biggest_number:
if len(s_nums) == 1:
pass
elif j == 0:
if s_nums[j+1] == biggest_number - 1:
can_delete = True
elif j == len(s_nums) - 1:
if s_nums[j-1] == biggest_number - 1:
can_delete = True
else:
if s_nums[j-1] == biggest_number - 1 or s_nums[j+1] == biggest_number - 1:
can_delete = True
if can_delete:
# print("deleting ", j, "from ", s_nums)
s_nums = s_nums[:j] + s_nums[j+1:]
# print("got ", s_nums)
can_delete = False
# letter_count[biggest_number] -= 1
ans += 1
j += 1
biggest_number -= 1
print(ans)
# print("ans: ", ans)
# print("s_nums: ", s_nums)
```
|
instruction
| 0
| 10,088
| 0
| 20,176
|
No
|
output
| 1
| 10,088
| 0
| 20,177
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of lowercase Latin letters. Let the length of s be |s|. You may perform several operations on this string.
In one operation, you can choose some index i and remove the i-th character of s (s_i) if at least one of its adjacent characters is the previous letter in the Latin alphabet for s_i. For example, the previous letter for b is a, the previous letter for s is r, the letter a has no previous letters. Note that after each removal the length of the string decreases by one. So, the index i should satisfy the condition 1 ≤ i ≤ |s| during each operation.
For the character s_i adjacent characters are s_{i-1} and s_{i+1}. The first and the last characters of s both have only one adjacent character (unless |s| = 1).
Consider the following example. Let s= bacabcab.
1. During the first move, you can remove the first character s_1= b because s_2= a. Then the string becomes s= acabcab.
2. During the second move, you can remove the fifth character s_5= c because s_4= b. Then the string becomes s= acabab.
3. During the third move, you can remove the sixth character s_6='b' because s_5= a. Then the string becomes s= acaba.
4. During the fourth move, the only character you can remove is s_4= b, because s_3= a (or s_5= a). The string becomes s= acaa and you cannot do anything with it.
Your task is to find the maximum possible number of characters you can remove if you choose the sequence of operations optimally.
Input
The first line of the input contains one integer |s| (1 ≤ |s| ≤ 100) — the length of s.
The second line of the input contains one string s consisting of |s| lowercase Latin letters.
Output
Print one integer — the maximum possible number of characters you can remove if you choose the sequence of moves optimally.
Examples
Input
8
bacabcab
Output
4
Input
4
bcda
Output
3
Input
6
abbbbb
Output
5
Note
The first example is described in the problem statement. Note that the sequence of moves provided in the statement is not the only, but it can be shown that the maximum possible answer to this test is 4.
In the second example, you can remove all but one character of s. The only possible answer follows.
1. During the first move, remove the third character s_3= d, s becomes bca.
2. During the second move, remove the second character s_2= c, s becomes ba.
3. And during the third move, remove the first character s_1= b, s becomes a.
Submitted Solution:
```
def calc(i):
if i!=0 and ord(s[i-1])==ord(s[i])-1:
return True
if i!=len(s)-1 and ord(s[i+1])==ord(s[i])-1:
return True
return False
n = int(input())
s = list(input())
ans = 0
for i in range(122,96,-1):
j = 0
while j<len(s):
if ord(s[j])==i and calc(j):
ans += 1
s.pop(j)
else:
j += 1
print (ans)
```
|
instruction
| 0
| 10,089
| 0
| 20,178
|
No
|
output
| 1
| 10,089
| 0
| 20,179
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of lowercase Latin letters. Let the length of s be |s|. You may perform several operations on this string.
In one operation, you can choose some index i and remove the i-th character of s (s_i) if at least one of its adjacent characters is the previous letter in the Latin alphabet for s_i. For example, the previous letter for b is a, the previous letter for s is r, the letter a has no previous letters. Note that after each removal the length of the string decreases by one. So, the index i should satisfy the condition 1 ≤ i ≤ |s| during each operation.
For the character s_i adjacent characters are s_{i-1} and s_{i+1}. The first and the last characters of s both have only one adjacent character (unless |s| = 1).
Consider the following example. Let s= bacabcab.
1. During the first move, you can remove the first character s_1= b because s_2= a. Then the string becomes s= acabcab.
2. During the second move, you can remove the fifth character s_5= c because s_4= b. Then the string becomes s= acabab.
3. During the third move, you can remove the sixth character s_6='b' because s_5= a. Then the string becomes s= acaba.
4. During the fourth move, the only character you can remove is s_4= b, because s_3= a (or s_5= a). The string becomes s= acaa and you cannot do anything with it.
Your task is to find the maximum possible number of characters you can remove if you choose the sequence of operations optimally.
Input
The first line of the input contains one integer |s| (1 ≤ |s| ≤ 100) — the length of s.
The second line of the input contains one string s consisting of |s| lowercase Latin letters.
Output
Print one integer — the maximum possible number of characters you can remove if you choose the sequence of moves optimally.
Examples
Input
8
bacabcab
Output
4
Input
4
bcda
Output
3
Input
6
abbbbb
Output
5
Note
The first example is described in the problem statement. Note that the sequence of moves provided in the statement is not the only, but it can be shown that the maximum possible answer to this test is 4.
In the second example, you can remove all but one character of s. The only possible answer follows.
1. During the first move, remove the third character s_3= d, s becomes bca.
2. During the second move, remove the second character s_2= c, s becomes ba.
3. And during the third move, remove the first character s_1= b, s becomes a.
Submitted Solution:
```
N = int(input())
S = list(input())
res = 0
i = len(S) - 1
while i >= 0 and len(S) > 1:
#print(i)
if (i + 1 < len(S) and ord(S[i]) - ord(S[i + 1]) == 1) or (i - 1 >= 0 and ord(S[i]) - ord(S[i - 1]) == 1):
S.pop(i)
res += 1
else:
i -= 1
if i >= len(S):
i = len(S) - 1
print(res)
```
|
instruction
| 0
| 10,090
| 0
| 20,180
|
No
|
output
| 1
| 10,090
| 0
| 20,181
|
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 2n operations. It can be proved that it is always possible.
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 10^5) — the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, output an integer k (0≤ k≤ 2n), followed by k integers p_1,…,p_k (1≤ p_i≤ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01→ 11→ 00→ 10.
In the second test case, we have 01011→ 00101→ 11101→ 01000→ 10100→ 00100→ 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged.
|
instruction
| 0
| 10,124
| 0
| 20,248
|
Tags: constructive algorithms, data structures, implementation, strings, two pointers
Correct Solution:
```
from sys import stdin
input=stdin.readline
def answer():
ans = []
i , j = 0 , n - 1
ind = n - 1
while(i <= j):
if(a[i] == b[ind]):
ans.append(1)
ans.append(ind + 1)
else:
ans.append(ind + 1)
if(i == j):break
ind -= 1
if(a[j] ^ 1 == b[ind]):
ans.append(1)
ans.append(ind + 1)
else:
ans.append(ind + 1)
ind -= 1
i , j = i + 1 , j - 1
print(len(ans) , *ans)
for T in range(int(input())):
n=int(input())
a = [int(i) for i in input().strip()]
b = [int(i) for i in input().strip()]
answer()
```
|
output
| 1
| 10,124
| 0
| 20,249
|
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 2n operations. It can be proved that it is always possible.
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 10^5) — the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, output an integer k (0≤ k≤ 2n), followed by k integers p_1,…,p_k (1≤ p_i≤ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01→ 11→ 00→ 10.
In the second test case, we have 01011→ 00101→ 11101→ 01000→ 10100→ 00100→ 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged.
|
instruction
| 0
| 10,125
| 0
| 20,250
|
Tags: constructive algorithms, data structures, implementation, strings, two pointers
Correct Solution:
```
import sys,os,io
# input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
input = sys.stdin.readline
for _ in range (int(input())):
n = int(input())
a = input().strip()
b = input().strip()
curr = a[0]
ans = []
for i in range (n):
if a[i]!=curr:
ans.append(i)
curr = a[i]
for i in range (n-1,-1,-1):
if curr != b[i]:
ans.append(i+1)
curr = b[i]
print(len(ans),*ans)
```
|
output
| 1
| 10,125
| 0
| 20,251
|
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 2n operations. It can be proved that it is always possible.
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 10^5) — the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, output an integer k (0≤ k≤ 2n), followed by k integers p_1,…,p_k (1≤ p_i≤ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01→ 11→ 00→ 10.
In the second test case, we have 01011→ 00101→ 11101→ 01000→ 10100→ 00100→ 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged.
|
instruction
| 0
| 10,126
| 0
| 20,252
|
Tags: constructive algorithms, data structures, implementation, strings, two pointers
Correct Solution:
```
str1="First"
str2="Second"
def rev(c,cnt):
if(cnt%2==0):
return c
if(c=='0'):
c='1'
else:
c='0'
return c
def solve():
n=int(input())
a=input()
b=input()
ans=list()
l,r=0,n-1
for i in range(n):
if(i%2==0):
if(rev(a[l],i)==b[n-i-1]):
ans.append(1)
l+=1
else:
if (rev(a[r], i) == b[n - i - 1]):
ans.append(1)
r -= 1
ans.append(n-i)
print(len(ans),sep=' ',end=' ')
for num in ans:
print(num,sep=' ',end=' ')
print()
def main():
t=int(input())
for i in range(t):
solve()
main()
```
|
output
| 1
| 10,126
| 0
| 20,253
|
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 2n operations. It can be proved that it is always possible.
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 10^5) — the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, output an integer k (0≤ k≤ 2n), followed by k integers p_1,…,p_k (1≤ p_i≤ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01→ 11→ 00→ 10.
In the second test case, we have 01011→ 00101→ 11101→ 01000→ 10100→ 00100→ 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged.
|
instruction
| 0
| 10,127
| 0
| 20,254
|
Tags: constructive algorithms, data structures, implementation, strings, two pointers
Correct Solution:
```
#------------------------------warmup----------------------------
# *******************************
# * AUTHOR: RAJDEEP GHOSH *
# * NICK : Rajdeep2k *
# * INSTITUTION: IIEST, SHIBPUR *
# *******************************
import os
import sys
from io import BytesIO, IOBase
import math
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now---------------------------------------------------
for _ in range(int(input())):
n = int(input())
s1 = input()
s2 = input()
if(s1 == s2):
print('0')
else:
s1 = list(s1)
s2 = list(s2)
ans=[]
end=n-1
rev=0
fc=s1[0]
while(end>=0):
if rev&1:
fc=chr(1 - (ord(s1[n-(rev//2)-1]) - 48) + 48)
else:
fc=s1[rev//2]
if fc==s2[end]:
ans.append(1)
ans.append(end+1)
rev+=1
end-=1
else:
ans.append(end+1)
rev+=1
end-=1
print(len(ans),end=' ')
print(*ans)
```
|
output
| 1
| 10,127
| 0
| 20,255
|
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 2n operations. It can be proved that it is always possible.
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 10^5) — the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, output an integer k (0≤ k≤ 2n), followed by k integers p_1,…,p_k (1≤ p_i≤ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01→ 11→ 00→ 10.
In the second test case, we have 01011→ 00101→ 11101→ 01000→ 10100→ 00100→ 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged.
|
instruction
| 0
| 10,128
| 0
| 20,256
|
Tags: constructive algorithms, data structures, implementation, strings, two pointers
Correct Solution:
```
import math
import sys
#input=sys.stdin.readline
t=int(input())
#t=1
for _ in range(t):
n=int(input())
#n,m=map(int,input().split())
#l1=list(map(int,input().split()))
a=input()
a+='0'
b=input()
b+='0'
ans=[]
ans1=[]
for i in range(n):
if a[i]=='1' and a[i+1]=='0' :
ans.append(i+1)
if a[i]=='0' and a[i+1]=='1':
ans.append(i+1)
if b[i]=='1' and b[i+1]=='0' :
ans1.append(i+1)
if b[i]=='0' and b[i+1]=='1':
ans1.append(i+1)
if len(ans)+len(ans1)==0:
print(0)
else:
print(len(ans)+len(ans1),*ans,*ans1[::-1])
```
|
output
| 1
| 10,128
| 0
| 20,257
|
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 2n operations. It can be proved that it is always possible.
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 10^5) — the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, output an integer k (0≤ k≤ 2n), followed by k integers p_1,…,p_k (1≤ p_i≤ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01→ 11→ 00→ 10.
In the second test case, we have 01011→ 00101→ 11101→ 01000→ 10100→ 00100→ 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged.
|
instruction
| 0
| 10,129
| 0
| 20,258
|
Tags: constructive algorithms, data structures, implementation, strings, two pointers
Correct Solution:
```
def f(c):
if c=='1':
return '0'
else:
return '1'
for _ in range(int(input())):
n=int(input())
a=list(input())
b=list(input())
l=[]
i=n-1
j=n-1
am=True
while j>=0:
if am:
if a[i]!=b[j]:
if a[i-j]==b[j]:
l.append(1)
a[i-j]=f(a[i-j])
l.append(j+1)
am=False
i-=j
i+=1
else:
i-=1
else:
if a[i]==b[j]:
if a[i+j]!=b[j]:
l.append(1)
a[i+j]=f(a[i+j])
l.append(j+1)
am=True
i+=j
i-=1
else:
i+=1
j-=1
l1=[len(l)]+l
print(*l1)
```
|
output
| 1
| 10,129
| 0
| 20,259
|
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 2n operations. It can be proved that it is always possible.
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 10^5) — the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, output an integer k (0≤ k≤ 2n), followed by k integers p_1,…,p_k (1≤ p_i≤ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01→ 11→ 00→ 10.
In the second test case, we have 01011→ 00101→ 11101→ 01000→ 10100→ 00100→ 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged.
|
instruction
| 0
| 10,130
| 0
| 20,260
|
Tags: constructive algorithms, data structures, implementation, strings, two pointers
Correct Solution:
```
import sys
t=int(input())
for _ in range(t):
n=int(input())
tempa=input()
tempb=input()
a=[]
for i in tempa:
a.append(int(i))
b=[]
for i in tempb:
b.append(int(i))
count=0
anslist=[]
start=1
rev=0
for i in range(n-1,-1,-1):
if(rev==0):
pos=start+i
else:
pos=start-i
curr=a[pos-1]
if(rev==1):
curr=curr^1
if(curr!=b[i]):
first=a[start-1]
if(rev==1):
first=first^1
if(first!=b[i]):
anslist.append(i+1)
count+=1
else:
anslist.append(1)
anslist.append(i+1)
count+=2
rev=rev^1
start=pos
print(count,end=" ")
for i in anslist:
sys.stdout.write(str(i)+" ")
print()
```
|
output
| 1
| 10,130
| 0
| 20,261
|
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the hard version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 2n operations. It can be proved that it is always possible.
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 10^5) — the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, output an integer k (0≤ k≤ 2n), followed by k integers p_1,…,p_k (1≤ p_i≤ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01→ 11→ 00→ 10.
In the second test case, we have 01011→ 00101→ 11101→ 01000→ 10100→ 00100→ 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged.
|
instruction
| 0
| 10,131
| 0
| 20,262
|
Tags: constructive algorithms, data structures, implementation, strings, two pointers
Correct Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
avl=AvlTree()
#-----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default='z', func=lambda a, b: min(a ,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left)/ 2)
# Check if middle element is
# less than or equal to key
if (arr[mid]<=key):
count = mid+1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def countGreater( arr,n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
for ik in range(int(input())):
n=int(input())
s=list(input())
for i in range(n):
s[i]=int(s[i])
s1=list(input())
for i in range(n):
s1[i]=int(s1[i])
ans=[]
cou=0
lastz=s[0]
su=0
for i in range(n-1,-1,-1):
si=s[su+(-1)**(cou)*i]
if cou%2==1:
si=1-si
if s1[i]!=si:
if lastz==s1[i]:
ans.append(1)
ans.append(i+1)
lastz=s1[i]
if cou % 2 == 1:
su -= i
else:
su += i
cou+=1
#print(s)
print(len(ans),*ans)
#print(*ans)
```
|
output
| 1
| 10,131
| 0
| 20,263
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 2n operations. It can be proved that it is always possible.
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 10^5) — the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, output an integer k (0≤ k≤ 2n), followed by k integers p_1,…,p_k (1≤ p_i≤ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01→ 11→ 00→ 10.
In the second test case, we have 01011→ 00101→ 11101→ 01000→ 10100→ 00100→ 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged.
Submitted Solution:
```
# from collections import Counter
# import math
def tc():
n = int(input())
a = input()
b = input()
segs = []
prev = a[0]
for i, ch in enumerate(a[1:]):
if ch != prev:
segs.append(i + 1)
prev = ch
bsegs = []
bprev = b[0]
for i, ch in enumerate(b[1:]):
if ch != bprev:
bsegs.append(i + 1)
bprev = ch
if a[-1] != b[-1]:
segs.append(n)
segs.extend(bsegs[::-1])
print(len(segs), ' '.join(map(str, segs)))
##################################
T = int(input())
for _ in range(T):
tc()
# tc()
```
|
instruction
| 0
| 10,132
| 0
| 20,264
|
Yes
|
output
| 1
| 10,132
| 0
| 20,265
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 2n operations. It can be proved that it is always possible.
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 10^5) — the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, output an integer k (0≤ k≤ 2n), followed by k integers p_1,…,p_k (1≤ p_i≤ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01→ 11→ 00→ 10.
In the second test case, we have 01011→ 00101→ 11101→ 01000→ 10100→ 00100→ 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged.
Submitted Solution:
```
from sys import stdin
input = lambda: stdin.readline().rstrip("\r\n")
from collections import deque as que, defaultdict as vector
from heapq import*
inin = lambda: int(input())
inar = lambda: list(map(int,input().split()))
from types import GeneratorType
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack: return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrappedfunc
Testcase=inin()
for _ in range(Testcase):
n=inin()
a=list(input())
b=list(input())
a=[int(x) for x in a]+[0]
b=[int(x) for x in b]+[0]
aw=[]
bw=[]
for i in range(n):
if a[i]!=a[i+1]:
aw.append(i+1)
if b[i]!=b[i+1]:
bw.append(i+1)
print(len(aw)+len(bw),*(aw),*bw[::-1])
```
|
instruction
| 0
| 10,133
| 0
| 20,266
|
Yes
|
output
| 1
| 10,133
| 0
| 20,267
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 2n operations. It can be proved that it is always possible.
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 10^5) — the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, output an integer k (0≤ k≤ 2n), followed by k integers p_1,…,p_k (1≤ p_i≤ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01→ 11→ 00→ 10.
In the second test case, we have 01011→ 00101→ 11101→ 01000→ 10100→ 00100→ 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged.
Submitted Solution:
```
def flip(a,flip):
if flip%2==0:
return a
else:
if a==1:
return 0
else:
return 1
for _ in range(int(input())):
n = int(input())
a = list(map(int,list(input())))
b = list(map(int,list(input())))
i = 0
j = n-1
ans = []
flipp = 0
while j>=0:
if flip(a[i],flipp)!=b[j]:
ans.append(j+1)
else:
ans.append(1)
ans.append(j+1)
flipp+=1
if i==0:
a.pop(0)
i = j-1
else:
a.pop()
i = 0
j-=1
ans.insert(0,len(ans))
print(*ans)
```
|
instruction
| 0
| 10,134
| 0
| 20,268
|
Yes
|
output
| 1
| 10,134
| 0
| 20,269
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 2n operations. It can be proved that it is always possible.
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 10^5) — the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, output an integer k (0≤ k≤ 2n), followed by k integers p_1,…,p_k (1≤ p_i≤ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01→ 11→ 00→ 10.
In the second test case, we have 01011→ 00101→ 11101→ 01000→ 10100→ 00100→ 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged.
Submitted Solution:
```
from collections import deque
t = int(input())
for _ in range(t):
n = int(input())
a = deque()
b = deque()
for i in input():
a.append(0 if i=='0' else 1)
for i in input():
b.append(0 if i=='0' else 1)
ans = []
rev = 0
while b:
bb = b.pop()
if rev%2==0:
a0 = a[0]
aa = a[-1]
else:
a0 = 1-a[-1]
aa = 1-a[0]
if aa==bb:
if rev%2==0:
a.pop()
else:
a.popleft()
continue
if a0==bb and b:
ans.append(1)
ans.append(len(b)+1)
rev += 1
if rev%2==0:
a.pop()
else:
a.popleft()
print(len(ans), end=' ')
print(*ans)
```
|
instruction
| 0
| 10,135
| 0
| 20,270
|
Yes
|
output
| 1
| 10,135
| 0
| 20,271
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 2n operations. It can be proved that it is always possible.
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 10^5) — the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, output an integer k (0≤ k≤ 2n), followed by k integers p_1,…,p_k (1≤ p_i≤ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01→ 11→ 00→ 10.
In the second test case, we have 01011→ 00101→ 11101→ 01000→ 10100→ 00100→ 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged.
Submitted Solution:
```
def helper(s):
ans = []
s = '0' + s
for i in range(1,len(s)):
if s[i]!=s[i-1]:
ans.append(i)
return ans
t = int(input())
for l in range(t):
n = int(input())
a = input()
b = input()
a1 = helper(a)
a2 = helper(b)
a = a1+a2[::-1]
print(len(a),end = " ")
for i in a:
print(i,end=" ")
print()
```
|
instruction
| 0
| 10,136
| 0
| 20,272
|
No
|
output
| 1
| 10,136
| 0
| 20,273
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 2n operations. It can be proved that it is always possible.
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 10^5) — the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, output an integer k (0≤ k≤ 2n), followed by k integers p_1,…,p_k (1≤ p_i≤ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01→ 11→ 00→ 10.
In the second test case, we have 01011→ 00101→ 11101→ 01000→ 10100→ 00100→ 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged.
Submitted Solution:
```
def solve(s):
new = ""
for i in s:
if i=="1":
new += "0"
else:
new += "1"
return new[::-1]
for nt in range(int(input())):
n = int(input())
a = input()
b = input()
ans = []
i = 1
count = 0
while i<n:
if i+1<n:
if a[i]!=b[i] and a[i+1]!=b[i+1]:
if a[i]==a[i+1]:
ans.append(i+2)
ans.append(2)
ans.append(i+2)
else:
ans.append(i+2)
ans.append(1)
ans.append(2)
ans.append(1)
ans.append(i+2)
i += 2
elif a[i]==b[i] and a[i+1]!=b[i+1]:
i += 1
elif a[i]!=b[i] and a[i+1]==b[i+1]:
ans.append(i+1)
ans.append(1)
ans.append(i+1)
i += 2
else:
i += 2
else:
if a[i]!=b[i]:
ans.append(i+1)
ans.append(1)
ans.append(i+1)
break
if a[0]!=b[0]:
ans.append(1)
print (len(ans),end = " ")
print (*ans)
# def solve(s):
# new = ""
# for i in s:
# if i=="1":
# new += "0"
# else:
# new += "1"
# return new[::-1]
# for nt in range(int(input())):
# n = int(input())
# a = input()
# b = input()
# ans = []
# for i in range(n-1,-1,-1):
# print (a,i,a[i])
# if a[i]!=b[i]:
# if a[i]==a[0]:
# ans.append(i+1)
# a = solve(a[0:i+1]) + a[i+1:]
# else:
# ans.append(1)
# ans.append(i+1)
# a = solve(a[i]+a[1:i+1]) + a[i+1:]
# print (len(ans),end = " ")
# print (*ans)
```
|
instruction
| 0
| 10,137
| 0
| 20,274
|
No
|
output
| 1
| 10,137
| 0
| 20,275
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 2n operations. It can be proved that it is always possible.
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 10^5) — the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, output an integer k (0≤ k≤ 2n), followed by k integers p_1,…,p_k (1≤ p_i≤ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01→ 11→ 00→ 10.
In the second test case, we have 01011→ 00101→ 11101→ 01000→ 10100→ 00100→ 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged.
Submitted Solution:
```
for _ in range (int(input())):
n = int(input())
a = list(input())
b = list(input())
ans = []
for i in range (n-1,-1,-1):
if b[i]!=a[0]:
ans.append(i+1)
if a[i]=='0':
a[0]='1'
else:
a[0] = '0'
else:
ans.append(1)
if a[0]=='0':
a[0]='1'
else:
a[0] = '0'
ans.append(i+1)
if a[i]=='0':
a[0]='1'
else:
a[0] = '0'
print(len(ans),end=" ")
print(*ans)
```
|
instruction
| 0
| 10,138
| 0
| 20,276
|
No
|
output
| 1
| 10,138
| 0
| 20,277
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 2n operations. It can be proved that it is always possible.
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 10^5) — the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, output an integer k (0≤ k≤ 2n), followed by k integers p_1,…,p_k (1≤ p_i≤ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01→ 11→ 00→ 10.
In the second test case, we have 01011→ 00101→ 11101→ 01000→ 10100→ 00100→ 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged.
Submitted Solution:
```
"""for _ in range(int(input())):
n,m=map(int,input().split())
l1=list(map(int,input().split()))
l2=list(map(int,input().split()))
f=0
for i in range(n):
if l1[i] in l2:
f=1
ans=l1[i]
break
if(f==0):
print("NO")
else:
print("YES")
print(1, ans)"""
"""for _ in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
x=l.count(1)
if(x==0):
print("First")
else:
if(x==n):
if(n%2==0):
print("Second")
else:
print("First")
else:
c=0
for i in range(n):
if(l[i]==1):
c+=1
else:
break
if(c%2==0):
print("First")
else:
print("Second")"""
for _ in range(int(input())):
n=int(input())
la=str(input())
lb=str(input())
ans=n
l=[]
a=list(la)
b=list(lb)
left=0
right=n-1
for i in range(n-1,-1,-1):
temp=n-i+1
if(temp%2==0):
if(a[left]==b[i]):
l.append(1)
left+=1
l.append(i+1)
else:
if(a[right]!=b[i]):
l.append(1)
right-=1
l.append(i+1)
print(len(l),end=" ")
for i in range(len(l)):
print(l[i],end=" ")
print()
```
|
instruction
| 0
| 10,139
| 0
| 20,278
|
No
|
output
| 1
| 10,139
| 0
| 20,279
|
Provide tags and a correct Python 3 solution for this coding contest problem.
We have a string of letters 'a' and 'b'. We want to perform some operations on it. On each step we choose one of substrings "ab" in the string and replace it with the string "bba". If we have no "ab" as a substring, our job is done. Print the minimum number of steps we should perform to make our job done modulo 109 + 7.
The string "ab" appears as a substring if there is a letter 'b' right after the letter 'a' somewhere in the string.
Input
The first line contains the initial string consisting of letters 'a' and 'b' only with length from 1 to 106.
Output
Print the minimum number of steps modulo 109 + 7.
Examples
Input
ab
Output
1
Input
aab
Output
3
Note
The first example: "ab" → "bba".
The second example: "aab" → "abba" → "bbaba" → "bbbbaa".
|
instruction
| 0
| 10,461
| 0
| 20,922
|
Tags: combinatorics, greedy, implementation, math
Correct Solution:
```
##############--->>>>> Deepcoder Amit Kumar Bhuyan <<<<<---##############
"""
Perfection is achieved not when there is nothing more to add, but rather when there is nothing more to take away.
"""
from __future__ import division, print_function
import os,sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
def ii(): return int(input())
def si(): return input()
def mi(): return map(int,input().strip().split(" "))
def msi(): return map(str,input().strip().split(" "))
def li(): return list(mi())
def dmain():
sys.setrecursionlimit(1000000)
threading.stack_size(1024000)
thread = threading.Thread(target=main)
thread.start()
#from collections import deque, Counter, OrderedDict,defaultdict
#from heapq import nsmallest, nlargest, heapify,heappop ,heappush, heapreplace
#from math import log,sqrt,factorial,cos,tan,sin,radians
#from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
#from decimal import *
#import threading
#from itertools import permutations
#Copy 2D list m = [x[:] for x in mark] .. Avoid Using Deepcopy
import sys
input = sys.stdin.readline
scanner = lambda: int(input())
string = lambda: input().rstrip()
get_list = lambda: list(read())
read = lambda: map(int, input().split())
get_float = lambda: map(float, input().split())
# from bisect import bisect_left as lower_bound;
# from bisect import bisect_right as upper_bound;
# from math import ceil, factorial;
def ceil(x):
if x != int(x):
x = int(x) + 1
return x
def factorial(x, m):
val = 1
while x>0:
val = (val * x) % m
x -= 1
return val
def fact(x):
val = 1
while x > 0:
val *= x
x -= 1
return val
# swap_array function
def swaparr(arr, a,b):
temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
## gcd function
def gcd(a,b):
if b == 0:
return a;
return gcd(b, a % b);
## lcm function
def lcm(a, b):
return (a * b) // math.gcd(a, b)
def is_integer(n):
return math.ceil(n) == math.floor(n)
## nCr function efficient using Binomial Cofficient
def nCr(n, k):
if k > n:
return 0
if(k > n - k):
k = n - k
res = 1
for i in range(k):
res = res * (n - i)
res = res / (i + 1)
return int(res)
## upper bound function code -- such that e in a[:i] e < x;
## prime factorization
def primefs(n):
## if n == 1 ## calculating primes
primes = {}
while(n%2 == 0 and n > 0):
primes[2] = primes.get(2, 0) + 1
n = n//2
for i in range(3, int(n**0.5)+2, 2):
while(n%i == 0 and n > 0):
primes[i] = primes.get(i, 0) + 1
n = n//i
if n > 2:
primes[n] = primes.get(n, 0) + 1
## prime factoriazation of n is stored in dictionary
## primes and can be accesed. O(sqrt n)
return primes
## MODULAR EXPONENTIATION FUNCTION
def power(x, y, p):
res = 1
x = x % p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) :
res = (res * x) % p
y = y >> 1
x = (x * x) % p
return res
## DISJOINT SET UNINON FUNCTIONS
def swap(a,b):
temp = a
a = b
b = temp
return a,b;
# find function with path compression included (recursive)
# def find(x, link):
# if link[x] == x:
# return x
# link[x] = find(link[x], link);
# return link[x];
# find function with path compression (ITERATIVE)
def find(x, link):
p = x;
while( p != link[p]):
p = link[p];
while( x != p):
nex = link[x];
link[x] = p;
x = nex;
return p;
# the union function which makes union(x,y)
# of two nodes x and y
def union(x, y, link, size):
x = find(x, link)
y = find(y, link)
if size[x] < size[y]:
x,y = swap(x,y)
if x != y:
size[x] += size[y]
link[y] = x
## returns an array of boolean if primes or not USING SIEVE OF ERATOSTHANES
def sieve(n):
prime = [True for i in range(n+1)]
prime[0], prime[1] = False, False
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
# Euler's Toitent Function phi
def phi(n) :
result = n
p = 2
while(p * p<= n) :
if (n % p == 0) :
while (n % p == 0) :
n = n // p
result = result * (1.0 - (1.0 / (float) (p)))
p = p + 1
if (n > 1) :
result = result * (1.0 - (1.0 / (float)(n)))
return (int)(result)
def is_prime(n):
if n == 0:
return False
if n == 1:
return True
for i in range(2, int(n ** (1 / 2)) + 1):
if not n % i:
return False
return True
def next_prime(n, primes):
while primes[n] != True:
n += 1
return n
#### PRIME FACTORIZATION IN O(log n) using Sieve ####
MAXN = int(1e5 + 5)
def spf_sieve():
spf[1] = 1;
for i in range(2, MAXN):
spf[i] = i;
for i in range(4, MAXN, 2):
spf[i] = 2;
for i in range(3, ceil(MAXN ** 0.5), 2):
if spf[i] == i:
for j in range(i*i, MAXN, i):
if spf[j] == j:
spf[j] = i;
## function for storing smallest prime factors (spf) in the array
################## un-comment below 2 lines when using factorization #################
spf = [0 for i in range(MAXN)]
# spf_sieve();
def factoriazation(x):
res = []
for i in range(2, int(x ** 0.5) + 1):
while x % i == 0:
res.append(i)
x //= i
if x != 1:
res.append(x)
return res
## this function is useful for multiple queries only, o/w use
## primefs function above. complexity O(log n)
def factors(n):
res = []
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
res.append(i)
res.append(n // i)
return list(set(res))
## taking integer array input
def int_array():
return list(map(int, input().strip().split()));
def float_array():
return list(map(float, input().strip().split()));
## taking string array input
def str_array():
return input().strip().split();
def binary_search(low, high, w, h, n):
while low < high:
mid = low + (high - low) // 2
# print(low, mid, high)
if check(mid, w, h, n):
low = mid + 1
else:
high = mid
return low
## for checking any conditions
def check(beauty, s, n, count):
pass
#defining a couple constants
MOD = int(1e9)+7;
CMOD = 998244353;
INF = float('inf'); NINF = -float('inf');
alphs = "abcdefghijklmnopqrstuvwxyz"
################### ---------------- TEMPLATE ENDS HERE ---------------- ###################
from itertools import permutations
import math
import bisect as bis
import random
import sys
import collections as collect
def solve():
s = string()
l = len(s)
i = 0
j = l - 1
ans = 0
while j >= 0:
if s[j] == 'b':
i += 1
else:
ans += i % MOD
i *= 2
i %= MOD
ans %= MOD
j -= 1
print(ans)
# region fastio
# template taken from https://github.com/cheran-senthil/PyRival/blob/master/templates/template.py
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
#read()
for i in range(1):
solve()
#dmain()
# Comment Read()
# fin_time = datetime.now()
# print("Execution time (for loop): ", (fin_time-init_time))
```
|
output
| 1
| 10,461
| 0
| 20,923
|
Provide tags and a correct Python 3 solution for this coding contest problem.
We have a string of letters 'a' and 'b'. We want to perform some operations on it. On each step we choose one of substrings "ab" in the string and replace it with the string "bba". If we have no "ab" as a substring, our job is done. Print the minimum number of steps we should perform to make our job done modulo 109 + 7.
The string "ab" appears as a substring if there is a letter 'b' right after the letter 'a' somewhere in the string.
Input
The first line contains the initial string consisting of letters 'a' and 'b' only with length from 1 to 106.
Output
Print the minimum number of steps modulo 109 + 7.
Examples
Input
ab
Output
1
Input
aab
Output
3
Note
The first example: "ab" → "bba".
The second example: "aab" → "abba" → "bbaba" → "bbbbaa".
|
instruction
| 0
| 10,462
| 0
| 20,924
|
Tags: combinatorics, greedy, implementation, math
Correct Solution:
```
s = input()
cnt = 0
ans = 0
mod = 1000000007
for i in reversed(range(len(s))):
if(s[i] is 'a'):
ans = (ans + cnt) % mod
cnt = (cnt * 2) % mod
else:
cnt += 1
print(ans)
```
|
output
| 1
| 10,462
| 0
| 20,925
|
Provide tags and a correct Python 3 solution for this coding contest problem.
We have a string of letters 'a' and 'b'. We want to perform some operations on it. On each step we choose one of substrings "ab" in the string and replace it with the string "bba". If we have no "ab" as a substring, our job is done. Print the minimum number of steps we should perform to make our job done modulo 109 + 7.
The string "ab" appears as a substring if there is a letter 'b' right after the letter 'a' somewhere in the string.
Input
The first line contains the initial string consisting of letters 'a' and 'b' only with length from 1 to 106.
Output
Print the minimum number of steps modulo 109 + 7.
Examples
Input
ab
Output
1
Input
aab
Output
3
Note
The first example: "ab" → "bba".
The second example: "aab" → "abba" → "bbaba" → "bbbbaa".
|
instruction
| 0
| 10,463
| 0
| 20,926
|
Tags: combinatorics, greedy, implementation, math
Correct Solution:
```
s = input()
a, b = 0, 0
for i in reversed(s):
if i == 'b':
b += 1
else:
a += b
b *= 2
b %= 10**9 + 7
print(a % (10**9 + 7))
"""
from re import findall
s = input()
k = 0
p = findall('ab', s)
while p:
k += len(p)
s = s.replace('ab', 'bba')
p = findall('ab', s)
print(k)
from re import search
s = input()
k = 0
while search('ab', s):
k += 1
s = s.replace('ab', 'bba', 1)
print(k)
from re import *
s = input()
k = 0
pattern = compile('ab')
while pattern.search(s):
k += 1
s = s.replace('ab', 'bba', 1)
print(k)
"""
```
|
output
| 1
| 10,463
| 0
| 20,927
|
Provide tags and a correct Python 3 solution for this coding contest problem.
We have a string of letters 'a' and 'b'. We want to perform some operations on it. On each step we choose one of substrings "ab" in the string and replace it with the string "bba". If we have no "ab" as a substring, our job is done. Print the minimum number of steps we should perform to make our job done modulo 109 + 7.
The string "ab" appears as a substring if there is a letter 'b' right after the letter 'a' somewhere in the string.
Input
The first line contains the initial string consisting of letters 'a' and 'b' only with length from 1 to 106.
Output
Print the minimum number of steps modulo 109 + 7.
Examples
Input
ab
Output
1
Input
aab
Output
3
Note
The first example: "ab" → "bba".
The second example: "aab" → "abba" → "bbaba" → "bbbbaa".
|
instruction
| 0
| 10,464
| 0
| 20,928
|
Tags: combinatorics, greedy, implementation, math
Correct Solution:
```
l = input()
flaga, flagb = 0, 0
countbn, countan = 0, 0
count = 0
MOD = 10 ** 9 + 7
# a^n b^m
i = len(l)
vec = []
while i > 0:
i = i - 1
if l[i] == 'b':
countbn += 1
else:
count += countbn
countbn *= 2
count %= MOD
countbn %= MOD
print(count % MOD)
```
|
output
| 1
| 10,464
| 0
| 20,929
|
Provide tags and a correct Python 3 solution for this coding contest problem.
We have a string of letters 'a' and 'b'. We want to perform some operations on it. On each step we choose one of substrings "ab" in the string and replace it with the string "bba". If we have no "ab" as a substring, our job is done. Print the minimum number of steps we should perform to make our job done modulo 109 + 7.
The string "ab" appears as a substring if there is a letter 'b' right after the letter 'a' somewhere in the string.
Input
The first line contains the initial string consisting of letters 'a' and 'b' only with length from 1 to 106.
Output
Print the minimum number of steps modulo 109 + 7.
Examples
Input
ab
Output
1
Input
aab
Output
3
Note
The first example: "ab" → "bba".
The second example: "aab" → "abba" → "bbaba" → "bbbbaa".
|
instruction
| 0
| 10,465
| 0
| 20,930
|
Tags: combinatorics, greedy, implementation, math
Correct Solution:
```
MOD = 10**9 + 7
s = input()
bcount, count = 0, 0
for c in reversed(s):
if c == 'b':
bcount += 1
else:
count = (count + bcount) % MOD
bcount = bcount * 2 % MOD
print(count)
```
|
output
| 1
| 10,465
| 0
| 20,931
|
Provide tags and a correct Python 3 solution for this coding contest problem.
We have a string of letters 'a' and 'b'. We want to perform some operations on it. On each step we choose one of substrings "ab" in the string and replace it with the string "bba". If we have no "ab" as a substring, our job is done. Print the minimum number of steps we should perform to make our job done modulo 109 + 7.
The string "ab" appears as a substring if there is a letter 'b' right after the letter 'a' somewhere in the string.
Input
The first line contains the initial string consisting of letters 'a' and 'b' only with length from 1 to 106.
Output
Print the minimum number of steps modulo 109 + 7.
Examples
Input
ab
Output
1
Input
aab
Output
3
Note
The first example: "ab" → "bba".
The second example: "aab" → "abba" → "bbaba" → "bbbbaa".
|
instruction
| 0
| 10,466
| 0
| 20,932
|
Tags: combinatorics, greedy, implementation, math
Correct Solution:
```
import math
import sys
mod = 1000000007
def main():
n = input()
tmp = 0
ans = 0
for i in range(len(n)-1,-1,-1):
if n[i] == 'a':
ans += tmp
ans %= mod
tmp *= 2
tmp %= mod
else:
tmp += 1
print(ans)
main()
```
|
output
| 1
| 10,466
| 0
| 20,933
|
Provide tags and a correct Python 3 solution for this coding contest problem.
We have a string of letters 'a' and 'b'. We want to perform some operations on it. On each step we choose one of substrings "ab" in the string and replace it with the string "bba". If we have no "ab" as a substring, our job is done. Print the minimum number of steps we should perform to make our job done modulo 109 + 7.
The string "ab" appears as a substring if there is a letter 'b' right after the letter 'a' somewhere in the string.
Input
The first line contains the initial string consisting of letters 'a' and 'b' only with length from 1 to 106.
Output
Print the minimum number of steps modulo 109 + 7.
Examples
Input
ab
Output
1
Input
aab
Output
3
Note
The first example: "ab" → "bba".
The second example: "aab" → "abba" → "bbaba" → "bbbbaa".
|
instruction
| 0
| 10,467
| 0
| 20,934
|
Tags: combinatorics, greedy, implementation, math
Correct Solution:
```
mod = 1000000007; b,ans = 0,0
for x in reversed(input()):
if x == 'a':
ans = (ans + b)%mod;
b = (2*b)%mod
else: b = (b+1%mod)
print(ans)
```
|
output
| 1
| 10,467
| 0
| 20,935
|
Provide tags and a correct Python 3 solution for this coding contest problem.
We have a string of letters 'a' and 'b'. We want to perform some operations on it. On each step we choose one of substrings "ab" in the string and replace it with the string "bba". If we have no "ab" as a substring, our job is done. Print the minimum number of steps we should perform to make our job done modulo 109 + 7.
The string "ab" appears as a substring if there is a letter 'b' right after the letter 'a' somewhere in the string.
Input
The first line contains the initial string consisting of letters 'a' and 'b' only with length from 1 to 106.
Output
Print the minimum number of steps modulo 109 + 7.
Examples
Input
ab
Output
1
Input
aab
Output
3
Note
The first example: "ab" → "bba".
The second example: "aab" → "abba" → "bbaba" → "bbbbaa".
|
instruction
| 0
| 10,468
| 0
| 20,936
|
Tags: combinatorics, greedy, implementation, math
Correct Solution:
```
s=input()
ans=0
j=0
cnt1=0
cnt2=0
for i in range(0,len(s)):
if i>=j:
while i<len(s) and s[i]=='a':
cnt1=cnt1+1
i=i+1
while i<len(s) and s[i]=='b':
cnt2=cnt2+1
i=i+1
j=i;
if cnt1>0 and cnt2>0:
ans=ans + cnt2
bb= cnt2*2
temp=cnt1-1
ans = ans + bb*(pow(2,temp,1000000007)-1)
#print(ans)
cnt2=0
print(ans%1000000007)
```
|
output
| 1
| 10,468
| 0
| 20,937
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a string of letters 'a' and 'b'. We want to perform some operations on it. On each step we choose one of substrings "ab" in the string and replace it with the string "bba". If we have no "ab" as a substring, our job is done. Print the minimum number of steps we should perform to make our job done modulo 109 + 7.
The string "ab" appears as a substring if there is a letter 'b' right after the letter 'a' somewhere in the string.
Input
The first line contains the initial string consisting of letters 'a' and 'b' only with length from 1 to 106.
Output
Print the minimum number of steps modulo 109 + 7.
Examples
Input
ab
Output
1
Input
aab
Output
3
Note
The first example: "ab" → "bba".
The second example: "aab" → "abba" → "bbaba" → "bbbbaa".
Submitted Solution:
```
s=input()
c=0
ans=0
cst=10**9+7
for i in range(len(s)-1,-1,-1):
if s[i]=='a':
ans=(ans+c)%cst
c=(c*2)%cst
else:
c=c+1
print(ans%cst)
```
|
instruction
| 0
| 10,469
| 0
| 20,938
|
Yes
|
output
| 1
| 10,469
| 0
| 20,939
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a string of letters 'a' and 'b'. We want to perform some operations on it. On each step we choose one of substrings "ab" in the string and replace it with the string "bba". If we have no "ab" as a substring, our job is done. Print the minimum number of steps we should perform to make our job done modulo 109 + 7.
The string "ab" appears as a substring if there is a letter 'b' right after the letter 'a' somewhere in the string.
Input
The first line contains the initial string consisting of letters 'a' and 'b' only with length from 1 to 106.
Output
Print the minimum number of steps modulo 109 + 7.
Examples
Input
ab
Output
1
Input
aab
Output
3
Note
The first example: "ab" → "bba".
The second example: "aab" → "abba" → "bbaba" → "bbbbaa".
Submitted Solution:
```
#!/usr/bin/python3.5
s=input()
m=1000000007
p=0
k=1
for i in s:
if i=='a':
k<<=1
k%=m
else:
p+=k-1;
p%=m
print(p)
```
|
instruction
| 0
| 10,470
| 0
| 20,940
|
Yes
|
output
| 1
| 10,470
| 0
| 20,941
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a string of letters 'a' and 'b'. We want to perform some operations on it. On each step we choose one of substrings "ab" in the string and replace it with the string "bba". If we have no "ab" as a substring, our job is done. Print the minimum number of steps we should perform to make our job done modulo 109 + 7.
The string "ab" appears as a substring if there is a letter 'b' right after the letter 'a' somewhere in the string.
Input
The first line contains the initial string consisting of letters 'a' and 'b' only with length from 1 to 106.
Output
Print the minimum number of steps modulo 109 + 7.
Examples
Input
ab
Output
1
Input
aab
Output
3
Note
The first example: "ab" → "bba".
The second example: "aab" → "abba" → "bbaba" → "bbbbaa".
Submitted Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def main():
s = S()
r = 0
b = 0
for c in s[::-1]:
if c == 'a':
r += b
r %= mod
b *= 2
b %= mod
else:
b += 1
return r
print(main())
```
|
instruction
| 0
| 10,471
| 0
| 20,942
|
Yes
|
output
| 1
| 10,471
| 0
| 20,943
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a string of letters 'a' and 'b'. We want to perform some operations on it. On each step we choose one of substrings "ab" in the string and replace it with the string "bba". If we have no "ab" as a substring, our job is done. Print the minimum number of steps we should perform to make our job done modulo 109 + 7.
The string "ab" appears as a substring if there is a letter 'b' right after the letter 'a' somewhere in the string.
Input
The first line contains the initial string consisting of letters 'a' and 'b' only with length from 1 to 106.
Output
Print the minimum number of steps modulo 109 + 7.
Examples
Input
ab
Output
1
Input
aab
Output
3
Note
The first example: "ab" → "bba".
The second example: "aab" → "abba" → "bbaba" → "bbbbaa".
Submitted Solution:
```
import sys
mod = 10**9 + 7
def solve():
s = input()[::-1]
ans = 0
b_cnt = 0
for ch in s:
if ch == 'b':
b_cnt = (b_cnt + 1) % mod
else:
ans = (ans + b_cnt) % mod
b_cnt = (b_cnt * 2) % mod
print(ans)
if __name__ == '__main__':
solve()
```
|
instruction
| 0
| 10,472
| 0
| 20,944
|
Yes
|
output
| 1
| 10,472
| 0
| 20,945
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a string of letters 'a' and 'b'. We want to perform some operations on it. On each step we choose one of substrings "ab" in the string and replace it with the string "bba". If we have no "ab" as a substring, our job is done. Print the minimum number of steps we should perform to make our job done modulo 109 + 7.
The string "ab" appears as a substring if there is a letter 'b' right after the letter 'a' somewhere in the string.
Input
The first line contains the initial string consisting of letters 'a' and 'b' only with length from 1 to 106.
Output
Print the minimum number of steps modulo 109 + 7.
Examples
Input
ab
Output
1
Input
aab
Output
3
Note
The first example: "ab" → "bba".
The second example: "aab" → "abba" → "bbaba" → "bbbbaa".
Submitted Solution:
```
import sys
import re
def solve():
str = input()
iter=re.finditer('ab', str)
astart = [x.start()+1 for x in iter]
iter=re.finditer('ba', str)
bstart = [x.start()+1 for x in iter]
if not bstart:
bstart=[0]
if not astart:
astart=[0]
if astart[0]<bstart[0]:
bstart.insert(0,0)
if len(bstart) == len(astart):
bstart.append(len(str))
A=[]
B=[]
incr=[]
MOD=1000000007
for i in range(len(astart)):
A.append(astart[i]-bstart[i])
B.append(bstart[i+1]-astart[i])
incr.append(((2**sum(A)-1)*B[i]) % MOD)
#print(A)
#print(B)
print(sum(incr))
if __name__ == '__main__':
solve()
```
|
instruction
| 0
| 10,473
| 0
| 20,946
|
No
|
output
| 1
| 10,473
| 0
| 20,947
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a string of letters 'a' and 'b'. We want to perform some operations on it. On each step we choose one of substrings "ab" in the string and replace it with the string "bba". If we have no "ab" as a substring, our job is done. Print the minimum number of steps we should perform to make our job done modulo 109 + 7.
The string "ab" appears as a substring if there is a letter 'b' right after the letter 'a' somewhere in the string.
Input
The first line contains the initial string consisting of letters 'a' and 'b' only with length from 1 to 106.
Output
Print the minimum number of steps modulo 109 + 7.
Examples
Input
ab
Output
1
Input
aab
Output
3
Note
The first example: "ab" → "bba".
The second example: "aab" → "abba" → "bbaba" → "bbbbaa".
Submitted Solution:
```
s=input()
ans=0
j=0
for i in range(0,len(s)):
if i>=j:
cnt1=0
while i<len(s) and s[i]=='a':
cnt1=cnt1+1
i=i+1
cnt2=0
while i<len(s) and s[i]=='b':
cnt2=cnt2+1
i=i+1
j=i;
if cnt1>0 and cnt2>0:
ans=ans + cnt2
bb= cnt2*2
cnt1=cnt1-1
ans = ans + bb*(pow(2,cnt1,1000000007)-1)
#print(ans)
print(ans%1000000007)
```
|
instruction
| 0
| 10,474
| 0
| 20,948
|
No
|
output
| 1
| 10,474
| 0
| 20,949
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a string of letters 'a' and 'b'. We want to perform some operations on it. On each step we choose one of substrings "ab" in the string and replace it with the string "bba". If we have no "ab" as a substring, our job is done. Print the minimum number of steps we should perform to make our job done modulo 109 + 7.
The string "ab" appears as a substring if there is a letter 'b' right after the letter 'a' somewhere in the string.
Input
The first line contains the initial string consisting of letters 'a' and 'b' only with length from 1 to 106.
Output
Print the minimum number of steps modulo 109 + 7.
Examples
Input
ab
Output
1
Input
aab
Output
3
Note
The first example: "ab" → "bba".
The second example: "aab" → "abba" → "bbaba" → "bbbbaa".
Submitted Solution:
```
m=1000*1000*1000+7
s=input()
from math import pow
#pow=[1]
#for i in range (1,len(s)):
# pow.append(pow[i-1]*2)
ans=0
m=1000*1000*1000+7
cnt=0
for i in s:
if(i=='a') :
cnt=cnt+1
else:
ans=(int(ans+pow(2,cnt)-1)) %m
print(ans)
```
|
instruction
| 0
| 10,475
| 0
| 20,950
|
No
|
output
| 1
| 10,475
| 0
| 20,951
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a string of letters 'a' and 'b'. We want to perform some operations on it. On each step we choose one of substrings "ab" in the string and replace it with the string "bba". If we have no "ab" as a substring, our job is done. Print the minimum number of steps we should perform to make our job done modulo 109 + 7.
The string "ab" appears as a substring if there is a letter 'b' right after the letter 'a' somewhere in the string.
Input
The first line contains the initial string consisting of letters 'a' and 'b' only with length from 1 to 106.
Output
Print the minimum number of steps modulo 109 + 7.
Examples
Input
ab
Output
1
Input
aab
Output
3
Note
The first example: "ab" → "bba".
The second example: "aab" → "abba" → "bbaba" → "bbbbaa".
Submitted Solution:
```
##############--->>>>> Deepcoder Amit Kumar Bhuyan <<<<<---##############
"""
Perfection is achieved not when there is nothing more to add, but rather when there is nothing more to take away.
"""
from __future__ import division, print_function
import os,sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
def ii(): return int(input())
def si(): return input()
def mi(): return map(int,input().strip().split(" "))
def msi(): return map(str,input().strip().split(" "))
def li(): return list(mi())
def dmain():
sys.setrecursionlimit(1000000)
threading.stack_size(1024000)
thread = threading.Thread(target=main)
thread.start()
#from collections import deque, Counter, OrderedDict,defaultdict
#from heapq import nsmallest, nlargest, heapify,heappop ,heappush, heapreplace
#from math import log,sqrt,factorial,cos,tan,sin,radians
#from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
#from decimal import *
#import threading
#from itertools import permutations
#Copy 2D list m = [x[:] for x in mark] .. Avoid Using Deepcopy
import sys
input = sys.stdin.readline
scanner = lambda: int(input())
string = lambda: input().rstrip()
get_list = lambda: list(read())
read = lambda: map(int, input().split())
get_float = lambda: map(float, input().split())
# from bisect import bisect_left as lower_bound;
# from bisect import bisect_right as upper_bound;
# from math import ceil, factorial;
def ceil(x):
if x != int(x):
x = int(x) + 1
return x
def factorial(x, m):
val = 1
while x>0:
val = (val * x) % m
x -= 1
return val
def fact(x):
val = 1
while x > 0:
val *= x
x -= 1
return val
# swap_array function
def swaparr(arr, a,b):
temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
## gcd function
def gcd(a,b):
if b == 0:
return a;
return gcd(b, a % b);
## lcm function
def lcm(a, b):
return (a * b) // math.gcd(a, b)
def is_integer(n):
return math.ceil(n) == math.floor(n)
## nCr function efficient using Binomial Cofficient
def nCr(n, k):
if k > n:
return 0
if(k > n - k):
k = n - k
res = 1
for i in range(k):
res = res * (n - i)
res = res / (i + 1)
return int(res)
## upper bound function code -- such that e in a[:i] e < x;
## prime factorization
def primefs(n):
## if n == 1 ## calculating primes
primes = {}
while(n%2 == 0 and n > 0):
primes[2] = primes.get(2, 0) + 1
n = n//2
for i in range(3, int(n**0.5)+2, 2):
while(n%i == 0 and n > 0):
primes[i] = primes.get(i, 0) + 1
n = n//i
if n > 2:
primes[n] = primes.get(n, 0) + 1
## prime factoriazation of n is stored in dictionary
## primes and can be accesed. O(sqrt n)
return primes
## MODULAR EXPONENTIATION FUNCTION
def power(x, y, p):
res = 1
x = x % p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) :
res = (res * x) % p
y = y >> 1
x = (x * x) % p
return res
## DISJOINT SET UNINON FUNCTIONS
def swap(a,b):
temp = a
a = b
b = temp
return a,b;
# find function with path compression included (recursive)
# def find(x, link):
# if link[x] == x:
# return x
# link[x] = find(link[x], link);
# return link[x];
# find function with path compression (ITERATIVE)
def find(x, link):
p = x;
while( p != link[p]):
p = link[p];
while( x != p):
nex = link[x];
link[x] = p;
x = nex;
return p;
# the union function which makes union(x,y)
# of two nodes x and y
def union(x, y, link, size):
x = find(x, link)
y = find(y, link)
if size[x] < size[y]:
x,y = swap(x,y)
if x != y:
size[x] += size[y]
link[y] = x
## returns an array of boolean if primes or not USING SIEVE OF ERATOSTHANES
def sieve(n):
prime = [True for i in range(n+1)]
prime[0], prime[1] = False, False
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
# Euler's Toitent Function phi
def phi(n) :
result = n
p = 2
while(p * p<= n) :
if (n % p == 0) :
while (n % p == 0) :
n = n // p
result = result * (1.0 - (1.0 / (float) (p)))
p = p + 1
if (n > 1) :
result = result * (1.0 - (1.0 / (float)(n)))
return (int)(result)
def is_prime(n):
if n == 0:
return False
if n == 1:
return True
for i in range(2, int(n ** (1 / 2)) + 1):
if not n % i:
return False
return True
def next_prime(n, primes):
while primes[n] != True:
n += 1
return n
#### PRIME FACTORIZATION IN O(log n) using Sieve ####
MAXN = int(1e5 + 5)
def spf_sieve():
spf[1] = 1;
for i in range(2, MAXN):
spf[i] = i;
for i in range(4, MAXN, 2):
spf[i] = 2;
for i in range(3, ceil(MAXN ** 0.5), 2):
if spf[i] == i:
for j in range(i*i, MAXN, i):
if spf[j] == j:
spf[j] = i;
## function for storing smallest prime factors (spf) in the array
################## un-comment below 2 lines when using factorization #################
spf = [0 for i in range(MAXN)]
# spf_sieve();
def factoriazation(x):
res = []
for i in range(2, int(x ** 0.5) + 1):
while x % i == 0:
res.append(i)
x //= i
if x != 1:
res.append(x)
return res
## this function is useful for multiple queries only, o/w use
## primefs function above. complexity O(log n)
def factors(n):
res = []
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
res.append(i)
res.append(n // i)
return list(set(res))
## taking integer array input
def int_array():
return list(map(int, input().strip().split()));
def float_array():
return list(map(float, input().strip().split()));
## taking string array input
def str_array():
return input().strip().split();
def binary_search(low, high, w, h, n):
while low < high:
mid = low + (high - low) // 2
# print(low, mid, high)
if check(mid, w, h, n):
low = mid + 1
else:
high = mid
return low
## for checking any conditions
def check(beauty, s, n, count):
pass
#defining a couple constants
MOD = int(1e9)+7;
CMOD = 998244353;
INF = float('inf'); NINF = -float('inf');
alphs = "abcdefghijklmnopqrstuvwxyz"
################### ---------------- TEMPLATE ENDS HERE ---------------- ###################
from itertools import permutations
import math
import bisect as bis
import random
import sys
import collections as collect
def solve():
s = string()
l = len(s)
i = 0
j = l - 1
ans = 0
while j >= 0:
if s[j] == 'b':
i += 1
else:
ans += i % MOD
i *= 2
j -= 1
print(ans)
# region fastio
# template taken from https://github.com/cheran-senthil/PyRival/blob/master/templates/template.py
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
#read()
for i in range(1):
solve()
#dmain()
# Comment Read()
# fin_time = datetime.now()
# print("Execution time (for loop): ", (fin_time-init_time))
```
|
instruction
| 0
| 10,476
| 0
| 20,952
|
No
|
output
| 1
| 10,476
| 0
| 20,953
|
Provide a correct Python 3 solution for this coding contest problem.
If the strings are consecutive, you can replace the characters with a rule to shorten the string. For example, for the string AAAA, the expression @ 4A will compress one character. Create a program that restores the character string compressed by this rule to the original character string. However, it is assumed that the @ character does not appear in the restored character string.
In addition, the original character string is uppercase letters, lowercase letters, numbers, and symbols, and can be up to 100 characters, and consecutive characters can be up to 9 characters.
input
Multiple strings are given. One string is given per line. The number of strings does not exceed 50.
output
For each character string, output the restored character string for each character on one line.
Example
Input
ab@5C1@8050
@99+1=1@90
Output
abCCCCC10000000050
999999999+1=1000000000
|
instruction
| 0
| 10,678
| 0
| 21,356
|
"Correct Solution:
```
while True:
try:
Tlist = list(input())
except:
break
while '@' in Tlist:
at = Tlist.index('@')
t = Tlist[at+2]
x = int(Tlist[at+1])
del(Tlist[at:at+3])
Tlist.insert(at,t*x)
print(''.join(Tlist))
```
|
output
| 1
| 10,678
| 0
| 21,357
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s of length n consisting only of lowercase Latin letters.
A substring of a string is a contiguous subsequence of that string. So, string "forces" is substring of string "codeforces", but string "coder" is not.
Your task is to calculate the number of ways to remove exactly one substring from this string in such a way that all remaining characters are equal (the number of distinct characters either zero or one).
It is guaranteed that there is at least two different characters in s.
Note that you can remove the whole string and it is correct. Also note that you should remove at least one character.
Since the answer can be rather large (not very large though) print it modulo 998244353.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the length of the string s.
The second line of the input contains the string s of length n consisting only of lowercase Latin letters.
It is guaranteed that there is at least two different characters in s.
Output
Print one integer — the number of ways modulo 998244353 to remove exactly one substring from s in such way that all remaining characters are equal.
Examples
Input
4
abaa
Output
6
Input
7
aacdeee
Output
6
Input
2
az
Output
3
Note
Let s[l; r] be the substring of s from the position l to the position r inclusive.
Then in the first example you can remove the following substrings:
* s[1; 2];
* s[1; 3];
* s[1; 4];
* s[2; 2];
* s[2; 3];
* s[2; 4].
In the second example you can remove the following substrings:
* s[1; 4];
* s[1; 5];
* s[1; 6];
* s[1; 7];
* s[2; 7];
* s[3; 7].
In the third example you can remove the following substrings:
* s[1; 1];
* s[1; 2];
* s[2; 2].
|
instruction
| 0
| 10,831
| 0
| 21,662
|
Tags: combinatorics, math, strings
Correct Solution:
```
import sys
from fractions import gcd
from itertools import groupby as gb
from itertools import permutations as perm
from collections import Counter as C
from collections import defaultdict as dd
sys.setrecursionlimit(10**5)
mod = 998244353
n = int(input())
s = input()
if s == s[0]*n:
print(n*(n+1)//2)
exit()
g = gb(s)
gg = gb(s[::-1])
a = 0
a_c,b_c = '',''
b = 0
for k,v in g:
a = len(list(v))
a_c = k
break
for k,v in gg:
b = len(list(v))
b_c = k
break
res = 0
if a_c == b_c:
res += a * b
res += a + b + 1
print(int(res)%mod)
```
|
output
| 1
| 10,831
| 0
| 21,663
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.