message
stringlengths 2
23.8k
| message_type
stringclasses 2
values | message_id
int64 0
1
| conversation_id
int64 97
109k
| cluster
float64 0
0
| __index_level_0__
int64 194
217k
|
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little penguin Polo adores strings. But most of all he adores strings of length n.
One day he wanted to find a string that meets the following conditions:
1. The string consists of n lowercase English letters (that is, the string's length equals n), exactly k of these letters are distinct.
2. No two neighbouring letters of a string coincide; that is, if we represent a string as s = s1s2... sn, then the following inequality holds, si ≠ si + 1(1 ≤ i < n).
3. Among all strings that meet points 1 and 2, the required string is lexicographically smallest.
Help him find such string or state that such string doesn't exist.
String x = x1x2... xp is lexicographically less than string y = y1y2... yq, if either p < q and x1 = y1, x2 = y2, ... , xp = yp, or there is such number r (r < p, r < q), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1. The characters of the strings are compared by their ASCII codes.
Input
A single line contains two positive integers n and k (1 ≤ n ≤ 106, 1 ≤ k ≤ 26) — the string's length and the number of distinct letters.
Output
In a single line print the required string. If there isn't such string, print "-1" (without the quotes).
Examples
Input
7 4
Output
ababacd
Input
4 7
Output
-1
Submitted Solution:
```
n,k = map(int,input().split())
if n<k:
print(-1)
else:
L = [chr(ord('a') + 2 + i) for i in range(k)]
end = "".join(L)
s = 'ab'*((n-k)//2)
if (n-k)%2 == 0:
print(s + end)
else:
print(s + 'a' + end)
```
|
instruction
| 0
| 107,319
| 0
| 214,638
|
No
|
output
| 1
| 107,319
| 0
| 214,639
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little penguin Polo adores strings. But most of all he adores strings of length n.
One day he wanted to find a string that meets the following conditions:
1. The string consists of n lowercase English letters (that is, the string's length equals n), exactly k of these letters are distinct.
2. No two neighbouring letters of a string coincide; that is, if we represent a string as s = s1s2... sn, then the following inequality holds, si ≠ si + 1(1 ≤ i < n).
3. Among all strings that meet points 1 and 2, the required string is lexicographically smallest.
Help him find such string or state that such string doesn't exist.
String x = x1x2... xp is lexicographically less than string y = y1y2... yq, if either p < q and x1 = y1, x2 = y2, ... , xp = yp, or there is such number r (r < p, r < q), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1. The characters of the strings are compared by their ASCII codes.
Input
A single line contains two positive integers n and k (1 ≤ n ≤ 106, 1 ≤ k ≤ 26) — the string's length and the number of distinct letters.
Output
In a single line print the required string. If there isn't such string, print "-1" (without the quotes).
Examples
Input
7 4
Output
ababacd
Input
4 7
Output
-1
Submitted Solution:
```
n,k=map(int,input().split())
if n<k:
print(-1)
exit()
if n==k:
ans=[chr(i+97) for i in range(k)]
print(*ans,sep='')
exit()
rem=k-2
ans="ab"*(n//2)+"ab"[:n%2]
ans=list(ans)
#print(ans)
c=99
for i in range(n-rem,n):
ans[i]=chr(c)
c+=1
print(*ans,sep='')
```
|
instruction
| 0
| 107,320
| 0
| 214,640
|
No
|
output
| 1
| 107,320
| 0
| 214,641
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little penguin Polo adores strings. But most of all he adores strings of length n.
One day he wanted to find a string that meets the following conditions:
1. The string consists of n lowercase English letters (that is, the string's length equals n), exactly k of these letters are distinct.
2. No two neighbouring letters of a string coincide; that is, if we represent a string as s = s1s2... sn, then the following inequality holds, si ≠ si + 1(1 ≤ i < n).
3. Among all strings that meet points 1 and 2, the required string is lexicographically smallest.
Help him find such string or state that such string doesn't exist.
String x = x1x2... xp is lexicographically less than string y = y1y2... yq, if either p < q and x1 = y1, x2 = y2, ... , xp = yp, or there is such number r (r < p, r < q), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1. The characters of the strings are compared by their ASCII codes.
Input
A single line contains two positive integers n and k (1 ≤ n ≤ 106, 1 ≤ k ≤ 26) — the string's length and the number of distinct letters.
Output
In a single line print the required string. If there isn't such string, print "-1" (without the quotes).
Examples
Input
7 4
Output
ababacd
Input
4 7
Output
-1
Submitted Solution:
```
def arr_inp():
return [int(x) for x in stdin.readline().split()]
def flip(x):
if chr(x) == 'a':
return ord('b')
else:
return ord('a')
from sys import stdin
n, k = arr_inp()
if k > n or (k == 1 and n > 1):
print(-1)
else:
ans, a = '', ord('a')
for i in range(n):
if i >= n - (k - 2):
a += 1
ans += chr(a)
else:
ans += chr(a)
a = flip(a)
print(ans)
```
|
instruction
| 0
| 107,321
| 0
| 214,642
|
No
|
output
| 1
| 107,321
| 0
| 214,643
|
Provide a correct Python 3 solution for this coding contest problem.
There are N strings of lowercase alphabet only. The i-th string is S_i. Every string is unique.
Provide answers for the Q queries below. The i-th query has the following format:
Query: An integer k_i and a string p_{i,1}p_{i,2}...p_{i,26} that results from permuting {`a`,`b`,...,`z`} are given. Output the sequence of the string S_{k_i} among the N strings in lexicographical order when the literal sequence is p_{i,1}<p_{i,2}<...<p_{i,26}.
Constraints
* 1 ≦ N,Q ≦ 100000
* 1 ≦ |S_i| (1 ≦ i ≦ N)
* S_i (1 ≦ i ≦ N) is a string of lowercase alphabet.
* The sum of |S_i| is no more than 400000.
* Every S_i is unique.
* 1 ≦ k_i ≦ N (1 ≦ i ≦ Q)
* For all 1 ≦ i ≦ Q, p_{i,1}p_{i,2}...p_{i,26} is a permutation of `abcd...z`.
Input
Inputs are provided from standard inputs in the following form.
N
S_1
:
S_N
Q
k_1 p_{1,1}p_{1,2}...p_{1,26}
:
k_Q p_{Q,1}p_{Q,2}...p_{Q,26}
Output
Output Q lines.
On line i, for the i-th query, output an integer indicating the sequence of the string S_{k_i} among the N strings in lexicographical order.
Examples
Input
5
aa
abbaa
abbba
aaab
aaaaaba
5
1 abcdefghijklmnopqrstuvwxyz
2 bacdefghijklmnopqrstuvwxyz
3 abcdefghijklmnopqrstuvwxyz
4 bacdefghijklmnopqrstuvwxyz
5 abcdefghijklmnopqrstuvwxyz
Output
1
2
5
4
2
Input
8
abrakatabra
abadaba
abracadabra
atcoder
grand
contest
ababa
a
6
3 abcdefghijklmnopqrstuvwxyz
6 qwertyuiopasdfghjklzxcvbnm
8 poiuytrewqlkjhgfdsamnbvcxz
2 qazwsxedcrfvtgbyhnujmikolp
1 plokmijnuhbygvtfcrdxeszwaq
4 mnbvcxzasdfghjklpoiuytrewq
Output
4
8
2
3
4
7
|
instruction
| 0
| 107,760
| 0
| 215,520
|
"Correct Solution:
```
# 文字列の問題で、同じような文字列をまとめたいので、
# どう考えても Trie を使いたい気持ちになる
# あとは適当にやったらなんとかなった
# 1100 点の割には簡単っぽい
class TrieNode:
def __init__(self):
self.child = {}
self.count = 0 # 自身を含めた部分木の大きさ
class Trie:
def __init__(self):
self.root = TrieNode()
def add(self, s):
node = self.root
node.count += 1
for c in s:
c = ord(c) - 97
if c not in node.child:
node.child[c] = TrieNode()
node = node.child[c]
node.count += 1
node.child[26] = TrieNode()
node.child[26].count += 1
def query(self, s):
res = [[0]*27 for _ in range(26)]
node = self.root
for c in s:
c = ord(c) - 97
res_c = res[c]
for i, child in node.child.items():
res_c[i] += child.count
node = node.child[c]
return res
from itertools import groupby
import sys
input = sys.stdin.readline
N = int(input())
S = [input()[:-1] for _ in range(N)]
trie = Trie()
for s in S:
trie.add(s)
Q = int(input())
KP = [input().split() for _ in range(Q)]
Ans = [-1] * Q
Idx_Q = sorted(range(Q), key=lambda x: KP[x][0])
for v, g in groupby(Idx_Q, key=lambda x: KP[x][0]):
K = int(v) - 1
L_K = trie.query(S[K])
for idx in g:
_, P = KP[idx]
P = [ord(c) - 97 for c in P]
ans = 1
for i, pi in enumerate(P):
for pj in P[:i]:
ans += L_K[pi][pj]
ans += L_K[pi][26]
Ans[idx] = ans
print("\n".join(map(str, Ans)))
```
|
output
| 1
| 107,760
| 0
| 215,521
|
Provide a correct Python 3 solution for this coding contest problem.
There are N strings of lowercase alphabet only. The i-th string is S_i. Every string is unique.
Provide answers for the Q queries below. The i-th query has the following format:
Query: An integer k_i and a string p_{i,1}p_{i,2}...p_{i,26} that results from permuting {`a`,`b`,...,`z`} are given. Output the sequence of the string S_{k_i} among the N strings in lexicographical order when the literal sequence is p_{i,1}<p_{i,2}<...<p_{i,26}.
Constraints
* 1 ≦ N,Q ≦ 100000
* 1 ≦ |S_i| (1 ≦ i ≦ N)
* S_i (1 ≦ i ≦ N) is a string of lowercase alphabet.
* The sum of |S_i| is no more than 400000.
* Every S_i is unique.
* 1 ≦ k_i ≦ N (1 ≦ i ≦ Q)
* For all 1 ≦ i ≦ Q, p_{i,1}p_{i,2}...p_{i,26} is a permutation of `abcd...z`.
Input
Inputs are provided from standard inputs in the following form.
N
S_1
:
S_N
Q
k_1 p_{1,1}p_{1,2}...p_{1,26}
:
k_Q p_{Q,1}p_{Q,2}...p_{Q,26}
Output
Output Q lines.
On line i, for the i-th query, output an integer indicating the sequence of the string S_{k_i} among the N strings in lexicographical order.
Examples
Input
5
aa
abbaa
abbba
aaab
aaaaaba
5
1 abcdefghijklmnopqrstuvwxyz
2 bacdefghijklmnopqrstuvwxyz
3 abcdefghijklmnopqrstuvwxyz
4 bacdefghijklmnopqrstuvwxyz
5 abcdefghijklmnopqrstuvwxyz
Output
1
2
5
4
2
Input
8
abrakatabra
abadaba
abracadabra
atcoder
grand
contest
ababa
a
6
3 abcdefghijklmnopqrstuvwxyz
6 qwertyuiopasdfghjklzxcvbnm
8 poiuytrewqlkjhgfdsamnbvcxz
2 qazwsxedcrfvtgbyhnujmikolp
1 plokmijnuhbygvtfcrdxeszwaq
4 mnbvcxzasdfghjklpoiuytrewq
Output
4
8
2
3
4
7
|
instruction
| 0
| 107,761
| 0
| 215,522
|
"Correct Solution:
```
# 文字列の問題で、同じような文字列をまとめたいので、
# どう考えても Trie を使いたい気持ちになる
# あとは適当にやったらなんとかなった
# 1100 点の割には簡単っぽい
class TrieNode:
def __init__(self):
self.child = {}
self.count = 0 # 自身を含めた部分木の大きさ
class Trie:
def __init__(self):
self.root = TrieNode()
def add(self, s):
node = self.root
node.count += 1
for c in s:
c = ord(c) - 97
if c not in node.child:
node.child[c] = TrieNode()
node = node.child[c]
node.count += 1
node.child[26] = TrieNode()
node.child[26].count += 1
def query(self, s):
res = [[0]*27 for _ in range(26)]
node = self.root
for c in s:
c = ord(c) - 97
res_c = res[c]
for i, child in node.child.items():
res_c[i] += child.count
node = node.child[c]
return res
from itertools import groupby
import sys
def main():
input = sys.stdin.readline
N = int(input())
S = [input()[:-1] for _ in range(N)]
trie = Trie()
for s in S:
trie.add(s)
Q = int(input())
KP = [input().split() for _ in range(Q)]
Ans = [-1] * Q
Idx_Q = sorted(range(Q), key=lambda x: KP[x][0])
for v, g in groupby(Idx_Q, key=lambda x: KP[x][0]):
K = int(v) - 1
L_K = trie.query(S[K])
for idx in g:
_, P = KP[idx]
P = [ord(c) - 97 for c in P]
ans = 1
for i, pi in enumerate(P):
for pj in P[:i]:
ans += L_K[pi][pj]
ans += L_K[pi][26]
Ans[idx] = ans
print("\n".join(map(str, Ans)))
main()
```
|
output
| 1
| 107,761
| 0
| 215,523
|
Provide a correct Python 3 solution for this coding contest problem.
There are N strings of lowercase alphabet only. The i-th string is S_i. Every string is unique.
Provide answers for the Q queries below. The i-th query has the following format:
Query: An integer k_i and a string p_{i,1}p_{i,2}...p_{i,26} that results from permuting {`a`,`b`,...,`z`} are given. Output the sequence of the string S_{k_i} among the N strings in lexicographical order when the literal sequence is p_{i,1}<p_{i,2}<...<p_{i,26}.
Constraints
* 1 ≦ N,Q ≦ 100000
* 1 ≦ |S_i| (1 ≦ i ≦ N)
* S_i (1 ≦ i ≦ N) is a string of lowercase alphabet.
* The sum of |S_i| is no more than 400000.
* Every S_i is unique.
* 1 ≦ k_i ≦ N (1 ≦ i ≦ Q)
* For all 1 ≦ i ≦ Q, p_{i,1}p_{i,2}...p_{i,26} is a permutation of `abcd...z`.
Input
Inputs are provided from standard inputs in the following form.
N
S_1
:
S_N
Q
k_1 p_{1,1}p_{1,2}...p_{1,26}
:
k_Q p_{Q,1}p_{Q,2}...p_{Q,26}
Output
Output Q lines.
On line i, for the i-th query, output an integer indicating the sequence of the string S_{k_i} among the N strings in lexicographical order.
Examples
Input
5
aa
abbaa
abbba
aaab
aaaaaba
5
1 abcdefghijklmnopqrstuvwxyz
2 bacdefghijklmnopqrstuvwxyz
3 abcdefghijklmnopqrstuvwxyz
4 bacdefghijklmnopqrstuvwxyz
5 abcdefghijklmnopqrstuvwxyz
Output
1
2
5
4
2
Input
8
abrakatabra
abadaba
abracadabra
atcoder
grand
contest
ababa
a
6
3 abcdefghijklmnopqrstuvwxyz
6 qwertyuiopasdfghjklzxcvbnm
8 poiuytrewqlkjhgfdsamnbvcxz
2 qazwsxedcrfvtgbyhnujmikolp
1 plokmijnuhbygvtfcrdxeszwaq
4 mnbvcxzasdfghjklpoiuytrewq
Output
4
8
2
3
4
7
|
instruction
| 0
| 107,762
| 0
| 215,524
|
"Correct Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from collections import defaultdict
"""
・trie木
・各ノードから、アルファベットごとの子ノードの番号
・親ノードの番号
"""
N = int(readline())
data = tuple(read().split())
S = data[:N]
Q = int(data[N])
query_target = list(map(int,data[N+1::2]))
query_order = data[N+2::2]
class Node():
def __init__(self,parent):
self.parent=parent
self.child = defaultdict(int)
self.is_word_node = False
self.Nword = 0 # 部分木にあるword_nodeの個数
def __repr__(self):
return 'parent:{}\nchild:{}\nNword:{}'.format(self.parent,self.child,self.Nword)
def add(word):
n = 0
next_idx = len(nodes)
for x in word:
nodes[n].Nword += 1
c = nodes[n].child[x]
if c == 0:
c = next_idx
nodes[n].child[x] = c
nodes.append(Node(n))
next_idx += 1
n = c
nodes[n].is_word_node = True
nodes[n].Nword += 1
def solve(word):
"""
・wordに沿って進む。
・「char1<char2ならば自身より弱い文字列1個」という情報を調べる・
・自身のprefixの個数も調べる
"""
data = defaultdict(int)
prefix = 0
n = 0
for x in word:
# 進む前に、他のルートの文字列数も確認する
for k,v in nodes[n].child.items():
if k == x:
continue
data[1000*k+x] += nodes[v].Nword # k<xのときの加算量
# prefixを見つけたら加算
if nodes[n].is_word_node:
prefix += 1
# 進む
n = nodes[n].child[x]
return data, prefix
root = Node(0)
nodes = [root]
for word in S:
add(word)
# 同じ文字列に対するクエリを一括処理
word_to_query = [[] for _ in range(N)]
for i,x in enumerate(query_target):
word_to_query[x-1].append(i)
answer = [0]*Q
for n,word in enumerate(S):
if not word_to_query[n]:
continue
data,pref = solve(word)
for q in word_to_query[n]:
order = query_order[q]
alphabet_rank = {x:i for i,x in enumerate(order)}
rank = pref+1
for x,v in data.items():
a,b = divmod(x,1000)
if alphabet_rank[a] < alphabet_rank[b]:
rank += v
answer[q] = rank
print('\n'.join(map(str,answer)))
```
|
output
| 1
| 107,762
| 0
| 215,525
|
Provide a correct Python 3 solution for this coding contest problem.
There are N strings of lowercase alphabet only. The i-th string is S_i. Every string is unique.
Provide answers for the Q queries below. The i-th query has the following format:
Query: An integer k_i and a string p_{i,1}p_{i,2}...p_{i,26} that results from permuting {`a`,`b`,...,`z`} are given. Output the sequence of the string S_{k_i} among the N strings in lexicographical order when the literal sequence is p_{i,1}<p_{i,2}<...<p_{i,26}.
Constraints
* 1 ≦ N,Q ≦ 100000
* 1 ≦ |S_i| (1 ≦ i ≦ N)
* S_i (1 ≦ i ≦ N) is a string of lowercase alphabet.
* The sum of |S_i| is no more than 400000.
* Every S_i is unique.
* 1 ≦ k_i ≦ N (1 ≦ i ≦ Q)
* For all 1 ≦ i ≦ Q, p_{i,1}p_{i,2}...p_{i,26} is a permutation of `abcd...z`.
Input
Inputs are provided from standard inputs in the following form.
N
S_1
:
S_N
Q
k_1 p_{1,1}p_{1,2}...p_{1,26}
:
k_Q p_{Q,1}p_{Q,2}...p_{Q,26}
Output
Output Q lines.
On line i, for the i-th query, output an integer indicating the sequence of the string S_{k_i} among the N strings in lexicographical order.
Examples
Input
5
aa
abbaa
abbba
aaab
aaaaaba
5
1 abcdefghijklmnopqrstuvwxyz
2 bacdefghijklmnopqrstuvwxyz
3 abcdefghijklmnopqrstuvwxyz
4 bacdefghijklmnopqrstuvwxyz
5 abcdefghijklmnopqrstuvwxyz
Output
1
2
5
4
2
Input
8
abrakatabra
abadaba
abracadabra
atcoder
grand
contest
ababa
a
6
3 abcdefghijklmnopqrstuvwxyz
6 qwertyuiopasdfghjklzxcvbnm
8 poiuytrewqlkjhgfdsamnbvcxz
2 qazwsxedcrfvtgbyhnujmikolp
1 plokmijnuhbygvtfcrdxeszwaq
4 mnbvcxzasdfghjklpoiuytrewq
Output
4
8
2
3
4
7
|
instruction
| 0
| 107,763
| 0
| 215,526
|
"Correct Solution:
```
import sys
alp = "abcdefghijklmnopqrstuvwxyz"
D = {}
for i in range(26):
D[alp[i]] = i
N = int(input())
c = [{}]
num = [N]
dep = [0]
Slis = []
lon = 0
for loop in range(N):
S = input()
S += " "
Slis.append(S)
#Slen += len(S)
nind = 0
for i in S:
if i not in c[nind]:
lon += 1
if len(c[nind]) == 1:
lon -= 1
c[nind][i] = len(c)
c.append({})
num.append(0)
dep.append(dep[nind]+1)
nind = c[nind][i]
num[nind] += 1
Q = int(input())
#print (lon)
if lon < 70000:
always = [0] * N
table = []
#print (c)
#print (num)
#table構築
for loop in range(N):
nt = [[0] * 26 for i in range(26)]
nind = 0
for i in Slis[loop]:
if i == " ":
continue
#print ("now char",i)
for j in c[nind]:
#print ("nowj",j)
if j == " ":
always[loop] += 1
#print ("always pl+1")
elif j != i:
#print ("if",i,">",j,"plus:",num[c[nind][j]])
nt[D[i]][D[j]] += num[c[nind][j]]
nind = c[nind][i]
table.append(nt)
#print (always)
#print (table[0])
#Q = int(input())
for loop in range(Q):
k,p = input().split()
k = int(k)
k-=1
ans = always[k] + 1
for i in range(26):
for j in range(i):
ind1 = D[p[i]]
ind2 = D[p[j]]
ans += table[k][ind1][ind2]
print (ans)
sys.exit()
#print (c)
#print (num)
lpc = 0
for loop in range(Q):
k,p = input().split()
k = int(k)
p = " " + p
nind = 0
ans = 0
ncr = 0
while ncr < len(Slis[k-1]):
i = Slis[k-1][ncr]
for j in p:
if j == i:
break
elif j in c[nind]:
ans += num[c[nind][j]]
while len( c[c[nind][i]] ) == 1:
for x in c[c[nind][i]]:
c[nind][i] = c[c[nind][i]][x]
nind = c[nind][i]
ncr = dep[nind]
print (ans+1)
```
|
output
| 1
| 107,763
| 0
| 215,527
|
Provide a correct Python 3 solution for this coding contest problem.
There are N strings of lowercase alphabet only. The i-th string is S_i. Every string is unique.
Provide answers for the Q queries below. The i-th query has the following format:
Query: An integer k_i and a string p_{i,1}p_{i,2}...p_{i,26} that results from permuting {`a`,`b`,...,`z`} are given. Output the sequence of the string S_{k_i} among the N strings in lexicographical order when the literal sequence is p_{i,1}<p_{i,2}<...<p_{i,26}.
Constraints
* 1 ≦ N,Q ≦ 100000
* 1 ≦ |S_i| (1 ≦ i ≦ N)
* S_i (1 ≦ i ≦ N) is a string of lowercase alphabet.
* The sum of |S_i| is no more than 400000.
* Every S_i is unique.
* 1 ≦ k_i ≦ N (1 ≦ i ≦ Q)
* For all 1 ≦ i ≦ Q, p_{i,1}p_{i,2}...p_{i,26} is a permutation of `abcd...z`.
Input
Inputs are provided from standard inputs in the following form.
N
S_1
:
S_N
Q
k_1 p_{1,1}p_{1,2}...p_{1,26}
:
k_Q p_{Q,1}p_{Q,2}...p_{Q,26}
Output
Output Q lines.
On line i, for the i-th query, output an integer indicating the sequence of the string S_{k_i} among the N strings in lexicographical order.
Examples
Input
5
aa
abbaa
abbba
aaab
aaaaaba
5
1 abcdefghijklmnopqrstuvwxyz
2 bacdefghijklmnopqrstuvwxyz
3 abcdefghijklmnopqrstuvwxyz
4 bacdefghijklmnopqrstuvwxyz
5 abcdefghijklmnopqrstuvwxyz
Output
1
2
5
4
2
Input
8
abrakatabra
abadaba
abracadabra
atcoder
grand
contest
ababa
a
6
3 abcdefghijklmnopqrstuvwxyz
6 qwertyuiopasdfghjklzxcvbnm
8 poiuytrewqlkjhgfdsamnbvcxz
2 qazwsxedcrfvtgbyhnujmikolp
1 plokmijnuhbygvtfcrdxeszwaq
4 mnbvcxzasdfghjklpoiuytrewq
Output
4
8
2
3
4
7
|
instruction
| 0
| 107,764
| 0
| 215,528
|
"Correct Solution:
```
from array import*;R=range;T=[0]*28;N=int(input());S=[[ord(C)-95 for C in input()]for _ in[0]*N];U=N*26**2*array('i',[0]);V=N*[0];Q=int(input())
for X in S:
P=0
for C in X:
if T[P+C]==0:T[P+C]=len(T);T+=[0]*28
T[P]+=1;P=T[P+C]
T[P]+=1;T[P+1]=1
for I in R(N):
P=0
for C in S[I]:
for A in R(26):
X=T[P+A+2]
if(A!=C-2)*X:U[676*I+26*A+C-2]+=T[X]
V[I]+=T[P+1]
P=T[P+C]
while Q:
K,P=input().split();K=int(K)-1;P=[ord(C)-97 for C in P];X=1+V[K]
for A in R(26):
for B in R(A+1,26):
X+=U[676*K+26*P[A]+P[B]]
print(X);Q-=1
```
|
output
| 1
| 107,764
| 0
| 215,529
|
Provide a correct Python 3 solution for this coding contest problem.
There are N strings of lowercase alphabet only. The i-th string is S_i. Every string is unique.
Provide answers for the Q queries below. The i-th query has the following format:
Query: An integer k_i and a string p_{i,1}p_{i,2}...p_{i,26} that results from permuting {`a`,`b`,...,`z`} are given. Output the sequence of the string S_{k_i} among the N strings in lexicographical order when the literal sequence is p_{i,1}<p_{i,2}<...<p_{i,26}.
Constraints
* 1 ≦ N,Q ≦ 100000
* 1 ≦ |S_i| (1 ≦ i ≦ N)
* S_i (1 ≦ i ≦ N) is a string of lowercase alphabet.
* The sum of |S_i| is no more than 400000.
* Every S_i is unique.
* 1 ≦ k_i ≦ N (1 ≦ i ≦ Q)
* For all 1 ≦ i ≦ Q, p_{i,1}p_{i,2}...p_{i,26} is a permutation of `abcd...z`.
Input
Inputs are provided from standard inputs in the following form.
N
S_1
:
S_N
Q
k_1 p_{1,1}p_{1,2}...p_{1,26}
:
k_Q p_{Q,1}p_{Q,2}...p_{Q,26}
Output
Output Q lines.
On line i, for the i-th query, output an integer indicating the sequence of the string S_{k_i} among the N strings in lexicographical order.
Examples
Input
5
aa
abbaa
abbba
aaab
aaaaaba
5
1 abcdefghijklmnopqrstuvwxyz
2 bacdefghijklmnopqrstuvwxyz
3 abcdefghijklmnopqrstuvwxyz
4 bacdefghijklmnopqrstuvwxyz
5 abcdefghijklmnopqrstuvwxyz
Output
1
2
5
4
2
Input
8
abrakatabra
abadaba
abracadabra
atcoder
grand
contest
ababa
a
6
3 abcdefghijklmnopqrstuvwxyz
6 qwertyuiopasdfghjklzxcvbnm
8 poiuytrewqlkjhgfdsamnbvcxz
2 qazwsxedcrfvtgbyhnujmikolp
1 plokmijnuhbygvtfcrdxeszwaq
4 mnbvcxzasdfghjklpoiuytrewq
Output
4
8
2
3
4
7
|
instruction
| 0
| 107,765
| 0
| 215,530
|
"Correct Solution:
```
import sys
readline = sys.stdin.readline
class Node:
def __init__(self, sigma, depth):
self.end = False
self.child = [None] * sigma
self.depth = depth
self.count = 0
def __setitem__(self, i, x):
self.child[i] = x
def __getitem__(self, i):
return self.child[i]
class Trie():
def __init__(self, sigma):
self.sigma = sigma
self.root = Node(sigma, 0)
def add(self, S):
vn = self.root
vn.count += 1
for cs in S:
if vn[cs] is None:
vn[cs] = Node(self.sigma, vn.depth + 1)
vn = vn[cs]
vn.count += 1
vn.end = True
T = Trie(26)
N = int(readline())
Di = [None]*N
for i in range(N):
S = list(map(lambda x: ord(x)-97, readline().strip()))
Di[i] = S
T.add(S)
Q = int(readline())
Ans = [None]*Q
Query = [[] for _ in range(N)]
for qu in range(Q):
k, p = readline().strip().split()
k = int(k)-1
p = list(map(lambda x:ord(x)-97, p))
pinv = [None]*26
for i in range(26):
pinv[p[i]] = i
Query[k].append((qu, pinv))
for k in range(N):
if not Query[k]:
continue
cost = [[0]*26 for _ in range(26)]
geta = 0
vn = T.root
for si in Di[k]:
for ti in range(26):
if si != ti and vn[ti] is not None:
cost[si][ti] += vn[ti].count
vn = vn[si]
if vn.end:
geta += 1
L, P = map(list, zip(*Query[k]))
M = len(P)
for idx in range(M):
res = 0
invp = P[idx]
for i in range(26):
for j in range(26):
if invp[i] > invp[j]:
res += cost[i][j]
Ans[L[idx]] = res+geta
print('\n'.join(map(str, Ans)))
```
|
output
| 1
| 107,765
| 0
| 215,531
|
Provide a correct Python 3 solution for this coding contest problem.
There are N strings of lowercase alphabet only. The i-th string is S_i. Every string is unique.
Provide answers for the Q queries below. The i-th query has the following format:
Query: An integer k_i and a string p_{i,1}p_{i,2}...p_{i,26} that results from permuting {`a`,`b`,...,`z`} are given. Output the sequence of the string S_{k_i} among the N strings in lexicographical order when the literal sequence is p_{i,1}<p_{i,2}<...<p_{i,26}.
Constraints
* 1 ≦ N,Q ≦ 100000
* 1 ≦ |S_i| (1 ≦ i ≦ N)
* S_i (1 ≦ i ≦ N) is a string of lowercase alphabet.
* The sum of |S_i| is no more than 400000.
* Every S_i is unique.
* 1 ≦ k_i ≦ N (1 ≦ i ≦ Q)
* For all 1 ≦ i ≦ Q, p_{i,1}p_{i,2}...p_{i,26} is a permutation of `abcd...z`.
Input
Inputs are provided from standard inputs in the following form.
N
S_1
:
S_N
Q
k_1 p_{1,1}p_{1,2}...p_{1,26}
:
k_Q p_{Q,1}p_{Q,2}...p_{Q,26}
Output
Output Q lines.
On line i, for the i-th query, output an integer indicating the sequence of the string S_{k_i} among the N strings in lexicographical order.
Examples
Input
5
aa
abbaa
abbba
aaab
aaaaaba
5
1 abcdefghijklmnopqrstuvwxyz
2 bacdefghijklmnopqrstuvwxyz
3 abcdefghijklmnopqrstuvwxyz
4 bacdefghijklmnopqrstuvwxyz
5 abcdefghijklmnopqrstuvwxyz
Output
1
2
5
4
2
Input
8
abrakatabra
abadaba
abracadabra
atcoder
grand
contest
ababa
a
6
3 abcdefghijklmnopqrstuvwxyz
6 qwertyuiopasdfghjklzxcvbnm
8 poiuytrewqlkjhgfdsamnbvcxz
2 qazwsxedcrfvtgbyhnujmikolp
1 plokmijnuhbygvtfcrdxeszwaq
4 mnbvcxzasdfghjklpoiuytrewq
Output
4
8
2
3
4
7
|
instruction
| 0
| 107,766
| 0
| 215,532
|
"Correct Solution:
```
import array;R=range;L=input;T=[0]*28;N=int(L());S=[[ord(C)-95 for C in L()]for _ in[0]*N];U=N*26**2*array.array('i',[0]);V=N*[0];Q=int(L())
for X in S:
P=0
for C in X:
if T[P+C]==0:T[P+C]=len(T);T+=[0]*28
T[P]+=1;P=T[P+C]
T[P]+=1;T[P+1]=1
while N:
N-=1;P=0
for C in S[N]:
for A in R(26):X=T[P+A+2];U[676*N+26*A+C-2]+=T[X]*(X and A!=C-2)
V[N]+=T[P+1];P=T[P+C]
while Q:K,P=L().split();K=int(K)-1;P=[ord(C)-97 for C in P];X=1+V[K]+sum(U[676*K+26*P[A]+P[B]]for A in R(26)for B in R(A+1,26));print(X);Q-=1
```
|
output
| 1
| 107,766
| 0
| 215,533
|
Provide a correct Python 3 solution for this coding contest problem.
There are N strings of lowercase alphabet only. The i-th string is S_i. Every string is unique.
Provide answers for the Q queries below. The i-th query has the following format:
Query: An integer k_i and a string p_{i,1}p_{i,2}...p_{i,26} that results from permuting {`a`,`b`,...,`z`} are given. Output the sequence of the string S_{k_i} among the N strings in lexicographical order when the literal sequence is p_{i,1}<p_{i,2}<...<p_{i,26}.
Constraints
* 1 ≦ N,Q ≦ 100000
* 1 ≦ |S_i| (1 ≦ i ≦ N)
* S_i (1 ≦ i ≦ N) is a string of lowercase alphabet.
* The sum of |S_i| is no more than 400000.
* Every S_i is unique.
* 1 ≦ k_i ≦ N (1 ≦ i ≦ Q)
* For all 1 ≦ i ≦ Q, p_{i,1}p_{i,2}...p_{i,26} is a permutation of `abcd...z`.
Input
Inputs are provided from standard inputs in the following form.
N
S_1
:
S_N
Q
k_1 p_{1,1}p_{1,2}...p_{1,26}
:
k_Q p_{Q,1}p_{Q,2}...p_{Q,26}
Output
Output Q lines.
On line i, for the i-th query, output an integer indicating the sequence of the string S_{k_i} among the N strings in lexicographical order.
Examples
Input
5
aa
abbaa
abbba
aaab
aaaaaba
5
1 abcdefghijklmnopqrstuvwxyz
2 bacdefghijklmnopqrstuvwxyz
3 abcdefghijklmnopqrstuvwxyz
4 bacdefghijklmnopqrstuvwxyz
5 abcdefghijklmnopqrstuvwxyz
Output
1
2
5
4
2
Input
8
abrakatabra
abadaba
abracadabra
atcoder
grand
contest
ababa
a
6
3 abcdefghijklmnopqrstuvwxyz
6 qwertyuiopasdfghjklzxcvbnm
8 poiuytrewqlkjhgfdsamnbvcxz
2 qazwsxedcrfvtgbyhnujmikolp
1 plokmijnuhbygvtfcrdxeszwaq
4 mnbvcxzasdfghjklpoiuytrewq
Output
4
8
2
3
4
7
|
instruction
| 0
| 107,767
| 0
| 215,534
|
"Correct Solution:
```
import array;R=range;L=input;T=[0]*28;N=int(L());S=[[ord(C)-95 for C in L()]for _ in[0]*N];U=N*26**2*array.array('i',[0]);V=N*[0];Q=int(L())
for X in S:
P=0
for C in X:
if T[P+C]==0:T[P+C]=len(T);T+=[0]*28
T[P]+=1;P=T[P+C]
T[P]+=1;T[P+1]=1
while N:
N-=1;P=0
for C in S[N]:
for A in R(26):X=T[P+A+2];U[676*N+26*A+C-2]+=T[X]*(X and A!=C-2)
V[N]+=T[P+1];P=T[P+C]
while Q:
K,P=L().split();K=int(K)-1;P=[ord(C)-97 for C in P];X=1+V[K]
for A in R(26):
for B in R(A+1,26):X+=U[676*K+26*P[A]+P[B]]
print(X);Q-=1
```
|
output
| 1
| 107,767
| 0
| 215,535
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N strings of lowercase alphabet only. The i-th string is S_i. Every string is unique.
Provide answers for the Q queries below. The i-th query has the following format:
Query: An integer k_i and a string p_{i,1}p_{i,2}...p_{i,26} that results from permuting {`a`,`b`,...,`z`} are given. Output the sequence of the string S_{k_i} among the N strings in lexicographical order when the literal sequence is p_{i,1}<p_{i,2}<...<p_{i,26}.
Constraints
* 1 ≦ N,Q ≦ 100000
* 1 ≦ |S_i| (1 ≦ i ≦ N)
* S_i (1 ≦ i ≦ N) is a string of lowercase alphabet.
* The sum of |S_i| is no more than 400000.
* Every S_i is unique.
* 1 ≦ k_i ≦ N (1 ≦ i ≦ Q)
* For all 1 ≦ i ≦ Q, p_{i,1}p_{i,2}...p_{i,26} is a permutation of `abcd...z`.
Input
Inputs are provided from standard inputs in the following form.
N
S_1
:
S_N
Q
k_1 p_{1,1}p_{1,2}...p_{1,26}
:
k_Q p_{Q,1}p_{Q,2}...p_{Q,26}
Output
Output Q lines.
On line i, for the i-th query, output an integer indicating the sequence of the string S_{k_i} among the N strings in lexicographical order.
Examples
Input
5
aa
abbaa
abbba
aaab
aaaaaba
5
1 abcdefghijklmnopqrstuvwxyz
2 bacdefghijklmnopqrstuvwxyz
3 abcdefghijklmnopqrstuvwxyz
4 bacdefghijklmnopqrstuvwxyz
5 abcdefghijklmnopqrstuvwxyz
Output
1
2
5
4
2
Input
8
abrakatabra
abadaba
abracadabra
atcoder
grand
contest
ababa
a
6
3 abcdefghijklmnopqrstuvwxyz
6 qwertyuiopasdfghjklzxcvbnm
8 poiuytrewqlkjhgfdsamnbvcxz
2 qazwsxedcrfvtgbyhnujmikolp
1 plokmijnuhbygvtfcrdxeszwaq
4 mnbvcxzasdfghjklpoiuytrewq
Output
4
8
2
3
4
7
Submitted Solution:
```
import array;R=range;L=input;T=[0]*28;N=int(L());S=[[ord(C)-95 for C in L()]for _ in[0]*N];U=N*26**2*array.array('i',[0]);V=N*[0];Q=int(L())
for X in S:
P=0
for C in X:
if T[P+C]==0:T[P+C]=len(T);T+=[0]*28
T[P]+=1;P=T[P+C]
T[P]+=1;T[P+1]=1
while N:
N-=1;P=0
for C in S[N]:
for A in R(26):
X=T[P+A+2]
if(A!=C-2)*X:U[676*N+26*A+C-2]+=T[X]
V[N]+=T[P+1]
P=T[P+C]
while Q:
K,P=L().split();K=int(K)-1;P=[ord(C)-97 for C in P];X=1+V[K]
for A in R(26):
for B in R(A+1,26):
X+=U[676*K+26*P[A]+P[B]]
print(X);Q-=1
```
|
instruction
| 0
| 107,768
| 0
| 215,536
|
Yes
|
output
| 1
| 107,768
| 0
| 215,537
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N strings of lowercase alphabet only. The i-th string is S_i. Every string is unique.
Provide answers for the Q queries below. The i-th query has the following format:
Query: An integer k_i and a string p_{i,1}p_{i,2}...p_{i,26} that results from permuting {`a`,`b`,...,`z`} are given. Output the sequence of the string S_{k_i} among the N strings in lexicographical order when the literal sequence is p_{i,1}<p_{i,2}<...<p_{i,26}.
Constraints
* 1 ≦ N,Q ≦ 100000
* 1 ≦ |S_i| (1 ≦ i ≦ N)
* S_i (1 ≦ i ≦ N) is a string of lowercase alphabet.
* The sum of |S_i| is no more than 400000.
* Every S_i is unique.
* 1 ≦ k_i ≦ N (1 ≦ i ≦ Q)
* For all 1 ≦ i ≦ Q, p_{i,1}p_{i,2}...p_{i,26} is a permutation of `abcd...z`.
Input
Inputs are provided from standard inputs in the following form.
N
S_1
:
S_N
Q
k_1 p_{1,1}p_{1,2}...p_{1,26}
:
k_Q p_{Q,1}p_{Q,2}...p_{Q,26}
Output
Output Q lines.
On line i, for the i-th query, output an integer indicating the sequence of the string S_{k_i} among the N strings in lexicographical order.
Examples
Input
5
aa
abbaa
abbba
aaab
aaaaaba
5
1 abcdefghijklmnopqrstuvwxyz
2 bacdefghijklmnopqrstuvwxyz
3 abcdefghijklmnopqrstuvwxyz
4 bacdefghijklmnopqrstuvwxyz
5 abcdefghijklmnopqrstuvwxyz
Output
1
2
5
4
2
Input
8
abrakatabra
abadaba
abracadabra
atcoder
grand
contest
ababa
a
6
3 abcdefghijklmnopqrstuvwxyz
6 qwertyuiopasdfghjklzxcvbnm
8 poiuytrewqlkjhgfdsamnbvcxz
2 qazwsxedcrfvtgbyhnujmikolp
1 plokmijnuhbygvtfcrdxeszwaq
4 mnbvcxzasdfghjklpoiuytrewq
Output
4
8
2
3
4
7
Submitted Solution:
```
import sys
readline = sys.stdin.readline
class Node:
def __init__(self, sigma, depth):
self.end = False
self.child = [None] * sigma
self.depth = depth
self.count = 0
def __setitem__(self, i, x):
self.child[i] = x
def __getitem__(self, i):
return self.child[i]
class Trie():
def __init__(self, sigma):
self.sigma = sigma
self.root = Node(sigma, 0)
def add(self, S):
vn = self.root
vn.count += 1
for cs in S:
if vn[cs] is None:
vn[cs] = Node(self.sigma, vn.depth + 1)
vn = vn[cs]
vn.count += 1
vn.end = True
T = Trie(26)
N = int(readline())
Di = [None]*N
for i in range(N):
S = list(map(lambda x: ord(x)-97, readline().strip()))
Di[i] = S
T.add(S)
Q = int(readline())
Ans = [None]*Q
for qu in range(Q):
k, p = readline().strip().split()
k = int(k)-1
p = list(map(lambda x:ord(x)-97, p))
vn = T.root
res = 0
for si in Di[k]:
for al in p:
if al == si:
break
if vn[al] is not None:
res += vn[al].count
vn = vn[si]
if vn.end:
res += 1
Ans[qu] = res
print('\n'.join(map(str, Ans)))
```
|
instruction
| 0
| 107,769
| 0
| 215,538
|
No
|
output
| 1
| 107,769
| 0
| 215,539
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N strings of lowercase alphabet only. The i-th string is S_i. Every string is unique.
Provide answers for the Q queries below. The i-th query has the following format:
Query: An integer k_i and a string p_{i,1}p_{i,2}...p_{i,26} that results from permuting {`a`,`b`,...,`z`} are given. Output the sequence of the string S_{k_i} among the N strings in lexicographical order when the literal sequence is p_{i,1}<p_{i,2}<...<p_{i,26}.
Constraints
* 1 ≦ N,Q ≦ 100000
* 1 ≦ |S_i| (1 ≦ i ≦ N)
* S_i (1 ≦ i ≦ N) is a string of lowercase alphabet.
* The sum of |S_i| is no more than 400000.
* Every S_i is unique.
* 1 ≦ k_i ≦ N (1 ≦ i ≦ Q)
* For all 1 ≦ i ≦ Q, p_{i,1}p_{i,2}...p_{i,26} is a permutation of `abcd...z`.
Input
Inputs are provided from standard inputs in the following form.
N
S_1
:
S_N
Q
k_1 p_{1,1}p_{1,2}...p_{1,26}
:
k_Q p_{Q,1}p_{Q,2}...p_{Q,26}
Output
Output Q lines.
On line i, for the i-th query, output an integer indicating the sequence of the string S_{k_i} among the N strings in lexicographical order.
Examples
Input
5
aa
abbaa
abbba
aaab
aaaaaba
5
1 abcdefghijklmnopqrstuvwxyz
2 bacdefghijklmnopqrstuvwxyz
3 abcdefghijklmnopqrstuvwxyz
4 bacdefghijklmnopqrstuvwxyz
5 abcdefghijklmnopqrstuvwxyz
Output
1
2
5
4
2
Input
8
abrakatabra
abadaba
abracadabra
atcoder
grand
contest
ababa
a
6
3 abcdefghijklmnopqrstuvwxyz
6 qwertyuiopasdfghjklzxcvbnm
8 poiuytrewqlkjhgfdsamnbvcxz
2 qazwsxedcrfvtgbyhnujmikolp
1 plokmijnuhbygvtfcrdxeszwaq
4 mnbvcxzasdfghjklpoiuytrewq
Output
4
8
2
3
4
7
Submitted Solution:
```
N = int(input())
S = [input() for _ in range(N)]
Q = int(input())
S.sort()
k, p = zip(*map(lambda x: (int(x[0]), x[1]), [input().split() for _ in range(Q)]))
for q in range(Q):
print(q)
```
|
instruction
| 0
| 107,770
| 0
| 215,540
|
No
|
output
| 1
| 107,770
| 0
| 215,541
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N strings of lowercase alphabet only. The i-th string is S_i. Every string is unique.
Provide answers for the Q queries below. The i-th query has the following format:
Query: An integer k_i and a string p_{i,1}p_{i,2}...p_{i,26} that results from permuting {`a`,`b`,...,`z`} are given. Output the sequence of the string S_{k_i} among the N strings in lexicographical order when the literal sequence is p_{i,1}<p_{i,2}<...<p_{i,26}.
Constraints
* 1 ≦ N,Q ≦ 100000
* 1 ≦ |S_i| (1 ≦ i ≦ N)
* S_i (1 ≦ i ≦ N) is a string of lowercase alphabet.
* The sum of |S_i| is no more than 400000.
* Every S_i is unique.
* 1 ≦ k_i ≦ N (1 ≦ i ≦ Q)
* For all 1 ≦ i ≦ Q, p_{i,1}p_{i,2}...p_{i,26} is a permutation of `abcd...z`.
Input
Inputs are provided from standard inputs in the following form.
N
S_1
:
S_N
Q
k_1 p_{1,1}p_{1,2}...p_{1,26}
:
k_Q p_{Q,1}p_{Q,2}...p_{Q,26}
Output
Output Q lines.
On line i, for the i-th query, output an integer indicating the sequence of the string S_{k_i} among the N strings in lexicographical order.
Examples
Input
5
aa
abbaa
abbba
aaab
aaaaaba
5
1 abcdefghijklmnopqrstuvwxyz
2 bacdefghijklmnopqrstuvwxyz
3 abcdefghijklmnopqrstuvwxyz
4 bacdefghijklmnopqrstuvwxyz
5 abcdefghijklmnopqrstuvwxyz
Output
1
2
5
4
2
Input
8
abrakatabra
abadaba
abracadabra
atcoder
grand
contest
ababa
a
6
3 abcdefghijklmnopqrstuvwxyz
6 qwertyuiopasdfghjklzxcvbnm
8 poiuytrewqlkjhgfdsamnbvcxz
2 qazwsxedcrfvtgbyhnujmikolp
1 plokmijnuhbygvtfcrdxeszwaq
4 mnbvcxzasdfghjklpoiuytrewq
Output
4
8
2
3
4
7
Submitted Solution:
```
N = int(input())
S = [input() for _ in range(N)]
Q = int(input())
k, p = zip(*map(lambda x: (int(x[0]), x[1]), [input().split() for _ in range(Q)]))
for q in range(Q):
print(q)
```
|
instruction
| 0
| 107,771
| 0
| 215,542
|
No
|
output
| 1
| 107,771
| 0
| 215,543
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N strings of lowercase alphabet only. The i-th string is S_i. Every string is unique.
Provide answers for the Q queries below. The i-th query has the following format:
Query: An integer k_i and a string p_{i,1}p_{i,2}...p_{i,26} that results from permuting {`a`,`b`,...,`z`} are given. Output the sequence of the string S_{k_i} among the N strings in lexicographical order when the literal sequence is p_{i,1}<p_{i,2}<...<p_{i,26}.
Constraints
* 1 ≦ N,Q ≦ 100000
* 1 ≦ |S_i| (1 ≦ i ≦ N)
* S_i (1 ≦ i ≦ N) is a string of lowercase alphabet.
* The sum of |S_i| is no more than 400000.
* Every S_i is unique.
* 1 ≦ k_i ≦ N (1 ≦ i ≦ Q)
* For all 1 ≦ i ≦ Q, p_{i,1}p_{i,2}...p_{i,26} is a permutation of `abcd...z`.
Input
Inputs are provided from standard inputs in the following form.
N
S_1
:
S_N
Q
k_1 p_{1,1}p_{1,2}...p_{1,26}
:
k_Q p_{Q,1}p_{Q,2}...p_{Q,26}
Output
Output Q lines.
On line i, for the i-th query, output an integer indicating the sequence of the string S_{k_i} among the N strings in lexicographical order.
Examples
Input
5
aa
abbaa
abbba
aaab
aaaaaba
5
1 abcdefghijklmnopqrstuvwxyz
2 bacdefghijklmnopqrstuvwxyz
3 abcdefghijklmnopqrstuvwxyz
4 bacdefghijklmnopqrstuvwxyz
5 abcdefghijklmnopqrstuvwxyz
Output
1
2
5
4
2
Input
8
abrakatabra
abadaba
abracadabra
atcoder
grand
contest
ababa
a
6
3 abcdefghijklmnopqrstuvwxyz
6 qwertyuiopasdfghjklzxcvbnm
8 poiuytrewqlkjhgfdsamnbvcxz
2 qazwsxedcrfvtgbyhnujmikolp
1 plokmijnuhbygvtfcrdxeszwaq
4 mnbvcxzasdfghjklpoiuytrewq
Output
4
8
2
3
4
7
Submitted Solution:
```
import sys
readline = sys.stdin.readline
class Node:
def __init__(self, sigma, depth):
self.end = False
self.child = [None] * sigma
self.depth = depth
self.count = 0
def __setitem__(self, i, x):
self.child[i] = x
def __getitem__(self, i):
return self.child[i]
class Trie():
def __init__(self, sigma):
self.sigma = sigma
self.root = Node(sigma, 0)
def add(self, S):
vn = self.root
vn.count += 1
for cs in S:
if vn[cs] is None:
vn[cs] = Node(self.sigma, vn.depth + 1)
vn = vn[cs]
vn.count += 1
vn.end = True
T = Trie(26)
N = int(readline())
Di = [None]*N
for i in range(N):
S = list(map(lambda x: ord(x)-97, readline().strip()))
Di[i] = S
T.add(S)
Q = int(readline())
Ans = [None]*Q
Query = [[] for _ in range(N)]
for qu in range(Q):
k, p = readline().strip().split()
k = int(k)-1
p = list(map(lambda x:ord(x)-97, p))
pinv = [None]*26
for i in range(26):
pinv[p[i]] = i
Query[k].append((qu, pinv))
for i in range(N):
if not Query[i]:
continue
L = []
P = []
for qu, p in Query[i]:
L.append(qu)
P.append(p)
M = len(P)
vn = T.root
ans = [0]*M
for si in Di[i]:
for al in range(26):
for idx in range(M):
pinv = P[idx]
if pinv[al] < pinv[si]:
if vn[al] is not None:
ans[idx] += vn[al].count
vn = vn[si]
if vn.end:
ans = [1+a for a in ans]
for j in range(M):
Ans[L[j]] = ans[j]
print('\n'.join(map(str, Ans)))
```
|
instruction
| 0
| 107,772
| 0
| 215,544
|
No
|
output
| 1
| 107,772
| 0
| 215,545
|
Provide a correct Python 3 solution for this coding contest problem.
There is data of up to 100 characters per line, consisting of half-width alphabetic character strings. Some lines are symmetric (same whether read from the left edge or the right edge). Create a program that reads this data and outputs the number of symmetric strings in it. Note that lines consisting of only one character are symmetrical.
Input
Multiple strings are given over multiple lines. One string is given for each line. The number of strings does not exceed 50.
Output
Outputs the number of symmetric strings on one line.
Example
Input
abcba
sx
abcddcba
rttrd
Output
2
|
instruction
| 0
| 107,776
| 0
| 215,552
|
"Correct Solution:
```
def get_input():
while True:
try:
yield ''.join(input())
except EOFError:
break
N = list(get_input())
ans = 0
for ll in range(len(N)):
S = N[ll]
flag = True
for i in range(len(S) // 2):
if S[i] != S[len(S)-i-1]:
flag = False
break
if flag:
ans += 1
print(ans)
```
|
output
| 1
| 107,776
| 0
| 215,553
|
Provide tags and a correct Python 3 solution for this coding contest problem.
The length of the longest common prefix of two strings s = s_1 s_2 … s_n and t = t_1 t_2 … t_m is defined as the maximum integer k (0 ≤ k ≤ min(n,m)) such that s_1 s_2 … s_k equals t_1 t_2 … t_k.
Koa the Koala initially has n+1 strings s_1, s_2, ..., s_{n+1}.
For each i (1 ≤ i ≤ n) she calculated a_i — the length of the longest common prefix of s_i and s_{i+1}.
Several days later Koa found these numbers, but she couldn't remember the strings.
So Koa would like to find some strings s_1, s_2, ..., s_{n+1} which would have generated numbers a_1, a_2, ..., a_n. Can you help her?
If there are many answers print any. We can show that answer always exists for the given constraints.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 100) — the number of test cases. Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of elements in the list a.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 50) — the elements of a.
It is guaranteed that the sum of n over all test cases does not exceed 100.
Output
For each test case:
Output n+1 lines. In the i-th line print string s_i (1 ≤ |s_i| ≤ 200), consisting of lowercase Latin letters. Length of the longest common prefix of strings s_i and s_{i+1} has to be equal to a_i.
If there are many answers print any. We can show that answer always exists for the given constraints.
Example
Input
4
4
1 2 4 2
2
5 3
3
1 3 1
3
0 0 0
Output
aeren
ari
arousal
around
ari
monogon
monogamy
monthly
kevinvu
kuroni
kurioni
korone
anton
loves
adhoc
problems
Note
In the 1-st test case one of the possible answers is s = [aeren, ari, arousal, around, ari].
Lengths of longest common prefixes are:
* Between \color{red}{a}eren and \color{red}{a}ri → 1
* Between \color{red}{ar}i and \color{red}{ar}ousal → 2
* Between \color{red}{arou}sal and \color{red}{arou}nd → 4
* Between \color{red}{ar}ound and \color{red}{ar}i → 2
|
instruction
| 0
| 108,003
| 0
| 216,006
|
Tags: constructive algorithms, greedy, strings
Correct Solution:
```
import string
import random
t=input()
t=int(t)
while(t>0):
n = int(input())
a = list(map(int,input().strip().split()))[:n]
alphabet = string.ascii_lowercase
test_list = list(alphabet)
ans=[]
start = 'fkbmlhfplstlnxggebayfkbmlhfplstlnxggebaytlnxggebaybay'
ans.append(start)
for i,val in enumerate(a):
cha = ans[-1]
ch = cha[val]
res = random.choice([ele for ele in test_list if ele != ch])
new = str(cha[:val]) + str(res) + str(cha[val+1:])
ans.append(new)
for i in ans:
print(i)
t-=1
```
|
output
| 1
| 108,003
| 0
| 216,007
|
Provide tags and a correct Python 3 solution for this coding contest problem.
The length of the longest common prefix of two strings s = s_1 s_2 … s_n and t = t_1 t_2 … t_m is defined as the maximum integer k (0 ≤ k ≤ min(n,m)) such that s_1 s_2 … s_k equals t_1 t_2 … t_k.
Koa the Koala initially has n+1 strings s_1, s_2, ..., s_{n+1}.
For each i (1 ≤ i ≤ n) she calculated a_i — the length of the longest common prefix of s_i and s_{i+1}.
Several days later Koa found these numbers, but she couldn't remember the strings.
So Koa would like to find some strings s_1, s_2, ..., s_{n+1} which would have generated numbers a_1, a_2, ..., a_n. Can you help her?
If there are many answers print any. We can show that answer always exists for the given constraints.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 100) — the number of test cases. Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of elements in the list a.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 50) — the elements of a.
It is guaranteed that the sum of n over all test cases does not exceed 100.
Output
For each test case:
Output n+1 lines. In the i-th line print string s_i (1 ≤ |s_i| ≤ 200), consisting of lowercase Latin letters. Length of the longest common prefix of strings s_i and s_{i+1} has to be equal to a_i.
If there are many answers print any. We can show that answer always exists for the given constraints.
Example
Input
4
4
1 2 4 2
2
5 3
3
1 3 1
3
0 0 0
Output
aeren
ari
arousal
around
ari
monogon
monogamy
monthly
kevinvu
kuroni
kurioni
korone
anton
loves
adhoc
problems
Note
In the 1-st test case one of the possible answers is s = [aeren, ari, arousal, around, ari].
Lengths of longest common prefixes are:
* Between \color{red}{a}eren and \color{red}{a}ri → 1
* Between \color{red}{ar}i and \color{red}{ar}ousal → 2
* Between \color{red}{arou}sal and \color{red}{arou}nd → 4
* Between \color{red}{ar}ound and \color{red}{ar}i → 2
|
instruction
| 0
| 108,004
| 0
| 216,008
|
Tags: constructive algorithms, greedy, strings
Correct Solution:
```
T = int(input())
for case in range(1, T + 1):
N = int(input())
arr = [int(x) for x in input().split()]
ch = 0
res = [""] * (N +1)
res[0] = max(1, arr[0]) * chr(97 + ch)
if arr[0] == 0:
ch += 1
ch = ch % 26
res[1] = max(1, arr[0]) * chr(97 + ch)
for i in range(1, N):
if arr[i] == 0:
ch += 1
ch = ch % 26
res[i + 1] = chr(97 + ch)
ch += 1
ch = ch % 26
elif arr[i] > len(res[i]):
ch += 1
ch = ch % 26
temp = res[i]
while True:
res[i] = temp + chr(97 + ch) * (arr[i] - len(res[i]))
if res[i - 1][:len(res[i])] != res[i]:
break
ch += 1
ch = ch % 26
res[i + 1] = res[i]
else:
res[i + 1] = res[i][:arr[i]]
for s in res:
print(s)
```
|
output
| 1
| 108,004
| 0
| 216,009
|
Provide tags and a correct Python 3 solution for this coding contest problem.
The length of the longest common prefix of two strings s = s_1 s_2 … s_n and t = t_1 t_2 … t_m is defined as the maximum integer k (0 ≤ k ≤ min(n,m)) such that s_1 s_2 … s_k equals t_1 t_2 … t_k.
Koa the Koala initially has n+1 strings s_1, s_2, ..., s_{n+1}.
For each i (1 ≤ i ≤ n) she calculated a_i — the length of the longest common prefix of s_i and s_{i+1}.
Several days later Koa found these numbers, but she couldn't remember the strings.
So Koa would like to find some strings s_1, s_2, ..., s_{n+1} which would have generated numbers a_1, a_2, ..., a_n. Can you help her?
If there are many answers print any. We can show that answer always exists for the given constraints.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 100) — the number of test cases. Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of elements in the list a.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 50) — the elements of a.
It is guaranteed that the sum of n over all test cases does not exceed 100.
Output
For each test case:
Output n+1 lines. In the i-th line print string s_i (1 ≤ |s_i| ≤ 200), consisting of lowercase Latin letters. Length of the longest common prefix of strings s_i and s_{i+1} has to be equal to a_i.
If there are many answers print any. We can show that answer always exists for the given constraints.
Example
Input
4
4
1 2 4 2
2
5 3
3
1 3 1
3
0 0 0
Output
aeren
ari
arousal
around
ari
monogon
monogamy
monthly
kevinvu
kuroni
kurioni
korone
anton
loves
adhoc
problems
Note
In the 1-st test case one of the possible answers is s = [aeren, ari, arousal, around, ari].
Lengths of longest common prefixes are:
* Between \color{red}{a}eren and \color{red}{a}ri → 1
* Between \color{red}{ar}i and \color{red}{ar}ousal → 2
* Between \color{red}{arou}sal and \color{red}{arou}nd → 4
* Between \color{red}{ar}ound and \color{red}{ar}i → 2
|
instruction
| 0
| 108,005
| 0
| 216,010
|
Tags: constructive algorithms, greedy, strings
Correct Solution:
```
import sys
input = sys.stdin.readline
def solve():
n = int(input())
l = [int(x) for x in input().split()]
c = max(l)
s = ['a'*(c+1)]*(n+1)
for i in range(n):
e = l[i]
d = 'a' if s[i][e] == 'b' else 'b'
s[i+1] = s[i][:e] + d + s[i][e+1:]
print('\n'.join(s))
for _ in range(int(input())):
solve()
```
|
output
| 1
| 108,005
| 0
| 216,011
|
Provide tags and a correct Python 3 solution for this coding contest problem.
The length of the longest common prefix of two strings s = s_1 s_2 … s_n and t = t_1 t_2 … t_m is defined as the maximum integer k (0 ≤ k ≤ min(n,m)) such that s_1 s_2 … s_k equals t_1 t_2 … t_k.
Koa the Koala initially has n+1 strings s_1, s_2, ..., s_{n+1}.
For each i (1 ≤ i ≤ n) she calculated a_i — the length of the longest common prefix of s_i and s_{i+1}.
Several days later Koa found these numbers, but she couldn't remember the strings.
So Koa would like to find some strings s_1, s_2, ..., s_{n+1} which would have generated numbers a_1, a_2, ..., a_n. Can you help her?
If there are many answers print any. We can show that answer always exists for the given constraints.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 100) — the number of test cases. Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of elements in the list a.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 50) — the elements of a.
It is guaranteed that the sum of n over all test cases does not exceed 100.
Output
For each test case:
Output n+1 lines. In the i-th line print string s_i (1 ≤ |s_i| ≤ 200), consisting of lowercase Latin letters. Length of the longest common prefix of strings s_i and s_{i+1} has to be equal to a_i.
If there are many answers print any. We can show that answer always exists for the given constraints.
Example
Input
4
4
1 2 4 2
2
5 3
3
1 3 1
3
0 0 0
Output
aeren
ari
arousal
around
ari
monogon
monogamy
monthly
kevinvu
kuroni
kurioni
korone
anton
loves
adhoc
problems
Note
In the 1-st test case one of the possible answers is s = [aeren, ari, arousal, around, ari].
Lengths of longest common prefixes are:
* Between \color{red}{a}eren and \color{red}{a}ri → 1
* Between \color{red}{ar}i and \color{red}{ar}ousal → 2
* Between \color{red}{arou}sal and \color{red}{arou}nd → 4
* Between \color{red}{ar}ound and \color{red}{ar}i → 2
|
instruction
| 0
| 108,006
| 0
| 216,012
|
Tags: constructive algorithms, greedy, strings
Correct Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
arr = [int(x) for x in input().split()]
max_n = max(arr)
arr = [max_n + 1] + arr
s = "a"*(max_n+1)
print(s)
for i in range(n):
if ord(s[arr[i+1]]) == 122:
c = "a"
else:
c = chr(ord(s[arr[i+1]]) + 1)
s = s[:arr[i+1]] + c + s[arr[i+1]+1:]
print(s)
```
|
output
| 1
| 108,006
| 0
| 216,013
|
Provide tags and a correct Python 3 solution for this coding contest problem.
The length of the longest common prefix of two strings s = s_1 s_2 … s_n and t = t_1 t_2 … t_m is defined as the maximum integer k (0 ≤ k ≤ min(n,m)) such that s_1 s_2 … s_k equals t_1 t_2 … t_k.
Koa the Koala initially has n+1 strings s_1, s_2, ..., s_{n+1}.
For each i (1 ≤ i ≤ n) she calculated a_i — the length of the longest common prefix of s_i and s_{i+1}.
Several days later Koa found these numbers, but she couldn't remember the strings.
So Koa would like to find some strings s_1, s_2, ..., s_{n+1} which would have generated numbers a_1, a_2, ..., a_n. Can you help her?
If there are many answers print any. We can show that answer always exists for the given constraints.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 100) — the number of test cases. Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of elements in the list a.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 50) — the elements of a.
It is guaranteed that the sum of n over all test cases does not exceed 100.
Output
For each test case:
Output n+1 lines. In the i-th line print string s_i (1 ≤ |s_i| ≤ 200), consisting of lowercase Latin letters. Length of the longest common prefix of strings s_i and s_{i+1} has to be equal to a_i.
If there are many answers print any. We can show that answer always exists for the given constraints.
Example
Input
4
4
1 2 4 2
2
5 3
3
1 3 1
3
0 0 0
Output
aeren
ari
arousal
around
ari
monogon
monogamy
monthly
kevinvu
kuroni
kurioni
korone
anton
loves
adhoc
problems
Note
In the 1-st test case one of the possible answers is s = [aeren, ari, arousal, around, ari].
Lengths of longest common prefixes are:
* Between \color{red}{a}eren and \color{red}{a}ri → 1
* Between \color{red}{ar}i and \color{red}{ar}ousal → 2
* Between \color{red}{arou}sal and \color{red}{arou}nd → 4
* Between \color{red}{ar}ound and \color{red}{ar}i → 2
|
instruction
| 0
| 108,007
| 0
| 216,014
|
Tags: constructive algorithms, greedy, strings
Correct Solution:
```
t=int(input())
for _ in range(t):
n=int(input())
l=list(map(int,input().split()))
s=['a']*(max(l)+1)
print(''.join(s))
for i in l:
if(s[i]=='b'):
s[i]='a'
else:
s[i]='b'
print(''.join(s))
```
|
output
| 1
| 108,007
| 0
| 216,015
|
Provide tags and a correct Python 3 solution for this coding contest problem.
The length of the longest common prefix of two strings s = s_1 s_2 … s_n and t = t_1 t_2 … t_m is defined as the maximum integer k (0 ≤ k ≤ min(n,m)) such that s_1 s_2 … s_k equals t_1 t_2 … t_k.
Koa the Koala initially has n+1 strings s_1, s_2, ..., s_{n+1}.
For each i (1 ≤ i ≤ n) she calculated a_i — the length of the longest common prefix of s_i and s_{i+1}.
Several days later Koa found these numbers, but she couldn't remember the strings.
So Koa would like to find some strings s_1, s_2, ..., s_{n+1} which would have generated numbers a_1, a_2, ..., a_n. Can you help her?
If there are many answers print any. We can show that answer always exists for the given constraints.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 100) — the number of test cases. Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of elements in the list a.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 50) — the elements of a.
It is guaranteed that the sum of n over all test cases does not exceed 100.
Output
For each test case:
Output n+1 lines. In the i-th line print string s_i (1 ≤ |s_i| ≤ 200), consisting of lowercase Latin letters. Length of the longest common prefix of strings s_i and s_{i+1} has to be equal to a_i.
If there are many answers print any. We can show that answer always exists for the given constraints.
Example
Input
4
4
1 2 4 2
2
5 3
3
1 3 1
3
0 0 0
Output
aeren
ari
arousal
around
ari
monogon
monogamy
monthly
kevinvu
kuroni
kurioni
korone
anton
loves
adhoc
problems
Note
In the 1-st test case one of the possible answers is s = [aeren, ari, arousal, around, ari].
Lengths of longest common prefixes are:
* Between \color{red}{a}eren and \color{red}{a}ri → 1
* Between \color{red}{ar}i and \color{red}{ar}ousal → 2
* Between \color{red}{arou}sal and \color{red}{arou}nd → 4
* Between \color{red}{ar}ound and \color{red}{ar}i → 2
|
instruction
| 0
| 108,008
| 0
| 216,016
|
Tags: constructive algorithms, greedy, strings
Correct Solution:
```
test= int(input())
for num in range(test):
n=int(input())
arr= list(map(int,input().split()))
s0= "a"*200
while(False):
break
print(s0)
for i in range(n):
xx= arr[i]
s=s0[:xx]
while(False):
break
for j in range(200-xx):
if(s0[xx+j]=='a'):
s+='b'
else:
s+='a'
print(s)
s0=s
```
|
output
| 1
| 108,008
| 0
| 216,017
|
Provide tags and a correct Python 3 solution for this coding contest problem.
The length of the longest common prefix of two strings s = s_1 s_2 … s_n and t = t_1 t_2 … t_m is defined as the maximum integer k (0 ≤ k ≤ min(n,m)) such that s_1 s_2 … s_k equals t_1 t_2 … t_k.
Koa the Koala initially has n+1 strings s_1, s_2, ..., s_{n+1}.
For each i (1 ≤ i ≤ n) she calculated a_i — the length of the longest common prefix of s_i and s_{i+1}.
Several days later Koa found these numbers, but she couldn't remember the strings.
So Koa would like to find some strings s_1, s_2, ..., s_{n+1} which would have generated numbers a_1, a_2, ..., a_n. Can you help her?
If there are many answers print any. We can show that answer always exists for the given constraints.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 100) — the number of test cases. Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of elements in the list a.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 50) — the elements of a.
It is guaranteed that the sum of n over all test cases does not exceed 100.
Output
For each test case:
Output n+1 lines. In the i-th line print string s_i (1 ≤ |s_i| ≤ 200), consisting of lowercase Latin letters. Length of the longest common prefix of strings s_i and s_{i+1} has to be equal to a_i.
If there are many answers print any. We can show that answer always exists for the given constraints.
Example
Input
4
4
1 2 4 2
2
5 3
3
1 3 1
3
0 0 0
Output
aeren
ari
arousal
around
ari
monogon
monogamy
monthly
kevinvu
kuroni
kurioni
korone
anton
loves
adhoc
problems
Note
In the 1-st test case one of the possible answers is s = [aeren, ari, arousal, around, ari].
Lengths of longest common prefixes are:
* Between \color{red}{a}eren and \color{red}{a}ri → 1
* Between \color{red}{ar}i and \color{red}{ar}ousal → 2
* Between \color{red}{arou}sal and \color{red}{arou}nd → 4
* Between \color{red}{ar}ound and \color{red}{ar}i → 2
|
instruction
| 0
| 108,009
| 0
| 216,018
|
Tags: constructive algorithms, greedy, strings
Correct Solution:
```
# dcordb's solution idea
import sys
input = sys.stdin.readline
for _ in range(int(input())):
n = int(input())
a = list(map(int,input().split()))
mx = max(a)
ans = ['a'*(mx+1) for i in range(n+1)]
for i in range(n):
s = 'a' if ans[i][a[i]] == 'b' else 'b'
ans[i+1] = ans[i][:a[i]] + s + ans[i][a[i]+1:]
for i in ans: print(i)
```
|
output
| 1
| 108,009
| 0
| 216,019
|
Provide tags and a correct Python 3 solution for this coding contest problem.
The length of the longest common prefix of two strings s = s_1 s_2 … s_n and t = t_1 t_2 … t_m is defined as the maximum integer k (0 ≤ k ≤ min(n,m)) such that s_1 s_2 … s_k equals t_1 t_2 … t_k.
Koa the Koala initially has n+1 strings s_1, s_2, ..., s_{n+1}.
For each i (1 ≤ i ≤ n) she calculated a_i — the length of the longest common prefix of s_i and s_{i+1}.
Several days later Koa found these numbers, but she couldn't remember the strings.
So Koa would like to find some strings s_1, s_2, ..., s_{n+1} which would have generated numbers a_1, a_2, ..., a_n. Can you help her?
If there are many answers print any. We can show that answer always exists for the given constraints.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 100) — the number of test cases. Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of elements in the list a.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 50) — the elements of a.
It is guaranteed that the sum of n over all test cases does not exceed 100.
Output
For each test case:
Output n+1 lines. In the i-th line print string s_i (1 ≤ |s_i| ≤ 200), consisting of lowercase Latin letters. Length of the longest common prefix of strings s_i and s_{i+1} has to be equal to a_i.
If there are many answers print any. We can show that answer always exists for the given constraints.
Example
Input
4
4
1 2 4 2
2
5 3
3
1 3 1
3
0 0 0
Output
aeren
ari
arousal
around
ari
monogon
monogamy
monthly
kevinvu
kuroni
kurioni
korone
anton
loves
adhoc
problems
Note
In the 1-st test case one of the possible answers is s = [aeren, ari, arousal, around, ari].
Lengths of longest common prefixes are:
* Between \color{red}{a}eren and \color{red}{a}ri → 1
* Between \color{red}{ar}i and \color{red}{ar}ousal → 2
* Between \color{red}{arou}sal and \color{red}{arou}nd → 4
* Between \color{red}{ar}ound and \color{red}{ar}i → 2
|
instruction
| 0
| 108,010
| 0
| 216,020
|
Tags: constructive algorithms, greedy, strings
Correct Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
l = list(map(int, input().split()))
a = ['a'] * 200
print(*a, sep = '')
for i in l:
for j in range(i, 200):
if a[j] == 'b':
a[j] = 'a'
elif a[j] == 'a':
a[j] = 'b'
print(*a, sep = '')
```
|
output
| 1
| 108,010
| 0
| 216,021
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The length of the longest common prefix of two strings s = s_1 s_2 … s_n and t = t_1 t_2 … t_m is defined as the maximum integer k (0 ≤ k ≤ min(n,m)) such that s_1 s_2 … s_k equals t_1 t_2 … t_k.
Koa the Koala initially has n+1 strings s_1, s_2, ..., s_{n+1}.
For each i (1 ≤ i ≤ n) she calculated a_i — the length of the longest common prefix of s_i and s_{i+1}.
Several days later Koa found these numbers, but she couldn't remember the strings.
So Koa would like to find some strings s_1, s_2, ..., s_{n+1} which would have generated numbers a_1, a_2, ..., a_n. Can you help her?
If there are many answers print any. We can show that answer always exists for the given constraints.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 100) — the number of test cases. Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of elements in the list a.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 50) — the elements of a.
It is guaranteed that the sum of n over all test cases does not exceed 100.
Output
For each test case:
Output n+1 lines. In the i-th line print string s_i (1 ≤ |s_i| ≤ 200), consisting of lowercase Latin letters. Length of the longest common prefix of strings s_i and s_{i+1} has to be equal to a_i.
If there are many answers print any. We can show that answer always exists for the given constraints.
Example
Input
4
4
1 2 4 2
2
5 3
3
1 3 1
3
0 0 0
Output
aeren
ari
arousal
around
ari
monogon
monogamy
monthly
kevinvu
kuroni
kurioni
korone
anton
loves
adhoc
problems
Note
In the 1-st test case one of the possible answers is s = [aeren, ari, arousal, around, ari].
Lengths of longest common prefixes are:
* Between \color{red}{a}eren and \color{red}{a}ri → 1
* Between \color{red}{ar}i and \color{red}{ar}ousal → 2
* Between \color{red}{arou}sal and \color{red}{arou}nd → 4
* Between \color{red}{ar}ound and \color{red}{ar}i → 2
Submitted Solution:
```
import sys
readline = sys.stdin.readline
def solve():
N = int(readline())
A = list(map(int, readline().split()))
s = 'a' * A[0] + 'b'
print(s)
for i, a in enumerate(A):
prefix = s[:a]
filler = 'x' if s[a] != 'x' else 'y'
if i == len(A) - 1:
s = prefix + filler
else:
s = prefix + (filler * (A[i + 1] - len(prefix) + 1))
print(s)
T = int(readline())
for t in range(T):
solve()
```
|
instruction
| 0
| 108,011
| 0
| 216,022
|
Yes
|
output
| 1
| 108,011
| 0
| 216,023
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The length of the longest common prefix of two strings s = s_1 s_2 … s_n and t = t_1 t_2 … t_m is defined as the maximum integer k (0 ≤ k ≤ min(n,m)) such that s_1 s_2 … s_k equals t_1 t_2 … t_k.
Koa the Koala initially has n+1 strings s_1, s_2, ..., s_{n+1}.
For each i (1 ≤ i ≤ n) she calculated a_i — the length of the longest common prefix of s_i and s_{i+1}.
Several days later Koa found these numbers, but she couldn't remember the strings.
So Koa would like to find some strings s_1, s_2, ..., s_{n+1} which would have generated numbers a_1, a_2, ..., a_n. Can you help her?
If there are many answers print any. We can show that answer always exists for the given constraints.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 100) — the number of test cases. Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of elements in the list a.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 50) — the elements of a.
It is guaranteed that the sum of n over all test cases does not exceed 100.
Output
For each test case:
Output n+1 lines. In the i-th line print string s_i (1 ≤ |s_i| ≤ 200), consisting of lowercase Latin letters. Length of the longest common prefix of strings s_i and s_{i+1} has to be equal to a_i.
If there are many answers print any. We can show that answer always exists for the given constraints.
Example
Input
4
4
1 2 4 2
2
5 3
3
1 3 1
3
0 0 0
Output
aeren
ari
arousal
around
ari
monogon
monogamy
monthly
kevinvu
kuroni
kurioni
korone
anton
loves
adhoc
problems
Note
In the 1-st test case one of the possible answers is s = [aeren, ari, arousal, around, ari].
Lengths of longest common prefixes are:
* Between \color{red}{a}eren and \color{red}{a}ri → 1
* Between \color{red}{ar}i and \color{red}{ar}ousal → 2
* Between \color{red}{arou}sal and \color{red}{arou}nd → 4
* Between \color{red}{ar}ound and \color{red}{ar}i → 2
Submitted Solution:
```
t=int(input())
for i in range(t):
n=int(input())
l=list(map(int,input().split()))
maxx=max(l)
s='a'*(maxx+1)
print(s)
for j in range(n):
gen=""
for k in range(0,l[j]):
gen+=s[k]
for k in range(l[j],maxx+1):
num=ord(s[k])+1
if(num>=123):
num%=123
num+=97
gen+=chr(num)
print(gen)
s=gen
```
|
instruction
| 0
| 108,012
| 0
| 216,024
|
Yes
|
output
| 1
| 108,012
| 0
| 216,025
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The length of the longest common prefix of two strings s = s_1 s_2 … s_n and t = t_1 t_2 … t_m is defined as the maximum integer k (0 ≤ k ≤ min(n,m)) such that s_1 s_2 … s_k equals t_1 t_2 … t_k.
Koa the Koala initially has n+1 strings s_1, s_2, ..., s_{n+1}.
For each i (1 ≤ i ≤ n) she calculated a_i — the length of the longest common prefix of s_i and s_{i+1}.
Several days later Koa found these numbers, but she couldn't remember the strings.
So Koa would like to find some strings s_1, s_2, ..., s_{n+1} which would have generated numbers a_1, a_2, ..., a_n. Can you help her?
If there are many answers print any. We can show that answer always exists for the given constraints.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 100) — the number of test cases. Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of elements in the list a.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 50) — the elements of a.
It is guaranteed that the sum of n over all test cases does not exceed 100.
Output
For each test case:
Output n+1 lines. In the i-th line print string s_i (1 ≤ |s_i| ≤ 200), consisting of lowercase Latin letters. Length of the longest common prefix of strings s_i and s_{i+1} has to be equal to a_i.
If there are many answers print any. We can show that answer always exists for the given constraints.
Example
Input
4
4
1 2 4 2
2
5 3
3
1 3 1
3
0 0 0
Output
aeren
ari
arousal
around
ari
monogon
monogamy
monthly
kevinvu
kuroni
kurioni
korone
anton
loves
adhoc
problems
Note
In the 1-st test case one of the possible answers is s = [aeren, ari, arousal, around, ari].
Lengths of longest common prefixes are:
* Between \color{red}{a}eren and \color{red}{a}ri → 1
* Between \color{red}{ar}i and \color{red}{ar}ousal → 2
* Between \color{red}{arou}sal and \color{red}{arou}nd → 4
* Between \color{red}{ar}ound and \color{red}{ar}i → 2
Submitted Solution:
```
for t in range(int(input())):
n=int(input())
n1=map(int,input().split())
N=list(n1)
n2=[N[0]]
n2.extend(N)
c=[]
if max(N)>0:
for _ in range (max(N)):
c.append('a')
print(''.join(c))
for i in range (n):
if N[i]<max(N):
if c[N[i]]=='a':
for ii in range(N[i],len(c)):
c[ii]='b'
else:
for jj in range (n2[i+1],len(c)):
c[jj]='a'
else:
pass
print(''.join(c))
else:
for _ in range (max(n2)+1):
c.append('a')
print(''.join(c))
for i in range (n):
if c[n2[i+1]]=='a':
for ii in range(n2[i+1],len(c)):
c[ii]='b'
else:
for jj in range (n2[i+1],len(c)):
c[jj]='a'
print(''.join(c))
```
|
instruction
| 0
| 108,013
| 0
| 216,026
|
Yes
|
output
| 1
| 108,013
| 0
| 216,027
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The length of the longest common prefix of two strings s = s_1 s_2 … s_n and t = t_1 t_2 … t_m is defined as the maximum integer k (0 ≤ k ≤ min(n,m)) such that s_1 s_2 … s_k equals t_1 t_2 … t_k.
Koa the Koala initially has n+1 strings s_1, s_2, ..., s_{n+1}.
For each i (1 ≤ i ≤ n) she calculated a_i — the length of the longest common prefix of s_i and s_{i+1}.
Several days later Koa found these numbers, but she couldn't remember the strings.
So Koa would like to find some strings s_1, s_2, ..., s_{n+1} which would have generated numbers a_1, a_2, ..., a_n. Can you help her?
If there are many answers print any. We can show that answer always exists for the given constraints.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 100) — the number of test cases. Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of elements in the list a.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 50) — the elements of a.
It is guaranteed that the sum of n over all test cases does not exceed 100.
Output
For each test case:
Output n+1 lines. In the i-th line print string s_i (1 ≤ |s_i| ≤ 200), consisting of lowercase Latin letters. Length of the longest common prefix of strings s_i and s_{i+1} has to be equal to a_i.
If there are many answers print any. We can show that answer always exists for the given constraints.
Example
Input
4
4
1 2 4 2
2
5 3
3
1 3 1
3
0 0 0
Output
aeren
ari
arousal
around
ari
monogon
monogamy
monthly
kevinvu
kuroni
kurioni
korone
anton
loves
adhoc
problems
Note
In the 1-st test case one of the possible answers is s = [aeren, ari, arousal, around, ari].
Lengths of longest common prefixes are:
* Between \color{red}{a}eren and \color{red}{a}ri → 1
* Between \color{red}{ar}i and \color{red}{ar}ousal → 2
* Between \color{red}{arou}sal and \color{red}{arou}nd → 4
* Between \color{red}{ar}ound and \color{red}{ar}i → 2
Submitted Solution:
```
def ii():return int(input())
def si():return input()
def mi():return map(int,input().split())
def li():return list(mi())
for _ in range(ii()):
n=ii()
a=li()
if(a[0]>0):
s='a'*a[0]
ans=[s,s]
else:
ans=['a','b']
for i in range(1,n):
x=a[i]
s1=ans[-1]
if len(s1)<x:
f=0
s2=ans[-2]
if len(s2)>len(s1) and s2[len(s1)]=='z':
f=1
if f==0:
s=s1+'z'*(x-len(s1))
ans[-1]=s
else:
s=s1+'y'*(x-len(s1))
ans[-1]=s
else:
if x==0:
if s1[0]!='z':
s='z'
else:
s='y'
else:
s=s1[:x]
ans.append(s)
for i in ans:
print(i)
```
|
instruction
| 0
| 108,014
| 0
| 216,028
|
Yes
|
output
| 1
| 108,014
| 0
| 216,029
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The length of the longest common prefix of two strings s = s_1 s_2 … s_n and t = t_1 t_2 … t_m is defined as the maximum integer k (0 ≤ k ≤ min(n,m)) such that s_1 s_2 … s_k equals t_1 t_2 … t_k.
Koa the Koala initially has n+1 strings s_1, s_2, ..., s_{n+1}.
For each i (1 ≤ i ≤ n) she calculated a_i — the length of the longest common prefix of s_i and s_{i+1}.
Several days later Koa found these numbers, but she couldn't remember the strings.
So Koa would like to find some strings s_1, s_2, ..., s_{n+1} which would have generated numbers a_1, a_2, ..., a_n. Can you help her?
If there are many answers print any. We can show that answer always exists for the given constraints.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 100) — the number of test cases. Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of elements in the list a.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 50) — the elements of a.
It is guaranteed that the sum of n over all test cases does not exceed 100.
Output
For each test case:
Output n+1 lines. In the i-th line print string s_i (1 ≤ |s_i| ≤ 200), consisting of lowercase Latin letters. Length of the longest common prefix of strings s_i and s_{i+1} has to be equal to a_i.
If there are many answers print any. We can show that answer always exists for the given constraints.
Example
Input
4
4
1 2 4 2
2
5 3
3
1 3 1
3
0 0 0
Output
aeren
ari
arousal
around
ari
monogon
monogamy
monthly
kevinvu
kuroni
kurioni
korone
anton
loves
adhoc
problems
Note
In the 1-st test case one of the possible answers is s = [aeren, ari, arousal, around, ari].
Lengths of longest common prefixes are:
* Between \color{red}{a}eren and \color{red}{a}ri → 1
* Between \color{red}{ar}i and \color{red}{ar}ousal → 2
* Between \color{red}{arou}sal and \color{red}{arou}nd → 4
* Between \color{red}{ar}ound and \color{red}{ar}i → 2
Submitted Solution:
```
from collections import deque
for _ in range(int(input())):
n = int(input())
s = deque(map(int, input().split()))
print("a" * 51)
s.appendleft(51)
for i in range(1, n + 1):
print(s[i] * "a")
```
|
instruction
| 0
| 108,015
| 0
| 216,030
|
No
|
output
| 1
| 108,015
| 0
| 216,031
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The length of the longest common prefix of two strings s = s_1 s_2 … s_n and t = t_1 t_2 … t_m is defined as the maximum integer k (0 ≤ k ≤ min(n,m)) such that s_1 s_2 … s_k equals t_1 t_2 … t_k.
Koa the Koala initially has n+1 strings s_1, s_2, ..., s_{n+1}.
For each i (1 ≤ i ≤ n) she calculated a_i — the length of the longest common prefix of s_i and s_{i+1}.
Several days later Koa found these numbers, but she couldn't remember the strings.
So Koa would like to find some strings s_1, s_2, ..., s_{n+1} which would have generated numbers a_1, a_2, ..., a_n. Can you help her?
If there are many answers print any. We can show that answer always exists for the given constraints.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 100) — the number of test cases. Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of elements in the list a.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 50) — the elements of a.
It is guaranteed that the sum of n over all test cases does not exceed 100.
Output
For each test case:
Output n+1 lines. In the i-th line print string s_i (1 ≤ |s_i| ≤ 200), consisting of lowercase Latin letters. Length of the longest common prefix of strings s_i and s_{i+1} has to be equal to a_i.
If there are many answers print any. We can show that answer always exists for the given constraints.
Example
Input
4
4
1 2 4 2
2
5 3
3
1 3 1
3
0 0 0
Output
aeren
ari
arousal
around
ari
monogon
monogamy
monthly
kevinvu
kuroni
kurioni
korone
anton
loves
adhoc
problems
Note
In the 1-st test case one of the possible answers is s = [aeren, ari, arousal, around, ari].
Lengths of longest common prefixes are:
* Between \color{red}{a}eren and \color{red}{a}ri → 1
* Between \color{red}{ar}i and \color{red}{ar}ousal → 2
* Between \color{red}{arou}sal and \color{red}{arou}nd → 4
* Between \color{red}{ar}ound and \color{red}{ar}i → 2
Submitted Solution:
```
import os
import heapq
import sys
import math
import bisect
import operator
from collections import defaultdict
from io import BytesIO, IOBase
def gcd(a,b):
if b==0:
return a
else:
return gcd(b,a%b)
def power(x, p,m):
res = 1
while p:
if p & 1:
res = (res * x) % m
x = (x * x) % m
p >>= 1
return res
def inar():
return [int(k) for k in input().split()]
# def bubbleSort(arr,b):
# n = len(arr)
# for i in range(n):
# for j in range(0, n - i - 1):
# if arr[j] > arr[j + 1] and b[j]!=b[j+1]:
# arr[j], arr[j + 1] = arr[j + 1], arr[j]
# b[j],b[j+1]=b[j+1],b[j]
def lcm(num1,num2):
return (num1*num2)//gcd(num1,num2)
def main():
for _ in range(int(input())):
n=int(input())
#n,k=map(int,input().split())
arr=inar()
res="abcdefghijklmnopqrstuvwxyz"
c=0
st=["a"*arr[0],"a"*arr[0]]
for i in range(1,n):
if arr[i]>arr[i-1]:
rem=arr[i]-len(st[i])
c=(c+1)%26
st[i]+=res[c+1]*rem
st.append(st[i])
else:
temp=st[i][0:arr[i]]
st.append(temp)
for i in range(len(st)):
print(st[i])
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")
if __name__ == "__main__":
main()
```
|
instruction
| 0
| 108,016
| 0
| 216,032
|
No
|
output
| 1
| 108,016
| 0
| 216,033
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The length of the longest common prefix of two strings s = s_1 s_2 … s_n and t = t_1 t_2 … t_m is defined as the maximum integer k (0 ≤ k ≤ min(n,m)) such that s_1 s_2 … s_k equals t_1 t_2 … t_k.
Koa the Koala initially has n+1 strings s_1, s_2, ..., s_{n+1}.
For each i (1 ≤ i ≤ n) she calculated a_i — the length of the longest common prefix of s_i and s_{i+1}.
Several days later Koa found these numbers, but she couldn't remember the strings.
So Koa would like to find some strings s_1, s_2, ..., s_{n+1} which would have generated numbers a_1, a_2, ..., a_n. Can you help her?
If there are many answers print any. We can show that answer always exists for the given constraints.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 100) — the number of test cases. Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of elements in the list a.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 50) — the elements of a.
It is guaranteed that the sum of n over all test cases does not exceed 100.
Output
For each test case:
Output n+1 lines. In the i-th line print string s_i (1 ≤ |s_i| ≤ 200), consisting of lowercase Latin letters. Length of the longest common prefix of strings s_i and s_{i+1} has to be equal to a_i.
If there are many answers print any. We can show that answer always exists for the given constraints.
Example
Input
4
4
1 2 4 2
2
5 3
3
1 3 1
3
0 0 0
Output
aeren
ari
arousal
around
ari
monogon
monogamy
monthly
kevinvu
kuroni
kurioni
korone
anton
loves
adhoc
problems
Note
In the 1-st test case one of the possible answers is s = [aeren, ari, arousal, around, ari].
Lengths of longest common prefixes are:
* Between \color{red}{a}eren and \color{red}{a}ri → 1
* Between \color{red}{ar}i and \color{red}{ar}ousal → 2
* Between \color{red}{arou}sal and \color{red}{arou}nd → 4
* Between \color{red}{ar}ound and \color{red}{ar}i → 2
Submitted Solution:
```
# cook your dish here
T=int(input())
l= ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
for i in range(0,T):
n=int(input())
a=[]
a=list(map(int,input().split()))
s=''
p=0
for i in range(max(a)):
s=s+l[(i%26)]
print(s)
for j in range(0,n):
s=s[:a[j]]+l[p]+s[(a[j]+1):]
p+=1
print(s)
```
|
instruction
| 0
| 108,017
| 0
| 216,034
|
No
|
output
| 1
| 108,017
| 0
| 216,035
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The length of the longest common prefix of two strings s = s_1 s_2 … s_n and t = t_1 t_2 … t_m is defined as the maximum integer k (0 ≤ k ≤ min(n,m)) such that s_1 s_2 … s_k equals t_1 t_2 … t_k.
Koa the Koala initially has n+1 strings s_1, s_2, ..., s_{n+1}.
For each i (1 ≤ i ≤ n) she calculated a_i — the length of the longest common prefix of s_i and s_{i+1}.
Several days later Koa found these numbers, but she couldn't remember the strings.
So Koa would like to find some strings s_1, s_2, ..., s_{n+1} which would have generated numbers a_1, a_2, ..., a_n. Can you help her?
If there are many answers print any. We can show that answer always exists for the given constraints.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 100) — the number of test cases. Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of elements in the list a.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 50) — the elements of a.
It is guaranteed that the sum of n over all test cases does not exceed 100.
Output
For each test case:
Output n+1 lines. In the i-th line print string s_i (1 ≤ |s_i| ≤ 200), consisting of lowercase Latin letters. Length of the longest common prefix of strings s_i and s_{i+1} has to be equal to a_i.
If there are many answers print any. We can show that answer always exists for the given constraints.
Example
Input
4
4
1 2 4 2
2
5 3
3
1 3 1
3
0 0 0
Output
aeren
ari
arousal
around
ari
monogon
monogamy
monthly
kevinvu
kuroni
kurioni
korone
anton
loves
adhoc
problems
Note
In the 1-st test case one of the possible answers is s = [aeren, ari, arousal, around, ari].
Lengths of longest common prefixes are:
* Between \color{red}{a}eren and \color{red}{a}ri → 1
* Between \color{red}{ar}i and \color{red}{ar}ousal → 2
* Between \color{red}{arou}sal and \color{red}{arou}nd → 4
* Between \color{red}{ar}ound and \color{red}{ar}i → 2
Submitted Solution:
```
# @author - Kaleab Asfaw
import sys
input = sys.stdin.readline
#for _ in range(int(input())):
#lst = list(map(int, input().split()))
#def main():
# ****************************** START ********************************
def main(n, a):
b = max(a)
e = 0
if a == [0] * n:
for i in range(n+1):
if e % 2: print("c"); e+=1
elif e % 2 == 0: print("d");e+=1
if i == n: return
for i in a:
if i == 0 and e % 2: print("c"); e+=1
elif i == 0 and e % 2 == 0: print("d");e+=1
else:
print("a" * i + "b")
if i == b:
print("a" * i + "b")
return
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
main(n, a)
```
|
instruction
| 0
| 108,018
| 0
| 216,036
|
No
|
output
| 1
| 108,018
| 0
| 216,037
|
Evaluate the correctness of the submitted Python 2 solution to the coding contest problem. Provide a "Yes" or "No" response.
The length of the longest common prefix of two strings s = s_1 s_2 … s_n and t = t_1 t_2 … t_m is defined as the maximum integer k (0 ≤ k ≤ min(n,m)) such that s_1 s_2 … s_k equals t_1 t_2 … t_k.
Koa the Koala initially has n+1 strings s_1, s_2, ..., s_{n+1}.
For each i (1 ≤ i ≤ n) she calculated a_i — the length of the longest common prefix of s_i and s_{i+1}.
Several days later Koa found these numbers, but she couldn't remember the strings.
So Koa would like to find some strings s_1, s_2, ..., s_{n+1} which would have generated numbers a_1, a_2, ..., a_n. Can you help her?
If there are many answers print any. We can show that answer always exists for the given constraints.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 100) — the number of test cases. Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100) — the number of elements in the list a.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 50) — the elements of a.
It is guaranteed that the sum of n over all test cases does not exceed 100.
Output
For each test case:
Output n+1 lines. In the i-th line print string s_i (1 ≤ |s_i| ≤ 200), consisting of lowercase Latin letters. Length of the longest common prefix of strings s_i and s_{i+1} has to be equal to a_i.
If there are many answers print any. We can show that answer always exists for the given constraints.
Example
Input
4
4
1 2 4 2
2
5 3
3
1 3 1
3
0 0 0
Output
aeren
ari
arousal
around
ari
monogon
monogamy
monthly
kevinvu
kuroni
kurioni
korone
anton
loves
adhoc
problems
Note
In the 1-st test case one of the possible answers is s = [aeren, ari, arousal, around, ari].
Lengths of longest common prefixes are:
* Between \color{red}{a}eren and \color{red}{a}ri → 1
* Between \color{red}{ar}i and \color{red}{ar}ousal → 2
* Between \color{red}{arou}sal and \color{red}{arou}nd → 4
* Between \color{red}{ar}ound and \color{red}{ar}i → 2
Submitted Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
pr=stdout.write
import heapq
raw_input = stdin.readline
def ni():
return int(raw_input())
def li():
return list(map(int,raw_input().split()))
def pn(n):
stdout.write(str(n)+'\n')
def pa(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return (map(int,stdin.read().split()))
range = xrange # not for python 3.0+
# main code
for t in range(ni()):
n=ni()
l=li()
if l[0]:
ans=['a'*l[0],'a'*l[0]]
else:
ans=['a','b']
for i in range(1,n):
if l[i]<=l[i-1]:
if l[i]:
ans.append(ans[-1][:l[i]])
else:
ans.append(chr(97+(ord(ans[-1][0])-96)%26))
else:
#print ord(ans[-1][-1])
ch = chr(97+((ord(ans[-1][-1])-96)%26))
temp=ans[-1] + ch*(l[i]-l[i-1])
ans[-1]=temp
ans.append(temp)
cur=0
for x in ans:
tp=x
if not tp:
tp=chr(97+curr)
curr=(curr+1)%26
pr(tp+'\n')
```
|
instruction
| 0
| 108,019
| 0
| 216,038
|
No
|
output
| 1
| 108,019
| 0
| 216,039
|
Provide tags and a correct Python 3 solution for this coding contest problem.
A string t is called an anagram of the string s, if it is possible to rearrange letters in t so that it is identical to the string s. For example, the string "aab" is an anagram of the string "aba" and the string "aaa" is not.
The string t is called a substring of the string s if it can be read starting from some position in the string s. For example, the string "aba" has six substrings: "a", "b", "a", "ab", "ba", "aba".
You are given a string s, consisting of lowercase Latin letters and characters "?". You are also given a string p, consisting of lowercase Latin letters only. Let's assume that a string is good if you can obtain an anagram of the string p from it, replacing the "?" characters by Latin letters. Each "?" can be replaced by exactly one character of the Latin alphabet. For example, if the string p = «aba», then the string "a??" is good, and the string «?bc» is not.
Your task is to find the number of good substrings of the string s (identical substrings must be counted in the answer several times).
Input
The first line is non-empty string s, consisting of no more than 105 lowercase Latin letters and characters "?". The second line is non-empty string p, consisting of no more than 105 lowercase Latin letters. Please note that the length of the string p can exceed the length of the string s.
Output
Print the single number representing the number of good substrings of string s.
Two substrings are considered different in their positions of occurrence are different. Thus, if some string occurs several times, then it should be counted the same number of times.
Examples
Input
bb??x???
aab
Output
2
Input
ab?c
acb
Output
2
Note
Consider the first sample test. Here the string s has two good substrings: "b??" (after we replace the question marks we get "baa"), "???" (after we replace the question marks we get "baa").
Let's consider the second sample test. Here the string s has two good substrings: "ab?" ("?" can be replaced by "c"), "b?c" ("?" can be replaced by "a").
|
instruction
| 0
| 108,052
| 0
| 216,104
|
Tags: implementation, strings
Correct 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
s = input()
p = dd(int)
m = 0
for i in input():
p[i] += 1
m += 1
n = len(s)
d = dd(int)
ans = 0
for i in range(n):
d[s[i]] += 1
if i >= m:
d[s[i - m]] -= 1
cur = 0
for j in range(97, 123):
x = chr(j)
if p[x]:
cur += abs(p[x] - d[x])
if cur == d['?']:
ans += 1
print(ans)
```
|
output
| 1
| 108,052
| 0
| 216,105
|
Provide tags and a correct Python 3 solution for this coding contest problem.
A string t is called an anagram of the string s, if it is possible to rearrange letters in t so that it is identical to the string s. For example, the string "aab" is an anagram of the string "aba" and the string "aaa" is not.
The string t is called a substring of the string s if it can be read starting from some position in the string s. For example, the string "aba" has six substrings: "a", "b", "a", "ab", "ba", "aba".
You are given a string s, consisting of lowercase Latin letters and characters "?". You are also given a string p, consisting of lowercase Latin letters only. Let's assume that a string is good if you can obtain an anagram of the string p from it, replacing the "?" characters by Latin letters. Each "?" can be replaced by exactly one character of the Latin alphabet. For example, if the string p = «aba», then the string "a??" is good, and the string «?bc» is not.
Your task is to find the number of good substrings of the string s (identical substrings must be counted in the answer several times).
Input
The first line is non-empty string s, consisting of no more than 105 lowercase Latin letters and characters "?". The second line is non-empty string p, consisting of no more than 105 lowercase Latin letters. Please note that the length of the string p can exceed the length of the string s.
Output
Print the single number representing the number of good substrings of string s.
Two substrings are considered different in their positions of occurrence are different. Thus, if some string occurs several times, then it should be counted the same number of times.
Examples
Input
bb??x???
aab
Output
2
Input
ab?c
acb
Output
2
Note
Consider the first sample test. Here the string s has two good substrings: "b??" (after we replace the question marks we get "baa"), "???" (after we replace the question marks we get "baa").
Let's consider the second sample test. Here the string s has two good substrings: "ab?" ("?" can be replaced by "c"), "b?c" ("?" can be replaced by "a").
|
instruction
| 0
| 108,053
| 0
| 216,106
|
Tags: implementation, strings
Correct Solution:
```
def check(l):
for _ in l:
if _<0:
return False
return True
a=input()
b=input()
ll=len(b)
lll=len(a)
if ll>lll:
print(0)
else:
l=[0]*26
for _ in b:
l[ord(_)-ord('a')]+=1
for i in range(ll):
if a[i]!='?':
l[ord(a[i])-ord('a')]-=1
c=0
if check(l):
c+=1
for i in range(ll,lll):
if a[i-ll]!='?':
l[ord(a[i-ll])-ord('a')]+=1
if a[i]!='?':
l[ord(a[i])-ord('a')]-=1
if check(l):
c+=1
print(c)
```
|
output
| 1
| 108,053
| 0
| 216,107
|
Provide tags and a correct Python 3 solution for this coding contest problem.
A string t is called an anagram of the string s, if it is possible to rearrange letters in t so that it is identical to the string s. For example, the string "aab" is an anagram of the string "aba" and the string "aaa" is not.
The string t is called a substring of the string s if it can be read starting from some position in the string s. For example, the string "aba" has six substrings: "a", "b", "a", "ab", "ba", "aba".
You are given a string s, consisting of lowercase Latin letters and characters "?". You are also given a string p, consisting of lowercase Latin letters only. Let's assume that a string is good if you can obtain an anagram of the string p from it, replacing the "?" characters by Latin letters. Each "?" can be replaced by exactly one character of the Latin alphabet. For example, if the string p = «aba», then the string "a??" is good, and the string «?bc» is not.
Your task is to find the number of good substrings of the string s (identical substrings must be counted in the answer several times).
Input
The first line is non-empty string s, consisting of no more than 105 lowercase Latin letters and characters "?". The second line is non-empty string p, consisting of no more than 105 lowercase Latin letters. Please note that the length of the string p can exceed the length of the string s.
Output
Print the single number representing the number of good substrings of string s.
Two substrings are considered different in their positions of occurrence are different. Thus, if some string occurs several times, then it should be counted the same number of times.
Examples
Input
bb??x???
aab
Output
2
Input
ab?c
acb
Output
2
Note
Consider the first sample test. Here the string s has two good substrings: "b??" (after we replace the question marks we get "baa"), "???" (after we replace the question marks we get "baa").
Let's consider the second sample test. Here the string s has two good substrings: "ab?" ("?" can be replaced by "c"), "b?c" ("?" can be replaced by "a").
|
instruction
| 0
| 108,054
| 0
| 216,108
|
Tags: implementation, strings
Correct Solution:
```
from collections import Counter as C
s, p = '_' + input(), input()
L, k = len(p), 0
Cs, Cp = C(s[:L]), C(p)
for i in range(len(s) - L):
Cs = Cs - C(s[i]) + C(s[L+i])
k += (Cs - Cp).keys() <= {'?'}
print(k)
```
|
output
| 1
| 108,054
| 0
| 216,109
|
Provide tags and a correct Python 3 solution for this coding contest problem.
A string t is called an anagram of the string s, if it is possible to rearrange letters in t so that it is identical to the string s. For example, the string "aab" is an anagram of the string "aba" and the string "aaa" is not.
The string t is called a substring of the string s if it can be read starting from some position in the string s. For example, the string "aba" has six substrings: "a", "b", "a", "ab", "ba", "aba".
You are given a string s, consisting of lowercase Latin letters and characters "?". You are also given a string p, consisting of lowercase Latin letters only. Let's assume that a string is good if you can obtain an anagram of the string p from it, replacing the "?" characters by Latin letters. Each "?" can be replaced by exactly one character of the Latin alphabet. For example, if the string p = «aba», then the string "a??" is good, and the string «?bc» is not.
Your task is to find the number of good substrings of the string s (identical substrings must be counted in the answer several times).
Input
The first line is non-empty string s, consisting of no more than 105 lowercase Latin letters and characters "?". The second line is non-empty string p, consisting of no more than 105 lowercase Latin letters. Please note that the length of the string p can exceed the length of the string s.
Output
Print the single number representing the number of good substrings of string s.
Two substrings are considered different in their positions of occurrence are different. Thus, if some string occurs several times, then it should be counted the same number of times.
Examples
Input
bb??x???
aab
Output
2
Input
ab?c
acb
Output
2
Note
Consider the first sample test. Here the string s has two good substrings: "b??" (after we replace the question marks we get "baa"), "???" (after we replace the question marks we get "baa").
Let's consider the second sample test. Here the string s has two good substrings: "ab?" ("?" can be replaced by "c"), "b?c" ("?" can be replaced by "a").
|
instruction
| 0
| 108,055
| 0
| 216,110
|
Tags: implementation, strings
Correct Solution:
```
import math,sys
from sys import stdin, stdout
from collections import Counter, defaultdict, deque
input = stdin.readline
I = lambda:int(input())
li = lambda:list(map(int,input().split()))
def case():
a=input().strip()
b=input().strip()
d=defaultdict(int)
if(len(a)<len(b)):
print(0)
return
d=Counter(b)
c=Counter(a[:len(b)])
f=1
x=0
y=0
ans=0
for i in d:
if(i in d and c[i]==d[i]):
continue
elif(i in d and c[i]<d[i]):
y+=d[i]-c[i]
elif(i in d and c[i]>d[i]):
f=0
elif(i not in d):
f=0
if(f and c['?']==y):
ans+=1
#print(x,y)
for j in range(len(b),len(a)):
c[a[j-len(b)]]-=1
c[a[j]]+=1
f=1
x=0
y=0
for i in d:
if(i in d and c[i]==d[i]):
continue
elif(i in d and c[i]<d[i]):
y+=d[i]-c[i]
elif(i in d and c[i]>d[i]):
f=0
elif(i not in d):
f=0
if(f and c['?']==y):
ans+=1
print(ans)
for _ in range(1):
case()
```
|
output
| 1
| 108,055
| 0
| 216,111
|
Provide tags and a correct Python 3 solution for this coding contest problem.
A string t is called an anagram of the string s, if it is possible to rearrange letters in t so that it is identical to the string s. For example, the string "aab" is an anagram of the string "aba" and the string "aaa" is not.
The string t is called a substring of the string s if it can be read starting from some position in the string s. For example, the string "aba" has six substrings: "a", "b", "a", "ab", "ba", "aba".
You are given a string s, consisting of lowercase Latin letters and characters "?". You are also given a string p, consisting of lowercase Latin letters only. Let's assume that a string is good if you can obtain an anagram of the string p from it, replacing the "?" characters by Latin letters. Each "?" can be replaced by exactly one character of the Latin alphabet. For example, if the string p = «aba», then the string "a??" is good, and the string «?bc» is not.
Your task is to find the number of good substrings of the string s (identical substrings must be counted in the answer several times).
Input
The first line is non-empty string s, consisting of no more than 105 lowercase Latin letters and characters "?". The second line is non-empty string p, consisting of no more than 105 lowercase Latin letters. Please note that the length of the string p can exceed the length of the string s.
Output
Print the single number representing the number of good substrings of string s.
Two substrings are considered different in their positions of occurrence are different. Thus, if some string occurs several times, then it should be counted the same number of times.
Examples
Input
bb??x???
aab
Output
2
Input
ab?c
acb
Output
2
Note
Consider the first sample test. Here the string s has two good substrings: "b??" (after we replace the question marks we get "baa"), "???" (after we replace the question marks we get "baa").
Let's consider the second sample test. Here the string s has two good substrings: "ab?" ("?" can be replaced by "c"), "b?c" ("?" can be replaced by "a").
|
instruction
| 0
| 108,056
| 0
| 216,112
|
Tags: implementation, strings
Correct Solution:
```
s = input() + '?'
p = input()
cnt = 0
d = [0] * 26
for c in p:
d[ord(c)-97] += 1
for c in s[0:len(p)]:
if c != '?':
d[ord(c)-97] -= 1
for k in range(len(p), len(s)):
if min(d) >= 0:
cnt += 1
if s[k] != '?':
d[ord(s[k])-97] -= 1
if s[k-len(p)] != '?':
d[ord(s[k-len(p)])-97] += 1
print(cnt)
# Made By Mostafa_Khaled
```
|
output
| 1
| 108,056
| 0
| 216,113
|
Provide tags and a correct Python 3 solution for this coding contest problem.
A string t is called an anagram of the string s, if it is possible to rearrange letters in t so that it is identical to the string s. For example, the string "aab" is an anagram of the string "aba" and the string "aaa" is not.
The string t is called a substring of the string s if it can be read starting from some position in the string s. For example, the string "aba" has six substrings: "a", "b", "a", "ab", "ba", "aba".
You are given a string s, consisting of lowercase Latin letters and characters "?". You are also given a string p, consisting of lowercase Latin letters only. Let's assume that a string is good if you can obtain an anagram of the string p from it, replacing the "?" characters by Latin letters. Each "?" can be replaced by exactly one character of the Latin alphabet. For example, if the string p = «aba», then the string "a??" is good, and the string «?bc» is not.
Your task is to find the number of good substrings of the string s (identical substrings must be counted in the answer several times).
Input
The first line is non-empty string s, consisting of no more than 105 lowercase Latin letters and characters "?". The second line is non-empty string p, consisting of no more than 105 lowercase Latin letters. Please note that the length of the string p can exceed the length of the string s.
Output
Print the single number representing the number of good substrings of string s.
Two substrings are considered different in their positions of occurrence are different. Thus, if some string occurs several times, then it should be counted the same number of times.
Examples
Input
bb??x???
aab
Output
2
Input
ab?c
acb
Output
2
Note
Consider the first sample test. Here the string s has two good substrings: "b??" (after we replace the question marks we get "baa"), "???" (after we replace the question marks we get "baa").
Let's consider the second sample test. Here the string s has two good substrings: "ab?" ("?" can be replaced by "c"), "b?c" ("?" can be replaced by "a").
|
instruction
| 0
| 108,057
| 0
| 216,114
|
Tags: implementation, strings
Correct Solution:
```
from collections import *
def change(mi, i):
global c
for j in range(mi, i):
c[s[j]] -= 1
if s[j] == s[i]:
return j + 1
def solve():
global c
ans, mi, ls, lp = 0, 0, len(s), len(p)
for i in range(ls):
if mem[s[i]]:
if c[s[i]] >= mem[s[i]]:
mi = change(mi, i)
c[s[i]] += 1
elif s[i] != '?':
mi, c = i + 1, defaultdict(int)
if i - mi + 1 == lp:
ans += 1
c[s[mi]] -= 1
mi += 1
return ans
s, p = input(), input()
mem, c = Counter(p), defaultdict(int)
print(solve())
```
|
output
| 1
| 108,057
| 0
| 216,115
|
Provide tags and a correct Python 3 solution for this coding contest problem.
A string t is called an anagram of the string s, if it is possible to rearrange letters in t so that it is identical to the string s. For example, the string "aab" is an anagram of the string "aba" and the string "aaa" is not.
The string t is called a substring of the string s if it can be read starting from some position in the string s. For example, the string "aba" has six substrings: "a", "b", "a", "ab", "ba", "aba".
You are given a string s, consisting of lowercase Latin letters and characters "?". You are also given a string p, consisting of lowercase Latin letters only. Let's assume that a string is good if you can obtain an anagram of the string p from it, replacing the "?" characters by Latin letters. Each "?" can be replaced by exactly one character of the Latin alphabet. For example, if the string p = «aba», then the string "a??" is good, and the string «?bc» is not.
Your task is to find the number of good substrings of the string s (identical substrings must be counted in the answer several times).
Input
The first line is non-empty string s, consisting of no more than 105 lowercase Latin letters and characters "?". The second line is non-empty string p, consisting of no more than 105 lowercase Latin letters. Please note that the length of the string p can exceed the length of the string s.
Output
Print the single number representing the number of good substrings of string s.
Two substrings are considered different in their positions of occurrence are different. Thus, if some string occurs several times, then it should be counted the same number of times.
Examples
Input
bb??x???
aab
Output
2
Input
ab?c
acb
Output
2
Note
Consider the first sample test. Here the string s has two good substrings: "b??" (after we replace the question marks we get "baa"), "???" (after we replace the question marks we get "baa").
Let's consider the second sample test. Here the string s has two good substrings: "ab?" ("?" can be replaced by "c"), "b?c" ("?" can be replaced by "a").
|
instruction
| 0
| 108,058
| 0
| 216,116
|
Tags: implementation, strings
Correct Solution:
```
from collections import Counter
s,p=input(),input()
if len(s)<len(p):
print(0)
exit()
cs=Counter(s[:len(p)])
cp=Counter(p)
ans,i,L=0,0,len(p)
while True:
ans+=((cs-cp).keys()<={'?'}) # если есть кроме "?"
if i==len(s)-L: break
cs=cs-Counter(s[i])+Counter(s[i+L])
i+=1
print(ans)
```
|
output
| 1
| 108,058
| 0
| 216,117
|
Provide tags and a correct Python 3 solution for this coding contest problem.
A string t is called an anagram of the string s, if it is possible to rearrange letters in t so that it is identical to the string s. For example, the string "aab" is an anagram of the string "aba" and the string "aaa" is not.
The string t is called a substring of the string s if it can be read starting from some position in the string s. For example, the string "aba" has six substrings: "a", "b", "a", "ab", "ba", "aba".
You are given a string s, consisting of lowercase Latin letters and characters "?". You are also given a string p, consisting of lowercase Latin letters only. Let's assume that a string is good if you can obtain an anagram of the string p from it, replacing the "?" characters by Latin letters. Each "?" can be replaced by exactly one character of the Latin alphabet. For example, if the string p = «aba», then the string "a??" is good, and the string «?bc» is not.
Your task is to find the number of good substrings of the string s (identical substrings must be counted in the answer several times).
Input
The first line is non-empty string s, consisting of no more than 105 lowercase Latin letters and characters "?". The second line is non-empty string p, consisting of no more than 105 lowercase Latin letters. Please note that the length of the string p can exceed the length of the string s.
Output
Print the single number representing the number of good substrings of string s.
Two substrings are considered different in their positions of occurrence are different. Thus, if some string occurs several times, then it should be counted the same number of times.
Examples
Input
bb??x???
aab
Output
2
Input
ab?c
acb
Output
2
Note
Consider the first sample test. Here the string s has two good substrings: "b??" (after we replace the question marks we get "baa"), "???" (after we replace the question marks we get "baa").
Let's consider the second sample test. Here the string s has two good substrings: "ab?" ("?" can be replaced by "c"), "b?c" ("?" can be replaced by "a").
|
instruction
| 0
| 108,059
| 0
| 216,118
|
Tags: implementation, strings
Correct Solution:
```
s1 = input()
s2 = input()
cnt1, cnt2 = [0] * 27, [0] * 27
if len(s1) < len(s2):
print(0)
exit()
def is_valid():
res = 0
for i in range(26):
if cnt2[i] < cnt1[i]: return 0
res += cnt2[i] - cnt1[i]
return 1 if res == cnt1[26] else 0
for i in range(len(s2)):
idx = ord(s1[i]) - ord('a')
if s1[i] == '?': idx = 26
cnt1[idx] += 1
idx = ord(s2[i]) - ord('a')
cnt2[idx] += 1
res = is_valid()
for i in range(1, len(s1)-len(s2)+1):
idx = ord(s1[i-1]) - ord('a')
if s1[i-1] == '?': idx = 26
cnt1[idx] -= 1
idx = ord(s1[len(s2)+i-1]) - ord('a')
if s1[len(s2)+i-1] == '?': idx = 26
cnt1[idx] += 1
res += is_valid()
print(res)
```
|
output
| 1
| 108,059
| 0
| 216,119
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string t is called an anagram of the string s, if it is possible to rearrange letters in t so that it is identical to the string s. For example, the string "aab" is an anagram of the string "aba" and the string "aaa" is not.
The string t is called a substring of the string s if it can be read starting from some position in the string s. For example, the string "aba" has six substrings: "a", "b", "a", "ab", "ba", "aba".
You are given a string s, consisting of lowercase Latin letters and characters "?". You are also given a string p, consisting of lowercase Latin letters only. Let's assume that a string is good if you can obtain an anagram of the string p from it, replacing the "?" characters by Latin letters. Each "?" can be replaced by exactly one character of the Latin alphabet. For example, if the string p = «aba», then the string "a??" is good, and the string «?bc» is not.
Your task is to find the number of good substrings of the string s (identical substrings must be counted in the answer several times).
Input
The first line is non-empty string s, consisting of no more than 105 lowercase Latin letters and characters "?". The second line is non-empty string p, consisting of no more than 105 lowercase Latin letters. Please note that the length of the string p can exceed the length of the string s.
Output
Print the single number representing the number of good substrings of string s.
Two substrings are considered different in their positions of occurrence are different. Thus, if some string occurs several times, then it should be counted the same number of times.
Examples
Input
bb??x???
aab
Output
2
Input
ab?c
acb
Output
2
Note
Consider the first sample test. Here the string s has two good substrings: "b??" (after we replace the question marks we get "baa"), "???" (after we replace the question marks we get "baa").
Let's consider the second sample test. Here the string s has two good substrings: "ab?" ("?" can be replaced by "c"), "b?c" ("?" can be replaced by "a").
Submitted Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from heapq import*
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
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 possible():
need=0
for i in p:
need+=max(p[i]-cur[i],0)
return int(need==cur['?'])
s=input()
p=input()
k=len(p)
n=len(s)
if(k>n):
print(0)
exit()
p=Counter(p)
cur=defaultdict(int)
for i in range(k):
cur[s[i]]+=1
ans=possible()
for i in range(1,n-k+1):
start=i
end=i+k-1
# print(start,end,ans)
cur[s[start-1]]-=1
cur[s[end]]+=1
ans+=possible()
print(ans)
```
|
instruction
| 0
| 108,060
| 0
| 216,120
|
Yes
|
output
| 1
| 108,060
| 0
| 216,121
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string t is called an anagram of the string s, if it is possible to rearrange letters in t so that it is identical to the string s. For example, the string "aab" is an anagram of the string "aba" and the string "aaa" is not.
The string t is called a substring of the string s if it can be read starting from some position in the string s. For example, the string "aba" has six substrings: "a", "b", "a", "ab", "ba", "aba".
You are given a string s, consisting of lowercase Latin letters and characters "?". You are also given a string p, consisting of lowercase Latin letters only. Let's assume that a string is good if you can obtain an anagram of the string p from it, replacing the "?" characters by Latin letters. Each "?" can be replaced by exactly one character of the Latin alphabet. For example, if the string p = «aba», then the string "a??" is good, and the string «?bc» is not.
Your task is to find the number of good substrings of the string s (identical substrings must be counted in the answer several times).
Input
The first line is non-empty string s, consisting of no more than 105 lowercase Latin letters and characters "?". The second line is non-empty string p, consisting of no more than 105 lowercase Latin letters. Please note that the length of the string p can exceed the length of the string s.
Output
Print the single number representing the number of good substrings of string s.
Two substrings are considered different in their positions of occurrence are different. Thus, if some string occurs several times, then it should be counted the same number of times.
Examples
Input
bb??x???
aab
Output
2
Input
ab?c
acb
Output
2
Note
Consider the first sample test. Here the string s has two good substrings: "b??" (after we replace the question marks we get "baa"), "???" (after we replace the question marks we get "baa").
Let's consider the second sample test. Here the string s has two good substrings: "ab?" ("?" can be replaced by "c"), "b?c" ("?" can be replaced by "a").
Submitted Solution:
```
s = list(input())
t = list(input())
sd=[0]*26
td=[0]*26
l=len(t)
l1=len(s)
if l1<l:
print(0)
exit()
for i in t:
td[ord(i)-ord('a')]+=1
for i in range(min(l,l1)):
if s[i]!='?':
sd[ord(s[i])-ord('a')]+=1
ans=1
for i in range(26):
if sd[i]>td[i]:
ans=0
for i in range(1,l1-l+1):
if s[i-1]!='?':
sd[ord(s[i-1])-ord('a')]-=1
if s[i+l-1]!='?':
sd[ord(s[i+l-1])-ord('a')]+=1
ans+=1
# print(sd,td)
for j in range(26):
if sd[j]>td[j]:
ans-=1
# print('aa')
break
# print(ans)
print(ans)
```
|
instruction
| 0
| 108,061
| 0
| 216,122
|
Yes
|
output
| 1
| 108,061
| 0
| 216,123
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string t is called an anagram of the string s, if it is possible to rearrange letters in t so that it is identical to the string s. For example, the string "aab" is an anagram of the string "aba" and the string "aaa" is not.
The string t is called a substring of the string s if it can be read starting from some position in the string s. For example, the string "aba" has six substrings: "a", "b", "a", "ab", "ba", "aba".
You are given a string s, consisting of lowercase Latin letters and characters "?". You are also given a string p, consisting of lowercase Latin letters only. Let's assume that a string is good if you can obtain an anagram of the string p from it, replacing the "?" characters by Latin letters. Each "?" can be replaced by exactly one character of the Latin alphabet. For example, if the string p = «aba», then the string "a??" is good, and the string «?bc» is not.
Your task is to find the number of good substrings of the string s (identical substrings must be counted in the answer several times).
Input
The first line is non-empty string s, consisting of no more than 105 lowercase Latin letters and characters "?". The second line is non-empty string p, consisting of no more than 105 lowercase Latin letters. Please note that the length of the string p can exceed the length of the string s.
Output
Print the single number representing the number of good substrings of string s.
Two substrings are considered different in their positions of occurrence are different. Thus, if some string occurs several times, then it should be counted the same number of times.
Examples
Input
bb??x???
aab
Output
2
Input
ab?c
acb
Output
2
Note
Consider the first sample test. Here the string s has two good substrings: "b??" (after we replace the question marks we get "baa"), "???" (after we replace the question marks we get "baa").
Let's consider the second sample test. Here the string s has two good substrings: "ab?" ("?" can be replaced by "c"), "b?c" ("?" can be replaced by "a").
Submitted Solution:
```
p, t = input(), input()
n, m = len(t), len(p)
if n > m: print(0)
else:
q = {c: p[: n].count(c) - t.count(c) - 1 for c in 'abcdefghijklmnopqrstuvwxyz'}
q['?'] = 0
s = int(all(q[c] < 0 for c in 'abcdefghijklmnopqrstuvwxyz'))
for i, j in zip(*[p[: m - n], p[n :]]):
q[i] -= 1
q[j] += 1
if all(q[c] < 0 for c in 'abcdefghijklmnopqrstuvwxyz'): s += 1
print(s)
```
|
instruction
| 0
| 108,062
| 0
| 216,124
|
Yes
|
output
| 1
| 108,062
| 0
| 216,125
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string t is called an anagram of the string s, if it is possible to rearrange letters in t so that it is identical to the string s. For example, the string "aab" is an anagram of the string "aba" and the string "aaa" is not.
The string t is called a substring of the string s if it can be read starting from some position in the string s. For example, the string "aba" has six substrings: "a", "b", "a", "ab", "ba", "aba".
You are given a string s, consisting of lowercase Latin letters and characters "?". You are also given a string p, consisting of lowercase Latin letters only. Let's assume that a string is good if you can obtain an anagram of the string p from it, replacing the "?" characters by Latin letters. Each "?" can be replaced by exactly one character of the Latin alphabet. For example, if the string p = «aba», then the string "a??" is good, and the string «?bc» is not.
Your task is to find the number of good substrings of the string s (identical substrings must be counted in the answer several times).
Input
The first line is non-empty string s, consisting of no more than 105 lowercase Latin letters and characters "?". The second line is non-empty string p, consisting of no more than 105 lowercase Latin letters. Please note that the length of the string p can exceed the length of the string s.
Output
Print the single number representing the number of good substrings of string s.
Two substrings are considered different in their positions of occurrence are different. Thus, if some string occurs several times, then it should be counted the same number of times.
Examples
Input
bb??x???
aab
Output
2
Input
ab?c
acb
Output
2
Note
Consider the first sample test. Here the string s has two good substrings: "b??" (after we replace the question marks we get "baa"), "???" (after we replace the question marks we get "baa").
Let's consider the second sample test. Here the string s has two good substrings: "ab?" ("?" can be replaced by "c"), "b?c" ("?" can be replaced by "a").
Submitted Solution:
```
p, t = input() + ' ', input()
n, m = len(t), len(p)
a = {c: p[: n].count(c) for c in 'abcdefghijklmnopqrstuvwxyz '}
b = {c: t.count(c) for c in 'abcdefghijklmnopqrstuvwxyz '}
s = 0; a['?'] = 0
for i in range(m - n):
for c in 'abcdefghijklmnopqrstuvwxyz ':
if a[c] > b[c]: break
if c == ' ': s += 1
a[p[i]] -= 1
a[p[i + n]] += 1
print(s)
```
|
instruction
| 0
| 108,063
| 0
| 216,126
|
Yes
|
output
| 1
| 108,063
| 0
| 216,127
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string t is called an anagram of the string s, if it is possible to rearrange letters in t so that it is identical to the string s. For example, the string "aab" is an anagram of the string "aba" and the string "aaa" is not.
The string t is called a substring of the string s if it can be read starting from some position in the string s. For example, the string "aba" has six substrings: "a", "b", "a", "ab", "ba", "aba".
You are given a string s, consisting of lowercase Latin letters and characters "?". You are also given a string p, consisting of lowercase Latin letters only. Let's assume that a string is good if you can obtain an anagram of the string p from it, replacing the "?" characters by Latin letters. Each "?" can be replaced by exactly one character of the Latin alphabet. For example, if the string p = «aba», then the string "a??" is good, and the string «?bc» is not.
Your task is to find the number of good substrings of the string s (identical substrings must be counted in the answer several times).
Input
The first line is non-empty string s, consisting of no more than 105 lowercase Latin letters and characters "?". The second line is non-empty string p, consisting of no more than 105 lowercase Latin letters. Please note that the length of the string p can exceed the length of the string s.
Output
Print the single number representing the number of good substrings of string s.
Two substrings are considered different in their positions of occurrence are different. Thus, if some string occurs several times, then it should be counted the same number of times.
Examples
Input
bb??x???
aab
Output
2
Input
ab?c
acb
Output
2
Note
Consider the first sample test. Here the string s has two good substrings: "b??" (after we replace the question marks we get "baa"), "???" (after we replace the question marks we get "baa").
Let's consider the second sample test. Here the string s has two good substrings: "ab?" ("?" can be replaced by "c"), "b?c" ("?" can be replaced by "a").
Submitted Solution:
```
from collections import *
def solve():
ans, c, mi, ls, lp = 0, defaultdict(int), 0, len(s), len(p)
for i in range(ls):
if mem[s[i]]:
if c[s[i]] < mem[s[i]]:
c[s[i]] += 1
else:
c, mi = defaultdict(int), i
elif s[i] != '?':
mi = i + 1
if i - mi + 1 == lp:
ans += 1
c[s[mi]] -= 1
mi += 1
return ans
s, p = input(), input()
mem = Counter(p)
print(solve())
```
|
instruction
| 0
| 108,064
| 0
| 216,128
|
No
|
output
| 1
| 108,064
| 0
| 216,129
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string t is called an anagram of the string s, if it is possible to rearrange letters in t so that it is identical to the string s. For example, the string "aab" is an anagram of the string "aba" and the string "aaa" is not.
The string t is called a substring of the string s if it can be read starting from some position in the string s. For example, the string "aba" has six substrings: "a", "b", "a", "ab", "ba", "aba".
You are given a string s, consisting of lowercase Latin letters and characters "?". You are also given a string p, consisting of lowercase Latin letters only. Let's assume that a string is good if you can obtain an anagram of the string p from it, replacing the "?" characters by Latin letters. Each "?" can be replaced by exactly one character of the Latin alphabet. For example, if the string p = «aba», then the string "a??" is good, and the string «?bc» is not.
Your task is to find the number of good substrings of the string s (identical substrings must be counted in the answer several times).
Input
The first line is non-empty string s, consisting of no more than 105 lowercase Latin letters and characters "?". The second line is non-empty string p, consisting of no more than 105 lowercase Latin letters. Please note that the length of the string p can exceed the length of the string s.
Output
Print the single number representing the number of good substrings of string s.
Two substrings are considered different in their positions of occurrence are different. Thus, if some string occurs several times, then it should be counted the same number of times.
Examples
Input
bb??x???
aab
Output
2
Input
ab?c
acb
Output
2
Note
Consider the first sample test. Here the string s has two good substrings: "b??" (after we replace the question marks we get "baa"), "???" (after we replace the question marks we get "baa").
Let's consider the second sample test. Here the string s has two good substrings: "ab?" ("?" can be replaced by "c"), "b?c" ("?" can be replaced by "a").
Submitted Solution:
```
t = input()
temp = list(str(input()))
temp.sort()
p = ''.join(temp)
anagramms = 0
for i in range(len(t)-len(p)+1):
temp = list(t[i:i+len(p)])
temp.sort()
pAnag = (''.join(temp)).replace('?', '')
if p.find(pAnag) != -1:
anagramms += 1
print(anagramms)
```
|
instruction
| 0
| 108,065
| 0
| 216,130
|
No
|
output
| 1
| 108,065
| 0
| 216,131
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string t is called an anagram of the string s, if it is possible to rearrange letters in t so that it is identical to the string s. For example, the string "aab" is an anagram of the string "aba" and the string "aaa" is not.
The string t is called a substring of the string s if it can be read starting from some position in the string s. For example, the string "aba" has six substrings: "a", "b", "a", "ab", "ba", "aba".
You are given a string s, consisting of lowercase Latin letters and characters "?". You are also given a string p, consisting of lowercase Latin letters only. Let's assume that a string is good if you can obtain an anagram of the string p from it, replacing the "?" characters by Latin letters. Each "?" can be replaced by exactly one character of the Latin alphabet. For example, if the string p = «aba», then the string "a??" is good, and the string «?bc» is not.
Your task is to find the number of good substrings of the string s (identical substrings must be counted in the answer several times).
Input
The first line is non-empty string s, consisting of no more than 105 lowercase Latin letters and characters "?". The second line is non-empty string p, consisting of no more than 105 lowercase Latin letters. Please note that the length of the string p can exceed the length of the string s.
Output
Print the single number representing the number of good substrings of string s.
Two substrings are considered different in their positions of occurrence are different. Thus, if some string occurs several times, then it should be counted the same number of times.
Examples
Input
bb??x???
aab
Output
2
Input
ab?c
acb
Output
2
Note
Consider the first sample test. Here the string s has two good substrings: "b??" (after we replace the question marks we get "baa"), "???" (after we replace the question marks we get "baa").
Let's consider the second sample test. Here the string s has two good substrings: "ab?" ("?" can be replaced by "c"), "b?c" ("?" can be replaced by "a").
Submitted Solution:
```
from collections import defaultdict
def is_anagram(window_freqs, anagram_freqs):
surplus = window_freqs['?']
for char in window_freqs.keys():
if char == '?': continue
if window_freqs[char] > anagram_freqs[char]:
return False
surplus -= (anagram_freqs[char] - window_freqs[char])
return surplus >= 0
text, anagram = input(), input()
S, W = len(text), len(anagram)
anagram_freqs = defaultdict(int)
for char in anagram: anagram_freqs[char] += 1
window_freqs = defaultdict(int)
for char in text[0:W]: window_freqs[char] += 1
count = 1 if is_anagram(window_freqs, anagram_freqs) else 0
for i in range(0, S - W):
# Remove char at position i, add char at position i+W
window_freqs[text[i]] -= 1
window_freqs[text[i+W]] += 1
count += 1 if is_anagram(window_freqs, anagram_freqs) else 0
print (count)
```
|
instruction
| 0
| 108,066
| 0
| 216,132
|
No
|
output
| 1
| 108,066
| 0
| 216,133
|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A string t is called an anagram of the string s, if it is possible to rearrange letters in t so that it is identical to the string s. For example, the string "aab" is an anagram of the string "aba" and the string "aaa" is not.
The string t is called a substring of the string s if it can be read starting from some position in the string s. For example, the string "aba" has six substrings: "a", "b", "a", "ab", "ba", "aba".
You are given a string s, consisting of lowercase Latin letters and characters "?". You are also given a string p, consisting of lowercase Latin letters only. Let's assume that a string is good if you can obtain an anagram of the string p from it, replacing the "?" characters by Latin letters. Each "?" can be replaced by exactly one character of the Latin alphabet. For example, if the string p = «aba», then the string "a??" is good, and the string «?bc» is not.
Your task is to find the number of good substrings of the string s (identical substrings must be counted in the answer several times).
Input
The first line is non-empty string s, consisting of no more than 105 lowercase Latin letters and characters "?". The second line is non-empty string p, consisting of no more than 105 lowercase Latin letters. Please note that the length of the string p can exceed the length of the string s.
Output
Print the single number representing the number of good substrings of string s.
Two substrings are considered different in their positions of occurrence are different. Thus, if some string occurs several times, then it should be counted the same number of times.
Examples
Input
bb??x???
aab
Output
2
Input
ab?c
acb
Output
2
Note
Consider the first sample test. Here the string s has two good substrings: "b??" (after we replace the question marks we get "baa"), "???" (after we replace the question marks we get "baa").
Let's consider the second sample test. Here the string s has two good substrings: "ab?" ("?" can be replaced by "c"), "b?c" ("?" can be replaced by "a").
Submitted Solution:
```
p, t = input(), input()
n, m = len(t), len(p)
q = {c: p[: n].count(c) - t.count(c) - 1 for c in 'abcdefghijklmnopqrstuvwxyz'}
q['?'] = 0
s = int(all(q[c] < 0 for c in 'abcdefghijklmnopqrstuvwxyz'))
for i, j in zip(*[p[: m - n], p[n :]]):
q[i] -= 1
q[j] += 1
if all(q[c] < 0 for c in 'abcdefghijklmnopqrstuvwxyz'): s += 1
print(s)
```
|
instruction
| 0
| 108,067
| 0
| 216,134
|
No
|
output
| 1
| 108,067
| 0
| 216,135
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.