text stringlengths 525 23.5k | conversation_id int64 129 108k | embedding sequence | cluster int64 6 6 |
|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem is different from the easy version. In this version Ujan makes at most 2n swaps. In addition, k ≤ 1000, n ≤ 50 and it is necessary to print swaps themselves. You can hack this problem if you solve it. But you can hack the previous problem only if you solve both problems.
After struggling and failing many times, Ujan decided to try to clean up his house again. He decided to get his strings in order first.
Ujan has two distinct strings s and t of length n consisting of only of lowercase English characters. He wants to make them equal. Since Ujan is lazy, he will perform the following operation at most 2n times: he takes two positions i and j (1 ≤ i,j ≤ n, the values i and j can be equal or different), and swaps the characters s_i and t_j.
Ujan's goal is to make the strings s and t equal. He does not need to minimize the number of performed operations: any sequence of operations of length 2n or shorter is suitable.
Input
The first line contains a single integer k (1 ≤ k ≤ 1000), the number of test cases.
For each of the test cases, the first line contains a single integer n (2 ≤ n ≤ 50), the length of the strings s and t.
Each of the next two lines contains the strings s and t, each having length exactly n. The strings consist only of lowercase English letters. It is guaranteed that strings are different.
Output
For each test case, output "Yes" if Ujan can make the two strings equal with at most 2n operations and "No" otherwise. You can print each letter in any case (upper or lower).
In the case of "Yes" print m (1 ≤ m ≤ 2n) on the next line, where m is the number of swap operations to make the strings equal. Then print m lines, each line should contain two integers i, j (1 ≤ i, j ≤ n) meaning that Ujan swaps s_i and t_j during the corresponding operation. You do not need to minimize the number of operations. Any sequence of length not more than 2n is suitable.
Example
Input
4
5
souse
houhe
3
cat
dog
2
aa
az
3
abc
bca
Output
Yes
1
1 4
No
No
Yes
3
1 2
3 1
2 3
Tags: strings
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
a = list(input())
b = list(input())
ml = []
for i in range(n-1):
if a[i] != b[i]:
if a[i] in a[i+1:]:
ind = i+1+a[i+1:].index(a[i])
b[i], a[ind] = a[ind], b[i]
ml.append((ind+1, i+1))
elif a[i] in b[i+1:]:
ind1 = i+1+b[i+1:].index(a[i])
a[i+1], b[ind1] = b[ind1], a[i+1]
b[i], a[i+1] = a[i+1], b[i]
ml.append((i+2, ind1+1))
ml.append((i+2, i+1))
else:
break
if a == b:
print('Yes')
print(len(ml))
for i in ml:
print(*i)
else:
print("No")
```
| 129 | [
0.28955078125,
-0.09613037109375,
-0.1514892578125,
-0.057098388671875,
-0.62646484375,
-0.5537109375,
0.038604736328125,
-0.0033721923828125,
0.071533203125,
1.01953125,
0.978515625,
0.06304931640625,
0.2388916015625,
-1.1875,
-0.63916015625,
-0.00443267822265625,
-0.4404296875,
-... | 6 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem is different from the easy version. In this version Ujan makes at most 2n swaps. In addition, k ≤ 1000, n ≤ 50 and it is necessary to print swaps themselves. You can hack this problem if you solve it. But you can hack the previous problem only if you solve both problems.
After struggling and failing many times, Ujan decided to try to clean up his house again. He decided to get his strings in order first.
Ujan has two distinct strings s and t of length n consisting of only of lowercase English characters. He wants to make them equal. Since Ujan is lazy, he will perform the following operation at most 2n times: he takes two positions i and j (1 ≤ i,j ≤ n, the values i and j can be equal or different), and swaps the characters s_i and t_j.
Ujan's goal is to make the strings s and t equal. He does not need to minimize the number of performed operations: any sequence of operations of length 2n or shorter is suitable.
Input
The first line contains a single integer k (1 ≤ k ≤ 1000), the number of test cases.
For each of the test cases, the first line contains a single integer n (2 ≤ n ≤ 50), the length of the strings s and t.
Each of the next two lines contains the strings s and t, each having length exactly n. The strings consist only of lowercase English letters. It is guaranteed that strings are different.
Output
For each test case, output "Yes" if Ujan can make the two strings equal with at most 2n operations and "No" otherwise. You can print each letter in any case (upper or lower).
In the case of "Yes" print m (1 ≤ m ≤ 2n) on the next line, where m is the number of swap operations to make the strings equal. Then print m lines, each line should contain two integers i, j (1 ≤ i, j ≤ n) meaning that Ujan swaps s_i and t_j during the corresponding operation. You do not need to minimize the number of operations. Any sequence of length not more than 2n is suitable.
Example
Input
4
5
souse
houhe
3
cat
dog
2
aa
az
3
abc
bca
Output
Yes
1
1 4
No
No
Yes
3
1 2
3 1
2 3
Tags: strings
Correct Solution:
```
from sys import stdin, stdout
from collections import Counter, deque
from bisect import bisect_left
from itertools import product
#input = stdin.buffer.readline
T = int(input())
for _ in range(T):
n = int(input())
a, b = list(input()), list(input())
cc = Counter(a+b)
if any([u%2 for u in cc.values()]):
print("No"); continue
res = []
for i in range(n):
if a[i] == b[i]: continue
if a[i] in a[i+1:]:
p = a[i+1:].index(a[i])
b[i], a[i+p+1] = a[i+p+1], b[i]
res.append((i+p+1, i))
else:
p = b[i+1:].index(a[i])
a[i+1], b[i+p+1] = b[i+p+1], a[i+1]
a[i+1], b[i] = b[i], a[i+1]
res.append((i+1, i+p+1))
res.append((i+1, i))
print("Yes")
print(len(res))
for u, v in res:
print(str(u+1)+' '+str(v+1))
```
| 130 | [
0.28955078125,
-0.09613037109375,
-0.1514892578125,
-0.057098388671875,
-0.62646484375,
-0.5537109375,
0.038604736328125,
-0.0033721923828125,
0.071533203125,
1.01953125,
0.978515625,
0.06304931640625,
0.2388916015625,
-1.1875,
-0.63916015625,
-0.00443267822265625,
-0.4404296875,
-... | 6 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem is different from the easy version. In this version Ujan makes at most 2n swaps. In addition, k ≤ 1000, n ≤ 50 and it is necessary to print swaps themselves. You can hack this problem if you solve it. But you can hack the previous problem only if you solve both problems.
After struggling and failing many times, Ujan decided to try to clean up his house again. He decided to get his strings in order first.
Ujan has two distinct strings s and t of length n consisting of only of lowercase English characters. He wants to make them equal. Since Ujan is lazy, he will perform the following operation at most 2n times: he takes two positions i and j (1 ≤ i,j ≤ n, the values i and j can be equal or different), and swaps the characters s_i and t_j.
Ujan's goal is to make the strings s and t equal. He does not need to minimize the number of performed operations: any sequence of operations of length 2n or shorter is suitable.
Input
The first line contains a single integer k (1 ≤ k ≤ 1000), the number of test cases.
For each of the test cases, the first line contains a single integer n (2 ≤ n ≤ 50), the length of the strings s and t.
Each of the next two lines contains the strings s and t, each having length exactly n. The strings consist only of lowercase English letters. It is guaranteed that strings are different.
Output
For each test case, output "Yes" if Ujan can make the two strings equal with at most 2n operations and "No" otherwise. You can print each letter in any case (upper or lower).
In the case of "Yes" print m (1 ≤ m ≤ 2n) on the next line, where m is the number of swap operations to make the strings equal. Then print m lines, each line should contain two integers i, j (1 ≤ i, j ≤ n) meaning that Ujan swaps s_i and t_j during the corresponding operation. You do not need to minimize the number of operations. Any sequence of length not more than 2n is suitable.
Example
Input
4
5
souse
houhe
3
cat
dog
2
aa
az
3
abc
bca
Output
Yes
1
1 4
No
No
Yes
3
1 2
3 1
2 3
Tags: strings
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
na = list(input())
nb = list(input())
k=0
zz = len(na)
ans = []
for i in range(zz):
f = 0
if(na[i]==nb[i]):
f= 1
if(not f):
for j in range(i+1,zz):
if(na[j]==na[i]):
ans.append((j+1,i+1))
na[j] = nb[i]
f = 1
break
if(not f):
for j in range(i+1,zz):
if(na[i]==nb[j]):
ans.append((j+1,j+1))
ans.append((j+1,i+1))
nb[j] = na[j]
na[j] = nb[i]
f = 1
break
#print(na,nb)
if(not f):
k =1
break
if(k):
print("NO")
else:
print("YES")
print(len(ans))
for t in ans:
print(t[0],t[1])
```
| 131 | [
0.28955078125,
-0.09613037109375,
-0.1514892578125,
-0.057098388671875,
-0.62646484375,
-0.5537109375,
0.038604736328125,
-0.0033721923828125,
0.071533203125,
1.01953125,
0.978515625,
0.06304931640625,
0.2388916015625,
-1.1875,
-0.63916015625,
-0.00443267822265625,
-0.4404296875,
-... | 6 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem is different from the easy version. In this version Ujan makes at most 2n swaps. In addition, k ≤ 1000, n ≤ 50 and it is necessary to print swaps themselves. You can hack this problem if you solve it. But you can hack the previous problem only if you solve both problems.
After struggling and failing many times, Ujan decided to try to clean up his house again. He decided to get his strings in order first.
Ujan has two distinct strings s and t of length n consisting of only of lowercase English characters. He wants to make them equal. Since Ujan is lazy, he will perform the following operation at most 2n times: he takes two positions i and j (1 ≤ i,j ≤ n, the values i and j can be equal or different), and swaps the characters s_i and t_j.
Ujan's goal is to make the strings s and t equal. He does not need to minimize the number of performed operations: any sequence of operations of length 2n or shorter is suitable.
Input
The first line contains a single integer k (1 ≤ k ≤ 1000), the number of test cases.
For each of the test cases, the first line contains a single integer n (2 ≤ n ≤ 50), the length of the strings s and t.
Each of the next two lines contains the strings s and t, each having length exactly n. The strings consist only of lowercase English letters. It is guaranteed that strings are different.
Output
For each test case, output "Yes" if Ujan can make the two strings equal with at most 2n operations and "No" otherwise. You can print each letter in any case (upper or lower).
In the case of "Yes" print m (1 ≤ m ≤ 2n) on the next line, where m is the number of swap operations to make the strings equal. Then print m lines, each line should contain two integers i, j (1 ≤ i, j ≤ n) meaning that Ujan swaps s_i and t_j during the corresponding operation. You do not need to minimize the number of operations. Any sequence of length not more than 2n is suitable.
Example
Input
4
5
souse
houhe
3
cat
dog
2
aa
az
3
abc
bca
Output
Yes
1
1 4
No
No
Yes
3
1 2
3 1
2 3
Tags: strings
Correct Solution:
```
T = int(input())
for t in range(T):
N = int(input())
s = list(input())
t = list(input())
i = 0
possible = True
res = []
while i < N:
# print("i : ", i)
# print("res : ", res)
# print("s[i], t[i] : ", s[i], t[i])
if s[i] != t[i]:
# Find index j such that s[i] == s[j] or s[i] == t[j]
# If no such j, then impossible
j = i + 1
found = False
while j < N:
# print("j : ", j)
# Then we just swap sj with ti
if s[i] == s[j]:
res.append((j, i))
s[j], t[i] = t[i], s[j]
found = True
break
# Then we first swap sj with tj
# Then sj with ti
elif s[i] == t[j]:
res.append((j, j))
s[j], t[j] = t[j], s[j]
res.append((j, i))
s[j], t[i] = t[i], s[j]
found = True
break
j += 1
if not (found):
possible = False
break
i += 1
if possible:
print("Yes")
print(len(res))
for i, j in res:
print(i + 1, j + 1)
else:
print("No")
```
| 132 | [
0.28955078125,
-0.09613037109375,
-0.1514892578125,
-0.057098388671875,
-0.62646484375,
-0.5537109375,
0.038604736328125,
-0.0033721923828125,
0.071533203125,
1.01953125,
0.978515625,
0.06304931640625,
0.2388916015625,
-1.1875,
-0.63916015625,
-0.00443267822265625,
-0.4404296875,
-... | 6 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem is different from the easy version. In this version Ujan makes at most 2n swaps. In addition, k ≤ 1000, n ≤ 50 and it is necessary to print swaps themselves. You can hack this problem if you solve it. But you can hack the previous problem only if you solve both problems.
After struggling and failing many times, Ujan decided to try to clean up his house again. He decided to get his strings in order first.
Ujan has two distinct strings s and t of length n consisting of only of lowercase English characters. He wants to make them equal. Since Ujan is lazy, he will perform the following operation at most 2n times: he takes two positions i and j (1 ≤ i,j ≤ n, the values i and j can be equal or different), and swaps the characters s_i and t_j.
Ujan's goal is to make the strings s and t equal. He does not need to minimize the number of performed operations: any sequence of operations of length 2n or shorter is suitable.
Input
The first line contains a single integer k (1 ≤ k ≤ 1000), the number of test cases.
For each of the test cases, the first line contains a single integer n (2 ≤ n ≤ 50), the length of the strings s and t.
Each of the next two lines contains the strings s and t, each having length exactly n. The strings consist only of lowercase English letters. It is guaranteed that strings are different.
Output
For each test case, output "Yes" if Ujan can make the two strings equal with at most 2n operations and "No" otherwise. You can print each letter in any case (upper or lower).
In the case of "Yes" print m (1 ≤ m ≤ 2n) on the next line, where m is the number of swap operations to make the strings equal. Then print m lines, each line should contain two integers i, j (1 ≤ i, j ≤ n) meaning that Ujan swaps s_i and t_j during the corresponding operation. You do not need to minimize the number of operations. Any sequence of length not more than 2n is suitable.
Example
Input
4
5
souse
houhe
3
cat
dog
2
aa
az
3
abc
bca
Output
Yes
1
1 4
No
No
Yes
3
1 2
3 1
2 3
Tags: strings
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
lis=[0]*2
lis[0]=list(input())
lis[1]=list(input())
ans=[]
gg=0
for i in range(n):
a=lis[0][i]
ind=-1
for j in range(i+1,n):
if a==lis[0][j]:
ind=j
break
if ind!=-1:
ans.append([ind+1,i+1])
lis[1][i],lis[0][ind]=lis[0][ind],lis[1][i]
else:
for j in range(i,n):
if a==lis[1][j]:
ind=j
break
if ind!=-1:
ans.append([n,ind+1])
ans.append([n,i+1])
lis[1][ind],lis[0][n-1]=lis[0][n-1],lis[1][ind]
lis[1][i],lis[0][n-1]=lis[0][n-1],lis[1][i]
else:
print("No")
gg=1
break
if gg==0:
print("Yes")
print(len(ans))
for i in range(len(ans)):
print(*ans[i])
```
| 133 | [
0.28955078125,
-0.09613037109375,
-0.1514892578125,
-0.057098388671875,
-0.62646484375,
-0.5537109375,
0.038604736328125,
-0.0033721923828125,
0.071533203125,
1.01953125,
0.978515625,
0.06304931640625,
0.2388916015625,
-1.1875,
-0.63916015625,
-0.00443267822265625,
-0.4404296875,
-... | 6 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem is different from the easy version. In this version Ujan makes at most 2n swaps. In addition, k ≤ 1000, n ≤ 50 and it is necessary to print swaps themselves. You can hack this problem if you solve it. But you can hack the previous problem only if you solve both problems.
After struggling and failing many times, Ujan decided to try to clean up his house again. He decided to get his strings in order first.
Ujan has two distinct strings s and t of length n consisting of only of lowercase English characters. He wants to make them equal. Since Ujan is lazy, he will perform the following operation at most 2n times: he takes two positions i and j (1 ≤ i,j ≤ n, the values i and j can be equal or different), and swaps the characters s_i and t_j.
Ujan's goal is to make the strings s and t equal. He does not need to minimize the number of performed operations: any sequence of operations of length 2n or shorter is suitable.
Input
The first line contains a single integer k (1 ≤ k ≤ 1000), the number of test cases.
For each of the test cases, the first line contains a single integer n (2 ≤ n ≤ 50), the length of the strings s and t.
Each of the next two lines contains the strings s and t, each having length exactly n. The strings consist only of lowercase English letters. It is guaranteed that strings are different.
Output
For each test case, output "Yes" if Ujan can make the two strings equal with at most 2n operations and "No" otherwise. You can print each letter in any case (upper or lower).
In the case of "Yes" print m (1 ≤ m ≤ 2n) on the next line, where m is the number of swap operations to make the strings equal. Then print m lines, each line should contain two integers i, j (1 ≤ i, j ≤ n) meaning that Ujan swaps s_i and t_j during the corresponding operation. You do not need to minimize the number of operations. Any sequence of length not more than 2n is suitable.
Example
Input
4
5
souse
houhe
3
cat
dog
2
aa
az
3
abc
bca
Output
Yes
1
1 4
No
No
Yes
3
1 2
3 1
2 3
Tags: strings
Correct Solution:
```
import sys
for t in range(int(sys.stdin.readline())):
n = int(sys.stdin.readline())
s1 = [ord(c) - 97 for c in sys.stdin.readline().strip()]
s2 = [ord(c) - 97 for c in sys.stdin.readline().strip()]
pl = []
orde = True
for i in range(26):
st1 = {j for j in range(n) if s1[j] == i}
st2 = {j for j in range(n) if s2[j] == i}
if len(st2) > len(st1):
st1, st2 = st2, st1
s1, s2 = s2, s1
orde = not orde
# stb = set()
rml = []
for el in st2:
if el in st1:
rml.append(el)
for el in rml:
st1.remove(el)
st2.remove(el)
tot = len(st1) + len(st2)
if (tot) & 1:
pl = []
break
# op = -1
# for j in range(25):
# if s2[j] != i:
# op = j
# break
# if op == -1:
# continue
# k = len(st1)//2
# for j in range(k):
# k1 = st1.pop()
# k2 = st1.pop()
# op1 = -1
# while len(st1) > 2:
# k1 = st1.pop()
# k2 = st1.pop()
# pl.append((k1, k2) if orde else (k2, k1))
# s1[k1], s2[k2] = s2[k2], s1[k1]
for k in st2:
st1.add(k)
pl.append((k, k))
s1[k], s2[k] = s2[k], s1[k]
for j in range(tot//2):
k1 = st1.pop()
k2 = st1.pop()
pl.append((k1, k2) if orde else (k2, k1))
s1[k1], s2[k2] = s2[k2], s1[k1]
if pl == []:
print("No")
else:
print(f"Yes\n{len(pl)}\n" + "".join([f"{tup[0] + 1} {tup[1] + 1}\n" for tup in pl]))
```
| 134 | [
0.28955078125,
-0.09613037109375,
-0.1514892578125,
-0.057098388671875,
-0.62646484375,
-0.5537109375,
0.038604736328125,
-0.0033721923828125,
0.071533203125,
1.01953125,
0.978515625,
0.06304931640625,
0.2388916015625,
-1.1875,
-0.63916015625,
-0.00443267822265625,
-0.4404296875,
-... | 6 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem is different from the easy version. In this version Ujan makes at most 2n swaps. In addition, k ≤ 1000, n ≤ 50 and it is necessary to print swaps themselves. You can hack this problem if you solve it. But you can hack the previous problem only if you solve both problems.
After struggling and failing many times, Ujan decided to try to clean up his house again. He decided to get his strings in order first.
Ujan has two distinct strings s and t of length n consisting of only of lowercase English characters. He wants to make them equal. Since Ujan is lazy, he will perform the following operation at most 2n times: he takes two positions i and j (1 ≤ i,j ≤ n, the values i and j can be equal or different), and swaps the characters s_i and t_j.
Ujan's goal is to make the strings s and t equal. He does not need to minimize the number of performed operations: any sequence of operations of length 2n or shorter is suitable.
Input
The first line contains a single integer k (1 ≤ k ≤ 1000), the number of test cases.
For each of the test cases, the first line contains a single integer n (2 ≤ n ≤ 50), the length of the strings s and t.
Each of the next two lines contains the strings s and t, each having length exactly n. The strings consist only of lowercase English letters. It is guaranteed that strings are different.
Output
For each test case, output "Yes" if Ujan can make the two strings equal with at most 2n operations and "No" otherwise. You can print each letter in any case (upper or lower).
In the case of "Yes" print m (1 ≤ m ≤ 2n) on the next line, where m is the number of swap operations to make the strings equal. Then print m lines, each line should contain two integers i, j (1 ≤ i, j ≤ n) meaning that Ujan swaps s_i and t_j during the corresponding operation. You do not need to minimize the number of operations. Any sequence of length not more than 2n is suitable.
Example
Input
4
5
souse
houhe
3
cat
dog
2
aa
az
3
abc
bca
Output
Yes
1
1 4
No
No
Yes
3
1 2
3 1
2 3
Tags: strings
Correct Solution:
```
from collections import defaultdict
# input = sys.stdin.readline
def case():
n = int(input())
s = input()
s = [i for i in s]
t = input()
t = [i for i in t]
d= defaultdict(int)
for i in s:
d[i]+=1
for i in t:
d[i]+=1
for i in d.values():
if i%2:
print("NO")
return
ans = []
for i in range(n):
flag = 0
for j in range(i+1, n):
if s[i] == s[j]:
t[i], s[j] = s[j], t[i]
ans.append([j+1, i+1])
flag = 1
break
if flag:
continue
for j in range(i+1, n):
if s[i] == t[j]:
s[j], t[j] = t[j], s[j]
ans.append([j+1, j+1])
t[i], s[j] = s[j], t[i]
ans.append([j+1, i+1])
flag = 1
break
if flag:
continue
print("YES")
print(len(ans))
for i in ans:
print(*i)
for _ in range(int(input())):
case()
```
| 135 | [
0.28955078125,
-0.09613037109375,
-0.1514892578125,
-0.057098388671875,
-0.62646484375,
-0.5537109375,
0.038604736328125,
-0.0033721923828125,
0.071533203125,
1.01953125,
0.978515625,
0.06304931640625,
0.2388916015625,
-1.1875,
-0.63916015625,
-0.00443267822265625,
-0.4404296875,
-... | 6 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem is different from the easy version. In this version Ujan makes at most 2n swaps. In addition, k ≤ 1000, n ≤ 50 and it is necessary to print swaps themselves. You can hack this problem if you solve it. But you can hack the previous problem only if you solve both problems.
After struggling and failing many times, Ujan decided to try to clean up his house again. He decided to get his strings in order first.
Ujan has two distinct strings s and t of length n consisting of only of lowercase English characters. He wants to make them equal. Since Ujan is lazy, he will perform the following operation at most 2n times: he takes two positions i and j (1 ≤ i,j ≤ n, the values i and j can be equal or different), and swaps the characters s_i and t_j.
Ujan's goal is to make the strings s and t equal. He does not need to minimize the number of performed operations: any sequence of operations of length 2n or shorter is suitable.
Input
The first line contains a single integer k (1 ≤ k ≤ 1000), the number of test cases.
For each of the test cases, the first line contains a single integer n (2 ≤ n ≤ 50), the length of the strings s and t.
Each of the next two lines contains the strings s and t, each having length exactly n. The strings consist only of lowercase English letters. It is guaranteed that strings are different.
Output
For each test case, output "Yes" if Ujan can make the two strings equal with at most 2n operations and "No" otherwise. You can print each letter in any case (upper or lower).
In the case of "Yes" print m (1 ≤ m ≤ 2n) on the next line, where m is the number of swap operations to make the strings equal. Then print m lines, each line should contain two integers i, j (1 ≤ i, j ≤ n) meaning that Ujan swaps s_i and t_j during the corresponding operation. You do not need to minimize the number of operations. Any sequence of length not more than 2n is suitable.
Example
Input
4
5
souse
houhe
3
cat
dog
2
aa
az
3
abc
bca
Output
Yes
1
1 4
No
No
Yes
3
1 2
3 1
2 3
Tags: strings
Correct Solution:
```
import sys
input = sys.stdin.readline
for q in range(int(input())):
N = int(input())
s = list(input().rstrip())
t = list(input().rstrip())
ans = []
for i in range(N-1):
if s[i] != t[i]:
for j in range(i + 1, N):
if s[j] == s[i]:
ans.append((j + 1, i + 1))
s[j], t[i] = t[i], s[j]
break
if t[j] == s[i]:
ans.append((i + 2, j + 1))
s[i + 1], t[j] = t[j], s[i + 1]
ans.append((i + 2, i + 1))
s[i + 1], t[i] = t[i], s[i + 1]
break
flag = True
for i in range(N):
if s[i] != t[i]: flag = False
if flag and ans:
print("Yes")
print(len(ans))
for u,v in ans:
print(u, v)
else:
print("No")
```
| 136 | [
0.28955078125,
-0.09613037109375,
-0.1514892578125,
-0.057098388671875,
-0.62646484375,
-0.5537109375,
0.038604736328125,
-0.0033721923828125,
0.071533203125,
1.01953125,
0.978515625,
0.06304931640625,
0.2388916015625,
-1.1875,
-0.63916015625,
-0.00443267822265625,
-0.4404296875,
-... | 6 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Girl loves problems on games very much. Here's one of them.
Two players have got a string s, consisting of lowercase English letters. They play a game that is described by the following rules:
* The players move in turns; In one move the player can remove an arbitrary letter from string s.
* If the player before his turn can reorder the letters in string s so as to get a palindrome, this player wins. A palindrome is a string that reads the same both ways (from left to right, and vice versa). For example, string "abba" is a palindrome and string "abc" isn't.
Determine which player will win, provided that both sides play optimally well — the one who moves first or the one who moves second.
Input
The input contains a single line, containing string s (1 ≤ |s| ≤ 103). String s consists of lowercase English letters.
Output
In a single line print word "First" if the first player wins (provided that both players play optimally well). Otherwise, print word "Second". Print the words without the quotes.
Examples
Input
aba
Output
First
Input
abca
Output
Second
Tags: games, greedy
Correct Solution:
```
from collections import Counter
s=input()
dic=Counter(s)
count=0
for val in dic.values():
if val%2!=0:
count+=1
if count==0:
print("First")
elif count%2==0:
print("Second")
else:
print("First")
```
| 286 | [
-0.05926513671875,
-0.02166748046875,
-0.0196075439453125,
0.052215576171875,
-0.450927734375,
-0.7783203125,
0.09783935546875,
-0.270263671875,
0.10504150390625,
0.57373046875,
0.467529296875,
0.044158935546875,
0.09722900390625,
-0.6591796875,
-0.7041015625,
-0.381103515625,
-0.829... | 6 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Girl loves problems on games very much. Here's one of them.
Two players have got a string s, consisting of lowercase English letters. They play a game that is described by the following rules:
* The players move in turns; In one move the player can remove an arbitrary letter from string s.
* If the player before his turn can reorder the letters in string s so as to get a palindrome, this player wins. A palindrome is a string that reads the same both ways (from left to right, and vice versa). For example, string "abba" is a palindrome and string "abc" isn't.
Determine which player will win, provided that both sides play optimally well — the one who moves first or the one who moves second.
Input
The input contains a single line, containing string s (1 ≤ |s| ≤ 103). String s consists of lowercase English letters.
Output
In a single line print word "First" if the first player wins (provided that both players play optimally well). Otherwise, print word "Second". Print the words without the quotes.
Examples
Input
aba
Output
First
Input
abca
Output
Second
Tags: games, greedy
Correct Solution:
```
from collections import Counter
def iswin(c):
if c == c[::-1]:
return True, None
else:
co = Counter(c)
ae = 0
k1 = c[0]
for k, v in co.items():
if v%2==0:
ae += 1
k1 = k
if ae == len(co) or len(co)%2==1 and ae == len(co)-1:
return True, None
else:
return False, k1
s = input()
p = True
res = ''
while s:
# print(s)
r, k = iswin(s)
if not r:
i = s.index(k)
s = s[:i] + s[min(i+1, len(s)-1):]
else:
if p:
res = 'First'
else:
res = 'Second'
break
p = not p
print(res)
```
| 287 | [
-0.058990478515625,
0.04998779296875,
-0.04571533203125,
0.0178375244140625,
-0.456298828125,
-0.7587890625,
0.0537109375,
-0.1953125,
0.0712890625,
0.578125,
0.54736328125,
0.0281982421875,
0.02008056640625,
-0.72607421875,
-0.62646484375,
-0.3623046875,
-0.80859375,
-0.7827148437... | 6 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Girl loves problems on games very much. Here's one of them.
Two players have got a string s, consisting of lowercase English letters. They play a game that is described by the following rules:
* The players move in turns; In one move the player can remove an arbitrary letter from string s.
* If the player before his turn can reorder the letters in string s so as to get a palindrome, this player wins. A palindrome is a string that reads the same both ways (from left to right, and vice versa). For example, string "abba" is a palindrome and string "abc" isn't.
Determine which player will win, provided that both sides play optimally well — the one who moves first or the one who moves second.
Input
The input contains a single line, containing string s (1 ≤ |s| ≤ 103). String s consists of lowercase English letters.
Output
In a single line print word "First" if the first player wins (provided that both players play optimally well). Otherwise, print word "Second". Print the words without the quotes.
Examples
Input
aba
Output
First
Input
abca
Output
Second
Tags: games, greedy
Correct Solution:
```
if __name__ == '__main__':
s = input()
c = [s.count(x) for x in set(s)]
total = 0
for x in c:
if x % 2 != 0:
total += 1
if total % 2 == 0 and total != 0:
print("Second")
else:
print("First")
```
| 288 | [
-0.0165557861328125,
0.034942626953125,
-0.0272216796875,
0.042144775390625,
-0.454833984375,
-0.7890625,
0.053314208984375,
-0.215576171875,
0.113525390625,
0.56787109375,
0.529296875,
0.049713134765625,
0.07135009765625,
-0.63720703125,
-0.65185546875,
-0.384765625,
-0.78076171875,... | 6 |
End of preview. Expand
in Data Studio
- Downloads last month
- 7