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 |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasiliy is fond of solving different tasks. Today he found one he wasn't able to solve himself, so he asks you to help.
Vasiliy is given n strings consisting of lowercase English letters. He wants them to be sorted in lexicographical order (as in the dictionary), but he is not allowed to swap any of them. The only operation he is allowed to do is to reverse any of them (first character becomes last, second becomes one before last and so on).
To reverse the i-th string Vasiliy has to spent ci units of energy. He is interested in the minimum amount of energy he has to spent in order to have strings sorted in lexicographical order.
String A is lexicographically smaller than string B if it is shorter than B (|A| < |B|) and is its prefix, or if none of them is a prefix of the other and at the first position where they differ character in A is smaller than the character in B.
For the purpose of this problem, two equal strings nearby do not break the condition of sequence being sorted lexicographically.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of strings.
The second line contains n integers ci (0 ≤ ci ≤ 109), the i-th of them is equal to the amount of energy Vasiliy has to spent in order to reverse the i-th string.
Then follow n lines, each containing a string consisting of lowercase English letters. The total length of these strings doesn't exceed 100 000.
Output
If it is impossible to reverse some of the strings such that they will be located in lexicographical order, print - 1. Otherwise, print the minimum total amount of energy Vasiliy has to spent.
Examples
Input
2
1 2
ba
ac
Output
1
Input
3
1 3 1
aa
ba
ac
Output
1
Input
2
5 5
bbb
aaa
Output
-1
Input
2
3 3
aaa
aa
Output
-1
Note
In the second sample one has to reverse string 2 or string 3. To amount of energy required to reverse the string 3 is smaller.
In the third sample, both strings do not change after reverse and they go in the wrong order, so the answer is - 1.
In the fourth sample, both strings consists of characters 'a' only, but in the sorted order string "aa" should go before string "aaa", thus the answer is - 1.
Submitted Solution:
```
n = int(input())
c = list(map(int, input().split()))
dp = [[0, 0] for i in range(n)]
x = input()
y = x[::-1]
dp[0] = [0, c[0]]
for i in range(1, n):
dp[i] = [float("inf"), float("inf")]
a = input()
b = a[::-1]
if x <= a:
dp[i][0] = min(dp[i - 1][0], dp[i][0])
if y <= a:
dp[i][0] = min(dp[i - 1][1], dp[i][0])
if x <= b:
dp[i][1] = min(dp[i - 1][0] + c[i], dp[i][1])
if y <= b:
dp[i][1] = min(dp[i - 1][1] + c[i], dp[i][1])
x = a
y = b
ans = min(dp[-1])
# print(dp)
if ans == float("inf"):
print(-1)
else:
print(ans)
``` | instruction | 0 | 80,467 | 6 | 160,934 |
Yes | output | 1 | 80,467 | 6 | 160,935 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasiliy is fond of solving different tasks. Today he found one he wasn't able to solve himself, so he asks you to help.
Vasiliy is given n strings consisting of lowercase English letters. He wants them to be sorted in lexicographical order (as in the dictionary), but he is not allowed to swap any of them. The only operation he is allowed to do is to reverse any of them (first character becomes last, second becomes one before last and so on).
To reverse the i-th string Vasiliy has to spent ci units of energy. He is interested in the minimum amount of energy he has to spent in order to have strings sorted in lexicographical order.
String A is lexicographically smaller than string B if it is shorter than B (|A| < |B|) and is its prefix, or if none of them is a prefix of the other and at the first position where they differ character in A is smaller than the character in B.
For the purpose of this problem, two equal strings nearby do not break the condition of sequence being sorted lexicographically.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of strings.
The second line contains n integers ci (0 ≤ ci ≤ 109), the i-th of them is equal to the amount of energy Vasiliy has to spent in order to reverse the i-th string.
Then follow n lines, each containing a string consisting of lowercase English letters. The total length of these strings doesn't exceed 100 000.
Output
If it is impossible to reverse some of the strings such that they will be located in lexicographical order, print - 1. Otherwise, print the minimum total amount of energy Vasiliy has to spent.
Examples
Input
2
1 2
ba
ac
Output
1
Input
3
1 3 1
aa
ba
ac
Output
1
Input
2
5 5
bbb
aaa
Output
-1
Input
2
3 3
aaa
aa
Output
-1
Note
In the second sample one has to reverse string 2 or string 3. To amount of energy required to reverse the string 3 is smaller.
In the third sample, both strings do not change after reverse and they go in the wrong order, so the answer is - 1.
In the fourth sample, both strings consists of characters 'a' only, but in the sorted order string "aa" should go before string "aaa", thus the answer is - 1.
Submitted Solution:
```
n=int(input())
g=list(map(int,input().split()))
def rv(s): return s[::-1]
ss=input()
rss=rv(ss)
d,p=0,g[0]
for i in range(1,n):
s=input()
rs=rv(s)
x,y=10**16,10**16
if s>=ss: x=d
if s>=rss: x=min(x,p)
if rs>=ss: y=d+g[i]
if rs>=rss: y=min(y,p+g[i])
d=x
p=y
ss=s
rss=rs
jj=min(d,p)
if jj==10**16: print(-1)
else: print(jj)
##//////////////// ////// /////// // /////// // // //
##//// // /// /// /// /// // /// /// //// //
##//// //// /// /// /// /// // ///////// //// ///////
##//// ///// /// /// /// /// // /// /// //// // //
##////////////// /////////// /////////// ////// /// /// // // // //
``` | instruction | 0 | 80,468 | 6 | 160,936 |
Yes | output | 1 | 80,468 | 6 | 160,937 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasiliy is fond of solving different tasks. Today he found one he wasn't able to solve himself, so he asks you to help.
Vasiliy is given n strings consisting of lowercase English letters. He wants them to be sorted in lexicographical order (as in the dictionary), but he is not allowed to swap any of them. The only operation he is allowed to do is to reverse any of them (first character becomes last, second becomes one before last and so on).
To reverse the i-th string Vasiliy has to spent ci units of energy. He is interested in the minimum amount of energy he has to spent in order to have strings sorted in lexicographical order.
String A is lexicographically smaller than string B if it is shorter than B (|A| < |B|) and is its prefix, or if none of them is a prefix of the other and at the first position where they differ character in A is smaller than the character in B.
For the purpose of this problem, two equal strings nearby do not break the condition of sequence being sorted lexicographically.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of strings.
The second line contains n integers ci (0 ≤ ci ≤ 109), the i-th of them is equal to the amount of energy Vasiliy has to spent in order to reverse the i-th string.
Then follow n lines, each containing a string consisting of lowercase English letters. The total length of these strings doesn't exceed 100 000.
Output
If it is impossible to reverse some of the strings such that they will be located in lexicographical order, print - 1. Otherwise, print the minimum total amount of energy Vasiliy has to spent.
Examples
Input
2
1 2
ba
ac
Output
1
Input
3
1 3 1
aa
ba
ac
Output
1
Input
2
5 5
bbb
aaa
Output
-1
Input
2
3 3
aaa
aa
Output
-1
Note
In the second sample one has to reverse string 2 or string 3. To amount of energy required to reverse the string 3 is smaller.
In the third sample, both strings do not change after reverse and they go in the wrong order, so the answer is - 1.
In the fourth sample, both strings consists of characters 'a' only, but in the sorted order string "aa" should go before string "aaa", thus the answer is - 1.
Submitted Solution:
```
n=int(input())
c=list(map(int,input().split()))
s=[]
d=[]
for i in range(n):
k=input()
s.append(k)
k=k[::-1]
d.append(k)
op=[[-1 for i in range(2)] for x in range(n)]
op[0][1]=c[0]
op[0][0]=0
for i in range(1,n):
if(s[i]>=s[i-1]):
if(op[i-1][0]!=-1):
if(op[i][0]==-1):
op[i][0]=op[i-1][0]
else:
op[i][0]=min(op[i][0],op[i-1][0])
if(s[i]>=d[i-1]):
if(op[i-1][1]!=-1):
if(op[i][0]==-1):
op[i][0]=op[i-1][1]
else:
op[i][0]=min(op[i][0],op[i-1][1])
if(d[i]>=d[i-1]):
if(op[i-1][1]!=-1):
if(op[i][1]==-1):
op[i][1]=op[i-1][1]+c[i]
else:
op[i][1]=min(op[i][1],op[i-1][1]+c[i])
if(d[i]>=s[i-1]):
if(op[i-1][0]!=-1):
if(op[i][1]==-1):
op[i][1]=op[i-1][0]+c[i]
else:
op[i][1]=min(op[i][1],op[i-1][0]+c[i])
if(op[n-1][1]==-1):
print(op[n-1][0])
elif(op[n-1][0]==-1):
print(op[n-1][1])
else:
print(min(op[n-1][0],op[n-1][1]))
``` | instruction | 0 | 80,469 | 6 | 160,938 |
Yes | output | 1 | 80,469 | 6 | 160,939 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasiliy is fond of solving different tasks. Today he found one he wasn't able to solve himself, so he asks you to help.
Vasiliy is given n strings consisting of lowercase English letters. He wants them to be sorted in lexicographical order (as in the dictionary), but he is not allowed to swap any of them. The only operation he is allowed to do is to reverse any of them (first character becomes last, second becomes one before last and so on).
To reverse the i-th string Vasiliy has to spent ci units of energy. He is interested in the minimum amount of energy he has to spent in order to have strings sorted in lexicographical order.
String A is lexicographically smaller than string B if it is shorter than B (|A| < |B|) and is its prefix, or if none of them is a prefix of the other and at the first position where they differ character in A is smaller than the character in B.
For the purpose of this problem, two equal strings nearby do not break the condition of sequence being sorted lexicographically.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of strings.
The second line contains n integers ci (0 ≤ ci ≤ 109), the i-th of them is equal to the amount of energy Vasiliy has to spent in order to reverse the i-th string.
Then follow n lines, each containing a string consisting of lowercase English letters. The total length of these strings doesn't exceed 100 000.
Output
If it is impossible to reverse some of the strings such that they will be located in lexicographical order, print - 1. Otherwise, print the minimum total amount of energy Vasiliy has to spent.
Examples
Input
2
1 2
ba
ac
Output
1
Input
3
1 3 1
aa
ba
ac
Output
1
Input
2
5 5
bbb
aaa
Output
-1
Input
2
3 3
aaa
aa
Output
-1
Note
In the second sample one has to reverse string 2 or string 3. To amount of energy required to reverse the string 3 is smaller.
In the third sample, both strings do not change after reverse and they go in the wrong order, so the answer is - 1.
In the fourth sample, both strings consists of characters 'a' only, but in the sorted order string "aa" should go before string "aaa", thus the answer is - 1.
Submitted Solution:
```
#import sys
#input = sys.stdin.readline
n = int(input())
a = list(map(int,input().split()))
s = []
r = []
d = [0]*(n+1)
MAX = int(1e18)
for i in range(0,n+1):
d[i] = [0]*2
for i in range(0,n):
s.append(input())
r.append(s[i][::-1])
d[0][0] = 0
d[0][1] = a[0]
for i in range(1,n):
for j in range(0,2):
if(j == 0):
st = s[i]
else:
st = r[i]
if(j==1):
d[i][j] = a[i]
if(st >= s[i-1] and st >= r[i-1]):
d[i][j] += min(d[i-1][0],d[i-1][1])
elif(st >= s[i-1]):
d[i][j] += d[i-1][0]
elif(st >= r[i-1]):
d[i][j] += d[i-1][1]
else:
d[i][j] = MAX
d[i][j] = min(d[i][j],MAX)
print(-1 if (d[n-1][0]==MAX and d[n-1][1]==MAX) else min(d[n-1][0],d[n-1][1]))
``` | instruction | 0 | 80,470 | 6 | 160,940 |
Yes | output | 1 | 80,470 | 6 | 160,941 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasiliy is fond of solving different tasks. Today he found one he wasn't able to solve himself, so he asks you to help.
Vasiliy is given n strings consisting of lowercase English letters. He wants them to be sorted in lexicographical order (as in the dictionary), but he is not allowed to swap any of them. The only operation he is allowed to do is to reverse any of them (first character becomes last, second becomes one before last and so on).
To reverse the i-th string Vasiliy has to spent ci units of energy. He is interested in the minimum amount of energy he has to spent in order to have strings sorted in lexicographical order.
String A is lexicographically smaller than string B if it is shorter than B (|A| < |B|) and is its prefix, or if none of them is a prefix of the other and at the first position where they differ character in A is smaller than the character in B.
For the purpose of this problem, two equal strings nearby do not break the condition of sequence being sorted lexicographically.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of strings.
The second line contains n integers ci (0 ≤ ci ≤ 109), the i-th of them is equal to the amount of energy Vasiliy has to spent in order to reverse the i-th string.
Then follow n lines, each containing a string consisting of lowercase English letters. The total length of these strings doesn't exceed 100 000.
Output
If it is impossible to reverse some of the strings such that they will be located in lexicographical order, print - 1. Otherwise, print the minimum total amount of energy Vasiliy has to spent.
Examples
Input
2
1 2
ba
ac
Output
1
Input
3
1 3 1
aa
ba
ac
Output
1
Input
2
5 5
bbb
aaa
Output
-1
Input
2
3 3
aaa
aa
Output
-1
Note
In the second sample one has to reverse string 2 or string 3. To amount of energy required to reverse the string 3 is smaller.
In the third sample, both strings do not change after reverse and they go in the wrong order, so the answer is - 1.
In the fourth sample, both strings consists of characters 'a' only, but in the sorted order string "aa" should go before string "aaa", thus the answer is - 1.
Submitted Solution:
```
inf = 10**100
n = int(input())
c= list(map(int,input().split()))
t=[]
for i in range(n):
t.append(input())
re=[i[::-1] for i in t]
dp=[[inf ,inf ] for i in range(n)]
dp[0] =[0,c[0]]
for i in range(1,n):
if t[i]>=t[i-1]:
dp[i][0] = min(dp[i][0] , dp[i-1][0])
if t[i] >= re[i-1]:
dp[i][0] = min( dp[i][0] , dp[i-1][0])
if re[i]>= t[i-1]:
dp[i][1] = min(dp[i][1] , dp[i-1][0]+c[i])
if re[i] >= re[i-1]:
dp[i][1] = min(dp[i][1] , dp[i-1][1]+c[i])
if min(dp[-1])==inf:
print(-1)
else:
print(min(dp[-1]))
``` | instruction | 0 | 80,471 | 6 | 160,942 |
No | output | 1 | 80,471 | 6 | 160,943 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasiliy is fond of solving different tasks. Today he found one he wasn't able to solve himself, so he asks you to help.
Vasiliy is given n strings consisting of lowercase English letters. He wants them to be sorted in lexicographical order (as in the dictionary), but he is not allowed to swap any of them. The only operation he is allowed to do is to reverse any of them (first character becomes last, second becomes one before last and so on).
To reverse the i-th string Vasiliy has to spent ci units of energy. He is interested in the minimum amount of energy he has to spent in order to have strings sorted in lexicographical order.
String A is lexicographically smaller than string B if it is shorter than B (|A| < |B|) and is its prefix, or if none of them is a prefix of the other and at the first position where they differ character in A is smaller than the character in B.
For the purpose of this problem, two equal strings nearby do not break the condition of sequence being sorted lexicographically.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of strings.
The second line contains n integers ci (0 ≤ ci ≤ 109), the i-th of them is equal to the amount of energy Vasiliy has to spent in order to reverse the i-th string.
Then follow n lines, each containing a string consisting of lowercase English letters. The total length of these strings doesn't exceed 100 000.
Output
If it is impossible to reverse some of the strings such that they will be located in lexicographical order, print - 1. Otherwise, print the minimum total amount of energy Vasiliy has to spent.
Examples
Input
2
1 2
ba
ac
Output
1
Input
3
1 3 1
aa
ba
ac
Output
1
Input
2
5 5
bbb
aaa
Output
-1
Input
2
3 3
aaa
aa
Output
-1
Note
In the second sample one has to reverse string 2 or string 3. To amount of energy required to reverse the string 3 is smaller.
In the third sample, both strings do not change after reverse and they go in the wrong order, so the answer is - 1.
In the fourth sample, both strings consists of characters 'a' only, but in the sorted order string "aa" should go before string "aaa", thus the answer is - 1.
Submitted Solution:
```
n = int(input())
c = [int(x) for x in input().split()]
l = []
for _ in range(n):
l.append(str(input()))
dp = [[10 ** 9] * 2 for _ in range(n)]
dp[0][0] = 0
dp[0][1] = c[0]
ans = 10 ** 9
for i in range(1, n):
if min(l[i - 1], l[i - 1][::-1]) > max(l[i], l[i][::-1]):
ans = -1
break
if l[i - 1] <= l[i]:
dp[i][0] = min(dp[i][0], dp[i - 1][0])
if l[i - 1][::-1] <= l[i]:
dp[i][0] = min(dp[i][0], dp[i - 1][1])
if l[i - 1] <= l[i][::-1]:
dp[i][1] = min(dp[i][1], dp[i - 1][0] + c[i])
if l[i - 1][::-1] <= l[i][::-1]:
dp[i][1] = min(dp[i][1], dp[i - 1][1] + c[i])
ans = min(dp[i][0], dp[i][1])
print(ans)
``` | instruction | 0 | 80,472 | 6 | 160,944 |
No | output | 1 | 80,472 | 6 | 160,945 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasiliy is fond of solving different tasks. Today he found one he wasn't able to solve himself, so he asks you to help.
Vasiliy is given n strings consisting of lowercase English letters. He wants them to be sorted in lexicographical order (as in the dictionary), but he is not allowed to swap any of them. The only operation he is allowed to do is to reverse any of them (first character becomes last, second becomes one before last and so on).
To reverse the i-th string Vasiliy has to spent ci units of energy. He is interested in the minimum amount of energy he has to spent in order to have strings sorted in lexicographical order.
String A is lexicographically smaller than string B if it is shorter than B (|A| < |B|) and is its prefix, or if none of them is a prefix of the other and at the first position where they differ character in A is smaller than the character in B.
For the purpose of this problem, two equal strings nearby do not break the condition of sequence being sorted lexicographically.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of strings.
The second line contains n integers ci (0 ≤ ci ≤ 109), the i-th of them is equal to the amount of energy Vasiliy has to spent in order to reverse the i-th string.
Then follow n lines, each containing a string consisting of lowercase English letters. The total length of these strings doesn't exceed 100 000.
Output
If it is impossible to reverse some of the strings such that they will be located in lexicographical order, print - 1. Otherwise, print the minimum total amount of energy Vasiliy has to spent.
Examples
Input
2
1 2
ba
ac
Output
1
Input
3
1 3 1
aa
ba
ac
Output
1
Input
2
5 5
bbb
aaa
Output
-1
Input
2
3 3
aaa
aa
Output
-1
Note
In the second sample one has to reverse string 2 or string 3. To amount of energy required to reverse the string 3 is smaller.
In the third sample, both strings do not change after reverse and they go in the wrong order, so the answer is - 1.
In the fourth sample, both strings consists of characters 'a' only, but in the sorted order string "aa" should go before string "aaa", thus the answer is - 1.
Submitted Solution:
```
import sys
def fastio():
from io import StringIO
from atexit import register
global input
sys.stdin = StringIO(sys.stdin.read())
input = lambda : sys.stdin.readline().rstrip('\r\n')
sys.stdout = StringIO()
register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()
def debug(*var, sep = ' ', end = '\n'):
print(*var, file=sys.stderr, end = end, sep = sep)
INF = 10**20
MOD = 10**9 + 7
I = lambda:list(map(int,input().split()))
from math import gcd
from math import ceil
from collections import defaultdict as dd, Counter
from bisect import bisect_left as bl, bisect_right as br
n, = I()
cost = I()
ans = 0
previous = ''
dp = [[INF] * 2 for i in range(n + 1)]
dp[0] = [0, 0]
for i in range(n):
s = input()
if s > previous:
dp[i + 1][0] = dp[i][0]
if s > previous[::-1]:
dp[i + 1][0] = min(dp[i + 1][0], dp[i][1])
s = s[::-1]
if s > previous:
dp[i + 1][1] = min(dp[i + 1][1], dp[i][0] + cost[i])
if s > previous[::-1]:
dp[i + 1][1] = min(dp[i + 1][1], dp[i][1] + cost[i])
previous = s[::-1]
if dp[n] == [INF, INF]:
print(-1)
exit()
print(min(dp[n]))
``` | instruction | 0 | 80,473 | 6 | 160,946 |
No | output | 1 | 80,473 | 6 | 160,947 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasiliy is fond of solving different tasks. Today he found one he wasn't able to solve himself, so he asks you to help.
Vasiliy is given n strings consisting of lowercase English letters. He wants them to be sorted in lexicographical order (as in the dictionary), but he is not allowed to swap any of them. The only operation he is allowed to do is to reverse any of them (first character becomes last, second becomes one before last and so on).
To reverse the i-th string Vasiliy has to spent ci units of energy. He is interested in the minimum amount of energy he has to spent in order to have strings sorted in lexicographical order.
String A is lexicographically smaller than string B if it is shorter than B (|A| < |B|) and is its prefix, or if none of them is a prefix of the other and at the first position where they differ character in A is smaller than the character in B.
For the purpose of this problem, two equal strings nearby do not break the condition of sequence being sorted lexicographically.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of strings.
The second line contains n integers ci (0 ≤ ci ≤ 109), the i-th of them is equal to the amount of energy Vasiliy has to spent in order to reverse the i-th string.
Then follow n lines, each containing a string consisting of lowercase English letters. The total length of these strings doesn't exceed 100 000.
Output
If it is impossible to reverse some of the strings such that they will be located in lexicographical order, print - 1. Otherwise, print the minimum total amount of energy Vasiliy has to spent.
Examples
Input
2
1 2
ba
ac
Output
1
Input
3
1 3 1
aa
ba
ac
Output
1
Input
2
5 5
bbb
aaa
Output
-1
Input
2
3 3
aaa
aa
Output
-1
Note
In the second sample one has to reverse string 2 or string 3. To amount of energy required to reverse the string 3 is smaller.
In the third sample, both strings do not change after reverse and they go in the wrong order, so the answer is - 1.
In the fourth sample, both strings consists of characters 'a' only, but in the sorted order string "aa" should go before string "aaa", thus the answer is - 1.
Submitted Solution:
```
import math
n=int(input())
a=list(map(int,input().split()))
s=[input() for _ in range(n)]
dp=[[0]*2 for _ in range(n)]
dp[0]=[0,a[0]]
for i in range(1,n):
dp[i]=[math.inf]*2
if s[i-1]<s[i]:
dp[i][0]=min(dp[i-1][0],dp[i][0])
if s[i-1][::-1]<s[i]:
dp[i][0]=min(dp[i-1][1],dp[i][0])
if s[i-1]<s[i][::-1]:
dp[i][1]=min(dp[i-1][0]+a[i],dp[i][1])
if s[i-1][::-1]<s[i][::-1]:
dp[i][1]=min(dp[i-1][1]+a[i],dp[i][1])
res=min(dp[-1])
print(-1 if res==math.inf else res)
``` | instruction | 0 | 80,474 | 6 | 160,948 |
No | output | 1 | 80,474 | 6 | 160,949 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The main city magazine offers its readers an opportunity to publish their ads. The format of the ad should be like this:
There are space-separated non-empty words of lowercase and uppercase Latin letters.
There are hyphen characters '-' in some words, their positions set word wrapping points. Word can include more than one hyphen.
It is guaranteed that there are no adjacent spaces and no adjacent hyphens. No hyphen is adjacent to space. There are no spaces and no hyphens before the first word and after the last word.
When the word is wrapped, the part of the word before hyphen and the hyphen itself stay on current line and the next part of the word is put on the next line. You can also put line break between two words, in that case the space stays on current line. Check notes for better understanding.
The ad can occupy no more that k lines and should have minimal width. The width of the ad is the maximal length of string (letters, spaces and hyphens are counted) in it.
You should write a program that will find minimal width of the ad.
Input
The first line contains number k (1 ≤ k ≤ 105).
The second line contains the text of the ad — non-empty space-separated words of lowercase and uppercase Latin letters and hyphens. Total length of the ad don't exceed 106 characters.
Output
Output minimal width of the ad.
Examples
Input
4
garage for sa-le
Output
7
Input
4
Edu-ca-tion-al Ro-unds are so fun
Output
10
Note
Here all spaces are replaced with dots.
In the first example one of possible results after all word wraps looks like this:
garage.
for.
sa-
le
The second example:
Edu-ca-
tion-al.
Ro-unds.
are.so.fun
| instruction | 0 | 81,344 | 6 | 162,688 |
Tags: binary search, greedy
Correct Solution:
```
import sys
#import random
from bisect import bisect_left as lb
from collections import deque
#sys.setrecursionlimit(10**8)
from queue import PriorityQueue as pq
from math import *
input_ = lambda: sys.stdin.readline().strip("\r\n")
ii = lambda : int(input_())
il = lambda : list(map(int, input_().split()))
ilf = lambda : list(map(float, input_().split()))
ip = lambda : input_()
fi = lambda : float(input_())
ap = lambda ab,bc,cd : ab[bc].append(cd)
li = lambda : list(input_())
pr = lambda x : print(x)
prinT = lambda x : print(x)
f = lambda : sys.stdout.flush()
inv =lambda x:pow(x,mod-2,mod)
mod = 10**9 + 7
n = ii()
a = ip()
b = []
t = 0
for i in range (len(a)) :
t += 1
if (a[i] == '-' or a[i] == " ") :
b.append(t)
t = 0
b.append(t)
l = 0
h = 10**7
def check(x) :
t1 = 1
s = 0
for i in b :
if (s+i)<=x :
s += i
elif (i>x) :
return False
else :
s = i
t1 += 1
if (t1 <= n) :
return True
else :
return False
ans = -1
#print(len(a))
p = -1
while (l<=h) :
m = (l+h)//2
if (m == p) :
break
p = m
if (check(m)) :
#print(m)
ans = m
h = m
else :
l = m+1
print(ans)
``` | output | 1 | 81,344 | 6 | 162,689 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The main city magazine offers its readers an opportunity to publish their ads. The format of the ad should be like this:
There are space-separated non-empty words of lowercase and uppercase Latin letters.
There are hyphen characters '-' in some words, their positions set word wrapping points. Word can include more than one hyphen.
It is guaranteed that there are no adjacent spaces and no adjacent hyphens. No hyphen is adjacent to space. There are no spaces and no hyphens before the first word and after the last word.
When the word is wrapped, the part of the word before hyphen and the hyphen itself stay on current line and the next part of the word is put on the next line. You can also put line break between two words, in that case the space stays on current line. Check notes for better understanding.
The ad can occupy no more that k lines and should have minimal width. The width of the ad is the maximal length of string (letters, spaces and hyphens are counted) in it.
You should write a program that will find minimal width of the ad.
Input
The first line contains number k (1 ≤ k ≤ 105).
The second line contains the text of the ad — non-empty space-separated words of lowercase and uppercase Latin letters and hyphens. Total length of the ad don't exceed 106 characters.
Output
Output minimal width of the ad.
Examples
Input
4
garage for sa-le
Output
7
Input
4
Edu-ca-tion-al Ro-unds are so fun
Output
10
Note
Here all spaces are replaced with dots.
In the first example one of possible results after all word wraps looks like this:
garage.
for.
sa-
le
The second example:
Edu-ca-
tion-al.
Ro-unds.
are.so.fun
| instruction | 0 | 81,345 | 6 | 162,690 |
Tags: binary search, greedy
Correct Solution:
```
n = int(input())
xs = list(map(lambda x: len(list(x)) + 1, input().replace('-', ' ').split()))
xs[-1] -= 1
def f(xs, n, c):
cnt = 1
tmp = 0
for x in xs:
if c < x:
return False
elif c < tmp + x:
tmp = 0
cnt += 1
tmp += x
return cnt <= n
l = 1
r = sum(xs)
while l + 1 < r:
c = (l + r) // 2
if f(xs, n, c):
r = c
else:
l = c
print(r)
``` | output | 1 | 81,345 | 6 | 162,691 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The main city magazine offers its readers an opportunity to publish their ads. The format of the ad should be like this:
There are space-separated non-empty words of lowercase and uppercase Latin letters.
There are hyphen characters '-' in some words, their positions set word wrapping points. Word can include more than one hyphen.
It is guaranteed that there are no adjacent spaces and no adjacent hyphens. No hyphen is adjacent to space. There are no spaces and no hyphens before the first word and after the last word.
When the word is wrapped, the part of the word before hyphen and the hyphen itself stay on current line and the next part of the word is put on the next line. You can also put line break between two words, in that case the space stays on current line. Check notes for better understanding.
The ad can occupy no more that k lines and should have minimal width. The width of the ad is the maximal length of string (letters, spaces and hyphens are counted) in it.
You should write a program that will find minimal width of the ad.
Input
The first line contains number k (1 ≤ k ≤ 105).
The second line contains the text of the ad — non-empty space-separated words of lowercase and uppercase Latin letters and hyphens. Total length of the ad don't exceed 106 characters.
Output
Output minimal width of the ad.
Examples
Input
4
garage for sa-le
Output
7
Input
4
Edu-ca-tion-al Ro-unds are so fun
Output
10
Note
Here all spaces are replaced with dots.
In the first example one of possible results after all word wraps looks like this:
garage.
for.
sa-
le
The second example:
Edu-ca-
tion-al.
Ro-unds.
are.so.fun
| instruction | 0 | 81,346 | 6 | 162,692 |
Tags: binary search, greedy
Correct Solution:
```
n = int(input())
s = input()
d = []
pre = 0
for i in range(len(s)):
if s[i] == '-':
d.append(pre + 1)
pre = 0
elif s[i] == ' ':
d.append(pre + 1)
pre = 0
else:
pre += 1
d.append(pre)
def calc(k, n):
m = len(d)
tmp = 0
cnt = 1
for i in range(m):
if d[i] > k:
return False
if tmp + d[i] <= k:
tmp += d[i]
else:
tmp = d[i]
cnt += 1
return cnt <= n
l, r = 0, 10 ** 6 + 1
while r - l > 1:
mid = (r + l) // 2
if calc(mid, n):
r = mid
else:
l = mid
print(r)
``` | output | 1 | 81,346 | 6 | 162,693 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The main city magazine offers its readers an opportunity to publish their ads. The format of the ad should be like this:
There are space-separated non-empty words of lowercase and uppercase Latin letters.
There are hyphen characters '-' in some words, their positions set word wrapping points. Word can include more than one hyphen.
It is guaranteed that there are no adjacent spaces and no adjacent hyphens. No hyphen is adjacent to space. There are no spaces and no hyphens before the first word and after the last word.
When the word is wrapped, the part of the word before hyphen and the hyphen itself stay on current line and the next part of the word is put on the next line. You can also put line break between two words, in that case the space stays on current line. Check notes for better understanding.
The ad can occupy no more that k lines and should have minimal width. The width of the ad is the maximal length of string (letters, spaces and hyphens are counted) in it.
You should write a program that will find minimal width of the ad.
Input
The first line contains number k (1 ≤ k ≤ 105).
The second line contains the text of the ad — non-empty space-separated words of lowercase and uppercase Latin letters and hyphens. Total length of the ad don't exceed 106 characters.
Output
Output minimal width of the ad.
Examples
Input
4
garage for sa-le
Output
7
Input
4
Edu-ca-tion-al Ro-unds are so fun
Output
10
Note
Here all spaces are replaced with dots.
In the first example one of possible results after all word wraps looks like this:
garage.
for.
sa-
le
The second example:
Edu-ca-
tion-al.
Ro-unds.
are.so.fun
| instruction | 0 | 81,347 | 6 | 162,694 |
Tags: binary search, greedy
Correct Solution:
```
#Bhargey Mehta (Sophomore)
#DA-IICT, Gandhinagar
import sys, math, queue
#sys.stdin = open("input.txt", "r")
MOD = 10**9+7
sys.setrecursionlimit(1000000)
def ok(w):
i = 0
c = 0
l = 0
while i < len(x):
if c+x[i] <= w:
c += x[i]
i += 1
else:
l += 1
c = 0
l += 1
return l <= n
n = int(input())
s = list(input().split())
x = []
for i in range(len(s)-1):
s[i] += " "
for i in range(len(s)):
s[i] = s[i].split('-')
for i in range(len(s)):
for j in range(len(s[i])-1):
x.append(len(s[i][j])+1)
x.append(len(s[i][-1]))
low = max(x)
high = sum(x)+1
while low <= high:
mid = (low+high)//2
if ok(mid):
ans = mid
high = mid-1
else:
low = mid+1
print(ans)
``` | output | 1 | 81,347 | 6 | 162,695 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The main city magazine offers its readers an opportunity to publish their ads. The format of the ad should be like this:
There are space-separated non-empty words of lowercase and uppercase Latin letters.
There are hyphen characters '-' in some words, their positions set word wrapping points. Word can include more than one hyphen.
It is guaranteed that there are no adjacent spaces and no adjacent hyphens. No hyphen is adjacent to space. There are no spaces and no hyphens before the first word and after the last word.
When the word is wrapped, the part of the word before hyphen and the hyphen itself stay on current line and the next part of the word is put on the next line. You can also put line break between two words, in that case the space stays on current line. Check notes for better understanding.
The ad can occupy no more that k lines and should have minimal width. The width of the ad is the maximal length of string (letters, spaces and hyphens are counted) in it.
You should write a program that will find minimal width of the ad.
Input
The first line contains number k (1 ≤ k ≤ 105).
The second line contains the text of the ad — non-empty space-separated words of lowercase and uppercase Latin letters and hyphens. Total length of the ad don't exceed 106 characters.
Output
Output minimal width of the ad.
Examples
Input
4
garage for sa-le
Output
7
Input
4
Edu-ca-tion-al Ro-unds are so fun
Output
10
Note
Here all spaces are replaced with dots.
In the first example one of possible results after all word wraps looks like this:
garage.
for.
sa-
le
The second example:
Edu-ca-
tion-al.
Ro-unds.
are.so.fun
| instruction | 0 | 81,348 | 6 | 162,696 |
Tags: binary search, greedy
Correct Solution:
```
def solve():
k = int(input())
s = input()
s = s.replace('-',' ')
x = [len(a) for a in s.split(' ')]
x[-1] -= 1
x = x[::-1]
def good(z):
y = x[:]
l = 1
curr = 0
while y:
u = y.pop() + 1
if u > z:
return False
elif curr + u > z:
l += 1
curr = u
else:
curr += u
return l <= k
low, high = 0, 10**6 + 1
while high - low > 1:
m = (low + high) // 2
if good(m):
high = m
else:
low = m
return high
print(solve())
``` | output | 1 | 81,348 | 6 | 162,697 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The main city magazine offers its readers an opportunity to publish their ads. The format of the ad should be like this:
There are space-separated non-empty words of lowercase and uppercase Latin letters.
There are hyphen characters '-' in some words, their positions set word wrapping points. Word can include more than one hyphen.
It is guaranteed that there are no adjacent spaces and no adjacent hyphens. No hyphen is adjacent to space. There are no spaces and no hyphens before the first word and after the last word.
When the word is wrapped, the part of the word before hyphen and the hyphen itself stay on current line and the next part of the word is put on the next line. You can also put line break between two words, in that case the space stays on current line. Check notes for better understanding.
The ad can occupy no more that k lines and should have minimal width. The width of the ad is the maximal length of string (letters, spaces and hyphens are counted) in it.
You should write a program that will find minimal width of the ad.
Input
The first line contains number k (1 ≤ k ≤ 105).
The second line contains the text of the ad — non-empty space-separated words of lowercase and uppercase Latin letters and hyphens. Total length of the ad don't exceed 106 characters.
Output
Output minimal width of the ad.
Examples
Input
4
garage for sa-le
Output
7
Input
4
Edu-ca-tion-al Ro-unds are so fun
Output
10
Note
Here all spaces are replaced with dots.
In the first example one of possible results after all word wraps looks like this:
garage.
for.
sa-
le
The second example:
Edu-ca-
tion-al.
Ro-unds.
are.so.fun
| instruction | 0 | 81,349 | 6 | 162,698 |
Tags: binary search, greedy
Correct Solution:
```
import sys
inf = 1 << 30
def solve():
def check(mid):
if a_max > mid:
return False
tot = 1
line = 0
for ai in a:
if line + ai > mid:
tot += 1
line = ai
if tot > k:
return False
else:
line += ai
return True
k = int(input())
s = input().replace('-', ' ')
a = [len(si) + 1 for si in s.split()]
a[-1] -= 1
a_max = max(a)
top = len(s)
btm = 0
while top - btm > 1:
mid = (top + btm) // 2
if check(mid):
top = mid
else:
btm = mid
ans = top
print(ans)
if __name__ == '__main__':
solve()
``` | output | 1 | 81,349 | 6 | 162,699 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The main city magazine offers its readers an opportunity to publish their ads. The format of the ad should be like this:
There are space-separated non-empty words of lowercase and uppercase Latin letters.
There are hyphen characters '-' in some words, their positions set word wrapping points. Word can include more than one hyphen.
It is guaranteed that there are no adjacent spaces and no adjacent hyphens. No hyphen is adjacent to space. There are no spaces and no hyphens before the first word and after the last word.
When the word is wrapped, the part of the word before hyphen and the hyphen itself stay on current line and the next part of the word is put on the next line. You can also put line break between two words, in that case the space stays on current line. Check notes for better understanding.
The ad can occupy no more that k lines and should have minimal width. The width of the ad is the maximal length of string (letters, spaces and hyphens are counted) in it.
You should write a program that will find minimal width of the ad.
Input
The first line contains number k (1 ≤ k ≤ 105).
The second line contains the text of the ad — non-empty space-separated words of lowercase and uppercase Latin letters and hyphens. Total length of the ad don't exceed 106 characters.
Output
Output minimal width of the ad.
Examples
Input
4
garage for sa-le
Output
7
Input
4
Edu-ca-tion-al Ro-unds are so fun
Output
10
Note
Here all spaces are replaced with dots.
In the first example one of possible results after all word wraps looks like this:
garage.
for.
sa-
le
The second example:
Edu-ca-
tion-al.
Ro-unds.
are.so.fun
| instruction | 0 | 81,350 | 6 | 162,700 |
Tags: binary search, greedy
Correct Solution:
```
# 803D
def do():
k = int(input())
ad = input()
def valid(width, limit):
l = -1
count = 0
cur = 0
for r in range(len(ad)):
if ad[r] == " " or ad[r] == "-":
l = r
cur += 1
if cur == width:
if l == -1 and r != len(ad) - 1:
return False
count += 1
# if r != len(ad) - 1:
# print([count, ad[r-width+1:l+1]])
# else:
# print([count, ad[r-width+1:]])
if r == len(ad) - 1:
cur = 0
else:
cur = r - l
l = -1
if count > limit:
return False
if cur:
count += 1
return count <= limit
lo, hi = 1, len(ad) + 1
while lo < hi:
mi = (lo + hi) >> 1
if not valid(mi, k):
lo = mi + 1
else:
hi = mi
return lo
print(do())
``` | output | 1 | 81,350 | 6 | 162,701 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The main city magazine offers its readers an opportunity to publish their ads. The format of the ad should be like this:
There are space-separated non-empty words of lowercase and uppercase Latin letters.
There are hyphen characters '-' in some words, their positions set word wrapping points. Word can include more than one hyphen.
It is guaranteed that there are no adjacent spaces and no adjacent hyphens. No hyphen is adjacent to space. There are no spaces and no hyphens before the first word and after the last word.
When the word is wrapped, the part of the word before hyphen and the hyphen itself stay on current line and the next part of the word is put on the next line. You can also put line break between two words, in that case the space stays on current line. Check notes for better understanding.
The ad can occupy no more that k lines and should have minimal width. The width of the ad is the maximal length of string (letters, spaces and hyphens are counted) in it.
You should write a program that will find minimal width of the ad.
Input
The first line contains number k (1 ≤ k ≤ 105).
The second line contains the text of the ad — non-empty space-separated words of lowercase and uppercase Latin letters and hyphens. Total length of the ad don't exceed 106 characters.
Output
Output minimal width of the ad.
Examples
Input
4
garage for sa-le
Output
7
Input
4
Edu-ca-tion-al Ro-unds are so fun
Output
10
Note
Here all spaces are replaced with dots.
In the first example one of possible results after all word wraps looks like this:
garage.
for.
sa-
le
The second example:
Edu-ca-
tion-al.
Ro-unds.
are.so.fun
| instruction | 0 | 81,351 | 6 | 162,702 |
Tags: binary search, greedy
Correct Solution:
```
import sys
#Library Info(ACL for Python/Pypy) -> https://github.com/not522/ac-library-python
def input():
return sys.stdin.readline().rstrip()
DXY = [(0, -1), (1,0), (0, 1), (-1,0)] #L,D,R,Uの順番
def main():
k = int(input())
s = input()
V = []
for elem in s.split(" "):
for v in elem.split("-"):
V.append(len(v) + 1)
V[-1] -= 1
l = max(V) - 1 # impossible
r = len(s) #possible
while r - l > 1:
med = (r + l) // 2
part,cost = 0,0
Q = V.copy()
while Q:
while Q and Q[-1] + cost <= med:
cost += Q.pop()
part += 1
cost = 0
if part <= k:
r = med
else:
l = med
print(r)
return 0
if __name__ == "__main__":
main()
``` | output | 1 | 81,351 | 6 | 162,703 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The main city magazine offers its readers an opportunity to publish their ads. The format of the ad should be like this:
There are space-separated non-empty words of lowercase and uppercase Latin letters.
There are hyphen characters '-' in some words, their positions set word wrapping points. Word can include more than one hyphen.
It is guaranteed that there are no adjacent spaces and no adjacent hyphens. No hyphen is adjacent to space. There are no spaces and no hyphens before the first word and after the last word.
When the word is wrapped, the part of the word before hyphen and the hyphen itself stay on current line and the next part of the word is put on the next line. You can also put line break between two words, in that case the space stays on current line. Check notes for better understanding.
The ad can occupy no more that k lines and should have minimal width. The width of the ad is the maximal length of string (letters, spaces and hyphens are counted) in it.
You should write a program that will find minimal width of the ad.
Input
The first line contains number k (1 ≤ k ≤ 105).
The second line contains the text of the ad — non-empty space-separated words of lowercase and uppercase Latin letters and hyphens. Total length of the ad don't exceed 106 characters.
Output
Output minimal width of the ad.
Examples
Input
4
garage for sa-le
Output
7
Input
4
Edu-ca-tion-al Ro-unds are so fun
Output
10
Note
Here all spaces are replaced with dots.
In the first example one of possible results after all word wraps looks like this:
garage.
for.
sa-
le
The second example:
Edu-ca-
tion-al.
Ro-unds.
are.so.fun
Submitted Solution:
```
import bisect
from itertools import accumulate
import os
import sys
import math
from decimal import *
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)
def input(): return sys.stdin.readline().rstrip("\r\n")
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
def SieveOfEratosthenes(n):
prime=[]
primes = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (primes[p] == True):
prime.append(p)
for i in range(p * p, n+1, p):
primes[i] = False
p += 1
return prime
def primefactors(n):
fac=[]
while(n%2==0):
fac.append(2)
n=n//2
for i in range(3,int(math.sqrt(n))+2):
while(n%i==0):
fac.append(i)
n=n//i
if n>1:
fac.append(n)
return fac
def factors(n):
fac=set()
fac.add(1)
fac.add(n)
for i in range(2,int(math.sqrt(n))+1):
if n%i==0:
fac.add(i)
fac.add(n//i)
return list(fac)
def modInverse(a, m):
m0 = m
y = 0
x = 1
if (m == 1):
return 0
while (a > 1):
q = a // m
t = m
m = a % m
a = t
t = y
y = x - q * y
x = t
if (x < 0):
x = x + m0
return x
#------------------------------------------------------code by AD18/apurva3455
def good(mid ,ans,n):
count=0
sumi=0
for i in range(0,len(ans)):
if ans[i]>mid:
return False
sumi+=ans[i]
if sumi>mid:
count+=1
sumi=ans[i]
count+=1
if count<=n:
return True
return False
ans=[]
n=int(input())
s=input()
count=0
s=s.replace("-", " ")
for i in range(0,len(s)):
if s[i]!=" ":
count+=1
else:
ans.append(count+1)
count=0
ans.append(count)
l=0
r=len(s)+1
fans=0
while(l<=r):
mid=(l+r)//2
if good(mid,ans,n)==True:
fans=mid
r=mid-1
else:
l=mid+1
print(fans)
``` | instruction | 0 | 81,352 | 6 | 162,704 |
Yes | output | 1 | 81,352 | 6 | 162,705 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The main city magazine offers its readers an opportunity to publish their ads. The format of the ad should be like this:
There are space-separated non-empty words of lowercase and uppercase Latin letters.
There are hyphen characters '-' in some words, their positions set word wrapping points. Word can include more than one hyphen.
It is guaranteed that there are no adjacent spaces and no adjacent hyphens. No hyphen is adjacent to space. There are no spaces and no hyphens before the first word and after the last word.
When the word is wrapped, the part of the word before hyphen and the hyphen itself stay on current line and the next part of the word is put on the next line. You can also put line break between two words, in that case the space stays on current line. Check notes for better understanding.
The ad can occupy no more that k lines and should have minimal width. The width of the ad is the maximal length of string (letters, spaces and hyphens are counted) in it.
You should write a program that will find minimal width of the ad.
Input
The first line contains number k (1 ≤ k ≤ 105).
The second line contains the text of the ad — non-empty space-separated words of lowercase and uppercase Latin letters and hyphens. Total length of the ad don't exceed 106 characters.
Output
Output minimal width of the ad.
Examples
Input
4
garage for sa-le
Output
7
Input
4
Edu-ca-tion-al Ro-unds are so fun
Output
10
Note
Here all spaces are replaced with dots.
In the first example one of possible results after all word wraps looks like this:
garage.
for.
sa-
le
The second example:
Edu-ca-
tion-al.
Ro-unds.
are.so.fun
Submitted Solution:
```
import sys
k = int(sys.stdin.buffer.readline().decode('utf-8'))
s = sys.stdin.buffer.readline().decode('utf-8').rstrip()
n = len(s)
prev, words = -1, []
for i in range(n):
if s[i] == ' ' or s[i] == '-':
words.append(i-prev)
prev = i
words.append(n-prev-1)
ok, ng = n+1, max(words)-1
while abs(ok - ng) > 1:
mid = (ok + ng) >> 1
line, width = 1, 0
for w in words:
if width + w > mid:
line += 1
width = w
else:
width += w
if line <= k:
ok = mid
else:
ng = mid
print(ok)
``` | instruction | 0 | 81,353 | 6 | 162,706 |
Yes | output | 1 | 81,353 | 6 | 162,707 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The main city magazine offers its readers an opportunity to publish their ads. The format of the ad should be like this:
There are space-separated non-empty words of lowercase and uppercase Latin letters.
There are hyphen characters '-' in some words, their positions set word wrapping points. Word can include more than one hyphen.
It is guaranteed that there are no adjacent spaces and no adjacent hyphens. No hyphen is adjacent to space. There are no spaces and no hyphens before the first word and after the last word.
When the word is wrapped, the part of the word before hyphen and the hyphen itself stay on current line and the next part of the word is put on the next line. You can also put line break between two words, in that case the space stays on current line. Check notes for better understanding.
The ad can occupy no more that k lines and should have minimal width. The width of the ad is the maximal length of string (letters, spaces and hyphens are counted) in it.
You should write a program that will find minimal width of the ad.
Input
The first line contains number k (1 ≤ k ≤ 105).
The second line contains the text of the ad — non-empty space-separated words of lowercase and uppercase Latin letters and hyphens. Total length of the ad don't exceed 106 characters.
Output
Output minimal width of the ad.
Examples
Input
4
garage for sa-le
Output
7
Input
4
Edu-ca-tion-al Ro-unds are so fun
Output
10
Note
Here all spaces are replaced with dots.
In the first example one of possible results after all word wraps looks like this:
garage.
for.
sa-
le
The second example:
Edu-ca-
tion-al.
Ro-unds.
are.so.fun
Submitted Solution:
```
# The first line contains number k (1 ≤ k ≤ 105).
# The second line contains the text of the ad —
# non-empty space-separated words of lowercase and uppercase Latin letters and hyphens.
K = int(input())
line = input()
line = line.replace('-', ' ')
text = line.split()
ords = list(map(len, text))
words = [x+1 for x in ords]
words[-1] -= 1
def can(limit):
row = 0
col = 0
win = 0
while win < len(words):
while (win < len(words) and col + words[win] <= limit):
col += words[win]
# print(text[win], end = '.')
win += 1
row += 1
# print()
col = 0
return row < K or (row <= K and col == 0)
lo = max(words)
hi = len(line)
while lo < hi:
mid = (lo + hi) // 2
# print(f'mid={mid}')
# mid = lo + (hi - lo) // 2
if can(mid):
hi = mid
else:
lo = mid + 1
print(hi)
``` | instruction | 0 | 81,354 | 6 | 162,708 |
Yes | output | 1 | 81,354 | 6 | 162,709 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The main city magazine offers its readers an opportunity to publish their ads. The format of the ad should be like this:
There are space-separated non-empty words of lowercase and uppercase Latin letters.
There are hyphen characters '-' in some words, their positions set word wrapping points. Word can include more than one hyphen.
It is guaranteed that there are no adjacent spaces and no adjacent hyphens. No hyphen is adjacent to space. There are no spaces and no hyphens before the first word and after the last word.
When the word is wrapped, the part of the word before hyphen and the hyphen itself stay on current line and the next part of the word is put on the next line. You can also put line break between two words, in that case the space stays on current line. Check notes for better understanding.
The ad can occupy no more that k lines and should have minimal width. The width of the ad is the maximal length of string (letters, spaces and hyphens are counted) in it.
You should write a program that will find minimal width of the ad.
Input
The first line contains number k (1 ≤ k ≤ 105).
The second line contains the text of the ad — non-empty space-separated words of lowercase and uppercase Latin letters and hyphens. Total length of the ad don't exceed 106 characters.
Output
Output minimal width of the ad.
Examples
Input
4
garage for sa-le
Output
7
Input
4
Edu-ca-tion-al Ro-unds are so fun
Output
10
Note
Here all spaces are replaced with dots.
In the first example one of possible results after all word wraps looks like this:
garage.
for.
sa-
le
The second example:
Edu-ca-
tion-al.
Ro-unds.
are.so.fun
Submitted 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
def modinv(n,p):
return pow(n,p-2,p)
def lines_occupied(arr, width):
if max(arr) > width:
return int(1e6) + 1
lines = 1
current_line_width = 0
for x in arr:
if current_line_width + x <= width:
current_line_width += x
else:
current_line_width = x
lines += 1
return lines
def main():
#sys.stdin = open('input.txt', 'r')
#sys.stdout = open('output.txt', 'w')
k = int(input())
s = input()
new_s = []
temp = []
for c in s:
if c == " ":
new_s.append("-")
else:
new_s.append(c)
# print("".join(new_s))
current = 1
for i in range(len(new_s)):
if new_s[i] != "-":
current += 1
else:
temp.append(current)
current = 1
temp.append(current-1)
# print(temp)
l = 1
r = int(1e6)
# print("enter line width: ")
# w = int(input())
# print(lines_occupied(new_s, 7))
while l < r:
m = l + (r - l)//2
lines = lines_occupied(temp, m)
if lines > k:
l = m+1
else:
r = m
# print(l, r, m)
a, b = [min(l, m), max(l, m)]
# print(a, b,k)
# print(lines_occupied(temp, a))
# print(lines_occupied(temp, b))
if lines_occupied(temp, a) <= k:
print(a)
else:
print(b)
#------------------ 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()
``` | instruction | 0 | 81,355 | 6 | 162,710 |
Yes | output | 1 | 81,355 | 6 | 162,711 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The main city magazine offers its readers an opportunity to publish their ads. The format of the ad should be like this:
There are space-separated non-empty words of lowercase and uppercase Latin letters.
There are hyphen characters '-' in some words, their positions set word wrapping points. Word can include more than one hyphen.
It is guaranteed that there are no adjacent spaces and no adjacent hyphens. No hyphen is adjacent to space. There are no spaces and no hyphens before the first word and after the last word.
When the word is wrapped, the part of the word before hyphen and the hyphen itself stay on current line and the next part of the word is put on the next line. You can also put line break between two words, in that case the space stays on current line. Check notes for better understanding.
The ad can occupy no more that k lines and should have minimal width. The width of the ad is the maximal length of string (letters, spaces and hyphens are counted) in it.
You should write a program that will find minimal width of the ad.
Input
The first line contains number k (1 ≤ k ≤ 105).
The second line contains the text of the ad — non-empty space-separated words of lowercase and uppercase Latin letters and hyphens. Total length of the ad don't exceed 106 characters.
Output
Output minimal width of the ad.
Examples
Input
4
garage for sa-le
Output
7
Input
4
Edu-ca-tion-al Ro-unds are so fun
Output
10
Note
Here all spaces are replaced with dots.
In the first example one of possible results after all word wraps looks like this:
garage.
for.
sa-
le
The second example:
Edu-ca-
tion-al.
Ro-unds.
are.so.fun
Submitted 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
def modinv(n,p):
return pow(n,p-2,p)
def lines_occupied(s, width):
temp = "".join(s)
temp = temp.split("-")
temp = [x+'-' for x in temp]
temp[-1] = temp[-1].rstrip('-')
# print(temp)
l_max = 0
for x in temp:
l_max = max(l_max, len(x))
if l_max+1 > width:
return int(1e6) + 1
lines = 1
current_line_width = 0
for x in temp:
if current_line_width + len(x) <= width:
current_line_width += len(x)
else:
current_line_width = len(x)
lines += 1
return lines
def main():
#sys.stdin = open('input.txt', 'r')
#sys.stdout = open('output.txt', 'w')
k = int(input())
s = input()
new_s = []
for c in s:
if c == " ":
new_s.append("-")
else:
new_s.append(c)
# print("".join(new_s))
l = 1
r = int(1e6)
# print("enter line width: ")
# w = int(input())
# print(lines_occupied(new_s, 20))
while l < r:
m = l + (r - l)//2
lines = lines_occupied(new_s, m)
if lines > k:
l = m+1
else:
r = m
a, b = [min(l, m), max(l, m)]
if lines_occupied(new_s, a) <= k:
print(a)
else:
print(b)
#------------------ 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()
``` | instruction | 0 | 81,356 | 6 | 162,712 |
No | output | 1 | 81,356 | 6 | 162,713 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The main city magazine offers its readers an opportunity to publish their ads. The format of the ad should be like this:
There are space-separated non-empty words of lowercase and uppercase Latin letters.
There are hyphen characters '-' in some words, their positions set word wrapping points. Word can include more than one hyphen.
It is guaranteed that there are no adjacent spaces and no adjacent hyphens. No hyphen is adjacent to space. There are no spaces and no hyphens before the first word and after the last word.
When the word is wrapped, the part of the word before hyphen and the hyphen itself stay on current line and the next part of the word is put on the next line. You can also put line break between two words, in that case the space stays on current line. Check notes for better understanding.
The ad can occupy no more that k lines and should have minimal width. The width of the ad is the maximal length of string (letters, spaces and hyphens are counted) in it.
You should write a program that will find minimal width of the ad.
Input
The first line contains number k (1 ≤ k ≤ 105).
The second line contains the text of the ad — non-empty space-separated words of lowercase and uppercase Latin letters and hyphens. Total length of the ad don't exceed 106 characters.
Output
Output minimal width of the ad.
Examples
Input
4
garage for sa-le
Output
7
Input
4
Edu-ca-tion-al Ro-unds are so fun
Output
10
Note
Here all spaces are replaced with dots.
In the first example one of possible results after all word wraps looks like this:
garage.
for.
sa-
le
The second example:
Edu-ca-
tion-al.
Ro-unds.
are.so.fun
Submitted Solution:
```
def check (xs, k, t):
l = 1
tmp = 0
for i in range(len(xs)):
tmp += xs[i]
if(tmp > t):
tmp = xs[i]
l += 1
if(tmp > t):
return False
if l > k:
return False
else:
return True
def binar(xs, k):
up = sum(xs)
down = 0
ans = (up+down)//2
while up != down:
if (check(xs, k, ans) ):
down = ans
ans = (ans+up)//2
else:
up = ans
ans = (ans + down)//2
return ans
k = int(input())
xs = list(map(lambda x: len(list(x)) + 1, input().replace('-', ' ').split()))
xs[-1] -= 1
up = sum(xs)
down = 0
ans = (up+down)//2
while ans != down and ans != up:
## print(" up: " + str(up) + " down: " + str(down) + " ans: " + str(ans) )
if (check(xs, k, ans) ):
up = ans
ans = (ans+down)//2
else:
down = ans
ans = (ans + up)//2 + 1
print(ans)
``` | instruction | 0 | 81,357 | 6 | 162,714 |
No | output | 1 | 81,357 | 6 | 162,715 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The main city magazine offers its readers an opportunity to publish their ads. The format of the ad should be like this:
There are space-separated non-empty words of lowercase and uppercase Latin letters.
There are hyphen characters '-' in some words, their positions set word wrapping points. Word can include more than one hyphen.
It is guaranteed that there are no adjacent spaces and no adjacent hyphens. No hyphen is adjacent to space. There are no spaces and no hyphens before the first word and after the last word.
When the word is wrapped, the part of the word before hyphen and the hyphen itself stay on current line and the next part of the word is put on the next line. You can also put line break between two words, in that case the space stays on current line. Check notes for better understanding.
The ad can occupy no more that k lines and should have minimal width. The width of the ad is the maximal length of string (letters, spaces and hyphens are counted) in it.
You should write a program that will find minimal width of the ad.
Input
The first line contains number k (1 ≤ k ≤ 105).
The second line contains the text of the ad — non-empty space-separated words of lowercase and uppercase Latin letters and hyphens. Total length of the ad don't exceed 106 characters.
Output
Output minimal width of the ad.
Examples
Input
4
garage for sa-le
Output
7
Input
4
Edu-ca-tion-al Ro-unds are so fun
Output
10
Note
Here all spaces are replaced with dots.
In the first example one of possible results after all word wraps looks like this:
garage.
for.
sa-
le
The second example:
Edu-ca-
tion-al.
Ro-unds.
are.so.fun
Submitted Solution:
```
def check (xs, k, t):
l = 1
tmp = 0
for i in range(len(xs)):
tmp += xs[i]
if(tmp > t):
tmp = xs[i]
l += 1
if(tmp > t):
return False
if l > k:
return False
else:
return True
def binar(xs, k):
up = sum(xs)
down = 0
ans = (up+down)//2
while up != down:
if (check(xs, k, ans) ):
down = ans
ans = (ans+up)//2
else:
up = ans
ans = (ans + down)//2
return ans
k = int(input())
xs = list(map(lambda x: len(list(x)) + 1, input().replace('-', ' ').split()))
xs[-1] -= 1
up = sum(xs)
down = 0
ans = (up+down)//2+1
##print(" up: " + str(up) + " down: " + str(down) + " ans: " + str(ans) )
while ans != down and ans != up:
## print(" up: " + str(up) + " down: " + str(down) + " ans: " + str(ans) )
if (check(xs, k, ans) ):
up = ans
ans = (ans+down)//2
else:
down = ans
ans = (ans + up)//2 + 1
print(ans)
``` | instruction | 0 | 81,358 | 6 | 162,716 |
No | output | 1 | 81,358 | 6 | 162,717 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The main city magazine offers its readers an opportunity to publish their ads. The format of the ad should be like this:
There are space-separated non-empty words of lowercase and uppercase Latin letters.
There are hyphen characters '-' in some words, their positions set word wrapping points. Word can include more than one hyphen.
It is guaranteed that there are no adjacent spaces and no adjacent hyphens. No hyphen is adjacent to space. There are no spaces and no hyphens before the first word and after the last word.
When the word is wrapped, the part of the word before hyphen and the hyphen itself stay on current line and the next part of the word is put on the next line. You can also put line break between two words, in that case the space stays on current line. Check notes for better understanding.
The ad can occupy no more that k lines and should have minimal width. The width of the ad is the maximal length of string (letters, spaces and hyphens are counted) in it.
You should write a program that will find minimal width of the ad.
Input
The first line contains number k (1 ≤ k ≤ 105).
The second line contains the text of the ad — non-empty space-separated words of lowercase and uppercase Latin letters and hyphens. Total length of the ad don't exceed 106 characters.
Output
Output minimal width of the ad.
Examples
Input
4
garage for sa-le
Output
7
Input
4
Edu-ca-tion-al Ro-unds are so fun
Output
10
Note
Here all spaces are replaced with dots.
In the first example one of possible results after all word wraps looks like this:
garage.
for.
sa-
le
The second example:
Edu-ca-
tion-al.
Ro-unds.
are.so.fun
Submitted Solution:
```
import sys
#Library Info(ACL for Python/Pypy) -> https://github.com/not522/ac-library-python
def input():
return sys.stdin.readline().rstrip()
DXY = [(0, -1), (1,0), (0, 1), (-1,0)] #L,D,R,Uの順番
def main():
k = int(input())
s = input()
V = []
for elem in s.split(" "):
for v in elem.split("-"):
V.append(len(v) + 1)
l = max(V) - 1 # impossible
r = len(s) #possible
V[-1] -= 1
while r - l > 1:
med = (r + l) // 2
part,cost = 0,0
Q = V.copy()
while Q:
while Q and Q[-1] + cost <= med:
cost += Q.pop()
part += 1
cost = 0
if part <= k:
r = med
else:
l = med
print(r)
return 0
if __name__ == "__main__":
main()
``` | instruction | 0 | 81,359 | 6 | 162,718 |
No | output | 1 | 81,359 | 6 | 162,719 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp came up with a new programming language. There are only two types of statements in it:
* "x := s": assign the variable named x the value s (where s is a string). For example, the statement var := hello assigns the variable named var the value hello. Note that s is the value of a string, not the name of a variable. Between the variable name, the := operator and the string contains exactly one space each.
* "x = a + b": assign the variable named x the concatenation of values of two variables a and b. For example, if the program consists of three statements a := hello, b := world, c = a + b, then the variable c will contain the string helloworld. It is guaranteed that the program is correct and the variables a and b were previously defined. There is exactly one space between the variable names and the = and + operators.
All variable names and strings only consist of lowercase letters of the English alphabet and do not exceed 5 characters.
The result of the program is the number of occurrences of string haha in the string that was written to the variable in the last statement.
Polycarp was very tired while inventing that language. He asks you to implement it. Your task is — for given program statements calculate the number of occurrences of string haha in the last assigned variable.
Input
The first line contains an integer t (1 ≤ t ≤ 10^3). Then t test cases follow.
The first line of each test case contains a single integer n (1 ≤ n ≤ 50) — the number of statements in the program. All variable names and strings are guaranteed to consist only of lowercase letters of the English alphabet and do not exceed 5 characters.
This is followed by n lines describing the statements in the format described above. It is guaranteed that the program is correct.
Output
For each set of input data, output the number of occurrences of the haha substring in the string that was written to the variable in the last statement.
Example
Input
4
6
a := h
b := aha
c = a + b
c = c + c
e = c + c
d = a + c
15
x := haha
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
1
haha := hah
5
haahh := aaaha
ahhhh = haahh + haahh
haahh = haahh + haahh
ahhhh = ahhhh + haahh
ahhaa = haahh + ahhhh
Output
3
32767
0
0
Note
In the first test case the resulting value of d is hhahahaha. | instruction | 0 | 81,982 | 6 | 163,964 |
Tags: data structures, hashing, implementation, matrices, strings
Correct Solution:
```
class Element:
def __init__(self, s=''):
if len(s) >= 6:
self.pref = s[:3]
self.suf = s[-3:]
else:
self.pref = s[:3]
self.suf = s[3:]
self.ans = calc(s)
self.orig = ''
self.len = len(s)
def calc(s: str):
ans = 0
for num, i in enumerate(s):
ans += s[num:num + 4] == 'haha'
return ans
t = int(input())
for _ in range(t):
n = int(input())
a = [input() for i in range(n)]
d = dict()
for i in a:
if ':=' in i:
a1, shit, a2 = i.split()
new = Element(a2)
new.orig = a2
d[a1] = Element(a2)
else:
a1, shit, b1, plus, b2 = i.split()
new = Element()
new.ans = d[b1].ans + d[b2].ans
s = (d[b1].pref + d[b1].suf + d[b2].pref + d[b2].suf)
if len(s) >= 6:
new.pref = s[:3]
new.suf = s[-3:]
else:
new.pref = s[:3]
new.suf = s[3:]
new.ans += calc((d[b1].pref + d[b1].suf)[-3:] + (d[b2].pref + d[b2].suf)[:3])
d[a1] = new
print(d[a[-1].split()[0]].ans)
``` | output | 1 | 81,982 | 6 | 163,965 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp came up with a new programming language. There are only two types of statements in it:
* "x := s": assign the variable named x the value s (where s is a string). For example, the statement var := hello assigns the variable named var the value hello. Note that s is the value of a string, not the name of a variable. Between the variable name, the := operator and the string contains exactly one space each.
* "x = a + b": assign the variable named x the concatenation of values of two variables a and b. For example, if the program consists of three statements a := hello, b := world, c = a + b, then the variable c will contain the string helloworld. It is guaranteed that the program is correct and the variables a and b were previously defined. There is exactly one space between the variable names and the = and + operators.
All variable names and strings only consist of lowercase letters of the English alphabet and do not exceed 5 characters.
The result of the program is the number of occurrences of string haha in the string that was written to the variable in the last statement.
Polycarp was very tired while inventing that language. He asks you to implement it. Your task is — for given program statements calculate the number of occurrences of string haha in the last assigned variable.
Input
The first line contains an integer t (1 ≤ t ≤ 10^3). Then t test cases follow.
The first line of each test case contains a single integer n (1 ≤ n ≤ 50) — the number of statements in the program. All variable names and strings are guaranteed to consist only of lowercase letters of the English alphabet and do not exceed 5 characters.
This is followed by n lines describing the statements in the format described above. It is guaranteed that the program is correct.
Output
For each set of input data, output the number of occurrences of the haha substring in the string that was written to the variable in the last statement.
Example
Input
4
6
a := h
b := aha
c = a + b
c = c + c
e = c + c
d = a + c
15
x := haha
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
1
haha := hah
5
haahh := aaaha
ahhhh = haahh + haahh
haahh = haahh + haahh
ahhhh = ahhhh + haahh
ahhaa = haahh + ahhhh
Output
3
32767
0
0
Note
In the first test case the resulting value of d is hhahahaha. | instruction | 0 | 81,983 | 6 | 163,966 |
Tags: data structures, hashing, implementation, matrices, strings
Correct Solution:
```
# Author : nitish420 --------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
def solve(s):
n=len(s)
cnt=0
for i in range(n-3):
if s[i]=='h' and s[i+1]=='a' and s[i+2]=='h' and s[i+3]=='a':
cnt+=1
return cnt
class string:
count=0
pre=str()
post=str()
def main():
for _ in range(int(input())):
n=int(input())
d={}
last=str()
for _ in range(n):
l=input().split()
last=l[0]
if len(l)==3:
z=string()
z.count=solve(l[2])
z.pre=l[2][:3]
z.post=l[2][-3:]
d[l[0]]=z
else:
x,y=d[l[2]],d[l[4]]
z=string()
z.count=x.count+y.count+solve(x.post+y.pre)
z.pre=(x.pre+y.pre)[:3]
z.post=(x.post+y.post)[-3:]
d[l[0]]=z
print(d[last].count)
#----------------------------------------------------------------------------------------
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = 'x' in file.mode or 'r' not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b'\n') + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode('ascii'))
self.read = lambda: self.buffer.read().decode('ascii')
self.readline = lambda: self.buffer.readline().decode('ascii')
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')
# endregion
if __name__ == '__main__':
main()
``` | output | 1 | 81,983 | 6 | 163,967 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp came up with a new programming language. There are only two types of statements in it:
* "x := s": assign the variable named x the value s (where s is a string). For example, the statement var := hello assigns the variable named var the value hello. Note that s is the value of a string, not the name of a variable. Between the variable name, the := operator and the string contains exactly one space each.
* "x = a + b": assign the variable named x the concatenation of values of two variables a and b. For example, if the program consists of three statements a := hello, b := world, c = a + b, then the variable c will contain the string helloworld. It is guaranteed that the program is correct and the variables a and b were previously defined. There is exactly one space between the variable names and the = and + operators.
All variable names and strings only consist of lowercase letters of the English alphabet and do not exceed 5 characters.
The result of the program is the number of occurrences of string haha in the string that was written to the variable in the last statement.
Polycarp was very tired while inventing that language. He asks you to implement it. Your task is — for given program statements calculate the number of occurrences of string haha in the last assigned variable.
Input
The first line contains an integer t (1 ≤ t ≤ 10^3). Then t test cases follow.
The first line of each test case contains a single integer n (1 ≤ n ≤ 50) — the number of statements in the program. All variable names and strings are guaranteed to consist only of lowercase letters of the English alphabet and do not exceed 5 characters.
This is followed by n lines describing the statements in the format described above. It is guaranteed that the program is correct.
Output
For each set of input data, output the number of occurrences of the haha substring in the string that was written to the variable in the last statement.
Example
Input
4
6
a := h
b := aha
c = a + b
c = c + c
e = c + c
d = a + c
15
x := haha
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
1
haha := hah
5
haahh := aaaha
ahhhh = haahh + haahh
haahh = haahh + haahh
ahhhh = ahhhh + haahh
ahhaa = haahh + ahhhh
Output
3
32767
0
0
Note
In the first test case the resulting value of d is hhahahaha. | instruction | 0 | 81,984 | 6 | 163,968 |
Tags: data structures, hashing, implementation, matrices, strings
Correct Solution:
```
t=int(input())
for _ in range(t):
n=int(input())
d={}
for i in range(n):
s=input()
if ':' in s:
col=s.index(':')
eq=s.index('=')
st=s[0:col-1]
d[st]=[s[eq+2:][:3],s[eq+2:][-3:],s[eq+2:].count('haha')]
#print(d)
#print(cnt)
else:
plus=s.index('+')
eq=s.index('=')
st=s[0:eq-1]
a=s[eq+2:plus-1];b=s[plus+2:]
res=0
#print(d[a],d[b])
if d[a][1].endswith('h') and d[b][0].startswith('aha'):
res+=1
if d[a][1].endswith('ha') and d[b][0].startswith('ha'):
res+=1
if d[a][1].endswith('hah') and d[b][0].startswith('a'):
res+=1
d[st]=[(d[a][0]+d[b][0])[:3],(d[a][1]+d[b][1])[-3:],d[a][2]+d[b][2]+res]
#print(d)
#print(cnt)
if i==n-1:
print(d[st][2])
``` | output | 1 | 81,984 | 6 | 163,969 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp came up with a new programming language. There are only two types of statements in it:
* "x := s": assign the variable named x the value s (where s is a string). For example, the statement var := hello assigns the variable named var the value hello. Note that s is the value of a string, not the name of a variable. Between the variable name, the := operator and the string contains exactly one space each.
* "x = a + b": assign the variable named x the concatenation of values of two variables a and b. For example, if the program consists of three statements a := hello, b := world, c = a + b, then the variable c will contain the string helloworld. It is guaranteed that the program is correct and the variables a and b were previously defined. There is exactly one space between the variable names and the = and + operators.
All variable names and strings only consist of lowercase letters of the English alphabet and do not exceed 5 characters.
The result of the program is the number of occurrences of string haha in the string that was written to the variable in the last statement.
Polycarp was very tired while inventing that language. He asks you to implement it. Your task is — for given program statements calculate the number of occurrences of string haha in the last assigned variable.
Input
The first line contains an integer t (1 ≤ t ≤ 10^3). Then t test cases follow.
The first line of each test case contains a single integer n (1 ≤ n ≤ 50) — the number of statements in the program. All variable names and strings are guaranteed to consist only of lowercase letters of the English alphabet and do not exceed 5 characters.
This is followed by n lines describing the statements in the format described above. It is guaranteed that the program is correct.
Output
For each set of input data, output the number of occurrences of the haha substring in the string that was written to the variable in the last statement.
Example
Input
4
6
a := h
b := aha
c = a + b
c = c + c
e = c + c
d = a + c
15
x := haha
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
1
haha := hah
5
haahh := aaaha
ahhhh = haahh + haahh
haahh = haahh + haahh
ahhhh = ahhhh + haahh
ahhaa = haahh + ahhhh
Output
3
32767
0
0
Note
In the first test case the resulting value of d is hhahahaha. | instruction | 0 | 81,985 | 6 | 163,970 |
Tags: data structures, hashing, implementation, matrices, strings
Correct Solution:
```
import time
def main():
def cnt(s):
ans = 0
for i in range(3, len(s)):
if s[i - 3] == 'h' and s[i - 2] == 'a' and s[i - 1] == 'h' and s[i] == 'a':
ans += 1
return ans
def concat(t1, t2):
mid = t1[2] + t2[0]
return (
t1[0] if len(t1[0]) == 3 else mid[:3],
t1[1] + t2[1] + cnt(mid),
t2[2] if len(t2[2]) == 3 else mid[-3:],
)
t = i_input()
for tt in range(t):
n = i_input()
d = {}
last = ''
for nn in range(n):
c = l_input()
if c[1] == ':=':
d[c[0]] = (c[2][:3], cnt(c[2]), c[2][-3:])
else:
d[c[0]] = concat(d[c[2]], d[c[4]])
last = c[0]
print(d[last][1])
############
def i_input():
return int(input())
def l_input():
return input().split()
def li_input():
return list(map(int, l_input()))
def il_input():
return list(map(int, l_input()))
# endregion
if __name__ == "__main__":
TT = time.time()
main()
# print("\n", time.time() - TT)
``` | output | 1 | 81,985 | 6 | 163,971 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp came up with a new programming language. There are only two types of statements in it:
* "x := s": assign the variable named x the value s (where s is a string). For example, the statement var := hello assigns the variable named var the value hello. Note that s is the value of a string, not the name of a variable. Between the variable name, the := operator and the string contains exactly one space each.
* "x = a + b": assign the variable named x the concatenation of values of two variables a and b. For example, if the program consists of three statements a := hello, b := world, c = a + b, then the variable c will contain the string helloworld. It is guaranteed that the program is correct and the variables a and b were previously defined. There is exactly one space between the variable names and the = and + operators.
All variable names and strings only consist of lowercase letters of the English alphabet and do not exceed 5 characters.
The result of the program is the number of occurrences of string haha in the string that was written to the variable in the last statement.
Polycarp was very tired while inventing that language. He asks you to implement it. Your task is — for given program statements calculate the number of occurrences of string haha in the last assigned variable.
Input
The first line contains an integer t (1 ≤ t ≤ 10^3). Then t test cases follow.
The first line of each test case contains a single integer n (1 ≤ n ≤ 50) — the number of statements in the program. All variable names and strings are guaranteed to consist only of lowercase letters of the English alphabet and do not exceed 5 characters.
This is followed by n lines describing the statements in the format described above. It is guaranteed that the program is correct.
Output
For each set of input data, output the number of occurrences of the haha substring in the string that was written to the variable in the last statement.
Example
Input
4
6
a := h
b := aha
c = a + b
c = c + c
e = c + c
d = a + c
15
x := haha
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
1
haha := hah
5
haahh := aaaha
ahhhh = haahh + haahh
haahh = haahh + haahh
ahhhh = ahhhh + haahh
ahhaa = haahh + ahhhh
Output
3
32767
0
0
Note
In the first test case the resulting value of d is hhahahaha. | instruction | 0 | 81,986 | 6 | 163,972 |
Tags: data structures, hashing, implementation, matrices, strings
Correct Solution:
```
from collections import OrderedDict
def find(s : str) -> int:
# print(s)
cnt = 0
for i in range(len(s)):
if(i + 3 >= len(s)):
break
elif(s[i : i + 4] == "haha"):
cnt += 1
return cnt
def find_duplicate(a : str, b : str) -> int:
cnt = 0
if(a[-1] + b[:3] == "haha"):
cnt += 1
if(a[-2:] + b[:2] == "haha"):
cnt += 1
if(a[-3:] + b[:1] == "haha"):
cnt += 1
# print(a, b, cnt)
return cnt
def solve():
n = int(input())
dict = OrderedDict()
for _ in range(n):
s = input()
s = s.split(" ")
# print(dict)
# print(s)
if(s[1][0] == ":"):
dict[s[0]] = [s[2][:4], s[2][max(len(s[2]) - 4, 0):], find(s[2])]
else:
a = dict[s[2]][0]
b = dict[s[2]][1]
c = dict[s[4]][0]
d = dict[s[4]][1]
if(len(a) < 4 or len(d) < 4):
here = b + c
dict[s[0]] = [here[:4], here[max(len(here) - 4, 0):], find_duplicate(b, c) + dict[s[2]][2] + dict[s[4]][2]]
else:
dict[s[0]] = [a, d, find_duplicate(b, c) + dict[s[2]][2] + dict[s[4]][2]]
item = dict[s[0]][-1]
print(item)
t = int(input())
for _ in range(t):
solve()
``` | output | 1 | 81,986 | 6 | 163,973 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp came up with a new programming language. There are only two types of statements in it:
* "x := s": assign the variable named x the value s (where s is a string). For example, the statement var := hello assigns the variable named var the value hello. Note that s is the value of a string, not the name of a variable. Between the variable name, the := operator and the string contains exactly one space each.
* "x = a + b": assign the variable named x the concatenation of values of two variables a and b. For example, if the program consists of three statements a := hello, b := world, c = a + b, then the variable c will contain the string helloworld. It is guaranteed that the program is correct and the variables a and b were previously defined. There is exactly one space between the variable names and the = and + operators.
All variable names and strings only consist of lowercase letters of the English alphabet and do not exceed 5 characters.
The result of the program is the number of occurrences of string haha in the string that was written to the variable in the last statement.
Polycarp was very tired while inventing that language. He asks you to implement it. Your task is — for given program statements calculate the number of occurrences of string haha in the last assigned variable.
Input
The first line contains an integer t (1 ≤ t ≤ 10^3). Then t test cases follow.
The first line of each test case contains a single integer n (1 ≤ n ≤ 50) — the number of statements in the program. All variable names and strings are guaranteed to consist only of lowercase letters of the English alphabet and do not exceed 5 characters.
This is followed by n lines describing the statements in the format described above. It is guaranteed that the program is correct.
Output
For each set of input data, output the number of occurrences of the haha substring in the string that was written to the variable in the last statement.
Example
Input
4
6
a := h
b := aha
c = a + b
c = c + c
e = c + c
d = a + c
15
x := haha
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
1
haha := hah
5
haahh := aaaha
ahhhh = haahh + haahh
haahh = haahh + haahh
ahhhh = ahhhh + haahh
ahhaa = haahh + ahhhh
Output
3
32767
0
0
Note
In the first test case the resulting value of d is hhahahaha. | instruction | 0 | 81,987 | 6 | 163,974 |
Tags: data structures, hashing, implementation, matrices, strings
Correct Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
# from fractions import *
# from functools import *
from heapq import *
from bisect 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 = 998244353
EPS = 1e-6
def Ceil(a,b): return a//b+int(a%b>0)
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()
def Count(s):
ans = 0
for i in range(len(s)):
if(s[i:i+4] == 'haha'): ans += 1
return ans
for _ in range(Int()):
n = Int()
C = defaultdict(int)
first = defaultdict(str)
last = defaultdict(str)
for i in range(n):
exp = input().split()
x = exp[0]
if(exp[1] == ':='):
val = exp[-1]
C[x] = Count(val)
first[x] = val[:3]
last[x] = val[-3:]
else:
a = exp[2]
b = exp[4]
C[x] = C[a] + C[b] + Count(last[a] + first[b])
val = first[a]
if(len(val) < 3): val = first[a] + first[b]
first[x] = val[:3]
val = last[b]
if(len(val) < 3): val = last[a] + last[b]
last[x] = val[-3:]
print(C[x])
``` | output | 1 | 81,987 | 6 | 163,975 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp came up with a new programming language. There are only two types of statements in it:
* "x := s": assign the variable named x the value s (where s is a string). For example, the statement var := hello assigns the variable named var the value hello. Note that s is the value of a string, not the name of a variable. Between the variable name, the := operator and the string contains exactly one space each.
* "x = a + b": assign the variable named x the concatenation of values of two variables a and b. For example, if the program consists of three statements a := hello, b := world, c = a + b, then the variable c will contain the string helloworld. It is guaranteed that the program is correct and the variables a and b were previously defined. There is exactly one space between the variable names and the = and + operators.
All variable names and strings only consist of lowercase letters of the English alphabet and do not exceed 5 characters.
The result of the program is the number of occurrences of string haha in the string that was written to the variable in the last statement.
Polycarp was very tired while inventing that language. He asks you to implement it. Your task is — for given program statements calculate the number of occurrences of string haha in the last assigned variable.
Input
The first line contains an integer t (1 ≤ t ≤ 10^3). Then t test cases follow.
The first line of each test case contains a single integer n (1 ≤ n ≤ 50) — the number of statements in the program. All variable names and strings are guaranteed to consist only of lowercase letters of the English alphabet and do not exceed 5 characters.
This is followed by n lines describing the statements in the format described above. It is guaranteed that the program is correct.
Output
For each set of input data, output the number of occurrences of the haha substring in the string that was written to the variable in the last statement.
Example
Input
4
6
a := h
b := aha
c = a + b
c = c + c
e = c + c
d = a + c
15
x := haha
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
1
haha := hah
5
haahh := aaaha
ahhhh = haahh + haahh
haahh = haahh + haahh
ahhhh = ahhhh + haahh
ahhaa = haahh + ahhhh
Output
3
32767
0
0
Note
In the first test case the resulting value of d is hhahahaha. | instruction | 0 | 81,988 | 6 | 163,976 |
Tags: data structures, hashing, implementation, matrices, strings
Correct Solution:
```
import sys
input = sys.stdin.readline
def im():
return map(int,input().split())
def ii():
return int(input())
def il():
return list(map(int,input().split()))
def ins():
return input()[:-1]
# s = 'a'
# print(s[-3:])
import re
for _ in range(ii()):
n = ii()
dic = {}
for _ in range(n):
st = ins()
lis = list(st.split(' '))
if lis[1]==':=':
cnt = len(re.findall('(?=haha)',lis[2]))
dic[lis[0]] = [lis[2][:3],lis[2][-3:],cnt]
else:
sf = dic[lis[2]][1]
sl = dic[lis[4]][0]
cnt = len(re.findall('(?=haha)', sf+sl ))
# print(lis[0],cnt,sf+sl)
# if lis[0]=='d':
# print(dic['c'])
cnt += dic[lis[2]][2] + dic[lis[4]][2]
dic[lis[0]] = [(dic[lis[2]][0]+dic[lis[4]][1])[:3],(dic[lis[2]][0]+dic[lis[4]][1])[-3:], cnt]
last = lis[0]
# print(dic)
print(dic[last][2])
``` | output | 1 | 81,988 | 6 | 163,977 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp came up with a new programming language. There are only two types of statements in it:
* "x := s": assign the variable named x the value s (where s is a string). For example, the statement var := hello assigns the variable named var the value hello. Note that s is the value of a string, not the name of a variable. Between the variable name, the := operator and the string contains exactly one space each.
* "x = a + b": assign the variable named x the concatenation of values of two variables a and b. For example, if the program consists of three statements a := hello, b := world, c = a + b, then the variable c will contain the string helloworld. It is guaranteed that the program is correct and the variables a and b were previously defined. There is exactly one space between the variable names and the = and + operators.
All variable names and strings only consist of lowercase letters of the English alphabet and do not exceed 5 characters.
The result of the program is the number of occurrences of string haha in the string that was written to the variable in the last statement.
Polycarp was very tired while inventing that language. He asks you to implement it. Your task is — for given program statements calculate the number of occurrences of string haha in the last assigned variable.
Input
The first line contains an integer t (1 ≤ t ≤ 10^3). Then t test cases follow.
The first line of each test case contains a single integer n (1 ≤ n ≤ 50) — the number of statements in the program. All variable names and strings are guaranteed to consist only of lowercase letters of the English alphabet and do not exceed 5 characters.
This is followed by n lines describing the statements in the format described above. It is guaranteed that the program is correct.
Output
For each set of input data, output the number of occurrences of the haha substring in the string that was written to the variable in the last statement.
Example
Input
4
6
a := h
b := aha
c = a + b
c = c + c
e = c + c
d = a + c
15
x := haha
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
x = x + x
1
haha := hah
5
haahh := aaaha
ahhhh = haahh + haahh
haahh = haahh + haahh
ahhhh = ahhhh + haahh
ahhaa = haahh + ahhhh
Output
3
32767
0
0
Note
In the first test case the resulting value of d is hhahahaha. | instruction | 0 | 81,989 | 6 | 163,978 |
Tags: data structures, hashing, implementation, matrices, strings
Correct Solution:
```
def f(a):
b=0
for i in range(len(a)-3):
if a[i]+a[i+1]+a[i+2]+a[i+3]=='haha':
b+=1
return b
for z in range(int(input())):
b=[]
b1=0
c=0
for y in range(int(input())):
a=input().split()
if len(a)==3:
for i in range(b1):
if b[i][0]==a[0]:
b[i]=[a[0],f(a[2]),a[2][:3],a[2][-3:]]
c=b[i][1]
break
else:
b.append([a[0],f(a[2]),a[2][:3],a[2][-3:]])
c=b[b1][1]
b1+=1
else:
d=[]
e=[]
for i in range(b1):
if b[i][0]==a[2]:
d=b[i]
if b[i][0]==a[4]:
e=b[i]
for i in range(b1):
if b[i][0]==a[0]:
b[i]=[a[0],d[1]+e[1]+f(d[3]+e[2]),str(d[2]+e[3])[:3],str(d[2]+e[3])[-3:]]
c=b[i][1]
break
else:
b.append([a[0],d[1]+e[1]+f(d[3]+e[2]),str(d[2]+e[3])[:3],str(d[2]+e[3])[-3:]])
c=b[b1][1]
b1+=1
print(c)
``` | output | 1 | 81,989 | 6 | 163,979 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Some dwarves that are finishing the StUDY (State University for Dwarven Youngsters) Bachelor courses, have been told "no genome, no degree". That means that all dwarves should write a thesis on genome. Dwarven genome is far from simple. It is represented by a string that consists of lowercase Latin letters.
Dwarf Misha has already chosen the subject for his thesis: determining by two dwarven genomes, whether they belong to the same race. Two dwarves belong to the same race if we can swap two characters in the first dwarf's genome and get the second dwarf's genome as a result. Help Dwarf Misha and find out whether two gnomes belong to the same race or not.
Input
The first line contains the first dwarf's genome: a non-empty string, consisting of lowercase Latin letters.
The second line contains the second dwarf's genome: a non-empty string, consisting of lowercase Latin letters.
The number of letters in each genome doesn't exceed 105. It is guaranteed that the strings that correspond to the genomes are different. The given genomes may have different length.
Output
Print "YES", if the dwarves belong to the same race. Otherwise, print "NO".
Examples
Input
ab
ba
Output
YES
Input
aa
ab
Output
NO
Note
* First example: you can simply swap two letters in string "ab". So we get "ba".
* Second example: we can't change string "aa" into string "ab", because "aa" does not contain letter "b". | instruction | 0 | 81,998 | 6 | 163,996 |
Tags: implementation, strings
Correct Solution:
```
s = input()
t = input()
print(['NO', 'YES'][sorted(s) == sorted(t) and sum([1 for i, j in zip(s, t) if i != j]) == 2])
``` | output | 1 | 81,998 | 6 | 163,997 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Some dwarves that are finishing the StUDY (State University for Dwarven Youngsters) Bachelor courses, have been told "no genome, no degree". That means that all dwarves should write a thesis on genome. Dwarven genome is far from simple. It is represented by a string that consists of lowercase Latin letters.
Dwarf Misha has already chosen the subject for his thesis: determining by two dwarven genomes, whether they belong to the same race. Two dwarves belong to the same race if we can swap two characters in the first dwarf's genome and get the second dwarf's genome as a result. Help Dwarf Misha and find out whether two gnomes belong to the same race or not.
Input
The first line contains the first dwarf's genome: a non-empty string, consisting of lowercase Latin letters.
The second line contains the second dwarf's genome: a non-empty string, consisting of lowercase Latin letters.
The number of letters in each genome doesn't exceed 105. It is guaranteed that the strings that correspond to the genomes are different. The given genomes may have different length.
Output
Print "YES", if the dwarves belong to the same race. Otherwise, print "NO".
Examples
Input
ab
ba
Output
YES
Input
aa
ab
Output
NO
Note
* First example: you can simply swap two letters in string "ab". So we get "ba".
* Second example: we can't change string "aa" into string "ab", because "aa" does not contain letter "b". | instruction | 0 | 81,999 | 6 | 163,998 |
Tags: implementation, strings
Correct Solution:
```
s = input()
t = input()
if len(s)!=len(t):
print('NO')
else:
mistakes = []
for i in range(len(s)):
if s[i]!=t[i]:
mistakes.append(i)
if len(mistakes)==0:
if len(set(s))==len(s):
print('NO')
else:
print('YES')
elif len(mistakes)==2:
if s[mistakes[0]]==t[mistakes[1]] and s[mistakes[1]]==t[mistakes[0]]:
print('YES')
else:
print('NO')
else:
print('NO')
``` | output | 1 | 81,999 | 6 | 163,999 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Some dwarves that are finishing the StUDY (State University for Dwarven Youngsters) Bachelor courses, have been told "no genome, no degree". That means that all dwarves should write a thesis on genome. Dwarven genome is far from simple. It is represented by a string that consists of lowercase Latin letters.
Dwarf Misha has already chosen the subject for his thesis: determining by two dwarven genomes, whether they belong to the same race. Two dwarves belong to the same race if we can swap two characters in the first dwarf's genome and get the second dwarf's genome as a result. Help Dwarf Misha and find out whether two gnomes belong to the same race or not.
Input
The first line contains the first dwarf's genome: a non-empty string, consisting of lowercase Latin letters.
The second line contains the second dwarf's genome: a non-empty string, consisting of lowercase Latin letters.
The number of letters in each genome doesn't exceed 105. It is guaranteed that the strings that correspond to the genomes are different. The given genomes may have different length.
Output
Print "YES", if the dwarves belong to the same race. Otherwise, print "NO".
Examples
Input
ab
ba
Output
YES
Input
aa
ab
Output
NO
Note
* First example: you can simply swap two letters in string "ab". So we get "ba".
* Second example: we can't change string "aa" into string "ab", because "aa" does not contain letter "b". | instruction | 0 | 82,000 | 6 | 164,000 |
Tags: implementation, strings
Correct Solution:
```
def check(genomeA , genomeB):
n = len(genomeA)
m = len(genomeB)
index = list()
if n != m:
return "NO"
result = "YES"
count = 0
if genomeA == genomeB:
return result
else:
for i in range(n):
if genomeA[i] != genomeB[i]:
count += 1
index.append(i)
if count == 3 and n > 2:
result = "NO"
break
if n > 2 and count == 1:
result = "NO"
if n <= 2 and count != 2:
result = "NO"
if result == "YES":
first = index[0]
second = index[1]
temp = genomeA[:first] + genomeA[second] + genomeA[first + 1:second] + genomeA[first] + genomeA[second + 1:]
if temp != genomeB:
result = "NO"
return result
if __name__ == "__main__":
genomeA = input().rstrip()
genomeB = input().rstrip()
print (check(genomeA , genomeB))
``` | output | 1 | 82,000 | 6 | 164,001 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Some dwarves that are finishing the StUDY (State University for Dwarven Youngsters) Bachelor courses, have been told "no genome, no degree". That means that all dwarves should write a thesis on genome. Dwarven genome is far from simple. It is represented by a string that consists of lowercase Latin letters.
Dwarf Misha has already chosen the subject for his thesis: determining by two dwarven genomes, whether they belong to the same race. Two dwarves belong to the same race if we can swap two characters in the first dwarf's genome and get the second dwarf's genome as a result. Help Dwarf Misha and find out whether two gnomes belong to the same race or not.
Input
The first line contains the first dwarf's genome: a non-empty string, consisting of lowercase Latin letters.
The second line contains the second dwarf's genome: a non-empty string, consisting of lowercase Latin letters.
The number of letters in each genome doesn't exceed 105. It is guaranteed that the strings that correspond to the genomes are different. The given genomes may have different length.
Output
Print "YES", if the dwarves belong to the same race. Otherwise, print "NO".
Examples
Input
ab
ba
Output
YES
Input
aa
ab
Output
NO
Note
* First example: you can simply swap two letters in string "ab". So we get "ba".
* Second example: we can't change string "aa" into string "ab", because "aa" does not contain letter "b". | instruction | 0 | 82,001 | 6 | 164,002 |
Tags: implementation, strings
Correct Solution:
```
import collections
s1 = input()
s2 = input()
c1 = collections.Counter(s1)
c2 = collections.Counter(s2)
c = 0
s1 = list(s1)
s2 = list(s2)
if(len(c1) == len(c2)):
for i in c1:
if c1[i] != c2[i]:
print('NO')
break
else:
for i in range(len(s1)):
if s1[i] != s2[i] and c <=2 :
s1[i] = s2[i]
c+=1
s1 = "".join(s1)
s2 = "".join(s2)
if(s1 == s2):
print('YES')
else:
print('NO')
else:
print('NO')
``` | output | 1 | 82,001 | 6 | 164,003 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Some dwarves that are finishing the StUDY (State University for Dwarven Youngsters) Bachelor courses, have been told "no genome, no degree". That means that all dwarves should write a thesis on genome. Dwarven genome is far from simple. It is represented by a string that consists of lowercase Latin letters.
Dwarf Misha has already chosen the subject for his thesis: determining by two dwarven genomes, whether they belong to the same race. Two dwarves belong to the same race if we can swap two characters in the first dwarf's genome and get the second dwarf's genome as a result. Help Dwarf Misha and find out whether two gnomes belong to the same race or not.
Input
The first line contains the first dwarf's genome: a non-empty string, consisting of lowercase Latin letters.
The second line contains the second dwarf's genome: a non-empty string, consisting of lowercase Latin letters.
The number of letters in each genome doesn't exceed 105. It is guaranteed that the strings that correspond to the genomes are different. The given genomes may have different length.
Output
Print "YES", if the dwarves belong to the same race. Otherwise, print "NO".
Examples
Input
ab
ba
Output
YES
Input
aa
ab
Output
NO
Note
* First example: you can simply swap two letters in string "ab". So we get "ba".
* Second example: we can't change string "aa" into string "ab", because "aa" does not contain letter "b". | instruction | 0 | 82,002 | 6 | 164,004 |
Tags: implementation, strings
Correct Solution:
```
s1=input()
s2=input()
if len(s1)!=len(s2):
print("NO")
else:
lens1 = len(s1)
s = []
ans = 0
for i in range(lens1):
if s1[i] != s2[i]:
ans += 1
s.append(list((s1[i], s2[i])))
if ans != 2:
print('NO')
else:
if s[0][1] == s[1][0] and s[0][0] == s[1][1]:
print('YES')
else:
print('NO')
``` | output | 1 | 82,002 | 6 | 164,005 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Some dwarves that are finishing the StUDY (State University for Dwarven Youngsters) Bachelor courses, have been told "no genome, no degree". That means that all dwarves should write a thesis on genome. Dwarven genome is far from simple. It is represented by a string that consists of lowercase Latin letters.
Dwarf Misha has already chosen the subject for his thesis: determining by two dwarven genomes, whether they belong to the same race. Two dwarves belong to the same race if we can swap two characters in the first dwarf's genome and get the second dwarf's genome as a result. Help Dwarf Misha and find out whether two gnomes belong to the same race or not.
Input
The first line contains the first dwarf's genome: a non-empty string, consisting of lowercase Latin letters.
The second line contains the second dwarf's genome: a non-empty string, consisting of lowercase Latin letters.
The number of letters in each genome doesn't exceed 105. It is guaranteed that the strings that correspond to the genomes are different. The given genomes may have different length.
Output
Print "YES", if the dwarves belong to the same race. Otherwise, print "NO".
Examples
Input
ab
ba
Output
YES
Input
aa
ab
Output
NO
Note
* First example: you can simply swap two letters in string "ab". So we get "ba".
* Second example: we can't change string "aa" into string "ab", because "aa" does not contain letter "b". | instruction | 0 | 82,003 | 6 | 164,006 |
Tags: implementation, strings
Correct Solution:
```
s1 = input()
s2 = input()
if len(s1) != len(s2):
print('NO')
quit(0)
if s1 == s2:
print('YES')
quit(0)
l = len(s1)
m = []
for k in range(l):
if s1[k] != s2[k]:
m.append(k)
if len(m) != 2:
print('NO')
quit(0)
if s1[m[0]] == s2[m[1]] and s1[m[1]] == s2[m[0]]:
print('YES')
quit(0)
print('NO')
``` | output | 1 | 82,003 | 6 | 164,007 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Some dwarves that are finishing the StUDY (State University for Dwarven Youngsters) Bachelor courses, have been told "no genome, no degree". That means that all dwarves should write a thesis on genome. Dwarven genome is far from simple. It is represented by a string that consists of lowercase Latin letters.
Dwarf Misha has already chosen the subject for his thesis: determining by two dwarven genomes, whether they belong to the same race. Two dwarves belong to the same race if we can swap two characters in the first dwarf's genome and get the second dwarf's genome as a result. Help Dwarf Misha and find out whether two gnomes belong to the same race or not.
Input
The first line contains the first dwarf's genome: a non-empty string, consisting of lowercase Latin letters.
The second line contains the second dwarf's genome: a non-empty string, consisting of lowercase Latin letters.
The number of letters in each genome doesn't exceed 105. It is guaranteed that the strings that correspond to the genomes are different. The given genomes may have different length.
Output
Print "YES", if the dwarves belong to the same race. Otherwise, print "NO".
Examples
Input
ab
ba
Output
YES
Input
aa
ab
Output
NO
Note
* First example: you can simply swap two letters in string "ab". So we get "ba".
* Second example: we can't change string "aa" into string "ab", because "aa" does not contain letter "b". | instruction | 0 | 82,004 | 6 | 164,008 |
Tags: implementation, strings
Correct Solution:
```
s = input()
st = input()
d_1 = []
d_2 = []
l1 = len(s)
l2 = len(st)
if l1 != l2:
print("NO")
exit()
for i in range(l1):
if s[i] != st[i]:
if len(d_1) + 1 > 2:
print("NO")
exit()
d_1.append(s[i])
d_2.append(st[i])
d_1.sort()
d_2.sort()
if len(d_1) == 2 and d_1 == d_2:
print("YES")
else:
print("NO")
``` | output | 1 | 82,004 | 6 | 164,009 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Some dwarves that are finishing the StUDY (State University for Dwarven Youngsters) Bachelor courses, have been told "no genome, no degree". That means that all dwarves should write a thesis on genome. Dwarven genome is far from simple. It is represented by a string that consists of lowercase Latin letters.
Dwarf Misha has already chosen the subject for his thesis: determining by two dwarven genomes, whether they belong to the same race. Two dwarves belong to the same race if we can swap two characters in the first dwarf's genome and get the second dwarf's genome as a result. Help Dwarf Misha and find out whether two gnomes belong to the same race or not.
Input
The first line contains the first dwarf's genome: a non-empty string, consisting of lowercase Latin letters.
The second line contains the second dwarf's genome: a non-empty string, consisting of lowercase Latin letters.
The number of letters in each genome doesn't exceed 105. It is guaranteed that the strings that correspond to the genomes are different. The given genomes may have different length.
Output
Print "YES", if the dwarves belong to the same race. Otherwise, print "NO".
Examples
Input
ab
ba
Output
YES
Input
aa
ab
Output
NO
Note
* First example: you can simply swap two letters in string "ab". So we get "ba".
* Second example: we can't change string "aa" into string "ab", because "aa" does not contain letter "b". | instruction | 0 | 82,005 | 6 | 164,010 |
Tags: implementation, strings
Correct Solution:
```
n=input()
m=input()
l=[]
s=""
if len(n)!=len(m):
print("NO")
exit()
for x in range(len(n)):
if n[x]!=m[x]:
l.append(x)
if len(l)>2:
print("NO")
exit()
if len(l)==2:
s=s+n[:l[0]]+n[l[1]]+n[l[0]+1:l[1]]+n[l[0]]+n[l[1]+1:]
if s==m: print("YES")
else: print("NO")
``` | output | 1 | 82,005 | 6 | 164,011 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some dwarves that are finishing the StUDY (State University for Dwarven Youngsters) Bachelor courses, have been told "no genome, no degree". That means that all dwarves should write a thesis on genome. Dwarven genome is far from simple. It is represented by a string that consists of lowercase Latin letters.
Dwarf Misha has already chosen the subject for his thesis: determining by two dwarven genomes, whether they belong to the same race. Two dwarves belong to the same race if we can swap two characters in the first dwarf's genome and get the second dwarf's genome as a result. Help Dwarf Misha and find out whether two gnomes belong to the same race or not.
Input
The first line contains the first dwarf's genome: a non-empty string, consisting of lowercase Latin letters.
The second line contains the second dwarf's genome: a non-empty string, consisting of lowercase Latin letters.
The number of letters in each genome doesn't exceed 105. It is guaranteed that the strings that correspond to the genomes are different. The given genomes may have different length.
Output
Print "YES", if the dwarves belong to the same race. Otherwise, print "NO".
Examples
Input
ab
ba
Output
YES
Input
aa
ab
Output
NO
Note
* First example: you can simply swap two letters in string "ab". So we get "ba".
* Second example: we can't change string "aa" into string "ab", because "aa" does not contain letter "b".
Submitted Solution:
```
string1 = input("")
dictionary1 = {}
string2 = input("")
dictionary2 = {}
if(len(string1) != len(string2)):
ans = "NO"
else:
for letter in string1:
if letter in dictionary1:
dictionary1[letter] += 1
else:
dictionary1[letter] = 1
for letter in string2:
if letter in dictionary2:
dictionary2[letter] += 1
else:
dictionary2[letter] = 1
if(dictionary1 == dictionary2):
ans = "YES"
else:
ans = "NO"
print(ans)
``` | instruction | 0 | 82,012 | 6 | 164,024 |
No | output | 1 | 82,012 | 6 | 164,025 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Capitalization is writing a word with its first letter as a capital letter. Your task is to capitalize the given word.
Note, that during capitalization all the letters except the first one remains unchanged.
Input
A single line contains a non-empty word. This word consists of lowercase and uppercase English letters. The length of the word will not exceed 103.
Output
Output the given word after capitalization.
Examples
Input
ApPLe
Output
ApPLe
Input
konjac
Output
Konjac | instruction | 0 | 82,031 | 6 | 164,062 |
Tags: implementation, strings
Correct Solution:
```
L = input()
P = L[0].upper()
F = L[1:]
G = P + F
print (G)
``` | output | 1 | 82,031 | 6 | 164,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Capitalization is writing a word with its first letter as a capital letter. Your task is to capitalize the given word.
Note, that during capitalization all the letters except the first one remains unchanged.
Input
A single line contains a non-empty word. This word consists of lowercase and uppercase English letters. The length of the word will not exceed 103.
Output
Output the given word after capitalization.
Examples
Input
ApPLe
Output
ApPLe
Input
konjac
Output
Konjac | instruction | 0 | 82,032 | 6 | 164,064 |
Tags: implementation, strings
Correct Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Sep 29 10:28:00 2020
@author: apple
"""
a=list(input())
a[0]=str.upper(a[0])
for i in range(0,len(a)):
print(a[i],end='')
``` | output | 1 | 82,032 | 6 | 164,065 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Capitalization is writing a word with its first letter as a capital letter. Your task is to capitalize the given word.
Note, that during capitalization all the letters except the first one remains unchanged.
Input
A single line contains a non-empty word. This word consists of lowercase and uppercase English letters. The length of the word will not exceed 103.
Output
Output the given word after capitalization.
Examples
Input
ApPLe
Output
ApPLe
Input
konjac
Output
Konjac | instruction | 0 | 82,033 | 6 | 164,066 |
Tags: implementation, strings
Correct Solution:
```
word=input();
if word[0]>"Z":
print(chr(ord(word[0])-32)+word[1:len(word)]);
else:
print(word);
``` | output | 1 | 82,033 | 6 | 164,067 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Capitalization is writing a word with its first letter as a capital letter. Your task is to capitalize the given word.
Note, that during capitalization all the letters except the first one remains unchanged.
Input
A single line contains a non-empty word. This word consists of lowercase and uppercase English letters. The length of the word will not exceed 103.
Output
Output the given word after capitalization.
Examples
Input
ApPLe
Output
ApPLe
Input
konjac
Output
Konjac | instruction | 0 | 82,034 | 6 | 164,068 |
Tags: implementation, strings
Correct Solution:
```
a=input()
b=a[0].upper()
print(a.replace(a[0],b,1))
``` | output | 1 | 82,034 | 6 | 164,069 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Capitalization is writing a word with its first letter as a capital letter. Your task is to capitalize the given word.
Note, that during capitalization all the letters except the first one remains unchanged.
Input
A single line contains a non-empty word. This word consists of lowercase and uppercase English letters. The length of the word will not exceed 103.
Output
Output the given word after capitalization.
Examples
Input
ApPLe
Output
ApPLe
Input
konjac
Output
Konjac | instruction | 0 | 82,035 | 6 | 164,070 |
Tags: implementation, strings
Correct Solution:
```
def capitalize(c):
if ord(c) >= 97 and ord(c) <= 122:
return chr(ord(c) - 32)
return c
word = input()
word_captitalized = ""
first_word = True
for c in word:
if first_word:
word_captitalized += capitalize(c)
first_word = False
else:
word_captitalized += c
print(word_captitalized)
``` | output | 1 | 82,035 | 6 | 164,071 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Capitalization is writing a word with its first letter as a capital letter. Your task is to capitalize the given word.
Note, that during capitalization all the letters except the first one remains unchanged.
Input
A single line contains a non-empty word. This word consists of lowercase and uppercase English letters. The length of the word will not exceed 103.
Output
Output the given word after capitalization.
Examples
Input
ApPLe
Output
ApPLe
Input
konjac
Output
Konjac | instruction | 0 | 82,036 | 6 | 164,072 |
Tags: implementation, strings
Correct Solution:
```
x = input()
a = x[1:]
o = x.capitalize()
w = o[0] + a
print(w)
``` | output | 1 | 82,036 | 6 | 164,073 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Capitalization is writing a word with its first letter as a capital letter. Your task is to capitalize the given word.
Note, that during capitalization all the letters except the first one remains unchanged.
Input
A single line contains a non-empty word. This word consists of lowercase and uppercase English letters. The length of the word will not exceed 103.
Output
Output the given word after capitalization.
Examples
Input
ApPLe
Output
ApPLe
Input
konjac
Output
Konjac | instruction | 0 | 82,037 | 6 | 164,074 |
Tags: implementation, strings
Correct Solution:
```
def s():
stri = input()
if ord(stri[0])>90:
stri = chr(ord(stri[0])-32)+stri[1:]
print(stri)
s()
``` | output | 1 | 82,037 | 6 | 164,075 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Capitalization is writing a word with its first letter as a capital letter. Your task is to capitalize the given word.
Note, that during capitalization all the letters except the first one remains unchanged.
Input
A single line contains a non-empty word. This word consists of lowercase and uppercase English letters. The length of the word will not exceed 103.
Output
Output the given word after capitalization.
Examples
Input
ApPLe
Output
ApPLe
Input
konjac
Output
Konjac | instruction | 0 | 82,038 | 6 | 164,076 |
Tags: implementation, strings
Correct Solution:
```
import sys
s=sys.stdin.readline().strip()
print(s[0].upper()+s[1:])
``` | output | 1 | 82,038 | 6 | 164,077 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given the string s of length n and the numbers p, q. Split the string s to pieces of length p and q.
For example, the string "Hello" for p = 2, q = 3 can be split to the two strings "Hel" and "lo" or to the two strings "He" and "llo".
Note it is allowed to split the string s to the strings only of length p or to the strings only of length q (see the second sample test).
Input
The first line contains three positive integers n, p, q (1 ≤ p, q ≤ n ≤ 100).
The second line contains the string s consists of lowercase and uppercase latin letters and digits.
Output
If it's impossible to split the string s to the strings of length p and q print the only number "-1".
Otherwise in the first line print integer k — the number of strings in partition of s.
Each of the next k lines should contain the strings in partition. Each string should be of the length p or q. The string should be in order of their appearing in string s — from left to right.
If there are several solutions print any of them.
Examples
Input
5 2 3
Hello
Output
2
He
llo
Input
10 9 5
Codeforces
Output
2
Codef
orces
Input
6 4 5
Privet
Output
-1
Input
8 1 1
abacabac
Output
8
a
b
a
c
a
b
a
c | instruction | 0 | 82,162 | 6 | 164,324 |
Tags: brute force, implementation, strings
Correct Solution:
```
def calc(n, p, q, s):
#pWords is number of words in p
#qWords is number of words in q
for totalPCharacters in range(0 , n+1, p):
if (n - (totalPCharacters)) % q == 0:
pWords = int(totalPCharacters / p)
qWords = int((n - (p * pWords)) / q)
totalQCharacters = q * qWords
print(pWords + qWords)
for i in range(0,totalPCharacters,p):
print(s[i:i+p])
for i in range(totalPCharacters,n,q):
print(s[i:i+q])
return
print(-1)
if __name__ == "__main__":
npq = [int(x) for x in input().split()]
s = input()
n = npq[0]
p = npq[1]
q = npq[2]
calc(n, p, q, s)
``` | output | 1 | 82,162 | 6 | 164,325 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.