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 n strings s_1, s_2, …, s_n consisting of lowercase Latin letters.
In one operation you can remove a character from a string s_i and insert it to an arbitrary position in a string s_j (j may be equal to i). You may perform this operation any number of times. Is it possible to make all n strings equal?
Input
The first line contains t (1 ≤ t ≤ 10): the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 1000): the number of strings.
n lines follow, the i-th line contains s_i (1 ≤ \lvert s_i \rvert ≤ 1000).
The sum of lengths of all strings in all test cases does not exceed 1000.
Output
If it is possible to make the strings equal, print "YES" (without quotes).
Otherwise, print "NO" (without quotes).
You can output each character in either lowercase or uppercase.
Example
Input
4
2
caa
cbb
3
cba
cba
cbb
4
ccab
cbac
bca
acbcc
4
acb
caf
c
cbafc
Output
YES
NO
YES
NO
Note
In the first test case, you can do the following:
* Remove the third character of the first string and insert it after the second character of the second string, making the two strings "ca" and "cbab" respectively.
* Remove the second character of the second string and insert it after the second character of the first string, making both strings equal to "cab".
In the second test case, it is impossible to make all n strings equal. | instruction | 0 | 42,267 | 0 | 84,534 |
Tags: greedy, strings
Correct Solution:
```
t=int(input())
for i in range(t):
n=int(input())
a=[]
for i in range(n):
s=input()
a.append(s)
d={}
for i in range(len(a)):
for j in range(len(a[i])):
if a[i][j] in d:
d[a[i][j]]+=1
else:
d[a[i][j]]=1
ans=1
for i in list(d.values()):
if i%n!=0:
ans=0
break
if ans==0:
print("NO")
else:
print("YES")
``` | output | 1 | 42,267 | 0 | 84,535 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n strings s_1, s_2, …, s_n consisting of lowercase Latin letters.
In one operation you can remove a character from a string s_i and insert it to an arbitrary position in a string s_j (j may be equal to i). You may perform this operation any number of times. Is it possible to make all n strings equal?
Input
The first line contains t (1 ≤ t ≤ 10): the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 1000): the number of strings.
n lines follow, the i-th line contains s_i (1 ≤ \lvert s_i \rvert ≤ 1000).
The sum of lengths of all strings in all test cases does not exceed 1000.
Output
If it is possible to make the strings equal, print "YES" (without quotes).
Otherwise, print "NO" (without quotes).
You can output each character in either lowercase or uppercase.
Example
Input
4
2
caa
cbb
3
cba
cba
cbb
4
ccab
cbac
bca
acbcc
4
acb
caf
c
cbafc
Output
YES
NO
YES
NO
Note
In the first test case, you can do the following:
* Remove the third character of the first string and insert it after the second character of the second string, making the two strings "ca" and "cbab" respectively.
* Remove the second character of the second string and insert it after the second character of the first string, making both strings equal to "cab".
In the second test case, it is impossible to make all n strings equal. | instruction | 0 | 42,268 | 0 | 84,536 |
Tags: greedy, strings
Correct Solution:
```
from collections import Counter
def solve(p,n):
for j in p:
if p[j]%n!=0:return 'NO'
return 'YES'
for j in range(int(input())):
n=int(input())
ans=""
for i in range(n):
ans+=input()
p=Counter(ans)
print(solve(p,n))
``` | output | 1 | 42,268 | 0 | 84,537 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n strings s_1, s_2, …, s_n consisting of lowercase Latin letters.
In one operation you can remove a character from a string s_i and insert it to an arbitrary position in a string s_j (j may be equal to i). You may perform this operation any number of times. Is it possible to make all n strings equal?
Input
The first line contains t (1 ≤ t ≤ 10): the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 1000): the number of strings.
n lines follow, the i-th line contains s_i (1 ≤ \lvert s_i \rvert ≤ 1000).
The sum of lengths of all strings in all test cases does not exceed 1000.
Output
If it is possible to make the strings equal, print "YES" (without quotes).
Otherwise, print "NO" (without quotes).
You can output each character in either lowercase or uppercase.
Example
Input
4
2
caa
cbb
3
cba
cba
cbb
4
ccab
cbac
bca
acbcc
4
acb
caf
c
cbafc
Output
YES
NO
YES
NO
Note
In the first test case, you can do the following:
* Remove the third character of the first string and insert it after the second character of the second string, making the two strings "ca" and "cbab" respectively.
* Remove the second character of the second string and insert it after the second character of the first string, making both strings equal to "cab".
In the second test case, it is impossible to make all n strings equal.
Submitted Solution:
```
for t in range(int(input())):
n=int(input())
d={}
for i in range(n):
for j in input():
if j not in d.keys():
d[j]=1
else:
d[j]+=1
f=0
for i in d.keys():
if d[i]%n!=0:
f=1
print("NO")
break
if f==0:
print("YES")
``` | instruction | 0 | 42,269 | 0 | 84,538 |
Yes | output | 1 | 42,269 | 0 | 84,539 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n strings s_1, s_2, …, s_n consisting of lowercase Latin letters.
In one operation you can remove a character from a string s_i and insert it to an arbitrary position in a string s_j (j may be equal to i). You may perform this operation any number of times. Is it possible to make all n strings equal?
Input
The first line contains t (1 ≤ t ≤ 10): the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 1000): the number of strings.
n lines follow, the i-th line contains s_i (1 ≤ \lvert s_i \rvert ≤ 1000).
The sum of lengths of all strings in all test cases does not exceed 1000.
Output
If it is possible to make the strings equal, print "YES" (without quotes).
Otherwise, print "NO" (without quotes).
You can output each character in either lowercase or uppercase.
Example
Input
4
2
caa
cbb
3
cba
cba
cbb
4
ccab
cbac
bca
acbcc
4
acb
caf
c
cbafc
Output
YES
NO
YES
NO
Note
In the first test case, you can do the following:
* Remove the third character of the first string and insert it after the second character of the second string, making the two strings "ca" and "cbab" respectively.
* Remove the second character of the second string and insert it after the second character of the first string, making both strings equal to "cab".
In the second test case, it is impossible to make all n strings equal.
Submitted Solution:
```
# def isPalindrome(word):
# i = 0
# j = len(word) - 1
# while i < j:
# if word[i] != word[j]:
# return False
# i+=1
# j-=1
# return True
# def longestPalindrome(string):
# length = len(string)
# maxLength = len(string)
# while maxLength > 1:
# start = 0
# while start <= length - maxLength:
# end = start + maxLength
# if isPalindrome(string[start:end]):
# return string[start:end]
# start += 1
# maxLength -= 1
# return False
# n = input()
# print(longestPalindrome(n))
# GOOGLE FOOBAR CHALLENGES
# from math import sqrt
# def solution(area):
# # Your code here
# ans = []
# while area:
# square = int(sqrt(area))
# ans.append(square**2)
# area -= square**2
# return ans
# print(solution(12))
# def solution(l, t):
# sum = 0
# i = 0
# n = len(l)
# for x in range(n):
# sum += l[x]
# # print(sum)
# if sum > t:
# while sum > t and i <= x:
# # print("sum in while: ", sum)
# sum -= l[i]
# i += 1
# if sum==t:
# return [i, x]
# return [-1, -1]
# print(solution([4, 3, 10, 2, 8], 2100))
# from fractions import Fraction
# def solution(pegs):
# n = len(pegs)
# default_ans = [-1, -1]
# if(n<2):
# return default_ans
# par = (n%2 == 0)
# add = 0
# if par:
# add = -pegs[0] + pegs[n-1]
# else:
# add = -pegs[0] - pegs[n-1]
# if n>2:
# for i in range(1, n-1):
# add += 2*(-1)**(i+1)*pegs[i]
# rad = 0
# if par:
# rad = Fraction(2*float(add)/3).limit_denominator()
# else:
# rad = 2*Fraction(add).limit_denominator()
# if rad < 2:
# return default_ans
# temp = rad
# for i in range(n-2):
# dist = pegs[i+1] - pegs[i]
# next = dist - temp
# if temp < 1 or next < 1:
# return default_ans
# else:
# temp = next
# return [rad.numerator, rad.denominator]
# print(solution([4, 30]))
# def getMedian(pandals):
# n = len(pandals)
# if n%2==0:
# median = (pandals[(n-1)//2] + pandals[(n//2)])/2
# else:
# median = pandals[n//2]
# return median
# def getDist(pandals):
# med = getMedian(pandals)
# dist = 0
# for x in range(len(pandals)):
# dist += abs(pandals[x] - med)
# return dist
# t = int(input())
# ans = []
# while t:
# pandals = list(map(int, input().split()))
# n = pandals[0]
# pandals.pop(0)
# pandals.sort()
# dist = getDist(pandals)
# if(dist - int(dist) < 0.0000001):
# dist = int(dist)
# ans.append(dist)
# t -= 1
# for d in ans:
# print(d)
t = int(input())
for _ in range(t):
arr = [0]*26
n = int(input())
for i in range(n):
s = input()
for ch in s:
arr[ord(ch)-ord('a')] += 1
for c in arr:
if c==0:
continue
if c%n != 0:
print("NO")
break
else:
print("YES")
``` | instruction | 0 | 42,270 | 0 | 84,540 |
Yes | output | 1 | 42,270 | 0 | 84,541 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n strings s_1, s_2, …, s_n consisting of lowercase Latin letters.
In one operation you can remove a character from a string s_i and insert it to an arbitrary position in a string s_j (j may be equal to i). You may perform this operation any number of times. Is it possible to make all n strings equal?
Input
The first line contains t (1 ≤ t ≤ 10): the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 1000): the number of strings.
n lines follow, the i-th line contains s_i (1 ≤ \lvert s_i \rvert ≤ 1000).
The sum of lengths of all strings in all test cases does not exceed 1000.
Output
If it is possible to make the strings equal, print "YES" (without quotes).
Otherwise, print "NO" (without quotes).
You can output each character in either lowercase or uppercase.
Example
Input
4
2
caa
cbb
3
cba
cba
cbb
4
ccab
cbac
bca
acbcc
4
acb
caf
c
cbafc
Output
YES
NO
YES
NO
Note
In the first test case, you can do the following:
* Remove the third character of the first string and insert it after the second character of the second string, making the two strings "ca" and "cbab" respectively.
* Remove the second character of the second string and insert it after the second character of the first string, making both strings equal to "cab".
In the second test case, it is impossible to make all n strings equal.
Submitted Solution:
```
# Author: SaykaT
# Problem: 1397A
# Time Created: August 31(Monday) 2020 || 10:54:57
#>-------------------------<#
from collections import Counter
#>-------------------------<#
# Helper Functions. -> Don't cluster your code.
# Main functions. -> Write the main solution here
def solve():
n = int(input())
string = ''
for _ in range(n):
tmp = input()
string += tmp
string = Counter(list(string))
ans = 'Yes'
for key in string:
if string[key] % n != 0:
ans = 'No'
break
print(ans)
# Multiple test cases
T = int(input())
for _ in range(T):
solve()
``` | instruction | 0 | 42,271 | 0 | 84,542 |
Yes | output | 1 | 42,271 | 0 | 84,543 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n strings s_1, s_2, …, s_n consisting of lowercase Latin letters.
In one operation you can remove a character from a string s_i and insert it to an arbitrary position in a string s_j (j may be equal to i). You may perform this operation any number of times. Is it possible to make all n strings equal?
Input
The first line contains t (1 ≤ t ≤ 10): the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 1000): the number of strings.
n lines follow, the i-th line contains s_i (1 ≤ \lvert s_i \rvert ≤ 1000).
The sum of lengths of all strings in all test cases does not exceed 1000.
Output
If it is possible to make the strings equal, print "YES" (without quotes).
Otherwise, print "NO" (without quotes).
You can output each character in either lowercase or uppercase.
Example
Input
4
2
caa
cbb
3
cba
cba
cbb
4
ccab
cbac
bca
acbcc
4
acb
caf
c
cbafc
Output
YES
NO
YES
NO
Note
In the first test case, you can do the following:
* Remove the third character of the first string and insert it after the second character of the second string, making the two strings "ca" and "cbab" respectively.
* Remove the second character of the second string and insert it after the second character of the first string, making both strings equal to "cab".
In the second test case, it is impossible to make all n strings equal.
Submitted Solution:
```
n = int(input())
while(n):
list1 = []
num = int(input())
for i in range(num):
q = input()
m = list(q)
list1.extend(m)
d = {i:list1.count(i) for i in list1}
count1 = 0
for j in d.values():
if j%num == 0:
count1 += 1
if count1 == len(d):
print("YES")
else:
print("NO")
n -= 1
``` | instruction | 0 | 42,272 | 0 | 84,544 |
Yes | output | 1 | 42,272 | 0 | 84,545 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n strings s_1, s_2, …, s_n consisting of lowercase Latin letters.
In one operation you can remove a character from a string s_i and insert it to an arbitrary position in a string s_j (j may be equal to i). You may perform this operation any number of times. Is it possible to make all n strings equal?
Input
The first line contains t (1 ≤ t ≤ 10): the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 1000): the number of strings.
n lines follow, the i-th line contains s_i (1 ≤ \lvert s_i \rvert ≤ 1000).
The sum of lengths of all strings in all test cases does not exceed 1000.
Output
If it is possible to make the strings equal, print "YES" (without quotes).
Otherwise, print "NO" (without quotes).
You can output each character in either lowercase or uppercase.
Example
Input
4
2
caa
cbb
3
cba
cba
cbb
4
ccab
cbac
bca
acbcc
4
acb
caf
c
cbafc
Output
YES
NO
YES
NO
Note
In the first test case, you can do the following:
* Remove the third character of the first string and insert it after the second character of the second string, making the two strings "ca" and "cbab" respectively.
* Remove the second character of the second string and insert it after the second character of the first string, making both strings equal to "cab".
In the second test case, it is impossible to make all n strings equal.
Submitted Solution:
```
t=int(input())
for i in range(t) :
n=int(input());b=[];s="";r="";cnt=0
for j in range(n) :
a=input();b.append(a)
for j in range(n) :
s+=b[j]
p=list(set(s))
for j in range(len(p)) :
r+=p[j]
for j in range(len(r)) :
if s.count(r[i])==n or s.count(r[i])%n==0 :
cnt+=1
if cnt==len(r) :
print("YES")
else :
print("NO")
``` | instruction | 0 | 42,273 | 0 | 84,546 |
No | output | 1 | 42,273 | 0 | 84,547 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n strings s_1, s_2, …, s_n consisting of lowercase Latin letters.
In one operation you can remove a character from a string s_i and insert it to an arbitrary position in a string s_j (j may be equal to i). You may perform this operation any number of times. Is it possible to make all n strings equal?
Input
The first line contains t (1 ≤ t ≤ 10): the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 1000): the number of strings.
n lines follow, the i-th line contains s_i (1 ≤ \lvert s_i \rvert ≤ 1000).
The sum of lengths of all strings in all test cases does not exceed 1000.
Output
If it is possible to make the strings equal, print "YES" (without quotes).
Otherwise, print "NO" (without quotes).
You can output each character in either lowercase or uppercase.
Example
Input
4
2
caa
cbb
3
cba
cba
cbb
4
ccab
cbac
bca
acbcc
4
acb
caf
c
cbafc
Output
YES
NO
YES
NO
Note
In the first test case, you can do the following:
* Remove the third character of the first string and insert it after the second character of the second string, making the two strings "ca" and "cbab" respectively.
* Remove the second character of the second string and insert it after the second character of the first string, making both strings equal to "cab".
In the second test case, it is impossible to make all n strings equal.
Submitted Solution:
```
n = int(input())
for i in range(n):
t = int(input())
tempStr = ''
for i in range(t):
s = input()
tempStr += s
if len(tempStr) % t != 0:
print('NO')
print(tempStr,t)
else:
tempSet = set(tempStr)
for i in tempSet:
if tempStr.count(i) % t != 0:
print('NO')
break
else:
print('YES')
``` | instruction | 0 | 42,274 | 0 | 84,548 |
No | output | 1 | 42,274 | 0 | 84,549 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n strings s_1, s_2, …, s_n consisting of lowercase Latin letters.
In one operation you can remove a character from a string s_i and insert it to an arbitrary position in a string s_j (j may be equal to i). You may perform this operation any number of times. Is it possible to make all n strings equal?
Input
The first line contains t (1 ≤ t ≤ 10): the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 1000): the number of strings.
n lines follow, the i-th line contains s_i (1 ≤ \lvert s_i \rvert ≤ 1000).
The sum of lengths of all strings in all test cases does not exceed 1000.
Output
If it is possible to make the strings equal, print "YES" (without quotes).
Otherwise, print "NO" (without quotes).
You can output each character in either lowercase or uppercase.
Example
Input
4
2
caa
cbb
3
cba
cba
cbb
4
ccab
cbac
bca
acbcc
4
acb
caf
c
cbafc
Output
YES
NO
YES
NO
Note
In the first test case, you can do the following:
* Remove the third character of the first string and insert it after the second character of the second string, making the two strings "ca" and "cbab" respectively.
* Remove the second character of the second string and insert it after the second character of the first string, making both strings equal to "cab".
In the second test case, it is impossible to make all n strings equal.
Submitted Solution:
```
t = int(input())
for i in range(t):
t_2 = int(input())
lenth = 0
for j in range(t_2):
string = input()
lenth += len(string)
if lenth % t_2 == 0:
print('YES')
else:
print('NO')
``` | instruction | 0 | 42,275 | 0 | 84,550 |
No | output | 1 | 42,275 | 0 | 84,551 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n strings s_1, s_2, …, s_n consisting of lowercase Latin letters.
In one operation you can remove a character from a string s_i and insert it to an arbitrary position in a string s_j (j may be equal to i). You may perform this operation any number of times. Is it possible to make all n strings equal?
Input
The first line contains t (1 ≤ t ≤ 10): the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 1000): the number of strings.
n lines follow, the i-th line contains s_i (1 ≤ \lvert s_i \rvert ≤ 1000).
The sum of lengths of all strings in all test cases does not exceed 1000.
Output
If it is possible to make the strings equal, print "YES" (without quotes).
Otherwise, print "NO" (without quotes).
You can output each character in either lowercase or uppercase.
Example
Input
4
2
caa
cbb
3
cba
cba
cbb
4
ccab
cbac
bca
acbcc
4
acb
caf
c
cbafc
Output
YES
NO
YES
NO
Note
In the first test case, you can do the following:
* Remove the third character of the first string and insert it after the second character of the second string, making the two strings "ca" and "cbab" respectively.
* Remove the second character of the second string and insert it after the second character of the first string, making both strings equal to "cab".
In the second test case, it is impossible to make all n strings equal.
Submitted Solution:
```
t = int(input())
res = []
from functools import reduce
from collections import Counter
def check(n,temp) :
return 'YES' if all([not i&1 for i in Counter(reduce(lambda x,y : x+y,temp)).values()]) else 'NO'
for _ in range(t) :
temp = []
n = int(input())
for __ in range(n) :
temp.append(input())
res.append(check(n,temp))
for i in res :
print(i)
``` | instruction | 0 | 42,276 | 0 | 84,552 |
No | output | 1 | 42,276 | 0 | 84,553 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-empty string s consisting of lowercase English letters. You have to pick exactly one non-empty substring of s and shift all its letters 'z' <image> 'y' <image> 'x' <image> 'b' <image> 'a' <image> 'z'. In other words, each character is replaced with the previous character of English alphabet and 'a' is replaced with 'z'.
What is the lexicographically minimum string that can be obtained from s by performing this shift exactly once?
Input
The only line of the input contains the string s (1 ≤ |s| ≤ 100 000) consisting of lowercase English letters.
Output
Print the lexicographically minimum string that can be obtained from s by shifting letters of exactly one non-empty substring.
Examples
Input
codeforces
Output
bncdenqbdr
Input
abacaba
Output
aaacaba
Note
String s is lexicographically smaller than some other string t of the same length if there exists some 1 ≤ i ≤ |s|, such that s1 = t1, s2 = t2, ..., si - 1 = ti - 1, and si < ti. | instruction | 0 | 42,540 | 0 | 85,080 |
Tags: constructive algorithms, greedy, implementation, strings
Correct Solution:
```
s = input()
t = []
i = 0
while i < len(s) and s[i] == "a":
if i == len(s) - 1:
t.append("z")
else:
t.append("a")
i += 1
while i < len(s) and s[i] != "a":
t.append(chr(ord(s[i]) - 1))
i += 1
t += list(s[i:])
print("".join(t))
``` | output | 1 | 42,540 | 0 | 85,081 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-empty string s consisting of lowercase English letters. You have to pick exactly one non-empty substring of s and shift all its letters 'z' <image> 'y' <image> 'x' <image> 'b' <image> 'a' <image> 'z'. In other words, each character is replaced with the previous character of English alphabet and 'a' is replaced with 'z'.
What is the lexicographically minimum string that can be obtained from s by performing this shift exactly once?
Input
The only line of the input contains the string s (1 ≤ |s| ≤ 100 000) consisting of lowercase English letters.
Output
Print the lexicographically minimum string that can be obtained from s by shifting letters of exactly one non-empty substring.
Examples
Input
codeforces
Output
bncdenqbdr
Input
abacaba
Output
aaacaba
Note
String s is lexicographically smaller than some other string t of the same length if there exists some 1 ≤ i ≤ |s|, such that s1 = t1, s2 = t2, ..., si - 1 = ti - 1, and si < ti. | instruction | 0 | 42,541 | 0 | 85,082 |
Tags: constructive algorithms, greedy, implementation, strings
Correct Solution:
```
ori_str = input();
res = '';
n = len(ori_str);
for i in range(n):
if ori_str[i] != 'a':
break;
else:
if i == n - 1:
res = res + 'z';
else:
res = res + 'a';
for i in range(len(res), n):
if ori_str[i] == 'a':
res = res + ori_str[i:];
break;
else:
res = res + chr(ord(ori_str[i]) - 1);
print(res)
``` | output | 1 | 42,541 | 0 | 85,083 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-empty string s consisting of lowercase English letters. You have to pick exactly one non-empty substring of s and shift all its letters 'z' <image> 'y' <image> 'x' <image> 'b' <image> 'a' <image> 'z'. In other words, each character is replaced with the previous character of English alphabet and 'a' is replaced with 'z'.
What is the lexicographically minimum string that can be obtained from s by performing this shift exactly once?
Input
The only line of the input contains the string s (1 ≤ |s| ≤ 100 000) consisting of lowercase English letters.
Output
Print the lexicographically minimum string that can be obtained from s by shifting letters of exactly one non-empty substring.
Examples
Input
codeforces
Output
bncdenqbdr
Input
abacaba
Output
aaacaba
Note
String s is lexicographically smaller than some other string t of the same length if there exists some 1 ≤ i ≤ |s|, such that s1 = t1, s2 = t2, ..., si - 1 = ti - 1, and si < ti. | instruction | 0 | 42,542 | 0 | 85,084 |
Tags: constructive algorithms, greedy, implementation, strings
Correct Solution:
```
def move(s):
new_s = ''
for i in range(len(s)):
new_s += chr(ord(s[i]) - 1)
return new_s
s = input()
st = -1
fi = -1
for i in range(len(s)):
if st == -1 and s[i] != 'a':
st = i
elif st != -1 and s[i] == 'a':
fi = i
break
if st != -1 and fi != -1:
print(s[:st], move(s[st:fi]), s[fi:], sep='')
elif st != -1 and fi == -1:
print(s[:st], move(s[st:]), sep='')
elif st == -1 and fi == -1:
print(s[:-1], 'z', sep='')
``` | output | 1 | 42,542 | 0 | 85,085 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-empty string s consisting of lowercase English letters. You have to pick exactly one non-empty substring of s and shift all its letters 'z' <image> 'y' <image> 'x' <image> 'b' <image> 'a' <image> 'z'. In other words, each character is replaced with the previous character of English alphabet and 'a' is replaced with 'z'.
What is the lexicographically minimum string that can be obtained from s by performing this shift exactly once?
Input
The only line of the input contains the string s (1 ≤ |s| ≤ 100 000) consisting of lowercase English letters.
Output
Print the lexicographically minimum string that can be obtained from s by shifting letters of exactly one non-empty substring.
Examples
Input
codeforces
Output
bncdenqbdr
Input
abacaba
Output
aaacaba
Note
String s is lexicographically smaller than some other string t of the same length if there exists some 1 ≤ i ≤ |s|, such that s1 = t1, s2 = t2, ..., si - 1 = ti - 1, and si < ti. | instruction | 0 | 42,543 | 0 | 85,086 |
Tags: constructive algorithms, greedy, implementation, strings
Correct Solution:
```
import string
alphabet = string.ascii_lowercase
di = {}
for i in range(len(alphabet)):
di[alphabet[i]] = alphabet[(i - 1) % len(alphabet)]
s = input()
new_s = ""
was_a = False
ans = False
for element in s:
if element == "a":
if was_a:
ans = True
new_s += element
continue
was_a = True
if ans:
new_s += element
else:
new_s += di[element]
if not was_a:
new_s = new_s[:len(new_s) - 1] + "z"
print(new_s)
``` | output | 1 | 42,543 | 0 | 85,087 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-empty string s consisting of lowercase English letters. You have to pick exactly one non-empty substring of s and shift all its letters 'z' <image> 'y' <image> 'x' <image> 'b' <image> 'a' <image> 'z'. In other words, each character is replaced with the previous character of English alphabet and 'a' is replaced with 'z'.
What is the lexicographically minimum string that can be obtained from s by performing this shift exactly once?
Input
The only line of the input contains the string s (1 ≤ |s| ≤ 100 000) consisting of lowercase English letters.
Output
Print the lexicographically minimum string that can be obtained from s by shifting letters of exactly one non-empty substring.
Examples
Input
codeforces
Output
bncdenqbdr
Input
abacaba
Output
aaacaba
Note
String s is lexicographically smaller than some other string t of the same length if there exists some 1 ≤ i ≤ |s|, such that s1 = t1, s2 = t2, ..., si - 1 = ti - 1, and si < ti. | instruction | 0 | 42,544 | 0 | 85,088 |
Tags: constructive algorithms, greedy, implementation, strings
Correct Solution:
```
# import sys
# input=sys.stdin.readline
a=input()
a="a"+a+"a"
a=list(a)
b=[]
for i in range(len(a)):
if a[i]=="a":
b.append(i)
e=0
for i in range(len(b)-1):
if b[i]+1!=b[i+1]:
e=1
f=b[i]
g=b[i+1]
break
if e==0:
a[-2]="z"
print("".join(a[1:-1]))
else:
for i in range(f+1,g):
a[i]=chr(ord(a[i])-1)
print("".join(a[1:-1]))
``` | output | 1 | 42,544 | 0 | 85,089 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-empty string s consisting of lowercase English letters. You have to pick exactly one non-empty substring of s and shift all its letters 'z' <image> 'y' <image> 'x' <image> 'b' <image> 'a' <image> 'z'. In other words, each character is replaced with the previous character of English alphabet and 'a' is replaced with 'z'.
What is the lexicographically minimum string that can be obtained from s by performing this shift exactly once?
Input
The only line of the input contains the string s (1 ≤ |s| ≤ 100 000) consisting of lowercase English letters.
Output
Print the lexicographically minimum string that can be obtained from s by shifting letters of exactly one non-empty substring.
Examples
Input
codeforces
Output
bncdenqbdr
Input
abacaba
Output
aaacaba
Note
String s is lexicographically smaller than some other string t of the same length if there exists some 1 ≤ i ≤ |s|, such that s1 = t1, s2 = t2, ..., si - 1 = ti - 1, and si < ti. | instruction | 0 | 42,545 | 0 | 85,090 |
Tags: constructive algorithms, greedy, implementation, strings
Correct Solution:
```
s = input()
s1 = ''
start = False
metka = False
i = 0
while i < len(s) and not start:
if s[i] != 'a' and not start:
s1 += chr(ord(s[i])- 1)
metka = True
elif s[i] == 'a' and not metka:
s1 += s[i]
elif s[i] == 'a' and metka:
s1 += s[i:]
start = True
i += 1
if not metka:
s1 = s[:-1] + 'z'
print(s1)
``` | output | 1 | 42,545 | 0 | 85,091 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-empty string s consisting of lowercase English letters. You have to pick exactly one non-empty substring of s and shift all its letters 'z' <image> 'y' <image> 'x' <image> 'b' <image> 'a' <image> 'z'. In other words, each character is replaced with the previous character of English alphabet and 'a' is replaced with 'z'.
What is the lexicographically minimum string that can be obtained from s by performing this shift exactly once?
Input
The only line of the input contains the string s (1 ≤ |s| ≤ 100 000) consisting of lowercase English letters.
Output
Print the lexicographically minimum string that can be obtained from s by shifting letters of exactly one non-empty substring.
Examples
Input
codeforces
Output
bncdenqbdr
Input
abacaba
Output
aaacaba
Note
String s is lexicographically smaller than some other string t of the same length if there exists some 1 ≤ i ≤ |s|, such that s1 = t1, s2 = t2, ..., si - 1 = ti - 1, and si < ti. | instruction | 0 | 42,546 | 0 | 85,092 |
Tags: constructive algorithms, greedy, implementation, strings
Correct Solution:
```
n = input()
i = 0
while(i < len(n)):
if(n[i] == 'a'):
i += 1
else:
break
if(i == len(n)):
print(n[:i-1]+'z')
else:
j = i
while(j < len(n)):
if(n[j] != 'a'):
j += 1
else:
break
s = n[:i]
for z in range(i, j):
s = s + chr(ord(n[z])-1)
s = s + n[j:]
print(s)
``` | output | 1 | 42,546 | 0 | 85,093 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a non-empty string s consisting of lowercase English letters. You have to pick exactly one non-empty substring of s and shift all its letters 'z' <image> 'y' <image> 'x' <image> 'b' <image> 'a' <image> 'z'. In other words, each character is replaced with the previous character of English alphabet and 'a' is replaced with 'z'.
What is the lexicographically minimum string that can be obtained from s by performing this shift exactly once?
Input
The only line of the input contains the string s (1 ≤ |s| ≤ 100 000) consisting of lowercase English letters.
Output
Print the lexicographically minimum string that can be obtained from s by shifting letters of exactly one non-empty substring.
Examples
Input
codeforces
Output
bncdenqbdr
Input
abacaba
Output
aaacaba
Note
String s is lexicographically smaller than some other string t of the same length if there exists some 1 ≤ i ≤ |s|, such that s1 = t1, s2 = t2, ..., si - 1 = ti - 1, and si < ti. | instruction | 0 | 42,547 | 0 | 85,094 |
Tags: constructive algorithms, greedy, implementation, strings
Correct Solution:
```
s = list(input())
dic = {}
for i in range(1, 26):
dic[chr(i + ord('a'))] = chr(i - 1 + ord('a'))
dic['a'] = 'z'
n = len(s)
for i in range(n):
if s[i] != 'a':
j = i
while j < n and s[j] != 'a':
s[j] = dic[s[j]]
j += 1
break
else:
s[-1] = dic[s[-1]]
print(''.join(s))
``` | output | 1 | 42,547 | 0 | 85,095 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a non-empty string s consisting of lowercase English letters. You have to pick exactly one non-empty substring of s and shift all its letters 'z' <image> 'y' <image> 'x' <image> 'b' <image> 'a' <image> 'z'. In other words, each character is replaced with the previous character of English alphabet and 'a' is replaced with 'z'.
What is the lexicographically minimum string that can be obtained from s by performing this shift exactly once?
Input
The only line of the input contains the string s (1 ≤ |s| ≤ 100 000) consisting of lowercase English letters.
Output
Print the lexicographically minimum string that can be obtained from s by shifting letters of exactly one non-empty substring.
Examples
Input
codeforces
Output
bncdenqbdr
Input
abacaba
Output
aaacaba
Note
String s is lexicographically smaller than some other string t of the same length if there exists some 1 ≤ i ≤ |s|, such that s1 = t1, s2 = t2, ..., si - 1 = ti - 1, and si < ti.
Submitted Solution:
```
alth = "abcdefghijklmnopqrstuvwxyz"
s = list(input())
n = len(s)
i = 0
while n > i and s[i] == "a":
i += 1
temp = 0
while n > i and s[i] != "a":
s[i] = alth[alth.find(s[i]) - 1]
temp = 1
i += 1
if temp == 0:
s[n-1] = "z"
print("".join(s))
``` | instruction | 0 | 42,548 | 0 | 85,096 |
Yes | output | 1 | 42,548 | 0 | 85,097 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a non-empty string s consisting of lowercase English letters. You have to pick exactly one non-empty substring of s and shift all its letters 'z' <image> 'y' <image> 'x' <image> 'b' <image> 'a' <image> 'z'. In other words, each character is replaced with the previous character of English alphabet and 'a' is replaced with 'z'.
What is the lexicographically minimum string that can be obtained from s by performing this shift exactly once?
Input
The only line of the input contains the string s (1 ≤ |s| ≤ 100 000) consisting of lowercase English letters.
Output
Print the lexicographically minimum string that can be obtained from s by shifting letters of exactly one non-empty substring.
Examples
Input
codeforces
Output
bncdenqbdr
Input
abacaba
Output
aaacaba
Note
String s is lexicographically smaller than some other string t of the same length if there exists some 1 ≤ i ≤ |s|, such that s1 = t1, s2 = t2, ..., si - 1 = ti - 1, and si < ti.
Submitted Solution:
```
#! /usr/bin/env python3
s = t = list(input())
total = 0
started = False
for i, c in enumerate(s):
if c == 'a':
if started:
break
else:
continue
else:
started = True
t[i] = chr(ord(c) - 1)
total += 1
if total == 0:
t[-1] = 'z'
print(''.join(t))
``` | instruction | 0 | 42,549 | 0 | 85,098 |
Yes | output | 1 | 42,549 | 0 | 85,099 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a non-empty string s consisting of lowercase English letters. You have to pick exactly one non-empty substring of s and shift all its letters 'z' <image> 'y' <image> 'x' <image> 'b' <image> 'a' <image> 'z'. In other words, each character is replaced with the previous character of English alphabet and 'a' is replaced with 'z'.
What is the lexicographically minimum string that can be obtained from s by performing this shift exactly once?
Input
The only line of the input contains the string s (1 ≤ |s| ≤ 100 000) consisting of lowercase English letters.
Output
Print the lexicographically minimum string that can be obtained from s by shifting letters of exactly one non-empty substring.
Examples
Input
codeforces
Output
bncdenqbdr
Input
abacaba
Output
aaacaba
Note
String s is lexicographically smaller than some other string t of the same length if there exists some 1 ≤ i ≤ |s|, such that s1 = t1, s2 = t2, ..., si - 1 = ti - 1, and si < ti.
Submitted Solution:
```
S = input()
N = len(S)
if N == 1:
if S == "a":
print("z")
else:
c = chr(ord(S) - 1)
print(c)
exit()
start = -1
stop = -1
for i, s in enumerate(S):
if start == -1 and s != "a":
start = i
continue
if start != -1 and s == "a":
stop = i - 1
break
if start == -1:
# last -> z
ans = list(S)
ans[-1] = "z"
print("".join(ans))
exit()
if stop == -1:
stop = N - 1
# print(start, stop)
ans = ""
for i, s in enumerate(S):
c = s
if start <= i <= stop:
c = chr(ord(s) - 1)
ans += c
print(ans)
``` | instruction | 0 | 42,550 | 0 | 85,100 |
Yes | output | 1 | 42,550 | 0 | 85,101 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a non-empty string s consisting of lowercase English letters. You have to pick exactly one non-empty substring of s and shift all its letters 'z' <image> 'y' <image> 'x' <image> 'b' <image> 'a' <image> 'z'. In other words, each character is replaced with the previous character of English alphabet and 'a' is replaced with 'z'.
What is the lexicographically minimum string that can be obtained from s by performing this shift exactly once?
Input
The only line of the input contains the string s (1 ≤ |s| ≤ 100 000) consisting of lowercase English letters.
Output
Print the lexicographically minimum string that can be obtained from s by shifting letters of exactly one non-empty substring.
Examples
Input
codeforces
Output
bncdenqbdr
Input
abacaba
Output
aaacaba
Note
String s is lexicographically smaller than some other string t of the same length if there exists some 1 ≤ i ≤ |s|, such that s1 = t1, s2 = t2, ..., si - 1 = ti - 1, and si < ti.
Submitted Solution:
```
s = input()
start = -1
end = -1
for i in range(len(s)):
if s[i] != 'a':
if start < 0:
start = i
end = i
else:
end = i
if s[i] == 'a' and start >= 0:
break
if start < 0:
print(s[0:len(s)-1], end="")
print('z')
else:
for i in range(len(s)):
if start <= i <= end:
if s[i] == 'a':
print('z', end="")
else:
print(chr(ord(s[i]) - 1), end="")
else:
print(s[i], end="")
``` | instruction | 0 | 42,551 | 0 | 85,102 |
Yes | output | 1 | 42,551 | 0 | 85,103 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a non-empty string s consisting of lowercase English letters. You have to pick exactly one non-empty substring of s and shift all its letters 'z' <image> 'y' <image> 'x' <image> 'b' <image> 'a' <image> 'z'. In other words, each character is replaced with the previous character of English alphabet and 'a' is replaced with 'z'.
What is the lexicographically minimum string that can be obtained from s by performing this shift exactly once?
Input
The only line of the input contains the string s (1 ≤ |s| ≤ 100 000) consisting of lowercase English letters.
Output
Print the lexicographically minimum string that can be obtained from s by shifting letters of exactly one non-empty substring.
Examples
Input
codeforces
Output
bncdenqbdr
Input
abacaba
Output
aaacaba
Note
String s is lexicographically smaller than some other string t of the same length if there exists some 1 ≤ i ≤ |s|, such that s1 = t1, s2 = t2, ..., si - 1 = ti - 1, and si < ti.
Submitted Solution:
```
alth = "abcdefghijklmnopqrstuvwxyz"
s = list(input())
n = len(s)
i = 0
while n > i and s[i] == "a":
i += 1
while n > i and s[i] != "a":
s[i] = alth[alth.find(s[i]) - 1]
i += 1
print("".join(s))
``` | instruction | 0 | 42,552 | 0 | 85,104 |
No | output | 1 | 42,552 | 0 | 85,105 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a non-empty string s consisting of lowercase English letters. You have to pick exactly one non-empty substring of s and shift all its letters 'z' <image> 'y' <image> 'x' <image> 'b' <image> 'a' <image> 'z'. In other words, each character is replaced with the previous character of English alphabet and 'a' is replaced with 'z'.
What is the lexicographically minimum string that can be obtained from s by performing this shift exactly once?
Input
The only line of the input contains the string s (1 ≤ |s| ≤ 100 000) consisting of lowercase English letters.
Output
Print the lexicographically minimum string that can be obtained from s by shifting letters of exactly one non-empty substring.
Examples
Input
codeforces
Output
bncdenqbdr
Input
abacaba
Output
aaacaba
Note
String s is lexicographically smaller than some other string t of the same length if there exists some 1 ≤ i ≤ |s|, such that s1 = t1, s2 = t2, ..., si - 1 = ti - 1, and si < ti.
Submitted Solution:
```
s = input()
start = -1
end = -1
for i in range(len(s)):
if s[i] != 'a':
if start < 0:
start = i
end = i
else:
end = i
if s[i] == 'a' and start > 0:
break
if start < 0:
print(s[0:len(s)-1], end="")
print('z')
else:
for i in range(len(s)):
if start <= i <= end:
if s[i] == 'a':
print('z', end="")
else:
print(chr(ord(s[i]) - 1), end="")
else:
print(s[i], end="")
``` | instruction | 0 | 42,553 | 0 | 85,106 |
No | output | 1 | 42,553 | 0 | 85,107 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a non-empty string s consisting of lowercase English letters. You have to pick exactly one non-empty substring of s and shift all its letters 'z' <image> 'y' <image> 'x' <image> 'b' <image> 'a' <image> 'z'. In other words, each character is replaced with the previous character of English alphabet and 'a' is replaced with 'z'.
What is the lexicographically minimum string that can be obtained from s by performing this shift exactly once?
Input
The only line of the input contains the string s (1 ≤ |s| ≤ 100 000) consisting of lowercase English letters.
Output
Print the lexicographically minimum string that can be obtained from s by shifting letters of exactly one non-empty substring.
Examples
Input
codeforces
Output
bncdenqbdr
Input
abacaba
Output
aaacaba
Note
String s is lexicographically smaller than some other string t of the same length if there exists some 1 ≤ i ≤ |s|, such that s1 = t1, s2 = t2, ..., si - 1 = ti - 1, and si < ti.
Submitted Solution:
```
s = input()
s1 = ''
start = False
metka = False
i = 0
while i < len(s) and not start:
if s[i] != 'a' and not start:
s1 += chr(ord(s[i])- 1)
metka = True
elif s[i] == 'a' and not metka:
s1 += s[i]
elif s[i] == 'a' and metka:
s1 += s[i:]
start = True
i += 1
print(s1)
``` | instruction | 0 | 42,554 | 0 | 85,108 |
No | output | 1 | 42,554 | 0 | 85,109 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a non-empty string s consisting of lowercase English letters. You have to pick exactly one non-empty substring of s and shift all its letters 'z' <image> 'y' <image> 'x' <image> 'b' <image> 'a' <image> 'z'. In other words, each character is replaced with the previous character of English alphabet and 'a' is replaced with 'z'.
What is the lexicographically minimum string that can be obtained from s by performing this shift exactly once?
Input
The only line of the input contains the string s (1 ≤ |s| ≤ 100 000) consisting of lowercase English letters.
Output
Print the lexicographically minimum string that can be obtained from s by shifting letters of exactly one non-empty substring.
Examples
Input
codeforces
Output
bncdenqbdr
Input
abacaba
Output
aaacaba
Note
String s is lexicographically smaller than some other string t of the same length if there exists some 1 ≤ i ≤ |s|, such that s1 = t1, s2 = t2, ..., si - 1 = ti - 1, and si < ti.
Submitted Solution:
```
a = list(input())
per = 0
for i in range(len(a)):
if a[i] == 'a':
if per == 0:
print('a', end = '')
else:
print(''.join(map(str, a[i:])))
break
else:
per = 1
print(chr(ord(a[i]) - 1), end = '')
``` | instruction | 0 | 42,555 | 0 | 85,110 |
No | output | 1 | 42,555 | 0 | 85,111 |
Provide a correct Python 3 solution for this coding contest problem.
We will call a string x good if it satisfies the following condition:
* Condition: x can be represented as a concatenation of two copies of another string y of length at least 1.
For example, `aa` and `bubobubo` are good; an empty string, `a`, `abcabcabc` and `abba` are not good.
Eagle and Owl created a puzzle on good strings. Find one string s that satisfies the following conditions. It can be proved that such a string always exists under the constraints in this problem.
* 1 ≤ |s| ≤ 200
* Each character of s is one of the 100 characters represented by the integers 1 through 100.
* Among the 2^{|s|} subsequences of s, exactly N are good strings.
Constraints
* 1 ≤ N ≤ 10^{12}
Input
Input is given from Standard Input in the following format:
N
Output
In the first line, print |s|, the length of s. In the second line, print the elements in s in order, with spaces in between. Any string that satisfies the above conditions will be accepted.
Examples
Input
7
Output
4
1 1 1 1
Input
299
Output
23
32 11 11 73 45 8 11 83 83 8 45 32 32 10 100 73 32 83 45 73 32 11 10 | instruction | 0 | 42,768 | 0 | 85,536 |
"Correct Solution:
```
if __name__ == "__main__":
N = int(input())
n = 40
for i in range(40, -1, -1):
if (N >= (1 << i) - 1):
n = i
break
data = []
for i in range(n):
data.append(i + 1)
N -= (1 << n) - 1
tmp = n
for i in range(n - 1, -1, -1):
if (N < (1 << i)):
continue
tmp += 1
data = data[:i] + [tmp] + data[i:]
N -= (1 << i)
ans = []
for x in range(len(data)):
ans.append(x + 1)
ans = ans + data
print (len(ans))
print (" ".join(map(str, ans)))
``` | output | 1 | 42,768 | 0 | 85,537 |
Provide a correct Python 3 solution for this coding contest problem.
We will call a string x good if it satisfies the following condition:
* Condition: x can be represented as a concatenation of two copies of another string y of length at least 1.
For example, `aa` and `bubobubo` are good; an empty string, `a`, `abcabcabc` and `abba` are not good.
Eagle and Owl created a puzzle on good strings. Find one string s that satisfies the following conditions. It can be proved that such a string always exists under the constraints in this problem.
* 1 ≤ |s| ≤ 200
* Each character of s is one of the 100 characters represented by the integers 1 through 100.
* Among the 2^{|s|} subsequences of s, exactly N are good strings.
Constraints
* 1 ≤ N ≤ 10^{12}
Input
Input is given from Standard Input in the following format:
N
Output
In the first line, print |s|, the length of s. In the second line, print the elements in s in order, with spaces in between. Any string that satisfies the above conditions will be accepted.
Examples
Input
7
Output
4
1 1 1 1
Input
299
Output
23
32 11 11 73 45 8 11 83 83 8 45 32 32 10 100 73 32 83 45 73 32 11 10 | instruction | 0 | 42,769 | 0 | 85,538 |
"Correct Solution:
```
def ncr(n, r):
r = min(n - r, r)
up = 1
down = 1
for i in range(r):
up *= (n - i)
down *= (i + 1)
return up // down
def seq(x):
s = 0
for i in range(1, x):
j = i * 2
if j > x:
break
s += ncr(x, j)
return s
def ins(total, p):
s = 0
for i in range(p + 1):
s += ncr(p, i) * ncr(total - p, i)
return s
ans = []
N = int(input())
k = 1
for i in range(41, 0, -1):
x = seq(i)
if N >= x:
for j in range(i):
ans.append(k)
N -= x
k += 1
break
size = len(ans)
s = size // 2
while N > 90:
m = 0
t = 0
for i in range(s + 1):
tmp = ins(size, i)
if tmp > N:
break
if tmp > t:
t = tmp
m = i
N -= t
ans.insert(m, k)
ans.append(k)
k += 1
while N > 0:
for i in range(41, 0, -1):
x = seq(i)
if N >= x:
for j in range(i):
ans.append(k)
N -= x
k += 1
break
print(len(ans))
print(" ".join([str(x) for x in ans]))
``` | output | 1 | 42,769 | 0 | 85,539 |
Provide a correct Python 3 solution for this coding contest problem.
We will call a string x good if it satisfies the following condition:
* Condition: x can be represented as a concatenation of two copies of another string y of length at least 1.
For example, `aa` and `bubobubo` are good; an empty string, `a`, `abcabcabc` and `abba` are not good.
Eagle and Owl created a puzzle on good strings. Find one string s that satisfies the following conditions. It can be proved that such a string always exists under the constraints in this problem.
* 1 ≤ |s| ≤ 200
* Each character of s is one of the 100 characters represented by the integers 1 through 100.
* Among the 2^{|s|} subsequences of s, exactly N are good strings.
Constraints
* 1 ≤ N ≤ 10^{12}
Input
Input is given from Standard Input in the following format:
N
Output
In the first line, print |s|, the length of s. In the second line, print the elements in s in order, with spaces in between. Any string that satisfies the above conditions will be accepted.
Examples
Input
7
Output
4
1 1 1 1
Input
299
Output
23
32 11 11 73 45 8 11 83 83 8 45 32 32 10 100 73 32 83 45 73 32 11 10 | instruction | 0 | 42,770 | 0 | 85,540 |
"Correct Solution:
```
def f(n):
if n == 1:
return []
if n % 2 == 0:
r = f(n//2)
k = len(r)
return r + [k+1]
if n % 2 == 1:
r = f(n - 1)
k = len(r)
return [k+1] + r
n = int(input())
r = f(n+1)
k = len(r)
res = r + list(range(1, k+1))
print(len(res))
for x in res:
print(x, end=' ')
print()
``` | output | 1 | 42,770 | 0 | 85,541 |
Provide a correct Python 3 solution for this coding contest problem.
We will call a string x good if it satisfies the following condition:
* Condition: x can be represented as a concatenation of two copies of another string y of length at least 1.
For example, `aa` and `bubobubo` are good; an empty string, `a`, `abcabcabc` and `abba` are not good.
Eagle and Owl created a puzzle on good strings. Find one string s that satisfies the following conditions. It can be proved that such a string always exists under the constraints in this problem.
* 1 ≤ |s| ≤ 200
* Each character of s is one of the 100 characters represented by the integers 1 through 100.
* Among the 2^{|s|} subsequences of s, exactly N are good strings.
Constraints
* 1 ≤ N ≤ 10^{12}
Input
Input is given from Standard Input in the following format:
N
Output
In the first line, print |s|, the length of s. In the second line, print the elements in s in order, with spaces in between. Any string that satisfies the above conditions will be accepted.
Examples
Input
7
Output
4
1 1 1 1
Input
299
Output
23
32 11 11 73 45 8 11 83 83 8 45 32 32 10 100 73 32 83 45 73 32 11 10 | instruction | 0 | 42,771 | 0 | 85,542 |
"Correct Solution:
```
#!/usr/bin/env python3
n = int(input())
x = []
y = []
k = 1
for c in bin(n + 1)[2 :][1 :]:
x += [ k ]
y += [ k ]
k += 1
if int(c):
x = [ k ] + x
y += [ k ]
k += 1
print(len(x + y))
print(*(x + y))
``` | output | 1 | 42,771 | 0 | 85,543 |
Provide a correct Python 3 solution for this coding contest problem.
We will call a string x good if it satisfies the following condition:
* Condition: x can be represented as a concatenation of two copies of another string y of length at least 1.
For example, `aa` and `bubobubo` are good; an empty string, `a`, `abcabcabc` and `abba` are not good.
Eagle and Owl created a puzzle on good strings. Find one string s that satisfies the following conditions. It can be proved that such a string always exists under the constraints in this problem.
* 1 ≤ |s| ≤ 200
* Each character of s is one of the 100 characters represented by the integers 1 through 100.
* Among the 2^{|s|} subsequences of s, exactly N are good strings.
Constraints
* 1 ≤ N ≤ 10^{12}
Input
Input is given from Standard Input in the following format:
N
Output
In the first line, print |s|, the length of s. In the second line, print the elements in s in order, with spaces in between. Any string that satisfies the above conditions will be accepted.
Examples
Input
7
Output
4
1 1 1 1
Input
299
Output
23
32 11 11 73 45 8 11 83 83 8 45 32 32 10 100 73 32 83 45 73 32 11 10 | instruction | 0 | 42,772 | 0 | 85,544 |
"Correct Solution:
```
def nCr(a,b):
tmp=1
for i in range(a,a-b,-1):tmp*=i
for i in range(1,b+1,1):tmp//=i
return tmp
n=int(input())
out=[]
co=1
coo=0
while n>0:
t=2
while True:
sum1=0
for j in range(2,t+1,2):
sum1+=nCr(t,j)
# print(n,sum)
if n<sum1:
t-=1
# n-=rco
break
rco=sum1
t+=1
ad=[co for _ in range(t)]
sum1=rco
ma=sum1
# print(ma)
for toa in range(1,4):
for tob in range(1,4):
CO=0
for r in range(1,min(toa,tob)+1):
CO+=nCr(toa,r)*nCr(tob,r)
for a in range(1,t):
sum2=sum1+((2**(toa+tob-1))-1)
for b in range(1,a+1):
sum2+=nCr(a,b)*nCr(t-a,b)*CO
if sum2>n:continue
if ma<sum2:
ma=sum2
ad=[co for _ in range(a)]
for _ in range(toa):ad.append(100-coo)
for _ in range(t-a):ad.append(co)
for _ in range(tob):ad.append(100-coo)
# print(ad,0,ma)
for t in ad:out.append(t)
# out.append(ad)
n-=ma
coo+=1
co+=1
print(len(out))
print(*out)
``` | output | 1 | 42,772 | 0 | 85,545 |
Provide a correct Python 3 solution for this coding contest problem.
We will call a string x good if it satisfies the following condition:
* Condition: x can be represented as a concatenation of two copies of another string y of length at least 1.
For example, `aa` and `bubobubo` are good; an empty string, `a`, `abcabcabc` and `abba` are not good.
Eagle and Owl created a puzzle on good strings. Find one string s that satisfies the following conditions. It can be proved that such a string always exists under the constraints in this problem.
* 1 ≤ |s| ≤ 200
* Each character of s is one of the 100 characters represented by the integers 1 through 100.
* Among the 2^{|s|} subsequences of s, exactly N are good strings.
Constraints
* 1 ≤ N ≤ 10^{12}
Input
Input is given from Standard Input in the following format:
N
Output
In the first line, print |s|, the length of s. In the second line, print the elements in s in order, with spaces in between. Any string that satisfies the above conditions will be accepted.
Examples
Input
7
Output
4
1 1 1 1
Input
299
Output
23
32 11 11 73 45 8 11 83 83 8 45 32 32 10 100 73 32 83 45 73 32 11 10 | instruction | 0 | 42,773 | 0 | 85,546 |
"Correct Solution:
```
n=int(input())
a=[0]
for i in range(40):
if n&(1<<i):a.append(i)
ans=[]
j=100
for i in range(len(a)-1):
for _ in range(a[i+1]-a[i]):
ans.append(j)
j-=1
ans.append(i+1)
ans=ans[:-1]
ans=[50]+[100-i for i in range(a[-1])]+[i+1 for i in range(len(a)-2)][::-1]+ans+[50]
print(len(ans))
print(*ans)
``` | output | 1 | 42,773 | 0 | 85,547 |
Provide a correct Python 3 solution for this coding contest problem.
We will call a string x good if it satisfies the following condition:
* Condition: x can be represented as a concatenation of two copies of another string y of length at least 1.
For example, `aa` and `bubobubo` are good; an empty string, `a`, `abcabcabc` and `abba` are not good.
Eagle and Owl created a puzzle on good strings. Find one string s that satisfies the following conditions. It can be proved that such a string always exists under the constraints in this problem.
* 1 ≤ |s| ≤ 200
* Each character of s is one of the 100 characters represented by the integers 1 through 100.
* Among the 2^{|s|} subsequences of s, exactly N are good strings.
Constraints
* 1 ≤ N ≤ 10^{12}
Input
Input is given from Standard Input in the following format:
N
Output
In the first line, print |s|, the length of s. In the second line, print the elements in s in order, with spaces in between. Any string that satisfies the above conditions will be accepted.
Examples
Input
7
Output
4
1 1 1 1
Input
299
Output
23
32 11 11 73 45 8 11 83 83 8 45 32 32 10 100 73 32 83 45 73 32 11 10 | instruction | 0 | 42,774 | 0 | 85,548 |
"Correct Solution:
```
import sys
input = sys.stdin.readline
from collections import deque
N = int(input())
# empty
N += 1
bit = [i for i in range(60) if N&(1<<i)]
n = bit[-1]
left = deque(range(n,0,-1))
right = deque()
x = n+1
for i in range(n,0,-1):
right.append(i)
if i-1 in bit:
right.append(x)
left.appendleft(x)
x += 1
S = list(left) + list(right)
print(len(S))
print(' '.join(map(str,S)))
``` | output | 1 | 42,774 | 0 | 85,549 |
Provide a correct Python 3 solution for this coding contest problem.
We will call a string x good if it satisfies the following condition:
* Condition: x can be represented as a concatenation of two copies of another string y of length at least 1.
For example, `aa` and `bubobubo` are good; an empty string, `a`, `abcabcabc` and `abba` are not good.
Eagle and Owl created a puzzle on good strings. Find one string s that satisfies the following conditions. It can be proved that such a string always exists under the constraints in this problem.
* 1 ≤ |s| ≤ 200
* Each character of s is one of the 100 characters represented by the integers 1 through 100.
* Among the 2^{|s|} subsequences of s, exactly N are good strings.
Constraints
* 1 ≤ N ≤ 10^{12}
Input
Input is given from Standard Input in the following format:
N
Output
In the first line, print |s|, the length of s. In the second line, print the elements in s in order, with spaces in between. Any string that satisfies the above conditions will be accepted.
Examples
Input
7
Output
4
1 1 1 1
Input
299
Output
23
32 11 11 73 45 8 11 83 83 8 45 32 32 10 100 73 32 83 45 73 32 11 10 | instruction | 0 | 42,775 | 0 | 85,550 |
"Correct Solution:
```
n = int(input()) + 1
k = 50
while ~n >> k & 1:
k -= 1
k -= 1
a = []
b = []
now = 1
while k >= 0:
a = a + [now]
b = b + [now]
now += 1
if n >> k & 1:
a = a + [now]
b = [now] + b
now += 1
k -= 1
print(len(a + b))
print(*(a + b))
``` | output | 1 | 42,775 | 0 | 85,551 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We will call a string x good if it satisfies the following condition:
* Condition: x can be represented as a concatenation of two copies of another string y of length at least 1.
For example, `aa` and `bubobubo` are good; an empty string, `a`, `abcabcabc` and `abba` are not good.
Eagle and Owl created a puzzle on good strings. Find one string s that satisfies the following conditions. It can be proved that such a string always exists under the constraints in this problem.
* 1 ≤ |s| ≤ 200
* Each character of s is one of the 100 characters represented by the integers 1 through 100.
* Among the 2^{|s|} subsequences of s, exactly N are good strings.
Constraints
* 1 ≤ N ≤ 10^{12}
Input
Input is given from Standard Input in the following format:
N
Output
In the first line, print |s|, the length of s. In the second line, print the elements in s in order, with spaces in between. Any string that satisfies the above conditions will be accepted.
Examples
Input
7
Output
4
1 1 1 1
Input
299
Output
23
32 11 11 73 45 8 11 83 83 8 45 32 32 10 100 73 32 83 45 73 32 11 10
Submitted Solution:
```
p,q,k=[],[],1
for i in bin(int(input())+1)[3:]:
p+=[k]
q+=[k]
k+=1
if i=='1':
p=[k]+p
q+=[k]
k+=1
p+=q
print(len(p))
print(*p)
``` | instruction | 0 | 42,776 | 0 | 85,552 |
Yes | output | 1 | 42,776 | 0 | 85,553 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We will call a string x good if it satisfies the following condition:
* Condition: x can be represented as a concatenation of two copies of another string y of length at least 1.
For example, `aa` and `bubobubo` are good; an empty string, `a`, `abcabcabc` and `abba` are not good.
Eagle and Owl created a puzzle on good strings. Find one string s that satisfies the following conditions. It can be proved that such a string always exists under the constraints in this problem.
* 1 ≤ |s| ≤ 200
* Each character of s is one of the 100 characters represented by the integers 1 through 100.
* Among the 2^{|s|} subsequences of s, exactly N are good strings.
Constraints
* 1 ≤ N ≤ 10^{12}
Input
Input is given from Standard Input in the following format:
N
Output
In the first line, print |s|, the length of s. In the second line, print the elements in s in order, with spaces in between. Any string that satisfies the above conditions will be accepted.
Examples
Input
7
Output
4
1 1 1 1
Input
299
Output
23
32 11 11 73 45 8 11 83 83 8 45 32 32 10 100 73 32 83 45 73 32 11 10
Submitted Solution:
```
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
"""
agc012 C
"""
n = int(input())
m = len(bin(n+1))-2
n = n-(2**(m-1)-1)
fact = []
tmp = 1
for i in range(1, m+2):
fact.append(tmp)
tmp = tmp*i
binom = [[0]*(m+1) for i in range(m+1)]
for i in range(m+1):
for j in range(i+1):
binom[i][j] = (fact[i]//(fact[j]*fact[i-j]))
binomsums = []
for j in range(m//2+1):
tmp = 1
for i in range(1, j+1):
tmp += binom[j][i]*binom[m-j][i]
binomsums.append(tmp)
a = [0]*(m//2+1)
ind = m//2
while n != 0:
b = binomsums.pop()
c, n = divmod(n, b)
a[ind] = c
ind -= 1
ans = []
i = 2
for j in range(m//2+1):
for k in range(a[j]):
ans.append(i)
i += 1
ans.append(1)
ans = ans + [1 for j in range(m-m//2-1)]
i -= 1
while i >= 2:
ans.append(i)
i -= 1
print(len(ans))
print(" ".join(map(str, ans)))
``` | instruction | 0 | 42,777 | 0 | 85,554 |
Yes | output | 1 | 42,777 | 0 | 85,555 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We will call a string x good if it satisfies the following condition:
* Condition: x can be represented as a concatenation of two copies of another string y of length at least 1.
For example, `aa` and `bubobubo` are good; an empty string, `a`, `abcabcabc` and `abba` are not good.
Eagle and Owl created a puzzle on good strings. Find one string s that satisfies the following conditions. It can be proved that such a string always exists under the constraints in this problem.
* 1 ≤ |s| ≤ 200
* Each character of s is one of the 100 characters represented by the integers 1 through 100.
* Among the 2^{|s|} subsequences of s, exactly N are good strings.
Constraints
* 1 ≤ N ≤ 10^{12}
Input
Input is given from Standard Input in the following format:
N
Output
In the first line, print |s|, the length of s. In the second line, print the elements in s in order, with spaces in between. Any string that satisfies the above conditions will be accepted.
Examples
Input
7
Output
4
1 1 1 1
Input
299
Output
23
32 11 11 73 45 8 11 83 83 8 45 32 32 10 100 73 32 83 45 73 32 11 10
Submitted Solution:
```
def test():
from itertools import combinations
s = '111223111223'
result = 0
for k in range(1, len(s) // 2 + 1):
for idx in combinations(range(len(s)), 2 * k):
success = True
for ii in range(k):
if s[idx[ii]] != s[idx[ii + k]]:
success = False
break
if success:
result += 1
print(result)
n = int(input())
factorials = [1, 1]
for i in range(2, 40):
factorials.append(factorials[-1] * i)
patterns = {}
for i in range(2, 40):
base = (1 << (i - 1)) - 1
gain = base
chars = i
if gain > n:
break
if gain not in patterns or chars < patterns[gain][0]:
patterns[gain] = (chars, (i,))
if i % 2 == 1:
continue
a = i // 2
ncr1 = factorials[i] // factorials[a] // factorials[a] - 1
for b in range(1, a + 1):
base2 = (1 << (2 * b - 1)) - 1
ncr2 = factorials[2 * b] // factorials[b] // factorials[b] - 1
gain = base + base2 + ncr1 * ncr2
chars = i + 2 * b
if gain > n:
break
if gain not in patterns or chars < patterns[gain][0]:
patterns[gain] = (chars, (a, b))
for c in range(1, b + 1):
base3 = (1 << (2 * c - 1)) - 1
ncr3 = factorials[2 * c] // factorials[c] // factorials[c] - 1
gain = base + base2 + base3 + ncr1 * ncr2 * ncr3 + ncr1 * ncr2 + ncr2 * ncr3 + ncr3 * ncr1
chars = i + 2 * b + 2 * c
if gain > n:
break
if gain not in patterns or chars < patterns[gain][0]:
patterns[gain] = (chars, (a, b, c))
for d in range(1, c + 1):
base4 = (1 << (2 * d - 1)) - 1
ncr4 = factorials[2 * d] // factorials[d] // factorials[d] - 1
gain = base + base2 + base3 + base4 + ncr1 * ncr2 * ncr3 * ncr4
gain += ncr1 * ncr2 * ncr3 + ncr1 * ncr2 * ncr4 + ncr1 * ncr3 * ncr4 + ncr2 * ncr3 * ncr4
gain += ncr1 * ncr2 + ncr1 * ncr3 + ncr1 * ncr4 + ncr2 * ncr3 + ncr2 * ncr4 + ncr3 * ncr4
chars = i + 2 * b + 2 * c + 2 * d
if gain > n:
break
if gain not in patterns or chars < patterns[gain][0]:
patterns[gain] = (chars, (a, b, c, d))
def dfs(use, i, remaining, total_char):
if remaining == 0:
return total_char <= 200
for j in range(i, len(patterns)):
gain, (chars, lengths) = patterns[j]
if total_char + remaining * chars / gain > 200:
break
if gain > remaining:
continue
use.append(lengths)
result = dfs(use, j, remaining - gain, total_char + chars)
if result:
return True
use.pop()
return False
patterns = sorted(patterns.items(), key=lambda item: item[0] / item[1][0], reverse=True)
use = []
result = dfs(use, 0, n, 0)
assert result
ans = []
c = 1
for lengths in use:
if len(lengths) == 1:
ans.extend([c] * lengths[0])
c += 1
else:
for _ in range(2):
for i, l in enumerate(lengths):
ans.extend([c + i] * l)
c += len(lengths)
print(len(ans))
print(*ans)
``` | instruction | 0 | 42,778 | 0 | 85,556 |
Yes | output | 1 | 42,778 | 0 | 85,557 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We will call a string x good if it satisfies the following condition:
* Condition: x can be represented as a concatenation of two copies of another string y of length at least 1.
For example, `aa` and `bubobubo` are good; an empty string, `a`, `abcabcabc` and `abba` are not good.
Eagle and Owl created a puzzle on good strings. Find one string s that satisfies the following conditions. It can be proved that such a string always exists under the constraints in this problem.
* 1 ≤ |s| ≤ 200
* Each character of s is one of the 100 characters represented by the integers 1 through 100.
* Among the 2^{|s|} subsequences of s, exactly N are good strings.
Constraints
* 1 ≤ N ≤ 10^{12}
Input
Input is given from Standard Input in the following format:
N
Output
In the first line, print |s|, the length of s. In the second line, print the elements in s in order, with spaces in between. Any string that satisfies the above conditions will be accepted.
Examples
Input
7
Output
4
1 1 1 1
Input
299
Output
23
32 11 11 73 45 8 11 83 83 8 45 32 32 10 100 73 32 83 45 73 32 11 10
Submitted Solution:
```
#!/usr/bin/env python3
def construct(N):
for n in range(40, -1, -1):
if N >= (1 << n) - 1:
break
p = []
for i in range(1, n+1):
p.append(i)
N -= (1 << n) - 1
for i in range(n-1, -1, -1):
if N < 1 << i:
continue
n += 1
p = p[:i] + [n] + p[i:]
N -= 1 << i
return p
N = int(input())
part = construct(N)
ans = part + [x + 1 for x in range(len(part))]
print(len(ans))
print(*ans, end=' ')
print()
``` | instruction | 0 | 42,779 | 0 | 85,558 |
Yes | output | 1 | 42,779 | 0 | 85,559 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We will call a string x good if it satisfies the following condition:
* Condition: x can be represented as a concatenation of two copies of another string y of length at least 1.
For example, `aa` and `bubobubo` are good; an empty string, `a`, `abcabcabc` and `abba` are not good.
Eagle and Owl created a puzzle on good strings. Find one string s that satisfies the following conditions. It can be proved that such a string always exists under the constraints in this problem.
* 1 ≤ |s| ≤ 200
* Each character of s is one of the 100 characters represented by the integers 1 through 100.
* Among the 2^{|s|} subsequences of s, exactly N are good strings.
Constraints
* 1 ≤ N ≤ 10^{12}
Input
Input is given from Standard Input in the following format:
N
Output
In the first line, print |s|, the length of s. In the second line, print the elements in s in order, with spaces in between. Any string that satisfies the above conditions will be accepted.
Examples
Input
7
Output
4
1 1 1 1
Input
299
Output
23
32 11 11 73 45 8 11 83 83 8 45 32 32 10 100 73 32 83 45 73 32 11 10
Submitted Solution:
```
def test():
from itertools import combinations
s = '111223111223'
result = 0
for k in range(1, len(s) // 2 + 1):
for idx in combinations(range(len(s)), 2 * k):
success = True
for ii in range(k):
if s[idx[ii]] != s[idx[ii + k]]:
success = False
break
if success:
result += 1
print(result)
n = int(input())
factorials = [1, 1]
for i in range(2, 40):
factorials.append(factorials[-1] * i)
patterns = []
for i in range(2, 40):
base = (1 << (i - 1)) - 1
patterns.append((base / i, base, i, 0, 0))
if i % 2 == 1:
continue
a = i // 2
ncr1 = factorials[i] // factorials[a] // factorials[a] - 1
for b in range(1, a + 1):
base2 = (1 << (2 * b - 1)) - 1
ncr2 = factorials[2 * b] // factorials[b] // factorials[b] - 1
gain = base + base2 + ncr1 * ncr2
chars = i + 2 * b
patterns.append((gain / chars, gain, a, b, 0))
for c in range(1, b + 1):
base3 = (1 << (2 * c - 1)) - 1
ncr3 = factorials[2 * c] // factorials[c] // factorials[c] - 1
gain = base + base2 + base3 + ncr1 * ncr2 * ncr3 + ncr1 * ncr2 + ncr2 * ncr3 + ncr3 * ncr1
chars = i + 2 * b + 2 * c
patterns.append((gain / chars, gain, a, b, c))
patterns.sort(reverse=True)
ans = []
c = 1
i = 0
while n:
if n >= patterns[i][1]:
n -= patterns[i][1]
if patterns[i][3] == 0:
ans.extend([c] * patterns[i][2])
c += 1
elif patterns[i][4] == 0:
ans.extend([c] * patterns[i][2])
ans.extend([c + 1] * patterns[i][3])
ans.extend([c] * patterns[i][2])
ans.extend([c + 1] * patterns[i][3])
c += 2
else:
ans.extend([c] * patterns[i][2])
ans.extend([c + 1] * patterns[i][3])
ans.extend([c + 2] * patterns[i][4])
ans.extend([c] * patterns[i][2])
ans.extend([c + 1] * patterns[i][3])
ans.extend([c + 2] * patterns[i][4])
c += 3
else:
i += 1
print(len(ans))
print(*ans)
``` | instruction | 0 | 42,780 | 0 | 85,560 |
No | output | 1 | 42,780 | 0 | 85,561 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We will call a string x good if it satisfies the following condition:
* Condition: x can be represented as a concatenation of two copies of another string y of length at least 1.
For example, `aa` and `bubobubo` are good; an empty string, `a`, `abcabcabc` and `abba` are not good.
Eagle and Owl created a puzzle on good strings. Find one string s that satisfies the following conditions. It can be proved that such a string always exists under the constraints in this problem.
* 1 ≤ |s| ≤ 200
* Each character of s is one of the 100 characters represented by the integers 1 through 100.
* Among the 2^{|s|} subsequences of s, exactly N are good strings.
Constraints
* 1 ≤ N ≤ 10^{12}
Input
Input is given from Standard Input in the following format:
N
Output
In the first line, print |s|, the length of s. In the second line, print the elements in s in order, with spaces in between. Any string that satisfies the above conditions will be accepted.
Examples
Input
7
Output
4
1 1 1 1
Input
299
Output
23
32 11 11 73 45 8 11 83 83 8 45 32 32 10 100 73 32 83 45 73 32 11 10
Submitted Solution:
```
N=int(input())
ans=[]
for k in range(50):
if N&(1<<k):
for i in range(k+1):
ans.append(str(2*k+1))
for i in range(2):
ans.append(str(2*k+2))
print(len(ans))
print(" ".join(ans))
``` | instruction | 0 | 42,781 | 0 | 85,562 |
No | output | 1 | 42,781 | 0 | 85,563 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We will call a string x good if it satisfies the following condition:
* Condition: x can be represented as a concatenation of two copies of another string y of length at least 1.
For example, `aa` and `bubobubo` are good; an empty string, `a`, `abcabcabc` and `abba` are not good.
Eagle and Owl created a puzzle on good strings. Find one string s that satisfies the following conditions. It can be proved that such a string always exists under the constraints in this problem.
* 1 ≤ |s| ≤ 200
* Each character of s is one of the 100 characters represented by the integers 1 through 100.
* Among the 2^{|s|} subsequences of s, exactly N are good strings.
Constraints
* 1 ≤ N ≤ 10^{12}
Input
Input is given from Standard Input in the following format:
N
Output
In the first line, print |s|, the length of s. In the second line, print the elements in s in order, with spaces in between. Any string that satisfies the above conditions will be accepted.
Examples
Input
7
Output
4
1 1 1 1
Input
299
Output
23
32 11 11 73 45 8 11 83 83 8 45 32 32 10 100 73 32 83 45 73 32 11 10
Submitted 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 = 10**9 + 7
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
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 = 10**9 + 7
N = 10 ** 4 + 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)
L = 25
cmb2 = [0 for i in range(L+1)]
for i in range(L+1):
for j in range(1,i+1):
cmb2[i] += cmb(i,j,p) * cmb(i,j,p)
#print(cmb2)
element = []
#print(element)
for i in range(1,L+1):
for j in range(1,L+1):
element.append([ cmb2[i]*cmb2[j] + 2**(i*2-1) + 2**(j*2-1) - 2, i,j])
for i in range(1,L):
element.append([2**(i-1)-1, -1, i])
element.sort(key = lambda x : x[0], reverse=True)
#print(element)
n = int(input())
ans = []
used = 0
while(True):
if(n==0):
print(len(ans))
print(" ".join(map(str,ans)))
break
now = []
for i in element:
if(i[0]<=n):
now = i
break
if(now[1]==-1):
used += 1
for j in range(now[2]):
ans.append(used)
else:
used+=2
for j in range(now[1]):
ans.append(used-1)
for j in range(now[2]):
ans.append(used)
for j in range(now[1]):
ans.append(used-1)
for j in range(now[2]):
ans.append(used)
n -= now[0]
``` | instruction | 0 | 42,782 | 0 | 85,564 |
No | output | 1 | 42,782 | 0 | 85,565 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We will call a string x good if it satisfies the following condition:
* Condition: x can be represented as a concatenation of two copies of another string y of length at least 1.
For example, `aa` and `bubobubo` are good; an empty string, `a`, `abcabcabc` and `abba` are not good.
Eagle and Owl created a puzzle on good strings. Find one string s that satisfies the following conditions. It can be proved that such a string always exists under the constraints in this problem.
* 1 ≤ |s| ≤ 200
* Each character of s is one of the 100 characters represented by the integers 1 through 100.
* Among the 2^{|s|} subsequences of s, exactly N are good strings.
Constraints
* 1 ≤ N ≤ 10^{12}
Input
Input is given from Standard Input in the following format:
N
Output
In the first line, print |s|, the length of s. In the second line, print the elements in s in order, with spaces in between. Any string that satisfies the above conditions will be accepted.
Examples
Input
7
Output
4
1 1 1 1
Input
299
Output
23
32 11 11 73 45 8 11 83 83 8 45 32 32 10 100 73 32 83 45 73 32 11 10
Submitted Solution:
```
N=int(input())
i=2
s=[]
count=1
while N!=0:
while True:
temp=2**(i-1)
if 4*temp-1>N:
break
i+=2
s.extend([count]*i)
N-=(temp-1)
i=2
count+=1
print(len(s))
ans=""
for i in s:
ans+=str(i)+" "
print(ans[0:-1])
``` | instruction | 0 | 42,783 | 0 | 85,566 |
No | output | 1 | 42,783 | 0 | 85,567 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a binary string of length n (i. e. a string consisting of n characters '0' and '1').
In one move you can swap two adjacent characters of the string. What is the lexicographically minimum possible string you can obtain from the given one if you can perform no more than k moves? It is possible that you do not perform any moves at all.
Note that you can swap the same pair of adjacent characters with indices i and i+1 arbitrary (possibly, zero) number of times. Each such swap is considered a separate move.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases.
The first line of the test case contains two integers n and k (1 ≤ n ≤ 10^6, 1 ≤ k ≤ n^2) — the length of the string and the number of moves you can perform.
The second line of the test case contains one string consisting of n characters '0' and '1'.
It is guaranteed that the sum of n over all test cases does not exceed 10^6 (∑ n ≤ 10^6).
Output
For each test case, print the answer on it: the lexicographically minimum possible string of length n you can obtain from the given one if you can perform no more than k moves.
Example
Input
3
8 5
11011010
7 9
1111100
7 11
1111100
Output
01011110
0101111
0011111
Note
In the first example, you can change the string as follows: 1\underline{10}11010 → \underline{10}111010 → 0111\underline{10}10 → 011\underline{10}110 → 01\underline{10}1110 → 01011110.
In the third example, there are enough operations to make the string sorted. | instruction | 0 | 43,053 | 0 | 86,106 |
Tags: greedy
Correct Solution:
```
q = int(input())
for i in range(q):
n, k = map(int, input().split())
s = list(input())
min_pos = 0
for j in range(n):
if s[j] == '0':
p = max(j - k, min_pos)
if k >= j - p:
k -= j - p
s[j], s[p] = s[p], s[j]
min_pos = p + 1
print(''.join(map(str, s)))
``` | output | 1 | 43,053 | 0 | 86,107 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a binary string of length n (i. e. a string consisting of n characters '0' and '1').
In one move you can swap two adjacent characters of the string. What is the lexicographically minimum possible string you can obtain from the given one if you can perform no more than k moves? It is possible that you do not perform any moves at all.
Note that you can swap the same pair of adjacent characters with indices i and i+1 arbitrary (possibly, zero) number of times. Each such swap is considered a separate move.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases.
The first line of the test case contains two integers n and k (1 ≤ n ≤ 10^6, 1 ≤ k ≤ n^2) — the length of the string and the number of moves you can perform.
The second line of the test case contains one string consisting of n characters '0' and '1'.
It is guaranteed that the sum of n over all test cases does not exceed 10^6 (∑ n ≤ 10^6).
Output
For each test case, print the answer on it: the lexicographically minimum possible string of length n you can obtain from the given one if you can perform no more than k moves.
Example
Input
3
8 5
11011010
7 9
1111100
7 11
1111100
Output
01011110
0101111
0011111
Note
In the first example, you can change the string as follows: 1\underline{10}11010 → \underline{10}111010 → 0111\underline{10}10 → 011\underline{10}110 → 01\underline{10}1110 → 01011110.
In the third example, there are enough operations to make the string sorted. | instruction | 0 | 43,054 | 0 | 86,108 |
Tags: greedy
Correct Solution:
```
from sys import stdin
input = stdin.readline
def solve(s, k):
result = []
ones = 0
for char in s:
if k == 0:
break
elif char == 1:
ones += 1
elif k >= ones:
result.append(0)
k -= ones
elif k > 0:
result += [1]*(ones-k)
result.append(0)
result += [1]*k
ones = 0
break
result += [1]*ones
result += s[len(result):]
result = "".join(map(str, result))
return result
if __name__ == "__main__":
for i in range(int(input())):
n, k = map(int, input().split())
s = [int(x) for x in input().strip()]
print(solve(s, k))
``` | output | 1 | 43,054 | 0 | 86,109 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a binary string of length n (i. e. a string consisting of n characters '0' and '1').
In one move you can swap two adjacent characters of the string. What is the lexicographically minimum possible string you can obtain from the given one if you can perform no more than k moves? It is possible that you do not perform any moves at all.
Note that you can swap the same pair of adjacent characters with indices i and i+1 arbitrary (possibly, zero) number of times. Each such swap is considered a separate move.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases.
The first line of the test case contains two integers n and k (1 ≤ n ≤ 10^6, 1 ≤ k ≤ n^2) — the length of the string and the number of moves you can perform.
The second line of the test case contains one string consisting of n characters '0' and '1'.
It is guaranteed that the sum of n over all test cases does not exceed 10^6 (∑ n ≤ 10^6).
Output
For each test case, print the answer on it: the lexicographically minimum possible string of length n you can obtain from the given one if you can perform no more than k moves.
Example
Input
3
8 5
11011010
7 9
1111100
7 11
1111100
Output
01011110
0101111
0011111
Note
In the first example, you can change the string as follows: 1\underline{10}11010 → \underline{10}111010 → 0111\underline{10}10 → 011\underline{10}110 → 01\underline{10}1110 → 01011110.
In the third example, there are enough operations to make the string sorted. | instruction | 0 | 43,055 | 0 | 86,110 |
Tags: greedy
Correct Solution:
```
import sys
import math
from collections import defaultdict,Counter,deque
# input=sys.stdin.readline
# def print(x):
# sys.stdout.write(str(x)+"\n")
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# sys.stdout=open("CP1/output.txt",'w')
# sys.stdin=open("CP1/input.txt",'r')
# mod=pow(10,9)+7
t=int(input())
for i in range(t):
n,k=map(int,input().split())
# a=list(map(int,input().split()))
s=list(input())
start=0
c=0
for j in range(n):
if s[j]=='0':
need=j-start
if k>=need:
c+=1
k-=need
start+=1
else:
s[:j]=['0']*c+['1']*(j-c)
for kk in range(j,start,-1):
if k:
s[kk],s[kk-1]=s[kk-1],s[kk]
k-=1
else:
break
print(''.join(s))
break
else:
print('0'*c+'1'*(n-c))
``` | output | 1 | 43,055 | 0 | 86,111 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a binary string of length n (i. e. a string consisting of n characters '0' and '1').
In one move you can swap two adjacent characters of the string. What is the lexicographically minimum possible string you can obtain from the given one if you can perform no more than k moves? It is possible that you do not perform any moves at all.
Note that you can swap the same pair of adjacent characters with indices i and i+1 arbitrary (possibly, zero) number of times. Each such swap is considered a separate move.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases.
The first line of the test case contains two integers n and k (1 ≤ n ≤ 10^6, 1 ≤ k ≤ n^2) — the length of the string and the number of moves you can perform.
The second line of the test case contains one string consisting of n characters '0' and '1'.
It is guaranteed that the sum of n over all test cases does not exceed 10^6 (∑ n ≤ 10^6).
Output
For each test case, print the answer on it: the lexicographically minimum possible string of length n you can obtain from the given one if you can perform no more than k moves.
Example
Input
3
8 5
11011010
7 9
1111100
7 11
1111100
Output
01011110
0101111
0011111
Note
In the first example, you can change the string as follows: 1\underline{10}11010 → \underline{10}111010 → 0111\underline{10}10 → 011\underline{10}110 → 01\underline{10}1110 → 01011110.
In the third example, there are enough operations to make the string sorted. | instruction | 0 | 43,056 | 0 | 86,112 |
Tags: greedy
Correct Solution:
```
class Case:
def __init__(self, size, moves, string):
self.size = size
self.moves = moves
self.string = string
SPACE = ' '
ZERO = '0'
ONE = '1'
def get_case():
line_elements = input().split(SPACE)
size = int(line_elements[0])
moves = int(line_elements[1])
string = list(input())
return Case(size, moves, string)
def get_zero_indices(string):
zero_indices = []
for index, char in enumerate(string):
if char == ZERO:
zero_indices.append(index)
return zero_indices
def get_zero_indices_after_moves(initial_zero_indices, ideal_indices, moves):
final_zero_indices = [None] * len(initial_zero_indices)
if len(initial_zero_indices) != len(ideal_indices):
raise ValueError('initial_zero_indices and ideal_indices should be of '
'the same length')
for i, zero_index in enumerate(initial_zero_indices):
if moves < 0:
raise ValueError('moves should be >= 0')
if moves == 0:
final_zero_indices[i] = zero_index
# return final_zero_indices
desired_moves = zero_index - ideal_indices[i]
allowed_moves = min(moves, desired_moves)
new_zero_index = zero_index - allowed_moves
final_zero_indices[i] = new_zero_index
moves = moves - allowed_moves
return final_zero_indices
def add_zeros(ones, zero_indices):
for index in zero_indices:
ones[index] = ZERO
return ones
def solve(case):
initial_zero_indices = get_zero_indices(case.string)
ideal_zero_indices = list(range((len(initial_zero_indices))))
final_zero_indices = get_zero_indices_after_moves(
initial_zero_indices, ideal_zero_indices, case.moves)
ones = [ONE] * case.size
response = add_zeros(ones, final_zero_indices)
return response
if __name__ == "__main__":
number_of_cases = int(input())
for i in range(number_of_cases):
case = get_case()
solvedList = solve(case)
solution = "".join(solvedList)
print(solution)
``` | output | 1 | 43,056 | 0 | 86,113 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a binary string of length n (i. e. a string consisting of n characters '0' and '1').
In one move you can swap two adjacent characters of the string. What is the lexicographically minimum possible string you can obtain from the given one if you can perform no more than k moves? It is possible that you do not perform any moves at all.
Note that you can swap the same pair of adjacent characters with indices i and i+1 arbitrary (possibly, zero) number of times. Each such swap is considered a separate move.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases.
The first line of the test case contains two integers n and k (1 ≤ n ≤ 10^6, 1 ≤ k ≤ n^2) — the length of the string and the number of moves you can perform.
The second line of the test case contains one string consisting of n characters '0' and '1'.
It is guaranteed that the sum of n over all test cases does not exceed 10^6 (∑ n ≤ 10^6).
Output
For each test case, print the answer on it: the lexicographically minimum possible string of length n you can obtain from the given one if you can perform no more than k moves.
Example
Input
3
8 5
11011010
7 9
1111100
7 11
1111100
Output
01011110
0101111
0011111
Note
In the first example, you can change the string as follows: 1\underline{10}11010 → \underline{10}111010 → 0111\underline{10}10 → 011\underline{10}110 → 01\underline{10}1110 → 01011110.
In the third example, there are enough operations to make the string sorted. | instruction | 0 | 43,057 | 0 | 86,114 |
Tags: greedy
Correct Solution:
```
for iter in range(int(input())):
numbers = list(map(int, input().split()))
a, b = numbers[0], numbers[1]
string = input()
counter = 0
ans = ''
flag = 0
for i in range(a):
if string[i] == '0':
counter += 1
ans = ans + '0'
b += counter - i - 1
if b <= 0:
flag = 1
if b != 0:
lenght = len(ans) - 1
ans = '0' * lenght
ans += '1' * -b
ans += '0'
counter1 = 0
anses = ''
for iterator in range(a):
if string[iterator] == '0' and counter > counter1:
anses += '1'
counter1 += 1
else:
anses += string[iterator]
ans += anses[len(ans):]
break
if flag:
print(ans)
else:
print(ans + '1' * (a - len(ans)))
``` | output | 1 | 43,057 | 0 | 86,115 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a binary string of length n (i. e. a string consisting of n characters '0' and '1').
In one move you can swap two adjacent characters of the string. What is the lexicographically minimum possible string you can obtain from the given one if you can perform no more than k moves? It is possible that you do not perform any moves at all.
Note that you can swap the same pair of adjacent characters with indices i and i+1 arbitrary (possibly, zero) number of times. Each such swap is considered a separate move.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases.
The first line of the test case contains two integers n and k (1 ≤ n ≤ 10^6, 1 ≤ k ≤ n^2) — the length of the string and the number of moves you can perform.
The second line of the test case contains one string consisting of n characters '0' and '1'.
It is guaranteed that the sum of n over all test cases does not exceed 10^6 (∑ n ≤ 10^6).
Output
For each test case, print the answer on it: the lexicographically minimum possible string of length n you can obtain from the given one if you can perform no more than k moves.
Example
Input
3
8 5
11011010
7 9
1111100
7 11
1111100
Output
01011110
0101111
0011111
Note
In the first example, you can change the string as follows: 1\underline{10}11010 → \underline{10}111010 → 0111\underline{10}10 → 011\underline{10}110 → 01\underline{10}1110 → 01011110.
In the third example, there are enough operations to make the string sorted. | instruction | 0 | 43,058 | 0 | 86,116 |
Tags: greedy
Correct Solution:
```
R = lambda: map(int, input().split())
for _ in range(int(input())):
n,k = R()
L = input()
p = k
c = 0
f = 1
for i in range(n):
if L[i] == '0':
if k >= (i-c):k -= (i-c)
else:f = 0;break
c += 1
if f:print('0'*c + '1'*(n-c))
else:
t = 0
res = list(L)
for i in range(n):
if L[i] == '0':t += 1;
if t == (c+1):
res[i-k] = '0'
break
for j in range(i+1):
if c > 0:res[j] = '0'
else:res[j] = '1'
c -= 1
res[i-k] = '0'
print(''.join(res))
``` | output | 1 | 43,058 | 0 | 86,117 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a binary string of length n (i. e. a string consisting of n characters '0' and '1').
In one move you can swap two adjacent characters of the string. What is the lexicographically minimum possible string you can obtain from the given one if you can perform no more than k moves? It is possible that you do not perform any moves at all.
Note that you can swap the same pair of adjacent characters with indices i and i+1 arbitrary (possibly, zero) number of times. Each such swap is considered a separate move.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases.
The first line of the test case contains two integers n and k (1 ≤ n ≤ 10^6, 1 ≤ k ≤ n^2) — the length of the string and the number of moves you can perform.
The second line of the test case contains one string consisting of n characters '0' and '1'.
It is guaranteed that the sum of n over all test cases does not exceed 10^6 (∑ n ≤ 10^6).
Output
For each test case, print the answer on it: the lexicographically minimum possible string of length n you can obtain from the given one if you can perform no more than k moves.
Example
Input
3
8 5
11011010
7 9
1111100
7 11
1111100
Output
01011110
0101111
0011111
Note
In the first example, you can change the string as follows: 1\underline{10}11010 → \underline{10}111010 → 0111\underline{10}10 → 011\underline{10}110 → 01\underline{10}1110 → 01011110.
In the third example, there are enough operations to make the string sorted. | instruction | 0 | 43,059 | 0 | 86,118 |
Tags: greedy
Correct Solution:
```
N = int(input())
for _ in range(N):
n,k = map(int,input().split())
a = [int(i) for i in input()]
Z = []
for i,v in enumerate(a):
if v == 0:
Z.append(i)
s = 0
rem = k
for z in Z:
if not rem:
break
if s == z:
s += 1
continue
mv = min(z-s, rem)
a[z-mv] = 0
a[z] = 1
s += 1
rem -= mv
print("".join(map(str, a)))
``` | output | 1 | 43,059 | 0 | 86,119 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a binary string of length n (i. e. a string consisting of n characters '0' and '1').
In one move you can swap two adjacent characters of the string. What is the lexicographically minimum possible string you can obtain from the given one if you can perform no more than k moves? It is possible that you do not perform any moves at all.
Note that you can swap the same pair of adjacent characters with indices i and i+1 arbitrary (possibly, zero) number of times. Each such swap is considered a separate move.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases.
The first line of the test case contains two integers n and k (1 ≤ n ≤ 10^6, 1 ≤ k ≤ n^2) — the length of the string and the number of moves you can perform.
The second line of the test case contains one string consisting of n characters '0' and '1'.
It is guaranteed that the sum of n over all test cases does not exceed 10^6 (∑ n ≤ 10^6).
Output
For each test case, print the answer on it: the lexicographically minimum possible string of length n you can obtain from the given one if you can perform no more than k moves.
Example
Input
3
8 5
11011010
7 9
1111100
7 11
1111100
Output
01011110
0101111
0011111
Note
In the first example, you can change the string as follows: 1\underline{10}11010 → \underline{10}111010 → 0111\underline{10}10 → 011\underline{10}110 → 01\underline{10}1110 → 01011110.
In the third example, there are enough operations to make the string sorted. | instruction | 0 | 43,060 | 0 | 86,120 |
Tags: greedy
Correct Solution:
```
def solve(n,k,s):
ind = []
flag = 0
#ind initialization
for q in range(n):
if s[q] == '0' and flag == 0: continue
if s[q] == '1': flag = 1
if s[q] == '0' and flag == 1:
ind.append(q+1)
#edge case
#11111 or 000000
if len(ind) == 0 or len(ind) == n:
print("".join(map(str,s)))
return
#general case
s = list(map(int, s))
s.insert(0,-1)
j = 0
for i in range(1,n+1):
if k == 0 or j == len(ind): break
if s[i] == 0: continue
if ind[j] - i <= k:
s[i],s[ind[j]] = s[ind[j]],s[i]
k -= ind[j]-i
j += 1
else:
s[ind[j]-k],s[ind[j]] = s[ind[j]],s[ind[j]-k]
j += 1
break
s.remove(-1)
print("".join(map(str,s)))
if __name__ == '__main__':
t = int(input())
for _ in range(t):
n,k = map(int,input().split())
s = list(input())
solve(n,k,s)
``` | output | 1 | 43,060 | 0 | 86,121 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.