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 of length n consisting only of the characters 0 and 1.
You perform the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue the remaining two parts together (any of them can be empty) in the same order. For example, if you erase the substring 111 from the string 111110, you will get the string 110. When you delete a substring of length l, you get a ⋅ l + b points.
Your task is to calculate the maximum number of points that you can score in total, if you have to make the given string empty.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of testcases.
The first line of each testcase contains three integers n, a and b (1 ≤ n ≤ 100; -100 ≤ a, b ≤ 100) — the length of the string s and the parameters a and b.
The second line contains the string s. The string s consists only of the characters 0 and 1.
Output
For each testcase, print a single integer — the maximum number of points that you can score.
Example
Input
3
3 2 0
000
5 -2 5
11001
6 1 -4
100111
Output
6
15
-2
Note
In the first example, it is enough to delete the entire string, then we will get 2 ⋅ 3 + 0 = 6 points.
In the second example, if we delete characters one by one, then for each deleted character we will get (-2) ⋅ 1 + 5 = 3 points, i. e. 15 points in total.
In the third example, we can delete the substring 00 from the string 100111, we get 1 ⋅ 2 + (-4) = -2 points, and the string will be equal to 1111, removing it entirely we get 1 ⋅ 4 + (-4) = 0 points. In total, we got -2 points for 2 operations. | instruction | 0 | 30,334 | 0 | 60,668 |
Tags: greedy, math
Correct Solution:
```
t = int(input())
for j in range(t):
n, a, b = map(int, input().split())
ans1 = 0
ans2 = 0
s = input()
ch = 0
per = ""
e = 0
for i in range(n):
if ch == 1 and per != s[i]:
if per == "1":
ans1 += max(a*e+b, a*e+e*b)
else:
ans2 += max(a*e+b, a*e+e*b)
e = 0
ch = 0
per = s[i]
if ch == 1 and per == s[i]:
e += 1
if ch == 0:
per = s[i]
ch = 1
e += 1
if e != 0:
if per == "1":
ans1 += max(a*e+b, a*e+e*b)
else:
ans2 += max(a*e+b, a*e+e*b)
#print(ans2)
ed = s.count("1")
nol = s.count("0")
#print(ans1+nol*a+b)
#print(ans1+nol*a+b*nol)
#print( ans2+ed*a+b)
#print(ans2+ed*a+b*ed)
if ed == 0:
print(max(ans1+nol*a+b, ans1+nol*a+b*nol, ans2))
elif nol == 0:
print(max(ans1, ans2+ed*a+b, ans2+ed*a+b*ed))
else:
print(max(ans1+nol*a+b, ans1+nol*a+b*nol, ans2+ed*a+b, ans2+ed*a+b*ed))
``` | output | 1 | 30,334 | 0 | 60,669 |
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 the characters 0 and 1.
You perform the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue the remaining two parts together (any of them can be empty) in the same order. For example, if you erase the substring 111 from the string 111110, you will get the string 110. When you delete a substring of length l, you get a ⋅ l + b points.
Your task is to calculate the maximum number of points that you can score in total, if you have to make the given string empty.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of testcases.
The first line of each testcase contains three integers n, a and b (1 ≤ n ≤ 100; -100 ≤ a, b ≤ 100) — the length of the string s and the parameters a and b.
The second line contains the string s. The string s consists only of the characters 0 and 1.
Output
For each testcase, print a single integer — the maximum number of points that you can score.
Example
Input
3
3 2 0
000
5 -2 5
11001
6 1 -4
100111
Output
6
15
-2
Note
In the first example, it is enough to delete the entire string, then we will get 2 ⋅ 3 + 0 = 6 points.
In the second example, if we delete characters one by one, then for each deleted character we will get (-2) ⋅ 1 + 5 = 3 points, i. e. 15 points in total.
In the third example, we can delete the substring 00 from the string 100111, we get 1 ⋅ 2 + (-4) = -2 points, and the string will be equal to 1111, removing it entirely we get 1 ⋅ 4 + (-4) = 0 points. In total, we got -2 points for 2 operations. | instruction | 0 | 30,335 | 0 | 60,670 |
Tags: greedy, math
Correct Solution:
```
#Fast I/O
import sys,os
import math
# To enable the file I/O i the below 2 lines are uncommented.
# read from in.txt if uncommented
if os.path.exists('in.txt'): sys.stdin=open('in.txt','r')
# will print on Console if file I/O is not activated
#if os.path.exists('out.txt'): sys.stdout=open('out.txt', 'w')
# inputs template
from io import BytesIO, IOBase
from heapq import *
from bisect import *
from collections import Counter
def main():
for _ in range(int(input())):
n,a,b=MI()
s=input()
if b>=0:
print(n*(a+b))
else:
z,o=0,0
if s[0]=="1":o+=1
else:z+=1
for i in range(1,n):
if s[i]==s[i-1]:continue
else:
if s[i]=="1":o+=1
else:z+=1
print(n*a+(min(z,o)+1)*b)
# Sample Inputs/Output
# region fastio
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")
#for array of integers
def MI():return (map(int,input().split()))
def mi():return int(input())
# endregion
#for fast output, always take string
def outP(var): sys.stdout.write(str(var)+'\n')
# end of any user-defined functions
MOD=10**9+7
mod=998244353
# main functions for execution of the program.
if __name__ == '__main__':
#This doesn't works here but works wonders when submitted on CodeChef or CodeForces
main()
``` | output | 1 | 30,335 | 0 | 60,671 |
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 the characters 0 and 1.
You perform the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue the remaining two parts together (any of them can be empty) in the same order. For example, if you erase the substring 111 from the string 111110, you will get the string 110. When you delete a substring of length l, you get a ⋅ l + b points.
Your task is to calculate the maximum number of points that you can score in total, if you have to make the given string empty.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of testcases.
The first line of each testcase contains three integers n, a and b (1 ≤ n ≤ 100; -100 ≤ a, b ≤ 100) — the length of the string s and the parameters a and b.
The second line contains the string s. The string s consists only of the characters 0 and 1.
Output
For each testcase, print a single integer — the maximum number of points that you can score.
Example
Input
3
3 2 0
000
5 -2 5
11001
6 1 -4
100111
Output
6
15
-2
Note
In the first example, it is enough to delete the entire string, then we will get 2 ⋅ 3 + 0 = 6 points.
In the second example, if we delete characters one by one, then for each deleted character we will get (-2) ⋅ 1 + 5 = 3 points, i. e. 15 points in total.
In the third example, we can delete the substring 00 from the string 100111, we get 1 ⋅ 2 + (-4) = -2 points, and the string will be equal to 1111, removing it entirely we get 1 ⋅ 4 + (-4) = 0 points. In total, we got -2 points for 2 operations. | instruction | 0 | 30,336 | 0 | 60,672 |
Tags: greedy, math
Correct Solution:
```
for t in range(int(input())):
n, a, b = map(int, input().split())
s = input()
changes = 0
for i in range(1,n):
if s[i]!=s[i-1]:
changes+=1
min_moves = (changes+3)//2
if b>=0:
print(n*(a+b))
continue
print(n*a + min_moves*b)
``` | output | 1 | 30,336 | 0 | 60,673 |
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 the characters 0 and 1.
You perform the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue the remaining two parts together (any of them can be empty) in the same order. For example, if you erase the substring 111 from the string 111110, you will get the string 110. When you delete a substring of length l, you get a ⋅ l + b points.
Your task is to calculate the maximum number of points that you can score in total, if you have to make the given string empty.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of testcases.
The first line of each testcase contains three integers n, a and b (1 ≤ n ≤ 100; -100 ≤ a, b ≤ 100) — the length of the string s and the parameters a and b.
The second line contains the string s. The string s consists only of the characters 0 and 1.
Output
For each testcase, print a single integer — the maximum number of points that you can score.
Example
Input
3
3 2 0
000
5 -2 5
11001
6 1 -4
100111
Output
6
15
-2
Note
In the first example, it is enough to delete the entire string, then we will get 2 ⋅ 3 + 0 = 6 points.
In the second example, if we delete characters one by one, then for each deleted character we will get (-2) ⋅ 1 + 5 = 3 points, i. e. 15 points in total.
In the third example, we can delete the substring 00 from the string 100111, we get 1 ⋅ 2 + (-4) = -2 points, and the string will be equal to 1111, removing it entirely we get 1 ⋅ 4 + (-4) = 0 points. In total, we got -2 points for 2 operations. | instruction | 0 | 30,337 | 0 | 60,674 |
Tags: greedy, math
Correct Solution:
```
# cook your dish here
import math
for i in range(int(input())):
n,a,b=list(map(int,input().split()))
s=list(input())
c=1
ones=s.count('1')
zeroes=s.count('0')
a1=[]
a0=[]
i=1
while(i<n):
if(s[i]==s[i-1]):
c+=1
else:
if(s[i-1]=='1'):
a1.append(c)
else:
a0.append(c)
c=1
i+=1
if(s[n-1]=='1'):
a1.append(c)
else:
a0.append(c)
sum1=0
for l in a0:
sum1+=max((a+b)*l,a*l+b)
if(ones!=0):
sum1+=(max((a+b)*ones , (a*ones+b)))
sum2=0
for l in a1:
sum2+=max((a+b)*l,a*l+b)
if(zeroes!=0):
sum2+=(max((a+b)*zeroes , (a*zeroes+b)))
print(max(sum1,sum2))
``` | output | 1 | 30,337 | 0 | 60,675 |
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 the characters 0 and 1.
You perform the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue the remaining two parts together (any of them can be empty) in the same order. For example, if you erase the substring 111 from the string 111110, you will get the string 110. When you delete a substring of length l, you get a ⋅ l + b points.
Your task is to calculate the maximum number of points that you can score in total, if you have to make the given string empty.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of testcases.
The first line of each testcase contains three integers n, a and b (1 ≤ n ≤ 100; -100 ≤ a, b ≤ 100) — the length of the string s and the parameters a and b.
The second line contains the string s. The string s consists only of the characters 0 and 1.
Output
For each testcase, print a single integer — the maximum number of points that you can score.
Example
Input
3
3 2 0
000
5 -2 5
11001
6 1 -4
100111
Output
6
15
-2
Note
In the first example, it is enough to delete the entire string, then we will get 2 ⋅ 3 + 0 = 6 points.
In the second example, if we delete characters one by one, then for each deleted character we will get (-2) ⋅ 1 + 5 = 3 points, i. e. 15 points in total.
In the third example, we can delete the substring 00 from the string 100111, we get 1 ⋅ 2 + (-4) = -2 points, and the string will be equal to 1111, removing it entirely we get 1 ⋅ 4 + (-4) = 0 points. In total, we got -2 points for 2 operations. | instruction | 0 | 30,338 | 0 | 60,676 |
Tags: greedy, math
Correct Solution:
```
import heapq,math
from collections import defaultdict,deque
from os import getcwd
import sys, os.path
#sys.setrecursionlimit(10000000)
if(os.path.exists('C:/Users/Dhanush/Desktop/cp/input.txt')):
sys.stdout = open('C:/Users/Dhanush/Desktop/cp/output.txt', 'w')
sys.stdin = open('C:/Users/Dhanush/Desktop/cp/input.txt', 'r')
def fun():
res=[]
i=1
c=1
while(i<n):
if(s[i]==s[i-1]):
c+=1
else:
res.append(c)
c=1
i+=1
res.append(c)
ans=0
ans1=0
i=0
while(i<len(res)):
ans1+=res[i]*a+b
i+=1
i=1
while(i<len(res)):
ans+=res[i]*a+b
i+=2
c=0
i=0
while(i<len(res)):
c+=res[i]
i+=2
ans+=c*a+b
return max(ans,ans1)
tc=int(input())
for _ in range(tc):
n,a,b=map(int,input().split())
s=input().strip()
ans1=n*a+n*b
ans2=fun()
print(max(ans1,ans2))
``` | output | 1 | 30,338 | 0 | 60,677 |
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 the characters 0 and 1.
You perform the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue the remaining two parts together (any of them can be empty) in the same order. For example, if you erase the substring 111 from the string 111110, you will get the string 110. When you delete a substring of length l, you get a ⋅ l + b points.
Your task is to calculate the maximum number of points that you can score in total, if you have to make the given string empty.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of testcases.
The first line of each testcase contains three integers n, a and b (1 ≤ n ≤ 100; -100 ≤ a, b ≤ 100) — the length of the string s and the parameters a and b.
The second line contains the string s. The string s consists only of the characters 0 and 1.
Output
For each testcase, print a single integer — the maximum number of points that you can score.
Example
Input
3
3 2 0
000
5 -2 5
11001
6 1 -4
100111
Output
6
15
-2
Note
In the first example, it is enough to delete the entire string, then we will get 2 ⋅ 3 + 0 = 6 points.
In the second example, if we delete characters one by one, then for each deleted character we will get (-2) ⋅ 1 + 5 = 3 points, i. e. 15 points in total.
In the third example, we can delete the substring 00 from the string 100111, we get 1 ⋅ 2 + (-4) = -2 points, and the string will be equal to 1111, removing it entirely we get 1 ⋅ 4 + (-4) = 0 points. In total, we got -2 points for 2 operations. | instruction | 0 | 30,339 | 0 | 60,678 |
Tags: greedy, math
Correct Solution:
```
t=int(input())
for _ in range(t):
n,a,b=map(int,input().split())
s=input()
if(b>=0):
ans=n*(a+b)
print(ans)
else:
ans=b
i=s[0]
j=i
n=n*a
for c in s:
if(c!=i and j!=c):
ans+=b
j=c
print(n+ans)
``` | output | 1 | 30,339 | 0 | 60,679 |
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 the characters 0 and 1.
You perform the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue the remaining two parts together (any of them can be empty) in the same order. For example, if you erase the substring 111 from the string 111110, you will get the string 110. When you delete a substring of length l, you get a ⋅ l + b points.
Your task is to calculate the maximum number of points that you can score in total, if you have to make the given string empty.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of testcases.
The first line of each testcase contains three integers n, a and b (1 ≤ n ≤ 100; -100 ≤ a, b ≤ 100) — the length of the string s and the parameters a and b.
The second line contains the string s. The string s consists only of the characters 0 and 1.
Output
For each testcase, print a single integer — the maximum number of points that you can score.
Example
Input
3
3 2 0
000
5 -2 5
11001
6 1 -4
100111
Output
6
15
-2
Note
In the first example, it is enough to delete the entire string, then we will get 2 ⋅ 3 + 0 = 6 points.
In the second example, if we delete characters one by one, then for each deleted character we will get (-2) ⋅ 1 + 5 = 3 points, i. e. 15 points in total.
In the third example, we can delete the substring 00 from the string 100111, we get 1 ⋅ 2 + (-4) = -2 points, and the string will be equal to 1111, removing it entirely we get 1 ⋅ 4 + (-4) = 0 points. In total, we got -2 points for 2 operations. | instruction | 0 | 30,340 | 0 | 60,680 |
Tags: greedy, math
Correct Solution:
```
import sys as _sys
def find_max_score(string, a, b):
# a * l + b
# sum of a * l is const
intermediate_result = len(string) * a
del a
# now we must add b * operations_n
if b >= 0:
operations_n = _find_max_operations_n(string)
else:
operations_n = _find_min_operations_n(string)
result = intermediate_result + b * operations_n
return result
def _find_max_operations_n(string):
return len(string)
def _find_min_operations_n(string):
while '00' in string:
string = string.replace('00', '0')
while '11' in string:
string = string.replace('11', '1')
groups_n = len(string)
if groups_n == 0:
return 0
return groups_n // 2 + 1
def _main():
[tests_n] = _read_ints()
for i_test in range(tests_n):
[s_length, a, b] = _read_ints()
s = _read_string()
assert len(s) == s_length
result = find_max_score(s, a, b)
print(result)
def _read_string():
return _sys.stdin.readline()[:-1]
def _read_ints():
return map(int, _read_string().split())
if __name__ == '__main__':
_main()
``` | output | 1 | 30,340 | 0 | 60,681 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s of length n consisting only of the characters 0 and 1.
You perform the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue the remaining two parts together (any of them can be empty) in the same order. For example, if you erase the substring 111 from the string 111110, you will get the string 110. When you delete a substring of length l, you get a ⋅ l + b points.
Your task is to calculate the maximum number of points that you can score in total, if you have to make the given string empty.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of testcases.
The first line of each testcase contains three integers n, a and b (1 ≤ n ≤ 100; -100 ≤ a, b ≤ 100) — the length of the string s and the parameters a and b.
The second line contains the string s. The string s consists only of the characters 0 and 1.
Output
For each testcase, print a single integer — the maximum number of points that you can score.
Example
Input
3
3 2 0
000
5 -2 5
11001
6 1 -4
100111
Output
6
15
-2
Note
In the first example, it is enough to delete the entire string, then we will get 2 ⋅ 3 + 0 = 6 points.
In the second example, if we delete characters one by one, then for each deleted character we will get (-2) ⋅ 1 + 5 = 3 points, i. e. 15 points in total.
In the third example, we can delete the substring 00 from the string 100111, we get 1 ⋅ 2 + (-4) = -2 points, and the string will be equal to 1111, removing it entirely we get 1 ⋅ 4 + (-4) = 0 points. In total, we got -2 points for 2 operations.
Submitted Solution:
```
for _ in range(int(input())):
n,a,b=map(int,input().split())
s=input()
if(b>=0):
print(n*(a+b))
else:
o=0;
z=0;
x=int(s[0]);
y=int(s[0]);
w=1
for i in s:
i=int(i)
if i==1:o+=1
else:
z+=1;
if i!=y:
w+=1;
y=i
if z==0 or o==0:
print(n*a+b)
else:
print(n*a+(w//2+1)*b)
``` | instruction | 0 | 30,341 | 0 | 60,682 |
Yes | output | 1 | 30,341 | 0 | 60,683 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s of length n consisting only of the characters 0 and 1.
You perform the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue the remaining two parts together (any of them can be empty) in the same order. For example, if you erase the substring 111 from the string 111110, you will get the string 110. When you delete a substring of length l, you get a ⋅ l + b points.
Your task is to calculate the maximum number of points that you can score in total, if you have to make the given string empty.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of testcases.
The first line of each testcase contains three integers n, a and b (1 ≤ n ≤ 100; -100 ≤ a, b ≤ 100) — the length of the string s and the parameters a and b.
The second line contains the string s. The string s consists only of the characters 0 and 1.
Output
For each testcase, print a single integer — the maximum number of points that you can score.
Example
Input
3
3 2 0
000
5 -2 5
11001
6 1 -4
100111
Output
6
15
-2
Note
In the first example, it is enough to delete the entire string, then we will get 2 ⋅ 3 + 0 = 6 points.
In the second example, if we delete characters one by one, then for each deleted character we will get (-2) ⋅ 1 + 5 = 3 points, i. e. 15 points in total.
In the third example, we can delete the substring 00 from the string 100111, we get 1 ⋅ 2 + (-4) = -2 points, and the string will be equal to 1111, removing it entirely we get 1 ⋅ 4 + (-4) = 0 points. In total, we got -2 points for 2 operations.
Submitted Solution:
```
import sys
import collections
import math
inf = sys.maxsize
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def input(): return sys.stdin.readline().strip()
mod = 1000000007
for _ in range(int(input())):
n, a, b = get_ints()
s = input()
zeros, ones = [], []
cnt = 1
for i in range(1, len(s)):
if s[i] == s[i - 1]:
cnt += 1
else:
if s[i - 1] == '0':
zeros.append(cnt)
else:
ones.append(cnt)
cnt = 1
if s[-1] == '0':
zeros.append(cnt)
else:
ones.append(cnt)
if b < 0:
res1 = 0;
res2 = 0;
sum1 = sum(ones)
sum2 = sum(zeros)
for i in range(len(zeros)):
res1 += zeros[i] * a + b
res1 += sum1 * a + b
for i in range(len(ones)):
res2 += ones[i] * a + b
res2 += sum2 * a + b
print(max(res1, res2))
else:
print(len(s) * a + len(s) * b)
``` | instruction | 0 | 30,342 | 0 | 60,684 |
Yes | output | 1 | 30,342 | 0 | 60,685 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s of length n consisting only of the characters 0 and 1.
You perform the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue the remaining two parts together (any of them can be empty) in the same order. For example, if you erase the substring 111 from the string 111110, you will get the string 110. When you delete a substring of length l, you get a ⋅ l + b points.
Your task is to calculate the maximum number of points that you can score in total, if you have to make the given string empty.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of testcases.
The first line of each testcase contains three integers n, a and b (1 ≤ n ≤ 100; -100 ≤ a, b ≤ 100) — the length of the string s and the parameters a and b.
The second line contains the string s. The string s consists only of the characters 0 and 1.
Output
For each testcase, print a single integer — the maximum number of points that you can score.
Example
Input
3
3 2 0
000
5 -2 5
11001
6 1 -4
100111
Output
6
15
-2
Note
In the first example, it is enough to delete the entire string, then we will get 2 ⋅ 3 + 0 = 6 points.
In the second example, if we delete characters one by one, then for each deleted character we will get (-2) ⋅ 1 + 5 = 3 points, i. e. 15 points in total.
In the third example, we can delete the substring 00 from the string 100111, we get 1 ⋅ 2 + (-4) = -2 points, and the string will be equal to 1111, removing it entirely we get 1 ⋅ 4 + (-4) = 0 points. In total, we got -2 points for 2 operations.
Submitted Solution:
```
import collections
import math
import collections
import sys
from functools import reduce
import decimal
sys.setrecursionlimit(10 ** 9)
decimal.getcontext().rounding = decimal.ROUND_HALF_UP
graphDict = collections.defaultdict
queue = collections.deque()
class Graphs:
def __init__(self):
self.graph = graphDict(list)
def add_edge(self, u, v):
self.graph[u].append(v)
def dfs_utility(self, nodes, visited_nodes):
visited_nodes.add(nodes)
for neighbour in self.graph[nodes]:
if neighbour not in visited_nodes:
self.dfs_utility(neighbour, visited_nodes)
else:
return neighbour
def dfs(self, node):
Visited = set()
self.dfs_utility(node, Visited)
def bfs(self, node):
visited = set()
if node not in visited:
queue.append(node)
visited.add(node)
while queue:
parent = queue.popleft()
print(parent)
for item in self.graph[parent]:
if item not in visited:
queue.append(item)
visited.add(item)
def rounding(n):
return int(decimal.Decimal(f'{n}').to_integral_value())
def factors(n):
return set(reduce(list.__add__,
([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
def inp():
return sys.stdin.readline().strip()
def map_inp(v_type):
return map(v_type, inp().split())
def list_inp(v_type):
return list(map_inp(v_type))
######################################## Solution ####################################
for _ in range(int(inp())):
n, a, b = map_inp(int)
arr = list(inp())
if a >= 0 and b >= 0:
print(len(arr) * (a + b))
elif b >= 0:
print(len(arr) * (a + b))
else:
dic = []
for i in range(len(arr)):
if i == 0:
dic.append(1)
continue
if arr[i] == arr[i - 1]:
dic[len(dic) - 1] += 1
else:
dic.append(1)
even_sum = 0
odd_sum = 0
for i in range(len(dic)):
if i & 1 == 0:
even_sum += dic[i]
else:
odd_sum += dic[i]
ans1, ans2 = 0, 0
ans1 += a * even_sum + b
for i in range(1, len(dic), 2):
ans1 += a * dic[i] + b
ans2 += a * odd_sum + b
for i in range(0, len(dic), 2):
ans2 += a * dic[i] + b
print(max(ans1, ans2))
``` | instruction | 0 | 30,343 | 0 | 60,686 |
Yes | output | 1 | 30,343 | 0 | 60,687 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s of length n consisting only of the characters 0 and 1.
You perform the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue the remaining two parts together (any of them can be empty) in the same order. For example, if you erase the substring 111 from the string 111110, you will get the string 110. When you delete a substring of length l, you get a ⋅ l + b points.
Your task is to calculate the maximum number of points that you can score in total, if you have to make the given string empty.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of testcases.
The first line of each testcase contains three integers n, a and b (1 ≤ n ≤ 100; -100 ≤ a, b ≤ 100) — the length of the string s and the parameters a and b.
The second line contains the string s. The string s consists only of the characters 0 and 1.
Output
For each testcase, print a single integer — the maximum number of points that you can score.
Example
Input
3
3 2 0
000
5 -2 5
11001
6 1 -4
100111
Output
6
15
-2
Note
In the first example, it is enough to delete the entire string, then we will get 2 ⋅ 3 + 0 = 6 points.
In the second example, if we delete characters one by one, then for each deleted character we will get (-2) ⋅ 1 + 5 = 3 points, i. e. 15 points in total.
In the third example, we can delete the substring 00 from the string 100111, we get 1 ⋅ 2 + (-4) = -2 points, and the string will be equal to 1111, removing it entirely we get 1 ⋅ 4 + (-4) = 0 points. In total, we got -2 points for 2 operations.
Submitted Solution:
```
t = int(input())
for i in range(t):
n, a, b=[int(j) for j in input().split()]
k = input()
if b >= 0:
print(n*a + b*n)
else:
print(n*a+b*(max(k.count('01'),k.count('10'))+1))
``` | instruction | 0 | 30,344 | 0 | 60,688 |
Yes | output | 1 | 30,344 | 0 | 60,689 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s of length n consisting only of the characters 0 and 1.
You perform the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue the remaining two parts together (any of them can be empty) in the same order. For example, if you erase the substring 111 from the string 111110, you will get the string 110. When you delete a substring of length l, you get a ⋅ l + b points.
Your task is to calculate the maximum number of points that you can score in total, if you have to make the given string empty.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of testcases.
The first line of each testcase contains three integers n, a and b (1 ≤ n ≤ 100; -100 ≤ a, b ≤ 100) — the length of the string s and the parameters a and b.
The second line contains the string s. The string s consists only of the characters 0 and 1.
Output
For each testcase, print a single integer — the maximum number of points that you can score.
Example
Input
3
3 2 0
000
5 -2 5
11001
6 1 -4
100111
Output
6
15
-2
Note
In the first example, it is enough to delete the entire string, then we will get 2 ⋅ 3 + 0 = 6 points.
In the second example, if we delete characters one by one, then for each deleted character we will get (-2) ⋅ 1 + 5 = 3 points, i. e. 15 points in total.
In the third example, we can delete the substring 00 from the string 100111, we get 1 ⋅ 2 + (-4) = -2 points, and the string will be equal to 1111, removing it entirely we get 1 ⋅ 4 + (-4) = 0 points. In total, we got -2 points for 2 operations.
Submitted Solution:
```
def solve():
n,a,b = map(int,input().split())
s = input()
li = []
for i in s:
if i=='1':
li.append(1)
else:
li.append(0)
if b>=0:
print(n*(a+b))
else:
i = 0
j = 0
ans = 0
temp = []
while i<n and j<n:
if li[i]==li[j]:
j+=1
else:
if li[i]==0:
temp.append(j-i)
i = j
j = i+1
if li[i]==0:
temp.append(j-i)
ans+=n*a + (len(temp)+1)*b
print(ans)
t = int(input())
for _ in range(t):
solve()
``` | instruction | 0 | 30,345 | 0 | 60,690 |
No | output | 1 | 30,345 | 0 | 60,691 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s of length n consisting only of the characters 0 and 1.
You perform the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue the remaining two parts together (any of them can be empty) in the same order. For example, if you erase the substring 111 from the string 111110, you will get the string 110. When you delete a substring of length l, you get a ⋅ l + b points.
Your task is to calculate the maximum number of points that you can score in total, if you have to make the given string empty.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of testcases.
The first line of each testcase contains three integers n, a and b (1 ≤ n ≤ 100; -100 ≤ a, b ≤ 100) — the length of the string s and the parameters a and b.
The second line contains the string s. The string s consists only of the characters 0 and 1.
Output
For each testcase, print a single integer — the maximum number of points that you can score.
Example
Input
3
3 2 0
000
5 -2 5
11001
6 1 -4
100111
Output
6
15
-2
Note
In the first example, it is enough to delete the entire string, then we will get 2 ⋅ 3 + 0 = 6 points.
In the second example, if we delete characters one by one, then for each deleted character we will get (-2) ⋅ 1 + 5 = 3 points, i. e. 15 points in total.
In the third example, we can delete the substring 00 from the string 100111, we get 1 ⋅ 2 + (-4) = -2 points, and the string will be equal to 1111, removing it entirely we get 1 ⋅ 4 + (-4) = 0 points. In total, we got -2 points for 2 operations.
Submitted Solution:
```
def count(string,length):
res = 0
for i in range(1,length):
if(string[i] != string[i-1]): res+=1
if(res < 2):
return res + 1
else:
return res
t = int(input())
for case in range(t):
line = [int(x) for x in input().split()]
if (line[2] >= 0):
input()
print(line[0]*(line[1]+line[2]))
else:
print(line[0]*line[1]+line[2]*count(input(),line[0]))
``` | instruction | 0 | 30,346 | 0 | 60,692 |
No | output | 1 | 30,346 | 0 | 60,693 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s of length n consisting only of the characters 0 and 1.
You perform the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue the remaining two parts together (any of them can be empty) in the same order. For example, if you erase the substring 111 from the string 111110, you will get the string 110. When you delete a substring of length l, you get a ⋅ l + b points.
Your task is to calculate the maximum number of points that you can score in total, if you have to make the given string empty.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of testcases.
The first line of each testcase contains three integers n, a and b (1 ≤ n ≤ 100; -100 ≤ a, b ≤ 100) — the length of the string s and the parameters a and b.
The second line contains the string s. The string s consists only of the characters 0 and 1.
Output
For each testcase, print a single integer — the maximum number of points that you can score.
Example
Input
3
3 2 0
000
5 -2 5
11001
6 1 -4
100111
Output
6
15
-2
Note
In the first example, it is enough to delete the entire string, then we will get 2 ⋅ 3 + 0 = 6 points.
In the second example, if we delete characters one by one, then for each deleted character we will get (-2) ⋅ 1 + 5 = 3 points, i. e. 15 points in total.
In the third example, we can delete the substring 00 from the string 100111, we get 1 ⋅ 2 + (-4) = -2 points, and the string will be equal to 1111, removing it entirely we get 1 ⋅ 4 + (-4) = 0 points. In total, we got -2 points for 2 operations.
Submitted Solution:
```
t=int(input())
def maxConsOne(s,val):
dp={}
count=0
# for i in range(len(s)):
i=0
while i<len(s):
if s[i]==str(val):
count=0
while i<len(s) and s[i]==str(val):
count+=1
i+=1
if count not in dp:
dp[count]=0
dp[count]+=1
else:
i+=1
return dp
for _ in range(t):
n,a,b=map(int,input().split())
s=input()
if b>0:
val=n*(a+b)
print(val)
continue
else:
dp1=maxConsOne(s,1)
dp0=maxConsOne(s,0)
count=0
for i in range(len(s)):
if s[i]==chr(1):
count+=1
n1=count
n0=n-n1
max1=0
for key,val in dp1.items():
max1+=(a*key+b)*val
max1+=(n0*a+b)
max0=0
for key,val in dp0.items():
max0+=(a*key+b)*val
max0+=(n1*a+b)
# print(dp0,dp1)
# print(max0,max1)
max0=max(max0,max1)
print(max0)
``` | instruction | 0 | 30,347 | 0 | 60,694 |
No | output | 1 | 30,347 | 0 | 60,695 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s of length n consisting only of the characters 0 and 1.
You perform the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue the remaining two parts together (any of them can be empty) in the same order. For example, if you erase the substring 111 from the string 111110, you will get the string 110. When you delete a substring of length l, you get a ⋅ l + b points.
Your task is to calculate the maximum number of points that you can score in total, if you have to make the given string empty.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of testcases.
The first line of each testcase contains three integers n, a and b (1 ≤ n ≤ 100; -100 ≤ a, b ≤ 100) — the length of the string s and the parameters a and b.
The second line contains the string s. The string s consists only of the characters 0 and 1.
Output
For each testcase, print a single integer — the maximum number of points that you can score.
Example
Input
3
3 2 0
000
5 -2 5
11001
6 1 -4
100111
Output
6
15
-2
Note
In the first example, it is enough to delete the entire string, then we will get 2 ⋅ 3 + 0 = 6 points.
In the second example, if we delete characters one by one, then for each deleted character we will get (-2) ⋅ 1 + 5 = 3 points, i. e. 15 points in total.
In the third example, we can delete the substring 00 from the string 100111, we get 1 ⋅ 2 + (-4) = -2 points, and the string will be equal to 1111, removing it entirely we get 1 ⋅ 4 + (-4) = 0 points. In total, we got -2 points for 2 operations.
Submitted Solution:
```
t = int(input())
for _ in range(t):
n,a,b = map(int,input().split())
s = input()
if b>=0:
print(a*n+b*n)
continue
v = list( ord(i) for i in s)
x = 1
res = 0
y = 0
for i in range(1,n):
if v[i] == v[0]:
x+=1
y+=1
else:
if x>0:res += x*a+b
x = 0
if x>0:
res+=x*a+b
if y!=n:
res+=(n-y)*a+b
best = res
x = 0
y = 0
res = 0
for i in range(1,n):
if v[i] != v[0]:
x+=1
y+=1
else:
if x>0: res += x*a+b
x = 0
if x>0:
res+=x*a+b
if y!=n:
res+=(n-y)*a+b
print(max(best,res))
``` | instruction | 0 | 30,348 | 0 | 60,696 |
No | output | 1 | 30,348 | 0 | 60,697 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp has got two strings s and t having equal length. Both strings consist of lowercase Latin letters "a" and "b".
Monocarp wants to make these two strings s and t equal to each other. He can do the following operation any number of times: choose an index pos_1 in the string s, choose an index pos_2 in the string t, and swap s_{pos_1} with t_{pos_2}.
You have to determine the minimum number of operations Monocarp has to perform to make s and t equal, and print any optimal sequence of operations — or say that it is impossible to make these strings equal.
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^{5}) — the length of s and t.
The second line contains one string s consisting of n characters "a" and "b".
The third line contains one string t consisting of n characters "a" and "b".
Output
If it is impossible to make these strings equal, print -1.
Otherwise, in the first line print k — the minimum number of operations required to make the strings equal. In each of the next k lines print two integers — the index in the string s and the index in the string t that should be used in the corresponding swap operation.
Examples
Input
4
abab
aabb
Output
2
3 3
3 2
Input
1
a
b
Output
-1
Input
8
babbaabb
abababaa
Output
3
2 6
1 3
7 8
Note
In the first example two operations are enough. For example, you can swap the third letter in s with the third letter in t. Then s = "abbb", t = "aaab". Then swap the third letter in s and the second letter in t. Then both s and t are equal to "abab".
In the second example it's impossible to make two strings equal. | instruction | 0 | 31,051 | 0 | 62,102 |
Tags: constructive algorithms, greedy
Correct Solution:
```
import sys
n = int(input())
s = input()
t = input()
l1 = []
l2 = []
for i in range(n):
if s[i] == 'a' and t[i] == 'b':
l1.append(i+1)
if s[i] == 'b' and t[i] == 'a':
l2.append(i+1)
if (len(l1)+len(l2))%2 != 0:
print(-1)
sys.exit()
if len(l1)%2 != 0:
ans = int(len(l1)/2)+int(len(l2)/2)+2
print(ans)
for i in range(1,len(l1)-1,2):
print(l1[i-1],l1[i])
for i in range(2,len(l2),2):
print(l2[i-1],l2[i])
print(l1[len(l1)-1],l1[len(l1)-1])
print(l1[len(l1)-1],l2[0])
else:
ans = int(len(l1)/2)+int(len(l2)/2)
print(ans)
for i in range(1,len(l1),2):
print(l1[i-1],l1[i])
for i in range(1,len(l2),2):
print(l2[i-1],l2[i])
``` | output | 1 | 31,051 | 0 | 62,103 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp has got two strings s and t having equal length. Both strings consist of lowercase Latin letters "a" and "b".
Monocarp wants to make these two strings s and t equal to each other. He can do the following operation any number of times: choose an index pos_1 in the string s, choose an index pos_2 in the string t, and swap s_{pos_1} with t_{pos_2}.
You have to determine the minimum number of operations Monocarp has to perform to make s and t equal, and print any optimal sequence of operations — or say that it is impossible to make these strings equal.
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^{5}) — the length of s and t.
The second line contains one string s consisting of n characters "a" and "b".
The third line contains one string t consisting of n characters "a" and "b".
Output
If it is impossible to make these strings equal, print -1.
Otherwise, in the first line print k — the minimum number of operations required to make the strings equal. In each of the next k lines print two integers — the index in the string s and the index in the string t that should be used in the corresponding swap operation.
Examples
Input
4
abab
aabb
Output
2
3 3
3 2
Input
1
a
b
Output
-1
Input
8
babbaabb
abababaa
Output
3
2 6
1 3
7 8
Note
In the first example two operations are enough. For example, you can swap the third letter in s with the third letter in t. Then s = "abbb", t = "aaab". Then swap the third letter in s and the second letter in t. Then both s and t are equal to "abab".
In the second example it's impossible to make two strings equal. | instruction | 0 | 31,052 | 0 | 62,104 |
Tags: constructive algorithms, greedy
Correct Solution:
```
n=int(input())
s=list(input())
t=list(input())
dic={'a,b':[],'b,a':[]}
for i in range(n):
if(s[i]!=t[i]):
if(s[i]=='a'):
dic['a,b'].append(i)
else:
dic['b,a'].append(i)
l1=len(dic['a,b'])
l2=len(dic['b,a'])
if((l1+l2)%2!=0):
print(-1)
else:
if(l1%2!=0):
print((l1+l2)//2+1)
print(dic['b,a'][-1]+1,dic['b,a'][-1]+1)
dic['a,b'].append(dic['b,a'][-1])
del dic['b,a'][-1]
l1+=1
l2-=1
else:
print((l1+l2)//2)
if(l2!=0):
for i in range(0,l2,2):
print(dic['b,a'][i]+1,dic['b,a'][i+1]+1)
if(l1!=0):
for i in range(0,l1,2):
print(dic['a,b'][i]+1,dic['a,b'][i+1]+1)
``` | output | 1 | 31,052 | 0 | 62,105 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp has got two strings s and t having equal length. Both strings consist of lowercase Latin letters "a" and "b".
Monocarp wants to make these two strings s and t equal to each other. He can do the following operation any number of times: choose an index pos_1 in the string s, choose an index pos_2 in the string t, and swap s_{pos_1} with t_{pos_2}.
You have to determine the minimum number of operations Monocarp has to perform to make s and t equal, and print any optimal sequence of operations — or say that it is impossible to make these strings equal.
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^{5}) — the length of s and t.
The second line contains one string s consisting of n characters "a" and "b".
The third line contains one string t consisting of n characters "a" and "b".
Output
If it is impossible to make these strings equal, print -1.
Otherwise, in the first line print k — the minimum number of operations required to make the strings equal. In each of the next k lines print two integers — the index in the string s and the index in the string t that should be used in the corresponding swap operation.
Examples
Input
4
abab
aabb
Output
2
3 3
3 2
Input
1
a
b
Output
-1
Input
8
babbaabb
abababaa
Output
3
2 6
1 3
7 8
Note
In the first example two operations are enough. For example, you can swap the third letter in s with the third letter in t. Then s = "abbb", t = "aaab". Then swap the third letter in s and the second letter in t. Then both s and t are equal to "abab".
In the second example it's impossible to make two strings equal. | instruction | 0 | 31,053 | 0 | 62,106 |
Tags: constructive algorithms, greedy
Correct Solution:
```
""" 616C """
""" 1152B """
# import math
# import sys
def main():
# n ,m= map(int,input().split())
# arr = list(map(int,input().split()))
# b = list(map(int,input().split()))
# n = int(input())
# string = str(input())
n = int(input())
s1 = str(input())
s2 = str(input())
if(s1==s2):
print(0)
return
a = []
b = []
cnt = 0
for i in range(n):
if s1[i]!=s2[i]:
cnt+=1
if(s1[i]=='a'):
a.append(i+1)
else:
b.append(i+1)
if(cnt%2):
print(-1)
return
if(len(a)%2):
print(((len(a)+len(b))//2)+1)
else:
print(((len(a)+len(b))//2))
for i in range(0,len(a)-(len(a)%2),2):
print(a[i],a[i+1])
for i in range(0,len(b)-(len(b)%2),2):
print(b[i],b[i+1])
if(len(a)%2!=0):
print(a[-1],a[-1])
print(a[-1],b[-1])
return
main()
# def test():
# t = int(input())
# while t:
# main()
# t-=1
# test()
``` | output | 1 | 31,053 | 0 | 62,107 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp has got two strings s and t having equal length. Both strings consist of lowercase Latin letters "a" and "b".
Monocarp wants to make these two strings s and t equal to each other. He can do the following operation any number of times: choose an index pos_1 in the string s, choose an index pos_2 in the string t, and swap s_{pos_1} with t_{pos_2}.
You have to determine the minimum number of operations Monocarp has to perform to make s and t equal, and print any optimal sequence of operations — or say that it is impossible to make these strings equal.
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^{5}) — the length of s and t.
The second line contains one string s consisting of n characters "a" and "b".
The third line contains one string t consisting of n characters "a" and "b".
Output
If it is impossible to make these strings equal, print -1.
Otherwise, in the first line print k — the minimum number of operations required to make the strings equal. In each of the next k lines print two integers — the index in the string s and the index in the string t that should be used in the corresponding swap operation.
Examples
Input
4
abab
aabb
Output
2
3 3
3 2
Input
1
a
b
Output
-1
Input
8
babbaabb
abababaa
Output
3
2 6
1 3
7 8
Note
In the first example two operations are enough. For example, you can swap the third letter in s with the third letter in t. Then s = "abbb", t = "aaab". Then swap the third letter in s and the second letter in t. Then both s and t are equal to "abab".
In the second example it's impossible to make two strings equal. | instruction | 0 | 31,054 | 0 | 62,108 |
Tags: constructive algorithms, greedy
Correct Solution:
```
SI = lambda : input()
from collections import Counter
n = int(input())
a = SI()
b = SI()
def solve(n,a,b):
d = Counter(a)+Counter(b)
for i in d:
if(d[i]&1):
print(-1)
return
xa = d[a]//2
newa = []
newb = []
for i in range(n):
if(a[i]!=b[i]):
newa.append((a[i],i))
newb.append((b[i],i))
a,b = newa,newb
aux = len(a)
if(aux==0):
print(0)
return
canta = 0
for i in a:
if(i[0]=='a'):
canta+=1
if(canta&1):
print(len(a)//2+1)
print(a[0][1]+1,a[0][1]+1)
a[0],b[0] = b[0],a[0]
else:
print(len(a)//2)
lastA,lastB = -1,-1
for i in range(aux):
if(a[i][0]=='a'):
if(lastA==-1):
lastA=a[i][1]
else:
print(lastA+1,a[i][1]+1)
lastA=-1
else:
if(lastB==-1):
lastB=a[i][1]
else:
print(lastB+1,a[i][1]+1)
lastB=-1
solve(n,a,b)
``` | output | 1 | 31,054 | 0 | 62,109 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp has got two strings s and t having equal length. Both strings consist of lowercase Latin letters "a" and "b".
Monocarp wants to make these two strings s and t equal to each other. He can do the following operation any number of times: choose an index pos_1 in the string s, choose an index pos_2 in the string t, and swap s_{pos_1} with t_{pos_2}.
You have to determine the minimum number of operations Monocarp has to perform to make s and t equal, and print any optimal sequence of operations — or say that it is impossible to make these strings equal.
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^{5}) — the length of s and t.
The second line contains one string s consisting of n characters "a" and "b".
The third line contains one string t consisting of n characters "a" and "b".
Output
If it is impossible to make these strings equal, print -1.
Otherwise, in the first line print k — the minimum number of operations required to make the strings equal. In each of the next k lines print two integers — the index in the string s and the index in the string t that should be used in the corresponding swap operation.
Examples
Input
4
abab
aabb
Output
2
3 3
3 2
Input
1
a
b
Output
-1
Input
8
babbaabb
abababaa
Output
3
2 6
1 3
7 8
Note
In the first example two operations are enough. For example, you can swap the third letter in s with the third letter in t. Then s = "abbb", t = "aaab". Then swap the third letter in s and the second letter in t. Then both s and t are equal to "abab".
In the second example it's impossible to make two strings equal. | instruction | 0 | 31,055 | 0 | 62,110 |
Tags: constructive algorithms, greedy
Correct Solution:
```
#!/usr/bin/env python3
import sys
def rint():
return map(int, sys.stdin.readline().split())
#lines = stdin.readlines()
n = int(input())
s = input()
t = input()
ab = []
ba = []
for i in range(n):
if s[i] == 'a' and t[i] == 'b':
ab.append(i+1)
elif s[i] == 'b' and t[i] == 'a':
ba.append(i+1)
#print(ab, ba)
if (len(ab) + len(ba))%2:
print(-1)
exit()
cnt = 0
ans = []
while len(ab) >= 2:
tmp1 = ab.pop()
tmp2 = ab.pop()
ans.append([tmp1, tmp2])
cnt += 1
while len(ba) >= 2:
tmp1 = ba.pop()
tmp2 = ba.pop()
ans.append([tmp1, tmp2])
cnt += 1
if len(ab) == 1:
tmp1 = ab.pop()
tmp2 = ba.pop()
ans.append([tmp1, tmp1])
ans.append([tmp1, tmp2])
cnt += 2
print(cnt)
for pair in ans:
print(*pair)
``` | output | 1 | 31,055 | 0 | 62,111 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp has got two strings s and t having equal length. Both strings consist of lowercase Latin letters "a" and "b".
Monocarp wants to make these two strings s and t equal to each other. He can do the following operation any number of times: choose an index pos_1 in the string s, choose an index pos_2 in the string t, and swap s_{pos_1} with t_{pos_2}.
You have to determine the minimum number of operations Monocarp has to perform to make s and t equal, and print any optimal sequence of operations — or say that it is impossible to make these strings equal.
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^{5}) — the length of s and t.
The second line contains one string s consisting of n characters "a" and "b".
The third line contains one string t consisting of n characters "a" and "b".
Output
If it is impossible to make these strings equal, print -1.
Otherwise, in the first line print k — the minimum number of operations required to make the strings equal. In each of the next k lines print two integers — the index in the string s and the index in the string t that should be used in the corresponding swap operation.
Examples
Input
4
abab
aabb
Output
2
3 3
3 2
Input
1
a
b
Output
-1
Input
8
babbaabb
abababaa
Output
3
2 6
1 3
7 8
Note
In the first example two operations are enough. For example, you can swap the third letter in s with the third letter in t. Then s = "abbb", t = "aaab". Then swap the third letter in s and the second letter in t. Then both s and t are equal to "abab".
In the second example it's impossible to make two strings equal. | instruction | 0 | 31,056 | 0 | 62,112 |
Tags: constructive algorithms, greedy
Correct Solution:
```
n=int(input())
s=input()
t=input()
a,b=[],[]
for i in range(n):
if s[i]!=t[i]:
if s[i]=="a":
a.append(i+1)
else:
b.append(i+1)
x,y=len(a),len(b)
if x%2==y%2:
k=(x+y)//2
if x%2==1:
print(k+1)
for i in range(0,x-1,2):
print(a[i], a[i+1])
for i in range(0,y-1,2):
print(b[i],b[i+1])
print(a[-1],a[-1])
print(a[-1],b[-1])
else:
print(k)
for i in range(0,x-1,2):
print(a[i], a[i+1])
for i in range(0,y-1,2):
print(b[i],b[i+1])
else:
print("-1")
``` | output | 1 | 31,056 | 0 | 62,113 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp has got two strings s and t having equal length. Both strings consist of lowercase Latin letters "a" and "b".
Monocarp wants to make these two strings s and t equal to each other. He can do the following operation any number of times: choose an index pos_1 in the string s, choose an index pos_2 in the string t, and swap s_{pos_1} with t_{pos_2}.
You have to determine the minimum number of operations Monocarp has to perform to make s and t equal, and print any optimal sequence of operations — or say that it is impossible to make these strings equal.
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^{5}) — the length of s and t.
The second line contains one string s consisting of n characters "a" and "b".
The third line contains one string t consisting of n characters "a" and "b".
Output
If it is impossible to make these strings equal, print -1.
Otherwise, in the first line print k — the minimum number of operations required to make the strings equal. In each of the next k lines print two integers — the index in the string s and the index in the string t that should be used in the corresponding swap operation.
Examples
Input
4
abab
aabb
Output
2
3 3
3 2
Input
1
a
b
Output
-1
Input
8
babbaabb
abababaa
Output
3
2 6
1 3
7 8
Note
In the first example two operations are enough. For example, you can swap the third letter in s with the third letter in t. Then s = "abbb", t = "aaab". Then swap the third letter in s and the second letter in t. Then both s and t are equal to "abab".
In the second example it's impossible to make two strings equal. | instruction | 0 | 31,057 | 0 | 62,114 |
Tags: constructive algorithms, greedy
Correct Solution:
```
n = int(input())
s = list(input())
t = list(input())
lis1=[]
lis2=[]
for i in range(n):
if s[i]!=t[i] and s[i]=='a' and t[i]=='b':
lis1.append([0,0,0])
lis1[-1][0]=s[i]
lis1[-1][1]=t[i]
lis1[-1][2]=i
if s[i]!=t[i] and s[i]=='b' and t[i]=='a':
lis2.append([0,0,0])
lis2[-1][0]=s[i]
lis2[-1][1]=t[i]
lis2[-1][2]=i
#print(lis1,lis2)
if (len(lis1)+len(lis2))%2:
print(-1)
else:
l1=len(lis1)
l2=len(lis2)
ans=[]
if l1%2 and l2%2:
print((l1+l2)//2 +1)
for i in range(0,l1-1,2):
ans.append([lis1[i][2]+1,lis1[i+1][2]+1])
ans.append([lis2[0][2]+1,lis2[0][2]+1])
ans.append([lis1[-1][2]+1,lis2[0][2]+1])
for i in range(1,l2,2):
ans.append([lis2[i][2]+1,lis2[i+1][2]+1])
else:
print((l1+l2)//2)
for i in range(0,l1,2):
ans.append([lis1[i][2]+1,lis1[i+1][2]+1])
for i in range(0,l2,2):
ans.append([lis2[i][2]+1,lis2[i+1][2]+1])
for i in ans:
print(*i)
``` | output | 1 | 31,057 | 0 | 62,115 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp has got two strings s and t having equal length. Both strings consist of lowercase Latin letters "a" and "b".
Monocarp wants to make these two strings s and t equal to each other. He can do the following operation any number of times: choose an index pos_1 in the string s, choose an index pos_2 in the string t, and swap s_{pos_1} with t_{pos_2}.
You have to determine the minimum number of operations Monocarp has to perform to make s and t equal, and print any optimal sequence of operations — or say that it is impossible to make these strings equal.
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^{5}) — the length of s and t.
The second line contains one string s consisting of n characters "a" and "b".
The third line contains one string t consisting of n characters "a" and "b".
Output
If it is impossible to make these strings equal, print -1.
Otherwise, in the first line print k — the minimum number of operations required to make the strings equal. In each of the next k lines print two integers — the index in the string s and the index in the string t that should be used in the corresponding swap operation.
Examples
Input
4
abab
aabb
Output
2
3 3
3 2
Input
1
a
b
Output
-1
Input
8
babbaabb
abababaa
Output
3
2 6
1 3
7 8
Note
In the first example two operations are enough. For example, you can swap the third letter in s with the third letter in t. Then s = "abbb", t = "aaab". Then swap the third letter in s and the second letter in t. Then both s and t are equal to "abab".
In the second example it's impossible to make two strings equal. | instruction | 0 | 31,058 | 0 | 62,116 |
Tags: constructive algorithms, greedy
Correct Solution:
```
# link: https://codeforces.com/problemset/problem/1215/C
for _ in range(1):
n = int(input())
s = input()
t = input()
pos01 = []
pos10 = []
for i in range(n):
if s[i] != t[i]:
if s[i] == 'a': pos01.append(i)
else: pos10.append(i)
if len(pos10) % 2 == len(pos01) % 2:
ans = []
for i in range(0,len(pos01),2):
if i+1 < len(pos01):
ans.append((pos01[i], pos01[i+1]))
else: break
for i in range(0,len(pos10),2):
if i+1 < len(pos10):
ans.append((pos10[i], pos10[i+1]))
else: break
if len(pos01) % 2:
x = pos01[-1]
y = pos10[-1]
ans.append((x,x))
ans.append((x,y))
print(len(ans))
for info in ans:
print(info[0] + 1, info[1] + 1)
else:
print(-1)
``` | output | 1 | 31,058 | 0 | 62,117 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has got two strings s and t having equal length. Both strings consist of lowercase Latin letters "a" and "b".
Monocarp wants to make these two strings s and t equal to each other. He can do the following operation any number of times: choose an index pos_1 in the string s, choose an index pos_2 in the string t, and swap s_{pos_1} with t_{pos_2}.
You have to determine the minimum number of operations Monocarp has to perform to make s and t equal, and print any optimal sequence of operations — or say that it is impossible to make these strings equal.
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^{5}) — the length of s and t.
The second line contains one string s consisting of n characters "a" and "b".
The third line contains one string t consisting of n characters "a" and "b".
Output
If it is impossible to make these strings equal, print -1.
Otherwise, in the first line print k — the minimum number of operations required to make the strings equal. In each of the next k lines print two integers — the index in the string s and the index in the string t that should be used in the corresponding swap operation.
Examples
Input
4
abab
aabb
Output
2
3 3
3 2
Input
1
a
b
Output
-1
Input
8
babbaabb
abababaa
Output
3
2 6
1 3
7 8
Note
In the first example two operations are enough. For example, you can swap the third letter in s with the third letter in t. Then s = "abbb", t = "aaab". Then swap the third letter in s and the second letter in t. Then both s and t are equal to "abab".
In the second example it's impossible to make two strings equal.
Submitted Solution:
```
R = lambda: map(int, input().split())
n = int(input())
s1 = input()
s2 = input()
ab,ba = [],[]
for i in range(n):
if s1[i] == 'a' and s2[i] == 'b':ab.append(i)
elif s1[i] == 'b' and s2[i] == 'a':ba.append(i)
l1,l2 = len(ab),len(ba)
if (l1 + l2) % 2:print(-1)
else:
print(((l1+l2)//2) + (l1 % 2))
if l1 % 2:
k = ab.pop()
print(k+1,k+1)
ba.append(k)
l1 -= 1
l2 += 1
for i in range(0,l1,2):print(ab[i]+1,ab[i+1]+1)
for i in range(0,l2,2):print(ba[i]+1,ba[i+1]+1)
``` | instruction | 0 | 31,059 | 0 | 62,118 |
Yes | output | 1 | 31,059 | 0 | 62,119 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has got two strings s and t having equal length. Both strings consist of lowercase Latin letters "a" and "b".
Monocarp wants to make these two strings s and t equal to each other. He can do the following operation any number of times: choose an index pos_1 in the string s, choose an index pos_2 in the string t, and swap s_{pos_1} with t_{pos_2}.
You have to determine the minimum number of operations Monocarp has to perform to make s and t equal, and print any optimal sequence of operations — or say that it is impossible to make these strings equal.
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^{5}) — the length of s and t.
The second line contains one string s consisting of n characters "a" and "b".
The third line contains one string t consisting of n characters "a" and "b".
Output
If it is impossible to make these strings equal, print -1.
Otherwise, in the first line print k — the minimum number of operations required to make the strings equal. In each of the next k lines print two integers — the index in the string s and the index in the string t that should be used in the corresponding swap operation.
Examples
Input
4
abab
aabb
Output
2
3 3
3 2
Input
1
a
b
Output
-1
Input
8
babbaabb
abababaa
Output
3
2 6
1 3
7 8
Note
In the first example two operations are enough. For example, you can swap the third letter in s with the third letter in t. Then s = "abbb", t = "aaab". Then swap the third letter in s and the second letter in t. Then both s and t are equal to "abab".
In the second example it's impossible to make two strings equal.
Submitted Solution:
```
n=int(input())
x=input()
y=input()
ba=[]
ab=[]
i=0
while i<n:
if x[i]=="a" and y[i]=="b":
ab.append(i+1)
elif x[i]=="b" and y[i]=="a":
ba.append(i+1)
i+=1
if (len(ab)+len(ba))%2==1:
print(-1)
else:
i,j=0,0
print(len(ab)//2+len(ab)%2+len(ba)//2+len(ba)%2)
while i<len(ab)-1:
print(ab[i],ab[i+1])
i+=2
while j<len(ba)-1:
print(ba[j], ba[j + 1])
j += 2
if i<len(ab):
print(ab[i],ab[i])
print(ab[i],ba[j])
``` | instruction | 0 | 31,060 | 0 | 62,120 |
Yes | output | 1 | 31,060 | 0 | 62,121 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has got two strings s and t having equal length. Both strings consist of lowercase Latin letters "a" and "b".
Monocarp wants to make these two strings s and t equal to each other. He can do the following operation any number of times: choose an index pos_1 in the string s, choose an index pos_2 in the string t, and swap s_{pos_1} with t_{pos_2}.
You have to determine the minimum number of operations Monocarp has to perform to make s and t equal, and print any optimal sequence of operations — or say that it is impossible to make these strings equal.
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^{5}) — the length of s and t.
The second line contains one string s consisting of n characters "a" and "b".
The third line contains one string t consisting of n characters "a" and "b".
Output
If it is impossible to make these strings equal, print -1.
Otherwise, in the first line print k — the minimum number of operations required to make the strings equal. In each of the next k lines print two integers — the index in the string s and the index in the string t that should be used in the corresponding swap operation.
Examples
Input
4
abab
aabb
Output
2
3 3
3 2
Input
1
a
b
Output
-1
Input
8
babbaabb
abababaa
Output
3
2 6
1 3
7 8
Note
In the first example two operations are enough. For example, you can swap the third letter in s with the third letter in t. Then s = "abbb", t = "aaab". Then swap the third letter in s and the second letter in t. Then both s and t are equal to "abab".
In the second example it's impossible to make two strings equal.
Submitted Solution:
```
def pars(x):
ans=[]
for i in x:
if(i=='a'):
ans.append('1')
else:
ans.append('0')
return ans
def strxor(a,b):
send=bin(int(num1,2)^int(num2,2))[2::]
return '0'*(len(a)-len(send))+send
def pprint(l):
print(len(l))
for i in l:
print(i[0]+1, i[1]+1)
n=int(input())
num1=pars(input())
num2=pars(input())
ans=[]
sh0s=[]
sh1s=[]
sh0, sh1 = 0,0
for ind, i in enumerate(num1):
if(i=='1' and num2[ind]=='0'):
sh0+=1
sh0s.append(ind)
elif(i=='0' and num2[ind]=='1'):
sh1+=1
sh1s.append(ind)
for i in range(sh0//2):
num1[sh0s[len(sh0s)-1]], num2[sh0s[len(sh0s)-2]] = num2[sh0s[len(sh0s)-2]], num1[sh0s[len(sh0s)-1]]
ans.append((sh0s[len(sh0s)-1], sh0s[len(sh0s)-2]))
sh0s.pop()
sh0s.pop()
for i in range(sh1//2):
num1[sh1s[len(sh1s)-1]], num2[sh1s[len(sh1s)-2]] = num2[sh1s[len(sh1s)-2]], num1[sh1s[len(sh1s)-1]]
ans.append((sh1s[len(sh1s)-1], sh1s[len(sh1s)-2]))
sh1s.pop()
sh1s.pop()
sh1,sh0=sh1%2, sh0%2
if(sh1==sh0 and sh0==0):
pprint(ans)
if(sh1!=sh0):
print(-1)
if(sh1==sh0 and sh1==1):
ans.append((sh1s[0], sh1s[0]))
num1[sh1s[0]], num2[sh1s[0]] = num2[sh1s[0]], num1[sh1s[0]]
ans.append((sh1s[0], sh0s[0]))
num1[sh1s[0]], num2[sh0s[0]] = num2[sh1s[0]], num1[sh0s[0]]
pprint(ans)
``` | instruction | 0 | 31,061 | 0 | 62,122 |
Yes | output | 1 | 31,061 | 0 | 62,123 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has got two strings s and t having equal length. Both strings consist of lowercase Latin letters "a" and "b".
Monocarp wants to make these two strings s and t equal to each other. He can do the following operation any number of times: choose an index pos_1 in the string s, choose an index pos_2 in the string t, and swap s_{pos_1} with t_{pos_2}.
You have to determine the minimum number of operations Monocarp has to perform to make s and t equal, and print any optimal sequence of operations — or say that it is impossible to make these strings equal.
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^{5}) — the length of s and t.
The second line contains one string s consisting of n characters "a" and "b".
The third line contains one string t consisting of n characters "a" and "b".
Output
If it is impossible to make these strings equal, print -1.
Otherwise, in the first line print k — the minimum number of operations required to make the strings equal. In each of the next k lines print two integers — the index in the string s and the index in the string t that should be used in the corresponding swap operation.
Examples
Input
4
abab
aabb
Output
2
3 3
3 2
Input
1
a
b
Output
-1
Input
8
babbaabb
abababaa
Output
3
2 6
1 3
7 8
Note
In the first example two operations are enough. For example, you can swap the third letter in s with the third letter in t. Then s = "abbb", t = "aaab". Then swap the third letter in s and the second letter in t. Then both s and t are equal to "abab".
In the second example it's impossible to make two strings equal.
Submitted Solution:
```
n=int(input())
a=list(input())
b=list(input())
aa=0
bb=0
c=[]
d=[]
for i in range(n):
if a[i]!=b[i]:
if a[i]=='a':
aa+=1
c.append(i+1)
else:
bb+=1
d.append(i+1)
if aa%2!=bb%2:
print(-1)
else:
if aa%2==0:
print(aa//2+bb//2)
i=0
while i<len(c)-1:
print(c[i],c[i+1])
i+=2
i=0
while i<len(d)-1:
print(d[i],d[i+1])
i+=2
else:
i=0
print(aa//2+(bb//2)+2)
while i<len(c)-2:
print(c[i],c[i+1])
i+=2
i=0
while i<len(d)-2:
print(d[i],d[i+1])
i+=2
print(c[-1],c[-1])
print(c[-1],d[-1])
``` | instruction | 0 | 31,062 | 0 | 62,124 |
Yes | output | 1 | 31,062 | 0 | 62,125 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has got two strings s and t having equal length. Both strings consist of lowercase Latin letters "a" and "b".
Monocarp wants to make these two strings s and t equal to each other. He can do the following operation any number of times: choose an index pos_1 in the string s, choose an index pos_2 in the string t, and swap s_{pos_1} with t_{pos_2}.
You have to determine the minimum number of operations Monocarp has to perform to make s and t equal, and print any optimal sequence of operations — or say that it is impossible to make these strings equal.
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^{5}) — the length of s and t.
The second line contains one string s consisting of n characters "a" and "b".
The third line contains one string t consisting of n characters "a" and "b".
Output
If it is impossible to make these strings equal, print -1.
Otherwise, in the first line print k — the minimum number of operations required to make the strings equal. In each of the next k lines print two integers — the index in the string s and the index in the string t that should be used in the corresponding swap operation.
Examples
Input
4
abab
aabb
Output
2
3 3
3 2
Input
1
a
b
Output
-1
Input
8
babbaabb
abababaa
Output
3
2 6
1 3
7 8
Note
In the first example two operations are enough. For example, you can swap the third letter in s with the third letter in t. Then s = "abbb", t = "aaab". Then swap the third letter in s and the second letter in t. Then both s and t are equal to "abab".
In the second example it's impossible to make two strings equal.
Submitted Solution:
```
###### ### ####### ####### ## # ##### ### #####
# # # # # # # # # # # # # ###
# # # # # # # # # # # # # ###
###### ######### # # # # # # ######### #
###### ######### # # # # # # ######### #
# # # # # # # # # # #### # # #
# # # # # # # ## # # # # #
###### # # ####### ####### # # ##### # # # #
from __future__ import print_function # for PyPy2
from collections import Counter, OrderedDict
from itertools import permutations as perm
from fractions import Fraction
from collections import deque
from sys import stdin
from bisect import *
from heapq import *
import math
g = lambda : stdin.readline().strip()
gl = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
mod = int(1e9)+7
inf = float("inf")
n, = gil()
a, b = gcl(), gcl()
# if a.count("a") != b.count("a"):
# print("NO")
# exit()
ab, ba = [], []
for i in range(n):
if a[i] == b[i]:
continue
elif a[i] == "a" and b[i] == "b":
ab.append(i+1)
else:
ba.append(i+1)
# print(ab)
# print(ba)
# exit()
if ~(len(ab)+len(ba))&1:
ans = len(ab)//2 + len(ba)//2 + (len(ab)&1) + (len(ba)&1)
print(ans)
while len(ab) >= 2:
print(ab.pop(), ab.pop())
while len(ba) >= 2:
print(ba.pop(), ba.pop())
if ab:
print(ab.pop(), ba.pop())
else:
print("NO")
``` | instruction | 0 | 31,063 | 0 | 62,126 |
No | output | 1 | 31,063 | 0 | 62,127 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has got two strings s and t having equal length. Both strings consist of lowercase Latin letters "a" and "b".
Monocarp wants to make these two strings s and t equal to each other. He can do the following operation any number of times: choose an index pos_1 in the string s, choose an index pos_2 in the string t, and swap s_{pos_1} with t_{pos_2}.
You have to determine the minimum number of operations Monocarp has to perform to make s and t equal, and print any optimal sequence of operations — or say that it is impossible to make these strings equal.
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^{5}) — the length of s and t.
The second line contains one string s consisting of n characters "a" and "b".
The third line contains one string t consisting of n characters "a" and "b".
Output
If it is impossible to make these strings equal, print -1.
Otherwise, in the first line print k — the minimum number of operations required to make the strings equal. In each of the next k lines print two integers — the index in the string s and the index in the string t that should be used in the corresponding swap operation.
Examples
Input
4
abab
aabb
Output
2
3 3
3 2
Input
1
a
b
Output
-1
Input
8
babbaabb
abababaa
Output
3
2 6
1 3
7 8
Note
In the first example two operations are enough. For example, you can swap the third letter in s with the third letter in t. Then s = "abbb", t = "aaab". Then swap the third letter in s and the second letter in t. Then both s and t are equal to "abab".
In the second example it's impossible to make two strings equal.
Submitted Solution:
```
import sys
input = sys.stdin.readline
def getInt(): return int(input())
def getVars(): return map(int, input().split())
def getList(): return list(map(int, input().split()))
def getStr(): return input().strip()
## -----------------------------------------
n = getInt()
s1 = getStr()
s2 = getStr()
d1 = []
d2 = []
for i in range(n):
if s1[i] != s2[i]:
if s1[i] == 'a':
d1.append(i+1)
else:
d2.append(i+1)
if (len(d1)+ len(d2)) % 2 > 0:
print(-1)
else:
if len(d1) < len(d2):
d1, d2 = d2, d1
res = (len(d1)+len(d2))//2
print(res)
for i in range(1, len(d1), 2):
print(d1[i-1], d1[i])
for i in range(1, len(d2), 2):
print(d2[i-1], d2[i])
if len(d1)%2 == 1:
print(d2[-1], d2[-1])
print(d2[-1], d1[-1])
``` | instruction | 0 | 31,064 | 0 | 62,128 |
No | output | 1 | 31,064 | 0 | 62,129 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has got two strings s and t having equal length. Both strings consist of lowercase Latin letters "a" and "b".
Monocarp wants to make these two strings s and t equal to each other. He can do the following operation any number of times: choose an index pos_1 in the string s, choose an index pos_2 in the string t, and swap s_{pos_1} with t_{pos_2}.
You have to determine the minimum number of operations Monocarp has to perform to make s and t equal, and print any optimal sequence of operations — or say that it is impossible to make these strings equal.
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^{5}) — the length of s and t.
The second line contains one string s consisting of n characters "a" and "b".
The third line contains one string t consisting of n characters "a" and "b".
Output
If it is impossible to make these strings equal, print -1.
Otherwise, in the first line print k — the minimum number of operations required to make the strings equal. In each of the next k lines print two integers — the index in the string s and the index in the string t that should be used in the corresponding swap operation.
Examples
Input
4
abab
aabb
Output
2
3 3
3 2
Input
1
a
b
Output
-1
Input
8
babbaabb
abababaa
Output
3
2 6
1 3
7 8
Note
In the first example two operations are enough. For example, you can swap the third letter in s with the third letter in t. Then s = "abbb", t = "aaab". Then swap the third letter in s and the second letter in t. Then both s and t are equal to "abab".
In the second example it's impossible to make two strings equal.
Submitted Solution:
```
def answer(n,A,B):
count=0
d={}
for i in range(n):
if A[i]=="a":
count+=1
if B[i]=="a":
count+=1
if (A[i],B[i]) in d:
d[(A[i],B[i])].append(i+1)
else:
d[(A[i],B[i])]=[i+1]
if count%2!=0:
return -1
ans=[]
k1=-1
k2=-1
if ("a","b") in d:
v=d[("a","b")]
for i in range(0,len(v)-len(v)%2,2):
ans.append([v[i],v[i+1]])
if len(v)%2!=0:
k1=v[-1]
if ("b","a") in d:
v=d[("b","a")]
for i in range(0,len(v)-len(v)%2,2):
ans.append([v[i],v[i+1]])
if len(v)%2!=0:
k2=v[-1]
if k1!=-1 and k2!=-1:
if ("a","a") in d:
p=d[("a","a")][0]
ans.append([p,k1])
ans.append([k2,p])
return ans
elif ("b","b") in d:
p=d[("b","b")][0]
ans.append([k1,p])
ans.append([p,k2])
return ans
else:
return -1
return ans
n=int(input())
s=input()
t=input()
y=answer(n,s,t)
if y==-1:
print(-1)
else:
print(len(y))
for i in range(len(y)):
print(*y[i])
``` | instruction | 0 | 31,065 | 0 | 62,130 |
No | output | 1 | 31,065 | 0 | 62,131 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has got two strings s and t having equal length. Both strings consist of lowercase Latin letters "a" and "b".
Monocarp wants to make these two strings s and t equal to each other. He can do the following operation any number of times: choose an index pos_1 in the string s, choose an index pos_2 in the string t, and swap s_{pos_1} with t_{pos_2}.
You have to determine the minimum number of operations Monocarp has to perform to make s and t equal, and print any optimal sequence of operations — or say that it is impossible to make these strings equal.
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^{5}) — the length of s and t.
The second line contains one string s consisting of n characters "a" and "b".
The third line contains one string t consisting of n characters "a" and "b".
Output
If it is impossible to make these strings equal, print -1.
Otherwise, in the first line print k — the minimum number of operations required to make the strings equal. In each of the next k lines print two integers — the index in the string s and the index in the string t that should be used in the corresponding swap operation.
Examples
Input
4
abab
aabb
Output
2
3 3
3 2
Input
1
a
b
Output
-1
Input
8
babbaabb
abababaa
Output
3
2 6
1 3
7 8
Note
In the first example two operations are enough. For example, you can swap the third letter in s with the third letter in t. Then s = "abbb", t = "aaab". Then swap the third letter in s and the second letter in t. Then both s and t are equal to "abab".
In the second example it's impossible to make two strings equal.
Submitted Solution:
```
n = int(input())
a = input()
b = input()
ab_pa = []
ba_pa = []
for i in range(n):
if a[i]=='a' and b[i]=='b':
ab_pa.append(i)
elif a[i]=='b' and b[i]=='a':
ba_pa.append(i)
ans = list()
for i in range(0,len(ba_pa),2):
if i+1<len(ba_pa):
ans.append([ba_pa[i]+1,ba_pa[i+1]+1])
for i in range(0,len(ab_pa),2):
if i+1<(len(ab_pa)):
ans.append([ab_pa[i]+1,ab_pa[i+1]+1])
p = len(ab_pa)%2
q = len(ba_pa)%2
if p==q:
if p==q==1:
ans.append([ab_pa[-1]+1,ba_pa[-1]+1])
ans.append([ab_pa[-1]+1,ab_pa[-1]+1])
print(len(ans))
for i in range(len(ans)):
print(*ans[i])
else:
print(-1)
``` | instruction | 0 | 31,066 | 0 | 62,132 |
No | output | 1 | 31,066 | 0 | 62,133 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a password which you often type — a string s of length n. Every character of this string is one of the first m lowercase Latin letters.
Since you spend a lot of time typing it, you want to buy a new keyboard.
A keyboard is a permutation of the first m Latin letters. For example, if m = 3, then there are six possible keyboards: abc, acb, bac, bca, cab and cba.
Since you type your password with one finger, you need to spend time moving your finger from one password character to the next. The time to move from character s_i to character s_{i+1} is equal to the distance between these characters on keyboard. The total time you have to spend typing the password with a keyboard is called the slowness of this keyboard.
More formaly, the slowness of keyboard is equal to ∑_{i=2}^{n} |pos_{s_{i-1}} - pos_{s_i} |, where pos_x is position of letter x in keyboard.
For example, if s is aacabc and the keyboard is bac, then the total time of typing this password is |pos_a - pos_a| + |pos_a - pos_c| + |pos_c - pos_a| + |pos_a - pos_b| + |pos_b - pos_c| = |2 - 2| + |2 - 3| + |3 - 2| + |2 - 1| + |1 - 3| = 0 + 1 + 1 + 1 + 2 = 5.
Before buying a new keyboard you want to know the minimum possible slowness that the keyboard can have.
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 20).
The second line contains the string s consisting of n characters. Each character is one of the first m Latin letters (lowercase).
Output
Print one integer – the minimum slowness a keyboard can have.
Examples
Input
6 3
aacabc
Output
5
Input
6 4
aaaaaa
Output
0
Input
15 4
abacabadabacaba
Output
16
Note
The first test case is considered in the statement.
In the second test case the slowness of any keyboard is 0.
In the third test case one of the most suitable keyboards is bacd. | instruction | 0 | 31,067 | 0 | 62,134 |
Tags: bitmasks, dp
Correct Solution:
```
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
INF = 10**9
n, m = [int(item) for item in input().split()]
s = input().rstrip()
count = [[0] * m for _ in range(m)]
ord_a = ord("a")
for c1, c2 in zip(s, s[1:]):
c1 = ord(c1) - ord_a
c2 = ord(c2) - ord_a
if c1 != c2:
count[c1][c2] += 1
sum_of_subset = [[0] * (1 << m) for _ in range(m)]
for i in range(m):
for j in range(1 << m):
if j == 0:
continue
lsb = j & -j
sum_of_subset[i][j] = sum_of_subset[i][j ^ lsb] + count[i][lsb.bit_length() - 1]
adj_in_subset = [0] * (1 << m)
for i in range(1 << m):
for j in range(m):
if i & (1 << j):
adj_in_subset[i] += sum_of_subset[j][i]
total_adj = adj_in_subset[-1]
dp = [INF] * (1 << m)
dp[0] = 0
for i in range(1 << m):
for j in range(m):
if i & 1 << j:
continue
not_i = ((1 << m) - 1) ^ i
val = dp[i] + (total_adj - adj_in_subset[i] - adj_in_subset[not_i])
dp[i | (1 << j)] = min(dp[i | (1 << j)], val)
print(dp[-1])
``` | output | 1 | 31,067 | 0 | 62,135 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a password which you often type — a string s of length n. Every character of this string is one of the first m lowercase Latin letters.
Since you spend a lot of time typing it, you want to buy a new keyboard.
A keyboard is a permutation of the first m Latin letters. For example, if m = 3, then there are six possible keyboards: abc, acb, bac, bca, cab and cba.
Since you type your password with one finger, you need to spend time moving your finger from one password character to the next. The time to move from character s_i to character s_{i+1} is equal to the distance between these characters on keyboard. The total time you have to spend typing the password with a keyboard is called the slowness of this keyboard.
More formaly, the slowness of keyboard is equal to ∑_{i=2}^{n} |pos_{s_{i-1}} - pos_{s_i} |, where pos_x is position of letter x in keyboard.
For example, if s is aacabc and the keyboard is bac, then the total time of typing this password is |pos_a - pos_a| + |pos_a - pos_c| + |pos_c - pos_a| + |pos_a - pos_b| + |pos_b - pos_c| = |2 - 2| + |2 - 3| + |3 - 2| + |2 - 1| + |1 - 3| = 0 + 1 + 1 + 1 + 2 = 5.
Before buying a new keyboard you want to know the minimum possible slowness that the keyboard can have.
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 20).
The second line contains the string s consisting of n characters. Each character is one of the first m Latin letters (lowercase).
Output
Print one integer – the minimum slowness a keyboard can have.
Examples
Input
6 3
aacabc
Output
5
Input
6 4
aaaaaa
Output
0
Input
15 4
abacabadabacaba
Output
16
Note
The first test case is considered in the statement.
In the second test case the slowness of any keyboard is 0.
In the third test case one of the most suitable keyboards is bacd. | instruction | 0 | 31,068 | 0 | 62,136 |
Tags: bitmasks, dp
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
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")
# ------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
from math import factorial
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush
# ------------------------------
def cord(c):
return ord(c)-ord('a')
def main():
n, m = RL()
s = input()
ct = [0]*(1<<m)
for i in range(n-1):
now, nex = cord(s[i]), cord(s[i+1])
if now==nex: continue
ct[1<<now | 1<<nex]+=1
for i in range(m):
for j in range(1<<m):
if (1<<i) & j:
ct[j]+=ct[(1<<i) ^ j]
dp = [INF]*(1<<m)
dp[0] = 0
for i in range(1<<m):
# pos = bin(i).count('1')
for j in range(m):
# sm = 0
# if i>>j & 1 == 0:
# for k in range(m):
# if 1<<k & i==0:
# sm-=ct[j][k]*pos
# else:
# sm+=ct[j][k]*pos
if i & 1<<j == 0:
sm = ct[-1]-ct[i]-ct[~i]
dp[i|(1<<j)] = min(dp[i|(1<<j)], dp[i] + sm)
# print(ct)
print(dp[-1])
if __name__ == "__main__":
main()
``` | output | 1 | 31,068 | 0 | 62,137 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a password which you often type — a string s of length n. Every character of this string is one of the first m lowercase Latin letters.
Since you spend a lot of time typing it, you want to buy a new keyboard.
A keyboard is a permutation of the first m Latin letters. For example, if m = 3, then there are six possible keyboards: abc, acb, bac, bca, cab and cba.
Since you type your password with one finger, you need to spend time moving your finger from one password character to the next. The time to move from character s_i to character s_{i+1} is equal to the distance between these characters on keyboard. The total time you have to spend typing the password with a keyboard is called the slowness of this keyboard.
More formaly, the slowness of keyboard is equal to ∑_{i=2}^{n} |pos_{s_{i-1}} - pos_{s_i} |, where pos_x is position of letter x in keyboard.
For example, if s is aacabc and the keyboard is bac, then the total time of typing this password is |pos_a - pos_a| + |pos_a - pos_c| + |pos_c - pos_a| + |pos_a - pos_b| + |pos_b - pos_c| = |2 - 2| + |2 - 3| + |3 - 2| + |2 - 1| + |1 - 3| = 0 + 1 + 1 + 1 + 2 = 5.
Before buying a new keyboard you want to know the minimum possible slowness that the keyboard can have.
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 20).
The second line contains the string s consisting of n characters. Each character is one of the first m Latin letters (lowercase).
Output
Print one integer – the minimum slowness a keyboard can have.
Examples
Input
6 3
aacabc
Output
5
Input
6 4
aaaaaa
Output
0
Input
15 4
abacabadabacaba
Output
16
Note
The first test case is considered in the statement.
In the second test case the slowness of any keyboard is 0.
In the third test case one of the most suitable keyboards is bacd. | instruction | 0 | 31,069 | 0 | 62,138 |
Tags: bitmasks, dp
Correct Solution:
```
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
INF = 10**9
n, m = [int(item) for item in input().split()]
s = input().rstrip()
count = [[0] * m for _ in range(m)]
ord_a = ord("a")
for c1, c2 in zip(s, s[1:]):
c1 = ord(c1) - ord_a
c2 = ord(c2) - ord_a
if c1 != c2:
count[c1][c2] += 1
sum_of_subset = [[0] * (1 << m) for _ in range(m)]
for i in range(m):
for j in range(1 << m):
if j == 0:
continue
lsb = j & -j
sum_of_subset[i][j] = sum_of_subset[i][j ^ lsb] + count[i][lsb.bit_length() - 1]
adj_in_subset = [0] * (1 << m)
for i in range(1 << m):
for j in range(m):
if i & (1 << j):
adj_in_subset[i] += sum_of_subset[j][i]
total_adj = adj_in_subset[-1]
dp = [INF] * (1 << m)
dp[0] = 0
for i in range(1 << m):
for j in range(m):
if i & 1 << j:
continue
cost = total_adj - adj_in_subset[i] - adj_in_subset[~i]
dp[i | (1 << j)] = min(dp[i | (1 << j)], dp[i] + cost)
print(dp[-1])
``` | output | 1 | 31,069 | 0 | 62,139 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a password which you often type — a string s of length n. Every character of this string is one of the first m lowercase Latin letters.
Since you spend a lot of time typing it, you want to buy a new keyboard.
A keyboard is a permutation of the first m Latin letters. For example, if m = 3, then there are six possible keyboards: abc, acb, bac, bca, cab and cba.
Since you type your password with one finger, you need to spend time moving your finger from one password character to the next. The time to move from character s_i to character s_{i+1} is equal to the distance between these characters on keyboard. The total time you have to spend typing the password with a keyboard is called the slowness of this keyboard.
More formaly, the slowness of keyboard is equal to ∑_{i=2}^{n} |pos_{s_{i-1}} - pos_{s_i} |, where pos_x is position of letter x in keyboard.
For example, if s is aacabc and the keyboard is bac, then the total time of typing this password is |pos_a - pos_a| + |pos_a - pos_c| + |pos_c - pos_a| + |pos_a - pos_b| + |pos_b - pos_c| = |2 - 2| + |2 - 3| + |3 - 2| + |2 - 1| + |1 - 3| = 0 + 1 + 1 + 1 + 2 = 5.
Before buying a new keyboard you want to know the minimum possible slowness that the keyboard can have.
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 20).
The second line contains the string s consisting of n characters. Each character is one of the first m Latin letters (lowercase).
Output
Print one integer – the minimum slowness a keyboard can have.
Examples
Input
6 3
aacabc
Output
5
Input
6 4
aaaaaa
Output
0
Input
15 4
abacabadabacaba
Output
16
Note
The first test case is considered in the statement.
In the second test case the slowness of any keyboard is 0.
In the third test case one of the most suitable keyboards is bacd. | instruction | 0 | 31,070 | 0 | 62,140 |
Tags: bitmasks, dp
Correct Solution:
```
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
INF = 10**9
n, m = [int(item) for item in input().split()]
s = input().rstrip()
# Calculate adjacent count in subset
adj_in_subset = [0] * (1 << m)
ord_a = ord("a")
for c1, c2 in zip(s, s[1:]):
c1 = ord(c1) - ord_a
c2 = ord(c2) - ord_a
if c1 != c2:
adj_in_subset[(1 << c1) + (1 << c2)] += 1
for i in range(m):
for j in range(1 << m):
if j & (1 << i):
adj_in_subset[j] += adj_in_subset[j ^ (1 << i)]
total_adj = adj_in_subset[-1]
dp = [INF] * (1 << m)
dp[0] = 0
for i in range(1 << m):
for j in range(m):
if i & 1 << j:
continue
cost = total_adj - adj_in_subset[i] - adj_in_subset[~i]
dp[i | (1 << j)] = min(dp[i | (1 << j)], dp[i] + cost)
print(dp[-1])
``` | output | 1 | 31,070 | 0 | 62,141 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a password which you often type — a string s of length n. Every character of this string is one of the first m lowercase Latin letters.
Since you spend a lot of time typing it, you want to buy a new keyboard.
A keyboard is a permutation of the first m Latin letters. For example, if m = 3, then there are six possible keyboards: abc, acb, bac, bca, cab and cba.
Since you type your password with one finger, you need to spend time moving your finger from one password character to the next. The time to move from character s_i to character s_{i+1} is equal to the distance between these characters on keyboard. The total time you have to spend typing the password with a keyboard is called the slowness of this keyboard.
More formaly, the slowness of keyboard is equal to ∑_{i=2}^{n} |pos_{s_{i-1}} - pos_{s_i} |, where pos_x is position of letter x in keyboard.
For example, if s is aacabc and the keyboard is bac, then the total time of typing this password is |pos_a - pos_a| + |pos_a - pos_c| + |pos_c - pos_a| + |pos_a - pos_b| + |pos_b - pos_c| = |2 - 2| + |2 - 3| + |3 - 2| + |2 - 1| + |1 - 3| = 0 + 1 + 1 + 1 + 2 = 5.
Before buying a new keyboard you want to know the minimum possible slowness that the keyboard can have.
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 20).
The second line contains the string s consisting of n characters. Each character is one of the first m Latin letters (lowercase).
Output
Print one integer – the minimum slowness a keyboard can have.
Examples
Input
6 3
aacabc
Output
5
Input
6 4
aaaaaa
Output
0
Input
15 4
abacabadabacaba
Output
16
Note
The first test case is considered in the statement.
In the second test case the slowness of any keyboard is 0.
In the third test case one of the most suitable keyboards is bacd. | instruction | 0 | 31,071 | 0 | 62,142 |
Tags: bitmasks, dp
Correct Solution:
```
n, m = map(int, input().split())
a = list(map(str, input().strip()))
dp = [10 ** 10] * (1 << 20)
cnt = [0] * (1 << 20)
def get(x):
return 1 << (ord(x) - ord('a'))
for i, v in enumerate(a):
if i:
cnt[get(a[i]) | get(a[i - 1])] += 1
for i in range(m):
for j in range(1 << m):
if (1 << i) & j:
cnt[j] += cnt[j ^ (1 << i)]
# print(bin(j), bin(j ^ 1 << i), cnt[j])
# for i in range(1 << m):
# for j in range(m):
# if not i & (1 << j):
# cnt[i | (1 << j)] += cnt[i]
# print(bin(i | (1 << j)), bin(i), cnt[i | 1 << j])
dp[0] = 0
for i in range(1 << m):
for j in range(m):
if not i & (1 << j):
dp[i | (1 << j)] = min(dp[i | (1 << j)],
dp[i] + n - 1 - cnt[i | (1 << j)] - cnt[(1 << m) - 1 - (i | (1 << j))])
print(dp[(1 << m) - 1])
``` | output | 1 | 31,071 | 0 | 62,143 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a password which you often type — a string s of length n. Every character of this string is one of the first m lowercase Latin letters.
Since you spend a lot of time typing it, you want to buy a new keyboard.
A keyboard is a permutation of the first m Latin letters. For example, if m = 3, then there are six possible keyboards: abc, acb, bac, bca, cab and cba.
Since you type your password with one finger, you need to spend time moving your finger from one password character to the next. The time to move from character s_i to character s_{i+1} is equal to the distance between these characters on keyboard. The total time you have to spend typing the password with a keyboard is called the slowness of this keyboard.
More formaly, the slowness of keyboard is equal to ∑_{i=2}^{n} |pos_{s_{i-1}} - pos_{s_i} |, where pos_x is position of letter x in keyboard.
For example, if s is aacabc and the keyboard is bac, then the total time of typing this password is |pos_a - pos_a| + |pos_a - pos_c| + |pos_c - pos_a| + |pos_a - pos_b| + |pos_b - pos_c| = |2 - 2| + |2 - 3| + |3 - 2| + |2 - 1| + |1 - 3| = 0 + 1 + 1 + 1 + 2 = 5.
Before buying a new keyboard you want to know the minimum possible slowness that the keyboard can have.
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 20).
The second line contains the string s consisting of n characters. Each character is one of the first m Latin letters (lowercase).
Output
Print one integer – the minimum slowness a keyboard can have.
Examples
Input
6 3
aacabc
Output
5
Input
6 4
aaaaaa
Output
0
Input
15 4
abacabadabacaba
Output
16
Note
The first test case is considered in the statement.
In the second test case the slowness of any keyboard is 0.
In the third test case one of the most suitable keyboards is bacd.
Submitted Solution:
```
#!python3
"""
"""
from collections import deque, Counter
import array
from itertools import combinations, permutations
from math import sqrt
import unittest
def read_int():
return int(input().strip())
def read_int_array():
return [int(i) for i in input().strip().split(' ')]
######################################################
n, m = read_int_array()
s = input().strip()
ctopos = {}
ctopos[s[0]] = 0
moves = 0
pos = 0
for i in range(1, n):
c = s[i]
if c not in ctopos:
if pos < len(ctopos) // 2:
for e in ctopos:
ctopos[e] += 1
ctopos[c] = 0
pos += 1
else:
ctopos[c] = len(ctopos)
moves += abs(ctopos[c] - pos)
pos = ctopos[c]
# print(moves, pos)
print(moves)
"""
counter = Counter(s)
res = deque()
side = True
for c, cnum in counter.most_common():
if not res:
res.append((c, cnum))
elif side:
res.appendleft((c, cnum))
else:
res.append((c, cnum))
side = not side
assert len(res) <= m
res = list(res)
# print(res)
ctopos = {}
pos = 0
for i, e in enumerate(res):
c, cnum = e
ctopos[c] = i
if c == s[0]:
pos = i
moves = 0
for k in range(1, n):
nextpos = ctopos[s[k]]
moves += abs(nextpos - pos)
pos = nextpos
print(moves)
"""
``` | instruction | 0 | 31,072 | 0 | 62,144 |
No | output | 1 | 31,072 | 0 | 62,145 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a password which you often type — a string s of length n. Every character of this string is one of the first m lowercase Latin letters.
Since you spend a lot of time typing it, you want to buy a new keyboard.
A keyboard is a permutation of the first m Latin letters. For example, if m = 3, then there are six possible keyboards: abc, acb, bac, bca, cab and cba.
Since you type your password with one finger, you need to spend time moving your finger from one password character to the next. The time to move from character s_i to character s_{i+1} is equal to the distance between these characters on keyboard. The total time you have to spend typing the password with a keyboard is called the slowness of this keyboard.
More formaly, the slowness of keyboard is equal to ∑_{i=2}^{n} |pos_{s_{i-1}} - pos_{s_i} |, where pos_x is position of letter x in keyboard.
For example, if s is aacabc and the keyboard is bac, then the total time of typing this password is |pos_a - pos_a| + |pos_a - pos_c| + |pos_c - pos_a| + |pos_a - pos_b| + |pos_b - pos_c| = |2 - 2| + |2 - 3| + |3 - 2| + |2 - 1| + |1 - 3| = 0 + 1 + 1 + 1 + 2 = 5.
Before buying a new keyboard you want to know the minimum possible slowness that the keyboard can have.
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 20).
The second line contains the string s consisting of n characters. Each character is one of the first m Latin letters (lowercase).
Output
Print one integer – the minimum slowness a keyboard can have.
Examples
Input
6 3
aacabc
Output
5
Input
6 4
aaaaaa
Output
0
Input
15 4
abacabadabacaba
Output
16
Note
The first test case is considered in the statement.
In the second test case the slowness of any keyboard is 0.
In the third test case one of the most suitable keyboards is bacd.
Submitted Solution:
```
def reverse(s):
str = ""
for i in s:
str = i + str
return str
def swap(s:str):
n=len(s)
temp=""
temp+=s[1:n//2]
temp+=s[0]
temp+=s[n//2:]
return temp
x,y=input().split()
x,y=int(x),int(y)
s=input()
aplabet=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','y','v','w','x','y','z']
l={s: 0 for s in aplabet}
for i in s:
l[i]+=1
while(len(l)> y):
l.popitem()
sorted_l = sorted(l.items(), key=lambda kv: kv[1])
l_={i[0]: i[1] for i in sorted_l}
key=''.join('{}'.format(key) for key, value in l_.items())
key=reverse(key)
key=swap(key)
res=0
for i in range(1,x):
res+=abs(key.index(s[i])-key.index(s[i-1]))
print(res)
``` | instruction | 0 | 31,073 | 0 | 62,146 |
No | output | 1 | 31,073 | 0 | 62,147 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a password which you often type — a string s of length n. Every character of this string is one of the first m lowercase Latin letters.
Since you spend a lot of time typing it, you want to buy a new keyboard.
A keyboard is a permutation of the first m Latin letters. For example, if m = 3, then there are six possible keyboards: abc, acb, bac, bca, cab and cba.
Since you type your password with one finger, you need to spend time moving your finger from one password character to the next. The time to move from character s_i to character s_{i+1} is equal to the distance between these characters on keyboard. The total time you have to spend typing the password with a keyboard is called the slowness of this keyboard.
More formaly, the slowness of keyboard is equal to ∑_{i=2}^{n} |pos_{s_{i-1}} - pos_{s_i} |, where pos_x is position of letter x in keyboard.
For example, if s is aacabc and the keyboard is bac, then the total time of typing this password is |pos_a - pos_a| + |pos_a - pos_c| + |pos_c - pos_a| + |pos_a - pos_b| + |pos_b - pos_c| = |2 - 2| + |2 - 3| + |3 - 2| + |2 - 1| + |1 - 3| = 0 + 1 + 1 + 1 + 2 = 5.
Before buying a new keyboard you want to know the minimum possible slowness that the keyboard can have.
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 20).
The second line contains the string s consisting of n characters. Each character is one of the first m Latin letters (lowercase).
Output
Print one integer – the minimum slowness a keyboard can have.
Examples
Input
6 3
aacabc
Output
5
Input
6 4
aaaaaa
Output
0
Input
15 4
abacabadabacaba
Output
16
Note
The first test case is considered in the statement.
In the second test case the slowness of any keyboard is 0.
In the third test case one of the most suitable keyboards is bacd.
Submitted Solution:
```
import random
n,m = map(int,input().split())
s = input()
table = [[0 for i in range(m)] for j in range(m)]
for i in range(1,n):
x,y = ord(s[i-1])-97,ord(s[i])-97
if x != y:
table[x][y] += 1
table[y][x] += 1
smls = [sum(table[i][j] for j in range(m)) for i in range(m)]
perm = list(range(m))
ans = 0
for _ in range(10):
random.shuffle(perm)
for i in range(m):
for j in range(1,m):
l,r = perm[j-1],perm[j]
ll = sum((table[l][perm[k]] for k in range(j-1)))
lr = smls[l]-ll-table[l][r]
rl = sum((table[r][perm[k]] for k in range(j-1)))
rr = smls[r]-rl-table[l][r]
if ll+rr < lr+rl:
perm[j-1],perm[j] = perm[j],perm[j-1]
anstmp = 0
for i in range(m-1):
for j in range(i+1,m):
anstmp += (j-i)*table[perm[i]][perm[j]]
ans = max(ans,anstmp)
print(ans)
``` | instruction | 0 | 31,074 | 0 | 62,148 |
No | output | 1 | 31,074 | 0 | 62,149 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a password which you often type — a string s of length n. Every character of this string is one of the first m lowercase Latin letters.
Since you spend a lot of time typing it, you want to buy a new keyboard.
A keyboard is a permutation of the first m Latin letters. For example, if m = 3, then there are six possible keyboards: abc, acb, bac, bca, cab and cba.
Since you type your password with one finger, you need to spend time moving your finger from one password character to the next. The time to move from character s_i to character s_{i+1} is equal to the distance between these characters on keyboard. The total time you have to spend typing the password with a keyboard is called the slowness of this keyboard.
More formaly, the slowness of keyboard is equal to ∑_{i=2}^{n} |pos_{s_{i-1}} - pos_{s_i} |, where pos_x is position of letter x in keyboard.
For example, if s is aacabc and the keyboard is bac, then the total time of typing this password is |pos_a - pos_a| + |pos_a - pos_c| + |pos_c - pos_a| + |pos_a - pos_b| + |pos_b - pos_c| = |2 - 2| + |2 - 3| + |3 - 2| + |2 - 1| + |1 - 3| = 0 + 1 + 1 + 1 + 2 = 5.
Before buying a new keyboard you want to know the minimum possible slowness that the keyboard can have.
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 20).
The second line contains the string s consisting of n characters. Each character is one of the first m Latin letters (lowercase).
Output
Print one integer – the minimum slowness a keyboard can have.
Examples
Input
6 3
aacabc
Output
5
Input
6 4
aaaaaa
Output
0
Input
15 4
abacabadabacaba
Output
16
Note
The first test case is considered in the statement.
In the second test case the slowness of any keyboard is 0.
In the third test case one of the most suitable keyboards is bacd.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
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")
# ------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
from math import factorial
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush
# ------------------------------
def cord(c):
return ord(c)-ord('a')
def main():
n, m = RL()
s = input()
inf = m*m
ct = [0]*(1<<m)
for i in range(n-1):
now, nex = cord(s[i]), cord(s[i+1])
if now==nex: continue
ct[1<<now | 1<<nex]+=1
for i in range(m):
for j in range(1<<m):
if 1<<i & j:
ct[j]+=ct[(1<<i) ^ j]
dp = [inf]*(1<<m)
dp[0] = 0
for i in range(1<<m):
# pos = bin(i).count('1')
for j in range(m):
# sm = 0
# if i>>j & 1 == 0:
# for k in range(m):
# if 1<<k & i==0:
# sm-=ct[j][k]*pos
# else:
# sm+=ct[j][k]*pos
if i & 1<<j == 0:
sm = ct[-1]-ct[i]-ct[~i]
dp[i|1<<j] = min(dp[i|1<<j], dp[i] + sm)
print(dp[-1])
if __name__ == "__main__":
main()
``` | instruction | 0 | 31,075 | 0 | 62,150 |
No | output | 1 | 31,075 | 0 | 62,151 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two strings s and t both of length n and both consisting of lowercase Latin letters.
In one move, you can choose any length len from 1 to n and perform the following operation:
* Choose any contiguous substring of the string s of length len and reverse it;
* at the same time choose any contiguous substring of the string t of length len and reverse it as well.
Note that during one move you reverse exactly one substring of the string s and exactly one substring of the string t.
Also note that borders of substrings you reverse in s and in t can be different, the only restriction is that you reverse the substrings of equal length. For example, if len=3 and n=5, you can reverse s[1 ... 3] and t[3 ... 5], s[2 ... 4] and t[2 ... 4], but not s[1 ... 3] and t[1 ... 2].
Your task is to say if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of s and t.
The second line of the test case contains one string s consisting of n lowercase Latin letters.
The third line of the test case contains one string t consisting of n lowercase Latin letters.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer on it — "YES" (without quotes) if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves and "NO" otherwise.
Example
Input
4
4
abcd
abdc
5
ababa
baaba
4
asdf
asdg
4
abcd
badc
Output
NO
YES
NO
YES | instruction | 0 | 31,076 | 0 | 62,152 |
Tags: constructive algorithms, sortings, strings
Correct Solution:
```
import sys
input = sys.stdin.readline
q=int(input())
from collections import Counter
for testcases in range(q):
n=int(input())
S=input().strip()
T=input().strip()
CS=Counter(S)
CT=Counter(T)
if CS!=CT:
print("NO")
continue
if max(CS.values())>=2:
print("YES")
continue
W=[0]*26
SA=0
for s in S:
SA+=sum(W[ord(s)-97:])
W[ord(s)-97]+=1
#print(SA)
W=[0]*26
TA=0
for s in T:
TA+=sum(W[ord(s)-97:])
W[ord(s)-97]+=1
#print(TA)
if (SA+TA)%2==0:
print("YES")
else:
print("NO")
``` | output | 1 | 31,076 | 0 | 62,153 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two strings s and t both of length n and both consisting of lowercase Latin letters.
In one move, you can choose any length len from 1 to n and perform the following operation:
* Choose any contiguous substring of the string s of length len and reverse it;
* at the same time choose any contiguous substring of the string t of length len and reverse it as well.
Note that during one move you reverse exactly one substring of the string s and exactly one substring of the string t.
Also note that borders of substrings you reverse in s and in t can be different, the only restriction is that you reverse the substrings of equal length. For example, if len=3 and n=5, you can reverse s[1 ... 3] and t[3 ... 5], s[2 ... 4] and t[2 ... 4], but not s[1 ... 3] and t[1 ... 2].
Your task is to say if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of s and t.
The second line of the test case contains one string s consisting of n lowercase Latin letters.
The third line of the test case contains one string t consisting of n lowercase Latin letters.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer on it — "YES" (without quotes) if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves and "NO" otherwise.
Example
Input
4
4
abcd
abdc
5
ababa
baaba
4
asdf
asdg
4
abcd
badc
Output
NO
YES
NO
YES | instruction | 0 | 31,077 | 0 | 62,154 |
Tags: constructive algorithms, sortings, strings
Correct Solution:
```
def inversionCount(s):
# function to count inversion count of the string;
freq = [0 for _ in range(26)] # for storing frequnecy
inv = 0
for i in range(len(s)):
# we'll add all the characters which are less than
# the ith character before i.
temp = 0
for j in range(ord(s[i]) - ord('a')):
temp += freq[j] # adding the count to inversion count
inv += (i - temp)
# updating the character in the frequency array
freq[ord(s[i]) - ord('a')] += 1
return inv
def haveRepeated(S1, S2):
# function to check whether any of the string
# have a repeated character
freq = [0 for _ in range(26)]
for i in range(len(S1)):
if freq[ord(S1[i]) - ord('a')] > 0:
return 1
freq[ord(S1[i]) - ord('a')] += 1
for i in range(26):
freq[i] = 0
for i in range(len(S2)):
if freq[ord(S2[i]) - ord('a')] > 0:
return 1
freq[ord(S2[i]) - ord('a')] += 1
return 0
def checkToMakeEqual(S1, S2):
# function to check whether the string S1 and S2
# can be made equal by reversing sub strings of
# same size in both strings
# frequency array to check whether both string have
# same character or not
freq = [0 for _ in range(26)]
for i in range(len(S1)):
# adding the frequency;
freq[ord(S1[i]) - ord('a')] += 1
flag = 0
for i in range(len(S2)):
if freq[ord(S2[i]) - ord('a')] == 0:
# if the character is not in S1
flag = 1
break
# decrementing the frequency
freq[ord(S2[i]) - ord('a')] -= 1
if flag == 1:
# If both string doesnot have same characters or not
print("No")
return
# finding inversion count of both strings
invCount1 = inversionCount(S1)
invCount2 = inversionCount(S2)
if (invCount1 == invCount2) or ((invCount1 % 2) == (invCount2 % 2)) or haveRepeated(S1, S2) == 1:
# If inversion count is same, or have same parity
# or if any of the string have a repeated character
# then the answer is Yes else No
print("Yes")
else:
print("No")
# driver code
T = int(input())
for _ in range(T):
n = int(input())
S1 = str(input())
S2 = str(input())
checkToMakeEqual(S1, S2)
``` | output | 1 | 31,077 | 0 | 62,155 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two strings s and t both of length n and both consisting of lowercase Latin letters.
In one move, you can choose any length len from 1 to n and perform the following operation:
* Choose any contiguous substring of the string s of length len and reverse it;
* at the same time choose any contiguous substring of the string t of length len and reverse it as well.
Note that during one move you reverse exactly one substring of the string s and exactly one substring of the string t.
Also note that borders of substrings you reverse in s and in t can be different, the only restriction is that you reverse the substrings of equal length. For example, if len=3 and n=5, you can reverse s[1 ... 3] and t[3 ... 5], s[2 ... 4] and t[2 ... 4], but not s[1 ... 3] and t[1 ... 2].
Your task is to say if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of s and t.
The second line of the test case contains one string s consisting of n lowercase Latin letters.
The third line of the test case contains one string t consisting of n lowercase Latin letters.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer on it — "YES" (without quotes) if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves and "NO" otherwise.
Example
Input
4
4
abcd
abdc
5
ababa
baaba
4
asdf
asdg
4
abcd
badc
Output
NO
YES
NO
YES | instruction | 0 | 31,078 | 0 | 62,156 |
Tags: constructive algorithms, sortings, strings
Correct Solution:
```
#!/usr/bin/env python -i
from collections import Counter, defaultdict
from string import ascii_lowercase
def can(e):
for k, v in e.items():
if {vi & 1 for vi in v} == {0, 1}:
return True
return False
def _parity(permutation):
length = len(permutation)
elements_seen = [False] * length
cycles = 0
for index, already_seen in enumerate(elements_seen):
if already_seen:
continue
cycles += 1
current = index
while not elements_seen[current]:
elements_seen[current] = True
current = permutation[current]
return (length-cycles) % 2 == 0
def parity(s):
i = 0
c = Counter(s)
e = defaultdict(list)
for k, v in sorted(c.items()):
for _ in range(v):
e[k].append(i)
i += 1
if can(e):
return {0, 1}
p = []
for ch in s:
p.append(e[ch].pop())
return {_parity(p)}
for _ in range(int(input())):
n = int(input())
s = input()
t = input()
if (Counter(s) == Counter(t)) and (parity(s) & parity(t)):
print("YES")
else:
print("NO")
``` | output | 1 | 31,078 | 0 | 62,157 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two strings s and t both of length n and both consisting of lowercase Latin letters.
In one move, you can choose any length len from 1 to n and perform the following operation:
* Choose any contiguous substring of the string s of length len and reverse it;
* at the same time choose any contiguous substring of the string t of length len and reverse it as well.
Note that during one move you reverse exactly one substring of the string s and exactly one substring of the string t.
Also note that borders of substrings you reverse in s and in t can be different, the only restriction is that you reverse the substrings of equal length. For example, if len=3 and n=5, you can reverse s[1 ... 3] and t[3 ... 5], s[2 ... 4] and t[2 ... 4], but not s[1 ... 3] and t[1 ... 2].
Your task is to say if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of s and t.
The second line of the test case contains one string s consisting of n lowercase Latin letters.
The third line of the test case contains one string t consisting of n lowercase Latin letters.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer on it — "YES" (without quotes) if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves and "NO" otherwise.
Example
Input
4
4
abcd
abdc
5
ababa
baaba
4
asdf
asdg
4
abcd
badc
Output
NO
YES
NO
YES | instruction | 0 | 31,079 | 0 | 62,158 |
Tags: constructive algorithms, sortings, strings
Correct Solution:
```
def f(s, t):
if sorted(s) != sorted(t):
return False # different chars
ss, st = set(s), set(t)
if len(s) > len(ss) or len(t) > len(st): # dup chars
return True
def rec(s, i, j):
if i == j:
return 0
if i + 1 == j:
if s[i] > s[j]:
s[i], s[j] = s[j], s[i]
return 1
else:
return 0
mid = (j - i) // 2
inv = 0
inv += rec(s, i, i + mid)
inv += rec(s, i + mid + 1, j)
out = []
a, b = i, i + mid + 1
while a <= i + mid or b <= j:
if a > i + mid:
out.append(s[b])
b += 1
elif b > j:
out.append(s[a])
a += 1
elif s[a] > s[b]:
out.append(s[b])
inv += (i + mid - a + 1)
b += 1
else:
out.append(s[a])
a += 1
assert len(out) == j - i + 1
for k in range(len(out)):
s[i + k] = out[k]
return inv
assert rec(list("24135"), 0, 4) == 3
assert rec(list("bacd"), 0, 3) == 1
assert rec(list("abdc"), 0, 3) == 1
assert rec(list("badc"), 0, 3) == 2
assert rec(list("acbd"), 0, 3) == 1
assert rec(list("abcdefgh"), 0, 7) == 0
assert rec(list("abcd"), 0, 3) == 0
assert rec(list("ba"), 0, 1) == 1
assert rec(list("AGFDE"), 0, 4) == 5
ps = rec(list(s), 0, len(s) - 1)
pt = rec(list(t), 0, len(t) - 1)
return ps % 2 == pt % 2
# ababa 5: 1, 4: 2, 3: 3, 2: 4
assert f("ababa", "baaba") is True
assert f("abcd", "abdc") is False
assert f("asdf", "asdg") is False
assert f("abcd", "badc") is True
q = int(input())
for _ in range(q):
l = int(input())
s = input()
t = input()
ans = f(s, t)
if ans:
print("YES")
else:
print("NO")
``` | output | 1 | 31,079 | 0 | 62,159 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two strings s and t both of length n and both consisting of lowercase Latin letters.
In one move, you can choose any length len from 1 to n and perform the following operation:
* Choose any contiguous substring of the string s of length len and reverse it;
* at the same time choose any contiguous substring of the string t of length len and reverse it as well.
Note that during one move you reverse exactly one substring of the string s and exactly one substring of the string t.
Also note that borders of substrings you reverse in s and in t can be different, the only restriction is that you reverse the substrings of equal length. For example, if len=3 and n=5, you can reverse s[1 ... 3] and t[3 ... 5], s[2 ... 4] and t[2 ... 4], but not s[1 ... 3] and t[1 ... 2].
Your task is to say if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of s and t.
The second line of the test case contains one string s consisting of n lowercase Latin letters.
The third line of the test case contains one string t consisting of n lowercase Latin letters.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer on it — "YES" (without quotes) if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves and "NO" otherwise.
Example
Input
4
4
abcd
abdc
5
ababa
baaba
4
asdf
asdg
4
abcd
badc
Output
NO
YES
NO
YES | instruction | 0 | 31,080 | 0 | 62,160 |
Tags: constructive algorithms, sortings, strings
Correct Solution:
```
from collections import *
f=lambda s:(Counter(s),len(set(s))==len(s)and sum(s[i]>s[j] for i in range(len(s))for j in range(i,len(s)))&1)
for _ in range(int(input())):
n,s,t=input(),input(),input()
print("YNEOS"[f(s)!=f(t)::2])
``` | output | 1 | 31,080 | 0 | 62,161 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two strings s and t both of length n and both consisting of lowercase Latin letters.
In one move, you can choose any length len from 1 to n and perform the following operation:
* Choose any contiguous substring of the string s of length len and reverse it;
* at the same time choose any contiguous substring of the string t of length len and reverse it as well.
Note that during one move you reverse exactly one substring of the string s and exactly one substring of the string t.
Also note that borders of substrings you reverse in s and in t can be different, the only restriction is that you reverse the substrings of equal length. For example, if len=3 and n=5, you can reverse s[1 ... 3] and t[3 ... 5], s[2 ... 4] and t[2 ... 4], but not s[1 ... 3] and t[1 ... 2].
Your task is to say if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of s and t.
The second line of the test case contains one string s consisting of n lowercase Latin letters.
The third line of the test case contains one string t consisting of n lowercase Latin letters.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer on it — "YES" (without quotes) if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves and "NO" otherwise.
Example
Input
4
4
abcd
abdc
5
ababa
baaba
4
asdf
asdg
4
abcd
badc
Output
NO
YES
NO
YES | instruction | 0 | 31,081 | 0 | 62,162 |
Tags: constructive algorithms, sortings, strings
Correct Solution:
```
q = int(input())
for i in range(q):
n = int(input())
a = input()
b = input()
countA = [0]*26
countB = [0]*26
for char in a:
countA[ord(char)-97] += 1
for char in b:
countB[ord(char)-97] += 1
no = 0
for i in range(26):
if countA[i] != countB[i]:
no = 1
break
if no:
print("NO")
continue
yes = 0
for i in range(26):
if countA[i] >= 2:
yes = 1
break
if countB[i] >= 2:
yes = 1
break
if yes:
print("YES")
continue
def countRev(s):
count = 0
for i in range(n):
for j in range(i+1,n):
if s[i] > s[j]:
count += 1
return count
x = countRev(a) - countRev(b)
if x%2:
print("NO")
else:
print("YES")
``` | output | 1 | 31,081 | 0 | 62,163 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two strings s and t both of length n and both consisting of lowercase Latin letters.
In one move, you can choose any length len from 1 to n and perform the following operation:
* Choose any contiguous substring of the string s of length len and reverse it;
* at the same time choose any contiguous substring of the string t of length len and reverse it as well.
Note that during one move you reverse exactly one substring of the string s and exactly one substring of the string t.
Also note that borders of substrings you reverse in s and in t can be different, the only restriction is that you reverse the substrings of equal length. For example, if len=3 and n=5, you can reverse s[1 ... 3] and t[3 ... 5], s[2 ... 4] and t[2 ... 4], but not s[1 ... 3] and t[1 ... 2].
Your task is to say if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of s and t.
The second line of the test case contains one string s consisting of n lowercase Latin letters.
The third line of the test case contains one string t consisting of n lowercase Latin letters.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer on it — "YES" (without quotes) if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves and "NO" otherwise.
Example
Input
4
4
abcd
abdc
5
ababa
baaba
4
asdf
asdg
4
abcd
badc
Output
NO
YES
NO
YES | instruction | 0 | 31,082 | 0 | 62,164 |
Tags: constructive algorithms, sortings, strings
Correct Solution:
```
q = int(input())
for _ in range(q):
n = int(input())
s = list(input())
t = list(input())
target = sorted(s)
if target != sorted(t):
print("NO")
continue
seen = set()
for c in s:
if c in seen:
print("YES")
break
seen.add(c)
else:
scnt = 0
for j in range(n - 1):
for i in range(n - 1):
if s[i] > s[i + 1]:
s[i], s[i + 1] = s[i + 1], s[i]
scnt += 1
tcnt = 0
for j in range(n - 1):
for i in range(n - 1):
if t[i] > t[i + 1]:
t[i], t[i + 1] = t[i + 1], t[i]
tcnt += 1
if (scnt - tcnt) % 2 == 0:
print("YES")
else:
print("NO")
``` | output | 1 | 31,082 | 0 | 62,165 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two strings s and t both of length n and both consisting of lowercase Latin letters.
In one move, you can choose any length len from 1 to n and perform the following operation:
* Choose any contiguous substring of the string s of length len and reverse it;
* at the same time choose any contiguous substring of the string t of length len and reverse it as well.
Note that during one move you reverse exactly one substring of the string s and exactly one substring of the string t.
Also note that borders of substrings you reverse in s and in t can be different, the only restriction is that you reverse the substrings of equal length. For example, if len=3 and n=5, you can reverse s[1 ... 3] and t[3 ... 5], s[2 ... 4] and t[2 ... 4], but not s[1 ... 3] and t[1 ... 2].
Your task is to say if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of s and t.
The second line of the test case contains one string s consisting of n lowercase Latin letters.
The third line of the test case contains one string t consisting of n lowercase Latin letters.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer on it — "YES" (without quotes) if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves and "NO" otherwise.
Example
Input
4
4
abcd
abdc
5
ababa
baaba
4
asdf
asdg
4
abcd
badc
Output
NO
YES
NO
YES | instruction | 0 | 31,083 | 0 | 62,166 |
Tags: constructive algorithms, sortings, strings
Correct Solution:
```
import sys, math
import io, os
#data = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
#from bisect import bisect_left as bl, bisect_right as br, insort
from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter
#from itertools import permutations,combinations
def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var) : sys.stdout.write(' '.join(map(str, var))+'\n')
def out(var) : sys.stdout.write(str(var)+'\n')
#from decimal import Decimal
#from fractions import Fraction
#sys.setrecursionlimit(100000)
INF = float('inf')
mod = int(1e9)+7
def cal(s):
l=[0]*26
cnt=0
for i in s:
for j in range(ord(i)-97+1,26):
cnt+=l[j]
l[ord(i)-97]+=1
return cnt
for q in range(int(data())):
n=int(data())
s=data()
t=data()
cnt_s=cal(s)
cnt_t=cal(t)
if (cnt_s==cnt_t or abs(cnt_s-cnt_t)%2==0 or max(Counter(s).values())>1) and (Counter(s)==Counter(t)):
out("YES")
else:
out("NO")
``` | output | 1 | 31,083 | 0 | 62,167 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two strings s and t both of length n and both consisting of lowercase Latin letters.
In one move, you can choose any length len from 1 to n and perform the following operation:
* Choose any contiguous substring of the string s of length len and reverse it;
* at the same time choose any contiguous substring of the string t of length len and reverse it as well.
Note that during one move you reverse exactly one substring of the string s and exactly one substring of the string t.
Also note that borders of substrings you reverse in s and in t can be different, the only restriction is that you reverse the substrings of equal length. For example, if len=3 and n=5, you can reverse s[1 ... 3] and t[3 ... 5], s[2 ... 4] and t[2 ... 4], but not s[1 ... 3] and t[1 ... 2].
Your task is to say if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of s and t.
The second line of the test case contains one string s consisting of n lowercase Latin letters.
The third line of the test case contains one string t consisting of n lowercase Latin letters.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer on it — "YES" (without quotes) if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves and "NO" otherwise.
Example
Input
4
4
abcd
abdc
5
ababa
baaba
4
asdf
asdg
4
abcd
badc
Output
NO
YES
NO
YES
Submitted Solution:
```
from collections import Counter
import sys
input = sys.stdin.readline
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
q = int(input())
for _ in range(q):
n = int(input())
s = input()
t = input()
if Counter(s) != Counter(t):
print('NO')
continue
elif Counter(s).most_common()[0][1] > 1:
print('YES')
continue
s_list = [ord(s[i]) for i in range(n)]
t_list = [ord(t[i]) for i in range(n)]
bit_s = Bit(150)
inv_s = 0
for i in range(n-1, -1, -1):
inv_s += bit_s.sum(s_list[i])
bit_s.add(s_list[i], 1)
bit_t = Bit(150)
inv_t = 0
for i in range(n - 1, -1, -1):
inv_t += bit_t.sum(t_list[i])
bit_t.add(t_list[i], 1)
if (inv_s - inv_t) % 2 == 0:
print('YES')
else:
print('NO')
``` | instruction | 0 | 31,084 | 0 | 62,168 |
Yes | output | 1 | 31,084 | 0 | 62,169 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two strings s and t both of length n and both consisting of lowercase Latin letters.
In one move, you can choose any length len from 1 to n and perform the following operation:
* Choose any contiguous substring of the string s of length len and reverse it;
* at the same time choose any contiguous substring of the string t of length len and reverse it as well.
Note that during one move you reverse exactly one substring of the string s and exactly one substring of the string t.
Also note that borders of substrings you reverse in s and in t can be different, the only restriction is that you reverse the substrings of equal length. For example, if len=3 and n=5, you can reverse s[1 ... 3] and t[3 ... 5], s[2 ... 4] and t[2 ... 4], but not s[1 ... 3] and t[1 ... 2].
Your task is to say if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of s and t.
The second line of the test case contains one string s consisting of n lowercase Latin letters.
The third line of the test case contains one string t consisting of n lowercase Latin letters.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer on it — "YES" (without quotes) if it is possible to make strings s and t equal after some (possibly, empty) sequence of moves and "NO" otherwise.
Example
Input
4
4
abcd
abdc
5
ababa
baaba
4
asdf
asdg
4
abcd
badc
Output
NO
YES
NO
YES
Submitted Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
from collections import Counter
def inv(x):
arr = [[ord(i)-97] for i in x]
ans = 0
while len(arr)!=1:
arr1 = []
for i in range(0,len(arr),2):
if i == len(arr)-1:
arr1.append(arr[-1])
continue
arr1.append([])
a,b = 0,0
for _ in range(len(arr[i])+len(arr[i+1])):
if a == len(arr[i]):
arr1[-1].append(arr[i+1][b])
b += 1
elif b == len(arr[i+1]):
arr1[-1].append(arr[i][a])
a += 1
elif arr[i][a] <= arr[i+1][b]:
arr1[-1].append(arr[i][a])
a += 1
else:
arr1[-1].append(arr[i+1][b])
b += 1
ans += len(arr[i])-a
arr = arr1
return ans
def solve(n,s,t):
x = Counter(s)
if x != Counter(t):
return 'NO'
if x[max(x,key=x.get)] >= 2:
return 'YES'
if inv(s)&1 == inv(t)&1:
return 'YES'
return 'NO'
def main():
for _ in range(int(input())):
n = int(input())
s = input().strip()
t = input().strip()
print(solve(n,s,t))
# Fast IO Region
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")
if __name__ == "__main__":
main()
``` | instruction | 0 | 31,085 | 0 | 62,170 |
Yes | output | 1 | 31,085 | 0 | 62,171 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.