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.
Max wants to buy a new skateboard. He has calculated the amount of money that is needed to buy a new skateboard. He left a calculator on the floor and went to ask some money from his parents. Meanwhile his little brother Yusuf came and started to press the keys randomly. Unfortunately Max has forgotten the number which he had calculated. The only thing he knows is that the number is divisible by 4.
You are given a string s consisting of digits (the number on the display of the calculator after Yusuf randomly pressed the keys). Your task is to find the number of substrings which are divisible by 4. A substring can start with a zero.
A substring of a string is a nonempty sequence of consecutive characters.
For example if string s is 124 then we have four substrings that are divisible by 4: 12, 4, 24 and 124. For the string 04 the answer is three: 0, 4, 04.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The only line contains string s (1 β€ |s| β€ 3Β·105). The string s contains only digits from 0 to 9.
Output
Print integer a β the number of substrings of the string s that are divisible by 4.
Note that the answer can be huge, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
124
Output
4
Input
04
Output
3
Input
5810438174
Output
9
|
instruction
| 0
| 99,868
| 0
| 199,736
|
Tags: dp
Correct Solution:
```
s = input()
count = 0
for i in range(len(s)):
if s[i] in ["0","4","8"]:
count+=1
for i in range(len(s)-1):
x = s[i:i+2]
if int(x)%4 == 0:
count+= i+1
print(count)
```
|
output
| 1
| 99,868
| 0
| 199,737
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Max wants to buy a new skateboard. He has calculated the amount of money that is needed to buy a new skateboard. He left a calculator on the floor and went to ask some money from his parents. Meanwhile his little brother Yusuf came and started to press the keys randomly. Unfortunately Max has forgotten the number which he had calculated. The only thing he knows is that the number is divisible by 4.
You are given a string s consisting of digits (the number on the display of the calculator after Yusuf randomly pressed the keys). Your task is to find the number of substrings which are divisible by 4. A substring can start with a zero.
A substring of a string is a nonempty sequence of consecutive characters.
For example if string s is 124 then we have four substrings that are divisible by 4: 12, 4, 24 and 124. For the string 04 the answer is three: 0, 4, 04.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The only line contains string s (1 β€ |s| β€ 3Β·105). The string s contains only digits from 0 to 9.
Output
Print integer a β the number of substrings of the string s that are divisible by 4.
Note that the answer can be huge, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
124
Output
4
Input
04
Output
3
Input
5810438174
Output
9
Submitted Solution:
```
s = input()
ans = 0
for i in range(1, len(s)):
if int(s[i - 1: i + 1]) % 4 == 0:
ans += i
for x in s:
if int(x) % 4 == 0:
ans += 1
print(ans)
```
|
instruction
| 0
| 99,869
| 0
| 199,738
|
Yes
|
output
| 1
| 99,869
| 0
| 199,739
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Max wants to buy a new skateboard. He has calculated the amount of money that is needed to buy a new skateboard. He left a calculator on the floor and went to ask some money from his parents. Meanwhile his little brother Yusuf came and started to press the keys randomly. Unfortunately Max has forgotten the number which he had calculated. The only thing he knows is that the number is divisible by 4.
You are given a string s consisting of digits (the number on the display of the calculator after Yusuf randomly pressed the keys). Your task is to find the number of substrings which are divisible by 4. A substring can start with a zero.
A substring of a string is a nonempty sequence of consecutive characters.
For example if string s is 124 then we have four substrings that are divisible by 4: 12, 4, 24 and 124. For the string 04 the answer is three: 0, 4, 04.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The only line contains string s (1 β€ |s| β€ 3Β·105). The string s contains only digits from 0 to 9.
Output
Print integer a β the number of substrings of the string s that are divisible by 4.
Note that the answer can be huge, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
124
Output
4
Input
04
Output
3
Input
5810438174
Output
9
Submitted Solution:
```
s = input("")
dp = s.count("0")+s.count("4")+s.count("8")
for i in range(len(s)-1):
if int(s[i] + s[i+1])%4 == 0:
dp += (i+1)
print(dp)
```
|
instruction
| 0
| 99,870
| 0
| 199,740
|
Yes
|
output
| 1
| 99,870
| 0
| 199,741
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Max wants to buy a new skateboard. He has calculated the amount of money that is needed to buy a new skateboard. He left a calculator on the floor and went to ask some money from his parents. Meanwhile his little brother Yusuf came and started to press the keys randomly. Unfortunately Max has forgotten the number which he had calculated. The only thing he knows is that the number is divisible by 4.
You are given a string s consisting of digits (the number on the display of the calculator after Yusuf randomly pressed the keys). Your task is to find the number of substrings which are divisible by 4. A substring can start with a zero.
A substring of a string is a nonempty sequence of consecutive characters.
For example if string s is 124 then we have four substrings that are divisible by 4: 12, 4, 24 and 124. For the string 04 the answer is three: 0, 4, 04.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The only line contains string s (1 β€ |s| β€ 3Β·105). The string s contains only digits from 0 to 9.
Output
Print integer a β the number of substrings of the string s that are divisible by 4.
Note that the answer can be huge, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
124
Output
4
Input
04
Output
3
Input
5810438174
Output
9
Submitted Solution:
```
S = input()
result = 0
for i in range(len(S) ):
if i == 0:
if int(S[i]) % 4 == 0:
result += 1
elif int(S[i]) % 4 == 0:
if int(S[i-1:i+1]) % 4 == 0:
result += i+1
else:
result += 1
elif int(S[i-1:i+1]) % 4 == 0:
result += i
print(result)
```
|
instruction
| 0
| 99,871
| 0
| 199,742
|
Yes
|
output
| 1
| 99,871
| 0
| 199,743
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Max wants to buy a new skateboard. He has calculated the amount of money that is needed to buy a new skateboard. He left a calculator on the floor and went to ask some money from his parents. Meanwhile his little brother Yusuf came and started to press the keys randomly. Unfortunately Max has forgotten the number which he had calculated. The only thing he knows is that the number is divisible by 4.
You are given a string s consisting of digits (the number on the display of the calculator after Yusuf randomly pressed the keys). Your task is to find the number of substrings which are divisible by 4. A substring can start with a zero.
A substring of a string is a nonempty sequence of consecutive characters.
For example if string s is 124 then we have four substrings that are divisible by 4: 12, 4, 24 and 124. For the string 04 the answer is three: 0, 4, 04.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The only line contains string s (1 β€ |s| β€ 3Β·105). The string s contains only digits from 0 to 9.
Output
Print integer a β the number of substrings of the string s that are divisible by 4.
Note that the answer can be huge, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
124
Output
4
Input
04
Output
3
Input
5810438174
Output
9
Submitted Solution:
```
s=input();
ans=0;
s=[int(x)for x in s];
ans+=sum([x%4==0 for x in s]);
for i in range(len(s)-1):
if (s[i]*10+s[i+1])%4==0:
ans+=i+1;
print(ans);
```
|
instruction
| 0
| 99,872
| 0
| 199,744
|
Yes
|
output
| 1
| 99,872
| 0
| 199,745
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Max wants to buy a new skateboard. He has calculated the amount of money that is needed to buy a new skateboard. He left a calculator on the floor and went to ask some money from his parents. Meanwhile his little brother Yusuf came and started to press the keys randomly. Unfortunately Max has forgotten the number which he had calculated. The only thing he knows is that the number is divisible by 4.
You are given a string s consisting of digits (the number on the display of the calculator after Yusuf randomly pressed the keys). Your task is to find the number of substrings which are divisible by 4. A substring can start with a zero.
A substring of a string is a nonempty sequence of consecutive characters.
For example if string s is 124 then we have four substrings that are divisible by 4: 12, 4, 24 and 124. For the string 04 the answer is three: 0, 4, 04.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The only line contains string s (1 β€ |s| β€ 3Β·105). The string s contains only digits from 0 to 9.
Output
Print integer a β the number of substrings of the string s that are divisible by 4.
Note that the answer can be huge, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
124
Output
4
Input
04
Output
3
Input
5810438174
Output
9
Submitted Solution:
```
s = "0" + input()
dp = [int(0)]*len(s)
res = 0
def pow(a, b) :
if b == 0 : return 1
elif b == 1 : return a
elif b % 2 == 0 : return pow(a*a, b/2)
else : return b*pow(a, b-1)
for i in range(1, len(s)) :
dp[i] = dp[i-1]*10 + int(s[i])
if dp[i] % 4 == 0 : res += 1
for i in range(1, len(s) - 1) :
for j in range(i+1, len(s)) :
if int(s[j]) % 2 == 0 and (dp[j] - dp[i]*pow(10,j-i)) % 4 == 0 : res += 1
print(res)
```
|
instruction
| 0
| 99,873
| 0
| 199,746
|
No
|
output
| 1
| 99,873
| 0
| 199,747
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Max wants to buy a new skateboard. He has calculated the amount of money that is needed to buy a new skateboard. He left a calculator on the floor and went to ask some money from his parents. Meanwhile his little brother Yusuf came and started to press the keys randomly. Unfortunately Max has forgotten the number which he had calculated. The only thing he knows is that the number is divisible by 4.
You are given a string s consisting of digits (the number on the display of the calculator after Yusuf randomly pressed the keys). Your task is to find the number of substrings which are divisible by 4. A substring can start with a zero.
A substring of a string is a nonempty sequence of consecutive characters.
For example if string s is 124 then we have four substrings that are divisible by 4: 12, 4, 24 and 124. For the string 04 the answer is three: 0, 4, 04.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The only line contains string s (1 β€ |s| β€ 3Β·105). The string s contains only digits from 0 to 9.
Output
Print integer a β the number of substrings of the string s that are divisible by 4.
Note that the answer can be huge, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
124
Output
4
Input
04
Output
3
Input
5810438174
Output
9
Submitted Solution:
```
n=input()
s=str(n)
c=0
for i in range(len(s)):
temp=""
for j in range(i,len(s)):
temp+=s[j]
print(temp)
if(int(temp)%4==0):
c+=1
print(c)
```
|
instruction
| 0
| 99,874
| 0
| 199,748
|
No
|
output
| 1
| 99,874
| 0
| 199,749
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Max wants to buy a new skateboard. He has calculated the amount of money that is needed to buy a new skateboard. He left a calculator on the floor and went to ask some money from his parents. Meanwhile his little brother Yusuf came and started to press the keys randomly. Unfortunately Max has forgotten the number which he had calculated. The only thing he knows is that the number is divisible by 4.
You are given a string s consisting of digits (the number on the display of the calculator after Yusuf randomly pressed the keys). Your task is to find the number of substrings which are divisible by 4. A substring can start with a zero.
A substring of a string is a nonempty sequence of consecutive characters.
For example if string s is 124 then we have four substrings that are divisible by 4: 12, 4, 24 and 124. For the string 04 the answer is three: 0, 4, 04.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The only line contains string s (1 β€ |s| β€ 3Β·105). The string s contains only digits from 0 to 9.
Output
Print integer a β the number of substrings of the string s that are divisible by 4.
Note that the answer can be huge, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
124
Output
4
Input
04
Output
3
Input
5810438174
Output
9
Submitted Solution:
```
n=int(input())
s=str(n)
c=0
for i in range(len(s)):
temp=""
for j in range(i,len(s)):
temp+=s[j]
if(int(temp)%4==0):
c+=1
print(c)
```
|
instruction
| 0
| 99,875
| 0
| 199,750
|
No
|
output
| 1
| 99,875
| 0
| 199,751
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Max wants to buy a new skateboard. He has calculated the amount of money that is needed to buy a new skateboard. He left a calculator on the floor and went to ask some money from his parents. Meanwhile his little brother Yusuf came and started to press the keys randomly. Unfortunately Max has forgotten the number which he had calculated. The only thing he knows is that the number is divisible by 4.
You are given a string s consisting of digits (the number on the display of the calculator after Yusuf randomly pressed the keys). Your task is to find the number of substrings which are divisible by 4. A substring can start with a zero.
A substring of a string is a nonempty sequence of consecutive characters.
For example if string s is 124 then we have four substrings that are divisible by 4: 12, 4, 24 and 124. For the string 04 the answer is three: 0, 4, 04.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use gets/scanf/printf instead of getline/cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The only line contains string s (1 β€ |s| β€ 3Β·105). The string s contains only digits from 0 to 9.
Output
Print integer a β the number of substrings of the string s that are divisible by 4.
Note that the answer can be huge, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Examples
Input
124
Output
4
Input
04
Output
3
Input
5810438174
Output
9
Submitted Solution:
```
import sys
def get_array(): return list(map(int, sys.stdin.readline().split()))
def get_ints(): return map(int, sys.stdin.readline().split())
def input(): return sys.stdin.readline().strip('\n')
s = input()
n = len(s)
ans = 0
ans += s.count('4')
ans += s.count('8')
for i in range(1,n):
k = s[i-1] + s[i]
if int(k)%4 == 0:
ans += i
if k == '04' or k == '08' or k in ['20','40','60','80']:
ans += 1
elif k == '00':
ans += 3
print(ans)
```
|
instruction
| 0
| 99,876
| 0
| 199,752
|
No
|
output
| 1
| 99,876
| 0
| 199,753
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
|
instruction
| 0
| 100,013
| 0
| 200,026
|
Tags: brute force, implementation, strings
Correct Solution:
```
# -*- coding: utf-8 -*-
import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
"""
created by shhuan at 2017/10/22 18:15
"""
N = int(input())
S = input()
def split(s, wc, pl, n):
ans = []
if pl % 2 == 0:
if any([x % 2 == 1 for x in wc.values()]):
return []
for i in range(0, len(s), pl):
t = s[i:i + pl]
ans.append(t[::2] + t[::-1][::2])
return ans
mid = [w for w, c in wc.items() if c % 2 == 1]
if len(mid) > n:
return []
midindex = 0
while len(ans) < n:
t = ''
u = mid[midindex] if midindex < len(mid) else ''
midindex += 1
if not u:
u = list([w for w, c in wc.items() if c > 0])[0]
wc[u] -= 1
need = pl-1
while need > 0:
pneed = need
for w, c in [(w, c) for w, c in wc.items()]:
if c > need:
t += str(w) * (need//2)
wc[w] -= need
need = 0
break
elif c > 1:
c //= 2
t += str(w) * c
wc[w] -= c * 2
need -= c*2
if need == pneed:
return []
t = t + u + t[::-1]
if len(t) < pl:
return []
ans.append(t)
return ans
S = "".join(sorted(list(S)))
WC = collections.Counter(S)
for parts in range(1, N+1):
if N % parts == 0:
wc = {k: v for k, v in WC.items()}
ans = split(S, wc, N//parts, parts)
if ans:
print(parts)
print(" ".join(ans))
exit(0)
```
|
output
| 1
| 100,013
| 0
| 200,027
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
|
instruction
| 0
| 100,014
| 0
| 200,028
|
Tags: brute force, implementation, strings
Correct Solution:
```
import sys
import math
from collections import defaultdict,deque
def is_possible(odd,even):
each = odd*2
if even % each == 0:
return True
return False
n=int(sys.stdin.readline())
s=sys.stdin.readline()[:-1]
dic=defaultdict(int)
for i in range(n):
dic[s[i]]+=1
odd,even = 0,0
for i in dic:
if dic[i]%2 != 0:
odd += 1
even += dic[i] - 1
else:
even += dic[i]
if odd == 0:
#print(0)
ans = [0 for x in range(even)]
cnt = 0
for i in dic:
while dic[i] > 0:
ans[cnt] = i
ans[even - cnt - 1] = i
cnt += 1
dic[i] -= 2
#print(ans)
print(1)
print(''.join(x for x in ans))
sys.exit()
while even >= 0:
if is_possible(odd,even):
break
odd += 2
even -= 2
length = 1 + (even) // (odd)
#print(length, 'length')
ans = [deque() for _ in range(odd)]
ansb = [[] for _ in range(odd)]
ansa = [[] for _ in range(odd)]
cnt = 0
#print(dic,'dic')
for i in dic:
if dic[i] % 2 !=0:
ans[cnt].append(i)
dic[i] -= 1
cnt += 1
#print()
#print(ans,' after odd',cnt)
for i in dic:
while dic[i] > 0:
if cnt >= odd:
break
ans[cnt].append(i)
ans[cnt + 1].append(i)
cnt += 2
dic[i] -= 2
if cnt >= odd:
break
cnt = 0
#print(ans,'ans')
for i in dic:
#print(cnt,'cnt',i,'i')
#print(ans[cnt])
if dic[i] > 0:
x = len(ans[cnt])
while dic[i] > 0:
ans[cnt].appendleft(i)
ans[cnt].append(i)
#ans[cnt] = [i] + ans[cnt] + [i]
dic[i] -= 2
x += 2
if x < length:
pass
else:
cnt += 1
if cnt < odd:
x = len(ans[cnt])
#print(ans,'ans')
#print(odd,'odd')
n = len(ans)
#print(n)
l =[]
for i in range(n):
l.append(''.join(x for x in ans[i]))
print(n)
print(*l)
```
|
output
| 1
| 100,014
| 0
| 200,029
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
|
instruction
| 0
| 100,015
| 0
| 200,030
|
Tags: brute force, implementation, strings
Correct Solution:
```
n = int(input())
s = list(input())
d = {}
for char in s:
if char not in d.keys():
d[char] = 1
else:
d[char] += 1
odd = []
even = []
for char in d.keys():
for i in range(d[char] // 2):
even.append(char)
even.append(char)
for i in range(d[char] % 2):
odd.append(char)
# print(len(even), len(odd))
if len(odd) <= 1:
x = ''.join([even[i] for i in range(1, len(even), 2)])
y = ''.join(odd)
print(1)
print(x + y + x[::-1])
elif len(even) % len(odd) == 0 and (len(even) // len(odd)) % 2 == 0 and (len(even) // len(odd)) > 0:
print(len(odd))
x = []
ratio = len(even) // len(odd)
indx = 0
for i in range(len(odd)):
tail = ''
while len(tail) < ratio // 2:
tail += even[indx]
indx += 2
x.append(tail + odd[i] + tail[::-1])
print(' '.join(x))
else:
ratio = len(even)//len(odd)
max_length = 1
for i in range(1,ratio+1,2):
if (len(even)+len(odd)) % i == 0 and max_length < i:
max_length = i
parts = (len(even) + len(odd))//max_length
print(parts)
x = []
indx = 0
for i in range(len(odd)):
tail = ''
while len(tail) < max_length // 2:
tail += even[indx]
indx += 2
x.append(tail + odd[i] + tail[::-1])
middle = []
for i in range(parts - len(odd)):
middle.append(even.pop())
for i in range(len(middle)):
tail = ''
while len(tail) < max_length // 2:
tail += even[indx]
indx += 2
x.append(tail + middle[i] + tail[::-1])
print(' '.join(x))
```
|
output
| 1
| 100,015
| 0
| 200,031
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
|
instruction
| 0
| 100,016
| 0
| 200,032
|
Tags: brute force, implementation, strings
Correct Solution:
```
mp,a,p={},[],[]
n=int(input())
for i in input():
if i in mp:mp[i]+=1
else:mp[i]=1
odd=0
for i in mp:
if mp[i]&1:
a.append(i)
mp[i]-=1
odd+=1
if mp[i]:
p.append(i)
m=max(1,odd)
for i in range(m,n+1):
if not n%i:
d=n//i
if odd and not d&1:continue
print(i)
for K in range(i-m):
a.append(p[-1])
if mp[p[-1]]>1:mp[p[-1]]-=1
else:p.pop()
for k in range(i):
s=''
for j in range(d//2):
s+=p[-1]
mp[p[-1]]-=2
if not mp[p[-1]]:p.pop()
if odd:print(s+a.pop()+s[::-1],end=' ')
else:print(s+s[::-1],end=' ')
exit()
```
|
output
| 1
| 100,016
| 0
| 200,033
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
|
instruction
| 0
| 100,017
| 0
| 200,034
|
Tags: brute force, implementation, strings
Correct Solution:
```
#!/usr/bin/env python3
def main():
import collections
n = int(input())
s = input()
alph = collections.Counter(s)
odd = sum(x & 0x1 for x in alph.values())
dq = collections.deque()
if odd == 0:
print(1)
for c, x in alph.items():
dq.append(c * (x >> 1))
dq.appendleft(c * (x >> 1))
print(*dq, sep="")
else:
for odd in range(odd, n):
if (n - odd) % (odd << 1) == 0:
print(odd)
odds = [c for c, x in alph.items() if x & 0x1]
items = list(alph.items())
while len(odds) != odd:
for i, x in enumerate(items):
if x[1] > 1:
items[i] = (x[0], x[1] - 2)
odds.append(x[0])
odds.append(x[0])
break
req_length = (n - odd) // odd + 1
cur_length = 0
while odd > 0:
if cur_length == 0:
dq.append(odds[-1])
cur_length += 1
odds.pop()
x = min(items[-1][1] >> 1, (req_length - cur_length) >> 1)
dq.append(items[-1][0] * x)
dq.appendleft(items[-1][0] * x)
cur_length += x << 1
if items[-1][1] - (x << 1) <= 1:
items.pop()
else:
items[-1] = (items[-1][0], items[-1][1] - (x << 1))
if cur_length == req_length:
print(*dq, sep="", end=' ')
odd -= 1
dq.clear()
cur_length = 0
print()
break
else:
print(n)
print(*s)
try:
while True:
main()
except EOFError:
pass
```
|
output
| 1
| 100,017
| 0
| 200,035
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
|
instruction
| 0
| 100,018
| 0
| 200,036
|
Tags: brute force, implementation, strings
Correct Solution:
```
n=int(input())
s=list(input())
lets={}
for i in s:
try:
lets[i]+=1
except:
lets[i]=1
count=0
centre=[]
rest=[]
for i in lets.keys():
if(lets[i]%2):
centre.append(i)
count+=1
rest+=[i]*(lets[i]//2)
if(count==0):
t=''
for i in lets.keys():
t=i*(lets[i]//2) + t + i*(lets[i]//2)
print(1)
print(t)
else:
extra=0
while(n%count!=0 or (n//count)%2==0):
count+=2
extra+=1
for i in range(extra):
centre+=[rest.pop()]*2
amt=len(rest)//(count)
temp=rest.copy()
rest=''
for i in temp:
rest+=i
print(count)
print(rest[0:amt] + centre[0] + rest[(1)*(amt)-1::-1],end=' ')
for i in range(1,count):
print(rest[i*(amt):(i+1)*amt] + centre[i] + rest[(i+1)*(amt)-1:(i)*amt-1:-1],end=' ')
print()
```
|
output
| 1
| 100,018
| 0
| 200,037
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
|
instruction
| 0
| 100,019
| 0
| 200,038
|
Tags: brute force, implementation, strings
Correct Solution:
```
n = int(input())
s = list(input())
d = {}
for char in s:
if char not in d.keys():
d[char] = 1
else:
d[char] += 1
odd = []
even = []
for char in d.keys():
for i in range(d[char] // 2):
even.append(char)
even.append(char)
for i in range(d[char] % 2):
odd.append(char)
if len(odd) <= 1:
x = ''.join([even[i] for i in range(1, len(even), 2)])
y = ''.join(odd)
print(1)
print(x + y + x[::-1])
else:
ratio = len(even)//len(odd)
max_length = 1
for i in range(1,ratio+2,2):
if n % i == 0 and max_length < i:
max_length = i
parts = n//max_length
print(parts)
x = []
indx = 0
for i in range(len(odd)):
tail = ''
while len(tail) < max_length // 2:
tail += even[indx]
indx += 2
x.append(tail + odd[i] + tail[::-1])
middle = []
for i in range(parts - len(odd)):
middle.append(even.pop())
for i in range(len(middle)):
tail = ''
while len(tail) < max_length // 2:
tail += even[indx]
indx += 2
x.append(tail + middle[i] + tail[::-1])
print(' '.join(x))
```
|
output
| 1
| 100,019
| 0
| 200,039
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
|
instruction
| 0
| 100,020
| 0
| 200,040
|
Tags: brute force, implementation, strings
Correct Solution:
```
from collections import Counter
n = int(input())
cnt = Counter(input())
odd = []
even = []
for s, c in cnt.items():
if c % 2 == 1:
odd.append([s, c])
else:
even.append([s, c])
k = max(1, len(odd))
for i in range(k, n + 1):
h = n // i
if i * h == n and (not odd and h % 2 == 0 or odd and h % 2 == 1):
k = i
break
h = n // k
res = []
while len(res) < k:
if odd:
s, c = odd.pop()
res.append(s)
c -= 1
if c:
even.append([s, c])
elif h % 2:
res.append(even[0][0])
res.append(even[0][0])
even[0][1] -= 2
if not even[0][1]:
even.pop(0)
else:
res.append('')
for i in range(k):
s = res[i]
while len(s) < h:
t = (h - len(s)) // 2
a, c = even[0]
if c <= 2 * t:
c //= 2
s = a*c + s + a*c
even.pop(0)
else:
s = a*t + s + a*t
even[0][1] -= 2 * t
res[i] = s
print(len(res))
print(' '.join(res))
```
|
output
| 1
| 100,020
| 0
| 200,041
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Submitted Solution:
```
from collections import Counter
n = int(input())
inp = input()
c = Counter(inp)
t = len(list(filter(lambda x: x % 2 == 1, list(c.values()))))
if t == 0:
temp = sum([[list(c.items())[j][0]] * (list(c.items())[j][1] // 2) for j in range(len(c.items()))], [])
print(1)
print(''.join(temp) + ''.join(temp[::-1]))
else:
ones = list()
for j in range(len(c.items())):
i = list(c.items())[j]
if i[1] % 2 == 1:
c[list(c.keys())[j]] -= 1
ones.append(i[0])
others = sum([[list(c.items())[j][0]] * (list(c.items())[j][1] // 2) for j in range(len(c.items()))], [])
while n % t != 0 or n // t % 2 == 0:
t += 2
o = others.pop()
ones.append(o)
ones.append(o)
L = n // t
ans = list()
ot = 0
for i in range(t):
mid = str()
if L % 2 == 1:
mid = ones[i]
ln = L // 2
ans.append(''.join(others[ot: ot + ln]) + mid + ''.join(others[ot: ot + ln][::-1]))
ot += ln
print(t)
print(' '.join(ans))
```
|
instruction
| 0
| 100,021
| 0
| 200,042
|
Yes
|
output
| 1
| 100,021
| 0
| 200,043
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Submitted Solution:
```
n = int(input())
s = input()
d = {}
for c in s:
if c not in d:
d[c] = 0
d[c] += 1
odd = []
sum = 0
for key in d:
if d[key] % 2 == 1:
odd.append(key)
d[key] -= 1
sum += d[key]
if sum // 2 < len(odd):
print(len(s))
for c in s:
print(c+' ', end='')
exit(0)
while True:
if len(odd) == 0 or (sum // 2) % len(odd) == 0:
break
sum -= 2
if sum // 2 < len(odd):
print(len(s))
for c in s:
print(c + ' ', end='')
exit(0)
for key in d:
odd.append(key)
odd.append(key)
d[key] -= 2
if d[key] == 0:
d.pop(key, None)
break
if len(odd) == 0:
odd.append('')
even = []
for key in d:
even += [key] * (d[key] // 2)
l = (sum // 2) // len(odd)
print(len(odd))
for i in range(len(odd)):
s = odd[i]
for j in range(i * l, (i + 1) * l):
s = even[j] + s + even[j]
print(s + ' ', end='')
```
|
instruction
| 0
| 100,022
| 0
| 200,044
|
Yes
|
output
| 1
| 100,022
| 0
| 200,045
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Submitted Solution:
```
n = int(input())
string = input()
char = []
charPair = []
charImpair = []
for car in string:
if car not in char:
z = string.count(car)
while z>1:
charPair.append(car)
z-=2
if(z==1):
charImpair.append(car)
char.append(car)
if len(charImpair) ==0 :
String1 = ''
for x in charPair:
String1+= x
if len(charImpair) ==1 :
String1 += charImpair[0]
for x in charPair[::-1]:
String1 += x
print('1')
print(String1)
else :
nbPalin = len(charImpair)
while len(charPair)%nbPalin != 0 :
nbPalin += 2
charImpair.append(charPair[-1])
charImpair.append(charPair[-1])
del(charPair[-1])
lenPalindrome = n/nbPalin
Palin = []
for i in range(nbPalin):
String2 = ''
indice = i * int(((lenPalindrome-1)/2))
for x in charPair[indice : int(indice + ((lenPalindrome-1)/2))]:
String2 += x
String2 += charImpair[i]
for x in range(indice + int(((lenPalindrome-1)/2))-1, indice-1 ,-1): # charPair[i + int(((lenPalindrome-1)/2))-1: i-1 :-1]:
String2 += charPair[x]
Palin.append(String2)
print(nbPalin)
String3 = ' '.join(Palin)
print(String3)
```
|
instruction
| 0
| 100,023
| 0
| 200,046
|
Yes
|
output
| 1
| 100,023
| 0
| 200,047
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Submitted Solution:
```
import sys
from collections import Counter
def gen(counter, skip):
for c, n in counter:
has = n // 2
if skip > has:
skip -= has
has = 0
elif skip > 0:
has -= skip
skip = 0
for i in range(has):
yield c
def gen_o(counter, take):
for c, n in counter:
for i in range(n % 2):
yield c
for c, n in counter:
has = (n // 2) * 2
if take > has:
take -= has
elif take > 0:
has = take
take = 0
for i in range(has):
yield c
N = int(next(sys.stdin))
s = next(sys.stdin).strip()
c = Counter(s)
even = 0
odd = 0
items = list(c.items())
for _, n in items:
even += n // 2
odd += n % 2
generator = gen(items, 0)
generator_o = gen_o(items, 0)
odd_c = odd
if odd == 0:
print(1)
front = [next(generator) for i in range(len(s) // 2)]
fs = "".join(front)
print(fs + fs[::-1])
else:
skip = 0
while even != 0 and even % odd != 0:
skip += 1
odd += 2
even -= 1
generator = gen(items, skip)
generator_o = gen_o(items, skip * 2)
print(odd)
per = even // odd
strs = []
for i in range(odd):
front = [next(generator) for i in range(per)]
fs = "".join(front)
strs.append(fs + next(generator_o) + fs[::-1])
print(" ".join(strs))
```
|
instruction
| 0
| 100,024
| 0
| 200,048
|
Yes
|
output
| 1
| 100,024
| 0
| 200,049
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Submitted Solution:
```
nlet = int(input())
let = [x for x in input()]
uno = [x for x in let if let.count(x)==1]
due = sorted([x for x in let if let.count(x)>1])[::2]
palin = len(uno)
totale = ""
if palin == 0:
totale += "".join(due+due[::-1])
else:
grup = len(due)//palin
j = 0
for i in range(1,palin+1):
f = i*grup
ini = due[j:f]
fin = ini[::-1]
totale += "".join(ini+[uno[i-1]]+fin+[" "])
j = f
print (totale)
```
|
instruction
| 0
| 100,025
| 0
| 200,050
|
No
|
output
| 1
| 100,025
| 0
| 200,051
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Submitted Solution:
```
n = int(input())
s = list(input())[:n]
d = {}
for char in s:
if char not in d.keys():
d[char] = 1
else:
d[char] += 1
odd = []
even = []
for char in d.keys():
for i in range(d[char] // 2):
even.append(char)
even.append(char)
for i in range(d[char] % 2):
odd.append(char)
if len(odd) <= 1:
x = ''.join([even[i] for i in range(1,len(even),2)])
y = ''.join(odd)
print(1)
print(x+y+x[::-1])
elif (len(even)//len(odd)) % 2 == 0 and (len(even)//len(odd)) > 0:
print(len(odd))
x = []
ratio = len(even)//len(odd)
indx = 0
for i in range(len(odd)):
tail = ''
while len(tail) < ratio//2:
tail += even[indx]
indx += 2
x.append(tail+odd[i]+tail[::-1])
print(' '.join(x))
else:
print(len(even)//2 + len(odd))
print((' '.join(even)+' '+ ' '.join(odd)).strip())
```
|
instruction
| 0
| 100,026
| 0
| 200,052
|
No
|
output
| 1
| 100,026
| 0
| 200,053
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Submitted Solution:
```
from collections import Counter
import sys
n = int(input())
s = input()
c = Counter(s)
a = []
odd = 0
for i in c:
if c[i] % 2:
odd += 1
a.append(i)
c[i] -= 1
even = n - odd
oddawal = odd
if odd != 0:
while even > 0:
if (even//2) % odd:
even -= 2
odd += 2
else:
break
else:
s = ''
for i in c:
s += i * (c[i]//2)
s += s[::-1]
print(1)
print(s)
sys.exit()
ubah = odd-oddawal
d = {}
for i in c:
if ubah > 0:
if c[i] % 2 == 0:
if ubah >= c[i]:
for _ in range(c[i]):
a.append(i)
ubah -= c[i]
d[i] = 0
else:
for _ in range(c[i]-ubah):
a.append(i)
ubah = 0
d[i] = c[i]-ubah
else:
break
for i in d:
c[i] = d[i]
print(len(a))
s = ''
for i in c:
s += i * (c[i]//2)
su = (len(s)//2)//len(a)
for i in range(len(a)):
a[i] = s[:su+1] + a[i] + s[:su+1][::-1]
s = s[su+1:]
print(*a)
```
|
instruction
| 0
| 100,027
| 0
| 200,054
|
No
|
output
| 1
| 100,027
| 0
| 200,055
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Submitted Solution:
```
n = int(input())
s = input()
let = list(set(list(s)))
m = len(let)
cnt = []
for c in let:
cn = [0]
for sc in s:
cn.append(cn[-1] + (sc == c))
cnt.append(cn)
def check(i, j):
c = 0
for p in range(m):
c += (cnt[p][j + 1] - cnt[p][i]) % 2 == 1
return c < 2
def create(i, j):
c = []
mid = None
for p in range(m):
h = cnt[p][j + 1] - cnt[p][i]
if h and h % 2 == 0:
c.append((let[p], h))
if h % 2:
mid = let[p], h
res = []
for l, h in c:
res.extend([l]*(h//2))
if mid:
res.extend([mid[0]]*mid[1])
for l, h in reversed(c):
res.extend([l]*(h//2))
return ''.join(res)
for c in range(1, n + 1):
if n % c == 0:
ch = True
l = n // c
for p in range(c):
ch = ch and check(p * l, (p + 1) * l - 1)
if ch:
res = []
for p in range(c):
res.append(create(p * l, (p + 1) * l - 1))
print(' '.join(res))
break
```
|
instruction
| 0
| 100,028
| 0
| 200,056
|
No
|
output
| 1
| 100,028
| 0
| 200,057
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan wants to write a letter to his friend. The letter is a string s consisting of lowercase Latin letters.
Unfortunately, when Ivan started writing the letter, he realised that it is very long and writing the whole letter may take extremely long time. So he wants to write the compressed version of string s instead of the string itself.
The compressed version of string s is a sequence of strings c1, s1, c2, s2, ..., ck, sk, where ci is the decimal representation of number ai (without any leading zeroes) and si is some string consisting of lowercase Latin letters. If Ivan writes string s1 exactly a1 times, then string s2 exactly a2 times, and so on, the result will be string s.
The length of a compressed version is |c1| + |s1| + |c2| + |s2|... |ck| + |sk|. Among all compressed versions Ivan wants to choose a version such that its length is minimum possible. Help Ivan to determine minimum possible length.
Input
The only line of input contains one string s consisting of lowercase Latin letters (1 β€ |s| β€ 8000).
Output
Output one integer number β the minimum possible length of a compressed version of s.
Examples
Input
aaaaaaaaaa
Output
3
Input
abcab
Output
6
Input
cczabababab
Output
7
Note
In the first example Ivan will choose this compressed version: c1 is 10, s1 is a.
In the second example Ivan will choose this compressed version: c1 is 1, s1 is abcab.
In the third example Ivan will choose this compressed version: c1 is 2, s1 is c, c2 is 1, s2 is z, c3 is 4, s3 is ab.
|
instruction
| 0
| 100,848
| 0
| 201,696
|
Tags: dp, hashing, string suffix structures, strings
Correct Solution:
```
s=input()
n=len(s)
def f(s):
n=len(s)
ar=[0]*n
i,j=1,0
while i<n:
if(s[i]==s[j]):
j+=1
ar[i]=j
i+=1
else:
if(j!=0):j=ar[j-1]
else:i+=1
return ar
dp=[n+1]*(n)+[0]
for i in range(n-1,-1,-1):
ar=f(s[i:])
for j in range(len(ar)):
T=1
k=j+1
if(k%(k-ar[j])==0):T=k//(k-ar[j])
dp[i]=min(dp[i],len(str(T))+k//T+dp[i+k])
print(dp[0])
```
|
output
| 1
| 100,848
| 0
| 201,697
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan wants to write a letter to his friend. The letter is a string s consisting of lowercase Latin letters.
Unfortunately, when Ivan started writing the letter, he realised that it is very long and writing the whole letter may take extremely long time. So he wants to write the compressed version of string s instead of the string itself.
The compressed version of string s is a sequence of strings c1, s1, c2, s2, ..., ck, sk, where ci is the decimal representation of number ai (without any leading zeroes) and si is some string consisting of lowercase Latin letters. If Ivan writes string s1 exactly a1 times, then string s2 exactly a2 times, and so on, the result will be string s.
The length of a compressed version is |c1| + |s1| + |c2| + |s2|... |ck| + |sk|. Among all compressed versions Ivan wants to choose a version such that its length is minimum possible. Help Ivan to determine minimum possible length.
Input
The only line of input contains one string s consisting of lowercase Latin letters (1 β€ |s| β€ 8000).
Output
Output one integer number β the minimum possible length of a compressed version of s.
Examples
Input
aaaaaaaaaa
Output
3
Input
abcab
Output
6
Input
cczabababab
Output
7
Note
In the first example Ivan will choose this compressed version: c1 is 10, s1 is a.
In the second example Ivan will choose this compressed version: c1 is 1, s1 is abcab.
In the third example Ivan will choose this compressed version: c1 is 2, s1 is c, c2 is 1, s2 is z, c3 is 4, s3 is ab.
|
instruction
| 0
| 100,849
| 0
| 201,698
|
Tags: dp, hashing, string suffix structures, strings
Correct Solution:
```
def prefix(s):
p = [0]
for i in range(1, len(s)):
j = p[-1]
while j > 0 and s[j] != s[i]:
j = p[j - 1]
if s[i] == s[j]:
j += 1
p.append(j)
return p
s = input()
n = len(s)
ans = [0] * (n + 1)
i = n - 1
while i >= 0:
p = prefix(s[i:])
ans[i] = 2 + ans[i + 1]
for j in range(len(p)):
z = 1
if (j + 1) % (j + 1 - p[j]) == 0:
z = (j + 1) // (j + 1 - p[j])
res = len(str(z)) + (j + 1) // z + ans[i + j + 1]
ans[i] = min(ans[i], res)
i -= 1
print(ans[0])
```
|
output
| 1
| 100,849
| 0
| 201,699
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call a string good if and only if it consists of only two types of letters β 'a' and 'b' and every two consecutive letters are distinct. For example "baba" and "aba" are good strings and "abb" is a bad string.
You have a strings "a", b strings "b" and c strings "ab". You want to choose some subset of these strings and concatenate them in any arbitrarily order.
What is the length of the longest good string you can obtain this way?
Input
The first line contains three positive integers a, b, c (1 β€ a, b, c β€ 10^9) β the number of strings "a", "b" and "ab" respectively.
Output
Print a single number β the maximum possible length of the good string you can obtain.
Examples
Input
1 1 1
Output
4
Input
2 1 2
Output
7
Input
3 5 2
Output
11
Input
2 2 1
Output
6
Input
1000000000 1000000000 1000000000
Output
4000000000
Note
In the first example the optimal string is "baba".
In the second example the optimal string is "abababa".
In the third example the optimal string is "bababababab".
In the fourth example the optimal string is "ababab".
|
instruction
| 0
| 101,238
| 0
| 202,476
|
Tags: greedy
Correct Solution:
```
a,b,c = map(int,input().split())
print([2*(min(a,b)+c)+1,2*(min(a,b)+c)][a==b])
```
|
output
| 1
| 101,238
| 0
| 202,477
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call a string good if and only if it consists of only two types of letters β 'a' and 'b' and every two consecutive letters are distinct. For example "baba" and "aba" are good strings and "abb" is a bad string.
You have a strings "a", b strings "b" and c strings "ab". You want to choose some subset of these strings and concatenate them in any arbitrarily order.
What is the length of the longest good string you can obtain this way?
Input
The first line contains three positive integers a, b, c (1 β€ a, b, c β€ 10^9) β the number of strings "a", "b" and "ab" respectively.
Output
Print a single number β the maximum possible length of the good string you can obtain.
Examples
Input
1 1 1
Output
4
Input
2 1 2
Output
7
Input
3 5 2
Output
11
Input
2 2 1
Output
6
Input
1000000000 1000000000 1000000000
Output
4000000000
Note
In the first example the optimal string is "baba".
In the second example the optimal string is "abababa".
In the third example the optimal string is "bababababab".
In the fourth example the optimal string is "ababab".
|
instruction
| 0
| 101,239
| 0
| 202,478
|
Tags: greedy
Correct Solution:
```
a,b,c=map(int,input().split())
if a!=b:
print(min(a,b)*2+1+c*2)
else:
print(a+b+c*2)
```
|
output
| 1
| 101,239
| 0
| 202,479
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call a string good if and only if it consists of only two types of letters β 'a' and 'b' and every two consecutive letters are distinct. For example "baba" and "aba" are good strings and "abb" is a bad string.
You have a strings "a", b strings "b" and c strings "ab". You want to choose some subset of these strings and concatenate them in any arbitrarily order.
What is the length of the longest good string you can obtain this way?
Input
The first line contains three positive integers a, b, c (1 β€ a, b, c β€ 10^9) β the number of strings "a", "b" and "ab" respectively.
Output
Print a single number β the maximum possible length of the good string you can obtain.
Examples
Input
1 1 1
Output
4
Input
2 1 2
Output
7
Input
3 5 2
Output
11
Input
2 2 1
Output
6
Input
1000000000 1000000000 1000000000
Output
4000000000
Note
In the first example the optimal string is "baba".
In the second example the optimal string is "abababa".
In the third example the optimal string is "bababababab".
In the fourth example the optimal string is "ababab".
|
instruction
| 0
| 101,240
| 0
| 202,480
|
Tags: greedy
Correct Solution:
```
a, b, c=map(int,input().split())
mn = min(a, b)
mx = max(a, b)
if mx > mn + 1:
mx = mn + 1
print(mn + mx + 2*c)
```
|
output
| 1
| 101,240
| 0
| 202,481
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call a string good if and only if it consists of only two types of letters β 'a' and 'b' and every two consecutive letters are distinct. For example "baba" and "aba" are good strings and "abb" is a bad string.
You have a strings "a", b strings "b" and c strings "ab". You want to choose some subset of these strings and concatenate them in any arbitrarily order.
What is the length of the longest good string you can obtain this way?
Input
The first line contains three positive integers a, b, c (1 β€ a, b, c β€ 10^9) β the number of strings "a", "b" and "ab" respectively.
Output
Print a single number β the maximum possible length of the good string you can obtain.
Examples
Input
1 1 1
Output
4
Input
2 1 2
Output
7
Input
3 5 2
Output
11
Input
2 2 1
Output
6
Input
1000000000 1000000000 1000000000
Output
4000000000
Note
In the first example the optimal string is "baba".
In the second example the optimal string is "abababa".
In the third example the optimal string is "bababababab".
In the fourth example the optimal string is "ababab".
|
instruction
| 0
| 101,241
| 0
| 202,482
|
Tags: greedy
Correct Solution:
```
a, b, c = map(int, input().split())
result = c*2 + min(a, b)*2 + (1 if a != b else 0)
print(result)
```
|
output
| 1
| 101,241
| 0
| 202,483
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call a string good if and only if it consists of only two types of letters β 'a' and 'b' and every two consecutive letters are distinct. For example "baba" and "aba" are good strings and "abb" is a bad string.
You have a strings "a", b strings "b" and c strings "ab". You want to choose some subset of these strings and concatenate them in any arbitrarily order.
What is the length of the longest good string you can obtain this way?
Input
The first line contains three positive integers a, b, c (1 β€ a, b, c β€ 10^9) β the number of strings "a", "b" and "ab" respectively.
Output
Print a single number β the maximum possible length of the good string you can obtain.
Examples
Input
1 1 1
Output
4
Input
2 1 2
Output
7
Input
3 5 2
Output
11
Input
2 2 1
Output
6
Input
1000000000 1000000000 1000000000
Output
4000000000
Note
In the first example the optimal string is "baba".
In the second example the optimal string is "abababa".
In the third example the optimal string is "bababababab".
In the fourth example the optimal string is "ababab".
|
instruction
| 0
| 101,242
| 0
| 202,484
|
Tags: greedy
Correct Solution:
```
from collections import Counter
a, b, c = map(int, input().split())
print((2 * (min(a, b) + c)) + (1 if a>b or b>a else 0))
```
|
output
| 1
| 101,242
| 0
| 202,485
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call a string good if and only if it consists of only two types of letters β 'a' and 'b' and every two consecutive letters are distinct. For example "baba" and "aba" are good strings and "abb" is a bad string.
You have a strings "a", b strings "b" and c strings "ab". You want to choose some subset of these strings and concatenate them in any arbitrarily order.
What is the length of the longest good string you can obtain this way?
Input
The first line contains three positive integers a, b, c (1 β€ a, b, c β€ 10^9) β the number of strings "a", "b" and "ab" respectively.
Output
Print a single number β the maximum possible length of the good string you can obtain.
Examples
Input
1 1 1
Output
4
Input
2 1 2
Output
7
Input
3 5 2
Output
11
Input
2 2 1
Output
6
Input
1000000000 1000000000 1000000000
Output
4000000000
Note
In the first example the optimal string is "baba".
In the second example the optimal string is "abababa".
In the third example the optimal string is "bababababab".
In the fourth example the optimal string is "ababab".
|
instruction
| 0
| 101,243
| 0
| 202,486
|
Tags: greedy
Correct Solution:
```
a,b,c=map(int, input().split())
if a==b:
print(a+b+2*c)
elif a<b:
print(2*a+2*c+1)
else:
print(2*b+2*c+1)
```
|
output
| 1
| 101,243
| 0
| 202,487
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call a string good if and only if it consists of only two types of letters β 'a' and 'b' and every two consecutive letters are distinct. For example "baba" and "aba" are good strings and "abb" is a bad string.
You have a strings "a", b strings "b" and c strings "ab". You want to choose some subset of these strings and concatenate them in any arbitrarily order.
What is the length of the longest good string you can obtain this way?
Input
The first line contains three positive integers a, b, c (1 β€ a, b, c β€ 10^9) β the number of strings "a", "b" and "ab" respectively.
Output
Print a single number β the maximum possible length of the good string you can obtain.
Examples
Input
1 1 1
Output
4
Input
2 1 2
Output
7
Input
3 5 2
Output
11
Input
2 2 1
Output
6
Input
1000000000 1000000000 1000000000
Output
4000000000
Note
In the first example the optimal string is "baba".
In the second example the optimal string is "abababa".
In the third example the optimal string is "bababababab".
In the fourth example the optimal string is "ababab".
|
instruction
| 0
| 101,244
| 0
| 202,488
|
Tags: greedy
Correct Solution:
```
def main():
a, b, c = map(int, input().split())
ans = 2 * c
ans += 2 * min(a, b)
if a != b:
ans += 1
print(ans)
if __name__ == "__main__":
main()
```
|
output
| 1
| 101,244
| 0
| 202,489
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call a string good if and only if it consists of only two types of letters β 'a' and 'b' and every two consecutive letters are distinct. For example "baba" and "aba" are good strings and "abb" is a bad string.
You have a strings "a", b strings "b" and c strings "ab". You want to choose some subset of these strings and concatenate them in any arbitrarily order.
What is the length of the longest good string you can obtain this way?
Input
The first line contains three positive integers a, b, c (1 β€ a, b, c β€ 10^9) β the number of strings "a", "b" and "ab" respectively.
Output
Print a single number β the maximum possible length of the good string you can obtain.
Examples
Input
1 1 1
Output
4
Input
2 1 2
Output
7
Input
3 5 2
Output
11
Input
2 2 1
Output
6
Input
1000000000 1000000000 1000000000
Output
4000000000
Note
In the first example the optimal string is "baba".
In the second example the optimal string is "abababa".
In the third example the optimal string is "bababababab".
In the fourth example the optimal string is "ababab".
|
instruction
| 0
| 101,245
| 0
| 202,490
|
Tags: greedy
Correct Solution:
```
a,b,c=[int(x) for x in input().split()]
if a==b:
print(a+b+2*c)
elif a>b:
print(b*2+2*c+1)
else:
print(a*2+2*c+1)
```
|
output
| 1
| 101,245
| 0
| 202,491
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a string good if and only if it consists of only two types of letters β 'a' and 'b' and every two consecutive letters are distinct. For example "baba" and "aba" are good strings and "abb" is a bad string.
You have a strings "a", b strings "b" and c strings "ab". You want to choose some subset of these strings and concatenate them in any arbitrarily order.
What is the length of the longest good string you can obtain this way?
Input
The first line contains three positive integers a, b, c (1 β€ a, b, c β€ 10^9) β the number of strings "a", "b" and "ab" respectively.
Output
Print a single number β the maximum possible length of the good string you can obtain.
Examples
Input
1 1 1
Output
4
Input
2 1 2
Output
7
Input
3 5 2
Output
11
Input
2 2 1
Output
6
Input
1000000000 1000000000 1000000000
Output
4000000000
Note
In the first example the optimal string is "baba".
In the second example the optimal string is "abababa".
In the third example the optimal string is "bababababab".
In the fourth example the optimal string is "ababab".
Submitted Solution:
```
a,b,c = map(int,input().split())
m = 2*c
if a>b:
m+=2*b + 1
elif a==b:
m+=2*a
else:
m+=2*a+1
print(m)
```
|
instruction
| 0
| 101,246
| 0
| 202,492
|
Yes
|
output
| 1
| 101,246
| 0
| 202,493
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a string good if and only if it consists of only two types of letters β 'a' and 'b' and every two consecutive letters are distinct. For example "baba" and "aba" are good strings and "abb" is a bad string.
You have a strings "a", b strings "b" and c strings "ab". You want to choose some subset of these strings and concatenate them in any arbitrarily order.
What is the length of the longest good string you can obtain this way?
Input
The first line contains three positive integers a, b, c (1 β€ a, b, c β€ 10^9) β the number of strings "a", "b" and "ab" respectively.
Output
Print a single number β the maximum possible length of the good string you can obtain.
Examples
Input
1 1 1
Output
4
Input
2 1 2
Output
7
Input
3 5 2
Output
11
Input
2 2 1
Output
6
Input
1000000000 1000000000 1000000000
Output
4000000000
Note
In the first example the optimal string is "baba".
In the second example the optimal string is "abababa".
In the third example the optimal string is "bababababab".
In the fourth example the optimal string is "ababab".
Submitted Solution:
```
a,b,c=input().split()
a,b,c=eval(a),eval(b),eval(c)
if a-b>1:
a=2*b+2*c+1
elif b-a>1:
a=2*a+2*c+1
else:
a=a+b+2*c
print(a)
```
|
instruction
| 0
| 101,247
| 0
| 202,494
|
Yes
|
output
| 1
| 101,247
| 0
| 202,495
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a string good if and only if it consists of only two types of letters β 'a' and 'b' and every two consecutive letters are distinct. For example "baba" and "aba" are good strings and "abb" is a bad string.
You have a strings "a", b strings "b" and c strings "ab". You want to choose some subset of these strings and concatenate them in any arbitrarily order.
What is the length of the longest good string you can obtain this way?
Input
The first line contains three positive integers a, b, c (1 β€ a, b, c β€ 10^9) β the number of strings "a", "b" and "ab" respectively.
Output
Print a single number β the maximum possible length of the good string you can obtain.
Examples
Input
1 1 1
Output
4
Input
2 1 2
Output
7
Input
3 5 2
Output
11
Input
2 2 1
Output
6
Input
1000000000 1000000000 1000000000
Output
4000000000
Note
In the first example the optimal string is "baba".
In the second example the optimal string is "abababa".
In the third example the optimal string is "bababababab".
In the fourth example the optimal string is "ababab".
Submitted Solution:
```
a,b,c = [int(x) for x in input().split(" ")]
if a==b: print(a+b+2*c)
else:
a,b = [a,b] if a<b else [b,a]
print(a*2+1+2*c)
```
|
instruction
| 0
| 101,248
| 0
| 202,496
|
Yes
|
output
| 1
| 101,248
| 0
| 202,497
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a string good if and only if it consists of only two types of letters β 'a' and 'b' and every two consecutive letters are distinct. For example "baba" and "aba" are good strings and "abb" is a bad string.
You have a strings "a", b strings "b" and c strings "ab". You want to choose some subset of these strings and concatenate them in any arbitrarily order.
What is the length of the longest good string you can obtain this way?
Input
The first line contains three positive integers a, b, c (1 β€ a, b, c β€ 10^9) β the number of strings "a", "b" and "ab" respectively.
Output
Print a single number β the maximum possible length of the good string you can obtain.
Examples
Input
1 1 1
Output
4
Input
2 1 2
Output
7
Input
3 5 2
Output
11
Input
2 2 1
Output
6
Input
1000000000 1000000000 1000000000
Output
4000000000
Note
In the first example the optimal string is "baba".
In the second example the optimal string is "abababa".
In the third example the optimal string is "bababababab".
In the fourth example the optimal string is "ababab".
Submitted Solution:
```
a, b, c = map(int, input().split())
m=min(a,b)
if a!=b:
s=(2*c)+(2*m)+1
else:
s=(2*c)+(2*m)
print(s)
```
|
instruction
| 0
| 101,249
| 0
| 202,498
|
Yes
|
output
| 1
| 101,249
| 0
| 202,499
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a string good if and only if it consists of only two types of letters β 'a' and 'b' and every two consecutive letters are distinct. For example "baba" and "aba" are good strings and "abb" is a bad string.
You have a strings "a", b strings "b" and c strings "ab". You want to choose some subset of these strings and concatenate them in any arbitrarily order.
What is the length of the longest good string you can obtain this way?
Input
The first line contains three positive integers a, b, c (1 β€ a, b, c β€ 10^9) β the number of strings "a", "b" and "ab" respectively.
Output
Print a single number β the maximum possible length of the good string you can obtain.
Examples
Input
1 1 1
Output
4
Input
2 1 2
Output
7
Input
3 5 2
Output
11
Input
2 2 1
Output
6
Input
1000000000 1000000000 1000000000
Output
4000000000
Note
In the first example the optimal string is "baba".
In the second example the optimal string is "abababa".
In the third example the optimal string is "bababababab".
In the fourth example the optimal string is "ababab".
Submitted Solution:
```
a,b,c=(int(i) for i in input().split())
if(b>a):
print((2*a)+1+(2*c))
elif(a<b):
print((2*c)+(2*b)+1)
else:
print(a+b+(2*c))
```
|
instruction
| 0
| 101,250
| 0
| 202,500
|
No
|
output
| 1
| 101,250
| 0
| 202,501
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a string good if and only if it consists of only two types of letters β 'a' and 'b' and every two consecutive letters are distinct. For example "baba" and "aba" are good strings and "abb" is a bad string.
You have a strings "a", b strings "b" and c strings "ab". You want to choose some subset of these strings and concatenate them in any arbitrarily order.
What is the length of the longest good string you can obtain this way?
Input
The first line contains three positive integers a, b, c (1 β€ a, b, c β€ 10^9) β the number of strings "a", "b" and "ab" respectively.
Output
Print a single number β the maximum possible length of the good string you can obtain.
Examples
Input
1 1 1
Output
4
Input
2 1 2
Output
7
Input
3 5 2
Output
11
Input
2 2 1
Output
6
Input
1000000000 1000000000 1000000000
Output
4000000000
Note
In the first example the optimal string is "baba".
In the second example the optimal string is "abababa".
In the third example the optimal string is "bababababab".
In the fourth example the optimal string is "ababab".
Submitted Solution:
```
a,b,c=map(int,input().split())
if abs(a-b)==0:
k=b
else:
k=min(a,b)+1
print((c*2)+k)
```
|
instruction
| 0
| 101,251
| 0
| 202,502
|
No
|
output
| 1
| 101,251
| 0
| 202,503
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a string good if and only if it consists of only two types of letters β 'a' and 'b' and every two consecutive letters are distinct. For example "baba" and "aba" are good strings and "abb" is a bad string.
You have a strings "a", b strings "b" and c strings "ab". You want to choose some subset of these strings and concatenate them in any arbitrarily order.
What is the length of the longest good string you can obtain this way?
Input
The first line contains three positive integers a, b, c (1 β€ a, b, c β€ 10^9) β the number of strings "a", "b" and "ab" respectively.
Output
Print a single number β the maximum possible length of the good string you can obtain.
Examples
Input
1 1 1
Output
4
Input
2 1 2
Output
7
Input
3 5 2
Output
11
Input
2 2 1
Output
6
Input
1000000000 1000000000 1000000000
Output
4000000000
Note
In the first example the optimal string is "baba".
In the second example the optimal string is "abababa".
In the third example the optimal string is "bababababab".
In the fourth example the optimal string is "ababab".
Submitted Solution:
```
#G3_A
import sys
lne = [int(i) for i in sys.stdin.readline().rstrip().split(" ")]
m = min(lne)
num = 4 * m
lne = [i - m for i in lne]
if lne[0] and lne[1]:
m = sorted(lne)[1]
num += 2 * m
if lne[1] != lne[0]:
num += 1
lne = [max(i - m, 0) for i in lne]
elif (lne[1] and lne[2]) or (lne[0] and lne[2]):
num += 2 * lne[2] + 1
elif lne[2]:
num += 2 * lne[2]
print(num)
```
|
instruction
| 0
| 101,252
| 0
| 202,504
|
No
|
output
| 1
| 101,252
| 0
| 202,505
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call a string good if and only if it consists of only two types of letters β 'a' and 'b' and every two consecutive letters are distinct. For example "baba" and "aba" are good strings and "abb" is a bad string.
You have a strings "a", b strings "b" and c strings "ab". You want to choose some subset of these strings and concatenate them in any arbitrarily order.
What is the length of the longest good string you can obtain this way?
Input
The first line contains three positive integers a, b, c (1 β€ a, b, c β€ 10^9) β the number of strings "a", "b" and "ab" respectively.
Output
Print a single number β the maximum possible length of the good string you can obtain.
Examples
Input
1 1 1
Output
4
Input
2 1 2
Output
7
Input
3 5 2
Output
11
Input
2 2 1
Output
6
Input
1000000000 1000000000 1000000000
Output
4000000000
Note
In the first example the optimal string is "baba".
In the second example the optimal string is "abababa".
In the third example the optimal string is "bababababab".
In the fourth example the optimal string is "ababab".
Submitted Solution:
```
a,b,c=map(int, input().split())
if a<=b:
print(a+b+2*c)
else:
print(2*a+2*c+1)
```
|
instruction
| 0
| 101,253
| 0
| 202,506
|
No
|
output
| 1
| 101,253
| 0
| 202,507
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have c_1 letters 'a', c_2 letters 'b', ..., c_{26} letters 'z'. You want to build a beautiful string of length n from them (obviously, you cannot use the i-th letter more than c_i times). Each c_i is greater than n/3.
A string is called beautiful if there are no palindromic contiguous substrings of odd length greater than 1 in it. For example, the string "abacaba" is not beautiful, it has several palindromic substrings of odd length greater than 1 (for example, "aca"). Another example: the string "abcaa" is beautiful.
Calculate the number of different strings you can build, and print the answer modulo 998244353.
Input
The first line contains one integer n (3 β€ n β€ 400).
The second line contains 26 integers c_1, c_2, ..., c_{26} (n/3 < c_i β€ n).
Output
Print one integer β the number of strings you can build, taken modulo 998244353.
Examples
Input
4
2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
Output
422500
Input
3
2 2 2 2 2 2 3 3 3 2 2 2 2 2 2 3 3 3 2 2 3 2 2 3 2 2
Output
16900
Input
400
348 322 247 158 209 134 151 267 268 176 214 379 372 291 388 135 147 304 169 149 193 351 380 368 181 340
Output
287489790
Submitted Solution:
```
from math import fabs
s = input()
n = len(s)
cur = ans = 0
for ch in s:
ans += int(fabs(int(ch) - cur))*n
cur = int(ch)
n -= 1
print(ans)
```
|
instruction
| 0
| 101,432
| 0
| 202,864
|
No
|
output
| 1
| 101,432
| 0
| 202,865
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have c_1 letters 'a', c_2 letters 'b', ..., c_{26} letters 'z'. You want to build a beautiful string of length n from them (obviously, you cannot use the i-th letter more than c_i times). Each c_i is greater than n/3.
A string is called beautiful if there are no palindromic contiguous substrings of odd length greater than 1 in it. For example, the string "abacaba" is not beautiful, it has several palindromic substrings of odd length greater than 1 (for example, "aca"). Another example: the string "abcaa" is beautiful.
Calculate the number of different strings you can build, and print the answer modulo 998244353.
Input
The first line contains one integer n (3 β€ n β€ 400).
The second line contains 26 integers c_1, c_2, ..., c_{26} (n/3 < c_i β€ n).
Output
Print one integer β the number of strings you can build, taken modulo 998244353.
Examples
Input
4
2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
Output
422500
Input
3
2 2 2 2 2 2 3 3 3 2 2 2 2 2 2 3 3 3 2 2 3 2 2 3 2 2
Output
16900
Input
400
348 322 247 158 209 134 151 267 268 176 214 379 372 291 388 135 147 304 169 149 193 351 380 368 181 340
Output
287489790
Submitted Solution:
```
import itertools, sys
num = [1, 6, 8, 9]
perm = itertools.permutations(num)
sev = {}
for i in perm:
ans=0
for j in i:
ans*=10
ans+=j
sev[ans % 7] = ans
import io,os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
val=input().decode().strip()
nums = [0] * 10
for i in num:
nums[i] = 1
nn=""
vl=0
for i in val:
if (nums[int(i)]):
nums[int(i)] = 0
continue
vl *= 10
vl += int(i)
vl %= 7
sys.stdout.write(i)
vl *= 10**4
vl %= 7
sys.stdout.write(str(sev[(7 - vl) % 7]))
```
|
instruction
| 0
| 101,433
| 0
| 202,866
|
No
|
output
| 1
| 101,433
| 0
| 202,867
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have c_1 letters 'a', c_2 letters 'b', ..., c_{26} letters 'z'. You want to build a beautiful string of length n from them (obviously, you cannot use the i-th letter more than c_i times). Each c_i is greater than n/3.
A string is called beautiful if there are no palindromic contiguous substrings of odd length greater than 1 in it. For example, the string "abacaba" is not beautiful, it has several palindromic substrings of odd length greater than 1 (for example, "aca"). Another example: the string "abcaa" is beautiful.
Calculate the number of different strings you can build, and print the answer modulo 998244353.
Input
The first line contains one integer n (3 β€ n β€ 400).
The second line contains 26 integers c_1, c_2, ..., c_{26} (n/3 < c_i β€ n).
Output
Print one integer β the number of strings you can build, taken modulo 998244353.
Examples
Input
4
2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
Output
422500
Input
3
2 2 2 2 2 2 3 3 3 2 2 2 2 2 2 3 3 3 2 2 3 2 2 3 2 2
Output
16900
Input
400
348 322 247 158 209 134 151 267 268 176 214 379 372 291 388 135 147 304 169 149 193 351 380 368 181 340
Output
287489790
Submitted Solution:
```
n = int(input())
c = list(map(int, input().split()))
print(26*26*(25**(n-2)) % 998244353)
#print(26*26*25*25)
'''
ΠΡΠ΅Π³ΠΎ Π²Π°ΡΠΈΠ°Π½ΡΠΎΠ²: 26^n
AXA
n ans
1 26
2 26*26
3 26*26*25
4 **** 26*26 25*25*25*25*25
[2, 2, 2, 2, 2, 2, 2, 2...]
1. C_26_n
2. C_26_(n - 1) * n - 1
3.
'''
```
|
instruction
| 0
| 101,434
| 0
| 202,868
|
No
|
output
| 1
| 101,434
| 0
| 202,869
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have c_1 letters 'a', c_2 letters 'b', ..., c_{26} letters 'z'. You want to build a beautiful string of length n from them (obviously, you cannot use the i-th letter more than c_i times). Each c_i is greater than n/3.
A string is called beautiful if there are no palindromic contiguous substrings of odd length greater than 1 in it. For example, the string "abacaba" is not beautiful, it has several palindromic substrings of odd length greater than 1 (for example, "aca"). Another example: the string "abcaa" is beautiful.
Calculate the number of different strings you can build, and print the answer modulo 998244353.
Input
The first line contains one integer n (3 β€ n β€ 400).
The second line contains 26 integers c_1, c_2, ..., c_{26} (n/3 < c_i β€ n).
Output
Print one integer β the number of strings you can build, taken modulo 998244353.
Examples
Input
4
2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
Output
422500
Input
3
2 2 2 2 2 2 3 3 3 2 2 2 2 2 2 3 3 3 2 2 3 2 2 3 2 2
Output
16900
Input
400
348 322 247 158 209 134 151 267 268 176 214 379 372 291 388 135 147 304 169 149 193 351 380 368 181 340
Output
287489790
Submitted Solution:
```
# Python3 program to replace c1 with c2
# and c2 with c1
def replace(s, c1, c2):
l = len(s)
# loop to traverse in the string
for i in range(l):
# check for c1 and replace
if (s[i] == c1):
s = s[0:i] + c2 + s[i + 1:]
# check for c2 and replace
elif (s[i] == c2):
s = s[0:i] + c1 + s[i + 1:]
return s
# Driver Code
if __name__ == '__main__':
s = "grrksfoegrrks"
c1 = 'e'
c2 = 'r'
print(replace(s, c1, c2))
# This code is contributed
# by PrinciRaj1992
```
|
instruction
| 0
| 101,435
| 0
| 202,870
|
No
|
output
| 1
| 101,435
| 0
| 202,871
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's define the cost of a string s as the number of index pairs i and j (1 β€ i < j < |s|) such that s_i = s_j and s_{i+1} = s_{j+1}.
You are given two positive integers n and k. Among all strings with length n that contain only the first k characters of the Latin alphabet, find a string with minimum possible cost. If there are multiple such strings with minimum cost β find any of them.
Input
The only line contains two integers n and k (1 β€ n β€ 2 β
10^5; 1 β€ k β€ 26).
Output
Print the string s such that it consists of n characters, each its character is one of the k first Latin letters, and it has the minimum possible cost among all these strings. If there are multiple such strings β print any of them.
Examples
Input
9 4
Output
aabacadbb
Input
5 1
Output
aaaaa
Input
10 26
Output
codeforces
|
instruction
| 0
| 101,436
| 0
| 202,872
|
Tags: brute force, constructive algorithms, graphs, greedy, strings
Correct Solution:
```
from __future__ import division, print_function
import math
import sys
import os
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")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input().strip()
return(list(s[:len(s)]))
def invr():
return(map(int,input().split()))
alp=['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
n,k=invr()
l1=[]
for i in range(k):
for j in range(i,k):
if i==j:
l1.append(alp[i])
continue
l1.append(alp[i]+alp[j])
s="".join(l1)
v=n//k + 1
ans=s*v
print(ans[:n])
```
|
output
| 1
| 101,436
| 0
| 202,873
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's define the cost of a string s as the number of index pairs i and j (1 β€ i < j < |s|) such that s_i = s_j and s_{i+1} = s_{j+1}.
You are given two positive integers n and k. Among all strings with length n that contain only the first k characters of the Latin alphabet, find a string with minimum possible cost. If there are multiple such strings with minimum cost β find any of them.
Input
The only line contains two integers n and k (1 β€ n β€ 2 β
10^5; 1 β€ k β€ 26).
Output
Print the string s such that it consists of n characters, each its character is one of the k first Latin letters, and it has the minimum possible cost among all these strings. If there are multiple such strings β print any of them.
Examples
Input
9 4
Output
aabacadbb
Input
5 1
Output
aaaaa
Input
10 26
Output
codeforces
|
instruction
| 0
| 101,437
| 0
| 202,874
|
Tags: brute force, constructive algorithms, graphs, greedy, strings
Correct Solution:
```
n,k=map(int,input().split())
ans=''
for i in range(k):
temp=chr(ord('a')+i)
ans+=temp
for j in range(i+1,k):
ans+=temp+chr(ord('a')+j)
if len(ans)<n:
while(len(ans)<n):
ans+=ans
print(ans[:n])
```
|
output
| 1
| 101,437
| 0
| 202,875
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's define the cost of a string s as the number of index pairs i and j (1 β€ i < j < |s|) such that s_i = s_j and s_{i+1} = s_{j+1}.
You are given two positive integers n and k. Among all strings with length n that contain only the first k characters of the Latin alphabet, find a string with minimum possible cost. If there are multiple such strings with minimum cost β find any of them.
Input
The only line contains two integers n and k (1 β€ n β€ 2 β
10^5; 1 β€ k β€ 26).
Output
Print the string s such that it consists of n characters, each its character is one of the k first Latin letters, and it has the minimum possible cost among all these strings. If there are multiple such strings β print any of them.
Examples
Input
9 4
Output
aabacadbb
Input
5 1
Output
aaaaa
Input
10 26
Output
codeforces
|
instruction
| 0
| 101,438
| 0
| 202,876
|
Tags: brute force, constructive algorithms, graphs, greedy, strings
Correct Solution:
```
import sys
import math
import heapq
import bisect
from collections import Counter
from collections import defaultdict
from io import BytesIO, IOBase
import string
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
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
self.BUFSIZE = 8192
def read(self):
while True:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, self.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 = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, self.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:
self.os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def get_int():
return int(input())
def get_ints():
return list(map(int, input().split(' ')))
def get_int_grid(n):
return [get_ints() for _ in range(n)]
def get_str():
return input().strip()
def get_strs():
return get_str().split(' ')
def flat_list(arr):
return [item for subarr in arr for item in subarr]
def yes_no(b):
if b:
return "YES"
else:
return "NO"
def binary_search(good, left, right, delta=1, right_true=False):
"""
Performs binary search
----------
Parameters
----------
:param good: Function used to perform the binary search
:param left: Starting value of left limit
:param right: Starting value of the right limit
:param delta: Margin of error, defaults value of 1 for integer binary search
:param right_true: Boolean, for whether the right limit is the true invariant
:return: Returns the most extremal value interval [left, right] which is good function evaluates to True,
alternatively returns False if no such value found
"""
limits = [left, right]
while limits[1] - limits[0] > delta:
if delta == 1:
mid = sum(limits) // 2
else:
mid = sum(limits) / 2
if good(mid):
limits[int(right_true)] = mid
else:
limits[int(~right_true)] = mid
if good(limits[int(right_true)]):
return limits[int(right_true)]
else:
return False
def prefix_sums(a):
p = [0]
for x in a:
p.append(p[-1] + x)
return p
def solve_a():
n = get_int()
r = get_ints()
return r.count(1) + r.count(3)
def solve_b():
a, b, c = get_ints()
swap = False
if b > a:
swap = True
a, b = b, a
x = 10 ** (a - 1)
y = int('1' * (b - c + 1) + '0' * (c - 1))
if swap:
return y, x
else:
return x, y
def solve_c():
n, q = get_ints()
a = get_ints()
a_max = max(a)
t = get_ints()
firsts = [-1 for _ in range(a_max)]
for i, v in enumerate(a):
if firsts[v - 1] == -1:
firsts[v - 1] = i
ans = []
for q in t:
q -= 1
tmp = firsts[q]
firsts[q] = 0
ans.append(tmp + 1)
for i, x in enumerate(firsts):
if i != q and firsts[i] < tmp:
firsts[i] += 1
return ans
def solve_d():
n, k = get_ints()
path = [0]
G = {j: [i for i in range(k)] for j in range(k)}
while len(path) < (k * k):
curr = path[-1]
foll = G[curr].pop()
path.append(foll)
ans = path * (n // len(path)) + path[:n % (len(path))]
alpha = list(string.ascii_lowercase)
ans_alpha = [alpha[x] for x in ans]
return ''.join(ans_alpha)
print(solve_d())
```
|
output
| 1
| 101,438
| 0
| 202,877
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.