message stringlengths 2 23.8k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 97 109k | cluster float64 0 0 | __index_level_0__ int64 194 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s of length n, which consists only of the first k letters of the Latin alphabet. All letters in string s are uppercase.
A subsequence of string s is a string that can be derived from s by deleting some of its symbols without changing the order of the remaining symbols. For example, "ADE" and "BD" are subsequences of "ABCDE", but "DEA" is not.
A subsequence of s called good if the number of occurences of each of the first k letters of the alphabet is the same.
Find the length of the longest good subsequence of s.
Input
The first line of the input contains integers n (1≤ n ≤ 10^5) and k (1 ≤ k ≤ 26).
The second line of the input contains the string s of length n. String s only contains uppercase letters from 'A' to the k-th letter of Latin alphabet.
Output
Print the only integer — the length of the longest good subsequence of string s.
Examples
Input
9 3
ACAABCCAB
Output
6
Input
9 4
ABCABCABC
Output
0
Note
In the first example, "ACBCAB" ("ACAABCCAB") is one of the subsequences that has the same frequency of 'A', 'B' and 'C'. Subsequence "CAB" also has the same frequency of these letters, but doesn't have the maximum possible length.
In the second example, none of the subsequences can have 'D', hence the answer is 0. | instruction | 0 | 20,286 | 0 | 40,572 |
Tags: implementation, strings
Correct Solution:
```
n, k = list(map(int, input().split()))
s = input()
alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
a = dict([(lit, 0) for lit in alpha[:k]])
for i in range(n):
a[s[i]] += 1
min_cnt = min(a.values())
print(min_cnt*k)
``` | output | 1 | 20,286 | 0 | 40,573 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a string s of length n, which consists only of the first k letters of the Latin alphabet. All letters in string s are uppercase.
A subsequence of string s is a string that can be derived from s by deleting some of its symbols without changing the order of the remaining symbols. For example, "ADE" and "BD" are subsequences of "ABCDE", but "DEA" is not.
A subsequence of s called good if the number of occurences of each of the first k letters of the alphabet is the same.
Find the length of the longest good subsequence of s.
Input
The first line of the input contains integers n (1≤ n ≤ 10^5) and k (1 ≤ k ≤ 26).
The second line of the input contains the string s of length n. String s only contains uppercase letters from 'A' to the k-th letter of Latin alphabet.
Output
Print the only integer — the length of the longest good subsequence of string s.
Examples
Input
9 3
ACAABCCAB
Output
6
Input
9 4
ABCABCABC
Output
0
Note
In the first example, "ACBCAB" ("ACAABCCAB") is one of the subsequences that has the same frequency of 'A', 'B' and 'C'. Subsequence "CAB" also has the same frequency of these letters, but doesn't have the maximum possible length.
In the second example, none of the subsequences can have 'D', hence the answer is 0. | instruction | 0 | 20,287 | 0 | 40,574 |
Tags: implementation, strings
Correct Solution:
```
#import sys
#sys.stdin = open("input.in","r")
#sys.stdout = open("test.out","w")
n,k= map(int, input().split())
l=input()
m=list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")[:k]
d=dict()
for i in m:
d[i] = 0
for j in l:
d[j] += 1
print(min(d.values()) * k)
``` | output | 1 | 20,287 | 0 | 40,575 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s of length n, which consists only of the first k letters of the Latin alphabet. All letters in string s are uppercase.
A subsequence of string s is a string that can be derived from s by deleting some of its symbols without changing the order of the remaining symbols. For example, "ADE" and "BD" are subsequences of "ABCDE", but "DEA" is not.
A subsequence of s called good if the number of occurences of each of the first k letters of the alphabet is the same.
Find the length of the longest good subsequence of s.
Input
The first line of the input contains integers n (1≤ n ≤ 10^5) and k (1 ≤ k ≤ 26).
The second line of the input contains the string s of length n. String s only contains uppercase letters from 'A' to the k-th letter of Latin alphabet.
Output
Print the only integer — the length of the longest good subsequence of string s.
Examples
Input
9 3
ACAABCCAB
Output
6
Input
9 4
ABCABCABC
Output
0
Note
In the first example, "ACBCAB" ("ACAABCCAB") is one of the subsequences that has the same frequency of 'A', 'B' and 'C'. Subsequence "CAB" also has the same frequency of these letters, but doesn't have the maximum possible length.
In the second example, none of the subsequences can have 'D', hence the answer is 0.
Submitted Solution:
```
'''input
9 4
ABCABCABC
'''
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
mod=10**9+7
n,k=[int(i) for i in input().split()]
s=input()
a=[0]*(26)
for i in s:
temp=ord(i)-ord("A")
a[temp]+=1
ans=0
temp=[]
for i in range(k):
temp.append(a[i])
final=min(temp)
if final==0:
print(0)
else:
print(final*k)
``` | instruction | 0 | 20,288 | 0 | 40,576 |
Yes | output | 1 | 20,288 | 0 | 40,577 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s of length n, which consists only of the first k letters of the Latin alphabet. All letters in string s are uppercase.
A subsequence of string s is a string that can be derived from s by deleting some of its symbols without changing the order of the remaining symbols. For example, "ADE" and "BD" are subsequences of "ABCDE", but "DEA" is not.
A subsequence of s called good if the number of occurences of each of the first k letters of the alphabet is the same.
Find the length of the longest good subsequence of s.
Input
The first line of the input contains integers n (1≤ n ≤ 10^5) and k (1 ≤ k ≤ 26).
The second line of the input contains the string s of length n. String s only contains uppercase letters from 'A' to the k-th letter of Latin alphabet.
Output
Print the only integer — the length of the longest good subsequence of string s.
Examples
Input
9 3
ACAABCCAB
Output
6
Input
9 4
ABCABCABC
Output
0
Note
In the first example, "ACBCAB" ("ACAABCCAB") is one of the subsequences that has the same frequency of 'A', 'B' and 'C'. Subsequence "CAB" also has the same frequency of these letters, but doesn't have the maximum possible length.
In the second example, none of the subsequences can have 'D', hence the answer is 0.
Submitted Solution:
```
from collections import defaultdict
n,k = map(int,input().split())
s=input()
ds = defaultdict(int)
for x in s:
ds[x]+=1
valids = [x for x in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'[:k]]
#print(dict(ds),valids)
m=9999999999
for x in valids:
m=min(m,ds[x])
print(m*k)
``` | instruction | 0 | 20,289 | 0 | 40,578 |
Yes | output | 1 | 20,289 | 0 | 40,579 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s of length n, which consists only of the first k letters of the Latin alphabet. All letters in string s are uppercase.
A subsequence of string s is a string that can be derived from s by deleting some of its symbols without changing the order of the remaining symbols. For example, "ADE" and "BD" are subsequences of "ABCDE", but "DEA" is not.
A subsequence of s called good if the number of occurences of each of the first k letters of the alphabet is the same.
Find the length of the longest good subsequence of s.
Input
The first line of the input contains integers n (1≤ n ≤ 10^5) and k (1 ≤ k ≤ 26).
The second line of the input contains the string s of length n. String s only contains uppercase letters from 'A' to the k-th letter of Latin alphabet.
Output
Print the only integer — the length of the longest good subsequence of string s.
Examples
Input
9 3
ACAABCCAB
Output
6
Input
9 4
ABCABCABC
Output
0
Note
In the first example, "ACBCAB" ("ACAABCCAB") is one of the subsequences that has the same frequency of 'A', 'B' and 'C'. Subsequence "CAB" also has the same frequency of these letters, but doesn't have the maximum possible length.
In the second example, none of the subsequences can have 'D', hence the answer is 0.
Submitted Solution:
```
from string import ascii_uppercase
from collections import Counter
letters = ascii_uppercase
n, k = map(int, input().split())
s = input()
c = Counter(s)
print(k * min(c[letter] for letter in letters[:k]))
``` | instruction | 0 | 20,290 | 0 | 40,580 |
Yes | output | 1 | 20,290 | 0 | 40,581 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s of length n, which consists only of the first k letters of the Latin alphabet. All letters in string s are uppercase.
A subsequence of string s is a string that can be derived from s by deleting some of its symbols without changing the order of the remaining symbols. For example, "ADE" and "BD" are subsequences of "ABCDE", but "DEA" is not.
A subsequence of s called good if the number of occurences of each of the first k letters of the alphabet is the same.
Find the length of the longest good subsequence of s.
Input
The first line of the input contains integers n (1≤ n ≤ 10^5) and k (1 ≤ k ≤ 26).
The second line of the input contains the string s of length n. String s only contains uppercase letters from 'A' to the k-th letter of Latin alphabet.
Output
Print the only integer — the length of the longest good subsequence of string s.
Examples
Input
9 3
ACAABCCAB
Output
6
Input
9 4
ABCABCABC
Output
0
Note
In the first example, "ACBCAB" ("ACAABCCAB") is one of the subsequences that has the same frequency of 'A', 'B' and 'C'. Subsequence "CAB" also has the same frequency of these letters, but doesn't have the maximum possible length.
In the second example, none of the subsequences can have 'D', hence the answer is 0.
Submitted Solution:
```
n,k=map(int,input().split())
l=list(map(str,input().strip()))
s=list(set(l))
temp=[]
if(len(s)!=k):
print(0)
else:
for i in s:
c=l.count(i)
temp.append(c)
temp.sort()
print(k*temp[0])
``` | instruction | 0 | 20,291 | 0 | 40,582 |
Yes | output | 1 | 20,291 | 0 | 40,583 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s of length n, which consists only of the first k letters of the Latin alphabet. All letters in string s are uppercase.
A subsequence of string s is a string that can be derived from s by deleting some of its symbols without changing the order of the remaining symbols. For example, "ADE" and "BD" are subsequences of "ABCDE", but "DEA" is not.
A subsequence of s called good if the number of occurences of each of the first k letters of the alphabet is the same.
Find the length of the longest good subsequence of s.
Input
The first line of the input contains integers n (1≤ n ≤ 10^5) and k (1 ≤ k ≤ 26).
The second line of the input contains the string s of length n. String s only contains uppercase letters from 'A' to the k-th letter of Latin alphabet.
Output
Print the only integer — the length of the longest good subsequence of string s.
Examples
Input
9 3
ACAABCCAB
Output
6
Input
9 4
ABCABCABC
Output
0
Note
In the first example, "ACBCAB" ("ACAABCCAB") is one of the subsequences that has the same frequency of 'A', 'B' and 'C'. Subsequence "CAB" also has the same frequency of these letters, but doesn't have the maximum possible length.
In the second example, none of the subsequences can have 'D', hence the answer is 0.
Submitted Solution:
```
n,k=input().split(" ")
str= input()
alph="ABCDEFGHIJKLMNOPQRSTUVWXYZ"[:int(k)]
i=0
j=0
for s in str:
if i==int(k) :
alph="ABCDEFGHIJKLMNOPQRSTUVWXYZ"[:int(k)]
i=0
if s in alph:
alph=alph.replace(s,"")
i=i+1
j=j+1
if (j)%int(k) is 0:
print(j)
else:
print(0)
``` | instruction | 0 | 20,292 | 0 | 40,584 |
No | output | 1 | 20,292 | 0 | 40,585 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s of length n, which consists only of the first k letters of the Latin alphabet. All letters in string s are uppercase.
A subsequence of string s is a string that can be derived from s by deleting some of its symbols without changing the order of the remaining symbols. For example, "ADE" and "BD" are subsequences of "ABCDE", but "DEA" is not.
A subsequence of s called good if the number of occurences of each of the first k letters of the alphabet is the same.
Find the length of the longest good subsequence of s.
Input
The first line of the input contains integers n (1≤ n ≤ 10^5) and k (1 ≤ k ≤ 26).
The second line of the input contains the string s of length n. String s only contains uppercase letters from 'A' to the k-th letter of Latin alphabet.
Output
Print the only integer — the length of the longest good subsequence of string s.
Examples
Input
9 3
ACAABCCAB
Output
6
Input
9 4
ABCABCABC
Output
0
Note
In the first example, "ACBCAB" ("ACAABCCAB") is one of the subsequences that has the same frequency of 'A', 'B' and 'C'. Subsequence "CAB" also has the same frequency of these letters, but doesn't have the maximum possible length.
In the second example, none of the subsequences can have 'D', hence the answer is 0.
Submitted Solution:
```
def count(l):
count_even = 0
count_odd = 0
for i in l:
if not i % 2:
count_even += 1
else:
count_odd += 1
return count_even, count_odd
def main_function():
n, m = [int(i) for i in input().split(" ")]
s = list(input())
d = {}
for i in s:
if i in d:
d[i] += 1
else:
d[i] = 1
if len(d) < m:
return 0
f = min(d, key=lambda i: d[i])
return d[f]
print(main_function())
``` | instruction | 0 | 20,293 | 0 | 40,586 |
No | output | 1 | 20,293 | 0 | 40,587 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s of length n, which consists only of the first k letters of the Latin alphabet. All letters in string s are uppercase.
A subsequence of string s is a string that can be derived from s by deleting some of its symbols without changing the order of the remaining symbols. For example, "ADE" and "BD" are subsequences of "ABCDE", but "DEA" is not.
A subsequence of s called good if the number of occurences of each of the first k letters of the alphabet is the same.
Find the length of the longest good subsequence of s.
Input
The first line of the input contains integers n (1≤ n ≤ 10^5) and k (1 ≤ k ≤ 26).
The second line of the input contains the string s of length n. String s only contains uppercase letters from 'A' to the k-th letter of Latin alphabet.
Output
Print the only integer — the length of the longest good subsequence of string s.
Examples
Input
9 3
ACAABCCAB
Output
6
Input
9 4
ABCABCABC
Output
0
Note
In the first example, "ACBCAB" ("ACAABCCAB") is one of the subsequences that has the same frequency of 'A', 'B' and 'C'. Subsequence "CAB" also has the same frequency of these letters, but doesn't have the maximum possible length.
In the second example, none of the subsequences can have 'D', hence the answer is 0.
Submitted Solution:
```
n, k = map(int, input().split(" "))
s = input()
arr, str = [], ""
if (k <= n):
for i in s:
if i not in arr:
arr.append(i)
if len(arr) == k:
str += "".join(arr)
arr = []
print(len(str))
else:
print(0)
``` | instruction | 0 | 20,294 | 0 | 40,588 |
No | output | 1 | 20,294 | 0 | 40,589 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s of length n, which consists only of the first k letters of the Latin alphabet. All letters in string s are uppercase.
A subsequence of string s is a string that can be derived from s by deleting some of its symbols without changing the order of the remaining symbols. For example, "ADE" and "BD" are subsequences of "ABCDE", but "DEA" is not.
A subsequence of s called good if the number of occurences of each of the first k letters of the alphabet is the same.
Find the length of the longest good subsequence of s.
Input
The first line of the input contains integers n (1≤ n ≤ 10^5) and k (1 ≤ k ≤ 26).
The second line of the input contains the string s of length n. String s only contains uppercase letters from 'A' to the k-th letter of Latin alphabet.
Output
Print the only integer — the length of the longest good subsequence of string s.
Examples
Input
9 3
ACAABCCAB
Output
6
Input
9 4
ABCABCABC
Output
0
Note
In the first example, "ACBCAB" ("ACAABCCAB") is one of the subsequences that has the same frequency of 'A', 'B' and 'C'. Subsequence "CAB" also has the same frequency of these letters, but doesn't have the maximum possible length.
In the second example, none of the subsequences can have 'D', hence the answer is 0.
Submitted Solution:
```
n,k = map(int,input().split())
s = input()
alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
min = 9999999999999
for i in range(1,k+1):
k = s.count(alpha[i])
if k <= min:
min = k
print(min * k)
``` | instruction | 0 | 20,295 | 0 | 40,590 |
No | output | 1 | 20,295 | 0 | 40,591 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Long ago, when Petya was a schoolboy, he was very much interested in the Petr# language grammar. During one lesson Petya got interested in the following question: how many different continuous substrings starting with the sbegin and ending with the send (it is possible sbegin = send), the given string t has. Substrings are different if and only if their contents aren't equal, their positions of occurence don't matter. Petya wasn't quite good at math, that's why he couldn't count this number. Help him!
Input
The input file consists of three lines. The first line contains string t. The second and the third lines contain the sbegin and send identificators, correspondingly. All three lines are non-empty strings consisting of lowercase Latin letters. The length of each string doesn't exceed 2000 characters.
Output
Output the only number — the amount of different substrings of t that start with sbegin and end with send.
Examples
Input
round
ro
ou
Output
1
Input
codeforces
code
forca
Output
0
Input
abababab
a
b
Output
4
Input
aba
ab
ba
Output
1
Note
In the third sample there are four appropriate different substrings. They are: ab, abab, ababab, abababab.
In the fourth sample identificators intersect. | instruction | 0 | 20,350 | 0 | 40,700 |
Tags: brute force, data structures, hashing, strings
Correct Solution:
```
from functools import cmp_to_key
def calc_lcp(s, sa):
rank = [0 for _ in range(len(s))]
for i in range(len(s)):
rank[sa[i]] = i
lcp = [0 for _ in range(len(s) - 1)]
h = 0
for i in range(len(s)):
if rank[i] < len(s) - 1:
while max(i, sa[rank[i] + 1]) + h < len(s) and s[i + h] == s[sa[rank[i] + 1] + h]:
h += 1
lcp[rank[i]] = h
if h > 0:
h -= 1
return lcp, rank
def suffix_array(s):
sa = [i for i in range(len(s))]
rank = [ord(s[i]) for i in range(len(s))]
k = 1
while k < len(s):
key = [0 for _ in range(len(s))]
base = max(rank) + 2
for i in range(len(s)):
key[i] = rank[i] * base + (rank[i + k] + 1 if i + k < len(s) else 0)
sa.sort(key=(lambda i: key[i]))
rank[sa[0]] = 0
for i in range(1, len(s)):
rank[sa[i]] = rank[sa[i - 1]] if key[sa[i - 1]] == key[sa[i]] else i
k *= 2
# for i in sa:
# print(s[i:])
return sa
def kmp(s, p):
pi = [0 for _ in range(len(p))]
k = 0
for i in range(1, len(p)):
while k > 0 and p[k] != p[i]:
k = pi[k - 1]
if p[k] == p[i]:
k += 1
pi[i] = k
k = 0
resp = []
for i in range(len(s)):
while k > 0 and p[k] != s[i]:
k = pi[k - 1]
if p[k] == s[i]:
k += 1
if k == len(p):
resp.append(i - len(p) + 1)
k = pi[k - 1]
return resp
def lower_bound(list, value):
left = 0
right = len(list)
while left < right:
mid = int((left + right) / 2)
if list[mid] < value:
left = mid + 1
else:
right = mid
return left
s = input()
start = input()
end = input()
indStart = kmp(s, start)
indEnd = kmp(s, end)
if len(indStart) == 0 or len(indEnd) == 0:
print(0)
else:
sa = suffix_array(s)
lcp, rank = calc_lcp(s, sa)
ind = rank[indStart[0]]
for st in indStart:
ind = min(ind, rank[st])
resp = len(indEnd) - lower_bound(indEnd, sa[ind] + max(0, len(start) - len(end)))
while ind < len(lcp) and lcp[ind] >= len(start):
ind += 1
resp += len(indEnd) - lower_bound(indEnd, sa[ind] + max(0, max(lcp[ind - 1] + 1, len(start)) - len(end)))
print(resp)
# Made By Mostafa_Khaled
``` | output | 1 | 20,350 | 0 | 40,701 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Tonio has a keyboard with only two letters, "V" and "K".
One day, he has typed out a string s with only these two letters. He really likes it when the string "VK" appears, so he wishes to change at most one letter in the string (or do no changes) to maximize the number of occurrences of that string. Compute the maximum number of times "VK" can appear as a substring (i. e. a letter "K" right after a letter "V") in the resulting string.
Input
The first line will contain a string s consisting only of uppercase English letters "V" and "K" with length not less than 1 and not greater than 100.
Output
Output a single integer, the maximum number of times "VK" can appear as a substring of the given string after changing at most one character.
Examples
Input
VK
Output
1
Input
VV
Output
1
Input
V
Output
0
Input
VKKKKKKKKKVVVVVVVVVK
Output
3
Input
KVKV
Output
1
Note
For the first case, we do not change any letters. "VK" appears once, which is the maximum number of times it could appear.
For the second case, we can change the second character from a "V" to a "K". This will give us the string "VK". This has one occurrence of the string "VK" as a substring.
For the fourth case, we can change the fourth character from a "K" to a "V". This will give us the string "VKKVKKKKKKVVVVVVVVVK". This has three occurrences of the string "VK" as a substring. We can check no other moves can give us strictly more occurrences. | instruction | 0 | 20,827 | 0 | 41,654 |
Tags: brute force
Correct Solution:
```
s = input().strip()
s = s.replace("VK", "*")
cnt = sum(map(lambda x: x=="*",s))
if "VV" in s or "KK" in s:
cnt +=1
print(cnt)
``` | output | 1 | 20,827 | 0 | 41,655 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Tonio has a keyboard with only two letters, "V" and "K".
One day, he has typed out a string s with only these two letters. He really likes it when the string "VK" appears, so he wishes to change at most one letter in the string (or do no changes) to maximize the number of occurrences of that string. Compute the maximum number of times "VK" can appear as a substring (i. e. a letter "K" right after a letter "V") in the resulting string.
Input
The first line will contain a string s consisting only of uppercase English letters "V" and "K" with length not less than 1 and not greater than 100.
Output
Output a single integer, the maximum number of times "VK" can appear as a substring of the given string after changing at most one character.
Examples
Input
VK
Output
1
Input
VV
Output
1
Input
V
Output
0
Input
VKKKKKKKKKVVVVVVVVVK
Output
3
Input
KVKV
Output
1
Note
For the first case, we do not change any letters. "VK" appears once, which is the maximum number of times it could appear.
For the second case, we can change the second character from a "V" to a "K". This will give us the string "VK". This has one occurrence of the string "VK" as a substring.
For the fourth case, we can change the fourth character from a "K" to a "V". This will give us the string "VKKVKKKKKKVVVVVVVVVK". This has three occurrences of the string "VK" as a substring. We can check no other moves can give us strictly more occurrences. | instruction | 0 | 20,828 | 0 | 41,656 |
Tags: brute force
Correct Solution:
```
s=input()
cnt=s.count("VK")
s=s.replace("VK"," ")
if ("VV" in s) or ("KK" in s):
cnt+=1
print(cnt)
``` | output | 1 | 20,828 | 0 | 41,657 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Tonio has a keyboard with only two letters, "V" and "K".
One day, he has typed out a string s with only these two letters. He really likes it when the string "VK" appears, so he wishes to change at most one letter in the string (or do no changes) to maximize the number of occurrences of that string. Compute the maximum number of times "VK" can appear as a substring (i. e. a letter "K" right after a letter "V") in the resulting string.
Input
The first line will contain a string s consisting only of uppercase English letters "V" and "K" with length not less than 1 and not greater than 100.
Output
Output a single integer, the maximum number of times "VK" can appear as a substring of the given string after changing at most one character.
Examples
Input
VK
Output
1
Input
VV
Output
1
Input
V
Output
0
Input
VKKKKKKKKKVVVVVVVVVK
Output
3
Input
KVKV
Output
1
Note
For the first case, we do not change any letters. "VK" appears once, which is the maximum number of times it could appear.
For the second case, we can change the second character from a "V" to a "K". This will give us the string "VK". This has one occurrence of the string "VK" as a substring.
For the fourth case, we can change the fourth character from a "K" to a "V". This will give us the string "VKKVKKKKKKVVVVVVVVVK". This has three occurrences of the string "VK" as a substring. We can check no other moves can give us strictly more occurrences. | instruction | 0 | 20,829 | 0 | 41,658 |
Tags: brute force
Correct Solution:
```
s=list(input())
n=len(s)
x,y=0,0
for i in range(n-1):
if(s[i]=='V' and s[i+1]=='K'):
s[i],s[i+1]='k','k'
x=x+1
s=''.join(s)
if('VV' in s or 'KK' in s):
x=x+1
print(x)
``` | output | 1 | 20,829 | 0 | 41,659 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Tonio has a keyboard with only two letters, "V" and "K".
One day, he has typed out a string s with only these two letters. He really likes it when the string "VK" appears, so he wishes to change at most one letter in the string (or do no changes) to maximize the number of occurrences of that string. Compute the maximum number of times "VK" can appear as a substring (i. e. a letter "K" right after a letter "V") in the resulting string.
Input
The first line will contain a string s consisting only of uppercase English letters "V" and "K" with length not less than 1 and not greater than 100.
Output
Output a single integer, the maximum number of times "VK" can appear as a substring of the given string after changing at most one character.
Examples
Input
VK
Output
1
Input
VV
Output
1
Input
V
Output
0
Input
VKKKKKKKKKVVVVVVVVVK
Output
3
Input
KVKV
Output
1
Note
For the first case, we do not change any letters. "VK" appears once, which is the maximum number of times it could appear.
For the second case, we can change the second character from a "V" to a "K". This will give us the string "VK". This has one occurrence of the string "VK" as a substring.
For the fourth case, we can change the fourth character from a "K" to a "V". This will give us the string "VKKVKKKKKKVVVVVVVVVK". This has three occurrences of the string "VK" as a substring. We can check no other moves can give us strictly more occurrences. | instruction | 0 | 20,830 | 0 | 41,660 |
Tags: brute force
Correct Solution:
```
def main():
a = input()
b = {}
pairs = 0
max = 0
b[0] = 0
for i in range(1, len(a)):
if a[i] is a[i-1]:
b[i] = b[i-1] + 1
elif a[i] is 'K':
pairs += 1
b[i-1] -= 1
b[i] = -1
else:
b[i] = 0
for i in range(1, len(a)):
if max < b[i]:
max = b[i]
if max > 0:
pairs += 1
print(pairs)
if __name__=='__main__':
main()
``` | output | 1 | 20,830 | 0 | 41,661 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Tonio has a keyboard with only two letters, "V" and "K".
One day, he has typed out a string s with only these two letters. He really likes it when the string "VK" appears, so he wishes to change at most one letter in the string (or do no changes) to maximize the number of occurrences of that string. Compute the maximum number of times "VK" can appear as a substring (i. e. a letter "K" right after a letter "V") in the resulting string.
Input
The first line will contain a string s consisting only of uppercase English letters "V" and "K" with length not less than 1 and not greater than 100.
Output
Output a single integer, the maximum number of times "VK" can appear as a substring of the given string after changing at most one character.
Examples
Input
VK
Output
1
Input
VV
Output
1
Input
V
Output
0
Input
VKKKKKKKKKVVVVVVVVVK
Output
3
Input
KVKV
Output
1
Note
For the first case, we do not change any letters. "VK" appears once, which is the maximum number of times it could appear.
For the second case, we can change the second character from a "V" to a "K". This will give us the string "VK". This has one occurrence of the string "VK" as a substring.
For the fourth case, we can change the fourth character from a "K" to a "V". This will give us the string "VKKVKKKKKKVVVVVVVVVK". This has three occurrences of the string "VK" as a substring. We can check no other moves can give us strictly more occurrences. | instruction | 0 | 20,831 | 0 | 41,662 |
Tags: brute force
Correct Solution:
```
a = input()
m = a.count('VK')
for i in range(len(a)):
if a[i] == 'V': a = a[:i]+'K'+a[i+1:]
else: a = a[:i]+'V'+a[i+1:]
if a.count('VK')>m: m = a.count('VK')
if a[i] == 'V': a = a[:i]+'K'+a[i+1:]
else: a = a[:i]+'V'+a[i+1:]
print(m)
``` | output | 1 | 20,831 | 0 | 41,663 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Tonio has a keyboard with only two letters, "V" and "K".
One day, he has typed out a string s with only these two letters. He really likes it when the string "VK" appears, so he wishes to change at most one letter in the string (or do no changes) to maximize the number of occurrences of that string. Compute the maximum number of times "VK" can appear as a substring (i. e. a letter "K" right after a letter "V") in the resulting string.
Input
The first line will contain a string s consisting only of uppercase English letters "V" and "K" with length not less than 1 and not greater than 100.
Output
Output a single integer, the maximum number of times "VK" can appear as a substring of the given string after changing at most one character.
Examples
Input
VK
Output
1
Input
VV
Output
1
Input
V
Output
0
Input
VKKKKKKKKKVVVVVVVVVK
Output
3
Input
KVKV
Output
1
Note
For the first case, we do not change any letters. "VK" appears once, which is the maximum number of times it could appear.
For the second case, we can change the second character from a "V" to a "K". This will give us the string "VK". This has one occurrence of the string "VK" as a substring.
For the fourth case, we can change the fourth character from a "K" to a "V". This will give us the string "VKKVKKKKKKVVVVVVVVVK". This has three occurrences of the string "VK" as a substring. We can check no other moves can give us strictly more occurrences. | instruction | 0 | 20,832 | 0 | 41,664 |
Tags: brute force
Correct Solution:
```
string = input()
length = len(string)
maximum = 0
j=0
for i in range(length-1):
if(string[i] == 'V' and string[i+1] == 'K'):
j+=1
if(j>maximum):
maximum = j
if(string[0] == 'V'):
string = 'K'+string[1:]
else:
string = 'V'+string[1:]
j=0
for i in range(length-1):
if(string[i] == 'V' and string[i+1] == 'K'):
j+=1
if(j>maximum):
maximum = j
for counter in range(1,length):
if(string[counter-1] == 'V'):
string = string[:counter-1]+'K'+string[counter:]
else:
string = string[:counter-1]+'V'+string[counter:]
if(string[counter] == 'V'):
string = string[:counter]+'K'+string[counter+1:]
else:
string = string[:counter]+'V'+string[counter+1:]
j=0
for i in range(length-1):
if(string[i] == 'V' and string[i+1] == 'K'):
j+=1
if(j>maximum):
maximum = j
print(maximum)
``` | output | 1 | 20,832 | 0 | 41,665 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Tonio has a keyboard with only two letters, "V" and "K".
One day, he has typed out a string s with only these two letters. He really likes it when the string "VK" appears, so he wishes to change at most one letter in the string (or do no changes) to maximize the number of occurrences of that string. Compute the maximum number of times "VK" can appear as a substring (i. e. a letter "K" right after a letter "V") in the resulting string.
Input
The first line will contain a string s consisting only of uppercase English letters "V" and "K" with length not less than 1 and not greater than 100.
Output
Output a single integer, the maximum number of times "VK" can appear as a substring of the given string after changing at most one character.
Examples
Input
VK
Output
1
Input
VV
Output
1
Input
V
Output
0
Input
VKKKKKKKKKVVVVVVVVVK
Output
3
Input
KVKV
Output
1
Note
For the first case, we do not change any letters. "VK" appears once, which is the maximum number of times it could appear.
For the second case, we can change the second character from a "V" to a "K". This will give us the string "VK". This has one occurrence of the string "VK" as a substring.
For the fourth case, we can change the fourth character from a "K" to a "V". This will give us the string "VKKVKKKKKKVVVVVVVVVK". This has three occurrences of the string "VK" as a substring. We can check no other moves can give us strictly more occurrences. | instruction | 0 | 20,833 | 0 | 41,666 |
Tags: brute force
Correct Solution:
```
def str_finder(s):
counter = counter_str(s)
for i in range(len(s)):
if s[i] == "V":
new = s[:i] + 'K' + s[i + 1:]
else:
new = s[:i] + 'V' + s[i + 1:]
if counter_str(new) > counter:
counter = counter_str(new)
return counter
def counter_str(s):
count = 0
for i in range(len(s) - 1):
if s[i] == "V" and s[i + 1] == "K":
count += 1
return count
if __name__ == '__main__':
n = str(input())
print(str_finder(n))
``` | output | 1 | 20,833 | 0 | 41,667 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Tonio has a keyboard with only two letters, "V" and "K".
One day, he has typed out a string s with only these two letters. He really likes it when the string "VK" appears, so he wishes to change at most one letter in the string (or do no changes) to maximize the number of occurrences of that string. Compute the maximum number of times "VK" can appear as a substring (i. e. a letter "K" right after a letter "V") in the resulting string.
Input
The first line will contain a string s consisting only of uppercase English letters "V" and "K" with length not less than 1 and not greater than 100.
Output
Output a single integer, the maximum number of times "VK" can appear as a substring of the given string after changing at most one character.
Examples
Input
VK
Output
1
Input
VV
Output
1
Input
V
Output
0
Input
VKKKKKKKKKVVVVVVVVVK
Output
3
Input
KVKV
Output
1
Note
For the first case, we do not change any letters. "VK" appears once, which is the maximum number of times it could appear.
For the second case, we can change the second character from a "V" to a "K". This will give us the string "VK". This has one occurrence of the string "VK" as a substring.
For the fourth case, we can change the fourth character from a "K" to a "V". This will give us the string "VKKVKKKKKKVVVVVVVVVK". This has three occurrences of the string "VK" as a substring. We can check no other moves can give us strictly more occurrences. | instruction | 0 | 20,834 | 0 | 41,668 |
Tags: brute force
Correct Solution:
```
s = 'K' + input() + 'V'
print(s.count('VK') + ('VVV' in s or 'KKK' in s))
``` | output | 1 | 20,834 | 0 | 41,669 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tonio has a keyboard with only two letters, "V" and "K".
One day, he has typed out a string s with only these two letters. He really likes it when the string "VK" appears, so he wishes to change at most one letter in the string (or do no changes) to maximize the number of occurrences of that string. Compute the maximum number of times "VK" can appear as a substring (i. e. a letter "K" right after a letter "V") in the resulting string.
Input
The first line will contain a string s consisting only of uppercase English letters "V" and "K" with length not less than 1 and not greater than 100.
Output
Output a single integer, the maximum number of times "VK" can appear as a substring of the given string after changing at most one character.
Examples
Input
VK
Output
1
Input
VV
Output
1
Input
V
Output
0
Input
VKKKKKKKKKVVVVVVVVVK
Output
3
Input
KVKV
Output
1
Note
For the first case, we do not change any letters. "VK" appears once, which is the maximum number of times it could appear.
For the second case, we can change the second character from a "V" to a "K". This will give us the string "VK". This has one occurrence of the string "VK" as a substring.
For the fourth case, we can change the fourth character from a "K" to a "V". This will give us the string "VKKVKKKKKKVVVVVVVVVK". This has three occurrences of the string "VK" as a substring. We can check no other moves can give us strictly more occurrences.
Submitted Solution:
```
from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
def main():
pass
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
str1 = input().rstrip()
count1 = 0
str2 = 0
for i in range(len(str1)-1):
if str1[i] == "V" and str1[i+1] == "K":
count1 += 1
if i == len(str1)-2:
if str1[i] == "V" and str1[i+1] == "V":
str2 = 1
elif str1[i] == "K" and str1[i+1] == "K":
if str1[i-1] != "V":
str2 = 1
elif i == 0:
if str1[i] == "K" and str1[i+1] == "K":
str2 = 1
elif str1[i] == "V" and str1[i+1] == "V":
if str1[i+1] == "V" and str1[i+2] != "K":
str2 = 1
else:
if str1[i] == "V" and str1[i+1] == "V":
if str1[i+1] == "V" and str1[i+2] != "K":
str2 = 1
elif str1[i] == "K" and str1[i+1] == "K":
if str1[i-1] != "V":
str2 = 1
print(count1+str2)
``` | instruction | 0 | 20,835 | 0 | 41,670 |
Yes | output | 1 | 20,835 | 0 | 41,671 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tonio has a keyboard with only two letters, "V" and "K".
One day, he has typed out a string s with only these two letters. He really likes it when the string "VK" appears, so he wishes to change at most one letter in the string (or do no changes) to maximize the number of occurrences of that string. Compute the maximum number of times "VK" can appear as a substring (i. e. a letter "K" right after a letter "V") in the resulting string.
Input
The first line will contain a string s consisting only of uppercase English letters "V" and "K" with length not less than 1 and not greater than 100.
Output
Output a single integer, the maximum number of times "VK" can appear as a substring of the given string after changing at most one character.
Examples
Input
VK
Output
1
Input
VV
Output
1
Input
V
Output
0
Input
VKKKKKKKKKVVVVVVVVVK
Output
3
Input
KVKV
Output
1
Note
For the first case, we do not change any letters. "VK" appears once, which is the maximum number of times it could appear.
For the second case, we can change the second character from a "V" to a "K". This will give us the string "VK". This has one occurrence of the string "VK" as a substring.
For the fourth case, we can change the fourth character from a "K" to a "V". This will give us the string "VKKVKKKKKKVVVVVVVVVK". This has three occurrences of the string "VK" as a substring. We can check no other moves can give us strictly more occurrences.
Submitted Solution:
```
a = input()
c = a.count("VK")
a = a.replace("VK","_")
if "VV" in a or "KK" in a:
c += 1
print(c)
``` | instruction | 0 | 20,836 | 0 | 41,672 |
Yes | output | 1 | 20,836 | 0 | 41,673 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tonio has a keyboard with only two letters, "V" and "K".
One day, he has typed out a string s with only these two letters. He really likes it when the string "VK" appears, so he wishes to change at most one letter in the string (or do no changes) to maximize the number of occurrences of that string. Compute the maximum number of times "VK" can appear as a substring (i. e. a letter "K" right after a letter "V") in the resulting string.
Input
The first line will contain a string s consisting only of uppercase English letters "V" and "K" with length not less than 1 and not greater than 100.
Output
Output a single integer, the maximum number of times "VK" can appear as a substring of the given string after changing at most one character.
Examples
Input
VK
Output
1
Input
VV
Output
1
Input
V
Output
0
Input
VKKKKKKKKKVVVVVVVVVK
Output
3
Input
KVKV
Output
1
Note
For the first case, we do not change any letters. "VK" appears once, which is the maximum number of times it could appear.
For the second case, we can change the second character from a "V" to a "K". This will give us the string "VK". This has one occurrence of the string "VK" as a substring.
For the fourth case, we can change the fourth character from a "K" to a "V". This will give us the string "VKKVKKKKKKVVVVVVVVVK". This has three occurrences of the string "VK" as a substring. We can check no other moves can give us strictly more occurrences.
Submitted Solution:
```
import sys
def solve():
s = [ch for ch in input()]
ans = ''.join(s).count('VK')
for i in range(len(s)):
if s[i] == 'V':
s[i] = 'K'
tmp = ''.join(s).count('VK')
ans = max(ans, tmp)
s[i] = 'V'
else:
s[i] = 'V'
tmp = ''.join(s).count('VK')
ans = max(ans, tmp)
s[i] = 'K'
print(ans)
def debug(x, table):
for name, val in table.items():
if x is val:
print('DEBUG:{} -> {}'.format(name, val), file=sys.stderr)
return None
if __name__ == '__main__':
solve()
``` | instruction | 0 | 20,837 | 0 | 41,674 |
Yes | output | 1 | 20,837 | 0 | 41,675 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tonio has a keyboard with only two letters, "V" and "K".
One day, he has typed out a string s with only these two letters. He really likes it when the string "VK" appears, so he wishes to change at most one letter in the string (or do no changes) to maximize the number of occurrences of that string. Compute the maximum number of times "VK" can appear as a substring (i. e. a letter "K" right after a letter "V") in the resulting string.
Input
The first line will contain a string s consisting only of uppercase English letters "V" and "K" with length not less than 1 and not greater than 100.
Output
Output a single integer, the maximum number of times "VK" can appear as a substring of the given string after changing at most one character.
Examples
Input
VK
Output
1
Input
VV
Output
1
Input
V
Output
0
Input
VKKKKKKKKKVVVVVVVVVK
Output
3
Input
KVKV
Output
1
Note
For the first case, we do not change any letters. "VK" appears once, which is the maximum number of times it could appear.
For the second case, we can change the second character from a "V" to a "K". This will give us the string "VK". This has one occurrence of the string "VK" as a substring.
For the fourth case, we can change the fourth character from a "K" to a "V". This will give us the string "VKKVKKKKKKVVVVVVVVVK". This has three occurrences of the string "VK" as a substring. We can check no other moves can give us strictly more occurrences.
Submitted Solution:
```
s=input()
m=s.count('VK')
for i in range(len(s)):
s2=s[:i]+'V'+s[i+1:]
s3=s[:i]+'K'+s[i+1:]
m=max(m,s2.count('VK'))
m=max(m,s3.count('VK'))
#print(s2,s3)
print(m)
``` | instruction | 0 | 20,838 | 0 | 41,676 |
Yes | output | 1 | 20,838 | 0 | 41,677 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tonio has a keyboard with only two letters, "V" and "K".
One day, he has typed out a string s with only these two letters. He really likes it when the string "VK" appears, so he wishes to change at most one letter in the string (or do no changes) to maximize the number of occurrences of that string. Compute the maximum number of times "VK" can appear as a substring (i. e. a letter "K" right after a letter "V") in the resulting string.
Input
The first line will contain a string s consisting only of uppercase English letters "V" and "K" with length not less than 1 and not greater than 100.
Output
Output a single integer, the maximum number of times "VK" can appear as a substring of the given string after changing at most one character.
Examples
Input
VK
Output
1
Input
VV
Output
1
Input
V
Output
0
Input
VKKKKKKKKKVVVVVVVVVK
Output
3
Input
KVKV
Output
1
Note
For the first case, we do not change any letters. "VK" appears once, which is the maximum number of times it could appear.
For the second case, we can change the second character from a "V" to a "K". This will give us the string "VK". This has one occurrence of the string "VK" as a substring.
For the fourth case, we can change the fourth character from a "K" to a "V". This will give us the string "VKKVKKKKKKVVVVVVVVVK". This has three occurrences of the string "VK" as a substring. We can check no other moves can give us strictly more occurrences.
Submitted Solution:
```
s=input()
a=s.count("VK")
b=s.count("KKK")
c=s.count("VVV")
if(a==0):
b=s.count("VV")
c=s.count("KK")
if(c>0 or b>0):
a+=1
print(a)
``` | instruction | 0 | 20,839 | 0 | 41,678 |
No | output | 1 | 20,839 | 0 | 41,679 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tonio has a keyboard with only two letters, "V" and "K".
One day, he has typed out a string s with only these two letters. He really likes it when the string "VK" appears, so he wishes to change at most one letter in the string (or do no changes) to maximize the number of occurrences of that string. Compute the maximum number of times "VK" can appear as a substring (i. e. a letter "K" right after a letter "V") in the resulting string.
Input
The first line will contain a string s consisting only of uppercase English letters "V" and "K" with length not less than 1 and not greater than 100.
Output
Output a single integer, the maximum number of times "VK" can appear as a substring of the given string after changing at most one character.
Examples
Input
VK
Output
1
Input
VV
Output
1
Input
V
Output
0
Input
VKKKKKKKKKVVVVVVVVVK
Output
3
Input
KVKV
Output
1
Note
For the first case, we do not change any letters. "VK" appears once, which is the maximum number of times it could appear.
For the second case, we can change the second character from a "V" to a "K". This will give us the string "VK". This has one occurrence of the string "VK" as a substring.
For the fourth case, we can change the fourth character from a "K" to a "V". This will give us the string "VKKVKKKKKKVVVVVVVVVK". This has three occurrences of the string "VK" as a substring. We can check no other moves can give us strictly more occurrences.
Submitted Solution:
```
s=str(input())
res=0
a=[0 for i in range(len(s)+1)]
for i in range(0,len(s)):
if s[i]=='V':
a[i]=0
else :
a[i]=1
for i in range(0,len(s)):
a[i]=1-a[i]
cnt=0
for j in range(len(s)-1):
print("casd")
if a[j]==0 and a[j+1]==1:
cnt+=1
if res<cnt:
res=cnt
a[i]=1-a[i]
print(res)
``` | instruction | 0 | 20,840 | 0 | 41,680 |
No | output | 1 | 20,840 | 0 | 41,681 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tonio has a keyboard with only two letters, "V" and "K".
One day, he has typed out a string s with only these two letters. He really likes it when the string "VK" appears, so he wishes to change at most one letter in the string (or do no changes) to maximize the number of occurrences of that string. Compute the maximum number of times "VK" can appear as a substring (i. e. a letter "K" right after a letter "V") in the resulting string.
Input
The first line will contain a string s consisting only of uppercase English letters "V" and "K" with length not less than 1 and not greater than 100.
Output
Output a single integer, the maximum number of times "VK" can appear as a substring of the given string after changing at most one character.
Examples
Input
VK
Output
1
Input
VV
Output
1
Input
V
Output
0
Input
VKKKKKKKKKVVVVVVVVVK
Output
3
Input
KVKV
Output
1
Note
For the first case, we do not change any letters. "VK" appears once, which is the maximum number of times it could appear.
For the second case, we can change the second character from a "V" to a "K". This will give us the string "VK". This has one occurrence of the string "VK" as a substring.
For the fourth case, we can change the fourth character from a "K" to a "V". This will give us the string "VKKVKKKKKKVVVVVVVVVK". This has three occurrences of the string "VK" as a substring. We can check no other moves can give us strictly more occurrences.
Submitted Solution:
```
s=input()
ans=0
for i in range(len(s)-1):
if s[i]+s[i+1]=='VK':ans+=1
print(ans+int('VVV'in s or'KKK'in s or s=='VV'or s=='KK'))
``` | instruction | 0 | 20,841 | 0 | 41,682 |
No | output | 1 | 20,841 | 0 | 41,683 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tonio has a keyboard with only two letters, "V" and "K".
One day, he has typed out a string s with only these two letters. He really likes it when the string "VK" appears, so he wishes to change at most one letter in the string (or do no changes) to maximize the number of occurrences of that string. Compute the maximum number of times "VK" can appear as a substring (i. e. a letter "K" right after a letter "V") in the resulting string.
Input
The first line will contain a string s consisting only of uppercase English letters "V" and "K" with length not less than 1 and not greater than 100.
Output
Output a single integer, the maximum number of times "VK" can appear as a substring of the given string after changing at most one character.
Examples
Input
VK
Output
1
Input
VV
Output
1
Input
V
Output
0
Input
VKKKKKKKKKVVVVVVVVVK
Output
3
Input
KVKV
Output
1
Note
For the first case, we do not change any letters. "VK" appears once, which is the maximum number of times it could appear.
For the second case, we can change the second character from a "V" to a "K". This will give us the string "VK". This has one occurrence of the string "VK" as a substring.
For the fourth case, we can change the fourth character from a "K" to a "V". This will give us the string "VKKVKKKKKKVVVVVVVVVK". This has three occurrences of the string "VK" as a substring. We can check no other moves can give us strictly more occurrences.
Submitted Solution:
```
s=input()
n=len(s)
z=''
#print(s,' ',z)
k=0
mm=0
vk='VK'
vv='VV'
kk='KK'
while vk in s:
m=s.index(vk)
#print(m)
z=s[:m]
s=s[m+2:]
k+=1
if (vv in z) or (kk in z):
mm=1
#print(s)
#print(z)
if k==0:
z=s
#print(mm)
if (vv in z) or (kk in z):
mm=1
print(k+mm)
``` | instruction | 0 | 20,842 | 0 | 41,684 |
No | output | 1 | 20,842 | 0 | 41,685 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a string s, initially consisting of n lowercase Latin letters. After that, you perform k operations with it, where <image>. During i-th operation you must erase some substring of length exactly 2i - 1 from s.
Print the lexicographically minimal string you may obtain after performing k such operations.
Input
The only line contains one string s consisting of n lowercase Latin letters (1 ≤ n ≤ 5000).
Output
Print the lexicographically minimal string you may obtain after performing k operations.
Examples
Input
adcbca
Output
aba
Input
abacabadabacaba
Output
aabacaba
Note
Possible operations in examples:
1. adcbca <image> adcba <image> aba;
2. abacabadabacaba <image> abcabadabacaba <image> aabadabacaba <image> aabacaba.
Submitted Solution:
```
from math import log
s = input()
n = len(s)
k = int(log(n,2))
l =[]
new = s
for x in range(1,k+1):
l.append(pow(2,x-1))
for j in l:
new = new[:(-j)]
print(new)
``` | instruction | 0 | 20,895 | 0 | 41,790 |
No | output | 1 | 20,895 | 0 | 41,791 |
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, initially consisting of n lowercase Latin letters. After that, you perform k operations with it, where <image>. During i-th operation you must erase some substring of length exactly 2i - 1 from s.
Print the lexicographically minimal string you may obtain after performing k such operations.
Input
The only line contains one string s consisting of n lowercase Latin letters (1 ≤ n ≤ 5000).
Output
Print the lexicographically minimal string you may obtain after performing k operations.
Examples
Input
adcbca
Output
aba
Input
abacabadabacaba
Output
aabacaba
Note
Possible operations in examples:
1. adcbca <image> adcba <image> aba;
2. abacabadabacaba <image> abcabadabacaba <image> aabadabacaba <image> aabacaba.
Submitted Solution:
```
from math import log
s = input()
n = len(s)
k = int(log(n,2))
l =[]
new = s
for x in range(1,k+1):
l.append(pow(2,x-1))
for j in l:
new = new[:(-j)]
sorted(new, key=str.lower)
print(new)
``` | instruction | 0 | 20,896 | 0 | 41,792 |
No | output | 1 | 20,896 | 0 | 41,793 |
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, initially consisting of n lowercase Latin letters. After that, you perform k operations with it, where <image>. During i-th operation you must erase some substring of length exactly 2i - 1 from s.
Print the lexicographically minimal string you may obtain after performing k such operations.
Input
The only line contains one string s consisting of n lowercase Latin letters (1 ≤ n ≤ 5000).
Output
Print the lexicographically minimal string you may obtain after performing k operations.
Examples
Input
adcbca
Output
aba
Input
abacabadabacaba
Output
aabacaba
Note
Possible operations in examples:
1. adcbca <image> adcba <image> aba;
2. abacabadabacaba <image> abcabadabacaba <image> aabadabacaba <image> aabacaba.
Submitted Solution:
```
from math import *
inp_str = input()
def erase(str_inp):
length = len(str_inp)
log_len = floor(log(length,2))
for i in range(0,log_len):
for j in range(length):
len1 = 2**(log_len-i-1)
if(j == (length - len1)):
str_inp=str_inp[:j]
break
else:
str1=str_inp[j:j+len1]
str2=str_inp[j+1:j+len1+1]
if(str1 > str2):
str_inp=str_inp[:j]+str_inp[j+len1:]
break
print(str_inp)
erase(inp_str)
``` | instruction | 0 | 20,897 | 0 | 41,794 |
No | output | 1 | 20,897 | 0 | 41,795 |
Provide a correct Python 3 solution for this coding contest problem.
You have two strings A = A_1 A_2 ... A_n and B = B_1 B_2 ... B_n of the same length consisting of 0 and 1.
You can transform A using the following operations in any order and as many times as you want:
* Shift A by one character to the left (i.e., if A = A_1 A_2 ... A_n, replace A with A_2 A_3 ... A_n A_1).
* Shift A by one character to the right (i.e., if A = A_1 A_2 ... A_n, replace A with A_n A_1 A_2 ... A_{n-1}).
* Choose any i such that B_i = 1. Flip A_i (i.e., set A_i = 1 - A_i).
You goal is to make strings A and B equal.
Print the smallest number of operations required to achieve this, or -1 if the goal is unreachable.
Constraints
* 1 \leq |A| = |B| \leq 2,000
* A and B consist of 0 and 1.
Input
Input is given from Standard Input in the following format:
A
B
Output
Print the smallest number of operations required to make strings A and B equal, or -1 if the goal is unreachable.
Examples
Input
1010
1100
Output
3
Input
1
0
Output
-1
Input
11010
10001
Output
4
Input
0100100
1111111
Output
5 | instruction | 0 | 21,023 | 0 | 42,046 |
"Correct Solution:
```
A=input()
B=input()
N=len(A)
if B.count("1")==0:
if A==B:
print(0)
else:
print(-1)
exit()
L=[-1]*N
R=[-1]*N
for i in range(N):
id=0
while B[(i-id)%N]!="1":
id+=1
L[i]=id
id=0
while B[(i+id)%N]!="1":
id+=1
R[i]=id
ans=10**18
for i in range(N):
#Left
rtemp=[[] for j in range(N)]
lmin=[i]*N
for j in range(N):
if A[j]!=B[(j-i)%N]:
rtemp[R[j]].append(L[j])
for j in range(N-2,-1,-1):
temp=lmin[j+1]
for val in rtemp[j+1]:
temp=max(temp,val)
lmin[j]=temp
test=0
for j in range(N):
if A[(j+i)%N]!=B[j]:
test+=1
for j in range(N):
temp=i+2*j+2*(lmin[j]-i)
ans=min(test+temp,ans)
#Right
ltemp=[[] for j in range(N)]
rmin=[N-i]*N
for j in range(N):
if A[j]!=B[(j-i)%N]:
ltemp[L[j]].append(R[j])
for j in range(N-2,-1,-1):
temp=rmin[j+1]
for val in ltemp[j+1]:
temp=max(temp,val)
rmin[j]=temp
test=0
for j in range(N):
if A[(j+i)%N]!=B[j]:
test+=1
for j in range(N):
temp=N-i+2*j+2*(rmin[j]-(N-i))
ans=min(ans,test+temp)
print(ans)
``` | output | 1 | 21,023 | 0 | 42,047 |
Provide a correct Python 3 solution for this coding contest problem.
You have two strings A = A_1 A_2 ... A_n and B = B_1 B_2 ... B_n of the same length consisting of 0 and 1.
You can transform A using the following operations in any order and as many times as you want:
* Shift A by one character to the left (i.e., if A = A_1 A_2 ... A_n, replace A with A_2 A_3 ... A_n A_1).
* Shift A by one character to the right (i.e., if A = A_1 A_2 ... A_n, replace A with A_n A_1 A_2 ... A_{n-1}).
* Choose any i such that B_i = 1. Flip A_i (i.e., set A_i = 1 - A_i).
You goal is to make strings A and B equal.
Print the smallest number of operations required to achieve this, or -1 if the goal is unreachable.
Constraints
* 1 \leq |A| = |B| \leq 2,000
* A and B consist of 0 and 1.
Input
Input is given from Standard Input in the following format:
A
B
Output
Print the smallest number of operations required to make strings A and B equal, or -1 if the goal is unreachable.
Examples
Input
1010
1100
Output
3
Input
1
0
Output
-1
Input
11010
10001
Output
4
Input
0100100
1111111
Output
5 | instruction | 0 | 21,024 | 0 | 42,048 |
"Correct Solution:
```
import sys
readline = sys.stdin.readline
A = list(map(int, readline().strip()))
B = list(map(int, readline().strip()))
N = len(A)
Ao = A[:]
inf = 10**9+7
if sum(B):
ans = inf
CRo = [None]*N
A2 = A + A
B2 = B + B
pre = None
for i in range(2*N-1, N-1, -1):
if B2[i]:
pre = i
for i in range(N-1, -1, -1):
if B2[i]:
pre = i
CRo[i] = pre - i
prel = None
for i in range(N-1, -1, -1):
if B[i]:
prel = i - N
break
prer = None
for i in range(N):
if B[i]:
prer = N + i
break
CLo = [None]*N
pre = prel
for i in range(N):
if B[i]:
pre = i
CLo[i] = i - pre
CR = CRo[:]
for j in range(N):
C = [a^b for a, b in zip(A, B)]
for i in range(N):
if B[i]:
CR[i] = 0
res = sum(C)
if res >= ans:
A = A[1:] + [A[0]]
CR = CR[1:] + [CR[0]]
continue
CL = [0]*N
pre = prel
for i in range(N):
if B[i]:
pre = i
if C[i]:
CL[i] = i - pre
mc = max(CL)
table = [0]*(1+mc)
for i in range(N):
if CL[i]:
table[CL[i]] = max(table[CL[i]], CR[i])
cnt = min(N, 2*mc)
for i in range(mc-1, -1, -1):
table[i] = max(table[i+1], table[i])
for i in range(mc):
cnt = min(cnt, 2*i+2*table[i+1])
ans = min(ans, res + cnt + j)
A = A[1:] + [A[0]]
CR = CR[1:] + [CR[0]]
A = Ao
CL = CLo[:]
for j in range(N):
C = [a^b for a, b in zip(A, B)]
res = sum(C)
for i in range(N):
if B[i]:
CL[i] = 0
if res >= ans:
A = [A[-1]] + A[:-1]
CL = [CL[-1]] + CL[:-1]
continue
CR = [0]*N
pre = prer
for i in range(N-1, -1, -1):
if B[i]:
pre = i
if C[i]:
CR[i] = pre - i
mc = max(CR)
table = [0]*(mc+1)
for i in range(N):
if CR[i]:
table[CR[i]] = max(table[CR[i]], CL[i])
for i in range(mc-1, -1, -1):
table[i] = max(table[i+1], table[i])
cnt = min(N, 2*mc)
for i in range(mc):
cnt = min(cnt, 2*i+2*table[i+1])
ans = min(ans, cnt + res + j)
A = [A[-1]] + A[:-1]
CL = [CL[-1]] + CL[:-1]
else:
ans = -1 if sum(A) else 0
print(ans)
``` | output | 1 | 21,024 | 0 | 42,049 |
Provide a correct Python 3 solution for this coding contest problem.
You have two strings A = A_1 A_2 ... A_n and B = B_1 B_2 ... B_n of the same length consisting of 0 and 1.
You can transform A using the following operations in any order and as many times as you want:
* Shift A by one character to the left (i.e., if A = A_1 A_2 ... A_n, replace A with A_2 A_3 ... A_n A_1).
* Shift A by one character to the right (i.e., if A = A_1 A_2 ... A_n, replace A with A_n A_1 A_2 ... A_{n-1}).
* Choose any i such that B_i = 1. Flip A_i (i.e., set A_i = 1 - A_i).
You goal is to make strings A and B equal.
Print the smallest number of operations required to achieve this, or -1 if the goal is unreachable.
Constraints
* 1 \leq |A| = |B| \leq 2,000
* A and B consist of 0 and 1.
Input
Input is given from Standard Input in the following format:
A
B
Output
Print the smallest number of operations required to make strings A and B equal, or -1 if the goal is unreachable.
Examples
Input
1010
1100
Output
3
Input
1
0
Output
-1
Input
11010
10001
Output
4
Input
0100100
1111111
Output
5 | instruction | 0 | 21,027 | 0 | 42,054 |
"Correct Solution:
```
mod = 1000000007
eps = 10**-9
def main():
import sys
input = sys.stdin.readline
A = input().rstrip('\n')
B = input().rstrip('\n')
N = len(A)
if A == B:
print(0)
exit()
if int(B) == 0:
print(-1)
exit()
def solve(A, B):
left = [0] * N
right = [0] * N
for i in range(N):
for j in range(N):
if B[(i-j)%N] == "1":
left[i] = j
break
for i in range(N):
for j in range(N):
if B[(i+j)%N] == "1":
right[i] = j
break
ret = 10**9
for k in range(N):
f = 0
i_list = []
for i in range(N):
if A[i] != B[(i-k)%N]:
f += 1
i_list.append(i)
lr = [0] * N
lmax = 0
rmax = 0
for i in i_list:
if left[i] <= k:
continue
lr[left[i] - k] = max(lr[left[i] - k], right[i])
lmax = max(lmax, left[i] - k)
ret = min(ret, f + 2 * lmax + k)
for l in range(N-1, 0, -1):
rmax = max(rmax, lr[l])
ret = min(ret, f + 2 * (l - 1 + rmax) + k)
return ret
print(min(solve(A, B), solve(A[::-1], B[::-1])))
if __name__ == '__main__':
main()
``` | output | 1 | 21,027 | 0 | 42,055 |
Provide a correct Python 3 solution for this coding contest problem.
You have two strings A = A_1 A_2 ... A_n and B = B_1 B_2 ... B_n of the same length consisting of 0 and 1.
You can transform A using the following operations in any order and as many times as you want:
* Shift A by one character to the left (i.e., if A = A_1 A_2 ... A_n, replace A with A_2 A_3 ... A_n A_1).
* Shift A by one character to the right (i.e., if A = A_1 A_2 ... A_n, replace A with A_n A_1 A_2 ... A_{n-1}).
* Choose any i such that B_i = 1. Flip A_i (i.e., set A_i = 1 - A_i).
You goal is to make strings A and B equal.
Print the smallest number of operations required to achieve this, or -1 if the goal is unreachable.
Constraints
* 1 \leq |A| = |B| \leq 2,000
* A and B consist of 0 and 1.
Input
Input is given from Standard Input in the following format:
A
B
Output
Print the smallest number of operations required to make strings A and B equal, or -1 if the goal is unreachable.
Examples
Input
1010
1100
Output
3
Input
1
0
Output
-1
Input
11010
10001
Output
4
Input
0100100
1111111
Output
5 | instruction | 0 | 21,028 | 0 | 42,056 |
"Correct Solution:
```
import math
import fractions
#import sys
#input = sys.stdin.readline
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
# divisors.sort()
return divisors
def ValueToBits(x,digit):
res = [0 for i in range(digit)]
now = x
for i in range(digit):
res[i]=now%2
now = now >> 1
return res
def BitsToValue(arr):
n = len(arr)
ans = 0
for i in range(n):
ans+= arr[i] * 2**i
return ans
def ZipArray(a):
aa = [[a[i],i]for i in range(n)]
aa.sort(key = lambda x : x[0])
for i in range(n):
aa[i][0]=i+1
aa.sort(key = lambda x : x[1])
b=[aa[i][0] for i in range(len(a))]
return b
def ValueToArray10(x, digit):
ans = [0 for i in range(digit)]
now = x
for i in range(digit):
ans[digit-i-1] = now%10
now = now //10
return ans
def Zeros(a,b):
if(b<=-1):
return [0 for i in range(a)]
else:
return [[0 for i in range(b)] for i in range(a)]
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
'''
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
p = 2
N = 10 ** 6 + 2
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, N + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
'''
#a = list(map(int, input().split()))
#################################################
#################################################
#################################################
#################################################
#11:00
in1 = input()
in2 = input()
n = len(in1)
a,b = [],[]
for i in range(n):
a.append(int(in1[i]))
b.append(int(in2[i]))
if(sum(b)==0):
if(sum(a)==0):
print(0)
else:
print(-1)
exit()
ok=1
for i in range(n):
if(a[i]!=b[i]):
ok=0
if(ok==1):
print(0)
exit()
####
left = []
rightest = -1-n
for i in range(n):
if(b[i]==1):
rightest = i-n
for i in range(n):
if(b[i]==1):
rightest = i
left.append(rightest-i)
right = []
leftest = 2*n
for i in range(n):
if(b[n-1-i]==1):
leftest = n-1-i +n
for i in range(n):
if(b[n-1-i]==1):
leftest = n-1-i
right.append(leftest - (n-1-i))
right = [right[n-1-i] for i in range(n)]
#print(left,right)
ans = 10**18
for i in range(n):
toFix = [0 for i in range(n)]
lrs = []
for j in range(n):
ij = (i+j)%n
if(a[j]!=b[ij]):
toFix[j]=1
lrs.append([left[j],right[j]])
lrs.sort(key = lambda x : x[0])
#print(lrs)
if(len(lrs)==0):
ans = min(ans,i,n-i)
continue
leftmin = lrs[0][0]
leftmax = lrs[-1][0]
rightmin = n
for j in lrs:
rightmin = min(rightmin,j[1])
rangemin = leftmin
rangemax = leftmax
for j in range(len(lrs)):
dist = len(lrs)
dist += abs(rangemin)
dist += abs(rangemax-rangemin)
dist1 = dist + abs(rangemax-i)
dist2 = dist + abs(rangemax-(i-n))
dist = len(lrs)
dist += abs(rangemax)
dist += abs(rangemax-rangemin)
dist3 = dist + abs(rangemin-i)
dist4 = dist + abs(rangemin-(i-n))
#print(dist1,dist2,dist3,dist4,rangemin,rangemax)
ans = min(ans,dist1,dist2,dist3,dist4)
rangemin = lrs[(j+1)%len(lrs)][0]
rangemax = max(rangemax,lrs[j][1])
rangemin = rightmin
dist = len(lrs)
dist += abs(rangemin)
dist += abs(rangemax-rangemin)
dist1 = dist + abs(rangemax-i)
dist2 = dist + abs(rangemax-(i-n))
dist = len(lrs)
dist += abs(rangemax)
dist += abs(rangemax-rangemin)
dist3 = dist + abs(rangemin-i)
dist4 = dist + abs(rangemin-(i-n))
#print(dist1,dist2,dist3,dist4,rangemin,rangemax)
ans = min(ans,dist1,dist2,dist3,dist4)
#print(i,"finish")
print(ans)
``` | output | 1 | 21,028 | 0 | 42,057 |
Provide a correct Python 3 solution for this coding contest problem.
You have two strings A = A_1 A_2 ... A_n and B = B_1 B_2 ... B_n of the same length consisting of 0 and 1.
You can transform A using the following operations in any order and as many times as you want:
* Shift A by one character to the left (i.e., if A = A_1 A_2 ... A_n, replace A with A_2 A_3 ... A_n A_1).
* Shift A by one character to the right (i.e., if A = A_1 A_2 ... A_n, replace A with A_n A_1 A_2 ... A_{n-1}).
* Choose any i such that B_i = 1. Flip A_i (i.e., set A_i = 1 - A_i).
You goal is to make strings A and B equal.
Print the smallest number of operations required to achieve this, or -1 if the goal is unreachable.
Constraints
* 1 \leq |A| = |B| \leq 2,000
* A and B consist of 0 and 1.
Input
Input is given from Standard Input in the following format:
A
B
Output
Print the smallest number of operations required to make strings A and B equal, or -1 if the goal is unreachable.
Examples
Input
1010
1100
Output
3
Input
1
0
Output
-1
Input
11010
10001
Output
4
Input
0100100
1111111
Output
5 | instruction | 0 | 21,029 | 0 | 42,058 |
"Correct Solution:
```
INF=10**18
A=list(map(lambda x:ord(x)-48,list(input())))
B=list(map(lambda x:ord(x)-48,list(input())))
fl=False
for i in B:
fl|=i
if fl==False:
for i in A:
if i:
print("-1")
exit(0)
print("0")
exit(0)
n=len(A)
bi=[]
for i in range(n):
bi.append([0,0,i])
for j in range(n):
if B[(i-j)%n]:
bi[i][0]=-j
break
for j in range(n):
if B[(i+j)%n]:
bi[i][1]=j
break
bi.sort()
ans=INF
def Update(d):
q=[]
nr=max(0,d)
for i in range(n):
x=bi[i][2]
if A[x]!=B[(x+d)%n]:
q.append(bi[i][:2])
ans=INF
for i in q:
ans=min(ans,2*(nr-min(0,min(d,i[0])))-abs(d))
nr=max(nr,i[1])
ans=min(ans,2*(nr-min(0,d))-abs(d))+len(q)
return ans
for i in range(-n,n):
ans=min(ans,Update(i))
print(ans)
``` | output | 1 | 21,029 | 0 | 42,059 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A non-empty string is called palindrome, if it reads the same from the left to the right and from the right to the left. For example, "abcba", "a", and "abba" are palindromes, while "abab" and "xy" are not.
A string is called a substring of another string, if it can be obtained from that string by dropping some (possibly zero) number of characters from the beginning and from the end of it. For example, "abc", "ab", and "c" are substrings of the string "abc", while "ac" and "d" are not.
Let's define a palindromic count of the string as the number of its substrings that are palindromes. For example, the palindromic count of the string "aaa" is 6 because all its substrings are palindromes, and the palindromic count of the string "abc" is 3 because only its substrings of length 1 are palindromes.
You are given a string s. You can arbitrarily rearrange its characters. You goal is to obtain a string with the maximum possible value of palindromic count.
Input
The first line contains an integer n (1 ≤ n ≤ 100 000) — the length of string s.
The second line contains string s that consists of exactly n lowercase characters of Latin alphabet.
Output
Print string t, which consists of the same set of characters (and each characters appears exactly the same number of times) as string s. Moreover, t should have the maximum possible value of palindromic count among all such strings strings.
If there are multiple such strings, print any of them.
Examples
Input
5
oolol
Output
ololo
Input
16
gagadbcgghhchbdf
Output
abccbaghghghgdfd
Note
In the first example, string "ololo" has 9 palindromic substrings: "o", "l", "o", "l", "o", "olo", "lol", "olo", "ololo". Note, that even though some substrings coincide, they are counted as many times as they appear in the resulting string.
In the second example, the palindromic count of string "abccbaghghghgdfd" is 29. | instruction | 0 | 21,197 | 0 | 42,394 |
Tags: constructive algorithms, strings
Correct Solution:
```
input()
print("".join(sorted(input())))
``` | output | 1 | 21,197 | 0 | 42,395 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A non-empty string is called palindrome, if it reads the same from the left to the right and from the right to the left. For example, "abcba", "a", and "abba" are palindromes, while "abab" and "xy" are not.
A string is called a substring of another string, if it can be obtained from that string by dropping some (possibly zero) number of characters from the beginning and from the end of it. For example, "abc", "ab", and "c" are substrings of the string "abc", while "ac" and "d" are not.
Let's define a palindromic count of the string as the number of its substrings that are palindromes. For example, the palindromic count of the string "aaa" is 6 because all its substrings are palindromes, and the palindromic count of the string "abc" is 3 because only its substrings of length 1 are palindromes.
You are given a string s. You can arbitrarily rearrange its characters. You goal is to obtain a string with the maximum possible value of palindromic count.
Input
The first line contains an integer n (1 ≤ n ≤ 100 000) — the length of string s.
The second line contains string s that consists of exactly n lowercase characters of Latin alphabet.
Output
Print string t, which consists of the same set of characters (and each characters appears exactly the same number of times) as string s. Moreover, t should have the maximum possible value of palindromic count among all such strings strings.
If there are multiple such strings, print any of them.
Examples
Input
5
oolol
Output
ololo
Input
16
gagadbcgghhchbdf
Output
abccbaghghghgdfd
Note
In the first example, string "ololo" has 9 palindromic substrings: "o", "l", "o", "l", "o", "olo", "lol", "olo", "ololo". Note, that even though some substrings coincide, they are counted as many times as they appear in the resulting string.
In the second example, the palindromic count of string "abccbaghghghgdfd" is 29. | instruction | 0 | 21,198 | 0 | 42,396 |
Tags: constructive algorithms, strings
Correct Solution:
```
from sys import stdin,stdout
n = stdin.readline()
b = [(lambda s : sorted(s))(list(stdin.readline()))]
stdout.write(''.join(b[0]))
``` | output | 1 | 21,198 | 0 | 42,397 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A non-empty string is called palindrome, if it reads the same from the left to the right and from the right to the left. For example, "abcba", "a", and "abba" are palindromes, while "abab" and "xy" are not.
A string is called a substring of another string, if it can be obtained from that string by dropping some (possibly zero) number of characters from the beginning and from the end of it. For example, "abc", "ab", and "c" are substrings of the string "abc", while "ac" and "d" are not.
Let's define a palindromic count of the string as the number of its substrings that are palindromes. For example, the palindromic count of the string "aaa" is 6 because all its substrings are palindromes, and the palindromic count of the string "abc" is 3 because only its substrings of length 1 are palindromes.
You are given a string s. You can arbitrarily rearrange its characters. You goal is to obtain a string with the maximum possible value of palindromic count.
Input
The first line contains an integer n (1 ≤ n ≤ 100 000) — the length of string s.
The second line contains string s that consists of exactly n lowercase characters of Latin alphabet.
Output
Print string t, which consists of the same set of characters (and each characters appears exactly the same number of times) as string s. Moreover, t should have the maximum possible value of palindromic count among all such strings strings.
If there are multiple such strings, print any of them.
Examples
Input
5
oolol
Output
ololo
Input
16
gagadbcgghhchbdf
Output
abccbaghghghgdfd
Note
In the first example, string "ololo" has 9 palindromic substrings: "o", "l", "o", "l", "o", "olo", "lol", "olo", "ololo". Note, that even though some substrings coincide, they are counted as many times as they appear in the resulting string.
In the second example, the palindromic count of string "abccbaghghghgdfd" is 29. | instruction | 0 | 21,199 | 0 | 42,398 |
Tags: constructive algorithms, strings
Correct Solution:
```
import math
def is_palindrome(string):
up_to_not_including = math.ceil(len(string))
for i in range(up_to_not_including):
if string[i] != string[len(string) - 1 - i]:
return False
return True
def count(string):
print(string)
count = 0
for i in range(0, len(string) + 1):
for j in range(i + 1, len(string) + 1):
if is_palindrome(string[i:j]):
count +=1
return count
def solve(string):
frequencies = {}
for char in string:
frequencies[char] = frequencies.get(char, 0) + 1
to_join = []
for char, freq in frequencies.items():
to_join.append(char * freq)
return "".join(to_join)
n = int(input())
string = input()[:n]
solution = solve(string)
print(solution)
``` | output | 1 | 21,199 | 0 | 42,399 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A non-empty string is called palindrome, if it reads the same from the left to the right and from the right to the left. For example, "abcba", "a", and "abba" are palindromes, while "abab" and "xy" are not.
A string is called a substring of another string, if it can be obtained from that string by dropping some (possibly zero) number of characters from the beginning and from the end of it. For example, "abc", "ab", and "c" are substrings of the string "abc", while "ac" and "d" are not.
Let's define a palindromic count of the string as the number of its substrings that are palindromes. For example, the palindromic count of the string "aaa" is 6 because all its substrings are palindromes, and the palindromic count of the string "abc" is 3 because only its substrings of length 1 are palindromes.
You are given a string s. You can arbitrarily rearrange its characters. You goal is to obtain a string with the maximum possible value of palindromic count.
Input
The first line contains an integer n (1 ≤ n ≤ 100 000) — the length of string s.
The second line contains string s that consists of exactly n lowercase characters of Latin alphabet.
Output
Print string t, which consists of the same set of characters (and each characters appears exactly the same number of times) as string s. Moreover, t should have the maximum possible value of palindromic count among all such strings strings.
If there are multiple such strings, print any of them.
Examples
Input
5
oolol
Output
ololo
Input
16
gagadbcgghhchbdf
Output
abccbaghghghgdfd
Note
In the first example, string "ololo" has 9 palindromic substrings: "o", "l", "o", "l", "o", "olo", "lol", "olo", "ololo". Note, that even though some substrings coincide, they are counted as many times as they appear in the resulting string.
In the second example, the palindromic count of string "abccbaghghghgdfd" is 29. | instruction | 0 | 21,200 | 0 | 42,400 |
Tags: constructive algorithms, strings
Correct Solution:
```
nn=int(input())
xx=list(input())
xx.sort()
a=''.join(xx)
print(a)
``` | output | 1 | 21,200 | 0 | 42,401 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A non-empty string is called palindrome, if it reads the same from the left to the right and from the right to the left. For example, "abcba", "a", and "abba" are palindromes, while "abab" and "xy" are not.
A string is called a substring of another string, if it can be obtained from that string by dropping some (possibly zero) number of characters from the beginning and from the end of it. For example, "abc", "ab", and "c" are substrings of the string "abc", while "ac" and "d" are not.
Let's define a palindromic count of the string as the number of its substrings that are palindromes. For example, the palindromic count of the string "aaa" is 6 because all its substrings are palindromes, and the palindromic count of the string "abc" is 3 because only its substrings of length 1 are palindromes.
You are given a string s. You can arbitrarily rearrange its characters. You goal is to obtain a string with the maximum possible value of palindromic count.
Input
The first line contains an integer n (1 ≤ n ≤ 100 000) — the length of string s.
The second line contains string s that consists of exactly n lowercase characters of Latin alphabet.
Output
Print string t, which consists of the same set of characters (and each characters appears exactly the same number of times) as string s. Moreover, t should have the maximum possible value of palindromic count among all such strings strings.
If there are multiple such strings, print any of them.
Examples
Input
5
oolol
Output
ololo
Input
16
gagadbcgghhchbdf
Output
abccbaghghghgdfd
Note
In the first example, string "ololo" has 9 palindromic substrings: "o", "l", "o", "l", "o", "olo", "lol", "olo", "ololo". Note, that even though some substrings coincide, they are counted as many times as they appear in the resulting string.
In the second example, the palindromic count of string "abccbaghghghgdfd" is 29. | instruction | 0 | 21,201 | 0 | 42,402 |
Tags: constructive algorithms, strings
Correct Solution:
```
input()
print(''.join(sorted(input())))
``` | output | 1 | 21,201 | 0 | 42,403 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A non-empty string is called palindrome, if it reads the same from the left to the right and from the right to the left. For example, "abcba", "a", and "abba" are palindromes, while "abab" and "xy" are not.
A string is called a substring of another string, if it can be obtained from that string by dropping some (possibly zero) number of characters from the beginning and from the end of it. For example, "abc", "ab", and "c" are substrings of the string "abc", while "ac" and "d" are not.
Let's define a palindromic count of the string as the number of its substrings that are palindromes. For example, the palindromic count of the string "aaa" is 6 because all its substrings are palindromes, and the palindromic count of the string "abc" is 3 because only its substrings of length 1 are palindromes.
You are given a string s. You can arbitrarily rearrange its characters. You goal is to obtain a string with the maximum possible value of palindromic count.
Input
The first line contains an integer n (1 ≤ n ≤ 100 000) — the length of string s.
The second line contains string s that consists of exactly n lowercase characters of Latin alphabet.
Output
Print string t, which consists of the same set of characters (and each characters appears exactly the same number of times) as string s. Moreover, t should have the maximum possible value of palindromic count among all such strings strings.
If there are multiple such strings, print any of them.
Examples
Input
5
oolol
Output
ololo
Input
16
gagadbcgghhchbdf
Output
abccbaghghghgdfd
Note
In the first example, string "ololo" has 9 palindromic substrings: "o", "l", "o", "l", "o", "olo", "lol", "olo", "ololo". Note, that even though some substrings coincide, they are counted as many times as they appear in the resulting string.
In the second example, the palindromic count of string "abccbaghghghgdfd" is 29. | instruction | 0 | 21,202 | 0 | 42,404 |
Tags: constructive algorithms, strings
Correct Solution:
```
n=int(input());print(''.join(sorted(input())))
``` | output | 1 | 21,202 | 0 | 42,405 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A non-empty string is called palindrome, if it reads the same from the left to the right and from the right to the left. For example, "abcba", "a", and "abba" are palindromes, while "abab" and "xy" are not.
A string is called a substring of another string, if it can be obtained from that string by dropping some (possibly zero) number of characters from the beginning and from the end of it. For example, "abc", "ab", and "c" are substrings of the string "abc", while "ac" and "d" are not.
Let's define a palindromic count of the string as the number of its substrings that are palindromes. For example, the palindromic count of the string "aaa" is 6 because all its substrings are palindromes, and the palindromic count of the string "abc" is 3 because only its substrings of length 1 are palindromes.
You are given a string s. You can arbitrarily rearrange its characters. You goal is to obtain a string with the maximum possible value of palindromic count.
Input
The first line contains an integer n (1 ≤ n ≤ 100 000) — the length of string s.
The second line contains string s that consists of exactly n lowercase characters of Latin alphabet.
Output
Print string t, which consists of the same set of characters (and each characters appears exactly the same number of times) as string s. Moreover, t should have the maximum possible value of palindromic count among all such strings strings.
If there are multiple such strings, print any of them.
Examples
Input
5
oolol
Output
ololo
Input
16
gagadbcgghhchbdf
Output
abccbaghghghgdfd
Note
In the first example, string "ololo" has 9 palindromic substrings: "o", "l", "o", "l", "o", "olo", "lol", "olo", "ololo". Note, that even though some substrings coincide, they are counted as many times as they appear in the resulting string.
In the second example, the palindromic count of string "abccbaghghghgdfd" is 29. | instruction | 0 | 21,203 | 0 | 42,406 |
Tags: constructive algorithms, strings
Correct Solution:
```
input();print(''.join(sorted(list(input()))))
``` | output | 1 | 21,203 | 0 | 42,407 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A non-empty string is called palindrome, if it reads the same from the left to the right and from the right to the left. For example, "abcba", "a", and "abba" are palindromes, while "abab" and "xy" are not.
A string is called a substring of another string, if it can be obtained from that string by dropping some (possibly zero) number of characters from the beginning and from the end of it. For example, "abc", "ab", and "c" are substrings of the string "abc", while "ac" and "d" are not.
Let's define a palindromic count of the string as the number of its substrings that are palindromes. For example, the palindromic count of the string "aaa" is 6 because all its substrings are palindromes, and the palindromic count of the string "abc" is 3 because only its substrings of length 1 are palindromes.
You are given a string s. You can arbitrarily rearrange its characters. You goal is to obtain a string with the maximum possible value of palindromic count.
Input
The first line contains an integer n (1 ≤ n ≤ 100 000) — the length of string s.
The second line contains string s that consists of exactly n lowercase characters of Latin alphabet.
Output
Print string t, which consists of the same set of characters (and each characters appears exactly the same number of times) as string s. Moreover, t should have the maximum possible value of palindromic count among all such strings strings.
If there are multiple such strings, print any of them.
Examples
Input
5
oolol
Output
ololo
Input
16
gagadbcgghhchbdf
Output
abccbaghghghgdfd
Note
In the first example, string "ololo" has 9 palindromic substrings: "o", "l", "o", "l", "o", "olo", "lol", "olo", "ololo". Note, that even though some substrings coincide, they are counted as many times as they appear in the resulting string.
In the second example, the palindromic count of string "abccbaghghghgdfd" is 29. | instruction | 0 | 21,204 | 0 | 42,408 |
Tags: constructive algorithms, strings
Correct Solution:
```
n=int(input())
s=input()
r=sorted(s)
print(''.join(r))
``` | output | 1 | 21,204 | 0 | 42,409 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A non-empty string is called palindrome, if it reads the same from the left to the right and from the right to the left. For example, "abcba", "a", and "abba" are palindromes, while "abab" and "xy" are not.
A string is called a substring of another string, if it can be obtained from that string by dropping some (possibly zero) number of characters from the beginning and from the end of it. For example, "abc", "ab", and "c" are substrings of the string "abc", while "ac" and "d" are not.
Let's define a palindromic count of the string as the number of its substrings that are palindromes. For example, the palindromic count of the string "aaa" is 6 because all its substrings are palindromes, and the palindromic count of the string "abc" is 3 because only its substrings of length 1 are palindromes.
You are given a string s. You can arbitrarily rearrange its characters. You goal is to obtain a string with the maximum possible value of palindromic count.
Input
The first line contains an integer n (1 ≤ n ≤ 100 000) — the length of string s.
The second line contains string s that consists of exactly n lowercase characters of Latin alphabet.
Output
Print string t, which consists of the same set of characters (and each characters appears exactly the same number of times) as string s. Moreover, t should have the maximum possible value of palindromic count among all such strings strings.
If there are multiple such strings, print any of them.
Examples
Input
5
oolol
Output
ololo
Input
16
gagadbcgghhchbdf
Output
abccbaghghghgdfd
Note
In the first example, string "ololo" has 9 palindromic substrings: "o", "l", "o", "l", "o", "olo", "lol", "olo", "ololo". Note, that even though some substrings coincide, they are counted as many times as they appear in the resulting string.
In the second example, the palindromic count of string "abccbaghghghgdfd" is 29.
Submitted Solution:
```
from collections import Counter
n = int(input())
st = input()
x = Counter(st)
if len(x.items())<2:
print(st)
else:
res=''
for i in x.items():
res+=i[0]*i[1]
print(res)
``` | instruction | 0 | 21,205 | 0 | 42,410 |
Yes | output | 1 | 21,205 | 0 | 42,411 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A non-empty string is called palindrome, if it reads the same from the left to the right and from the right to the left. For example, "abcba", "a", and "abba" are palindromes, while "abab" and "xy" are not.
A string is called a substring of another string, if it can be obtained from that string by dropping some (possibly zero) number of characters from the beginning and from the end of it. For example, "abc", "ab", and "c" are substrings of the string "abc", while "ac" and "d" are not.
Let's define a palindromic count of the string as the number of its substrings that are palindromes. For example, the palindromic count of the string "aaa" is 6 because all its substrings are palindromes, and the palindromic count of the string "abc" is 3 because only its substrings of length 1 are palindromes.
You are given a string s. You can arbitrarily rearrange its characters. You goal is to obtain a string with the maximum possible value of palindromic count.
Input
The first line contains an integer n (1 ≤ n ≤ 100 000) — the length of string s.
The second line contains string s that consists of exactly n lowercase characters of Latin alphabet.
Output
Print string t, which consists of the same set of characters (and each characters appears exactly the same number of times) as string s. Moreover, t should have the maximum possible value of palindromic count among all such strings strings.
If there are multiple such strings, print any of them.
Examples
Input
5
oolol
Output
ololo
Input
16
gagadbcgghhchbdf
Output
abccbaghghghgdfd
Note
In the first example, string "ololo" has 9 palindromic substrings: "o", "l", "o", "l", "o", "olo", "lol", "olo", "ololo". Note, that even though some substrings coincide, they are counted as many times as they appear in the resulting string.
In the second example, the palindromic count of string "abccbaghghghgdfd" is 29.
Submitted Solution:
```
n = int(input())
s = input()
print(*sorted(list(s)),sep='')
``` | instruction | 0 | 21,206 | 0 | 42,412 |
Yes | output | 1 | 21,206 | 0 | 42,413 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A non-empty string is called palindrome, if it reads the same from the left to the right and from the right to the left. For example, "abcba", "a", and "abba" are palindromes, while "abab" and "xy" are not.
A string is called a substring of another string, if it can be obtained from that string by dropping some (possibly zero) number of characters from the beginning and from the end of it. For example, "abc", "ab", and "c" are substrings of the string "abc", while "ac" and "d" are not.
Let's define a palindromic count of the string as the number of its substrings that are palindromes. For example, the palindromic count of the string "aaa" is 6 because all its substrings are palindromes, and the palindromic count of the string "abc" is 3 because only its substrings of length 1 are palindromes.
You are given a string s. You can arbitrarily rearrange its characters. You goal is to obtain a string with the maximum possible value of palindromic count.
Input
The first line contains an integer n (1 ≤ n ≤ 100 000) — the length of string s.
The second line contains string s that consists of exactly n lowercase characters of Latin alphabet.
Output
Print string t, which consists of the same set of characters (and each characters appears exactly the same number of times) as string s. Moreover, t should have the maximum possible value of palindromic count among all such strings strings.
If there are multiple such strings, print any of them.
Examples
Input
5
oolol
Output
ololo
Input
16
gagadbcgghhchbdf
Output
abccbaghghghgdfd
Note
In the first example, string "ololo" has 9 palindromic substrings: "o", "l", "o", "l", "o", "olo", "lol", "olo", "ololo". Note, that even though some substrings coincide, they are counted as many times as they appear in the resulting string.
In the second example, the palindromic count of string "abccbaghghghgdfd" is 29.
Submitted Solution:
```
n=int(input())
word=list(input())
word.sort()
print(''.join(word))
``` | instruction | 0 | 21,207 | 0 | 42,414 |
Yes | output | 1 | 21,207 | 0 | 42,415 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A non-empty string is called palindrome, if it reads the same from the left to the right and from the right to the left. For example, "abcba", "a", and "abba" are palindromes, while "abab" and "xy" are not.
A string is called a substring of another string, if it can be obtained from that string by dropping some (possibly zero) number of characters from the beginning and from the end of it. For example, "abc", "ab", and "c" are substrings of the string "abc", while "ac" and "d" are not.
Let's define a palindromic count of the string as the number of its substrings that are palindromes. For example, the palindromic count of the string "aaa" is 6 because all its substrings are palindromes, and the palindromic count of the string "abc" is 3 because only its substrings of length 1 are palindromes.
You are given a string s. You can arbitrarily rearrange its characters. You goal is to obtain a string with the maximum possible value of palindromic count.
Input
The first line contains an integer n (1 ≤ n ≤ 100 000) — the length of string s.
The second line contains string s that consists of exactly n lowercase characters of Latin alphabet.
Output
Print string t, which consists of the same set of characters (and each characters appears exactly the same number of times) as string s. Moreover, t should have the maximum possible value of palindromic count among all such strings strings.
If there are multiple such strings, print any of them.
Examples
Input
5
oolol
Output
ololo
Input
16
gagadbcgghhchbdf
Output
abccbaghghghgdfd
Note
In the first example, string "ololo" has 9 palindromic substrings: "o", "l", "o", "l", "o", "olo", "lol", "olo", "ololo". Note, that even though some substrings coincide, they are counted as many times as they appear in the resulting string.
In the second example, the palindromic count of string "abccbaghghghgdfd" is 29.
Submitted Solution:
```
n = int(input())
s = input()
l = [i for i in s]
l.sort()
for i in l:
print(i, end = "")
``` | instruction | 0 | 21,208 | 0 | 42,416 |
Yes | output | 1 | 21,208 | 0 | 42,417 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A non-empty string is called palindrome, if it reads the same from the left to the right and from the right to the left. For example, "abcba", "a", and "abba" are palindromes, while "abab" and "xy" are not.
A string is called a substring of another string, if it can be obtained from that string by dropping some (possibly zero) number of characters from the beginning and from the end of it. For example, "abc", "ab", and "c" are substrings of the string "abc", while "ac" and "d" are not.
Let's define a palindromic count of the string as the number of its substrings that are palindromes. For example, the palindromic count of the string "aaa" is 6 because all its substrings are palindromes, and the palindromic count of the string "abc" is 3 because only its substrings of length 1 are palindromes.
You are given a string s. You can arbitrarily rearrange its characters. You goal is to obtain a string with the maximum possible value of palindromic count.
Input
The first line contains an integer n (1 ≤ n ≤ 100 000) — the length of string s.
The second line contains string s that consists of exactly n lowercase characters of Latin alphabet.
Output
Print string t, which consists of the same set of characters (and each characters appears exactly the same number of times) as string s. Moreover, t should have the maximum possible value of palindromic count among all such strings strings.
If there are multiple such strings, print any of them.
Examples
Input
5
oolol
Output
ololo
Input
16
gagadbcgghhchbdf
Output
abccbaghghghgdfd
Note
In the first example, string "ololo" has 9 palindromic substrings: "o", "l", "o", "l", "o", "olo", "lol", "olo", "ololo". Note, that even though some substrings coincide, they are counted as many times as they appear in the resulting string.
In the second example, the palindromic count of string "abccbaghghghgdfd" is 29.
Submitted Solution:
```
input()
s=input()
dict = {}
for c in s:
keys=dict.keys()
if c in keys:
dict[c]+=1
else:
dict[c]=1
l = list(dict.items())
news=''
l.sort(key=lambda x: -x[1])
for i in range(0,len(l),2):
if i+1==len(l):
for k in range(0,l[i][1]):
news+=l[i][0]
else:
bb=l[i][1]
aa=l[i+1][1]
for k in range(0,(bb-aa)//2):
news+=l[i][0]
for k in range(0,aa):
news+=l[i][0]
news+=l[i+1][0]
for k in range(0,(bb-aa)//2+(bb-aa)%2):
news+=l[i][0]
print(news)
``` | instruction | 0 | 21,209 | 0 | 42,418 |
No | output | 1 | 21,209 | 0 | 42,419 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A non-empty string is called palindrome, if it reads the same from the left to the right and from the right to the left. For example, "abcba", "a", and "abba" are palindromes, while "abab" and "xy" are not.
A string is called a substring of another string, if it can be obtained from that string by dropping some (possibly zero) number of characters from the beginning and from the end of it. For example, "abc", "ab", and "c" are substrings of the string "abc", while "ac" and "d" are not.
Let's define a palindromic count of the string as the number of its substrings that are palindromes. For example, the palindromic count of the string "aaa" is 6 because all its substrings are palindromes, and the palindromic count of the string "abc" is 3 because only its substrings of length 1 are palindromes.
You are given a string s. You can arbitrarily rearrange its characters. You goal is to obtain a string with the maximum possible value of palindromic count.
Input
The first line contains an integer n (1 ≤ n ≤ 100 000) — the length of string s.
The second line contains string s that consists of exactly n lowercase characters of Latin alphabet.
Output
Print string t, which consists of the same set of characters (and each characters appears exactly the same number of times) as string s. Moreover, t should have the maximum possible value of palindromic count among all such strings strings.
If there are multiple such strings, print any of them.
Examples
Input
5
oolol
Output
ololo
Input
16
gagadbcgghhchbdf
Output
abccbaghghghgdfd
Note
In the first example, string "ololo" has 9 palindromic substrings: "o", "l", "o", "l", "o", "olo", "lol", "olo", "ololo". Note, that even though some substrings coincide, they are counted as many times as they appear in the resulting string.
In the second example, the palindromic count of string "abccbaghghghgdfd" is 29.
Submitted Solution:
```
a = {}
s = input()
s1 = ''
for i in range(len(s)):
if s[i] not in a:
a[s[i]] = 1
else:
a[s[i]] += 1
for i in a:
s1 += str(i) * a[i]
print(s1)
``` | instruction | 0 | 21,210 | 0 | 42,420 |
No | output | 1 | 21,210 | 0 | 42,421 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A non-empty string is called palindrome, if it reads the same from the left to the right and from the right to the left. For example, "abcba", "a", and "abba" are palindromes, while "abab" and "xy" are not.
A string is called a substring of another string, if it can be obtained from that string by dropping some (possibly zero) number of characters from the beginning and from the end of it. For example, "abc", "ab", and "c" are substrings of the string "abc", while "ac" and "d" are not.
Let's define a palindromic count of the string as the number of its substrings that are palindromes. For example, the palindromic count of the string "aaa" is 6 because all its substrings are palindromes, and the palindromic count of the string "abc" is 3 because only its substrings of length 1 are palindromes.
You are given a string s. You can arbitrarily rearrange its characters. You goal is to obtain a string with the maximum possible value of palindromic count.
Input
The first line contains an integer n (1 ≤ n ≤ 100 000) — the length of string s.
The second line contains string s that consists of exactly n lowercase characters of Latin alphabet.
Output
Print string t, which consists of the same set of characters (and each characters appears exactly the same number of times) as string s. Moreover, t should have the maximum possible value of palindromic count among all such strings strings.
If there are multiple such strings, print any of them.
Examples
Input
5
oolol
Output
ololo
Input
16
gagadbcgghhchbdf
Output
abccbaghghghgdfd
Note
In the first example, string "ololo" has 9 palindromic substrings: "o", "l", "o", "l", "o", "olo", "lol", "olo", "ololo". Note, that even though some substrings coincide, they are counted as many times as they appear in the resulting string.
In the second example, the palindromic count of string "abccbaghghghgdfd" is 29.
Submitted Solution:
```
n = input()
s = input()
d = dict()
for i in s:
d[i] = d.get(i, 0) + 1
print(d)
st = ''
for key in d.keys():
st += key * d[key]
print(st)
``` | instruction | 0 | 21,211 | 0 | 42,422 |
No | output | 1 | 21,211 | 0 | 42,423 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.