message
stringlengths 2
23.4k
| message_type
stringclasses 2
values | message_id
int64 0
1
| conversation_id
int64 129
108k
| cluster
float64 6
6
| __index_level_0__
int64 258
216k
|
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Kefa found n baloons. For convenience, we denote color of i-th baloon as si — lowercase letter of the Latin alphabet. Also Kefa has k friends. Friend will be upset, If he get two baloons of the same color. Kefa want to give out all baloons to his friends. Help Kefa to find out, can he give out all his baloons, such that no one of his friens will be upset — print «YES», if he can, and «NO», otherwise. Note, that Kefa's friend will not upset, if he doesn't get baloons at all.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 100) — the number of baloons and friends.
Next line contains string s — colors of baloons.
Output
Answer to the task — «YES» or «NO» in a single line.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
4 2
aabb
Output
YES
Input
6 3
aacaab
Output
NO
Note
In the first sample Kefa can give 1-st and 3-rd baloon to the first friend, and 2-nd and 4-th to the second.
In the second sample Kefa needs to give to all his friends baloons of color a, but one baloon will stay, thats why answer is «NO».
|
instruction
| 0
| 4,718
| 6
| 9,436
|
Tags: brute force, implementation
Correct Solution:
```
n,k = map(int, input().split())
s = input()
r = [0]*26
y=0
for i in s:
nomer = ord(i)-97
r[nomer] +=1
for i in range(len(r)):
if r[i] >k and r[i] !=0:
y+=1
if y>0:
print('NO')
elif y==0:
print('YES')
```
|
output
| 1
| 4,718
| 6
| 9,437
|
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Kefa found n baloons. For convenience, we denote color of i-th baloon as si — lowercase letter of the Latin alphabet. Also Kefa has k friends. Friend will be upset, If he get two baloons of the same color. Kefa want to give out all baloons to his friends. Help Kefa to find out, can he give out all his baloons, such that no one of his friens will be upset — print «YES», if he can, and «NO», otherwise. Note, that Kefa's friend will not upset, if he doesn't get baloons at all.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 100) — the number of baloons and friends.
Next line contains string s — colors of baloons.
Output
Answer to the task — «YES» or «NO» in a single line.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
4 2
aabb
Output
YES
Input
6 3
aacaab
Output
NO
Note
In the first sample Kefa can give 1-st and 3-rd baloon to the first friend, and 2-nd and 4-th to the second.
In the second sample Kefa needs to give to all his friends baloons of color a, but one baloon will stay, thats why answer is «NO».
|
instruction
| 0
| 4,719
| 6
| 9,438
|
Tags: brute force, implementation
Correct Solution:
```
n, k = map(int, input().split())
b = list(input())
a = {}
s = 0
for i in b:
a[i] = a.get(i, 0) + 1
for i in a:
if a[i] > s:
s = a[i]
if s > k:
print('NO')
else:
print('YES')
```
|
output
| 1
| 4,719
| 6
| 9,439
|
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Kefa found n baloons. For convenience, we denote color of i-th baloon as si — lowercase letter of the Latin alphabet. Also Kefa has k friends. Friend will be upset, If he get two baloons of the same color. Kefa want to give out all baloons to his friends. Help Kefa to find out, can he give out all his baloons, such that no one of his friens will be upset — print «YES», if he can, and «NO», otherwise. Note, that Kefa's friend will not upset, if he doesn't get baloons at all.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 100) — the number of baloons and friends.
Next line contains string s — colors of baloons.
Output
Answer to the task — «YES» or «NO» in a single line.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
4 2
aabb
Output
YES
Input
6 3
aacaab
Output
NO
Note
In the first sample Kefa can give 1-st and 3-rd baloon to the first friend, and 2-nd and 4-th to the second.
In the second sample Kefa needs to give to all his friends baloons of color a, but one baloon will stay, thats why answer is «NO».
|
instruction
| 0
| 4,720
| 6
| 9,440
|
Tags: brute force, implementation
Correct Solution:
```
n, k = map(int, input().split())
s = input()
l = set(list(s))
a = [s.count(i) for i in l]
if max(a) > k:
print('NO')
else:
print('YES')
```
|
output
| 1
| 4,720
| 6
| 9,441
|
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Kefa found n baloons. For convenience, we denote color of i-th baloon as si — lowercase letter of the Latin alphabet. Also Kefa has k friends. Friend will be upset, If he get two baloons of the same color. Kefa want to give out all baloons to his friends. Help Kefa to find out, can he give out all his baloons, such that no one of his friens will be upset — print «YES», if he can, and «NO», otherwise. Note, that Kefa's friend will not upset, if he doesn't get baloons at all.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 100) — the number of baloons and friends.
Next line contains string s — colors of baloons.
Output
Answer to the task — «YES» or «NO» in a single line.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
4 2
aabb
Output
YES
Input
6 3
aacaab
Output
NO
Note
In the first sample Kefa can give 1-st and 3-rd baloon to the first friend, and 2-nd and 4-th to the second.
In the second sample Kefa needs to give to all his friends baloons of color a, but one baloon will stay, thats why answer is «NO».
|
instruction
| 0
| 4,721
| 6
| 9,442
|
Tags: brute force, implementation
Correct Solution:
```
n,k=map(int,input().split())
a=input()
d={}
for i in a:
d[i]=d.get(i,0)+1
for i in d:
if d[i]>k:
print('NO')
break
else:
print('YES')
# n,k=map(int,input().split())
# a=input()
# d={}
# kol=0
# kolkol=0
# for i in a:
# d[i]=d.get(i,0)+1
# print(d)
# for i in d:
# if d[i]%k==0:
# kol+=1
# for i in d:
# if d[i]==1:
# kolkol+=1
# if kol==k or kolkol==len(d):
# print('YES')
# else:
# print('NO')
```
|
output
| 1
| 4,721
| 6
| 9,443
|
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Kefa found n baloons. For convenience, we denote color of i-th baloon as si — lowercase letter of the Latin alphabet. Also Kefa has k friends. Friend will be upset, If he get two baloons of the same color. Kefa want to give out all baloons to his friends. Help Kefa to find out, can he give out all his baloons, such that no one of his friens will be upset — print «YES», if he can, and «NO», otherwise. Note, that Kefa's friend will not upset, if he doesn't get baloons at all.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 100) — the number of baloons and friends.
Next line contains string s — colors of baloons.
Output
Answer to the task — «YES» or «NO» in a single line.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
4 2
aabb
Output
YES
Input
6 3
aacaab
Output
NO
Note
In the first sample Kefa can give 1-st and 3-rd baloon to the first friend, and 2-nd and 4-th to the second.
In the second sample Kefa needs to give to all his friends baloons of color a, but one baloon will stay, thats why answer is «NO».
|
instruction
| 0
| 4,722
| 6
| 9,444
|
Tags: brute force, implementation
Correct Solution:
```
n, k = list(map(int, input().split()))
s = list(input())
unique = set(s)
count = {}
for i in s:
count[i] = count.get(i, 0) + 1
values = [count[c] for c in unique]
values.sort(reverse=True)
assign = [[] for i in range(k)]
each = n//k
rem = n%k
for i in range(k):
for j in range(each):
for v in range(len(values)):
if(values[v] > 0 and v not in assign[i]):
assign[i].append(v)
values[v] -= 1
break
for v in range(len(values)):
while(values[v] > 0):
got = False
for i in range(k):
if(v not in assign[i]):
assign[i].append(v)
values[v] -= 1
got = True
break
if(got == False):
break
#print(assign, values)
ans = True
for v in range(len(values)):
if(values[v] > 0):
ans = False
break
if(ans == True):
print('YES')
else:
print('NO')
```
|
output
| 1
| 4,722
| 6
| 9,445
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vera adores poems. All the poems Vera knows are divided into quatrains (groups of four lines) and in each quatrain some lines contain rhymes.
Let's consider that all lines in the poems consist of lowercase Latin letters (without spaces). Letters "a", "e", "i", "o", "u" are considered vowels.
Two lines rhyme if their suffixes that start from the k-th vowels (counting from the end) match. If a line has less than k vowels, then such line can't rhyme with any other line. For example, if k = 1, lines commit and hermit rhyme (the corresponding suffixes equal it), and if k = 2, they do not rhyme (ommit ≠ ermit).
Today on a literature lesson Vera learned that quatrains can contain four different schemes of rhymes, namely the following ones (the same letters stand for rhyming lines):
* Clerihew (aabb);
* Alternating (abab);
* Enclosed (abba).
If all lines of a quatrain pairwise rhyme, then the quatrain can belong to any rhyme scheme (this situation is represented by aaaa).
If all quatrains of a poem belong to the same rhyme scheme, then we can assume that the whole poem belongs to this rhyme scheme. If in each quatrain all lines pairwise rhyme, then the rhyme scheme of the poem is aaaa. Let us note that it doesn't matter whether lines from different quatrains rhyme with each other or not. In other words, it is possible that different quatrains aren't connected by a rhyme.
Vera got a long poem as a home task. The girl has to analyse it and find the poem rhyme scheme. Help Vera cope with the task.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2500, 1 ≤ k ≤ 5) — the number of quatrains in the poem and the vowel's number, correspondingly. Next 4n lines contain the poem. Each line is not empty and only consists of small Latin letters. The total length of the lines does not exceed 104.
If we assume that the lines are numbered starting from 1, then the first quatrain contains lines number 1, 2, 3, 4; the second one contains lines number 5, 6, 7, 8; and so on.
Output
Print the rhyme scheme of the poem as "aabb", "abab", "abba", "aaaa"; or "NO" if the poem does not belong to any of the above mentioned schemes.
Examples
Input
1 1
day
may
sun
fun
Output
aabb
Input
1 1
day
may
gray
way
Output
aaaa
Input
2 1
a
a
a
a
a
a
e
e
Output
aabb
Input
2 1
day
may
sun
fun
test
hill
fest
thrill
Output
NO
Note
In the last sample both quatrains have rhymes but finding the common scheme is impossible, so the answer is "NO".
|
instruction
| 0
| 5,220
| 6
| 10,440
|
Tags: implementation
Correct Solution:
```
def rhyme(a,b,k):
v=["a","e","i","o","u"]
i_a=None
i_b=None
v_a=0
v_b=0
for i in range(len(a)-1,-1,-1):
if a[i] in v:
v_a+=1
if v_a==k:
i_a=i
break
for i in range(len(b)-1,-1,-1):
if b[i] in v:
v_b+=1
if v_b==k:
i_b=i
break
if i_a!=None and i_b != None and a[i_a:]==b[i_b:]:
return True
return False
def main(arr,k):
style={0:"aabb",1:"abab",2:"abba",3:'aaaa'}
ans=[]
for j in range(4):
c=True
for i in range(len(arr)):
q=arr[i]
if j==0:
if rhyme(q[0],q[1],k) and rhyme(q[2],q[3],k):
continue
else:
c=False
break
if j==1:
if rhyme(q[0],q[2],k) and rhyme(q[1],q[3],k):
continue
else:
c=False
break
if j==2:
if rhyme(q[0],q[3],k) and rhyme(q[1],q[2],k):
continue
else:
c=False
break
if j==3:
if rhyme(q[0],q[1],k) and rhyme(q[1],q[2],k) and rhyme(q[2],q[3],k):
continue
else:
c=False
break
if c:
ans.append(j)
if 3 in ans:
return style[3]
elif len(ans)>=1:
return style[ans[0]]
else:
return "NO"
n,k=list(map(int,input().split()))
arr=[]
for i in range(n):
temp=[]
for j in range(4):
temp.append(input())
arr.append(temp)
print(main(arr,k))
```
|
output
| 1
| 5,220
| 6
| 10,441
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vera adores poems. All the poems Vera knows are divided into quatrains (groups of four lines) and in each quatrain some lines contain rhymes.
Let's consider that all lines in the poems consist of lowercase Latin letters (without spaces). Letters "a", "e", "i", "o", "u" are considered vowels.
Two lines rhyme if their suffixes that start from the k-th vowels (counting from the end) match. If a line has less than k vowels, then such line can't rhyme with any other line. For example, if k = 1, lines commit and hermit rhyme (the corresponding suffixes equal it), and if k = 2, they do not rhyme (ommit ≠ ermit).
Today on a literature lesson Vera learned that quatrains can contain four different schemes of rhymes, namely the following ones (the same letters stand for rhyming lines):
* Clerihew (aabb);
* Alternating (abab);
* Enclosed (abba).
If all lines of a quatrain pairwise rhyme, then the quatrain can belong to any rhyme scheme (this situation is represented by aaaa).
If all quatrains of a poem belong to the same rhyme scheme, then we can assume that the whole poem belongs to this rhyme scheme. If in each quatrain all lines pairwise rhyme, then the rhyme scheme of the poem is aaaa. Let us note that it doesn't matter whether lines from different quatrains rhyme with each other or not. In other words, it is possible that different quatrains aren't connected by a rhyme.
Vera got a long poem as a home task. The girl has to analyse it and find the poem rhyme scheme. Help Vera cope with the task.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2500, 1 ≤ k ≤ 5) — the number of quatrains in the poem and the vowel's number, correspondingly. Next 4n lines contain the poem. Each line is not empty and only consists of small Latin letters. The total length of the lines does not exceed 104.
If we assume that the lines are numbered starting from 1, then the first quatrain contains lines number 1, 2, 3, 4; the second one contains lines number 5, 6, 7, 8; and so on.
Output
Print the rhyme scheme of the poem as "aabb", "abab", "abba", "aaaa"; or "NO" if the poem does not belong to any of the above mentioned schemes.
Examples
Input
1 1
day
may
sun
fun
Output
aabb
Input
1 1
day
may
gray
way
Output
aaaa
Input
2 1
a
a
a
a
a
a
e
e
Output
aabb
Input
2 1
day
may
sun
fun
test
hill
fest
thrill
Output
NO
Note
In the last sample both quatrains have rhymes but finding the common scheme is impossible, so the answer is "NO".
|
instruction
| 0
| 5,221
| 6
| 10,442
|
Tags: implementation
Correct Solution:
```
#from bisect import bisect_left as bl #c++ lowerbound bl(array,element)
#from bisect import bisect_right as br #c++ upperbound br(array,element)
#from __future__ import print_function, division #while using python2
# from itertools import accumulate
# from collections import defaultdict, Counter
def modinv(n,p):
return pow(n,p-2,p)
def get_suffix(s, k):
vovels = "aeiou"
for i in range(len(s)-1, -1, -1):
if s[i] in vovels:
k -= 1
if k == 0:
return s[i:]
return -1
# aaaa = 1
# aabb = 2
# abab = 3
# abba = 4
# none = -1
def get_scheme(s1, s2, s3, s4):
if s1 == s2 == s3 == s4:
return 1
if s1 == s2 and s3 == s4:
return 2
if s1 == s3 and s2 == s4:
return 3
if s1 == s4 and s2 == s3:
return 4
return -1
def get_scheme2(x):
if x == 1:
return "aaaa"
if x == 2:
return "aabb"
if x == 3:
return "abab"
if x == 4:
return "abba"
def main():
#sys.stdin = open('input.txt', 'r')
#sys.stdout = open('output.txt', 'w')
# print(get_suffix("commit", 3))
n, k = [int(x) for x in input().split()]
rhymes = []
no_scheme = False
for i in range(n):
s1 = get_suffix(input(), k)
s2 = get_suffix(input(), k)
s3 = get_suffix(input(), k)
s4 = get_suffix(input(), k)
if s1 == -1 or s2 == -1 or s3 == -1 or s4 == -1:
rhymes.append(-1)
else:
rhymes.append(get_scheme(s1, s2, s3, s4))
# print(*rhymes)
rhymes = set(rhymes)
scheme = ""
if -1 in rhymes:
scheme = "NO"
elif len(rhymes) == 1:
scheme = get_scheme2(rhymes.pop())
elif len(rhymes) == 2 and 1 in rhymes:
rhymes.remove(1)
scheme = get_scheme2(rhymes.pop())
else:
scheme = "NO"
print(scheme)
#------------------ Python 2 and 3 footer by Pajenegod and c1729-----------------------------------------
py2 = round(0.5)
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192
class FastIO(BytesIO):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.writable = "x" in file.mode or "w" in file.mode
self.write = super(FastIO, self).write if self.writable else None
def _fill(self):
s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
return s
def read(self):
while self._fill(): pass
return super(FastIO,self).read()
def readline(self):
while self.newlines == 0:
s = self._fill(); self.newlines = s.count(b"\n") + (not s)
self.newlines -= 1
return super(FastIO, self).readline()
def flush(self):
if self.writable:
os.write(self._fd, self.getvalue())
self.truncate(0), self.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
if py2:
self.write = self.buffer.write
self.read = self.buffer.read
self.readline = self.buffer.readline
else:
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')
if __name__ == '__main__':
main()
```
|
output
| 1
| 5,221
| 6
| 10,443
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vera adores poems. All the poems Vera knows are divided into quatrains (groups of four lines) and in each quatrain some lines contain rhymes.
Let's consider that all lines in the poems consist of lowercase Latin letters (without spaces). Letters "a", "e", "i", "o", "u" are considered vowels.
Two lines rhyme if their suffixes that start from the k-th vowels (counting from the end) match. If a line has less than k vowels, then such line can't rhyme with any other line. For example, if k = 1, lines commit and hermit rhyme (the corresponding suffixes equal it), and if k = 2, they do not rhyme (ommit ≠ ermit).
Today on a literature lesson Vera learned that quatrains can contain four different schemes of rhymes, namely the following ones (the same letters stand for rhyming lines):
* Clerihew (aabb);
* Alternating (abab);
* Enclosed (abba).
If all lines of a quatrain pairwise rhyme, then the quatrain can belong to any rhyme scheme (this situation is represented by aaaa).
If all quatrains of a poem belong to the same rhyme scheme, then we can assume that the whole poem belongs to this rhyme scheme. If in each quatrain all lines pairwise rhyme, then the rhyme scheme of the poem is aaaa. Let us note that it doesn't matter whether lines from different quatrains rhyme with each other or not. In other words, it is possible that different quatrains aren't connected by a rhyme.
Vera got a long poem as a home task. The girl has to analyse it and find the poem rhyme scheme. Help Vera cope with the task.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2500, 1 ≤ k ≤ 5) — the number of quatrains in the poem and the vowel's number, correspondingly. Next 4n lines contain the poem. Each line is not empty and only consists of small Latin letters. The total length of the lines does not exceed 104.
If we assume that the lines are numbered starting from 1, then the first quatrain contains lines number 1, 2, 3, 4; the second one contains lines number 5, 6, 7, 8; and so on.
Output
Print the rhyme scheme of the poem as "aabb", "abab", "abba", "aaaa"; or "NO" if the poem does not belong to any of the above mentioned schemes.
Examples
Input
1 1
day
may
sun
fun
Output
aabb
Input
1 1
day
may
gray
way
Output
aaaa
Input
2 1
a
a
a
a
a
a
e
e
Output
aabb
Input
2 1
day
may
sun
fun
test
hill
fest
thrill
Output
NO
Note
In the last sample both quatrains have rhymes but finding the common scheme is impossible, so the answer is "NO".
|
instruction
| 0
| 5,222
| 6
| 10,444
|
Tags: implementation
Correct Solution:
```
n,k = map(int,input().split())
lis=[]
vov=['a','e','i','o','u']
d={}
d['aabb']=d['abab']=d['abba']=d['aaaa']=0
for i in range(n*4):
s = input()
lis.append(s)
if i%4==3:
tmp=['']*4
for j in range(4):
s=lis[j]
c=0
cou=0
for ll in s[::-1]:
cou+=1
if ll in vov:
c+=1
if c==k:
tmp[j]=s[-cou:]
break
# print(tmp)
tt=1
if tmp[0]==tmp[1]==tmp[2]==tmp[3] and tmp[0]!='':
d['aaaa']+=1
tt=0
if tmp[0]==tmp[1] and tmp[2]==tmp[3] and tmp[1]!=tmp[3] and tmp[1]!='' and tmp[3]!='':
d['aabb']+=1
tt=0
elif tmp[0]==tmp[2] and tmp[1]==tmp[3] and tmp[1]!=tmp[0] and tmp[1]!='' and tmp[0]!='':
d['abab']+=1
tt=0
elif tmp[0]==tmp[3] and tmp[1]==tmp[2] and tmp[2]!=tmp[0] and tmp[1]!='' and tmp[3]!='':
d['abba']+=1
tt=0
if tt:
print("NO")
exit()
lis=[]
c=0
for i in d:
if d[i]>0:
c+=1
if c==1:
for i in d:
if d[i]>0:
print(i)
exit()
elif c==2 and d['aaaa']>0:
for i in d:
if d[i]>0:
print(i)
exit()
else:
print("NO")
```
|
output
| 1
| 5,222
| 6
| 10,445
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vera adores poems. All the poems Vera knows are divided into quatrains (groups of four lines) and in each quatrain some lines contain rhymes.
Let's consider that all lines in the poems consist of lowercase Latin letters (without spaces). Letters "a", "e", "i", "o", "u" are considered vowels.
Two lines rhyme if their suffixes that start from the k-th vowels (counting from the end) match. If a line has less than k vowels, then such line can't rhyme with any other line. For example, if k = 1, lines commit and hermit rhyme (the corresponding suffixes equal it), and if k = 2, they do not rhyme (ommit ≠ ermit).
Today on a literature lesson Vera learned that quatrains can contain four different schemes of rhymes, namely the following ones (the same letters stand for rhyming lines):
* Clerihew (aabb);
* Alternating (abab);
* Enclosed (abba).
If all lines of a quatrain pairwise rhyme, then the quatrain can belong to any rhyme scheme (this situation is represented by aaaa).
If all quatrains of a poem belong to the same rhyme scheme, then we can assume that the whole poem belongs to this rhyme scheme. If in each quatrain all lines pairwise rhyme, then the rhyme scheme of the poem is aaaa. Let us note that it doesn't matter whether lines from different quatrains rhyme with each other or not. In other words, it is possible that different quatrains aren't connected by a rhyme.
Vera got a long poem as a home task. The girl has to analyse it and find the poem rhyme scheme. Help Vera cope with the task.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2500, 1 ≤ k ≤ 5) — the number of quatrains in the poem and the vowel's number, correspondingly. Next 4n lines contain the poem. Each line is not empty and only consists of small Latin letters. The total length of the lines does not exceed 104.
If we assume that the lines are numbered starting from 1, then the first quatrain contains lines number 1, 2, 3, 4; the second one contains lines number 5, 6, 7, 8; and so on.
Output
Print the rhyme scheme of the poem as "aabb", "abab", "abba", "aaaa"; or "NO" if the poem does not belong to any of the above mentioned schemes.
Examples
Input
1 1
day
may
sun
fun
Output
aabb
Input
1 1
day
may
gray
way
Output
aaaa
Input
2 1
a
a
a
a
a
a
e
e
Output
aabb
Input
2 1
day
may
sun
fun
test
hill
fest
thrill
Output
NO
Note
In the last sample both quatrains have rhymes but finding the common scheme is impossible, so the answer is "NO".
|
instruction
| 0
| 5,223
| 6
| 10,446
|
Tags: implementation
Correct Solution:
```
n, k = map(int, input().split())
ve = 'aeiou'
abba, aabb, abab = 1, 1, 1
for j in range(n):
a = ['']*4
for i in range(4):
a[i] = input()
l = len(a[i])
curr = 0
while l > 0 and curr < k:
l -= 1
if a[i][l] in ve:
curr += 1
if curr == k:
a[i] = a[i][l:]
else:
a[i] = str(i)
if a[0] == a[3] and a[1] == a[2]:
abba = abba and 1
else:
abba = 0
if a[0] == a[1] and a[2] == a[3]:
aabb = aabb and 1
else:
aabb = 0
if a[0] == a[2] and a[1] == a[3]:
abab = abab and 1
else:
abab = 0
if abba and aabb and abab:
print('aaaa')
elif not(abba or aabb or abab):
print('NO')
elif abba:
print('abba')
elif abab:
print('abab')
elif aabb:
print('aabb')
# Made By Mostafa_Khaled
```
|
output
| 1
| 5,223
| 6
| 10,447
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vera adores poems. All the poems Vera knows are divided into quatrains (groups of four lines) and in each quatrain some lines contain rhymes.
Let's consider that all lines in the poems consist of lowercase Latin letters (without spaces). Letters "a", "e", "i", "o", "u" are considered vowels.
Two lines rhyme if their suffixes that start from the k-th vowels (counting from the end) match. If a line has less than k vowels, then such line can't rhyme with any other line. For example, if k = 1, lines commit and hermit rhyme (the corresponding suffixes equal it), and if k = 2, they do not rhyme (ommit ≠ ermit).
Today on a literature lesson Vera learned that quatrains can contain four different schemes of rhymes, namely the following ones (the same letters stand for rhyming lines):
* Clerihew (aabb);
* Alternating (abab);
* Enclosed (abba).
If all lines of a quatrain pairwise rhyme, then the quatrain can belong to any rhyme scheme (this situation is represented by aaaa).
If all quatrains of a poem belong to the same rhyme scheme, then we can assume that the whole poem belongs to this rhyme scheme. If in each quatrain all lines pairwise rhyme, then the rhyme scheme of the poem is aaaa. Let us note that it doesn't matter whether lines from different quatrains rhyme with each other or not. In other words, it is possible that different quatrains aren't connected by a rhyme.
Vera got a long poem as a home task. The girl has to analyse it and find the poem rhyme scheme. Help Vera cope with the task.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2500, 1 ≤ k ≤ 5) — the number of quatrains in the poem and the vowel's number, correspondingly. Next 4n lines contain the poem. Each line is not empty and only consists of small Latin letters. The total length of the lines does not exceed 104.
If we assume that the lines are numbered starting from 1, then the first quatrain contains lines number 1, 2, 3, 4; the second one contains lines number 5, 6, 7, 8; and so on.
Output
Print the rhyme scheme of the poem as "aabb", "abab", "abba", "aaaa"; or "NO" if the poem does not belong to any of the above mentioned schemes.
Examples
Input
1 1
day
may
sun
fun
Output
aabb
Input
1 1
day
may
gray
way
Output
aaaa
Input
2 1
a
a
a
a
a
a
e
e
Output
aabb
Input
2 1
day
may
sun
fun
test
hill
fest
thrill
Output
NO
Note
In the last sample both quatrains have rhymes but finding the common scheme is impossible, so the answer is "NO".
|
instruction
| 0
| 5,224
| 6
| 10,448
|
Tags: implementation
Correct Solution:
```
n, k = map(int, input().split())
vowels = ['a', 'e', 'i', 'o', 'u']
def find_nth(tab, S, n):
amount, pos = (1 if tab[0] in S else 0), 0
while pos < len(tab) and amount < n:
pos += 1
if tab[pos] in S:
amount += 1
return pos
def rhyme_type(lines, k):
suffixes = []
for line in lines:
amount = 0
for i in line:
if i in vowels:
amount += 1
if amount < k:
return 'TRASH'
rev = list(reversed(list(line)))
ind_from_front = find_nth(rev, vowels, k)
suffixes.append(line[-ind_from_front - 1:])
if all([suffixes[0] == x for x in suffixes]):
return 'aaaa'
if suffixes[0] == suffixes[1] and suffixes[2] == suffixes[3]:
return 'aabb'
if suffixes[0] == suffixes[2] and suffixes[1] == suffixes[3]:
return 'abab'
if suffixes[0] == suffixes[3] and suffixes[1] == suffixes[2]:
return 'abba'
return 'TRASH'
all_rhymes = set()
for _ in range(n):
lines = [input(), input(), input(), input()]
all_rhymes.add(rhyme_type(lines, k))
if 'TRASH' not in all_rhymes and len(all_rhymes) == 2 and 'aaaa' in all_rhymes:
all_rhymes.remove('aaaa')
print(list(all_rhymes)[0])
elif len(all_rhymes) > 1 or 'TRASH' in all_rhymes:
print('NO')
else:
print(list(all_rhymes)[0])
```
|
output
| 1
| 5,224
| 6
| 10,449
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vera adores poems. All the poems Vera knows are divided into quatrains (groups of four lines) and in each quatrain some lines contain rhymes.
Let's consider that all lines in the poems consist of lowercase Latin letters (without spaces). Letters "a", "e", "i", "o", "u" are considered vowels.
Two lines rhyme if their suffixes that start from the k-th vowels (counting from the end) match. If a line has less than k vowels, then such line can't rhyme with any other line. For example, if k = 1, lines commit and hermit rhyme (the corresponding suffixes equal it), and if k = 2, they do not rhyme (ommit ≠ ermit).
Today on a literature lesson Vera learned that quatrains can contain four different schemes of rhymes, namely the following ones (the same letters stand for rhyming lines):
* Clerihew (aabb);
* Alternating (abab);
* Enclosed (abba).
If all lines of a quatrain pairwise rhyme, then the quatrain can belong to any rhyme scheme (this situation is represented by aaaa).
If all quatrains of a poem belong to the same rhyme scheme, then we can assume that the whole poem belongs to this rhyme scheme. If in each quatrain all lines pairwise rhyme, then the rhyme scheme of the poem is aaaa. Let us note that it doesn't matter whether lines from different quatrains rhyme with each other or not. In other words, it is possible that different quatrains aren't connected by a rhyme.
Vera got a long poem as a home task. The girl has to analyse it and find the poem rhyme scheme. Help Vera cope with the task.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2500, 1 ≤ k ≤ 5) — the number of quatrains in the poem and the vowel's number, correspondingly. Next 4n lines contain the poem. Each line is not empty and only consists of small Latin letters. The total length of the lines does not exceed 104.
If we assume that the lines are numbered starting from 1, then the first quatrain contains lines number 1, 2, 3, 4; the second one contains lines number 5, 6, 7, 8; and so on.
Output
Print the rhyme scheme of the poem as "aabb", "abab", "abba", "aaaa"; or "NO" if the poem does not belong to any of the above mentioned schemes.
Examples
Input
1 1
day
may
sun
fun
Output
aabb
Input
1 1
day
may
gray
way
Output
aaaa
Input
2 1
a
a
a
a
a
a
e
e
Output
aabb
Input
2 1
day
may
sun
fun
test
hill
fest
thrill
Output
NO
Note
In the last sample both quatrains have rhymes but finding the common scheme is impossible, so the answer is "NO".
|
instruction
| 0
| 5,225
| 6
| 10,450
|
Tags: implementation
Correct Solution:
```
n, k = map(int, input().split())
def get_suffix(line):
position = 0
for _ in range(k):
position -= 1
while -position <= len(line) and line[position] not in 'aeiou':
position -= 1
if -position > len(line):
return ''
return line[position:]
common_rhyme_type = 'aaaa'
for _ in range(n):
s1, s2, s3, s4 = [get_suffix(input()) for _ in range(4)]
if '' in (s1, s2, s3, s4):
print('NO')
break
if s1 == s2 == s3 == s4:
rhyme_type = 'aaaa'
elif s1 == s2 and s3 == s4:
rhyme_type = 'aabb'
elif s1 == s3 and s2 == s4:
rhyme_type = 'abab'
elif s1 == s4 and s2 == s3:
rhyme_type = 'abba'
else:
print('NO')
break
if rhyme_type != 'aaaa':
if common_rhyme_type != 'aaaa' and rhyme_type != common_rhyme_type:
print('NO')
break
else:
common_rhyme_type = rhyme_type
else:
print(common_rhyme_type)
```
|
output
| 1
| 5,225
| 6
| 10,451
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vera adores poems. All the poems Vera knows are divided into quatrains (groups of four lines) and in each quatrain some lines contain rhymes.
Let's consider that all lines in the poems consist of lowercase Latin letters (without spaces). Letters "a", "e", "i", "o", "u" are considered vowels.
Two lines rhyme if their suffixes that start from the k-th vowels (counting from the end) match. If a line has less than k vowels, then such line can't rhyme with any other line. For example, if k = 1, lines commit and hermit rhyme (the corresponding suffixes equal it), and if k = 2, they do not rhyme (ommit ≠ ermit).
Today on a literature lesson Vera learned that quatrains can contain four different schemes of rhymes, namely the following ones (the same letters stand for rhyming lines):
* Clerihew (aabb);
* Alternating (abab);
* Enclosed (abba).
If all lines of a quatrain pairwise rhyme, then the quatrain can belong to any rhyme scheme (this situation is represented by aaaa).
If all quatrains of a poem belong to the same rhyme scheme, then we can assume that the whole poem belongs to this rhyme scheme. If in each quatrain all lines pairwise rhyme, then the rhyme scheme of the poem is aaaa. Let us note that it doesn't matter whether lines from different quatrains rhyme with each other or not. In other words, it is possible that different quatrains aren't connected by a rhyme.
Vera got a long poem as a home task. The girl has to analyse it and find the poem rhyme scheme. Help Vera cope with the task.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2500, 1 ≤ k ≤ 5) — the number of quatrains in the poem and the vowel's number, correspondingly. Next 4n lines contain the poem. Each line is not empty and only consists of small Latin letters. The total length of the lines does not exceed 104.
If we assume that the lines are numbered starting from 1, then the first quatrain contains lines number 1, 2, 3, 4; the second one contains lines number 5, 6, 7, 8; and so on.
Output
Print the rhyme scheme of the poem as "aabb", "abab", "abba", "aaaa"; or "NO" if the poem does not belong to any of the above mentioned schemes.
Examples
Input
1 1
day
may
sun
fun
Output
aabb
Input
1 1
day
may
gray
way
Output
aaaa
Input
2 1
a
a
a
a
a
a
e
e
Output
aabb
Input
2 1
day
may
sun
fun
test
hill
fest
thrill
Output
NO
Note
In the last sample both quatrains have rhymes but finding the common scheme is impossible, so the answer is "NO".
|
instruction
| 0
| 5,226
| 6
| 10,452
|
Tags: implementation
Correct Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from heapq import*
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ALPHA='abcdefghijklmnopqrstuvwxyz'
M=10**9+7
EPS=1e-6
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
# vsInput()
ACCEPTED={'aaaa','aabb','abba','abab'}
vowels='aeiou'
nul='abcd'
nu=0
def operate(s):
global nu
c=0
for i in range(len(s)-1,-1,-1):
if(s[i] in vowels):
c+=1
if(c==k):
return s[i:]
nu=(nu+1)%4
return nul[nu]
def rhymes(a):
a=[operate(i) for i in a]
# print(a)
ID={}
id=0
ans=''
for i in a:
if(i not in ID):
ID[i]=nul[id]
id+=1
ans+=ID[i]
return ans
n,k=value()
scheme=set()
for i in range(n):
a=[]
for j in range(4):
a.append(input())
scheme.add(rhymes(a))
# print(scheme)
for i in scheme:
if(i not in ACCEPTED):
print("NO")
exit()
if(len(scheme)>2):
print("NO")
elif(len(scheme)==2):
if('aaaa' not in scheme):
print("NO")
else:
for i in scheme:
if(i!='aaaa'):
print(i)
else:
print(*scheme)
```
|
output
| 1
| 5,226
| 6
| 10,453
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Vera adores poems. All the poems Vera knows are divided into quatrains (groups of four lines) and in each quatrain some lines contain rhymes.
Let's consider that all lines in the poems consist of lowercase Latin letters (without spaces). Letters "a", "e", "i", "o", "u" are considered vowels.
Two lines rhyme if their suffixes that start from the k-th vowels (counting from the end) match. If a line has less than k vowels, then such line can't rhyme with any other line. For example, if k = 1, lines commit and hermit rhyme (the corresponding suffixes equal it), and if k = 2, they do not rhyme (ommit ≠ ermit).
Today on a literature lesson Vera learned that quatrains can contain four different schemes of rhymes, namely the following ones (the same letters stand for rhyming lines):
* Clerihew (aabb);
* Alternating (abab);
* Enclosed (abba).
If all lines of a quatrain pairwise rhyme, then the quatrain can belong to any rhyme scheme (this situation is represented by aaaa).
If all quatrains of a poem belong to the same rhyme scheme, then we can assume that the whole poem belongs to this rhyme scheme. If in each quatrain all lines pairwise rhyme, then the rhyme scheme of the poem is aaaa. Let us note that it doesn't matter whether lines from different quatrains rhyme with each other or not. In other words, it is possible that different quatrains aren't connected by a rhyme.
Vera got a long poem as a home task. The girl has to analyse it and find the poem rhyme scheme. Help Vera cope with the task.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2500, 1 ≤ k ≤ 5) — the number of quatrains in the poem and the vowel's number, correspondingly. Next 4n lines contain the poem. Each line is not empty and only consists of small Latin letters. The total length of the lines does not exceed 104.
If we assume that the lines are numbered starting from 1, then the first quatrain contains lines number 1, 2, 3, 4; the second one contains lines number 5, 6, 7, 8; and so on.
Output
Print the rhyme scheme of the poem as "aabb", "abab", "abba", "aaaa"; or "NO" if the poem does not belong to any of the above mentioned schemes.
Examples
Input
1 1
day
may
sun
fun
Output
aabb
Input
1 1
day
may
gray
way
Output
aaaa
Input
2 1
a
a
a
a
a
a
e
e
Output
aabb
Input
2 1
day
may
sun
fun
test
hill
fest
thrill
Output
NO
Note
In the last sample both quatrains have rhymes but finding the common scheme is impossible, so the answer is "NO".
|
instruction
| 0
| 5,227
| 6
| 10,454
|
Tags: implementation
Correct Solution:
```
from sys import stdin
read = stdin.readline
n,k = map(int,read().split())
r = 0
vowel = {'a','e','i','o','u'}
def cmp(a,b,k,vowel):
l = 0
for x,y in zip(reversed(a),reversed(b)):
if x != y:
return False
l += (x in vowel)
if l == k:
return True
return False
im = True
for s in range(n):
a,b,c,d = read(),read(),read(),read()
l = 0
for i,x in enumerate(reversed(a),start=1):
l += (x in vowel)
if l == k:
break
else:
print('NO')
break
b2,b3,b4 = (a[-i:] == b[-i:]),(a[-i:] == c[-i:]),(a[-i:] == d[-i:])
if b2 + b3 + b4 == 3:
continue
elif b2 + b3 + b4 == 1:
if b2 and (r == 1 or r == 0) and cmp(c,d,k,vowel):
r = 1
continue
elif b3 and (r==2 or r == 0) and cmp(b,d,k,vowel):
r = 2
continue
elif b4 and (r == 3 or r == 0) and cmp(b,c,k,vowel):
r = 3
continue
print('NO')
break
else:
print(['aaaa','aabb','abab','abba'][r])
```
|
output
| 1
| 5,227
| 6
| 10,455
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vera adores poems. All the poems Vera knows are divided into quatrains (groups of four lines) and in each quatrain some lines contain rhymes.
Let's consider that all lines in the poems consist of lowercase Latin letters (without spaces). Letters "a", "e", "i", "o", "u" are considered vowels.
Two lines rhyme if their suffixes that start from the k-th vowels (counting from the end) match. If a line has less than k vowels, then such line can't rhyme with any other line. For example, if k = 1, lines commit and hermit rhyme (the corresponding suffixes equal it), and if k = 2, they do not rhyme (ommit ≠ ermit).
Today on a literature lesson Vera learned that quatrains can contain four different schemes of rhymes, namely the following ones (the same letters stand for rhyming lines):
* Clerihew (aabb);
* Alternating (abab);
* Enclosed (abba).
If all lines of a quatrain pairwise rhyme, then the quatrain can belong to any rhyme scheme (this situation is represented by aaaa).
If all quatrains of a poem belong to the same rhyme scheme, then we can assume that the whole poem belongs to this rhyme scheme. If in each quatrain all lines pairwise rhyme, then the rhyme scheme of the poem is aaaa. Let us note that it doesn't matter whether lines from different quatrains rhyme with each other or not. In other words, it is possible that different quatrains aren't connected by a rhyme.
Vera got a long poem as a home task. The girl has to analyse it and find the poem rhyme scheme. Help Vera cope with the task.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2500, 1 ≤ k ≤ 5) — the number of quatrains in the poem and the vowel's number, correspondingly. Next 4n lines contain the poem. Each line is not empty and only consists of small Latin letters. The total length of the lines does not exceed 104.
If we assume that the lines are numbered starting from 1, then the first quatrain contains lines number 1, 2, 3, 4; the second one contains lines number 5, 6, 7, 8; and so on.
Output
Print the rhyme scheme of the poem as "aabb", "abab", "abba", "aaaa"; or "NO" if the poem does not belong to any of the above mentioned schemes.
Examples
Input
1 1
day
may
sun
fun
Output
aabb
Input
1 1
day
may
gray
way
Output
aaaa
Input
2 1
a
a
a
a
a
a
e
e
Output
aabb
Input
2 1
day
may
sun
fun
test
hill
fest
thrill
Output
NO
Note
In the last sample both quatrains have rhymes but finding the common scheme is impossible, so the answer is "NO".
Submitted Solution:
```
n, k = map(int, input().split())
def get_suffix(line):
position = -1
for _ in range(k):
while -position <= len(line) and line[position] not in 'aeiou':
position -= 1
if -position > len(line):
return ''
return line[position:]
def detect_rhyme_type(quatrain):
s1, s2, s3, s4 = [get_suffix(line) for line in quatrain]
if s1 == s2 == s3 == s4:
return 'aaaa'
elif s1 == s2 and s3 == s4:
return 'aabb'
elif s1 == s3 and s2 == s4:
return 'abab'
elif s1 == s4 and s2 == s3:
return 'abba'
else:
return 'NO'
common_rhyme_type = 'aaaa'
for _ in range(n):
quatrain = [input() for _ in range(4)]
rhyme_type = detect_rhyme_type(quatrain)
if rhyme_type == 'NO':
print('NO')
break
if rhyme_type != common_rhyme_type and common_rhyme_type != 'aaaa':
print('NO')
break
else:
common_rhyme_type = rhyme_type
else:
print(common_rhyme_type)
```
|
instruction
| 0
| 5,228
| 6
| 10,456
|
No
|
output
| 1
| 5,228
| 6
| 10,457
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vera adores poems. All the poems Vera knows are divided into quatrains (groups of four lines) and in each quatrain some lines contain rhymes.
Let's consider that all lines in the poems consist of lowercase Latin letters (without spaces). Letters "a", "e", "i", "o", "u" are considered vowels.
Two lines rhyme if their suffixes that start from the k-th vowels (counting from the end) match. If a line has less than k vowels, then such line can't rhyme with any other line. For example, if k = 1, lines commit and hermit rhyme (the corresponding suffixes equal it), and if k = 2, they do not rhyme (ommit ≠ ermit).
Today on a literature lesson Vera learned that quatrains can contain four different schemes of rhymes, namely the following ones (the same letters stand for rhyming lines):
* Clerihew (aabb);
* Alternating (abab);
* Enclosed (abba).
If all lines of a quatrain pairwise rhyme, then the quatrain can belong to any rhyme scheme (this situation is represented by aaaa).
If all quatrains of a poem belong to the same rhyme scheme, then we can assume that the whole poem belongs to this rhyme scheme. If in each quatrain all lines pairwise rhyme, then the rhyme scheme of the poem is aaaa. Let us note that it doesn't matter whether lines from different quatrains rhyme with each other or not. In other words, it is possible that different quatrains aren't connected by a rhyme.
Vera got a long poem as a home task. The girl has to analyse it and find the poem rhyme scheme. Help Vera cope with the task.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2500, 1 ≤ k ≤ 5) — the number of quatrains in the poem and the vowel's number, correspondingly. Next 4n lines contain the poem. Each line is not empty and only consists of small Latin letters. The total length of the lines does not exceed 104.
If we assume that the lines are numbered starting from 1, then the first quatrain contains lines number 1, 2, 3, 4; the second one contains lines number 5, 6, 7, 8; and so on.
Output
Print the rhyme scheme of the poem as "aabb", "abab", "abba", "aaaa"; or "NO" if the poem does not belong to any of the above mentioned schemes.
Examples
Input
1 1
day
may
sun
fun
Output
aabb
Input
1 1
day
may
gray
way
Output
aaaa
Input
2 1
a
a
a
a
a
a
e
e
Output
aabb
Input
2 1
day
may
sun
fun
test
hill
fest
thrill
Output
NO
Note
In the last sample both quatrains have rhymes but finding the common scheme is impossible, so the answer is "NO".
Submitted Solution:
```
n,k = map(int,input().split())
lis=[]
vov=['a','e','i','o','u']
d={}
d['aabb']=d['abab']=d['abba']=d['aaaa']=0
for i in range(n*4):
s = input()
lis.append(s)
if i%4==3:
tmp=['']*4
for j in range(4):
s=lis[j]
c=0
cou=0
for ll in s[::-1]:
cou+=1
if ll in vov:
c+=1
if c==k:
tmp[j]=s[-cou:]
break
# print(tmp)
if tmp[0]==tmp[1]==tmp[2]==tmp[3] and tmp[0]!='':
d['aaaa']+=1
if tmp[0]==tmp[1] and tmp[2]==tmp[3] and tmp[1]!=tmp[3] and tmp[1]!='' and tmp[3]!='':
d['aabb']+=1
elif tmp[0]==tmp[2] and tmp[1]==tmp[3] and tmp[1]!=tmp[0] and tmp[1]!='' and tmp[0]!='':
d['abab']+=1
elif tmp[0]==tmp[3] and tmp[1]==tmp[2] and tmp[2]!=tmp[0] and tmp[1]!='' and tmp[3]!='':
d['abba']+=1
else:
print("NO")
exit()
lis=[]
c=0
for i in d:
if d[i]>0:
c+=1
if c==1:
for i in d:
if d[i]>0:
print(i)
exit()
elif c==2 and d['aaaa']>0:
for i in d:
if d[i]>0:
print(i)
exit()
else:
print("NO")
```
|
instruction
| 0
| 5,229
| 6
| 10,458
|
No
|
output
| 1
| 5,229
| 6
| 10,459
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vera adores poems. All the poems Vera knows are divided into quatrains (groups of four lines) and in each quatrain some lines contain rhymes.
Let's consider that all lines in the poems consist of lowercase Latin letters (without spaces). Letters "a", "e", "i", "o", "u" are considered vowels.
Two lines rhyme if their suffixes that start from the k-th vowels (counting from the end) match. If a line has less than k vowels, then such line can't rhyme with any other line. For example, if k = 1, lines commit and hermit rhyme (the corresponding suffixes equal it), and if k = 2, they do not rhyme (ommit ≠ ermit).
Today on a literature lesson Vera learned that quatrains can contain four different schemes of rhymes, namely the following ones (the same letters stand for rhyming lines):
* Clerihew (aabb);
* Alternating (abab);
* Enclosed (abba).
If all lines of a quatrain pairwise rhyme, then the quatrain can belong to any rhyme scheme (this situation is represented by aaaa).
If all quatrains of a poem belong to the same rhyme scheme, then we can assume that the whole poem belongs to this rhyme scheme. If in each quatrain all lines pairwise rhyme, then the rhyme scheme of the poem is aaaa. Let us note that it doesn't matter whether lines from different quatrains rhyme with each other or not. In other words, it is possible that different quatrains aren't connected by a rhyme.
Vera got a long poem as a home task. The girl has to analyse it and find the poem rhyme scheme. Help Vera cope with the task.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2500, 1 ≤ k ≤ 5) — the number of quatrains in the poem and the vowel's number, correspondingly. Next 4n lines contain the poem. Each line is not empty and only consists of small Latin letters. The total length of the lines does not exceed 104.
If we assume that the lines are numbered starting from 1, then the first quatrain contains lines number 1, 2, 3, 4; the second one contains lines number 5, 6, 7, 8; and so on.
Output
Print the rhyme scheme of the poem as "aabb", "abab", "abba", "aaaa"; or "NO" if the poem does not belong to any of the above mentioned schemes.
Examples
Input
1 1
day
may
sun
fun
Output
aabb
Input
1 1
day
may
gray
way
Output
aaaa
Input
2 1
a
a
a
a
a
a
e
e
Output
aabb
Input
2 1
day
may
sun
fun
test
hill
fest
thrill
Output
NO
Note
In the last sample both quatrains have rhymes but finding the common scheme is impossible, so the answer is "NO".
Submitted Solution:
```
n, p = map(int, input().split())
final = []
fe = 0
for i in range(0, 4*n, 4):
l = []
for j in range(4):
s = input()
temp = p
error = 0
for k in range(len(s)-1, -1, -1):
if(s[k] == 'a' or s[k] == 'e' or s[k] == 'i' or s[k] == 'o' or s[k] == 'u'):
temp -= 1
if(temp == 0):
l.append(s[k:])
break
if(len(l) == 4):
if(l[0] == l[1] and l[2] == l[3] and l[1] == l[2]):
final.append(1)
elif(l[0] == l[1] and l[2] == l[3]):
final.append(2)
elif(l[0] == l[2] and l[1] == l[3]):
final.append(3)
elif(l[0] == l[3] and l[2] == l[1]):
final.append(4)
else:
fe = 1
if(len(l) == n):
final = list(set(final))
# print(final)
if(len(final) == 1):
if(final[0] == 1):
print("aaaa")
elif(final[0] == 2):
print("aabb")
elif(final[0] == 3):
print("abab")
elif (final[0] == 4):
print("abba")
elif(len(final) == 2):
if(final[0] == 1 or final[1] == 1):
if(final[0] == 2):
print("aabb")
elif(final[0] == 3):
print("abab")
elif(final[0] == 4):
print("abba")
elif(final[1] == 2):
print("aabb")
elif(final[1] == 3):
print("abab")
elif(final[1] == 4):
print("abba")
else:
print("NO")
else:
print("NO")
else:
print("NO")
```
|
instruction
| 0
| 5,230
| 6
| 10,460
|
No
|
output
| 1
| 5,230
| 6
| 10,461
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vera adores poems. All the poems Vera knows are divided into quatrains (groups of four lines) and in each quatrain some lines contain rhymes.
Let's consider that all lines in the poems consist of lowercase Latin letters (without spaces). Letters "a", "e", "i", "o", "u" are considered vowels.
Two lines rhyme if their suffixes that start from the k-th vowels (counting from the end) match. If a line has less than k vowels, then such line can't rhyme with any other line. For example, if k = 1, lines commit and hermit rhyme (the corresponding suffixes equal it), and if k = 2, they do not rhyme (ommit ≠ ermit).
Today on a literature lesson Vera learned that quatrains can contain four different schemes of rhymes, namely the following ones (the same letters stand for rhyming lines):
* Clerihew (aabb);
* Alternating (abab);
* Enclosed (abba).
If all lines of a quatrain pairwise rhyme, then the quatrain can belong to any rhyme scheme (this situation is represented by aaaa).
If all quatrains of a poem belong to the same rhyme scheme, then we can assume that the whole poem belongs to this rhyme scheme. If in each quatrain all lines pairwise rhyme, then the rhyme scheme of the poem is aaaa. Let us note that it doesn't matter whether lines from different quatrains rhyme with each other or not. In other words, it is possible that different quatrains aren't connected by a rhyme.
Vera got a long poem as a home task. The girl has to analyse it and find the poem rhyme scheme. Help Vera cope with the task.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2500, 1 ≤ k ≤ 5) — the number of quatrains in the poem and the vowel's number, correspondingly. Next 4n lines contain the poem. Each line is not empty and only consists of small Latin letters. The total length of the lines does not exceed 104.
If we assume that the lines are numbered starting from 1, then the first quatrain contains lines number 1, 2, 3, 4; the second one contains lines number 5, 6, 7, 8; and so on.
Output
Print the rhyme scheme of the poem as "aabb", "abab", "abba", "aaaa"; or "NO" if the poem does not belong to any of the above mentioned schemes.
Examples
Input
1 1
day
may
sun
fun
Output
aabb
Input
1 1
day
may
gray
way
Output
aaaa
Input
2 1
a
a
a
a
a
a
e
e
Output
aabb
Input
2 1
day
may
sun
fun
test
hill
fest
thrill
Output
NO
Note
In the last sample both quatrains have rhymes but finding the common scheme is impossible, so the answer is "NO".
Submitted Solution:
```
n, k = map(int, input().split())
vowels = ['a', 'e', 'i', 'o', 'u']
def find_nth(tab, S, n):
amount, pos = (1 if tab[0] in S else 0), 0
while pos < len(tab) and amount < n:
pos += 1
if tab[pos] in S:
amount += 1
return pos
def rhyme_type(lines, k):
suffixes = []
for line in lines:
amount = 0
for i in line:
if i in vowels:
amount += 1
if amount < k:
return 'TRASH'
rev = list(reversed(list(line)))
ind_from_front = find_nth(rev, vowels, k)
suffixes.append(line[-ind_from_front - 1:])
print(suffixes)
if all([suffixes[0] == x for x in suffixes]):
return 'aaaa'
if suffixes[0] == suffixes[1] and suffixes[2] == suffixes[3]:
return 'aabb'
if suffixes[0] == suffixes[2] and suffixes[1] == suffixes[3]:
return 'abab'
if suffixes[0] == suffixes[3] and suffixes[1] == suffixes[2]:
return 'abba'
return 'TRASH'
all_rhymes = set()
for _ in range(n):
lines = [input(), input(), input(), input()]
all_rhymes.add(rhyme_type(lines, k))
if 'TRASH' not in all_rhymes and len(all_rhymes) == 2 and 'aaaa' in all_rhymes:
all_rhymes.remove('aaaa')
print(list(all_rhymes)[0])
elif len(all_rhymes) > 1 or 'TRASH' in all_rhymes:
print('NO')
else:
print(list(all_rhymes)[0])
```
|
instruction
| 0
| 5,231
| 6
| 10,462
|
No
|
output
| 1
| 5,231
| 6
| 10,463
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Piegirl is buying stickers for a project. Stickers come on sheets, and each sheet of stickers contains exactly n stickers. Each sticker has exactly one character printed on it, so a sheet of stickers can be described by a string of length n. Piegirl wants to create a string s using stickers. She may buy as many sheets of stickers as she wants, and may specify any string of length n for the sheets, but all the sheets must be identical, so the string is the same for all sheets. Once she attains the sheets of stickers, she will take some of the stickers from the sheets and arrange (in any order) them to form s. Determine the minimum number of sheets she has to buy, and provide a string describing a possible sheet of stickers she should buy.
Input
The first line contains string s (1 ≤ |s| ≤ 1000), consisting of lowercase English characters only. The second line contains an integer n (1 ≤ n ≤ 1000).
Output
On the first line, print the minimum number of sheets Piegirl has to buy. On the second line, print a string consisting of n lower case English characters. This string should describe a sheet of stickers that Piegirl can buy in order to minimize the number of sheets. If Piegirl cannot possibly form the string s, print instead a single line with the number -1.
Examples
Input
banana
4
Output
2
baan
Input
banana
3
Output
3
nab
Input
banana
2
Output
-1
Note
In the second example, Piegirl can order 3 sheets of stickers with the characters "nab". She can take characters "nab" from the first sheet, "na" from the second, and "a" from the third, and arrange them to from "banana".
|
instruction
| 0
| 5,339
| 6
| 10,678
|
Tags: binary search, constructive algorithms, greedy
Correct Solution:
```
s = input()
n = int(input())
d = {}
r = 0
for a in s:
d.setdefault(a, 0)
d[a] += 1
if(d[a] > r):
r = d[a]
if (len(d) > n):
print(-1)
else:
l = 0
while r - l > 1:
k = (l + r) // 2
cur = 0
for x in d.values():
cur += (x+k-1) // k
if cur > n:
l = k
else:
r = k
print(r)
s = ''
for a in d.keys():
s += a * ((d[a] + r - 1) // r)
l=len(s)
s += 'a' * (n-len(s))
print(s)
```
|
output
| 1
| 5,339
| 6
| 10,679
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Piegirl is buying stickers for a project. Stickers come on sheets, and each sheet of stickers contains exactly n stickers. Each sticker has exactly one character printed on it, so a sheet of stickers can be described by a string of length n. Piegirl wants to create a string s using stickers. She may buy as many sheets of stickers as she wants, and may specify any string of length n for the sheets, but all the sheets must be identical, so the string is the same for all sheets. Once she attains the sheets of stickers, she will take some of the stickers from the sheets and arrange (in any order) them to form s. Determine the minimum number of sheets she has to buy, and provide a string describing a possible sheet of stickers she should buy.
Input
The first line contains string s (1 ≤ |s| ≤ 1000), consisting of lowercase English characters only. The second line contains an integer n (1 ≤ n ≤ 1000).
Output
On the first line, print the minimum number of sheets Piegirl has to buy. On the second line, print a string consisting of n lower case English characters. This string should describe a sheet of stickers that Piegirl can buy in order to minimize the number of sheets. If Piegirl cannot possibly form the string s, print instead a single line with the number -1.
Examples
Input
banana
4
Output
2
baan
Input
banana
3
Output
3
nab
Input
banana
2
Output
-1
Note
In the second example, Piegirl can order 3 sheets of stickers with the characters "nab". She can take characters "nab" from the first sheet, "na" from the second, and "a" from the third, and arrange them to from "banana".
|
instruction
| 0
| 5,341
| 6
| 10,682
|
Tags: binary search, constructive algorithms, greedy
Correct Solution:
```
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")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
import math
s = input()
n = int(input())
d = {}
reserve = ''
unique = 0
max_occur = 1
all_letters = ''
for x in s:
if x in d:
d[x] += 1
if d[x] > max_occur:
max_occur = d[x]
else:
d[x] = 1
unique += 1
all_letters += x
if unique > n:
print(-1)
elif unique == n:
print(max_occur)
print(all_letters)
else:
l = 1
r = max_occur
ans = max_occur
check = 0
final_str = all_letters
check_str = ''
while l<=r:
mid = l + (r-l)//2
check = 0
check_str = ''
reserve = ''
for i in d.keys():
if d[i] > mid:
check += math.ceil(d[i]/mid)
check_str += i*math.ceil(d[i]/mid)
reserve += i*(d[i] - math.ceil(d[i]/mid))
else:
check += 1
check_str += i
reserve += i*(d[i]-1)
if check <= n:
final_str = '%s' % check_str
if len(final_str) < n:
final_str += reserve[:n-len(final_str)]
if len(final_str) < n:
final_str += 'a'*(n-len(final_str))
ans = mid
r = mid-1
else:
l = mid+1
print(ans)
print(final_str)
```
|
output
| 1
| 5,341
| 6
| 10,683
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Piegirl is buying stickers for a project. Stickers come on sheets, and each sheet of stickers contains exactly n stickers. Each sticker has exactly one character printed on it, so a sheet of stickers can be described by a string of length n. Piegirl wants to create a string s using stickers. She may buy as many sheets of stickers as she wants, and may specify any string of length n for the sheets, but all the sheets must be identical, so the string is the same for all sheets. Once she attains the sheets of stickers, she will take some of the stickers from the sheets and arrange (in any order) them to form s. Determine the minimum number of sheets she has to buy, and provide a string describing a possible sheet of stickers she should buy.
Input
The first line contains string s (1 ≤ |s| ≤ 1000), consisting of lowercase English characters only. The second line contains an integer n (1 ≤ n ≤ 1000).
Output
On the first line, print the minimum number of sheets Piegirl has to buy. On the second line, print a string consisting of n lower case English characters. This string should describe a sheet of stickers that Piegirl can buy in order to minimize the number of sheets. If Piegirl cannot possibly form the string s, print instead a single line with the number -1.
Examples
Input
banana
4
Output
2
baan
Input
banana
3
Output
3
nab
Input
banana
2
Output
-1
Note
In the second example, Piegirl can order 3 sheets of stickers with the characters "nab". She can take characters "nab" from the first sheet, "na" from the second, and "a" from the third, and arrange them to from "banana".
|
instruction
| 0
| 5,342
| 6
| 10,684
|
Tags: binary search, constructive algorithms, greedy
Correct Solution:
```
import math
from sys import stdin
from math import ceil
if __name__ == '__main__':
s = input()
n = int(input())
dictionary = {}
for i in s:
if i in dictionary:
dictionary[i] = dictionary[i] + 1
else:
dictionary[i] = 1
if len(dictionary) > n:
print(-1)
else:
if len(s) < n:
print(1)
newS = s
else:
lengthS = len(s) // n
newLength = len(s)
while lengthS < newLength:
mid = (lengthS + newLength) // 2
total = 0
for i in dictionary:
total = total + ceil(dictionary[i] / mid)
if total > n:
lengthS = mid + 1
else:
newLength = mid
print(lengthS)
newS = ''
for i in dictionary:
for j in range(ceil(dictionary[i] / lengthS)):
newS = newS + i
for i in range(n - len(newS)):
newS = newS + s[0]
print(newS)
```
|
output
| 1
| 5,342
| 6
| 10,685
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Piegirl is buying stickers for a project. Stickers come on sheets, and each sheet of stickers contains exactly n stickers. Each sticker has exactly one character printed on it, so a sheet of stickers can be described by a string of length n. Piegirl wants to create a string s using stickers. She may buy as many sheets of stickers as she wants, and may specify any string of length n for the sheets, but all the sheets must be identical, so the string is the same for all sheets. Once she attains the sheets of stickers, she will take some of the stickers from the sheets and arrange (in any order) them to form s. Determine the minimum number of sheets she has to buy, and provide a string describing a possible sheet of stickers she should buy.
Input
The first line contains string s (1 ≤ |s| ≤ 1000), consisting of lowercase English characters only. The second line contains an integer n (1 ≤ n ≤ 1000).
Output
On the first line, print the minimum number of sheets Piegirl has to buy. On the second line, print a string consisting of n lower case English characters. This string should describe a sheet of stickers that Piegirl can buy in order to minimize the number of sheets. If Piegirl cannot possibly form the string s, print instead a single line with the number -1.
Examples
Input
banana
4
Output
2
baan
Input
banana
3
Output
3
nab
Input
banana
2
Output
-1
Note
In the second example, Piegirl can order 3 sheets of stickers with the characters "nab". She can take characters "nab" from the first sheet, "na" from the second, and "a" from the third, and arrange them to from "banana".
|
instruction
| 0
| 5,343
| 6
| 10,686
|
Tags: binary search, constructive algorithms, greedy
Correct Solution:
```
from math import ceil
s = input ()
n = int (input ())
count = {}
for i in s:
if i in count:
count[i] += 1
else:
count[i] = 1
if len(count) > n:
print (-1)
else:
if len(s) < n:
print (1)
ret = s
else:
l,h = len (s)//n, len (s)
while (l < h):
m = (l+h) // 2
tot = 0
for i in count:
tot += ceil (count[i]/m)
if tot > n: l = m+1
else: h = m
print (l)
ret = ''
for i in count:
for j in range (ceil (count[i]/l)):
ret += i
for i in range (n-len(ret)):
ret += s[0]
print (ret)
```
|
output
| 1
| 5,343
| 6
| 10,687
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Piegirl is buying stickers for a project. Stickers come on sheets, and each sheet of stickers contains exactly n stickers. Each sticker has exactly one character printed on it, so a sheet of stickers can be described by a string of length n. Piegirl wants to create a string s using stickers. She may buy as many sheets of stickers as she wants, and may specify any string of length n for the sheets, but all the sheets must be identical, so the string is the same for all sheets. Once she attains the sheets of stickers, she will take some of the stickers from the sheets and arrange (in any order) them to form s. Determine the minimum number of sheets she has to buy, and provide a string describing a possible sheet of stickers she should buy.
Input
The first line contains string s (1 ≤ |s| ≤ 1000), consisting of lowercase English characters only. The second line contains an integer n (1 ≤ n ≤ 1000).
Output
On the first line, print the minimum number of sheets Piegirl has to buy. On the second line, print a string consisting of n lower case English characters. This string should describe a sheet of stickers that Piegirl can buy in order to minimize the number of sheets. If Piegirl cannot possibly form the string s, print instead a single line with the number -1.
Examples
Input
banana
4
Output
2
baan
Input
banana
3
Output
3
nab
Input
banana
2
Output
-1
Note
In the second example, Piegirl can order 3 sheets of stickers with the characters "nab". She can take characters "nab" from the first sheet, "na" from the second, and "a" from the third, and arrange them to from "banana".
|
instruction
| 0
| 5,344
| 6
| 10,688
|
Tags: binary search, constructive algorithms, greedy
Correct Solution:
```
s = input()
n = int(input())
symb_cnt = {}
for c in s:
symb_cnt[c] = symb_cnt[c] + 1 if c in symb_cnt else 1
for cnt in range(1, len(s) + 1):
s1 = ""
for c in symb_cnt:
s1 += c * ((symb_cnt[c] + cnt - 1) // cnt)
if len(s1) <= n:
for i in range(n - len(s1)):
s1 += 'a'
print(cnt)
print(s1)
exit(0)
print(-1)
```
|
output
| 1
| 5,344
| 6
| 10,689
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Piegirl is buying stickers for a project. Stickers come on sheets, and each sheet of stickers contains exactly n stickers. Each sticker has exactly one character printed on it, so a sheet of stickers can be described by a string of length n. Piegirl wants to create a string s using stickers. She may buy as many sheets of stickers as she wants, and may specify any string of length n for the sheets, but all the sheets must be identical, so the string is the same for all sheets. Once she attains the sheets of stickers, she will take some of the stickers from the sheets and arrange (in any order) them to form s. Determine the minimum number of sheets she has to buy, and provide a string describing a possible sheet of stickers she should buy.
Input
The first line contains string s (1 ≤ |s| ≤ 1000), consisting of lowercase English characters only. The second line contains an integer n (1 ≤ n ≤ 1000).
Output
On the first line, print the minimum number of sheets Piegirl has to buy. On the second line, print a string consisting of n lower case English characters. This string should describe a sheet of stickers that Piegirl can buy in order to minimize the number of sheets. If Piegirl cannot possibly form the string s, print instead a single line with the number -1.
Examples
Input
banana
4
Output
2
baan
Input
banana
3
Output
3
nab
Input
banana
2
Output
-1
Note
In the second example, Piegirl can order 3 sheets of stickers with the characters "nab". She can take characters "nab" from the first sheet, "na" from the second, and "a" from the third, and arrange them to from "banana".
|
instruction
| 0
| 5,345
| 6
| 10,690
|
Tags: binary search, constructive algorithms, greedy
Correct Solution:
```
from collections import Counter
def main():
s = input()
l = int(input())
d = Counter(s)
if len(d) > l:
print(-1)
return
lo = 0
hi = 10000
while lo + 1 < hi:
mid = (lo + hi) // 2
c = 0
for x in iter(d.values()):
c += (x + mid - 1) // mid
if c > l:
lo = mid
else:
hi = mid
print(hi)
ans = []
for x in iter(d.items()):
ans.append(x[0] * int(((x[1] + hi - 1) / hi)))
t = ''.join(ans)
if len(t) < l:
t += 'a' * (l - len(t))
print(t)
main()
```
|
output
| 1
| 5,345
| 6
| 10,691
|
Provide tags and a correct Python 3 solution for this coding contest problem.
First-rate specialists graduate from Berland State Institute of Peace and Friendship. You are one of the most talented students in this university. The education is not easy because you need to have fundamental knowledge in different areas, which sometimes are not related to each other.
For example, you should know linguistics very well. You learn a structure of Reberland language as foreign language. In this language words are constructed according to the following rules. First you need to choose the "root" of the word — some string which has more than 4 letters. Then several strings with the length 2 or 3 symbols are appended to this word. The only restriction — it is not allowed to append the same string twice in a row. All these strings are considered to be suffixes of the word (this time we use word "suffix" to describe a morpheme but not the few last characters of the string as you may used to).
Here is one exercise that you have found in your task list. You are given the word s. Find all distinct strings with the length 2 or 3, which can be suffixes of this word according to the word constructing rules in Reberland language.
Two strings are considered distinct if they have different length or there is a position in which corresponding characters do not match.
Let's look at the example: the word abacabaca is given. This word can be obtained in the following ways: <image>, where the root of the word is overlined, and suffixes are marked by "corners". Thus, the set of possible suffixes for this word is {aca, ba, ca}.
Input
The only line contains a string s (5 ≤ |s| ≤ 104) consisting of lowercase English letters.
Output
On the first line print integer k — a number of distinct possible suffixes. On the next k lines print suffixes.
Print suffixes in lexicographical (alphabetical) order.
Examples
Input
abacabaca
Output
3
aca
ba
ca
Input
abaca
Output
0
Note
The first test was analysed in the problem statement.
In the second example the length of the string equals 5. The length of the root equals 5, so no string can be used as a suffix.
|
instruction
| 0
| 5,462
| 6
| 10,924
|
Tags: dp, implementation, strings
Correct Solution:
```
s = input()
possible = [[],[],[False]*10100, [False]*10100]
length = len(s)
possible[2][length-2] = True
possible[3][length-3] = True
for i in range(length-1, 5-1,-1):
if length - 4 >= i:
possible[2][i] = (possible[2][i+2] and s[i:i+2] != s[i+2:i+4]) or possible[3][i+2]
if length - 5 >= i:
possible[3][i] = possible[2][i+3]
if length - 6 >= i:
possible[3][i] = (possible[3][i + 3] and s[i:i+3] != s[i+3:i+6]) or possible[3][i]
output = set()
for i in range(5,10000):
if possible[2][i]:
output.add(s[i:i + 2])
if possible[3][i]:
output.add(s[i:i + 3])
output_list = sorted(list(output))
print(len(output_list))
for o in output_list:
print(o)
```
|
output
| 1
| 5,462
| 6
| 10,925
|
Provide tags and a correct Python 3 solution for this coding contest problem.
First-rate specialists graduate from Berland State Institute of Peace and Friendship. You are one of the most talented students in this university. The education is not easy because you need to have fundamental knowledge in different areas, which sometimes are not related to each other.
For example, you should know linguistics very well. You learn a structure of Reberland language as foreign language. In this language words are constructed according to the following rules. First you need to choose the "root" of the word — some string which has more than 4 letters. Then several strings with the length 2 or 3 symbols are appended to this word. The only restriction — it is not allowed to append the same string twice in a row. All these strings are considered to be suffixes of the word (this time we use word "suffix" to describe a morpheme but not the few last characters of the string as you may used to).
Here is one exercise that you have found in your task list. You are given the word s. Find all distinct strings with the length 2 or 3, which can be suffixes of this word according to the word constructing rules in Reberland language.
Two strings are considered distinct if they have different length or there is a position in which corresponding characters do not match.
Let's look at the example: the word abacabaca is given. This word can be obtained in the following ways: <image>, where the root of the word is overlined, and suffixes are marked by "corners". Thus, the set of possible suffixes for this word is {aca, ba, ca}.
Input
The only line contains a string s (5 ≤ |s| ≤ 104) consisting of lowercase English letters.
Output
On the first line print integer k — a number of distinct possible suffixes. On the next k lines print suffixes.
Print suffixes in lexicographical (alphabetical) order.
Examples
Input
abacabaca
Output
3
aca
ba
ca
Input
abaca
Output
0
Note
The first test was analysed in the problem statement.
In the second example the length of the string equals 5. The length of the root equals 5, so no string can be used as a suffix.
|
instruction
| 0
| 5,463
| 6
| 10,926
|
Tags: dp, implementation, strings
Correct Solution:
```
import sys
value = input()
if (len(value) < 7):
print(0)
sys.exit(0)
res = set()
possible = {}
possible[len(value)] = set([2])
if (len(value) > 7):
possible[len(value)].add(3)
possibleLen = [2, 3]
for i in reversed(range(7, len(value) + 1)):
possibleVal = possible.get(i, set())
for length in possibleVal:
nextI = i - length
val = value[nextI:i]
res.add(val)
for posLen in possibleLen:
if (nextI >= 5 + posLen and value[nextI - posLen:nextI] != val):
setNextI = possible.setdefault(nextI, set())
setNextI.add(posLen)
print(len(res))
for val in sorted(res):
print(val)
```
|
output
| 1
| 5,463
| 6
| 10,927
|
Provide tags and a correct Python 3 solution for this coding contest problem.
First-rate specialists graduate from Berland State Institute of Peace and Friendship. You are one of the most talented students in this university. The education is not easy because you need to have fundamental knowledge in different areas, which sometimes are not related to each other.
For example, you should know linguistics very well. You learn a structure of Reberland language as foreign language. In this language words are constructed according to the following rules. First you need to choose the "root" of the word — some string which has more than 4 letters. Then several strings with the length 2 or 3 symbols are appended to this word. The only restriction — it is not allowed to append the same string twice in a row. All these strings are considered to be suffixes of the word (this time we use word "suffix" to describe a morpheme but not the few last characters of the string as you may used to).
Here is one exercise that you have found in your task list. You are given the word s. Find all distinct strings with the length 2 or 3, which can be suffixes of this word according to the word constructing rules in Reberland language.
Two strings are considered distinct if they have different length or there is a position in which corresponding characters do not match.
Let's look at the example: the word abacabaca is given. This word can be obtained in the following ways: <image>, where the root of the word is overlined, and suffixes are marked by "corners". Thus, the set of possible suffixes for this word is {aca, ba, ca}.
Input
The only line contains a string s (5 ≤ |s| ≤ 104) consisting of lowercase English letters.
Output
On the first line print integer k — a number of distinct possible suffixes. On the next k lines print suffixes.
Print suffixes in lexicographical (alphabetical) order.
Examples
Input
abacabaca
Output
3
aca
ba
ca
Input
abaca
Output
0
Note
The first test was analysed in the problem statement.
In the second example the length of the string equals 5. The length of the root equals 5, so no string can be used as a suffix.
|
instruction
| 0
| 5,464
| 6
| 10,928
|
Tags: dp, implementation, strings
Correct Solution:
```
from sys import *
setrecursionlimit(20000)
dp = []
ans = []
def fun(s, pos, r, ln):
if pos <= 4+ln:
return 0
if dp[pos][ln-2] != 0:
return dp[pos][ln-2]
if s[pos-ln:pos] != r:
dp[pos][ln-2] = 1 + fun(s, pos - ln, s[pos-ln:pos],2) + fun(s, pos - ln, s[pos-ln:pos],3)
ans.append(s[pos-ln:pos])
''' if pos > 4+ln and s[pos-3:pos] != r:
dp[pos][1] = 1 + fun(s, pos - 3, s[pos-3:pos])
ans.append(s[pos-3:pos])'''
return dp[pos][ln-2]
s = input()
dp = [[0, 0] for i in range(len(s) + 1)]
fun(s, len(s), '', 2)
fun(s, len(s), '', 3)
ans = list(set(ans))
ans.sort()
print (len(ans))
for i in ans:
print (i)
```
|
output
| 1
| 5,464
| 6
| 10,929
|
Provide tags and a correct Python 3 solution for this coding contest problem.
First-rate specialists graduate from Berland State Institute of Peace and Friendship. You are one of the most talented students in this university. The education is not easy because you need to have fundamental knowledge in different areas, which sometimes are not related to each other.
For example, you should know linguistics very well. You learn a structure of Reberland language as foreign language. In this language words are constructed according to the following rules. First you need to choose the "root" of the word — some string which has more than 4 letters. Then several strings with the length 2 or 3 symbols are appended to this word. The only restriction — it is not allowed to append the same string twice in a row. All these strings are considered to be suffixes of the word (this time we use word "suffix" to describe a morpheme but not the few last characters of the string as you may used to).
Here is one exercise that you have found in your task list. You are given the word s. Find all distinct strings with the length 2 or 3, which can be suffixes of this word according to the word constructing rules in Reberland language.
Two strings are considered distinct if they have different length or there is a position in which corresponding characters do not match.
Let's look at the example: the word abacabaca is given. This word can be obtained in the following ways: <image>, where the root of the word is overlined, and suffixes are marked by "corners". Thus, the set of possible suffixes for this word is {aca, ba, ca}.
Input
The only line contains a string s (5 ≤ |s| ≤ 104) consisting of lowercase English letters.
Output
On the first line print integer k — a number of distinct possible suffixes. On the next k lines print suffixes.
Print suffixes in lexicographical (alphabetical) order.
Examples
Input
abacabaca
Output
3
aca
ba
ca
Input
abaca
Output
0
Note
The first test was analysed in the problem statement.
In the second example the length of the string equals 5. The length of the root equals 5, so no string can be used as a suffix.
|
instruction
| 0
| 5,465
| 6
| 10,930
|
Tags: dp, implementation, strings
Correct Solution:
```
s = input()
n = len(s)
s += '0000000000'
dp = [[0] * 2 for i in range(n + 5)]
dp[n] = [1, 1]
res = set()
for i in range(n - 1, 4, -1):
if i + 2 <= n and ((dp[i + 2][0] and s[i: i + 2] != s[i + 2: i + 4]) or dp[i + 2][1]):
res.add(s[i: i + 2])
dp[i][0] = 1
if i + 3 <= n and ((dp[i + 3][1] and s[i: i + 3] != s[i + 3: i + 6]) or dp[i + 3][0]):
res.add(s[i: i + 3])
dp[i][1] = 1
print(len(res))
for ss in sorted(res):
print(ss)
```
|
output
| 1
| 5,465
| 6
| 10,931
|
Provide tags and a correct Python 3 solution for this coding contest problem.
First-rate specialists graduate from Berland State Institute of Peace and Friendship. You are one of the most talented students in this university. The education is not easy because you need to have fundamental knowledge in different areas, which sometimes are not related to each other.
For example, you should know linguistics very well. You learn a structure of Reberland language as foreign language. In this language words are constructed according to the following rules. First you need to choose the "root" of the word — some string which has more than 4 letters. Then several strings with the length 2 or 3 symbols are appended to this word. The only restriction — it is not allowed to append the same string twice in a row. All these strings are considered to be suffixes of the word (this time we use word "suffix" to describe a morpheme but not the few last characters of the string as you may used to).
Here is one exercise that you have found in your task list. You are given the word s. Find all distinct strings with the length 2 or 3, which can be suffixes of this word according to the word constructing rules in Reberland language.
Two strings are considered distinct if they have different length or there is a position in which corresponding characters do not match.
Let's look at the example: the word abacabaca is given. This word can be obtained in the following ways: <image>, where the root of the word is overlined, and suffixes are marked by "corners". Thus, the set of possible suffixes for this word is {aca, ba, ca}.
Input
The only line contains a string s (5 ≤ |s| ≤ 104) consisting of lowercase English letters.
Output
On the first line print integer k — a number of distinct possible suffixes. On the next k lines print suffixes.
Print suffixes in lexicographical (alphabetical) order.
Examples
Input
abacabaca
Output
3
aca
ba
ca
Input
abaca
Output
0
Note
The first test was analysed in the problem statement.
In the second example the length of the string equals 5. The length of the root equals 5, so no string can be used as a suffix.
|
instruction
| 0
| 5,466
| 6
| 10,932
|
Tags: dp, implementation, strings
Correct Solution:
```
__author__ = 'Utena'
s=input()
n=len(s)
ans=set()
if n<=6:
print(0)
exit(0)
dp=[[False,False]for i in range(n+1)]
if n>7:
dp[3][1]=True
ans.add(s[-3:])
dp[2][0]=True
ans.add(s[-2:])
for i in range(4,n-4):
if s[(-i):(-i+2)]!=s[(-i+2):(-i+3)]+s[-i+3]and dp[i-2][0] or dp[i-2][1]:
dp[i][0]=True
ans|={s[(-i):(-i+2)]}
if i>=6 and s[(-i):(-i+3)]!=s[(-i+3):(-i+5)]+s[-i+5]and dp[i-3][1] or dp[i-3][0]:
dp[i][1]=True
ans.add(s[(-i):(-i+3)])
ans=sorted(list(ans))
print(len(ans))
print('\n'.join(ans))
```
|
output
| 1
| 5,466
| 6
| 10,933
|
Provide tags and a correct Python 3 solution for this coding contest problem.
First-rate specialists graduate from Berland State Institute of Peace and Friendship. You are one of the most talented students in this university. The education is not easy because you need to have fundamental knowledge in different areas, which sometimes are not related to each other.
For example, you should know linguistics very well. You learn a structure of Reberland language as foreign language. In this language words are constructed according to the following rules. First you need to choose the "root" of the word — some string which has more than 4 letters. Then several strings with the length 2 or 3 symbols are appended to this word. The only restriction — it is not allowed to append the same string twice in a row. All these strings are considered to be suffixes of the word (this time we use word "suffix" to describe a morpheme but not the few last characters of the string as you may used to).
Here is one exercise that you have found in your task list. You are given the word s. Find all distinct strings with the length 2 or 3, which can be suffixes of this word according to the word constructing rules in Reberland language.
Two strings are considered distinct if they have different length or there is a position in which corresponding characters do not match.
Let's look at the example: the word abacabaca is given. This word can be obtained in the following ways: <image>, where the root of the word is overlined, and suffixes are marked by "corners". Thus, the set of possible suffixes for this word is {aca, ba, ca}.
Input
The only line contains a string s (5 ≤ |s| ≤ 104) consisting of lowercase English letters.
Output
On the first line print integer k — a number of distinct possible suffixes. On the next k lines print suffixes.
Print suffixes in lexicographical (alphabetical) order.
Examples
Input
abacabaca
Output
3
aca
ba
ca
Input
abaca
Output
0
Note
The first test was analysed in the problem statement.
In the second example the length of the string equals 5. The length of the root equals 5, so no string can be used as a suffix.
|
instruction
| 0
| 5,467
| 6
| 10,934
|
Tags: dp, implementation, strings
Correct Solution:
```
def main():
s = input()[5:]
n = len(s)
if n < 2:
print(0)
return
res2, res3 = set(), set()
dp2 = [False] * (n + 1)
dp3 = [False] * (n + 1)
dp2[-1] = dp3[-1] = True
for i in range(n, 1, -1):
if dp3[i] or dp2[i] and s[i - 2:i] != s[i:i + 2]:
res2.add(s[i - 2:i])
dp2[i - 2] = True
if dp2[i] or dp3[i] and s[i - 3:i] != s[i:i + 3]:
res3.add(s[i - 3:i])
dp3[i - 3] = True
res3.discard(s[i - 3:i])
res3.update(res2)
print(len(res3))
for s in sorted(res3):
print(s)
if __name__ == '__main__':
main()
```
|
output
| 1
| 5,467
| 6
| 10,935
|
Provide tags and a correct Python 3 solution for this coding contest problem.
First-rate specialists graduate from Berland State Institute of Peace and Friendship. You are one of the most talented students in this university. The education is not easy because you need to have fundamental knowledge in different areas, which sometimes are not related to each other.
For example, you should know linguistics very well. You learn a structure of Reberland language as foreign language. In this language words are constructed according to the following rules. First you need to choose the "root" of the word — some string which has more than 4 letters. Then several strings with the length 2 or 3 symbols are appended to this word. The only restriction — it is not allowed to append the same string twice in a row. All these strings are considered to be suffixes of the word (this time we use word "suffix" to describe a morpheme but not the few last characters of the string as you may used to).
Here is one exercise that you have found in your task list. You are given the word s. Find all distinct strings with the length 2 or 3, which can be suffixes of this word according to the word constructing rules in Reberland language.
Two strings are considered distinct if they have different length or there is a position in which corresponding characters do not match.
Let's look at the example: the word abacabaca is given. This word can be obtained in the following ways: <image>, where the root of the word is overlined, and suffixes are marked by "corners". Thus, the set of possible suffixes for this word is {aca, ba, ca}.
Input
The only line contains a string s (5 ≤ |s| ≤ 104) consisting of lowercase English letters.
Output
On the first line print integer k — a number of distinct possible suffixes. On the next k lines print suffixes.
Print suffixes in lexicographical (alphabetical) order.
Examples
Input
abacabaca
Output
3
aca
ba
ca
Input
abaca
Output
0
Note
The first test was analysed in the problem statement.
In the second example the length of the string equals 5. The length of the root equals 5, so no string can be used as a suffix.
|
instruction
| 0
| 5,468
| 6
| 10,936
|
Tags: dp, implementation, strings
Correct Solution:
```
def getPossibleSuffixes(s):
if len(s) == 5:
print(0)
return
possible_suffixes = s[5:len(s)]
suffixes = []
helper_hash = {}
suffix_starts = [0 for x in range(len(possible_suffixes))]
prev_2 = ["" for x in range(len(possible_suffixes))]
suffix_starts[-1] = 1
for i in range(len(possible_suffixes)-2, -1, -1):
if suffix_starts[i+1] and prev_2[i+1] != possible_suffixes[i:i+2]:
if not helper_hash.get(possible_suffixes[i:i+2]):
suffixes.append(possible_suffixes[i:i+2])
helper_hash[possible_suffixes[i:i+2]] = True
if i-1>=0:
prev_2[i-1] = possible_suffixes[i:i+2]
suffix_starts[i-1] = 1
if i+2 < len(possible_suffixes) and suffix_starts[i+2] and prev_2[i+2] != possible_suffixes[i:i+3]:
if not helper_hash.get(possible_suffixes[i:i+3]):
suffixes.append(possible_suffixes[i:i+3])
helper_hash[possible_suffixes[i:i+3]] = True
if i-1>=0:
if prev_2[i-1] != "":
prev_2[i-1] = ""
else:
prev_2[i-1] = possible_suffixes[i:i+3]
suffix_starts[i-1] = 1
print(len(suffixes))
suffixes.sort()
for suffix in suffixes:
print(suffix)
s = input()
getPossibleSuffixes(s)
```
|
output
| 1
| 5,468
| 6
| 10,937
|
Provide tags and a correct Python 3 solution for this coding contest problem.
First-rate specialists graduate from Berland State Institute of Peace and Friendship. You are one of the most talented students in this university. The education is not easy because you need to have fundamental knowledge in different areas, which sometimes are not related to each other.
For example, you should know linguistics very well. You learn a structure of Reberland language as foreign language. In this language words are constructed according to the following rules. First you need to choose the "root" of the word — some string which has more than 4 letters. Then several strings with the length 2 or 3 symbols are appended to this word. The only restriction — it is not allowed to append the same string twice in a row. All these strings are considered to be suffixes of the word (this time we use word "suffix" to describe a morpheme but not the few last characters of the string as you may used to).
Here is one exercise that you have found in your task list. You are given the word s. Find all distinct strings with the length 2 or 3, which can be suffixes of this word according to the word constructing rules in Reberland language.
Two strings are considered distinct if they have different length or there is a position in which corresponding characters do not match.
Let's look at the example: the word abacabaca is given. This word can be obtained in the following ways: <image>, where the root of the word is overlined, and suffixes are marked by "corners". Thus, the set of possible suffixes for this word is {aca, ba, ca}.
Input
The only line contains a string s (5 ≤ |s| ≤ 104) consisting of lowercase English letters.
Output
On the first line print integer k — a number of distinct possible suffixes. On the next k lines print suffixes.
Print suffixes in lexicographical (alphabetical) order.
Examples
Input
abacabaca
Output
3
aca
ba
ca
Input
abaca
Output
0
Note
The first test was analysed in the problem statement.
In the second example the length of the string equals 5. The length of the root equals 5, so no string can be used as a suffix.
|
instruction
| 0
| 5,469
| 6
| 10,938
|
Tags: dp, implementation, strings
Correct Solution:
```
string = input()
s = set()
finded = {}
import sys
sys.setrecursionlimit(900000000)
def get_substr(string, start, parent):
# базовый случай
if start >= len(string):
return
if start+1 < len(string):
substr = string[start:start+2]
# проверим не та же ли это строка
if substr != parent:
s.add(substr)
if (start+2, 2) not in finded:
get_substr(string, start+2, substr)
finded[(start+2, 2)] = True
if start+2 < len(string):
substr = string[start:start+3]
# проверим не та же ли это строка
if substr != parent:
s.add(substr)
if (start+3, 3) not in finded:
get_substr(string, start+3, substr)
finded[(start+3, 3)] = True
get_substr(string[5:][::-1], 0, "")
print(len(s))
ans = []
for i in s:
ans.append(i[::-1])
for a in sorted(ans):
print(a)
```
|
output
| 1
| 5,469
| 6
| 10,939
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
First-rate specialists graduate from Berland State Institute of Peace and Friendship. You are one of the most talented students in this university. The education is not easy because you need to have fundamental knowledge in different areas, which sometimes are not related to each other.
For example, you should know linguistics very well. You learn a structure of Reberland language as foreign language. In this language words are constructed according to the following rules. First you need to choose the "root" of the word — some string which has more than 4 letters. Then several strings with the length 2 or 3 symbols are appended to this word. The only restriction — it is not allowed to append the same string twice in a row. All these strings are considered to be suffixes of the word (this time we use word "suffix" to describe a morpheme but not the few last characters of the string as you may used to).
Here is one exercise that you have found in your task list. You are given the word s. Find all distinct strings with the length 2 or 3, which can be suffixes of this word according to the word constructing rules in Reberland language.
Two strings are considered distinct if they have different length or there is a position in which corresponding characters do not match.
Let's look at the example: the word abacabaca is given. This word can be obtained in the following ways: <image>, where the root of the word is overlined, and suffixes are marked by "corners". Thus, the set of possible suffixes for this word is {aca, ba, ca}.
Input
The only line contains a string s (5 ≤ |s| ≤ 104) consisting of lowercase English letters.
Output
On the first line print integer k — a number of distinct possible suffixes. On the next k lines print suffixes.
Print suffixes in lexicographical (alphabetical) order.
Examples
Input
abacabaca
Output
3
aca
ba
ca
Input
abaca
Output
0
Note
The first test was analysed in the problem statement.
In the second example the length of the string equals 5. The length of the root equals 5, so no string can be used as a suffix.
Submitted Solution:
```
from sys import *
setrecursionlimit(200000)
d = {}
t = set()
s = input() + ' '
def gen(l, ll):
if (l, ll) in t: return
t.add((l, ll))
if l > 6:
d[s[l - 2 : l]] = 1
if s[l - 2 : l] != s[l : ll]: gen(l - 2, l)
if l > 7:
d[s[l - 3 : l]] = 1
if s[l - 3 : l] != s[l : ll]: gen(l - 3, l)
gen(len(s) - 1,len(s))
print(len(d))
for k in sorted(d): print(k)
```
|
instruction
| 0
| 5,470
| 6
| 10,940
|
Yes
|
output
| 1
| 5,470
| 6
| 10,941
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
First-rate specialists graduate from Berland State Institute of Peace and Friendship. You are one of the most talented students in this university. The education is not easy because you need to have fundamental knowledge in different areas, which sometimes are not related to each other.
For example, you should know linguistics very well. You learn a structure of Reberland language as foreign language. In this language words are constructed according to the following rules. First you need to choose the "root" of the word — some string which has more than 4 letters. Then several strings with the length 2 or 3 symbols are appended to this word. The only restriction — it is not allowed to append the same string twice in a row. All these strings are considered to be suffixes of the word (this time we use word "suffix" to describe a morpheme but not the few last characters of the string as you may used to).
Here is one exercise that you have found in your task list. You are given the word s. Find all distinct strings with the length 2 or 3, which can be suffixes of this word according to the word constructing rules in Reberland language.
Two strings are considered distinct if they have different length or there is a position in which corresponding characters do not match.
Let's look at the example: the word abacabaca is given. This word can be obtained in the following ways: <image>, where the root of the word is overlined, and suffixes are marked by "corners". Thus, the set of possible suffixes for this word is {aca, ba, ca}.
Input
The only line contains a string s (5 ≤ |s| ≤ 104) consisting of lowercase English letters.
Output
On the first line print integer k — a number of distinct possible suffixes. On the next k lines print suffixes.
Print suffixes in lexicographical (alphabetical) order.
Examples
Input
abacabaca
Output
3
aca
ba
ca
Input
abaca
Output
0
Note
The first test was analysed in the problem statement.
In the second example the length of the string equals 5. The length of the root equals 5, so no string can be used as a suffix.
Submitted Solution:
```
import sys
input = sys.stdin.readline
s = input().strip()
n = len(s)
poss = [[False] * 2 for _ in range(n)]
poss[n - 2][0] = poss[n - 3][1] = True
for i in range(n - 4, -1, -1):
poss[i][0] = s[i: i + 2] != s[i + 2: i + 4] and poss[i + 2][0] or poss[i + 2][1]
poss[i][1] = s[i: i + 3] != s[i + 3: i + 6] and poss[i + 3][1] or poss[i + 3][0]
ans = set()
for i in range(5, n):
if poss[i][0]:
ans.add(s[i: i + 2])
if poss[i][1]:
ans.add(s[i:i + 3])
print(len(ans))
for x in sorted(ans):
print(x)
```
|
instruction
| 0
| 5,471
| 6
| 10,942
|
Yes
|
output
| 1
| 5,471
| 6
| 10,943
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
First-rate specialists graduate from Berland State Institute of Peace and Friendship. You are one of the most talented students in this university. The education is not easy because you need to have fundamental knowledge in different areas, which sometimes are not related to each other.
For example, you should know linguistics very well. You learn a structure of Reberland language as foreign language. In this language words are constructed according to the following rules. First you need to choose the "root" of the word — some string which has more than 4 letters. Then several strings with the length 2 or 3 symbols are appended to this word. The only restriction — it is not allowed to append the same string twice in a row. All these strings are considered to be suffixes of the word (this time we use word "suffix" to describe a morpheme but not the few last characters of the string as you may used to).
Here is one exercise that you have found in your task list. You are given the word s. Find all distinct strings with the length 2 or 3, which can be suffixes of this word according to the word constructing rules in Reberland language.
Two strings are considered distinct if they have different length or there is a position in which corresponding characters do not match.
Let's look at the example: the word abacabaca is given. This word can be obtained in the following ways: <image>, where the root of the word is overlined, and suffixes are marked by "corners". Thus, the set of possible suffixes for this word is {aca, ba, ca}.
Input
The only line contains a string s (5 ≤ |s| ≤ 104) consisting of lowercase English letters.
Output
On the first line print integer k — a number of distinct possible suffixes. On the next k lines print suffixes.
Print suffixes in lexicographical (alphabetical) order.
Examples
Input
abacabaca
Output
3
aca
ba
ca
Input
abaca
Output
0
Note
The first test was analysed in the problem statement.
In the second example the length of the string equals 5. The length of the root equals 5, so no string can be used as a suffix.
Submitted Solution:
```
t = input()
s, d = set(), set()
p = {(len(t), 2)}
while p:
m, x = p.pop()
r = m + x
for y in [x, 5 - x]:
l = m - y
q = (l, y)
if q in d or l < 5 or t[l:m] == t[m:r]: continue
s.add(t[l:m])
d.add(q)
p.add(q)
print(len(s))
print('\n'.join(sorted(s)))
# Made By Mostafa_Khaled
```
|
instruction
| 0
| 5,472
| 6
| 10,944
|
Yes
|
output
| 1
| 5,472
| 6
| 10,945
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
First-rate specialists graduate from Berland State Institute of Peace and Friendship. You are one of the most talented students in this university. The education is not easy because you need to have fundamental knowledge in different areas, which sometimes are not related to each other.
For example, you should know linguistics very well. You learn a structure of Reberland language as foreign language. In this language words are constructed according to the following rules. First you need to choose the "root" of the word — some string which has more than 4 letters. Then several strings with the length 2 or 3 symbols are appended to this word. The only restriction — it is not allowed to append the same string twice in a row. All these strings are considered to be suffixes of the word (this time we use word "suffix" to describe a morpheme but not the few last characters of the string as you may used to).
Here is one exercise that you have found in your task list. You are given the word s. Find all distinct strings with the length 2 or 3, which can be suffixes of this word according to the word constructing rules in Reberland language.
Two strings are considered distinct if they have different length or there is a position in which corresponding characters do not match.
Let's look at the example: the word abacabaca is given. This word can be obtained in the following ways: <image>, where the root of the word is overlined, and suffixes are marked by "corners". Thus, the set of possible suffixes for this word is {aca, ba, ca}.
Input
The only line contains a string s (5 ≤ |s| ≤ 104) consisting of lowercase English letters.
Output
On the first line print integer k — a number of distinct possible suffixes. On the next k lines print suffixes.
Print suffixes in lexicographical (alphabetical) order.
Examples
Input
abacabaca
Output
3
aca
ba
ca
Input
abaca
Output
0
Note
The first test was analysed in the problem statement.
In the second example the length of the string equals 5. The length of the root equals 5, so no string can be used as a suffix.
Submitted Solution:
```
s = input()
n = len(s)
dp2,dp3=[0 for i in range(n)],[0 for i in range(n)]
if(n<7): print(0)
else:
if n-2>4: dp2[n-2]=1
if n-3>4: dp3[n-3]=1;
i=n-4
while i>=5:
dp2[i]=(dp3[i+2] | (dp2[i+2] & (s[i:i+2]!=s[i+2:i+4]) ) )
dp3[i]=dp2[i+3] | (dp3[i+3] & (s[i:i+3]!=s[i+3:i+6]) )
i=i-1
a=set()
for i in range(n):
if dp2[i]:a.add(s[i:i+2])
if dp3[i]:a.add(s[i:i+3])
a=sorted(list(a))
print(len(a))
for i in a:
print(i)
```
|
instruction
| 0
| 5,473
| 6
| 10,946
|
Yes
|
output
| 1
| 5,473
| 6
| 10,947
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
First-rate specialists graduate from Berland State Institute of Peace and Friendship. You are one of the most talented students in this university. The education is not easy because you need to have fundamental knowledge in different areas, which sometimes are not related to each other.
For example, you should know linguistics very well. You learn a structure of Reberland language as foreign language. In this language words are constructed according to the following rules. First you need to choose the "root" of the word — some string which has more than 4 letters. Then several strings with the length 2 or 3 symbols are appended to this word. The only restriction — it is not allowed to append the same string twice in a row. All these strings are considered to be suffixes of the word (this time we use word "suffix" to describe a morpheme but not the few last characters of the string as you may used to).
Here is one exercise that you have found in your task list. You are given the word s. Find all distinct strings with the length 2 or 3, which can be suffixes of this word according to the word constructing rules in Reberland language.
Two strings are considered distinct if they have different length or there is a position in which corresponding characters do not match.
Let's look at the example: the word abacabaca is given. This word can be obtained in the following ways: <image>, where the root of the word is overlined, and suffixes are marked by "corners". Thus, the set of possible suffixes for this word is {aca, ba, ca}.
Input
The only line contains a string s (5 ≤ |s| ≤ 104) consisting of lowercase English letters.
Output
On the first line print integer k — a number of distinct possible suffixes. On the next k lines print suffixes.
Print suffixes in lexicographical (alphabetical) order.
Examples
Input
abacabaca
Output
3
aca
ba
ca
Input
abaca
Output
0
Note
The first test was analysed in the problem statement.
In the second example the length of the string equals 5. The length of the root equals 5, so no string can be used as a suffix.
Submitted Solution:
```
s = input()
if len(s) <= 5:
print(0)
else:
words = set()
s = s[5:]
r = len(s)
for j in range(r, 1, -1):
if j == r - 1:
continue
if j == 2:
words.add(s[0:2])
continue
words.add(s[j - 2:j])
words.add(s[j - 3:j])
print(len(words))
for word in sorted(words):
print(word)
```
|
instruction
| 0
| 5,474
| 6
| 10,948
|
No
|
output
| 1
| 5,474
| 6
| 10,949
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
First-rate specialists graduate from Berland State Institute of Peace and Friendship. You are one of the most talented students in this university. The education is not easy because you need to have fundamental knowledge in different areas, which sometimes are not related to each other.
For example, you should know linguistics very well. You learn a structure of Reberland language as foreign language. In this language words are constructed according to the following rules. First you need to choose the "root" of the word — some string which has more than 4 letters. Then several strings with the length 2 or 3 symbols are appended to this word. The only restriction — it is not allowed to append the same string twice in a row. All these strings are considered to be suffixes of the word (this time we use word "suffix" to describe a morpheme but not the few last characters of the string as you may used to).
Here is one exercise that you have found in your task list. You are given the word s. Find all distinct strings with the length 2 or 3, which can be suffixes of this word according to the word constructing rules in Reberland language.
Two strings are considered distinct if they have different length or there is a position in which corresponding characters do not match.
Let's look at the example: the word abacabaca is given. This word can be obtained in the following ways: <image>, where the root of the word is overlined, and suffixes are marked by "corners". Thus, the set of possible suffixes for this word is {aca, ba, ca}.
Input
The only line contains a string s (5 ≤ |s| ≤ 104) consisting of lowercase English letters.
Output
On the first line print integer k — a number of distinct possible suffixes. On the next k lines print suffixes.
Print suffixes in lexicographical (alphabetical) order.
Examples
Input
abacabaca
Output
3
aca
ba
ca
Input
abaca
Output
0
Note
The first test was analysed in the problem statement.
In the second example the length of the string equals 5. The length of the root equals 5, so no string can be used as a suffix.
Submitted Solution:
```
for _ in range(1):
st=input()
n=len(st)
if n<=6:
print(0)
continue
i=5
d=set()
for i in range(5,n-1):
if i==n-4:
d.add(str(st[i])+str(st[i+1]))
elif i==n-3:
d.add(str(st[i])+str(st[i+1])+str(st[i+2]))
else:
if i<=n-2:
d.add(str(st[i])+str(st[i+1]))
if i<=n-3:
d.add(str(st[i]) + str(st[i + 1]) + str(st[i + 2]))
arr=[]
for i in d:
arr.append(i)
arr.sort()
print(len(arr))
for i in arr:
print(i)
```
|
instruction
| 0
| 5,475
| 6
| 10,950
|
No
|
output
| 1
| 5,475
| 6
| 10,951
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
First-rate specialists graduate from Berland State Institute of Peace and Friendship. You are one of the most talented students in this university. The education is not easy because you need to have fundamental knowledge in different areas, which sometimes are not related to each other.
For example, you should know linguistics very well. You learn a structure of Reberland language as foreign language. In this language words are constructed according to the following rules. First you need to choose the "root" of the word — some string which has more than 4 letters. Then several strings with the length 2 or 3 symbols are appended to this word. The only restriction — it is not allowed to append the same string twice in a row. All these strings are considered to be suffixes of the word (this time we use word "suffix" to describe a morpheme but not the few last characters of the string as you may used to).
Here is one exercise that you have found in your task list. You are given the word s. Find all distinct strings with the length 2 or 3, which can be suffixes of this word according to the word constructing rules in Reberland language.
Two strings are considered distinct if they have different length or there is a position in which corresponding characters do not match.
Let's look at the example: the word abacabaca is given. This word can be obtained in the following ways: <image>, where the root of the word is overlined, and suffixes are marked by "corners". Thus, the set of possible suffixes for this word is {aca, ba, ca}.
Input
The only line contains a string s (5 ≤ |s| ≤ 104) consisting of lowercase English letters.
Output
On the first line print integer k — a number of distinct possible suffixes. On the next k lines print suffixes.
Print suffixes in lexicographical (alphabetical) order.
Examples
Input
abacabaca
Output
3
aca
ba
ca
Input
abaca
Output
0
Note
The first test was analysed in the problem statement.
In the second example the length of the string equals 5. The length of the root equals 5, so no string can be used as a suffix.
Submitted Solution:
```
def getPossibleSuffixes(s):
if len(s) == 5:
print(0)
return
possible_suffixes = s[5:len(s)]
suffixes = []
suffix_starts = [0 for x in range(len(possible_suffixes))]
prev_2 = ["" for x in range(len(possible_suffixes))]
prev_3 = ["" for x in range(len(possible_suffixes))]
suffix_starts[-1] = 1
for i in range(len(possible_suffixes)-2, -1, -1):
if suffix_starts[i+1] and prev_2[i+1] != possible_suffixes[i:i+2]:
if possible_suffixes[i:i+2] not in suffixes:
suffixes.append(possible_suffixes[i:i+2])
if i-1>=0:
prev_2[i-1] = possible_suffixes[i:i+2]
suffix_starts[i-1] = 1
if i+2 < len(possible_suffixes) and suffix_starts[i+2] and prev_3[i+2] != possible_suffixes[i:i+3]:
if possible_suffixes[i:i+3] not in suffixes:
suffixes.append(possible_suffixes[i:i+3])
if i-1>=0:
prev_3[i-1] = possible_suffixes[i:i+3]
suffix_starts[i-1] = 1
print(len(suffixes))
suffixes.sort()
for suffix in suffixes:
print(suffix)
s = input()
getPossibleSuffixes(s)
```
|
instruction
| 0
| 5,476
| 6
| 10,952
|
No
|
output
| 1
| 5,476
| 6
| 10,953
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
First-rate specialists graduate from Berland State Institute of Peace and Friendship. You are one of the most talented students in this university. The education is not easy because you need to have fundamental knowledge in different areas, which sometimes are not related to each other.
For example, you should know linguistics very well. You learn a structure of Reberland language as foreign language. In this language words are constructed according to the following rules. First you need to choose the "root" of the word — some string which has more than 4 letters. Then several strings with the length 2 or 3 symbols are appended to this word. The only restriction — it is not allowed to append the same string twice in a row. All these strings are considered to be suffixes of the word (this time we use word "suffix" to describe a morpheme but not the few last characters of the string as you may used to).
Here is one exercise that you have found in your task list. You are given the word s. Find all distinct strings with the length 2 or 3, which can be suffixes of this word according to the word constructing rules in Reberland language.
Two strings are considered distinct if they have different length or there is a position in which corresponding characters do not match.
Let's look at the example: the word abacabaca is given. This word can be obtained in the following ways: <image>, where the root of the word is overlined, and suffixes are marked by "corners". Thus, the set of possible suffixes for this word is {aca, ba, ca}.
Input
The only line contains a string s (5 ≤ |s| ≤ 104) consisting of lowercase English letters.
Output
On the first line print integer k — a number of distinct possible suffixes. On the next k lines print suffixes.
Print suffixes in lexicographical (alphabetical) order.
Examples
Input
abacabaca
Output
3
aca
ba
ca
Input
abaca
Output
0
Note
The first test was analysed in the problem statement.
In the second example the length of the string equals 5. The length of the root equals 5, so no string can be used as a suffix.
Submitted Solution:
```
__author__ = 'Utena'
s=input()
n=len(s)
ans=set()
if n<=6:
print(0)
exit(0)
dp=[[False,False]for i in range(n+1)]
if n>6:dp[3][1]=True
dp[2][0]=True
ans.add(s[-2:])
ans.add(s[-3:])
for i in range(4,n-4):
if s[(-i):(-i+2)]!=s[(-i+2):(-i+4)]and dp[i-2][0] or dp[i-2][1]:
dp[i][0]=True
ans|={s[(-i):(-i+2)]}
if i>=6 and s[(-i):(-i+3)]!=s[(-i+3):(-i+6)]and dp[i-3][1] or dp[i-3][0]:
dp[i][1]=True
ans.add(s[(-i):(-i+3)])
ans=sorted(list(ans))
print(len(ans))
print('\n'.join(ans))
```
|
instruction
| 0
| 5,477
| 6
| 10,954
|
No
|
output
| 1
| 5,477
| 6
| 10,955
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Thanks to your help, Heidi is confident that no one can fool her. She has now decided to post some fake news on the HC2 Facebook page. However, she wants to be able to communicate to the HC2 committee that the post is fake, using some secret phrase hidden in the post as a subsequence. To make this method foolproof, she wants the phrase to appear n times in the post. She is asking you to design a post (string) s and a hidden phrase p such that p appears in s as a subsequence exactly n times.
Input
The first and only line of input contains a single integer n (1 ≤ n ≤ 1 000 000).
Output
The output should contain two nonempty strings s and p separated by a single space. Each string should be composed of letters (a-z and A-Z: both lowercase and uppercase are allowed) and have length at most 200. The number of occurrences of p in s as a subsequence should be exactly n. If there are many possible solutions, output any of them. It is guaranteed that at least one solution exists.
Examples
Input
2
Output
hHheidi Hei
Input
4
Output
bbbba ba
Input
6
Output
aaabb ab
Note
An occurrence of p as a subsequence in s should be thought of as a set of positions in s such that the letters at these positions, in order, form p. The number of occurences is thus the number of such sets. For example, ab appears 6 times as a subsequence in aaabb, for the following sets of positions: {1, 4}, {1, 5}, {2, 4}, {2, 5}, {3, 4}, {3, 5} (that is, we should choose one of the a's and one of the b's).
|
instruction
| 0
| 5,531
| 6
| 11,062
|
Tags: constructive algorithms, strings
Correct Solution:
```
def rek(k):
if k == 1:
return ('a', 'a')
elif k == 2:
return ('aa', 'a')
s, p = rek((k - 1) // 2)
x = chr(ord(p[-1]) + 1)
return (p + x * (2 - k % 2) + s[len(p):] + 2 * x, p + x)
s, p = rek(int(input()))
print(s, p)
```
|
output
| 1
| 5,531
| 6
| 11,063
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Thanks to your help, Heidi is confident that no one can fool her. She has now decided to post some fake news on the HC2 Facebook page. However, she wants to be able to communicate to the HC2 committee that the post is fake, using some secret phrase hidden in the post as a subsequence. To make this method foolproof, she wants the phrase to appear n times in the post. She is asking you to design a post (string) s and a hidden phrase p such that p appears in s as a subsequence exactly n times.
Input
The first and only line of input contains a single integer n (1 ≤ n ≤ 1 000 000).
Output
The output should contain two nonempty strings s and p separated by a single space. Each string should be composed of letters (a-z and A-Z: both lowercase and uppercase are allowed) and have length at most 200. The number of occurrences of p in s as a subsequence should be exactly n. If there are many possible solutions, output any of them. It is guaranteed that at least one solution exists.
Examples
Input
2
Output
hHheidi Hei
Input
4
Output
bbbba ba
Input
6
Output
aaabb ab
Note
An occurrence of p as a subsequence in s should be thought of as a set of positions in s such that the letters at these positions, in order, form p. The number of occurences is thus the number of such sets. For example, ab appears 6 times as a subsequence in aaabb, for the following sets of positions: {1, 4}, {1, 5}, {2, 4}, {2, 5}, {3, 4}, {3, 5} (that is, we should choose one of the a's and one of the b's).
|
instruction
| 0
| 5,532
| 6
| 11,064
|
Tags: constructive algorithms, strings
Correct Solution:
```
def getstr(n):
if n==1:
return 'a','',1
elif n==2:
return 'ab','b',2
else:
if n%2==0:
p,u,now=getstr((n-2)//2)
c = chr(ord('a')+now)
return p+c,c+u+c+c,now+1
else:
p,u,now=getstr((n-1)//2)
c = chr(ord('a')+now)
return p+c,u+c+c,now+1
n = int(input())
ans = getstr(n)
print(ans[0]+ans[1],ans[0])
```
|
output
| 1
| 5,532
| 6
| 11,065
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Thanks to your help, Heidi is confident that no one can fool her. She has now decided to post some fake news on the HC2 Facebook page. However, she wants to be able to communicate to the HC2 committee that the post is fake, using some secret phrase hidden in the post as a subsequence. To make this method foolproof, she wants the phrase to appear n times in the post. She is asking you to design a post (string) s and a hidden phrase p such that p appears in s as a subsequence exactly n times.
Input
The first and only line of input contains a single integer n (1 ≤ n ≤ 1 000 000).
Output
The output should contain two nonempty strings s and p separated by a single space. Each string should be composed of letters (a-z and A-Z: both lowercase and uppercase are allowed) and have length at most 200. The number of occurrences of p in s as a subsequence should be exactly n. If there are many possible solutions, output any of them. It is guaranteed that at least one solution exists.
Examples
Input
2
Output
hHheidi Hei
Input
4
Output
bbbba ba
Input
6
Output
aaabb ab
Note
An occurrence of p as a subsequence in s should be thought of as a set of positions in s such that the letters at these positions, in order, form p. The number of occurences is thus the number of such sets. For example, ab appears 6 times as a subsequence in aaabb, for the following sets of positions: {1, 4}, {1, 5}, {2, 4}, {2, 5}, {3, 4}, {3, 5} (that is, we should choose one of the a's and one of the b's).
|
instruction
| 0
| 5,533
| 6
| 11,066
|
Tags: constructive algorithms, strings
Correct Solution:
```
def solve(k):
if k == 1:
return ('a', 'a')
if k == 2:
return ('aa', 'a')
s, p = solve((k-1) // 2)
x = chr(ord(p[-1])+1)
return (p+x*(2-k%2)+s[len(p):]+x*2, p+x)
s, p = solve(int(input()))
print(s, p)
```
|
output
| 1
| 5,533
| 6
| 11,067
|
Provide tags and a correct Python 3 solution for this coding contest problem.
Thanks to your help, Heidi is confident that no one can fool her. She has now decided to post some fake news on the HC2 Facebook page. However, she wants to be able to communicate to the HC2 committee that the post is fake, using some secret phrase hidden in the post as a subsequence. To make this method foolproof, she wants the phrase to appear n times in the post. She is asking you to design a post (string) s and a hidden phrase p such that p appears in s as a subsequence exactly n times.
Input
The first and only line of input contains a single integer n (1 ≤ n ≤ 1 000 000).
Output
The output should contain two nonempty strings s and p separated by a single space. Each string should be composed of letters (a-z and A-Z: both lowercase and uppercase are allowed) and have length at most 200. The number of occurrences of p in s as a subsequence should be exactly n. If there are many possible solutions, output any of them. It is guaranteed that at least one solution exists.
Examples
Input
2
Output
hHheidi Hei
Input
4
Output
bbbba ba
Input
6
Output
aaabb ab
Note
An occurrence of p as a subsequence in s should be thought of as a set of positions in s such that the letters at these positions, in order, form p. The number of occurences is thus the number of such sets. For example, ab appears 6 times as a subsequence in aaabb, for the following sets of positions: {1, 4}, {1, 5}, {2, 4}, {2, 5}, {3, 4}, {3, 5} (that is, we should choose one of the a's and one of the b's).
|
instruction
| 0
| 5,534
| 6
| 11,068
|
Tags: constructive algorithms, strings
Correct Solution:
```
import string
alphabet = list(string.ascii_lowercase + string.ascii_uppercase)
def calc(n):
if n == 1:
return '', 'a'
if n == 2:
return 'a', 'a'
if n % 2 == 1:
u, p = calc(n//2)
x = alphabet.pop()
return u+x+x, p+x
else:
u, p = calc(n//2-1)
x = alphabet.pop()
return x+u+x+x, p+x
n = int(input())
u, p = calc(n)
print(p+u+' '+p)
```
|
output
| 1
| 5,534
| 6
| 11,069
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a list of n strings a1, a2, ..., an. You'd like to concatenate them together in some order such that the resulting string would be lexicographically smallest.
Given the list of strings, output the lexicographically smallest concatenation.
Input
The first line contains integer n — the number of strings (1 ≤ n ≤ 5·104).
Each of the next n lines contains one string ai (1 ≤ |ai| ≤ 50) consisting of only lowercase English letters. The sum of string lengths will not exceed 5·104.
Output
Print the only string a — the lexicographically smallest string concatenation.
Examples
Input
4
abba
abacaba
bcd
er
Output
abacabaabbabcder
Input
5
x
xx
xxa
xxaa
xxaaa
Output
xxaaaxxaaxxaxxx
Input
3
c
cb
cba
Output
cbacbc
|
instruction
| 0
| 6,237
| 6
| 12,474
|
Tags: sortings, strings
Correct Solution:
```
n = int(input())
def comp(a, b):
l = a + b
r = b + a
if l < r: return -1
elif l == r: return 0
else: return 1
from functools import cmp_to_key
d = []
for _ in range(n):
s = input().rstrip()
d.append(s)
d.sort(key=cmp_to_key(comp))
print(''.join(d))
```
|
output
| 1
| 6,237
| 6
| 12,475
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a list of n strings a1, a2, ..., an. You'd like to concatenate them together in some order such that the resulting string would be lexicographically smallest.
Given the list of strings, output the lexicographically smallest concatenation.
Input
The first line contains integer n — the number of strings (1 ≤ n ≤ 5·104).
Each of the next n lines contains one string ai (1 ≤ |ai| ≤ 50) consisting of only lowercase English letters. The sum of string lengths will not exceed 5·104.
Output
Print the only string a — the lexicographically smallest string concatenation.
Examples
Input
4
abba
abacaba
bcd
er
Output
abacabaabbabcder
Input
5
x
xx
xxa
xxaa
xxaaa
Output
xxaaaxxaaxxaxxx
Input
3
c
cb
cba
Output
cbacbc
|
instruction
| 0
| 6,238
| 6
| 12,476
|
Tags: sortings, strings
Correct Solution:
```
#### IMPORTANT LIBRARY ####
############################
### DO NOT USE import random --> 250ms to load the library
############################
### In case of extra libraries: https://github.com/cheran-senthil/PyRival
######################
####### IMPORT #######
######################
from functools import cmp_to_key
from collections import deque, Counter
from heapq import heappush, heappop
from math import log, ceil
######################
#### STANDARD I/O ####
######################
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")
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)
def print(*args, **kwargs):
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()
def inp():
return sys.stdin.readline().rstrip("\r\n") # for fast input
def ii():
return int(inp())
def si():
return str(inp())
def li(lag = 0):
l = list(map(int, inp().split()))
if lag != 0:
for i in range(len(l)):
l[i] += lag
return l
def mi(lag = 0):
matrix = list()
for i in range(n):
matrix.append(li(lag))
return matrix
def lsi(): #string list
return list(map(str, inp().split()))
def print_list(lista, space = " "):
print(space.join(map(str, lista)))
######################
### BISECT METHODS ###
######################
def bisect_left(a, x):
"""i tale che a[i] >= x e a[i-1] < x"""
left = 0
right = len(a)
while left < right:
mid = (left+right)//2
if a[mid] < x:
left = mid+1
else:
right = mid
return left
def bisect_right(a, x):
"""i tale che a[i] > x e a[i-1] <= x"""
left = 0
right = len(a)
while left < right:
mid = (left+right)//2
if a[mid] > x:
right = mid
else:
left = mid+1
return left
def bisect_elements(a, x):
"""elementi pari a x nell'árray sortato"""
return bisect_right(a, x) - bisect_left(a, x)
######################
### MOD OPERATION ####
######################
MOD = 10**9 + 7
maxN = 5
FACT = [0] * maxN
INV_FACT = [0] * maxN
def add(x, y):
return (x+y) % MOD
def multiply(x, y):
return (x*y) % MOD
def power(x, y):
if y == 0:
return 1
elif y % 2:
return multiply(x, power(x, y-1))
else:
a = power(x, y//2)
return multiply(a, a)
def inverse(x):
return power(x, MOD-2)
def divide(x, y):
return multiply(x, inverse(y))
def allFactorials():
FACT[0] = 1
for i in range(1, maxN):
FACT[i] = multiply(i, FACT[i-1])
def inverseFactorials():
n = len(INV_FACT)
INV_FACT[n-1] = inverse(FACT[n-1])
for i in range(n-2, -1, -1):
INV_FACT[i] = multiply(INV_FACT[i+1], i+1)
def coeffBinom(n, k):
if n < k:
return 0
return multiply(FACT[n], multiply(INV_FACT[k], INV_FACT[n-k]))
######################
#### GRAPH ALGOS #####
######################
# ZERO BASED GRAPH
def create_graph(n, m, undirected = 1, unweighted = 1):
graph = [[] for i in range(n)]
if unweighted:
for i in range(m):
[x, y] = li(lag = -1)
graph[x].append(y)
if undirected:
graph[y].append(x)
else:
for i in range(m):
[x, y, w] = li(lag = -1)
w += 1
graph[x].append([y,w])
if undirected:
graph[y].append([x,w])
return graph
def create_tree(n, unweighted = 1):
children = [[] for i in range(n)]
if unweighted:
for i in range(n-1):
[x, y] = li(lag = -1)
children[x].append(y)
children[y].append(x)
else:
for i in range(n-1):
[x, y, w] = li(lag = -1)
w += 1
children[x].append([y, w])
children[y].append([x, w])
return children
def dist(tree, n, A, B = -1):
s = [[A, 0]]
massimo, massimo_nodo = 0, 0
distanza = -1
v = [-1] * n
while s:
el, dis = s.pop()
if dis > massimo:
massimo = dis
massimo_nodo = el
if el == B:
distanza = dis
for child in tree[el]:
if v[child] == -1:
v[child] = 1
s.append([child, dis+1])
return massimo, massimo_nodo, distanza
def diameter(tree):
_, foglia, _ = dist(tree, n, 0)
diam, _, _ = dist(tree, n, foglia)
return diam
def dfs(graph, n, A):
v = [-1] * n
s = [[A, 0]]
v[A] = 0
while s:
el, dis = s.pop()
for child in graph[el]:
if v[child] == -1:
v[child] = dis + 1
s.append([child, dis + 1])
return v #visited: -1 if not visited, otherwise v[B] is the distance in terms of edges
def bfs(graph, n, A):
v = [-1] * n
s = deque()
s.append([A, 0])
v[A] = 0
while s:
el, dis = s.popleft()
for child in graph[el]:
if v[child] == -1:
v[child] = dis + 1
s.append([child, dis + 1])
return v #visited: -1 if not visited, otherwise v[B] is the distance in terms of edges
#FROM A GIVEN ROOT, RECOVER THE STRUCTURE
def parents_children_root_unrooted_tree(tree, n, root = 0):
q = deque()
visited = [0] * n
parent = [-1] * n
children = [[] for i in range(n)]
q.append(root)
while q:
all_done = 1
visited[q[0]] = 1
for child in tree[q[0]]:
if not visited[child]:
all_done = 0
q.appendleft(child)
if all_done:
for child in tree[q[0]]:
if parent[child] == -1:
parent[q[0]] = child
children[child].append(q[0])
q.popleft()
return parent, children
# CALCULATING LONGEST PATH FOR ALL THE NODES
def all_longest_path_passing_from_node(parent, children, n):
q = deque()
visited = [len(children[i]) for i in range(n)]
downwards = [[0,0] for i in range(n)]
upward = [1] * n
longest_path = [1] * n
for i in range(n):
if not visited[i]:
q.append(i)
downwards[i] = [1,0]
while q:
node = q.popleft()
if parent[node] != -1:
visited[parent[node]] -= 1
if not visited[parent[node]]:
q.append(parent[node])
else:
root = node
for child in children[node]:
downwards[node] = sorted([downwards[node][0], downwards[node][1], downwards[child][0] + 1], reverse = True)[0:2]
s = [node]
while s:
node = s.pop()
if parent[node] != -1:
if downwards[parent[node]][0] == downwards[node][0] + 1:
upward[node] = 1 + max(upward[parent[node]], downwards[parent[node]][1])
else:
upward[node] = 1 + max(upward[parent[node]], downwards[parent[node]][0])
longest_path[node] = downwards[node][0] + downwards[node][1] + upward[node] - min([downwards[node][0], downwards[node][1], upward[node]]) - 1
for child in children[node]:
s.append(child)
return longest_path
### TBD SUCCESSOR GRAPH 7.5
### TBD TREE QUERIES 10.2 da 2 a 4
### TBD ADVANCED TREE 10.3
### TBD GRAPHS AND MATRICES 11.3.3 e 11.4.3 e 11.5.3 (ON GAMES)
######################
## END OF LIBRARIES ##
######################
n = ii()
lista = []
for i in range(n):
lista.append(si())
def custom_sort(lista):
def cmp(x,y):
if x+y>y+x:
return 1
else:
return -1
return sorted(lista, key = cmp_to_key(cmp))
lista = custom_sort(lista)
print_list(lista, "")
```
|
output
| 1
| 6,238
| 6
| 12,477
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a list of n strings a1, a2, ..., an. You'd like to concatenate them together in some order such that the resulting string would be lexicographically smallest.
Given the list of strings, output the lexicographically smallest concatenation.
Input
The first line contains integer n — the number of strings (1 ≤ n ≤ 5·104).
Each of the next n lines contains one string ai (1 ≤ |ai| ≤ 50) consisting of only lowercase English letters. The sum of string lengths will not exceed 5·104.
Output
Print the only string a — the lexicographically smallest string concatenation.
Examples
Input
4
abba
abacaba
bcd
er
Output
abacabaabbabcder
Input
5
x
xx
xxa
xxaa
xxaaa
Output
xxaaaxxaaxxaxxx
Input
3
c
cb
cba
Output
cbacbc
|
instruction
| 0
| 6,239
| 6
| 12,478
|
Tags: sortings, strings
Correct Solution:
```
from functools import cmp_to_key
def cmp(a,b):
return -1 if a+b < b+a else 0
def main():
n = int(input())
l = [input() for i in range(n)]
l = sorted(l,key=cmp_to_key(cmp))
for i in l:
print(i,end="")
if __name__ == "__main__":
main()
```
|
output
| 1
| 6,239
| 6
| 12,479
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a list of n strings a1, a2, ..., an. You'd like to concatenate them together in some order such that the resulting string would be lexicographically smallest.
Given the list of strings, output the lexicographically smallest concatenation.
Input
The first line contains integer n — the number of strings (1 ≤ n ≤ 5·104).
Each of the next n lines contains one string ai (1 ≤ |ai| ≤ 50) consisting of only lowercase English letters. The sum of string lengths will not exceed 5·104.
Output
Print the only string a — the lexicographically smallest string concatenation.
Examples
Input
4
abba
abacaba
bcd
er
Output
abacabaabbabcder
Input
5
x
xx
xxa
xxaa
xxaaa
Output
xxaaaxxaaxxaxxx
Input
3
c
cb
cba
Output
cbacbc
|
instruction
| 0
| 6,241
| 6
| 12,482
|
Tags: sortings, strings
Correct Solution:
```
from functools import cmp_to_key
n = int(input())
l = []
for i in range(n):
l.append(input())
l.sort(key = cmp_to_key(lambda x,y : 1 if x+y > y+x else -1))
print(''.join(l))
```
|
output
| 1
| 6,241
| 6
| 12,483
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a list of n strings a1, a2, ..., an. You'd like to concatenate them together in some order such that the resulting string would be lexicographically smallest.
Given the list of strings, output the lexicographically smallest concatenation.
Input
The first line contains integer n — the number of strings (1 ≤ n ≤ 5·104).
Each of the next n lines contains one string ai (1 ≤ |ai| ≤ 50) consisting of only lowercase English letters. The sum of string lengths will not exceed 5·104.
Output
Print the only string a — the lexicographically smallest string concatenation.
Examples
Input
4
abba
abacaba
bcd
er
Output
abacabaabbabcder
Input
5
x
xx
xxa
xxaa
xxaaa
Output
xxaaaxxaaxxaxxx
Input
3
c
cb
cba
Output
cbacbc
|
instruction
| 0
| 6,242
| 6
| 12,484
|
Tags: sortings, strings
Correct Solution:
```
# List = [[10,1],[20,2],[10,3]] --> Initial
# List = [[10, 1], [10, 3], [20, 2]] --> Normal Sort
# List = [[10, 3], [10, 1], [20, 2]] --> Sort with custom key [ascending, descending]
from functools import cmp_to_key
def custom(x,y):
a = x +y
b = y+ x
if(a < b):
return -1
elif(b < a):
return 1
else:
return 0
n = int(input())
arr = []
for i in range(n):
s = input()
arr.append(s)
# arr.sort(key = cmp)
arr.sort(key = cmp_to_key(custom))
# print(arr)
ans = ""
for i in arr:
ans += i
print(ans)
```
|
output
| 1
| 6,242
| 6
| 12,485
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a list of n strings a1, a2, ..., an. You'd like to concatenate them together in some order such that the resulting string would be lexicographically smallest.
Given the list of strings, output the lexicographically smallest concatenation.
Input
The first line contains integer n — the number of strings (1 ≤ n ≤ 5·104).
Each of the next n lines contains one string ai (1 ≤ |ai| ≤ 50) consisting of only lowercase English letters. The sum of string lengths will not exceed 5·104.
Output
Print the only string a — the lexicographically smallest string concatenation.
Examples
Input
4
abba
abacaba
bcd
er
Output
abacabaabbabcder
Input
5
x
xx
xxa
xxaa
xxaaa
Output
xxaaaxxaaxxaxxx
Input
3
c
cb
cba
Output
cbacbc
|
instruction
| 0
| 6,243
| 6
| 12,486
|
Tags: sortings, strings
Correct Solution:
```
from bisect import insort,bisect_right,bisect_left
from sys import stdout, stdin, setrecursionlimit
from heapq import heappush, heappop, heapify
from io import BytesIO, IOBase
from collections import *
from itertools import *
from random import *
from string import *
from queue import *
from math import *
from re import *
from os import *
# sqrt,ceil,floor,factorial,gcd,log2,log10,comb
####################################---fast-input-output----#########################################
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 = read(self._fd, max(fstat(self._fd).st_size, 8192))
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 = read(self._fd, max(fstat(self._fd).st_size, 8192))
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:
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")
stdin, stdout = IOWrapper(stdin), IOWrapper(stdout)
graph, mod, szzz = {}, 10**9 + 7, lambda: sorted(zzz())
def getStr(): return input()
def getInt(): return int(input())
def listStr(): return list(input())
def getStrs(): return input().split()
def isInt(s): return '0' <= s[0] <= '9'
def input(): return stdin.readline().strip()
def zzz(): return [int(i) for i in input().split()]
def output(answer, end='\n'): stdout.write(str(answer) + end)
def lcd(xnum1, xnum2): return (xnum1 * xnum2 // gcd(xnum1, xnum2))
def getPrimes(N = 10**5):
SN = int(sqrt(N))
sieve = [i for i in range(N+1)]
sieve[1] = 0
for i in sieve:
if i > SN:
break
if i == 0:
continue
for j in range(2*i, N+1, i):
sieve[j] = 0
prime = [i for i in range(N+1) if sieve[i] != 0]
return prime
def primeFactor(n,prime=getPrimes()):
lst = []
mx=int(sqrt(n))+1
for i in prime:
if i>mx:break
while n%i==0:
lst.append(i)
n//=i
if n>1:
lst.append(n)
return lst
dx = [-1, 1, 0, 0, 1, -1, 1, -1]
dy = [0, 0, 1, -1, 1, -1, -1, 1]
daysInMounth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
#################################################---Some Rule For Me To Follow---#################################
"""
--instants of Reading problem continuously try to understand them.
--Try & again try, maybe you're just one statement away!
"""
##################################################---START-CODING---###############################################
num = getInt()
lst=[]
for _ in range(num):
lst.append(getStr())
def mergeSort(s):
if len(s)==1:
return s
s1 = mergeSort(s[:len(s)//2])
s2 = mergeSort(s[len(s)//2:])
return merge(s1,s2)
def merge(s1,s2):
lst=[]
ind1 = 0
ind2 = 0
while ind1!=len(s1) and ind2 != len(s2):
if s1[ind1]+s2[ind2]>s2[ind2]+s1[ind1]:
lst.append(s2[ind2])
ind2+=1
else:
lst.append(s1[ind1])
ind1+=1
if ind1 != len(s1):
lst+=s1[ind1:]
else:
lst+=s2[ind2:]
return lst
print(''.join(i for i in mergeSort(lst)))
```
|
output
| 1
| 6,243
| 6
| 12,487
|
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given a list of n strings a1, a2, ..., an. You'd like to concatenate them together in some order such that the resulting string would be lexicographically smallest.
Given the list of strings, output the lexicographically smallest concatenation.
Input
The first line contains integer n — the number of strings (1 ≤ n ≤ 5·104).
Each of the next n lines contains one string ai (1 ≤ |ai| ≤ 50) consisting of only lowercase English letters. The sum of string lengths will not exceed 5·104.
Output
Print the only string a — the lexicographically smallest string concatenation.
Examples
Input
4
abba
abacaba
bcd
er
Output
abacabaabbabcder
Input
5
x
xx
xxa
xxaa
xxaaa
Output
xxaaaxxaaxxaxxx
Input
3
c
cb
cba
Output
cbacbc
|
instruction
| 0
| 6,244
| 6
| 12,488
|
Tags: sortings, strings
Correct Solution:
```
def cmp_to_key(mycmp):
'Convert a cmp= function into a key= function'
class K:
def __init__(self, obj, *args):
self.obj = obj
def __lt__(self, other):
return mycmp(self.obj, other.obj) < 0
def __gt__(self, other):
return mycmp(self.obj, other.obj) > 0
def __eq__(self, other):
return mycmp(self.obj, other.obj) == 0
def __le__(self, other):
return mycmp(self.obj, other.obj) <= 0
def __ge__(self, other):
return mycmp(self.obj, other.obj) >= 0
def __ne__(self, other):
return mycmp(self.obj, other.obj) != 0
return K
n = int(input())
ls = [input() for _ in range(n)]
def compare_str(x, y):
if x + y < y + x:
return -1
elif x + y > y + x:
return 1
else:
return 0
ls.sort(key=cmp_to_key(compare_str))
print("".join(ls))
```
|
output
| 1
| 6,244
| 6
| 12,489
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.