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 a correct Python 3 solution for this coding contest problem.
For given two sequences $X$ and $Y$, a sequence $Z$ is a common subsequence of $X$ and $Y$ if $Z$ is a subsequence of both $X$ and $Y$. For example, if $X = \\{a,b,c,b,d,a,b\\}$ and $Y = \\{b,d,c,a,b,a\\}$, the sequence $\\{b,c,a\\}$ is a common subsequence of both $X$ and $Y$. On the other hand, the sequence $\\{b,c,a\\}$ is not a longest common subsequence (LCS) of $X$ and $Y$, since it has length 3 and the sequence $\\{b,c,b,a\\}$, which is also common to both $X$ and $Y$, has length 4. The sequence $\\{b,c,b,a\\}$ is an LCS of $X$ and $Y$, since there is no common subsequence of length 5 or greater.
Write a program which finds the length of LCS of given two sequences $X$ and $Y$. The sequence consists of alphabetical characters.
Constraints
* $1 \leq q \leq 150$
* $1 \leq$ length of $X$ and $Y$ $\leq 1,000$
* $q \leq 20$ if the dataset includes a sequence whose length is more than 100
Input
The input consists of multiple datasets. In the first line, an integer $q$ which is the number of datasets is given. In the following $2 \times q$ lines, each dataset which consists of the two sequences $X$ and $Y$ are given.
Output
For each dataset, print the length of LCS of $X$ and $Y$ in a line.
Example
Input
3
abcbdab
bdcaba
abc
abc
abc
bc
Output
4
3
2 | instruction | 0 | 57,127 | 0 | 114,254 |
"Correct Solution:
```
for _ in[0]*int(input()):
X,Y,z=input(),input(),[]
for y in Y:
s=i=0
for k in z:
t=X.find(y,s)+1
if t<1:break
if t<k:z[i]=t
s=k;i+=1
else:
t=X.find(y,s)+1
if t:z+=[t]
print(len(z))
``` | output | 1 | 57,127 | 0 | 114,255 |
Provide a correct Python 3 solution for this coding contest problem.
For given two sequences $X$ and $Y$, a sequence $Z$ is a common subsequence of $X$ and $Y$ if $Z$ is a subsequence of both $X$ and $Y$. For example, if $X = \\{a,b,c,b,d,a,b\\}$ and $Y = \\{b,d,c,a,b,a\\}$, the sequence $\\{b,c,a\\}$ is a common subsequence of both $X$ and $Y$. On the other hand, the sequence $\\{b,c,a\\}$ is not a longest common subsequence (LCS) of $X$ and $Y$, since it has length 3 and the sequence $\\{b,c,b,a\\}$, which is also common to both $X$ and $Y$, has length 4. The sequence $\\{b,c,b,a\\}$ is an LCS of $X$ and $Y$, since there is no common subsequence of length 5 or greater.
Write a program which finds the length of LCS of given two sequences $X$ and $Y$. The sequence consists of alphabetical characters.
Constraints
* $1 \leq q \leq 150$
* $1 \leq$ length of $X$ and $Y$ $\leq 1,000$
* $q \leq 20$ if the dataset includes a sequence whose length is more than 100
Input
The input consists of multiple datasets. In the first line, an integer $q$ which is the number of datasets is given. In the following $2 \times q$ lines, each dataset which consists of the two sequences $X$ and $Y$ are given.
Output
For each dataset, print the length of LCS of $X$ and $Y$ in a line.
Example
Input
3
abcbdab
bdcaba
abc
abc
abc
bc
Output
4
3
2 | instruction | 0 | 57,128 | 0 | 114,256 |
"Correct Solution:
```
# ALDS_10_C - 最長共通部分列
import sys
# def main():
# q = int(input())
#
# for _ in range(q):
# X = list(str(sys.stdin.readline().strip()))
# Y = list(str(sys.stdin.readline().strip()))
#
# dp = [[0] * (len(X) + 1) for _ in range(len(Y) + 1)]
#
# for y in range(len(Y)):
# for x in range(len(X)):
# dp[y + 1][x + 1] = max(dp[y][x + 1], dp[y + 1][x])
# if X[x] == Y[y]:
# dp[y + 1][x + 1] = dp[y][x] + 1
#
# print(dp[-1][-1])
def main():
q = int(input())
for _ in range(q):
X = list(str(sys.stdin.readline().strip()))
Y = list(str(sys.stdin.readline().strip()))
dp = [0] * (len(X) + 1)
for y in range(len(Y)):
dp2 = dp[:]
# print(dp2)
for x in range(len(X)):
if X[x] == Y[y]:
dp[x + 1] = dp2[x] + 1
elif dp[x + 1] < dp[x]:
dp[x + 1] = dp[x]
print(dp[-1])
if __name__ == '__main__':
main()
``` | output | 1 | 57,128 | 0 | 114,257 |
Provide a correct Python 3 solution for this coding contest problem.
For given two sequences $X$ and $Y$, a sequence $Z$ is a common subsequence of $X$ and $Y$ if $Z$ is a subsequence of both $X$ and $Y$. For example, if $X = \\{a,b,c,b,d,a,b\\}$ and $Y = \\{b,d,c,a,b,a\\}$, the sequence $\\{b,c,a\\}$ is a common subsequence of both $X$ and $Y$. On the other hand, the sequence $\\{b,c,a\\}$ is not a longest common subsequence (LCS) of $X$ and $Y$, since it has length 3 and the sequence $\\{b,c,b,a\\}$, which is also common to both $X$ and $Y$, has length 4. The sequence $\\{b,c,b,a\\}$ is an LCS of $X$ and $Y$, since there is no common subsequence of length 5 or greater.
Write a program which finds the length of LCS of given two sequences $X$ and $Y$. The sequence consists of alphabetical characters.
Constraints
* $1 \leq q \leq 150$
* $1 \leq$ length of $X$ and $Y$ $\leq 1,000$
* $q \leq 20$ if the dataset includes a sequence whose length is more than 100
Input
The input consists of multiple datasets. In the first line, an integer $q$ which is the number of datasets is given. In the following $2 \times q$ lines, each dataset which consists of the two sequences $X$ and $Y$ are given.
Output
For each dataset, print the length of LCS of $X$ and $Y$ in a line.
Example
Input
3
abcbdab
bdcaba
abc
abc
abc
bc
Output
4
3
2 | instruction | 0 | 57,129 | 0 | 114,258 |
"Correct Solution:
```
def len_LCS(X,Y):
x_l = len(X)
y_l = len(Y)
lcs_row = [0 for _ in range(x_l+1)]
for j in range(y_l):
y_j = Y[j]
lcs_row_p = lcs_row[:]
# lcs_row_p: [i] [i+1]
# lcs_row : [i] [i+1]
for i in range(x_l):
if X[i] == y_j:
lcs_row[i+1] = lcs_row_p[i] + 1
elif lcs_row[i] > lcs_row_p[i+1]:
lcs_row[i+1] = lcs_row[i]
return lcs_row[-1]
if __name__=='__main__':
n = int(input())
for _ in range(n):
X = input()
Y = input()
print(len_LCS(X,Y))
``` | output | 1 | 57,129 | 0 | 114,259 |
Provide a correct Python 3 solution for this coding contest problem.
For given two sequences $X$ and $Y$, a sequence $Z$ is a common subsequence of $X$ and $Y$ if $Z$ is a subsequence of both $X$ and $Y$. For example, if $X = \\{a,b,c,b,d,a,b\\}$ and $Y = \\{b,d,c,a,b,a\\}$, the sequence $\\{b,c,a\\}$ is a common subsequence of both $X$ and $Y$. On the other hand, the sequence $\\{b,c,a\\}$ is not a longest common subsequence (LCS) of $X$ and $Y$, since it has length 3 and the sequence $\\{b,c,b,a\\}$, which is also common to both $X$ and $Y$, has length 4. The sequence $\\{b,c,b,a\\}$ is an LCS of $X$ and $Y$, since there is no common subsequence of length 5 or greater.
Write a program which finds the length of LCS of given two sequences $X$ and $Y$. The sequence consists of alphabetical characters.
Constraints
* $1 \leq q \leq 150$
* $1 \leq$ length of $X$ and $Y$ $\leq 1,000$
* $q \leq 20$ if the dataset includes a sequence whose length is more than 100
Input
The input consists of multiple datasets. In the first line, an integer $q$ which is the number of datasets is given. In the following $2 \times q$ lines, each dataset which consists of the two sequences $X$ and $Y$ are given.
Output
For each dataset, print the length of LCS of $X$ and $Y$ in a line.
Example
Input
3
abcbdab
bdcaba
abc
abc
abc
bc
Output
4
3
2 | instruction | 0 | 57,130 | 0 | 114,260 |
"Correct Solution:
```
import sys
def lcs(X, Y):
indices = [0]
for c in Y:
for i in range(len(indices) - 1, -1, -1):
tmp = X.find(c, indices[i])
if tmp + 1:
if i + 1 < len(indices):
indices[i + 1] = min(indices[i + 1], tmp + 1)
else:
indices.append(tmp + 1)
return len(indices) - 1
q = int(input())
for i in range(q):
X = sys.stdin.readline().rstrip('\r\n')
Y = sys.stdin.readline().rstrip('\r\n')
print(lcs(X, Y))
``` | output | 1 | 57,130 | 0 | 114,261 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For given two sequences $X$ and $Y$, a sequence $Z$ is a common subsequence of $X$ and $Y$ if $Z$ is a subsequence of both $X$ and $Y$. For example, if $X = \\{a,b,c,b,d,a,b\\}$ and $Y = \\{b,d,c,a,b,a\\}$, the sequence $\\{b,c,a\\}$ is a common subsequence of both $X$ and $Y$. On the other hand, the sequence $\\{b,c,a\\}$ is not a longest common subsequence (LCS) of $X$ and $Y$, since it has length 3 and the sequence $\\{b,c,b,a\\}$, which is also common to both $X$ and $Y$, has length 4. The sequence $\\{b,c,b,a\\}$ is an LCS of $X$ and $Y$, since there is no common subsequence of length 5 or greater.
Write a program which finds the length of LCS of given two sequences $X$ and $Y$. The sequence consists of alphabetical characters.
Constraints
* $1 \leq q \leq 150$
* $1 \leq$ length of $X$ and $Y$ $\leq 1,000$
* $q \leq 20$ if the dataset includes a sequence whose length is more than 100
Input
The input consists of multiple datasets. In the first line, an integer $q$ which is the number of datasets is given. In the following $2 \times q$ lines, each dataset which consists of the two sequences $X$ and $Y$ are given.
Output
For each dataset, print the length of LCS of $X$ and $Y$ in a line.
Example
Input
3
abcbdab
bdcaba
abc
abc
abc
bc
Output
4
3
2
Submitted Solution:
```
def lcs(s1, s2):
if len(s1) < len(s2):
s1, s2 = s2, s1
dp = []
for s2_k in s2:
#print(dp)
bgn_idx = 0
for i, cur_idx in enumerate(dp):#要素とそのindexを取得
#s2_kをs1のbgn_idx番目以降から探す
chr_idx = s1.find(s2_k, bgn_idx) + 1
#print(s2_k, i, cur_idx, chr_idx, dp)
if not chr_idx:#0だったらTrue#findは見つからないとき - 1を返す
break
dp[i] = min(cur_idx, chr_idx)
#print(dp)
bgn_idx = cur_idx
else:#breakされなければ読み込まれる。
chr_idx = s1.find(s2_k, bgn_idx) + 1
if chr_idx:#0だったらfalse
dp.append(chr_idx)
#print(dp)
return len(dp)
n = int(input())
for _ in range(n):
x = input()
y = input()
print(lcs(x, y))
``` | instruction | 0 | 57,131 | 0 | 114,262 |
Yes | output | 1 | 57,131 | 0 | 114,263 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For given two sequences $X$ and $Y$, a sequence $Z$ is a common subsequence of $X$ and $Y$ if $Z$ is a subsequence of both $X$ and $Y$. For example, if $X = \\{a,b,c,b,d,a,b\\}$ and $Y = \\{b,d,c,a,b,a\\}$, the sequence $\\{b,c,a\\}$ is a common subsequence of both $X$ and $Y$. On the other hand, the sequence $\\{b,c,a\\}$ is not a longest common subsequence (LCS) of $X$ and $Y$, since it has length 3 and the sequence $\\{b,c,b,a\\}$, which is also common to both $X$ and $Y$, has length 4. The sequence $\\{b,c,b,a\\}$ is an LCS of $X$ and $Y$, since there is no common subsequence of length 5 or greater.
Write a program which finds the length of LCS of given two sequences $X$ and $Y$. The sequence consists of alphabetical characters.
Constraints
* $1 \leq q \leq 150$
* $1 \leq$ length of $X$ and $Y$ $\leq 1,000$
* $q \leq 20$ if the dataset includes a sequence whose length is more than 100
Input
The input consists of multiple datasets. In the first line, an integer $q$ which is the number of datasets is given. In the following $2 \times q$ lines, each dataset which consists of the two sequences $X$ and $Y$ are given.
Output
For each dataset, print the length of LCS of $X$ and $Y$ in a line.
Example
Input
3
abcbdab
bdcaba
abc
abc
abc
bc
Output
4
3
2
Submitted Solution:
```
import sys
input = lambda: sys.stdin.readline().rstrip()
def lcs(x, y):
dp = [0 for _ in range(len(y)+1)]
for i in range(len(x)):
tmp = dp[:]
num = x[i]
for j in range(len(y)):
if num == y[j]:
dp[j+1] = tmp[j] + 1
elif dp[j+1] < dp[j]:
dp[j+1] = dp[j]
return dp[-1]
n=int(input())
for _ in range(n):
print(lcs(input(),input()))
``` | instruction | 0 | 57,132 | 0 | 114,264 |
Yes | output | 1 | 57,132 | 0 | 114,265 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For given two sequences $X$ and $Y$, a sequence $Z$ is a common subsequence of $X$ and $Y$ if $Z$ is a subsequence of both $X$ and $Y$. For example, if $X = \\{a,b,c,b,d,a,b\\}$ and $Y = \\{b,d,c,a,b,a\\}$, the sequence $\\{b,c,a\\}$ is a common subsequence of both $X$ and $Y$. On the other hand, the sequence $\\{b,c,a\\}$ is not a longest common subsequence (LCS) of $X$ and $Y$, since it has length 3 and the sequence $\\{b,c,b,a\\}$, which is also common to both $X$ and $Y$, has length 4. The sequence $\\{b,c,b,a\\}$ is an LCS of $X$ and $Y$, since there is no common subsequence of length 5 or greater.
Write a program which finds the length of LCS of given two sequences $X$ and $Y$. The sequence consists of alphabetical characters.
Constraints
* $1 \leq q \leq 150$
* $1 \leq$ length of $X$ and $Y$ $\leq 1,000$
* $q \leq 20$ if the dataset includes a sequence whose length is more than 100
Input
The input consists of multiple datasets. In the first line, an integer $q$ which is the number of datasets is given. In the following $2 \times q$ lines, each dataset which consists of the two sequences $X$ and $Y$ are given.
Output
For each dataset, print the length of LCS of $X$ and $Y$ in a line.
Example
Input
3
abcbdab
bdcaba
abc
abc
abc
bc
Output
4
3
2
Submitted Solution:
```
e=input
a=[]
for _ in[0]*int(e()):
X,z=e(),[]
for y in e():
s=i=0
for k in z:
t=X.find(y,s)+1
if t<1:break
if t<k:z[i]=t
s=k;i+=1
else:
t=X.find(y,s)+1
if t:z+=[t]
a+=[len(z)]
print('\n'.join(map(str,a)))
``` | instruction | 0 | 57,133 | 0 | 114,266 |
Yes | output | 1 | 57,133 | 0 | 114,267 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For given two sequences $X$ and $Y$, a sequence $Z$ is a common subsequence of $X$ and $Y$ if $Z$ is a subsequence of both $X$ and $Y$. For example, if $X = \\{a,b,c,b,d,a,b\\}$ and $Y = \\{b,d,c,a,b,a\\}$, the sequence $\\{b,c,a\\}$ is a common subsequence of both $X$ and $Y$. On the other hand, the sequence $\\{b,c,a\\}$ is not a longest common subsequence (LCS) of $X$ and $Y$, since it has length 3 and the sequence $\\{b,c,b,a\\}$, which is also common to both $X$ and $Y$, has length 4. The sequence $\\{b,c,b,a\\}$ is an LCS of $X$ and $Y$, since there is no common subsequence of length 5 or greater.
Write a program which finds the length of LCS of given two sequences $X$ and $Y$. The sequence consists of alphabetical characters.
Constraints
* $1 \leq q \leq 150$
* $1 \leq$ length of $X$ and $Y$ $\leq 1,000$
* $q \leq 20$ if the dataset includes a sequence whose length is more than 100
Input
The input consists of multiple datasets. In the first line, an integer $q$ which is the number of datasets is given. In the following $2 \times q$ lines, each dataset which consists of the two sequences $X$ and $Y$ are given.
Output
For each dataset, print the length of LCS of $X$ and $Y$ in a line.
Example
Input
3
abcbdab
bdcaba
abc
abc
abc
bc
Output
4
3
2
Submitted Solution:
```
q = int(input())
def lcs(a, b):
# L[i]はa1~ajとb1~bkから長さがi+1の共通部分列が作れるときのjが取りうる最小値とする
L = []
for bk in b:
bgn_idx = 0 # 検索開始位置
for i, cur_idx in enumerate(L):
# bkがbgn_idx以降でaにあれば、そのidx+1かcur_idxの小さい方で更新
chr_idx = a.find(bk, bgn_idx) + 1
if not chr_idx:
break
L[i] = min(cur_idx, chr_idx)
bgn_idx = cur_idx
# 全部まわったということはbkが現在の最長の共通文字列以降にaにあったということ。であれば末尾に追加できる
else:
# bkがbgn_idx以降でaにあれば、そのidx+1をLに追加
chr_idx = a.find(bk, bgn_idx) + 1
if chr_idx:
L.append(chr_idx)
return len(L)
for _ in range(q):
s = input()
t = input()
print(lcs(s, t))
``` | instruction | 0 | 57,134 | 0 | 114,268 |
Yes | output | 1 | 57,134 | 0 | 114,269 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For given two sequences $X$ and $Y$, a sequence $Z$ is a common subsequence of $X$ and $Y$ if $Z$ is a subsequence of both $X$ and $Y$. For example, if $X = \\{a,b,c,b,d,a,b\\}$ and $Y = \\{b,d,c,a,b,a\\}$, the sequence $\\{b,c,a\\}$ is a common subsequence of both $X$ and $Y$. On the other hand, the sequence $\\{b,c,a\\}$ is not a longest common subsequence (LCS) of $X$ and $Y$, since it has length 3 and the sequence $\\{b,c,b,a\\}$, which is also common to both $X$ and $Y$, has length 4. The sequence $\\{b,c,b,a\\}$ is an LCS of $X$ and $Y$, since there is no common subsequence of length 5 or greater.
Write a program which finds the length of LCS of given two sequences $X$ and $Y$. The sequence consists of alphabetical characters.
Constraints
* $1 \leq q \leq 150$
* $1 \leq$ length of $X$ and $Y$ $\leq 1,000$
* $q \leq 20$ if the dataset includes a sequence whose length is more than 100
Input
The input consists of multiple datasets. In the first line, an integer $q$ which is the number of datasets is given. In the following $2 \times q$ lines, each dataset which consists of the two sequences $X$ and $Y$ are given.
Output
For each dataset, print the length of LCS of $X$ and $Y$ in a line.
Example
Input
3
abcbdab
bdcaba
abc
abc
abc
bc
Output
4
3
2
Submitted Solution:
```
def calc_lcs(X, Y):
from array import array
max_lcs = 0
m = len(X)
n = len(Y)
X = ' ' + X
Y = ' ' + Y
c = array('I', [0] * (1001 * 1001))
for i in range(1, m+1):
for j in range(1, n+1):
if X[i] == Y[j]:
c[i*1001 + j] = c[(i-1)*1001 + j - 1] + 1
elif c[(i-1)*1001 + j] >= c[i*1001 + j - 1]:
c[i*1001 + j] = c[(i-1)*1001 + j]
else:
c[i*1001 + j] = c[i*1001 + j - 1]
max_lcs = max(max_lcs, c[i*1001 + j])
return max_lcs
if __name__ == '__main__':
# ??????????????\???
num = int(input())
# f = open('input.txt')
# num = int(f.readline())
for _ in range(num):
X = input()
Y = input()
# X = f.readline().strip()
# Y = f.readline().strip()
# ???????????????
result = calc_lcs(X, Y)
# ???????????¨???
print(result)
``` | instruction | 0 | 57,135 | 0 | 114,270 |
No | output | 1 | 57,135 | 0 | 114,271 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For given two sequences $X$ and $Y$, a sequence $Z$ is a common subsequence of $X$ and $Y$ if $Z$ is a subsequence of both $X$ and $Y$. For example, if $X = \\{a,b,c,b,d,a,b\\}$ and $Y = \\{b,d,c,a,b,a\\}$, the sequence $\\{b,c,a\\}$ is a common subsequence of both $X$ and $Y$. On the other hand, the sequence $\\{b,c,a\\}$ is not a longest common subsequence (LCS) of $X$ and $Y$, since it has length 3 and the sequence $\\{b,c,b,a\\}$, which is also common to both $X$ and $Y$, has length 4. The sequence $\\{b,c,b,a\\}$ is an LCS of $X$ and $Y$, since there is no common subsequence of length 5 or greater.
Write a program which finds the length of LCS of given two sequences $X$ and $Y$. The sequence consists of alphabetical characters.
Constraints
* $1 \leq q \leq 150$
* $1 \leq$ length of $X$ and $Y$ $\leq 1,000$
* $q \leq 20$ if the dataset includes a sequence whose length is more than 100
Input
The input consists of multiple datasets. In the first line, an integer $q$ which is the number of datasets is given. In the following $2 \times q$ lines, each dataset which consists of the two sequences $X$ and $Y$ are given.
Output
For each dataset, print the length of LCS of $X$ and $Y$ in a line.
Example
Input
3
abcbdab
bdcaba
abc
abc
abc
bc
Output
4
3
2
Submitted Solution:
```
from collections import defaultdict
def longest_common_subsequence(s, t):
dp = [[0] * (len(t) + 1) for _ in range(len(s) + 1)]
for i in range(len(s)):
for j in range(len(t)):
if s[i] == t[j]:
dp[i + 1][j + 1] = dp[i][j] + 1
else:
dp[i + 1][j + 1] = max(dp[i + 1][j], dp[i][j + 1])
return dp[-1][-1]
def longest_common_subsequence2(s, t):
dp = [0 for _ in range(len(t) + 1)]
for i in range(len(s)):
tmp = dp[:]
for j in range(len(t)):
if s[i] == t[j]:
dp[j + 1] = tmp[j] + 1
else:
dp[j + 1] = max(dp[j + 1], dp[j])
return dp[-1]
def main():
n = int(input())
for _ in range(n):
X, Y = input(), input()
print(longest_common_subsequence2(X, Y))
if __name__ == '__main__':
main()
``` | instruction | 0 | 57,136 | 0 | 114,272 |
No | output | 1 | 57,136 | 0 | 114,273 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For given two sequences $X$ and $Y$, a sequence $Z$ is a common subsequence of $X$ and $Y$ if $Z$ is a subsequence of both $X$ and $Y$. For example, if $X = \\{a,b,c,b,d,a,b\\}$ and $Y = \\{b,d,c,a,b,a\\}$, the sequence $\\{b,c,a\\}$ is a common subsequence of both $X$ and $Y$. On the other hand, the sequence $\\{b,c,a\\}$ is not a longest common subsequence (LCS) of $X$ and $Y$, since it has length 3 and the sequence $\\{b,c,b,a\\}$, which is also common to both $X$ and $Y$, has length 4. The sequence $\\{b,c,b,a\\}$ is an LCS of $X$ and $Y$, since there is no common subsequence of length 5 or greater.
Write a program which finds the length of LCS of given two sequences $X$ and $Y$. The sequence consists of alphabetical characters.
Constraints
* $1 \leq q \leq 150$
* $1 \leq$ length of $X$ and $Y$ $\leq 1,000$
* $q \leq 20$ if the dataset includes a sequence whose length is more than 100
Input
The input consists of multiple datasets. In the first line, an integer $q$ which is the number of datasets is given. In the following $2 \times q$ lines, each dataset which consists of the two sequences $X$ and $Y$ are given.
Output
For each dataset, print the length of LCS of $X$ and $Y$ in a line.
Example
Input
3
abcbdab
bdcaba
abc
abc
abc
bc
Output
4
3
2
Submitted Solution:
```
# -*- coding: utf-8 -*-
import numpy as np
def lcs_sol(x, y):
n = len(x)
m = len(y)
dp = np.zeros((n + 1) * (m + 1)).reshape(n + 1, m + 1)
for i in range(1, n + 1):
for j in range(1, m + 1):
if x[i - 1] == y[j - 1]:
dp[i][j] = dp[i - 1][j - 1] + 1
else:
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
return dp[n][m]
if __name__ == '__main__':
import sys
q = int(sys.stdin.readline().strip())
for i in range(q):
x = sys.stdin.readline().strip()
y = sys.stdin.readline().strip()
print(lcs_sol(x, y))
``` | instruction | 0 | 57,137 | 0 | 114,274 |
No | output | 1 | 57,137 | 0 | 114,275 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For given two sequences $X$ and $Y$, a sequence $Z$ is a common subsequence of $X$ and $Y$ if $Z$ is a subsequence of both $X$ and $Y$. For example, if $X = \\{a,b,c,b,d,a,b\\}$ and $Y = \\{b,d,c,a,b,a\\}$, the sequence $\\{b,c,a\\}$ is a common subsequence of both $X$ and $Y$. On the other hand, the sequence $\\{b,c,a\\}$ is not a longest common subsequence (LCS) of $X$ and $Y$, since it has length 3 and the sequence $\\{b,c,b,a\\}$, which is also common to both $X$ and $Y$, has length 4. The sequence $\\{b,c,b,a\\}$ is an LCS of $X$ and $Y$, since there is no common subsequence of length 5 or greater.
Write a program which finds the length of LCS of given two sequences $X$ and $Y$. The sequence consists of alphabetical characters.
Constraints
* $1 \leq q \leq 150$
* $1 \leq$ length of $X$ and $Y$ $\leq 1,000$
* $q \leq 20$ if the dataset includes a sequence whose length is more than 100
Input
The input consists of multiple datasets. In the first line, an integer $q$ which is the number of datasets is given. In the following $2 \times q$ lines, each dataset which consists of the two sequences $X$ and $Y$ are given.
Output
For each dataset, print the length of LCS of $X$ and $Y$ in a line.
Example
Input
3
abcbdab
bdcaba
abc
abc
abc
bc
Output
4
3
2
Submitted Solution:
```
def lcs(X,Y):
p=len(X)
q=len(Y)
Z=[[0 for i in range(q+1)]for j in range(p+1)]
for i in range(p):
for j in range(q):
if X[i]==Y[j]:
Z[i+1][j+1]=Z[i][j]+1
else:
if Z[i][j+1]>Z[i+1][j]:
Z[i+1][j+1]=Z[i][j+1]
else:
Z[i+1][j+1]=Z[i+1][j]
print(Z[p][q])
n=int(input())
for i in range(n):
X=input()
Y=input()
lcs(X,Y)
``` | instruction | 0 | 57,138 | 0 | 114,276 |
No | output | 1 | 57,138 | 0 | 114,277 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of n lowercase Latin letters.
Let's define a substring as a contiguous subsegment of a string. For example, "acab" is a substring of "abacaba" (it starts in position 3 and ends in position 6), but "aa" or "d" aren't substrings of this string. So the substring of the string s from position l to position r is s[l; r] = s_l s_{l + 1} ... s_r.
You have to choose exactly one of the substrings of the given string and reverse it (i. e. make s[l; r] = s_r s_{r - 1} ... s_l) to obtain a string that is less lexicographically. Note that it is not necessary to obtain the minimum possible string.
If it is impossible to reverse some substring of the given string to obtain a string that is less, print "NO". Otherwise print "YES" and any suitable substring.
String x is lexicographically less than string y, if either x is a prefix of y (and x ≠ y), or there exists such i (1 ≤ i ≤ min(|x|, |y|)), that x_i < y_i, and for any j (1 ≤ j < i) x_j = y_j. Here |a| denotes the length of the string a. The lexicographic comparison of strings is implemented by operator < in modern programming languages.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the length of s.
The second line of the input contains the string s of length n consisting only of lowercase Latin letters.
Output
If it is impossible to reverse some substring of the given string to obtain a string which is lexicographically less, print "NO". Otherwise print "YES" and two indices l and r (1 ≤ l < r ≤ n) denoting the substring you have to reverse. If there are multiple answers, you can print any.
Examples
Input
7
abacaba
Output
YES
2 5
Input
6
aabcfg
Output
NO
Note
In the first testcase the resulting string is "aacabba". | instruction | 0 | 57,212 | 0 | 114,424 |
Tags: implementation, sortings, strings
Correct Solution:
```
n=int(input())
a=input()
lo,hi=0,0
flag=0
for i in range(n-1):
x=a[i]
y=a[i+1]
if x>y:
flag=1
lo=i+1
hi=i+2
break
if flag==1:
print("YES")
print(lo,hi)
else:
print("NO")
``` | output | 1 | 57,212 | 0 | 114,425 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of n lowercase Latin letters.
Let's define a substring as a contiguous subsegment of a string. For example, "acab" is a substring of "abacaba" (it starts in position 3 and ends in position 6), but "aa" or "d" aren't substrings of this string. So the substring of the string s from position l to position r is s[l; r] = s_l s_{l + 1} ... s_r.
You have to choose exactly one of the substrings of the given string and reverse it (i. e. make s[l; r] = s_r s_{r - 1} ... s_l) to obtain a string that is less lexicographically. Note that it is not necessary to obtain the minimum possible string.
If it is impossible to reverse some substring of the given string to obtain a string that is less, print "NO". Otherwise print "YES" and any suitable substring.
String x is lexicographically less than string y, if either x is a prefix of y (and x ≠ y), or there exists such i (1 ≤ i ≤ min(|x|, |y|)), that x_i < y_i, and for any j (1 ≤ j < i) x_j = y_j. Here |a| denotes the length of the string a. The lexicographic comparison of strings is implemented by operator < in modern programming languages.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the length of s.
The second line of the input contains the string s of length n consisting only of lowercase Latin letters.
Output
If it is impossible to reverse some substring of the given string to obtain a string which is lexicographically less, print "NO". Otherwise print "YES" and two indices l and r (1 ≤ l < r ≤ n) denoting the substring you have to reverse. If there are multiple answers, you can print any.
Examples
Input
7
abacaba
Output
YES
2 5
Input
6
aabcfg
Output
NO
Note
In the first testcase the resulting string is "aacabba". | instruction | 0 | 57,213 | 0 | 114,426 |
Tags: implementation, sortings, strings
Correct Solution:
```
n = int(input())
s = input()
for i in range(0, n-1):
if s[i+1] < s[i]:
print('YES')
print(i+1, i + 2)
exit(0)
print('NO')
``` | output | 1 | 57,213 | 0 | 114,427 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of n lowercase Latin letters.
Let's define a substring as a contiguous subsegment of a string. For example, "acab" is a substring of "abacaba" (it starts in position 3 and ends in position 6), but "aa" or "d" aren't substrings of this string. So the substring of the string s from position l to position r is s[l; r] = s_l s_{l + 1} ... s_r.
You have to choose exactly one of the substrings of the given string and reverse it (i. e. make s[l; r] = s_r s_{r - 1} ... s_l) to obtain a string that is less lexicographically. Note that it is not necessary to obtain the minimum possible string.
If it is impossible to reverse some substring of the given string to obtain a string that is less, print "NO". Otherwise print "YES" and any suitable substring.
String x is lexicographically less than string y, if either x is a prefix of y (and x ≠ y), or there exists such i (1 ≤ i ≤ min(|x|, |y|)), that x_i < y_i, and for any j (1 ≤ j < i) x_j = y_j. Here |a| denotes the length of the string a. The lexicographic comparison of strings is implemented by operator < in modern programming languages.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the length of s.
The second line of the input contains the string s of length n consisting only of lowercase Latin letters.
Output
If it is impossible to reverse some substring of the given string to obtain a string which is lexicographically less, print "NO". Otherwise print "YES" and two indices l and r (1 ≤ l < r ≤ n) denoting the substring you have to reverse. If there are multiple answers, you can print any.
Examples
Input
7
abacaba
Output
YES
2 5
Input
6
aabcfg
Output
NO
Note
In the first testcase the resulting string is "aacabba". | instruction | 0 | 57,214 | 0 | 114,428 |
Tags: implementation, sortings, strings
Correct Solution:
```
input()
a=input()
r=-1
for i,x in enumerate(zip(a,a[1:])):
if x[0]>x[1]:r=i+1
print([f'YES\n{r} {r+1}','NO'][r<0])
``` | output | 1 | 57,214 | 0 | 114,429 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of n lowercase Latin letters.
Let's define a substring as a contiguous subsegment of a string. For example, "acab" is a substring of "abacaba" (it starts in position 3 and ends in position 6), but "aa" or "d" aren't substrings of this string. So the substring of the string s from position l to position r is s[l; r] = s_l s_{l + 1} ... s_r.
You have to choose exactly one of the substrings of the given string and reverse it (i. e. make s[l; r] = s_r s_{r - 1} ... s_l) to obtain a string that is less lexicographically. Note that it is not necessary to obtain the minimum possible string.
If it is impossible to reverse some substring of the given string to obtain a string that is less, print "NO". Otherwise print "YES" and any suitable substring.
String x is lexicographically less than string y, if either x is a prefix of y (and x ≠ y), or there exists such i (1 ≤ i ≤ min(|x|, |y|)), that x_i < y_i, and for any j (1 ≤ j < i) x_j = y_j. Here |a| denotes the length of the string a. The lexicographic comparison of strings is implemented by operator < in modern programming languages.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the length of s.
The second line of the input contains the string s of length n consisting only of lowercase Latin letters.
Output
If it is impossible to reverse some substring of the given string to obtain a string which is lexicographically less, print "NO". Otherwise print "YES" and two indices l and r (1 ≤ l < r ≤ n) denoting the substring you have to reverse. If there are multiple answers, you can print any.
Examples
Input
7
abacaba
Output
YES
2 5
Input
6
aabcfg
Output
NO
Note
In the first testcase the resulting string is "aacabba". | instruction | 0 | 57,215 | 0 | 114,430 |
Tags: implementation, sortings, strings
Correct Solution:
```
def main():
from sys import stdin, stdout
n = int(stdin.readline().rstrip())
s = stdin.readline().rstrip()
flag = True
for i in range(n - 1):
if s[i] <= s[i + 1]:
continue
else:
stdout.write("YES\n" + str(i + 1) + " " + str(i + 2) + "\n")
flag = False
return
if flag == True:
stdout.write("NO\n")
return
for i in range(n):
for j in range(n - 1, i, -1):
#stdout.write(s[i:j] + " " + sr + "\n")
if s[i] > s[j]:
#stdout.write(sr + "\n" + s[i:j] + "\n")
stdout.write("YES\n" + str(i + 1) + " " + str(j + 1) + "\n")
return
stdout.write("NO\n")
if __name__ == "__main__":
main()
``` | output | 1 | 57,215 | 0 | 114,431 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of n lowercase Latin letters.
Let's define a substring as a contiguous subsegment of a string. For example, "acab" is a substring of "abacaba" (it starts in position 3 and ends in position 6), but "aa" or "d" aren't substrings of this string. So the substring of the string s from position l to position r is s[l; r] = s_l s_{l + 1} ... s_r.
You have to choose exactly one of the substrings of the given string and reverse it (i. e. make s[l; r] = s_r s_{r - 1} ... s_l) to obtain a string that is less lexicographically. Note that it is not necessary to obtain the minimum possible string.
If it is impossible to reverse some substring of the given string to obtain a string that is less, print "NO". Otherwise print "YES" and any suitable substring.
String x is lexicographically less than string y, if either x is a prefix of y (and x ≠ y), or there exists such i (1 ≤ i ≤ min(|x|, |y|)), that x_i < y_i, and for any j (1 ≤ j < i) x_j = y_j. Here |a| denotes the length of the string a. The lexicographic comparison of strings is implemented by operator < in modern programming languages.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the length of s.
The second line of the input contains the string s of length n consisting only of lowercase Latin letters.
Output
If it is impossible to reverse some substring of the given string to obtain a string which is lexicographically less, print "NO". Otherwise print "YES" and two indices l and r (1 ≤ l < r ≤ n) denoting the substring you have to reverse. If there are multiple answers, you can print any.
Examples
Input
7
abacaba
Output
YES
2 5
Input
6
aabcfg
Output
NO
Note
In the first testcase the resulting string is "aacabba". | instruction | 0 | 57,216 | 0 | 114,432 |
Tags: implementation, sortings, strings
Correct Solution:
```
n = int(input())
s = input()
flag = False
#start, stop = -1
for i in range(n-1):
if s[i]>s[i+1]:
flag = True
print("YES")
print(i+1, i+2)
break
if not flag:
print("NO")
``` | output | 1 | 57,216 | 0 | 114,433 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of n lowercase Latin letters.
Let's define a substring as a contiguous subsegment of a string. For example, "acab" is a substring of "abacaba" (it starts in position 3 and ends in position 6), but "aa" or "d" aren't substrings of this string. So the substring of the string s from position l to position r is s[l; r] = s_l s_{l + 1} ... s_r.
You have to choose exactly one of the substrings of the given string and reverse it (i. e. make s[l; r] = s_r s_{r - 1} ... s_l) to obtain a string that is less lexicographically. Note that it is not necessary to obtain the minimum possible string.
If it is impossible to reverse some substring of the given string to obtain a string that is less, print "NO". Otherwise print "YES" and any suitable substring.
String x is lexicographically less than string y, if either x is a prefix of y (and x ≠ y), or there exists such i (1 ≤ i ≤ min(|x|, |y|)), that x_i < y_i, and for any j (1 ≤ j < i) x_j = y_j. Here |a| denotes the length of the string a. The lexicographic comparison of strings is implemented by operator < in modern programming languages.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the length of s.
The second line of the input contains the string s of length n consisting only of lowercase Latin letters.
Output
If it is impossible to reverse some substring of the given string to obtain a string which is lexicographically less, print "NO". Otherwise print "YES" and two indices l and r (1 ≤ l < r ≤ n) denoting the substring you have to reverse. If there are multiple answers, you can print any.
Examples
Input
7
abacaba
Output
YES
2 5
Input
6
aabcfg
Output
NO
Note
In the first testcase the resulting string is "aacabba". | instruction | 0 | 57,217 | 0 | 114,434 |
Tags: implementation, sortings, strings
Correct Solution:
```
n = int(input())
s = input()
i = 0
while i < n - 1 and s[i] <= s[i + 1]:
i += 1
if i == n - 1:
print('NO')
else:
print('YES')
print('{} {}'.format(i + 1, i + 2))
``` | output | 1 | 57,217 | 0 | 114,435 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of n lowercase Latin letters.
Let's define a substring as a contiguous subsegment of a string. For example, "acab" is a substring of "abacaba" (it starts in position 3 and ends in position 6), but "aa" or "d" aren't substrings of this string. So the substring of the string s from position l to position r is s[l; r] = s_l s_{l + 1} ... s_r.
You have to choose exactly one of the substrings of the given string and reverse it (i. e. make s[l; r] = s_r s_{r - 1} ... s_l) to obtain a string that is less lexicographically. Note that it is not necessary to obtain the minimum possible string.
If it is impossible to reverse some substring of the given string to obtain a string that is less, print "NO". Otherwise print "YES" and any suitable substring.
String x is lexicographically less than string y, if either x is a prefix of y (and x ≠ y), or there exists such i (1 ≤ i ≤ min(|x|, |y|)), that x_i < y_i, and for any j (1 ≤ j < i) x_j = y_j. Here |a| denotes the length of the string a. The lexicographic comparison of strings is implemented by operator < in modern programming languages.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the length of s.
The second line of the input contains the string s of length n consisting only of lowercase Latin letters.
Output
If it is impossible to reverse some substring of the given string to obtain a string which is lexicographically less, print "NO". Otherwise print "YES" and two indices l and r (1 ≤ l < r ≤ n) denoting the substring you have to reverse. If there are multiple answers, you can print any.
Examples
Input
7
abacaba
Output
YES
2 5
Input
6
aabcfg
Output
NO
Note
In the first testcase the resulting string is "aacabba". | instruction | 0 | 57,218 | 0 | 114,436 |
Tags: implementation, sortings, strings
Correct Solution:
```
n=int(input())
a=str(input())
c=ord(a[0])
for i in range(1,n):
if c<=ord(a[i]):
c=ord(a[i])
else:
print("YES")
print(i,i+1)
exit()
print("NO")
``` | output | 1 | 57,218 | 0 | 114,437 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s consisting of n lowercase Latin letters.
Let's define a substring as a contiguous subsegment of a string. For example, "acab" is a substring of "abacaba" (it starts in position 3 and ends in position 6), but "aa" or "d" aren't substrings of this string. So the substring of the string s from position l to position r is s[l; r] = s_l s_{l + 1} ... s_r.
You have to choose exactly one of the substrings of the given string and reverse it (i. e. make s[l; r] = s_r s_{r - 1} ... s_l) to obtain a string that is less lexicographically. Note that it is not necessary to obtain the minimum possible string.
If it is impossible to reverse some substring of the given string to obtain a string that is less, print "NO". Otherwise print "YES" and any suitable substring.
String x is lexicographically less than string y, if either x is a prefix of y (and x ≠ y), or there exists such i (1 ≤ i ≤ min(|x|, |y|)), that x_i < y_i, and for any j (1 ≤ j < i) x_j = y_j. Here |a| denotes the length of the string a. The lexicographic comparison of strings is implemented by operator < in modern programming languages.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the length of s.
The second line of the input contains the string s of length n consisting only of lowercase Latin letters.
Output
If it is impossible to reverse some substring of the given string to obtain a string which is lexicographically less, print "NO". Otherwise print "YES" and two indices l and r (1 ≤ l < r ≤ n) denoting the substring you have to reverse. If there are multiple answers, you can print any.
Examples
Input
7
abacaba
Output
YES
2 5
Input
6
aabcfg
Output
NO
Note
In the first testcase the resulting string is "aacabba". | instruction | 0 | 57,219 | 0 | 114,438 |
Tags: implementation, sortings, strings
Correct Solution:
```
n = int(input())
string = input()
flag = 0
for i in range(0,n-1):
if string[i] > string[i+1]:
flag = 1
print("YES")
print(i+1,i+2)
break
if flag == 0:
print("NO")
``` | output | 1 | 57,219 | 0 | 114,439 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of n lowercase Latin letters.
Let's define a substring as a contiguous subsegment of a string. For example, "acab" is a substring of "abacaba" (it starts in position 3 and ends in position 6), but "aa" or "d" aren't substrings of this string. So the substring of the string s from position l to position r is s[l; r] = s_l s_{l + 1} ... s_r.
You have to choose exactly one of the substrings of the given string and reverse it (i. e. make s[l; r] = s_r s_{r - 1} ... s_l) to obtain a string that is less lexicographically. Note that it is not necessary to obtain the minimum possible string.
If it is impossible to reverse some substring of the given string to obtain a string that is less, print "NO". Otherwise print "YES" and any suitable substring.
String x is lexicographically less than string y, if either x is a prefix of y (and x ≠ y), or there exists such i (1 ≤ i ≤ min(|x|, |y|)), that x_i < y_i, and for any j (1 ≤ j < i) x_j = y_j. Here |a| denotes the length of the string a. The lexicographic comparison of strings is implemented by operator < in modern programming languages.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the length of s.
The second line of the input contains the string s of length n consisting only of lowercase Latin letters.
Output
If it is impossible to reverse some substring of the given string to obtain a string which is lexicographically less, print "NO". Otherwise print "YES" and two indices l and r (1 ≤ l < r ≤ n) denoting the substring you have to reverse. If there are multiple answers, you can print any.
Examples
Input
7
abacaba
Output
YES
2 5
Input
6
aabcfg
Output
NO
Note
In the first testcase the resulting string is "aacabba".
Submitted Solution:
```
input()
word1 = input()
def str_reverse(word):
for idx, letter in enumerate(word):
if idx != len(word) - 1:
if word[idx] > word[idx + 1]:
print('YES')
print(idx + 1, idx + 2)
return
print('NO')
(str_reverse(word1))
``` | instruction | 0 | 57,220 | 0 | 114,440 |
Yes | output | 1 | 57,220 | 0 | 114,441 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of n lowercase Latin letters.
Let's define a substring as a contiguous subsegment of a string. For example, "acab" is a substring of "abacaba" (it starts in position 3 and ends in position 6), but "aa" or "d" aren't substrings of this string. So the substring of the string s from position l to position r is s[l; r] = s_l s_{l + 1} ... s_r.
You have to choose exactly one of the substrings of the given string and reverse it (i. e. make s[l; r] = s_r s_{r - 1} ... s_l) to obtain a string that is less lexicographically. Note that it is not necessary to obtain the minimum possible string.
If it is impossible to reverse some substring of the given string to obtain a string that is less, print "NO". Otherwise print "YES" and any suitable substring.
String x is lexicographically less than string y, if either x is a prefix of y (and x ≠ y), or there exists such i (1 ≤ i ≤ min(|x|, |y|)), that x_i < y_i, and for any j (1 ≤ j < i) x_j = y_j. Here |a| denotes the length of the string a. The lexicographic comparison of strings is implemented by operator < in modern programming languages.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the length of s.
The second line of the input contains the string s of length n consisting only of lowercase Latin letters.
Output
If it is impossible to reverse some substring of the given string to obtain a string which is lexicographically less, print "NO". Otherwise print "YES" and two indices l and r (1 ≤ l < r ≤ n) denoting the substring you have to reverse. If there are multiple answers, you can print any.
Examples
Input
7
abacaba
Output
YES
2 5
Input
6
aabcfg
Output
NO
Note
In the first testcase the resulting string is "aacabba".
Submitted Solution:
```
n = int(input())
l = list(input())
cnt = [0] * 26
cnt[ord(l[0]) - 97] = 1
st = -1
for i in range(1, n):
cnt[ord(l[i]) - 97] = 1
for j in range(ord(l[i]) - 97 + 1, 26):
if cnt[j] == 1:
st = i
if st == -1:
print('NO')
exit()
print('YES')
rev = -2
for i in range(st):
if l[i] > l[st]:
rev = i
break
print(rev + 1, st + 1)
``` | instruction | 0 | 57,221 | 0 | 114,442 |
Yes | output | 1 | 57,221 | 0 | 114,443 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of n lowercase Latin letters.
Let's define a substring as a contiguous subsegment of a string. For example, "acab" is a substring of "abacaba" (it starts in position 3 and ends in position 6), but "aa" or "d" aren't substrings of this string. So the substring of the string s from position l to position r is s[l; r] = s_l s_{l + 1} ... s_r.
You have to choose exactly one of the substrings of the given string and reverse it (i. e. make s[l; r] = s_r s_{r - 1} ... s_l) to obtain a string that is less lexicographically. Note that it is not necessary to obtain the minimum possible string.
If it is impossible to reverse some substring of the given string to obtain a string that is less, print "NO". Otherwise print "YES" and any suitable substring.
String x is lexicographically less than string y, if either x is a prefix of y (and x ≠ y), or there exists such i (1 ≤ i ≤ min(|x|, |y|)), that x_i < y_i, and for any j (1 ≤ j < i) x_j = y_j. Here |a| denotes the length of the string a. The lexicographic comparison of strings is implemented by operator < in modern programming languages.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the length of s.
The second line of the input contains the string s of length n consisting only of lowercase Latin letters.
Output
If it is impossible to reverse some substring of the given string to obtain a string which is lexicographically less, print "NO". Otherwise print "YES" and two indices l and r (1 ≤ l < r ≤ n) denoting the substring you have to reverse. If there are multiple answers, you can print any.
Examples
Input
7
abacaba
Output
YES
2 5
Input
6
aabcfg
Output
NO
Note
In the first testcase the resulting string is "aacabba".
Submitted Solution:
```
n = int(input())
a = list(input())
work = False
l,r = 0,0
l = 1
lv = ord(a[0])
for i in range(1,len(a)):
if ord(a[i])>=lv:
lv = ord(a[i])
l = i+1
else:
r = i+1
work = True
break
if work:
print("YES")
print(l,r)
else:
print("NO")
``` | instruction | 0 | 57,222 | 0 | 114,444 |
Yes | output | 1 | 57,222 | 0 | 114,445 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of n lowercase Latin letters.
Let's define a substring as a contiguous subsegment of a string. For example, "acab" is a substring of "abacaba" (it starts in position 3 and ends in position 6), but "aa" or "d" aren't substrings of this string. So the substring of the string s from position l to position r is s[l; r] = s_l s_{l + 1} ... s_r.
You have to choose exactly one of the substrings of the given string and reverse it (i. e. make s[l; r] = s_r s_{r - 1} ... s_l) to obtain a string that is less lexicographically. Note that it is not necessary to obtain the minimum possible string.
If it is impossible to reverse some substring of the given string to obtain a string that is less, print "NO". Otherwise print "YES" and any suitable substring.
String x is lexicographically less than string y, if either x is a prefix of y (and x ≠ y), or there exists such i (1 ≤ i ≤ min(|x|, |y|)), that x_i < y_i, and for any j (1 ≤ j < i) x_j = y_j. Here |a| denotes the length of the string a. The lexicographic comparison of strings is implemented by operator < in modern programming languages.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the length of s.
The second line of the input contains the string s of length n consisting only of lowercase Latin letters.
Output
If it is impossible to reverse some substring of the given string to obtain a string which is lexicographically less, print "NO". Otherwise print "YES" and two indices l and r (1 ≤ l < r ≤ n) denoting the substring you have to reverse. If there are multiple answers, you can print any.
Examples
Input
7
abacaba
Output
YES
2 5
Input
6
aabcfg
Output
NO
Note
In the first testcase the resulting string is "aacabba".
Submitted Solution:
```
n=int(input())
s=input()
fl=0
for i in range(n-1):
if s[i]>s[i+1]:
print('YES')
print(i+1, i + 2)
fl=1
break
if not fl: print('NO')
``` | instruction | 0 | 57,223 | 0 | 114,446 |
Yes | output | 1 | 57,223 | 0 | 114,447 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of n lowercase Latin letters.
Let's define a substring as a contiguous subsegment of a string. For example, "acab" is a substring of "abacaba" (it starts in position 3 and ends in position 6), but "aa" or "d" aren't substrings of this string. So the substring of the string s from position l to position r is s[l; r] = s_l s_{l + 1} ... s_r.
You have to choose exactly one of the substrings of the given string and reverse it (i. e. make s[l; r] = s_r s_{r - 1} ... s_l) to obtain a string that is less lexicographically. Note that it is not necessary to obtain the minimum possible string.
If it is impossible to reverse some substring of the given string to obtain a string that is less, print "NO". Otherwise print "YES" and any suitable substring.
String x is lexicographically less than string y, if either x is a prefix of y (and x ≠ y), or there exists such i (1 ≤ i ≤ min(|x|, |y|)), that x_i < y_i, and for any j (1 ≤ j < i) x_j = y_j. Here |a| denotes the length of the string a. The lexicographic comparison of strings is implemented by operator < in modern programming languages.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the length of s.
The second line of the input contains the string s of length n consisting only of lowercase Latin letters.
Output
If it is impossible to reverse some substring of the given string to obtain a string which is lexicographically less, print "NO". Otherwise print "YES" and two indices l and r (1 ≤ l < r ≤ n) denoting the substring you have to reverse. If there are multiple answers, you can print any.
Examples
Input
7
abacaba
Output
YES
2 5
Input
6
aabcfg
Output
NO
Note
In the first testcase the resulting string is "aacabba".
Submitted Solution:
```
n, a = int(input()), input()
for i in range(n - 1):
if a[i] > a[i + 1]:
exit(print('YES', i + 1, i + 1))
print('NO')
``` | instruction | 0 | 57,224 | 0 | 114,448 |
No | output | 1 | 57,224 | 0 | 114,449 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of n lowercase Latin letters.
Let's define a substring as a contiguous subsegment of a string. For example, "acab" is a substring of "abacaba" (it starts in position 3 and ends in position 6), but "aa" or "d" aren't substrings of this string. So the substring of the string s from position l to position r is s[l; r] = s_l s_{l + 1} ... s_r.
You have to choose exactly one of the substrings of the given string and reverse it (i. e. make s[l; r] = s_r s_{r - 1} ... s_l) to obtain a string that is less lexicographically. Note that it is not necessary to obtain the minimum possible string.
If it is impossible to reverse some substring of the given string to obtain a string that is less, print "NO". Otherwise print "YES" and any suitable substring.
String x is lexicographically less than string y, if either x is a prefix of y (and x ≠ y), or there exists such i (1 ≤ i ≤ min(|x|, |y|)), that x_i < y_i, and for any j (1 ≤ j < i) x_j = y_j. Here |a| denotes the length of the string a. The lexicographic comparison of strings is implemented by operator < in modern programming languages.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the length of s.
The second line of the input contains the string s of length n consisting only of lowercase Latin letters.
Output
If it is impossible to reverse some substring of the given string to obtain a string which is lexicographically less, print "NO". Otherwise print "YES" and two indices l and r (1 ≤ l < r ≤ n) denoting the substring you have to reverse. If there are multiple answers, you can print any.
Examples
Input
7
abacaba
Output
YES
2 5
Input
6
aabcfg
Output
NO
Note
In the first testcase the resulting string is "aacabba".
Submitted Solution:
```
n = int(input())
s = list((input()))
v = list(sorted(s))
if s == v:
print('NO')
exit()
print('YES')
for i in range(0, n - 1):
if s[i] != v[i]:
for j in range(i, n - 1):
if v[i] == s[j]:
print(i + 1, j + 1)
exit()
# UBCF
# CodeForcesian
# ♥
# تفففففف
``` | instruction | 0 | 57,225 | 0 | 114,450 |
No | output | 1 | 57,225 | 0 | 114,451 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of n lowercase Latin letters.
Let's define a substring as a contiguous subsegment of a string. For example, "acab" is a substring of "abacaba" (it starts in position 3 and ends in position 6), but "aa" or "d" aren't substrings of this string. So the substring of the string s from position l to position r is s[l; r] = s_l s_{l + 1} ... s_r.
You have to choose exactly one of the substrings of the given string and reverse it (i. e. make s[l; r] = s_r s_{r - 1} ... s_l) to obtain a string that is less lexicographically. Note that it is not necessary to obtain the minimum possible string.
If it is impossible to reverse some substring of the given string to obtain a string that is less, print "NO". Otherwise print "YES" and any suitable substring.
String x is lexicographically less than string y, if either x is a prefix of y (and x ≠ y), or there exists such i (1 ≤ i ≤ min(|x|, |y|)), that x_i < y_i, and for any j (1 ≤ j < i) x_j = y_j. Here |a| denotes the length of the string a. The lexicographic comparison of strings is implemented by operator < in modern programming languages.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the length of s.
The second line of the input contains the string s of length n consisting only of lowercase Latin letters.
Output
If it is impossible to reverse some substring of the given string to obtain a string which is lexicographically less, print "NO". Otherwise print "YES" and two indices l and r (1 ≤ l < r ≤ n) denoting the substring you have to reverse. If there are multiple answers, you can print any.
Examples
Input
7
abacaba
Output
YES
2 5
Input
6
aabcfg
Output
NO
Note
In the first testcase the resulting string is "aacabba".
Submitted Solution:
```
_ = input()
x = input()
start = 0
for i,ch in enumerate(x):
if i == 0: continue
if x[start] > ch:
print("YES")
print(start, i)
break
if ch > x[start]: start = i
else:
print("NO")
``` | instruction | 0 | 57,226 | 0 | 114,452 |
No | output | 1 | 57,226 | 0 | 114,453 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s consisting of n lowercase Latin letters.
Let's define a substring as a contiguous subsegment of a string. For example, "acab" is a substring of "abacaba" (it starts in position 3 and ends in position 6), but "aa" or "d" aren't substrings of this string. So the substring of the string s from position l to position r is s[l; r] = s_l s_{l + 1} ... s_r.
You have to choose exactly one of the substrings of the given string and reverse it (i. e. make s[l; r] = s_r s_{r - 1} ... s_l) to obtain a string that is less lexicographically. Note that it is not necessary to obtain the minimum possible string.
If it is impossible to reverse some substring of the given string to obtain a string that is less, print "NO". Otherwise print "YES" and any suitable substring.
String x is lexicographically less than string y, if either x is a prefix of y (and x ≠ y), or there exists such i (1 ≤ i ≤ min(|x|, |y|)), that x_i < y_i, and for any j (1 ≤ j < i) x_j = y_j. Here |a| denotes the length of the string a. The lexicographic comparison of strings is implemented by operator < in modern programming languages.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the length of s.
The second line of the input contains the string s of length n consisting only of lowercase Latin letters.
Output
If it is impossible to reverse some substring of the given string to obtain a string which is lexicographically less, print "NO". Otherwise print "YES" and two indices l and r (1 ≤ l < r ≤ n) denoting the substring you have to reverse. If there are multiple answers, you can print any.
Examples
Input
7
abacaba
Output
YES
2 5
Input
6
aabcfg
Output
NO
Note
In the first testcase the resulting string is "aacabba".
Submitted Solution:
```
n = int(input())
s = input()
for i in range(n-1):
if s[i] > s[i+1]:
print("YES")
print(i+1, i+2)
else:
print("NO")
``` | instruction | 0 | 57,227 | 0 | 114,454 |
No | output | 1 | 57,227 | 0 | 114,455 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A string is called a k-string if it can be represented as k concatenated copies of some string. For example, the string "aabaabaabaab" is at the same time a 1-string, a 2-string and a 4-string, but it is not a 3-string, a 5-string, or a 6-string and so on. Obviously any string is a 1-string.
You are given a string s, consisting of lowercase English letters and a positive integer k. Your task is to reorder the letters in the string s in such a way that the resulting string is a k-string.
Input
The first input line contains integer k (1 ≤ k ≤ 1000). The second line contains s, all characters in s are lowercase English letters. The string length s satisfies the inequality 1 ≤ |s| ≤ 1000, where |s| is the length of string s.
Output
Rearrange the letters in string s in such a way that the result is a k-string. Print the result on a single output line. If there are multiple solutions, print any of them.
If the solution doesn't exist, print "-1" (without quotes).
Examples
Input
2
aazz
Output
azaz
Input
3
abcabcabz
Output
-1 | instruction | 0 | 57,364 | 0 | 114,728 |
Tags: implementation, strings
Correct Solution:
```
k = int(input())
def f(s):
a=''
for i in set(s):
if s.count(i)%k:
return False
else:
a+=s.count(i)//k*i
return a
s=f(input())
print(s*k if s else -1)
``` | output | 1 | 57,364 | 0 | 114,729 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A string is called a k-string if it can be represented as k concatenated copies of some string. For example, the string "aabaabaabaab" is at the same time a 1-string, a 2-string and a 4-string, but it is not a 3-string, a 5-string, or a 6-string and so on. Obviously any string is a 1-string.
You are given a string s, consisting of lowercase English letters and a positive integer k. Your task is to reorder the letters in the string s in such a way that the resulting string is a k-string.
Input
The first input line contains integer k (1 ≤ k ≤ 1000). The second line contains s, all characters in s are lowercase English letters. The string length s satisfies the inequality 1 ≤ |s| ≤ 1000, where |s| is the length of string s.
Output
Rearrange the letters in string s in such a way that the result is a k-string. Print the result on a single output line. If there are multiple solutions, print any of them.
If the solution doesn't exist, print "-1" (without quotes).
Examples
Input
2
aazz
Output
azaz
Input
3
abcabcabz
Output
-1 | instruction | 0 | 57,365 | 0 | 114,730 |
Tags: implementation, strings
Correct Solution:
```
track = dict()
k = int(input())
s = input()
for i in s:
if not (i in track.keys()):
track[i] = 0
track[i] += 1
poss = True
for i in track.keys():
if(track[i] % k != 0):
poss = False
print(-1)
break
if(poss):
sub = ""
for i in track.keys():
sub += i * int(track[i]/k)
print(sub * k)
``` | output | 1 | 57,365 | 0 | 114,731 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A string is called a k-string if it can be represented as k concatenated copies of some string. For example, the string "aabaabaabaab" is at the same time a 1-string, a 2-string and a 4-string, but it is not a 3-string, a 5-string, or a 6-string and so on. Obviously any string is a 1-string.
You are given a string s, consisting of lowercase English letters and a positive integer k. Your task is to reorder the letters in the string s in such a way that the resulting string is a k-string.
Input
The first input line contains integer k (1 ≤ k ≤ 1000). The second line contains s, all characters in s are lowercase English letters. The string length s satisfies the inequality 1 ≤ |s| ≤ 1000, where |s| is the length of string s.
Output
Rearrange the letters in string s in such a way that the result is a k-string. Print the result on a single output line. If there are multiple solutions, print any of them.
If the solution doesn't exist, print "-1" (without quotes).
Examples
Input
2
aazz
Output
azaz
Input
3
abcabcabz
Output
-1 | instruction | 0 | 57,366 | 0 | 114,732 |
Tags: implementation, strings
Correct Solution:
```
k=int(input())
string=input()
size=len(string)//k
if len(string)%k!=0:
print(-1)
exit()
dict={}
for c in string:
dict[c]=string.count(c)
ans=sum([x//k for x in dict.values()])
List=dict.keys()
y="".join(x*(dict[x]//k) for x in List)
if ans==size:
print(y*k)
else:
print(-1)
``` | output | 1 | 57,366 | 0 | 114,733 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A string is called a k-string if it can be represented as k concatenated copies of some string. For example, the string "aabaabaabaab" is at the same time a 1-string, a 2-string and a 4-string, but it is not a 3-string, a 5-string, or a 6-string and so on. Obviously any string is a 1-string.
You are given a string s, consisting of lowercase English letters and a positive integer k. Your task is to reorder the letters in the string s in such a way that the resulting string is a k-string.
Input
The first input line contains integer k (1 ≤ k ≤ 1000). The second line contains s, all characters in s are lowercase English letters. The string length s satisfies the inequality 1 ≤ |s| ≤ 1000, where |s| is the length of string s.
Output
Rearrange the letters in string s in such a way that the result is a k-string. Print the result on a single output line. If there are multiple solutions, print any of them.
If the solution doesn't exist, print "-1" (without quotes).
Examples
Input
2
aazz
Output
azaz
Input
3
abcabcabz
Output
-1 | instruction | 0 | 57,367 | 0 | 114,734 |
Tags: implementation, strings
Correct Solution:
```
import sys
k=int(input())
s=list(input())
count=[0]*26
n=len(s)
ans=''
for i in range(n):
count[ord(s[i])-97]+=1
for i in range(26):
if count[i]%k!=0:
print(-1)
sys.exit()
else:
ans+=chr(i+97)*(count[i]//k)
print(ans*k)
``` | output | 1 | 57,367 | 0 | 114,735 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A string is called a k-string if it can be represented as k concatenated copies of some string. For example, the string "aabaabaabaab" is at the same time a 1-string, a 2-string and a 4-string, but it is not a 3-string, a 5-string, or a 6-string and so on. Obviously any string is a 1-string.
You are given a string s, consisting of lowercase English letters and a positive integer k. Your task is to reorder the letters in the string s in such a way that the resulting string is a k-string.
Input
The first input line contains integer k (1 ≤ k ≤ 1000). The second line contains s, all characters in s are lowercase English letters. The string length s satisfies the inequality 1 ≤ |s| ≤ 1000, where |s| is the length of string s.
Output
Rearrange the letters in string s in such a way that the result is a k-string. Print the result on a single output line. If there are multiple solutions, print any of them.
If the solution doesn't exist, print "-1" (without quotes).
Examples
Input
2
aazz
Output
azaz
Input
3
abcabcabz
Output
-1 | instruction | 0 | 57,368 | 0 | 114,736 |
Tags: implementation, strings
Correct Solution:
```
k = int(input())
s = input()
chars = "".join(set(s))
kstring = ""
for i in chars:
if s.count(i) % k != 0:
kstring = -1
break
kstring += i * (s.count(i) // k)
if kstring == -1:
print(kstring)
else:
print(kstring * k)
``` | output | 1 | 57,368 | 0 | 114,737 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A string is called a k-string if it can be represented as k concatenated copies of some string. For example, the string "aabaabaabaab" is at the same time a 1-string, a 2-string and a 4-string, but it is not a 3-string, a 5-string, or a 6-string and so on. Obviously any string is a 1-string.
You are given a string s, consisting of lowercase English letters and a positive integer k. Your task is to reorder the letters in the string s in such a way that the resulting string is a k-string.
Input
The first input line contains integer k (1 ≤ k ≤ 1000). The second line contains s, all characters in s are lowercase English letters. The string length s satisfies the inequality 1 ≤ |s| ≤ 1000, where |s| is the length of string s.
Output
Rearrange the letters in string s in such a way that the result is a k-string. Print the result on a single output line. If there are multiple solutions, print any of them.
If the solution doesn't exist, print "-1" (without quotes).
Examples
Input
2
aazz
Output
azaz
Input
3
abcabcabz
Output
-1 | instruction | 0 | 57,369 | 0 | 114,738 |
Tags: implementation, strings
Correct Solution:
```
k=int(input())
s=input()
l=list(s)
x=sorted(list(set(map(str,l))))
c=0
ct=[]
for i in range(len(x)):
ct.append(l.count(x[i]))
if (l.count(x[i]))%k==0:
c+=1
if c==len(x):
r=""
for i in range(len(x)):
r+= x[i]*((ct[i])//k)
print(r*k)
else:
print(-1)
``` | output | 1 | 57,369 | 0 | 114,739 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A string is called a k-string if it can be represented as k concatenated copies of some string. For example, the string "aabaabaabaab" is at the same time a 1-string, a 2-string and a 4-string, but it is not a 3-string, a 5-string, or a 6-string and so on. Obviously any string is a 1-string.
You are given a string s, consisting of lowercase English letters and a positive integer k. Your task is to reorder the letters in the string s in such a way that the resulting string is a k-string.
Input
The first input line contains integer k (1 ≤ k ≤ 1000). The second line contains s, all characters in s are lowercase English letters. The string length s satisfies the inequality 1 ≤ |s| ≤ 1000, where |s| is the length of string s.
Output
Rearrange the letters in string s in such a way that the result is a k-string. Print the result on a single output line. If there are multiple solutions, print any of them.
If the solution doesn't exist, print "-1" (without quotes).
Examples
Input
2
aazz
Output
azaz
Input
3
abcabcabz
Output
-1 | instruction | 0 | 57,370 | 0 | 114,740 |
Tags: implementation, strings
Correct Solution:
```
k=int(input())
s=list(input())
d={}
for x in s:
d[x]=d.get(x,0)+1
for x in d:
if d[x]%k: print(-1); break
d[x]//=k
else:
s=''
for x in d:
for i in range(d[x]):
s+=x
ans=[s for _ in range(k)]
print(''.join(ans))
``` | output | 1 | 57,370 | 0 | 114,741 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A string is called a k-string if it can be represented as k concatenated copies of some string. For example, the string "aabaabaabaab" is at the same time a 1-string, a 2-string and a 4-string, but it is not a 3-string, a 5-string, or a 6-string and so on. Obviously any string is a 1-string.
You are given a string s, consisting of lowercase English letters and a positive integer k. Your task is to reorder the letters in the string s in such a way that the resulting string is a k-string.
Input
The first input line contains integer k (1 ≤ k ≤ 1000). The second line contains s, all characters in s are lowercase English letters. The string length s satisfies the inequality 1 ≤ |s| ≤ 1000, where |s| is the length of string s.
Output
Rearrange the letters in string s in such a way that the result is a k-string. Print the result on a single output line. If there are multiple solutions, print any of them.
If the solution doesn't exist, print "-1" (without quotes).
Examples
Input
2
aazz
Output
azaz
Input
3
abcabcabz
Output
-1 | instruction | 0 | 57,371 | 0 | 114,742 |
Tags: implementation, strings
Correct Solution:
```
def kstring(s, k):
if len(s)%k != 0:
return ""
else:
from collections import Counter
d = dict(Counter(s))
ans = []
for letter in d:
count = d[letter]
if count%k == 0:
ans.append(letter*(count//k))
else:
return ""
ans = "".join(ans)
ans = ans*k
return ans
k = int(input())
s = input()
a = kstring(s, k)
if not a:
print(-1)
else:
print(a)
``` | output | 1 | 57,371 | 0 | 114,743 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string is called a k-string if it can be represented as k concatenated copies of some string. For example, the string "aabaabaabaab" is at the same time a 1-string, a 2-string and a 4-string, but it is not a 3-string, a 5-string, or a 6-string and so on. Obviously any string is a 1-string.
You are given a string s, consisting of lowercase English letters and a positive integer k. Your task is to reorder the letters in the string s in such a way that the resulting string is a k-string.
Input
The first input line contains integer k (1 ≤ k ≤ 1000). The second line contains s, all characters in s are lowercase English letters. The string length s satisfies the inequality 1 ≤ |s| ≤ 1000, where |s| is the length of string s.
Output
Rearrange the letters in string s in such a way that the result is a k-string. Print the result on a single output line. If there are multiple solutions, print any of them.
If the solution doesn't exist, print "-1" (without quotes).
Examples
Input
2
aazz
Output
azaz
Input
3
abcabcabz
Output
-1
Submitted Solution:
```
k=int(input())
s=input().strip()
chars=set()
freq=[0]*(26)
for i in s:
chars.add(i)
freq[ord(i)-ord('a')]+=1
for i in range(26):
if freq[i]%k!=0:
print("-1")
exit()
else:
freq[i]//=k
for i in range(k):
for j in range(26):
for l in range(freq[j]):
print(chr(j+ord('a')),end="")
print()
``` | instruction | 0 | 57,372 | 0 | 114,744 |
Yes | output | 1 | 57,372 | 0 | 114,745 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string is called a k-string if it can be represented as k concatenated copies of some string. For example, the string "aabaabaabaab" is at the same time a 1-string, a 2-string and a 4-string, but it is not a 3-string, a 5-string, or a 6-string and so on. Obviously any string is a 1-string.
You are given a string s, consisting of lowercase English letters and a positive integer k. Your task is to reorder the letters in the string s in such a way that the resulting string is a k-string.
Input
The first input line contains integer k (1 ≤ k ≤ 1000). The second line contains s, all characters in s are lowercase English letters. The string length s satisfies the inequality 1 ≤ |s| ≤ 1000, where |s| is the length of string s.
Output
Rearrange the letters in string s in such a way that the result is a k-string. Print the result on a single output line. If there are multiple solutions, print any of them.
If the solution doesn't exist, print "-1" (without quotes).
Examples
Input
2
aazz
Output
azaz
Input
3
abcabcabz
Output
-1
Submitted Solution:
```
k = int(input())
a = input()
b = list(set(a))
c = {}
for i in b:
if a.count(i)%k == 0:
c[i] = a.count(i)//k
else:
print(-1)
exit(0)
substring = ''
for key in c:
substring += c[key]*key
print(k*substring)
``` | instruction | 0 | 57,373 | 0 | 114,746 |
Yes | output | 1 | 57,373 | 0 | 114,747 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string is called a k-string if it can be represented as k concatenated copies of some string. For example, the string "aabaabaabaab" is at the same time a 1-string, a 2-string and a 4-string, but it is not a 3-string, a 5-string, or a 6-string and so on. Obviously any string is a 1-string.
You are given a string s, consisting of lowercase English letters and a positive integer k. Your task is to reorder the letters in the string s in such a way that the resulting string is a k-string.
Input
The first input line contains integer k (1 ≤ k ≤ 1000). The second line contains s, all characters in s are lowercase English letters. The string length s satisfies the inequality 1 ≤ |s| ≤ 1000, where |s| is the length of string s.
Output
Rearrange the letters in string s in such a way that the result is a k-string. Print the result on a single output line. If there are multiple solutions, print any of them.
If the solution doesn't exist, print "-1" (without quotes).
Examples
Input
2
aazz
Output
azaz
Input
3
abcabcabz
Output
-1
Submitted Solution:
```
from collections import Counter
def Sol(st,k):
data = Counter(st)
d = data.most_common()
for i in d:
if i[1]%k != 0:
print(-1)
return
c = list(data.values())
c.sort(reverse=True)
for i in range(len(c)):
c[i] = int(c[i]/k)
ans = ''
it = 0
l = len(c)
count = 0
while True:
if d[0][1] != 0:
ans += d[0][0]*c[it]
d = d[1:] + [(d[0][0],d[0][1]-c[it])]
it += 1
if it%l == 0:
it = 0
else:
break
print(ans)
return
#for t in range(int(input())):
#n,k = map(int,input().split())
#n = int(input())
#arr = list(map(int,input().split()))
k = int(input())
n = input()
Sol(n,k)
``` | instruction | 0 | 57,374 | 0 | 114,748 |
Yes | output | 1 | 57,374 | 0 | 114,749 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string is called a k-string if it can be represented as k concatenated copies of some string. For example, the string "aabaabaabaab" is at the same time a 1-string, a 2-string and a 4-string, but it is not a 3-string, a 5-string, or a 6-string and so on. Obviously any string is a 1-string.
You are given a string s, consisting of lowercase English letters and a positive integer k. Your task is to reorder the letters in the string s in such a way that the resulting string is a k-string.
Input
The first input line contains integer k (1 ≤ k ≤ 1000). The second line contains s, all characters in s are lowercase English letters. The string length s satisfies the inequality 1 ≤ |s| ≤ 1000, where |s| is the length of string s.
Output
Rearrange the letters in string s in such a way that the result is a k-string. Print the result on a single output line. If there are multiple solutions, print any of them.
If the solution doesn't exist, print "-1" (without quotes).
Examples
Input
2
aazz
Output
azaz
Input
3
abcabcabz
Output
-1
Submitted Solution:
```
n = int(input())
string = input()
d = {x:0 for x in string}
count = 0
for s in string:
d[s] += 1
notok = False
letters = ''
for key,values in d.items():
if values%n != 0:
print(-1)
notok = True
break
else:
letters += (int(values/n)*key)
#print(d)
if notok == False:
print(n*letters)
``` | instruction | 0 | 57,375 | 0 | 114,750 |
Yes | output | 1 | 57,375 | 0 | 114,751 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string is called a k-string if it can be represented as k concatenated copies of some string. For example, the string "aabaabaabaab" is at the same time a 1-string, a 2-string and a 4-string, but it is not a 3-string, a 5-string, or a 6-string and so on. Obviously any string is a 1-string.
You are given a string s, consisting of lowercase English letters and a positive integer k. Your task is to reorder the letters in the string s in such a way that the resulting string is a k-string.
Input
The first input line contains integer k (1 ≤ k ≤ 1000). The second line contains s, all characters in s are lowercase English letters. The string length s satisfies the inequality 1 ≤ |s| ≤ 1000, where |s| is the length of string s.
Output
Rearrange the letters in string s in such a way that the result is a k-string. Print the result on a single output line. If there are multiple solutions, print any of them.
If the solution doesn't exist, print "-1" (without quotes).
Examples
Input
2
aazz
Output
azaz
Input
3
abcabcabz
Output
-1
Submitted Solution:
```
def func():
k = int(input())
s = input()
slist = []
copy = []
pos = 0
rep = 1
for let in s:
slist.append(let)
for let in slist:
if let in copy:
continue
if rep > k:
print(-1)
return
pos = slist.index(let)
rep = 1
while True:
if rep == k:
copy.append(let)
break
if pos+1 == len(slist):
break
if let != slist[pos+1]:
pos+=1
else:
pos+=1
rep += 1
if rep < k:
print(-1)
return
word1 = ""
word2 = ""
for let in copy:
word1 += let
for i in range(k):
word2 += word1
print(word2)
func()
``` | instruction | 0 | 57,376 | 0 | 114,752 |
No | output | 1 | 57,376 | 0 | 114,753 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string is called a k-string if it can be represented as k concatenated copies of some string. For example, the string "aabaabaabaab" is at the same time a 1-string, a 2-string and a 4-string, but it is not a 3-string, a 5-string, or a 6-string and so on. Obviously any string is a 1-string.
You are given a string s, consisting of lowercase English letters and a positive integer k. Your task is to reorder the letters in the string s in such a way that the resulting string is a k-string.
Input
The first input line contains integer k (1 ≤ k ≤ 1000). The second line contains s, all characters in s are lowercase English letters. The string length s satisfies the inequality 1 ≤ |s| ≤ 1000, where |s| is the length of string s.
Output
Rearrange the letters in string s in such a way that the result is a k-string. Print the result on a single output line. If there are multiple solutions, print any of them.
If the solution doesn't exist, print "-1" (without quotes).
Examples
Input
2
aazz
Output
azaz
Input
3
abcabcabz
Output
-1
Submitted Solution:
```
def solve(s,n):
d = {}
for i in s:
if not d.get(i):
d[i] = 1
else:
d[i] += 1
l = [(k,v) for k,v in d.items()]
res = ''
base_val = 1000000000
for i in range(len(l)):
if l[i][1] % n != 0:
return -1
if l[i][1] < base_val:
base_val = l[i][1]
for i in range(len(l)):
for j in range(i, len(l)):
if l[i][0] > l[j][0]:
l[i],l[j] = l[j],l[i]
for i in l:
res+=i[0]*(i[1]//n)
return res*base_val
def main() :
# n,k = list(map(int, input().split(' ')))
# n = int(input())
# arr = input().split(' ')
# s = input()
# res=''
# arr = []
# for _ in range(n):
# i = input()
# arr.append(i)
# for i in arr:
n = int(input())
s = input()
print(solve(s,n))
main()
``` | instruction | 0 | 57,377 | 0 | 114,754 |
No | output | 1 | 57,377 | 0 | 114,755 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string is called a k-string if it can be represented as k concatenated copies of some string. For example, the string "aabaabaabaab" is at the same time a 1-string, a 2-string and a 4-string, but it is not a 3-string, a 5-string, or a 6-string and so on. Obviously any string is a 1-string.
You are given a string s, consisting of lowercase English letters and a positive integer k. Your task is to reorder the letters in the string s in such a way that the resulting string is a k-string.
Input
The first input line contains integer k (1 ≤ k ≤ 1000). The second line contains s, all characters in s are lowercase English letters. The string length s satisfies the inequality 1 ≤ |s| ≤ 1000, where |s| is the length of string s.
Output
Rearrange the letters in string s in such a way that the result is a k-string. Print the result on a single output line. If there are multiple solutions, print any of them.
If the solution doesn't exist, print "-1" (without quotes).
Examples
Input
2
aazz
Output
azaz
Input
3
abcabcabz
Output
-1
Submitted Solution:
```
k=int(input())
s=str(input())
s=list(s)
d={}
for i in s:
d[i]=s.count(i)
cnt=0
s1=''
for j in d:
if d[j]==k:
cnt+=1
s1+=j
if cnt!=len(d):
print(-1)
else:
print(s1*k)
``` | instruction | 0 | 57,378 | 0 | 114,756 |
No | output | 1 | 57,378 | 0 | 114,757 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string is called a k-string if it can be represented as k concatenated copies of some string. For example, the string "aabaabaabaab" is at the same time a 1-string, a 2-string and a 4-string, but it is not a 3-string, a 5-string, or a 6-string and so on. Obviously any string is a 1-string.
You are given a string s, consisting of lowercase English letters and a positive integer k. Your task is to reorder the letters in the string s in such a way that the resulting string is a k-string.
Input
The first input line contains integer k (1 ≤ k ≤ 1000). The second line contains s, all characters in s are lowercase English letters. The string length s satisfies the inequality 1 ≤ |s| ≤ 1000, where |s| is the length of string s.
Output
Rearrange the letters in string s in such a way that the result is a k-string. Print the result on a single output line. If there are multiple solutions, print any of them.
If the solution doesn't exist, print "-1" (without quotes).
Examples
Input
2
aazz
Output
azaz
Input
3
abcabcabz
Output
-1
Submitted Solution:
```
k=int(input())
n=input()
x=''
v=''
lst=[]
lst1=[]
if(n.count(n[0])==len(n) and len(n)==k):
print(n)
else:
for i in n:
if(i not in lst1):
x=x+i
lst.append(n.count(i))
lst1.append(i)
if(min(lst)==k):
for j in x:
v+=(j*(n.count(j)//k))
print(v*k)
else:
print(-1)
``` | instruction | 0 | 57,379 | 0 | 114,758 |
No | output | 1 | 57,379 | 0 | 114,759 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Professor GukiZ doesn't accept string as they are. He likes to swap some letters in string to obtain a new one.
GukiZ has strings a, b, and c. He wants to obtain string k by swapping some letters in a, so that k should contain as many non-overlapping substrings equal either to b or c as possible. Substring of string x is a string formed by consecutive segment of characters from x. Two substrings of string x overlap if there is position i in string x occupied by both of them.
GukiZ was disappointed because none of his students managed to solve the problem. Can you help them and find one of possible strings k?
Input
The first line contains string a, the second line contains string b, and the third line contains string c (1 ≤ |a|, |b|, |c| ≤ 105, where |s| denotes the length of string s).
All three strings consist only of lowercase English letters.
It is possible that b and c coincide.
Output
Find one of possible strings k, as described in the problem statement. If there are multiple possible answers, print any of them.
Examples
Input
aaa
a
b
Output
aaa
Input
pozdravstaklenidodiri
niste
dobri
Output
nisteaadddiiklooprrvz
Input
abbbaaccca
ab
aca
Output
ababacabcc
Note
In the third sample, this optimal solutions has three non-overlaping substrings equal to either b or c on positions 1 – 2 (ab), 3 – 4 (ab), 5 – 7 (aca). In this sample, there exist many other optimal solutions, one of them would be acaababbcc. | instruction | 0 | 57,540 | 0 | 115,080 |
Tags: brute force, constructive algorithms, implementation, strings
Correct Solution:
```
from collections import Counter
from collections import defaultdict
def get_single(a, b):
res = 2 ** 32
for s in b.keys():
res = min(res, a[s] // b[s])
return res
def get_count(a, b, c):
best = 0, get_single(a, c)
r1 = 0
while a & b == b:
r1 += 1
a = a - b
r2 = get_single(a, c)
if r1 + r2 > sum(best):
best = r1, r2
return best
a = input()
b = input()
c = input()
aa = Counter(a)
bb = Counter(b)
cc = Counter(c)
r = get_count(Counter(a), bb, cc)
res = b * r[0] + c * r[1]
rest = aa - Counter(res)
res += ''.join(list(rest.elements()))
print(res)
``` | output | 1 | 57,540 | 0 | 115,081 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Professor GukiZ doesn't accept string as they are. He likes to swap some letters in string to obtain a new one.
GukiZ has strings a, b, and c. He wants to obtain string k by swapping some letters in a, so that k should contain as many non-overlapping substrings equal either to b or c as possible. Substring of string x is a string formed by consecutive segment of characters from x. Two substrings of string x overlap if there is position i in string x occupied by both of them.
GukiZ was disappointed because none of his students managed to solve the problem. Can you help them and find one of possible strings k?
Input
The first line contains string a, the second line contains string b, and the third line contains string c (1 ≤ |a|, |b|, |c| ≤ 105, where |s| denotes the length of string s).
All three strings consist only of lowercase English letters.
It is possible that b and c coincide.
Output
Find one of possible strings k, as described in the problem statement. If there are multiple possible answers, print any of them.
Examples
Input
aaa
a
b
Output
aaa
Input
pozdravstaklenidodiri
niste
dobri
Output
nisteaadddiiklooprrvz
Input
abbbaaccca
ab
aca
Output
ababacabcc
Note
In the third sample, this optimal solutions has three non-overlaping substrings equal to either b or c on positions 1 – 2 (ab), 3 – 4 (ab), 5 – 7 (aca). In this sample, there exist many other optimal solutions, one of them would be acaababbcc. | instruction | 0 | 57,541 | 0 | 115,082 |
Tags: brute force, constructive algorithms, implementation, strings
Correct Solution:
```
sa = input()
a = [0] * 26
for i in sa:
a[ord(i) - ord('a')] += 1
sb = input()
b = [0] * 26
for i in sb:
b[ord(i) - ord('a')] += 1
sc = input()
c = [0] * 26
for i in sc:
c[ord(i) - ord('a')] += 1
def zu(n):
m = 1000000000
for i in range(26):
if n * b[i] > a[i]:
return -1
if c[i] > 0:
m = min(m, (a[i] - n * b[i]) // c[i])
return n + m
n = 0
m = 0
v = 0
for i in range(100000):
u = zu(i)
if u < 0:
break
if v < u:
v = u
n = i
m = u - i
print(sb * n + sc * m, end = '')
for i in range(26):
a[i] -= n * b[i] + m * c[i]
print(chr(i + ord('a')) * a[i], end = '')
``` | output | 1 | 57,541 | 0 | 115,083 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Professor GukiZ doesn't accept string as they are. He likes to swap some letters in string to obtain a new one.
GukiZ has strings a, b, and c. He wants to obtain string k by swapping some letters in a, so that k should contain as many non-overlapping substrings equal either to b or c as possible. Substring of string x is a string formed by consecutive segment of characters from x. Two substrings of string x overlap if there is position i in string x occupied by both of them.
GukiZ was disappointed because none of his students managed to solve the problem. Can you help them and find one of possible strings k?
Input
The first line contains string a, the second line contains string b, and the third line contains string c (1 ≤ |a|, |b|, |c| ≤ 105, where |s| denotes the length of string s).
All three strings consist only of lowercase English letters.
It is possible that b and c coincide.
Output
Find one of possible strings k, as described in the problem statement. If there are multiple possible answers, print any of them.
Examples
Input
aaa
a
b
Output
aaa
Input
pozdravstaklenidodiri
niste
dobri
Output
nisteaadddiiklooprrvz
Input
abbbaaccca
ab
aca
Output
ababacabcc
Note
In the third sample, this optimal solutions has three non-overlaping substrings equal to either b or c on positions 1 – 2 (ab), 3 – 4 (ab), 5 – 7 (aca). In this sample, there exist many other optimal solutions, one of them would be acaababbcc. | instruction | 0 | 57,542 | 0 | 115,084 |
Tags: brute force, constructive algorithms, implementation, strings
Correct Solution:
```
contest = True
if not contest:
fin = open("in", "r")
inp = input if contest else lambda: fin.readline()[:-1]
read = lambda: tuple(map(int, inp().split()))
def cstr(s):
d = {}
for c in s:
if not c in d:
d[c] = 1
else:
d[c] += 1
return d
s, a, b = inp(), inp(), inp()
ks, ka, kb = cstr(s), cstr(a), cstr(b)
def suka(ks, kx, minusV, minusK):
ans = ""
d = 10**20
#print("k:", minusK, "|", ", ".join([str(k)+":"+str(kx[k]) for k in kx]))
for k in kx:
if not k in ks: return 0
c = ks[k]
if k in minusV:
c = max(c - minusV[k] * minusK, 0)
#print(ks[k] // c, k, ":", ks[k], minusV[k] if k in minusV else "_", minusK)
d = min(c // kx[k], d)
#print(d, ka, b * d)
return d
def solve(s, ka, kb):
ks = cstr(s)
#print("\n---------", ", ".join([str(k)+":"+str(ks[k]) for k in ks]))
#print("---------", ", ".join([str(k)+":"+str(ka[k]) for k in ka]))
#print("---------", ", ".join([str(k)+":"+str(kb[k]) for k in kb]))
da = suka(ks, ka, {}, 0)
mx = 0
ans = (-1, -1)
for dai in range(0, da+1):
db = suka(ks, kb, ka, dai)
if dai + db >= mx:
mx = dai + db
ans = (dai, db)
return (mx, ans)
ab = ((b, a, kb, ka), (a, b, ka, kb))
answs = [(solve(s, kb, ka), 0), (solve(s, ka, kb), 1)]
ans = max(answs, key=lambda v: v[0])
ab = ab[ans[1]]
ans = ans[0][1]
for k in ks:
if k in ab[2]: ks[k] -= ans[0] * ab[2][k]
if k in ab[3]: ks[k] -= ans[1] * ab[3][k]
print(ans[0] * ab[0] + ans[1] * ab[1] + "".join([str(k * ks[k]) for k in ks]))
``` | output | 1 | 57,542 | 0 | 115,085 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Professor GukiZ doesn't accept string as they are. He likes to swap some letters in string to obtain a new one.
GukiZ has strings a, b, and c. He wants to obtain string k by swapping some letters in a, so that k should contain as many non-overlapping substrings equal either to b or c as possible. Substring of string x is a string formed by consecutive segment of characters from x. Two substrings of string x overlap if there is position i in string x occupied by both of them.
GukiZ was disappointed because none of his students managed to solve the problem. Can you help them and find one of possible strings k?
Input
The first line contains string a, the second line contains string b, and the third line contains string c (1 ≤ |a|, |b|, |c| ≤ 105, where |s| denotes the length of string s).
All three strings consist only of lowercase English letters.
It is possible that b and c coincide.
Output
Find one of possible strings k, as described in the problem statement. If there are multiple possible answers, print any of them.
Examples
Input
aaa
a
b
Output
aaa
Input
pozdravstaklenidodiri
niste
dobri
Output
nisteaadddiiklooprrvz
Input
abbbaaccca
ab
aca
Output
ababacabcc
Note
In the third sample, this optimal solutions has three non-overlaping substrings equal to either b or c on positions 1 – 2 (ab), 3 – 4 (ab), 5 – 7 (aca). In this sample, there exist many other optimal solutions, one of them would be acaababbcc. | instruction | 0 | 57,543 | 0 | 115,086 |
Tags: brute force, constructive algorithms, implementation, strings
Correct Solution:
```
a = input()
b = input()
c = input()
all_set = set(a + b + c)
def getMin(object_dict, sub_dict):
return min([object_dict[ch] // sub_dict[ch] for ch in sub_dict.keys() if sub_dict[ch] > 0])
a_dict = {ch : a.count(ch) for ch in all_set}
b_dict = {ch : b.count(ch) for ch in all_set}
c_dict = {ch : c.count(ch) for ch in all_set}
bMin = getMin(a_dict, b_dict)
bsum = 0
csum = 0
for i in range(bMin + 1):
j = min((a_dict[ch] - b_dict[ch] * i) // c_dict[ch] for ch in all_set if c_dict[ch] > 0)
if i + j > bsum + csum:
bsum, csum = i, j
print(b * bsum, end = "")
print(c * csum, end = "")
for ch in all_set:
print(ch * (a_dict[ch] - b_dict[ch] * bsum - c_dict[ch] * csum), end = '')
print()
``` | output | 1 | 57,543 | 0 | 115,087 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Professor GukiZ doesn't accept string as they are. He likes to swap some letters in string to obtain a new one.
GukiZ has strings a, b, and c. He wants to obtain string k by swapping some letters in a, so that k should contain as many non-overlapping substrings equal either to b or c as possible. Substring of string x is a string formed by consecutive segment of characters from x. Two substrings of string x overlap if there is position i in string x occupied by both of them.
GukiZ was disappointed because none of his students managed to solve the problem. Can you help them and find one of possible strings k?
Input
The first line contains string a, the second line contains string b, and the third line contains string c (1 ≤ |a|, |b|, |c| ≤ 105, where |s| denotes the length of string s).
All three strings consist only of lowercase English letters.
It is possible that b and c coincide.
Output
Find one of possible strings k, as described in the problem statement. If there are multiple possible answers, print any of them.
Examples
Input
aaa
a
b
Output
aaa
Input
pozdravstaklenidodiri
niste
dobri
Output
nisteaadddiiklooprrvz
Input
abbbaaccca
ab
aca
Output
ababacabcc
Note
In the third sample, this optimal solutions has three non-overlaping substrings equal to either b or c on positions 1 – 2 (ab), 3 – 4 (ab), 5 – 7 (aca). In this sample, there exist many other optimal solutions, one of them would be acaababbcc. | instruction | 0 | 57,544 | 0 | 115,088 |
Tags: brute force, constructive algorithms, implementation, strings
Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,copy
from itertools import chain, dropwhile, permutations, combinations
from collections import defaultdict, deque
# Guide:
# 1. construct complex data types while reading (e.g. graph adj list)
# 2. avoid any non-necessary time/memory usage
# 3. avoid templates and write more from scratch
# 4. switch to "flat" implementations
def VI(): return list(map(int,input().split()))
def I(): return int(input())
def LIST(n,m=None): return [0]*n if m is None else [[0]*m for i in range(n)]
def ELIST(n): return [[] for i in range(n)]
def MI(n=None,m=None): # input matrix of integers
if n is None: n,m = VI()
arr = LIST(n)
for i in range(n): arr[i] = VI()
return arr
def MS(n=None,m=None): # input matrix of strings
if n is None: n,m = VI()
arr = LIST(n)
for i in range(n): arr[i] = input()
return arr
def MIT(n=None,m=None): # input transposed matrix/array of integers
if n is None: n,m = VI()
a = MI(n,m)
arr = LIST(m,n)
for i,l in enumerate(a):
for j,x in enumerate(l):
arr[j][i] = x
return arr
def run(n,x,l,r):
s = 0
curr = 1
for i in range(n):
skip = (l[i]-curr) // x
s += r[i]-curr-skip*x+1
curr = r[i]+1
print(s)
def main(info=0):
a,b,c = input(), input(), input()
A = [a.count(chr(x+ord('a'))) for x in range(26)]
B = [b.count(chr(x+ord('a'))) for x in range(26)]
C = [c.count(chr(x+ord('a'))) for x in range(26)]
def nin(m,s):
n = 1000000
for x in set(s):
i = ord(x)-ord('a')
n = min(n, m[i]//s.count(x))
return n
def xin(m,s):
n = 1000000
for i in range(26):
if s[i]>0:
n = min(n, m[i]//s[i])
return n
def setup(ib,ic):
s = b*ib + c*ic
for i in range(26):
char = chr(i+ord('a'))
if char in s:
A[i] -= s.count(char)
s += char * A[i]
return s
# nb = nin(A,b)
# nc = nin(A,c)
nb = xin(A,B)
nc = xin(A,C)
best_i = (-1,-1)
best = 0
for j in range(nb+1):
loc = nc
for x in range(26):
if C[x]>0:
loc = min(loc, (A[x]-j*B[x])//C[x])
if (j+loc)>best:
best = j+loc
best_i = (j,loc)
print(setup(*best_i))
# p = nc+nb
# minus = 0
# ii, jj = -1,-1
# while p-minus>0:
# for i in range(0,minus+1):
# j = minus-i
# if i>nb or j>nc:
# continue
# #print("start ",p,i,j,p-i-j)
# if nin((b*(nb-i))+(c*(nc-j)))>0:
# ii,jj = nb-i,nc-j
# #print("f ",ii,jj)
# break
# if ii >= 0:
# #print("w ",ii,jj)
# break
# minus += 1
# if ii<0:
# print(a)
# else:
# s = b*ii + c*jj
# for i,v in enumerate(m):
# char = chr(i+ord('a'))
# if char in s:
# m[i] -= s.count(char)
# s += char * m[i]
# print(s)
if __name__ == "__main__":
main()
``` | output | 1 | 57,544 | 0 | 115,089 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Professor GukiZ doesn't accept string as they are. He likes to swap some letters in string to obtain a new one.
GukiZ has strings a, b, and c. He wants to obtain string k by swapping some letters in a, so that k should contain as many non-overlapping substrings equal either to b or c as possible. Substring of string x is a string formed by consecutive segment of characters from x. Two substrings of string x overlap if there is position i in string x occupied by both of them.
GukiZ was disappointed because none of his students managed to solve the problem. Can you help them and find one of possible strings k?
Input
The first line contains string a, the second line contains string b, and the third line contains string c (1 ≤ |a|, |b|, |c| ≤ 105, where |s| denotes the length of string s).
All three strings consist only of lowercase English letters.
It is possible that b and c coincide.
Output
Find one of possible strings k, as described in the problem statement. If there are multiple possible answers, print any of them.
Examples
Input
aaa
a
b
Output
aaa
Input
pozdravstaklenidodiri
niste
dobri
Output
nisteaadddiiklooprrvz
Input
abbbaaccca
ab
aca
Output
ababacabcc
Note
In the third sample, this optimal solutions has three non-overlaping substrings equal to either b or c on positions 1 – 2 (ab), 3 – 4 (ab), 5 – 7 (aca). In this sample, there exist many other optimal solutions, one of them would be acaababbcc. | instruction | 0 | 57,545 | 0 | 115,090 |
Tags: brute force, constructive algorithms, implementation, strings
Correct Solution:
```
INF = 999999999999999999999999999999999999999
a = input()
b = input()
c = input()
a_letters = [0] * 26
b_letters = [0] * 26
c_letters = [0] * 26
for code in range(ord('a'), ord('z') + 1):
letter = chr(code)
a_letters[code - ord('a')] = a.count(letter)
b_letters[code - ord('a')] = b.count(letter)
c_letters[code - ord('a')] = c.count(letter)
while True:
b_count = [0] * 26
for i in range(26):
if b_letters[i] > 0:
b_count[i] = a_letters[i] // b_letters[i]
else:
b_count[i] = INF
c_count = [0] * 26
for i in range(26):
if c_letters[i] > 0:
c_count[i] = a_letters[i] // c_letters[i]
else:
c_count[i] = INF
b_min = min(b_count)
c_min = min(c_count)
if b_min == 0 and c_min == 0:
break
if b_min > c_min:
print(b, end='')
for i in range(26):
a_letters[i] -= b_letters[i]
else:
print(c, end='')
for i in range(26):
a_letters[i] -= c_letters[i]
for i in range(26):
print(chr(ord('a') + i) * a_letters[i], end='')
print()
``` | output | 1 | 57,545 | 0 | 115,091 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.