text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish has a tree consisting of n nodes numbered 1 to n rooted at node 1. The i-th node in the tree has a cost a_i, and binary digit b_i is written in it. He wants to have binary digit c_i written in the i-th node in the end.
To achieve this, he can perform the following operation any number of times:
* Select any k nodes from the subtree of any node u, and shuffle the digits in these nodes as he wishes, incurring a cost of k ⋅ a_u. Here, he can choose k ranging from 1 to the size of the subtree of u.
He wants to perform the operations in such a way that every node finally has the digit corresponding to its target.
Help him find the minimum total cost he needs to spend so that after all the operations, every node u has digit c_u written in it, or determine that it is impossible.
Input
First line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) denoting the number of nodes in the tree.
i-th line of the next n lines contains 3 space-separated integers a_i, b_i, c_i (1 ≤ a_i ≤ 10^9, 0 ≤ b_i, c_i ≤ 1) — the cost of the i-th node, its initial digit and its goal digit.
Each of the next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n, u ≠ v), meaning that there is an edge between nodes u and v in the tree.
Output
Print the minimum total cost to make every node reach its target digit, and -1 if it is impossible.
Examples
Input
5
1 0 1
20 1 0
300 0 1
4000 0 0
50000 1 0
1 2
2 3
2 4
1 5
Output
4
Input
5
10000 0 1
2000 1 0
300 0 1
40 0 0
1 1 0
1 2
2 3
2 4
1 5
Output
24000
Input
2
109 0 1
205 0 1
1 2
Output
-1
Note
The tree corresponding to samples 1 and 2 are:
<image>
In sample 1, we can choose node 1 and k = 4 for a cost of 4 ⋅ 1 = 4 and select nodes {1, 2, 3, 5}, shuffle their digits and get the desired digits in every node.
In sample 2, we can choose node 1 and k = 2 for a cost of 10000 ⋅ 2, select nodes {1, 5} and exchange their digits, and similarly, choose node 2 and k = 2 for a cost of 2000 ⋅ 2, select nodes {2, 3} and exchange their digits to get the desired digits in every node.
In sample 3, it is impossible to get the desired digits, because there is no node with digit 1 initially.
Submitted Solution:
```
import sys
input = sys.stdin.readline
from collections import deque
t = int(input())
C = [] # cost
P = [-1 for i in range(t)] # parents
Y = [] # difference in types
X = [[] for i in range(t)]
for i in range(t):
a,b,c = list(map(int, input().split()))
C.append(a)
Y.append(b-c)
for i in range(t-1):
a,b = list(map(int, input().split()))
a -= 1
b -= 1
X[a].append(b)
#X[b].append(a)
if sum(Y) != 0:
print(-1)
exit()
else:
R = [] # list of nodes in order
Q = deque([0])
while Q:
x = deque.popleft(Q)
R.append(x)
for c in X[x]:
P[c] = x
deque.append(Q,c)
#print(P)
#print(R)
for j in R[1:]:
C[j] = min(C[j], C[P[j]])
#print(Y)
ans = 0
for i in R[1:][::-1]:
if Y[i] != Y[P[i]]:
ans += C[P[i]] * min(abs(Y[i]), abs(Y[P[i]]))
Y[P[i]] += Y[i]
print(ans*2)
```
No
| 108,000 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish has a tree consisting of n nodes numbered 1 to n rooted at node 1. The i-th node in the tree has a cost a_i, and binary digit b_i is written in it. He wants to have binary digit c_i written in the i-th node in the end.
To achieve this, he can perform the following operation any number of times:
* Select any k nodes from the subtree of any node u, and shuffle the digits in these nodes as he wishes, incurring a cost of k ⋅ a_u. Here, he can choose k ranging from 1 to the size of the subtree of u.
He wants to perform the operations in such a way that every node finally has the digit corresponding to its target.
Help him find the minimum total cost he needs to spend so that after all the operations, every node u has digit c_u written in it, or determine that it is impossible.
Input
First line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) denoting the number of nodes in the tree.
i-th line of the next n lines contains 3 space-separated integers a_i, b_i, c_i (1 ≤ a_i ≤ 10^9, 0 ≤ b_i, c_i ≤ 1) — the cost of the i-th node, its initial digit and its goal digit.
Each of the next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n, u ≠ v), meaning that there is an edge between nodes u and v in the tree.
Output
Print the minimum total cost to make every node reach its target digit, and -1 if it is impossible.
Examples
Input
5
1 0 1
20 1 0
300 0 1
4000 0 0
50000 1 0
1 2
2 3
2 4
1 5
Output
4
Input
5
10000 0 1
2000 1 0
300 0 1
40 0 0
1 1 0
1 2
2 3
2 4
1 5
Output
24000
Input
2
109 0 1
205 0 1
1 2
Output
-1
Note
The tree corresponding to samples 1 and 2 are:
<image>
In sample 1, we can choose node 1 and k = 4 for a cost of 4 ⋅ 1 = 4 and select nodes {1, 2, 3, 5}, shuffle their digits and get the desired digits in every node.
In sample 2, we can choose node 1 and k = 2 for a cost of 10000 ⋅ 2, select nodes {1, 5} and exchange their digits, and similarly, choose node 2 and k = 2 for a cost of 2000 ⋅ 2, select nodes {2, 3} and exchange their digits to get the desired digits in every node.
In sample 3, it is impossible to get the desired digits, because there is no node with digit 1 initially.
Submitted Solution:
```
#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
ans = 0
def solve():
global ans
def dfs(x):
global ans
p = [0,0]
if b[x] != c[x]:
p[b[x]] += 1
for y in v[x]:
if d[y]:
d[y] = 0
q = dfs(y)
p[0] += q[0]
p[1] += q[1]
m = min(p)
ans += m*a[x]
p[0] -= m
p[1] -= m
return p
n = I()
a = []
b = []
c = []
for _ in range(n):
x,y,z = LI()
a.append(x)
b.append(y)
c.append(z)
v = [[] for i in range(n)]
for _ in range(n-1):
x,y = LI()
x -= 1
y -= 1
v[x].append(y)
v[y].append(x)
if b.count(1) != c.count(1):
print(-1)
return
q = [0]
d = [1]*n
d[0] = 0
while q:
x = q.pop()
ax = a[x]
for y in v[x]:
if d[y]:
d[y] = 0
if ax < a[y]:
a[y] = ax
q.append(y)
d = [1]*n
dfs(0)
print(ans*2)
return
#Solve
if __name__ == "__main__":
solve()
```
No
| 108,001 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish has a tree consisting of n nodes numbered 1 to n rooted at node 1. The i-th node in the tree has a cost a_i, and binary digit b_i is written in it. He wants to have binary digit c_i written in the i-th node in the end.
To achieve this, he can perform the following operation any number of times:
* Select any k nodes from the subtree of any node u, and shuffle the digits in these nodes as he wishes, incurring a cost of k ⋅ a_u. Here, he can choose k ranging from 1 to the size of the subtree of u.
He wants to perform the operations in such a way that every node finally has the digit corresponding to its target.
Help him find the minimum total cost he needs to spend so that after all the operations, every node u has digit c_u written in it, or determine that it is impossible.
Input
First line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) denoting the number of nodes in the tree.
i-th line of the next n lines contains 3 space-separated integers a_i, b_i, c_i (1 ≤ a_i ≤ 10^9, 0 ≤ b_i, c_i ≤ 1) — the cost of the i-th node, its initial digit and its goal digit.
Each of the next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n, u ≠ v), meaning that there is an edge between nodes u and v in the tree.
Output
Print the minimum total cost to make every node reach its target digit, and -1 if it is impossible.
Examples
Input
5
1 0 1
20 1 0
300 0 1
4000 0 0
50000 1 0
1 2
2 3
2 4
1 5
Output
4
Input
5
10000 0 1
2000 1 0
300 0 1
40 0 0
1 1 0
1 2
2 3
2 4
1 5
Output
24000
Input
2
109 0 1
205 0 1
1 2
Output
-1
Note
The tree corresponding to samples 1 and 2 are:
<image>
In sample 1, we can choose node 1 and k = 4 for a cost of 4 ⋅ 1 = 4 and select nodes {1, 2, 3, 5}, shuffle their digits and get the desired digits in every node.
In sample 2, we can choose node 1 and k = 2 for a cost of 10000 ⋅ 2, select nodes {1, 5} and exchange their digits, and similarly, choose node 2 and k = 2 for a cost of 2000 ⋅ 2, select nodes {2, 3} and exchange their digits to get the desired digits in every node.
In sample 3, it is impossible to get the desired digits, because there is no node with digit 1 initially.
Submitted Solution:
```
# from math import factorial as fac
from collections import defaultdict
# from copy import deepcopy
import sys, math
f = None
try:
f = open('q1.input', 'r')
except IOError:
f = sys.stdin
if 'xrange' in dir(__builtins__):
range = xrange
# print(f.readline())
def print_case_iterable(case_num, iterable):
print("Case #{}: {}".format(case_num," ".join(map(str,iterable))))
def print_case_number(case_num, iterable):
print("Case #{}: {}".format(case_num,iterable))
def print_iterable(A):
print (' '.join(A))
def read_int():
return int(f.readline().strip())
def read_int_array():
return [int(x) for x in f.readline().strip().split(" ")]
def rns():
a = [x for x in f.readline().split(" ")]
return int(a[0]), a[1].strip()
def read_string():
return list(f.readline().strip())
def bi(x):
return bin(x)[2:]
from collections import deque
import math
from collections import deque, defaultdict
import heapq
from sys import stdout
# a=cost, b=written, c=wanted
import threading
sys.setrecursionlimit(2*10**5+2)
# sys.setrecursionlimit(10**6)
threading.stack_size(10**8)
def dfs(v,adj,curr_min,visited,data,res):
visited[v] = True
curr_min = min(curr_min,data[v][0])
balance = data[v][2]-data[v][1]
total = abs(balance)
for u in adj[v]:
if visited[u]:
continue
zeros = dfs(u,adj,curr_min,visited,data,res)
balance += zeros
total += abs(zeros)
res[0] += curr_min * (total-abs(balance))
return balance
def solution(n,data,adj):
#dfs, correct as much as possible with minimum up to know, propogate up.
visited = [False]*(n+1)
res = [0]
balance = dfs(1,adj,10**10,visited,data,res)
if balance == 0:
return res[0]
return -1
def main():
T = 1
for i in range(T):
n = read_int()
adj = defaultdict(list)
data = [0]
for j in range(n):
data.append(read_int_array())
for j in range(n-1):
u,v = read_int_array()
adj[u].append(v)
adj[v].append(u)
x = solution(n,data,adj)
if 'xrange' not in dir(__builtins__):
print(x)
else:
print >>output,str(x)# "Case #"+str(i+1)+':',
if 'xrange' in dir(__builtins__):
print(output.getvalue())
output.close()
stdout.flush()
if 'xrange' in dir(__builtins__):
import cStringIO
output = cStringIO.StringIO()
#example usage:
# for l in res:
# print >>output, str(len(l)) + ' ' + ' '.join(l)
threading.stack_size(10**8)
if __name__ == '__main__':
t = threading.Thread(target=main)
t.start()
t.join()
stdout.flush()
stdout.flush()
print(-1)
```
No
| 108,002 |
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
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
```
| 108,003 |
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
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)
```
| 108,004 |
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
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()
```
| 108,005 |
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
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)
```
| 108,006 |
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
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))
```
| 108,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
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
```
| 108,008 |
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
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)
```
| 108,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
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 = '')
```
| 108,010 |
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()
```
Yes
| 108,011 |
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
```
Yes
| 108,012 |
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))
```
Yes
| 108,013 |
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)
```
Yes
| 108,014 |
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")
```
No
| 108,015 |
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()
```
No
| 108,016 |
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)
```
No
| 108,017 |
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)
```
No
| 108,018 |
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')
```
No
| 108,019 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given an array a of n integers, such that a_1 + a_2 + ⋅⋅⋅ + a_n = 0.
In one operation, you can choose two different indices i and j (1 ≤ i, j ≤ n), decrement a_i by one and increment a_j by one. If i < j this operation is free, otherwise it costs one coin.
How many coins do you have to spend in order to make all elements equal to 0?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 5000). Description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements.
The next line contains n integers a_1, …, a_n (-10^9 ≤ a_i ≤ 10^9). It is given that ∑_{i=1}^n a_i = 0.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the minimum number of coins we have to spend in order to make all elements equal to 0.
Example
Input
7
4
-3 5 -3 1
2
1 -1
4
-3 2 -3 4
4
-1 1 1 -1
7
-5 7 -6 -4 17 -13 4
6
-1000000000 -1000000000 -1000000000 1000000000 1000000000 1000000000
1
0
Output
3
0
4
1
8
3000000000
0
Note
Possible strategy for the first test case:
* Do (i=2, j=3) three times (free), a = [-3, 2, 0, 1].
* Do (i=2, j=1) two times (pay two coins), a = [-1, 0, 0, 1].
* Do (i=4, j=1) one time (pay one coin), a = [0, 0, 0, 0].
Tags: constructive algorithms, implementation
Correct Solution:
```
import sys
import bisect as bi
import math
from collections import defaultdict as dd
import heapq
import itertools
##import operator
input=sys.stdin.readline
import random
##sys.setrecursionlimit(10**7)
##fo=open("output.txt","w")
##fi=open("input2.txt","w")
mo=10**9+7
def cin():
return map(int,sin().split())
def ain():
return list(map(int,sin().split()))
def sin():
return input()
def inin():
return int(input())
def pref(a,n,f):
pre=[0]*n
if(f==0): ##from beginning
pre[0]=a[0]
for i in range(1,n):
pre[i]=a[i]+pre[i-1]
else: ##from end
pre[-1]=a[-1]
for i in range(n-2,-1,-1):
pre[i]=pre[i+1]+a[i]
return pre
for _ in range(inin()):
n=inin()
l=ain()
post=pref(l,n,1)
ma=max(post)
print(ma)
## n,k=cin()
## d=dd(int)
## x=ain()
## y=ain()
## for i in x:
## d[i]+=1
## d=sorted(d.items(),key = lambda x:x[1],reverse=True)
## print(d)
##def msb(n):n|=n>>1;n|=n>>2;n|=n>>4;n|=n>>8;n|=n>>16;n|=n>>32;n|=n>>64;return n-(n>>1) #2 ki power
##def pref(a,n,f):
## pre=[0]*n
## if(f==0): ##from beginning
## pre[0]=a[0]
## for i in range(1,n):
## pre[i]=a[i]+pre[i-1]
## else: ##from end
## pre[-1]=a[-1]
## for i in range(n-2,-1,-1):
## pre[i]=pre[i+1]+a[i]
## return pre
##maxint=10**24
##def kadane(a,size):
## max_so_far = -maxint - 1
## max_ending_here = 0
##
## for i in range(0, size):
## max_ending_here = max_ending_here + a[i]
## if (max_so_far < max_ending_here):
## max_so_far = max_ending_here
##
## if max_ending_here < 0:
## max_ending_here = 0
## return max_so_far
##def power(x, y):
## if(y == 0):return 1
## temp = power(x, int(y / 2))%mo
## if (y % 2 == 0):return (temp * temp)%mo
## else:
## if(y > 0):return (x * temp * temp)%mo
## else:return ((temp * temp)//x )%mo
```
| 108,020 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given an array a of n integers, such that a_1 + a_2 + ⋅⋅⋅ + a_n = 0.
In one operation, you can choose two different indices i and j (1 ≤ i, j ≤ n), decrement a_i by one and increment a_j by one. If i < j this operation is free, otherwise it costs one coin.
How many coins do you have to spend in order to make all elements equal to 0?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 5000). Description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements.
The next line contains n integers a_1, …, a_n (-10^9 ≤ a_i ≤ 10^9). It is given that ∑_{i=1}^n a_i = 0.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the minimum number of coins we have to spend in order to make all elements equal to 0.
Example
Input
7
4
-3 5 -3 1
2
1 -1
4
-3 2 -3 4
4
-1 1 1 -1
7
-5 7 -6 -4 17 -13 4
6
-1000000000 -1000000000 -1000000000 1000000000 1000000000 1000000000
1
0
Output
3
0
4
1
8
3000000000
0
Note
Possible strategy for the first test case:
* Do (i=2, j=3) three times (free), a = [-3, 2, 0, 1].
* Do (i=2, j=1) two times (pay two coins), a = [-1, 0, 0, 1].
* Do (i=4, j=1) one time (pay one coin), a = [0, 0, 0, 0].
Tags: constructive algorithms, implementation
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
ans, pos, neg = 0, 0, 0
ans = 0
stack = 0
for i in range(n):
if arr[i] < 0 and stack == 0:
ans += abs(arr[i])
elif arr[i] > 0 and stack == 0:
stack += arr[i]
elif arr[i] < 0 and stack > 0:
stack += arr[i]
if stack < 0:
ans += abs(stack)
stack = 0
elif arr[i] > 0 and stack > 0:
stack += arr[i]
print(ans)
# if arr[0] > 0:
# pos += arr[0]
# if arr[-1] < 0:
# neg += arr[-1]
# for i in range(n):
# if arr[i] > 0 and pos = 0 and i != n-1:
# pos += arr[i]
# if arr[i] < 0 and neg = 0 and i != 0:
# neg += arr[i]
# if arr[i] > 0 and pos > 0:
# if pos > neg:
# pos += arr[i]
# pos -=
# ans = abs(pos - neg)
# pos
# for i in range(1, n):
# if arr[i] < 0 and arr[i-1] > 0:
# if abs(arr[i]) > abs(arr[i-1]):
# arr[i] = arr[i] + arr[i-1]
# arr[i-1] = 0
# else:
# arr[i-1] = arr[i] + arr[i-1]
# arr[i] = 0
```
| 108,021 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given an array a of n integers, such that a_1 + a_2 + ⋅⋅⋅ + a_n = 0.
In one operation, you can choose two different indices i and j (1 ≤ i, j ≤ n), decrement a_i by one and increment a_j by one. If i < j this operation is free, otherwise it costs one coin.
How many coins do you have to spend in order to make all elements equal to 0?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 5000). Description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements.
The next line contains n integers a_1, …, a_n (-10^9 ≤ a_i ≤ 10^9). It is given that ∑_{i=1}^n a_i = 0.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the minimum number of coins we have to spend in order to make all elements equal to 0.
Example
Input
7
4
-3 5 -3 1
2
1 -1
4
-3 2 -3 4
4
-1 1 1 -1
7
-5 7 -6 -4 17 -13 4
6
-1000000000 -1000000000 -1000000000 1000000000 1000000000 1000000000
1
0
Output
3
0
4
1
8
3000000000
0
Note
Possible strategy for the first test case:
* Do (i=2, j=3) three times (free), a = [-3, 2, 0, 1].
* Do (i=2, j=1) two times (pay two coins), a = [-1, 0, 0, 1].
* Do (i=4, j=1) one time (pay one coin), a = [0, 0, 0, 0].
Tags: constructive algorithms, implementation
Correct Solution:
```
from sys import stdin
input = stdin.readline
t = int(input())
for _ in range(t):
n = int(input())
a = [int(x) for x in input().split()]
p = 0
ans = 0
for i in range(n):
if a[i] > 0:
p += a[i]
else:
ans += max(0, -a[i] - p)
p = max(0, p + a[i])
print(ans)
```
| 108,022 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given an array a of n integers, such that a_1 + a_2 + ⋅⋅⋅ + a_n = 0.
In one operation, you can choose two different indices i and j (1 ≤ i, j ≤ n), decrement a_i by one and increment a_j by one. If i < j this operation is free, otherwise it costs one coin.
How many coins do you have to spend in order to make all elements equal to 0?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 5000). Description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements.
The next line contains n integers a_1, …, a_n (-10^9 ≤ a_i ≤ 10^9). It is given that ∑_{i=1}^n a_i = 0.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the minimum number of coins we have to spend in order to make all elements equal to 0.
Example
Input
7
4
-3 5 -3 1
2
1 -1
4
-3 2 -3 4
4
-1 1 1 -1
7
-5 7 -6 -4 17 -13 4
6
-1000000000 -1000000000 -1000000000 1000000000 1000000000 1000000000
1
0
Output
3
0
4
1
8
3000000000
0
Note
Possible strategy for the first test case:
* Do (i=2, j=3) three times (free), a = [-3, 2, 0, 1].
* Do (i=2, j=1) two times (pay two coins), a = [-1, 0, 0, 1].
* Do (i=4, j=1) one time (pay one coin), a = [0, 0, 0, 0].
Tags: constructive algorithms, implementation
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
arr=list(map(int,input().split()))
c=0
pos=0
for i in range(n):
if arr[i]>0:
pos+=arr[i]
else:
arr[i]=arr[i]*-1
if pos>arr[i]:
pos-=arr[i]
else:
c+=arr[i]-pos
pos=0
print(c)
```
| 108,023 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given an array a of n integers, such that a_1 + a_2 + ⋅⋅⋅ + a_n = 0.
In one operation, you can choose two different indices i and j (1 ≤ i, j ≤ n), decrement a_i by one and increment a_j by one. If i < j this operation is free, otherwise it costs one coin.
How many coins do you have to spend in order to make all elements equal to 0?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 5000). Description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements.
The next line contains n integers a_1, …, a_n (-10^9 ≤ a_i ≤ 10^9). It is given that ∑_{i=1}^n a_i = 0.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the minimum number of coins we have to spend in order to make all elements equal to 0.
Example
Input
7
4
-3 5 -3 1
2
1 -1
4
-3 2 -3 4
4
-1 1 1 -1
7
-5 7 -6 -4 17 -13 4
6
-1000000000 -1000000000 -1000000000 1000000000 1000000000 1000000000
1
0
Output
3
0
4
1
8
3000000000
0
Note
Possible strategy for the first test case:
* Do (i=2, j=3) three times (free), a = [-3, 2, 0, 1].
* Do (i=2, j=1) two times (pay two coins), a = [-1, 0, 0, 1].
* Do (i=4, j=1) one time (pay one coin), a = [0, 0, 0, 0].
Tags: constructive algorithms, implementation
Correct Solution:
```
for _ in range(int(input())):
lens = int(input())
arrs = [int(x) for x in input().split()]
psum = 0
for i in arrs:
psum += i
psum = max(psum, 0)
print(psum)
```
| 108,024 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given an array a of n integers, such that a_1 + a_2 + ⋅⋅⋅ + a_n = 0.
In one operation, you can choose two different indices i and j (1 ≤ i, j ≤ n), decrement a_i by one and increment a_j by one. If i < j this operation is free, otherwise it costs one coin.
How many coins do you have to spend in order to make all elements equal to 0?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 5000). Description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements.
The next line contains n integers a_1, …, a_n (-10^9 ≤ a_i ≤ 10^9). It is given that ∑_{i=1}^n a_i = 0.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the minimum number of coins we have to spend in order to make all elements equal to 0.
Example
Input
7
4
-3 5 -3 1
2
1 -1
4
-3 2 -3 4
4
-1 1 1 -1
7
-5 7 -6 -4 17 -13 4
6
-1000000000 -1000000000 -1000000000 1000000000 1000000000 1000000000
1
0
Output
3
0
4
1
8
3000000000
0
Note
Possible strategy for the first test case:
* Do (i=2, j=3) three times (free), a = [-3, 2, 0, 1].
* Do (i=2, j=1) two times (pay two coins), a = [-1, 0, 0, 1].
* Do (i=4, j=1) one time (pay one coin), a = [0, 0, 0, 0].
Tags: constructive algorithms, implementation
Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Thu Sep 17 07:50:00 2020
@author: Harshal
"""
test=int(input())
for _ in range(test):
n=int(input())
arr=list(map(int,input().split()))
ans=0
for i in arr:
ans=max(ans+i,0)
print(ans)
```
| 108,025 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given an array a of n integers, such that a_1 + a_2 + ⋅⋅⋅ + a_n = 0.
In one operation, you can choose two different indices i and j (1 ≤ i, j ≤ n), decrement a_i by one and increment a_j by one. If i < j this operation is free, otherwise it costs one coin.
How many coins do you have to spend in order to make all elements equal to 0?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 5000). Description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements.
The next line contains n integers a_1, …, a_n (-10^9 ≤ a_i ≤ 10^9). It is given that ∑_{i=1}^n a_i = 0.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the minimum number of coins we have to spend in order to make all elements equal to 0.
Example
Input
7
4
-3 5 -3 1
2
1 -1
4
-3 2 -3 4
4
-1 1 1 -1
7
-5 7 -6 -4 17 -13 4
6
-1000000000 -1000000000 -1000000000 1000000000 1000000000 1000000000
1
0
Output
3
0
4
1
8
3000000000
0
Note
Possible strategy for the first test case:
* Do (i=2, j=3) three times (free), a = [-3, 2, 0, 1].
* Do (i=2, j=1) two times (pay two coins), a = [-1, 0, 0, 1].
* Do (i=4, j=1) one time (pay one coin), a = [0, 0, 0, 0].
Tags: constructive algorithms, implementation
Correct Solution:
```
T = int(input())
for t in range(T):
n = int(input())
A = list(map(int, input().split()))
start = 1
for i in range(n):
if A[i] > 0:
temp = []
sum = 0
for j in range(max(i+1, start), n):
if A[j] < 0:
temp.append(j)
sum -= A[j]
if sum >= A[i]:
break
if sum >= A[i]:
# A[i] = 0
for k in temp:
if A[i] + A[k] > 0:
A[i] += A[k]
A[k] = 0
else:
A[k] += A[i]
A[i] = 0
start = k
# print(A[i], A[k], k,sum)
else:
A[i] -= sum
for k in temp:
A[k] = 0
# print(A[i], A[k], sum)
break
ans = 0
for i in range(n):
if A[i] > 0:
break
ans -= A[i]
print( ans)
```
| 108,026 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given an array a of n integers, such that a_1 + a_2 + ⋅⋅⋅ + a_n = 0.
In one operation, you can choose two different indices i and j (1 ≤ i, j ≤ n), decrement a_i by one and increment a_j by one. If i < j this operation is free, otherwise it costs one coin.
How many coins do you have to spend in order to make all elements equal to 0?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 5000). Description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements.
The next line contains n integers a_1, …, a_n (-10^9 ≤ a_i ≤ 10^9). It is given that ∑_{i=1}^n a_i = 0.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the minimum number of coins we have to spend in order to make all elements equal to 0.
Example
Input
7
4
-3 5 -3 1
2
1 -1
4
-3 2 -3 4
4
-1 1 1 -1
7
-5 7 -6 -4 17 -13 4
6
-1000000000 -1000000000 -1000000000 1000000000 1000000000 1000000000
1
0
Output
3
0
4
1
8
3000000000
0
Note
Possible strategy for the first test case:
* Do (i=2, j=3) three times (free), a = [-3, 2, 0, 1].
* Do (i=2, j=1) two times (pay two coins), a = [-1, 0, 0, 1].
* Do (i=4, j=1) one time (pay one coin), a = [0, 0, 0, 0].
Tags: constructive algorithms, implementation
Correct Solution:
```
import sys
input=sys.stdin.readline
for _ in range(int(input())):
n=int(input())
ar=list(map(int,input().split()))
ans=0
pos=0
neg=0
for i in range(n):
if(ar[i]<0):
pos+=ar[i]
if(pos<0):
ans+=abs(pos)
pos=0
elif(ar[i]>0):
pos+=ar[i]
print(ans)
```
| 108,027 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given an array a of n integers, such that a_1 + a_2 + ⋅⋅⋅ + a_n = 0.
In one operation, you can choose two different indices i and j (1 ≤ i, j ≤ n), decrement a_i by one and increment a_j by one. If i < j this operation is free, otherwise it costs one coin.
How many coins do you have to spend in order to make all elements equal to 0?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 5000). Description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements.
The next line contains n integers a_1, …, a_n (-10^9 ≤ a_i ≤ 10^9). It is given that ∑_{i=1}^n a_i = 0.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the minimum number of coins we have to spend in order to make all elements equal to 0.
Example
Input
7
4
-3 5 -3 1
2
1 -1
4
-3 2 -3 4
4
-1 1 1 -1
7
-5 7 -6 -4 17 -13 4
6
-1000000000 -1000000000 -1000000000 1000000000 1000000000 1000000000
1
0
Output
3
0
4
1
8
3000000000
0
Note
Possible strategy for the first test case:
* Do (i=2, j=3) three times (free), a = [-3, 2, 0, 1].
* Do (i=2, j=1) two times (pay two coins), a = [-1, 0, 0, 1].
* Do (i=4, j=1) one time (pay one coin), a = [0, 0, 0, 0].
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
minus=0
plus=0
for i in a:
if i==0:
continue
elif i>0:
plus+=i
else:
if plus>=abs(i):
plus+=i
else:
plus=0
hg=abs(i)-plus
minus-=hg
print(abs(plus))
```
Yes
| 108,028 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given an array a of n integers, such that a_1 + a_2 + ⋅⋅⋅ + a_n = 0.
In one operation, you can choose two different indices i and j (1 ≤ i, j ≤ n), decrement a_i by one and increment a_j by one. If i < j this operation is free, otherwise it costs one coin.
How many coins do you have to spend in order to make all elements equal to 0?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 5000). Description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements.
The next line contains n integers a_1, …, a_n (-10^9 ≤ a_i ≤ 10^9). It is given that ∑_{i=1}^n a_i = 0.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the minimum number of coins we have to spend in order to make all elements equal to 0.
Example
Input
7
4
-3 5 -3 1
2
1 -1
4
-3 2 -3 4
4
-1 1 1 -1
7
-5 7 -6 -4 17 -13 4
6
-1000000000 -1000000000 -1000000000 1000000000 1000000000 1000000000
1
0
Output
3
0
4
1
8
3000000000
0
Note
Possible strategy for the first test case:
* Do (i=2, j=3) three times (free), a = [-3, 2, 0, 1].
* Do (i=2, j=1) two times (pay two coins), a = [-1, 0, 0, 1].
* Do (i=4, j=1) one time (pay one coin), a = [0, 0, 0, 0].
Submitted Solution:
```
t=int(input())
for i in range(t):
a=int(input())
b=[int(s) for s in input().split()]
s=0
t=0
for k in range(len(b)):
if s+b[k]>=0:
s+=b[k]
else:
t+=abs(b[k])-s
s-=min(s,abs(b[k]))
print(t)
```
Yes
| 108,029 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given an array a of n integers, such that a_1 + a_2 + ⋅⋅⋅ + a_n = 0.
In one operation, you can choose two different indices i and j (1 ≤ i, j ≤ n), decrement a_i by one and increment a_j by one. If i < j this operation is free, otherwise it costs one coin.
How many coins do you have to spend in order to make all elements equal to 0?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 5000). Description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements.
The next line contains n integers a_1, …, a_n (-10^9 ≤ a_i ≤ 10^9). It is given that ∑_{i=1}^n a_i = 0.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the minimum number of coins we have to spend in order to make all elements equal to 0.
Example
Input
7
4
-3 5 -3 1
2
1 -1
4
-3 2 -3 4
4
-1 1 1 -1
7
-5 7 -6 -4 17 -13 4
6
-1000000000 -1000000000 -1000000000 1000000000 1000000000 1000000000
1
0
Output
3
0
4
1
8
3000000000
0
Note
Possible strategy for the first test case:
* Do (i=2, j=3) three times (free), a = [-3, 2, 0, 1].
* Do (i=2, j=1) two times (pay two coins), a = [-1, 0, 0, 1].
* Do (i=4, j=1) one time (pay one coin), a = [0, 0, 0, 0].
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
s = 0
ans = 0
for i in range(n):
s += arr[i]
ans = min(ans, s)
print(abs(ans))
```
Yes
| 108,030 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given an array a of n integers, such that a_1 + a_2 + ⋅⋅⋅ + a_n = 0.
In one operation, you can choose two different indices i and j (1 ≤ i, j ≤ n), decrement a_i by one and increment a_j by one. If i < j this operation is free, otherwise it costs one coin.
How many coins do you have to spend in order to make all elements equal to 0?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 5000). Description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements.
The next line contains n integers a_1, …, a_n (-10^9 ≤ a_i ≤ 10^9). It is given that ∑_{i=1}^n a_i = 0.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the minimum number of coins we have to spend in order to make all elements equal to 0.
Example
Input
7
4
-3 5 -3 1
2
1 -1
4
-3 2 -3 4
4
-1 1 1 -1
7
-5 7 -6 -4 17 -13 4
6
-1000000000 -1000000000 -1000000000 1000000000 1000000000 1000000000
1
0
Output
3
0
4
1
8
3000000000
0
Note
Possible strategy for the first test case:
* Do (i=2, j=3) three times (free), a = [-3, 2, 0, 1].
* Do (i=2, j=1) two times (pay two coins), a = [-1, 0, 0, 1].
* Do (i=4, j=1) one time (pay one coin), a = [0, 0, 0, 0].
Submitted Solution:
```
# https://codeforces.com/contest/1405/problem/B
'''
Author @Subhajit Das (sdsubhajitdas.github.io)
SWE @Turbot HQ India PVT Ltd.
07/09/2020
'''
import math
def main():
n = int(input().strip())
arr = list(map(int,input().strip().split()))
cost = suffixSum = arr[-1]
for i in reversed(range(n-1)):
suffixSum += arr[i]
cost = max(cost,suffixSum)
print(cost)
if __name__ == "__main__":
for _ in range(int(input())):
main()
# main()
```
Yes
| 108,031 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given an array a of n integers, such that a_1 + a_2 + ⋅⋅⋅ + a_n = 0.
In one operation, you can choose two different indices i and j (1 ≤ i, j ≤ n), decrement a_i by one and increment a_j by one. If i < j this operation is free, otherwise it costs one coin.
How many coins do you have to spend in order to make all elements equal to 0?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 5000). Description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements.
The next line contains n integers a_1, …, a_n (-10^9 ≤ a_i ≤ 10^9). It is given that ∑_{i=1}^n a_i = 0.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the minimum number of coins we have to spend in order to make all elements equal to 0.
Example
Input
7
4
-3 5 -3 1
2
1 -1
4
-3 2 -3 4
4
-1 1 1 -1
7
-5 7 -6 -4 17 -13 4
6
-1000000000 -1000000000 -1000000000 1000000000 1000000000 1000000000
1
0
Output
3
0
4
1
8
3000000000
0
Note
Possible strategy for the first test case:
* Do (i=2, j=3) three times (free), a = [-3, 2, 0, 1].
* Do (i=2, j=1) two times (pay two coins), a = [-1, 0, 0, 1].
* Do (i=4, j=1) one time (pay one coin), a = [0, 0, 0, 0].
Submitted Solution:
```
import math
test = int(input())
for t in range(test):
n = int(input())
A = list(map(int,input().split()))
if(n==2):
if(A[0]<=A[1]):
print(0)
continue
sump=0;sumn=0
B = []
for i in range(n):
if(A[i]>0):
sump+=A[i]
if(sumn!=0):
B.append(sumn)
sumn = 0
else:
sumn+=A[i]
if(sump!=0):
B.append(sump)
sump = 0
if(sumn!=0):
B.append(sumn)
if(sump!=0):
B.append(sump)
for i in range(1,len(B)-1):
if(B[i]<0):
continue
else:
a = min(B[i],abs(B[i+1]))
B[i+1] += a
B[i] -= a
ans = 0
for i in B:
if(i<0):
ans+=i
print(abs(ans))
```
No
| 108,032 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given an array a of n integers, such that a_1 + a_2 + ⋅⋅⋅ + a_n = 0.
In one operation, you can choose two different indices i and j (1 ≤ i, j ≤ n), decrement a_i by one and increment a_j by one. If i < j this operation is free, otherwise it costs one coin.
How many coins do you have to spend in order to make all elements equal to 0?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 5000). Description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements.
The next line contains n integers a_1, …, a_n (-10^9 ≤ a_i ≤ 10^9). It is given that ∑_{i=1}^n a_i = 0.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the minimum number of coins we have to spend in order to make all elements equal to 0.
Example
Input
7
4
-3 5 -3 1
2
1 -1
4
-3 2 -3 4
4
-1 1 1 -1
7
-5 7 -6 -4 17 -13 4
6
-1000000000 -1000000000 -1000000000 1000000000 1000000000 1000000000
1
0
Output
3
0
4
1
8
3000000000
0
Note
Possible strategy for the first test case:
* Do (i=2, j=3) three times (free), a = [-3, 2, 0, 1].
* Do (i=2, j=1) two times (pay two coins), a = [-1, 0, 0, 1].
* Do (i=4, j=1) one time (pay one coin), a = [0, 0, 0, 0].
Submitted Solution:
```
t=int(input())
while (t>0):
n=int(input())
arr=[abs(int(i)) for i in input().split()]
print(sum(arr)//n)
t-=1
```
No
| 108,033 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given an array a of n integers, such that a_1 + a_2 + ⋅⋅⋅ + a_n = 0.
In one operation, you can choose two different indices i and j (1 ≤ i, j ≤ n), decrement a_i by one and increment a_j by one. If i < j this operation is free, otherwise it costs one coin.
How many coins do you have to spend in order to make all elements equal to 0?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 5000). Description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements.
The next line contains n integers a_1, …, a_n (-10^9 ≤ a_i ≤ 10^9). It is given that ∑_{i=1}^n a_i = 0.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the minimum number of coins we have to spend in order to make all elements equal to 0.
Example
Input
7
4
-3 5 -3 1
2
1 -1
4
-3 2 -3 4
4
-1 1 1 -1
7
-5 7 -6 -4 17 -13 4
6
-1000000000 -1000000000 -1000000000 1000000000 1000000000 1000000000
1
0
Output
3
0
4
1
8
3000000000
0
Note
Possible strategy for the first test case:
* Do (i=2, j=3) three times (free), a = [-3, 2, 0, 1].
* Do (i=2, j=1) two times (pay two coins), a = [-1, 0, 0, 1].
* Do (i=4, j=1) one time (pay one coin), a = [0, 0, 0, 0].
Submitted Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
mod = 10 ** 9 + 7
mod1 = 998244353
# sys.setrecursionlimit(300000)
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
# sys.setrecursionlimit(300000)
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")
# -------------------game starts now----------------------------------------------------import math
# -----------------------------------------------binary seacrh tree---------------------------------------
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: max(a, b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] <= key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
for ik in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
ans=0
cur=0
for i in range(n-1,-1,-1):
if l[i]>=0:
ans+=max(0,l[i]+cur)
cur-=min(l[i],cur)
else:
cur+=l[i]
print(ans)
```
No
| 108,034 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given an array a of n integers, such that a_1 + a_2 + ⋅⋅⋅ + a_n = 0.
In one operation, you can choose two different indices i and j (1 ≤ i, j ≤ n), decrement a_i by one and increment a_j by one. If i < j this operation is free, otherwise it costs one coin.
How many coins do you have to spend in order to make all elements equal to 0?
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 5000). Description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements.
The next line contains n integers a_1, …, a_n (-10^9 ≤ a_i ≤ 10^9). It is given that ∑_{i=1}^n a_i = 0.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the minimum number of coins we have to spend in order to make all elements equal to 0.
Example
Input
7
4
-3 5 -3 1
2
1 -1
4
-3 2 -3 4
4
-1 1 1 -1
7
-5 7 -6 -4 17 -13 4
6
-1000000000 -1000000000 -1000000000 1000000000 1000000000 1000000000
1
0
Output
3
0
4
1
8
3000000000
0
Note
Possible strategy for the first test case:
* Do (i=2, j=3) three times (free), a = [-3, 2, 0, 1].
* Do (i=2, j=1) two times (pay two coins), a = [-1, 0, 0, 1].
* Do (i=4, j=1) one time (pay one coin), a = [0, 0, 0, 0].
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()));b=[]
for i in range(n):
if a[i]>0:
b.append(i)
j=0
if n==1:
print(0)
else:
for i in range(b[0]+1,n):
if a[i]>=0:
continue
if a[b[j]]>=-a[i]:
a[b[j]]+=a[i]
a[i]=0
else:
a[i]+=a[b[j]]
a[b[j]]=0
j+=1
s=0
a.sort()
for i in a:
if i>=0:
break
s-=i
print(s)
```
No
| 108,035 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya got an integer array a_1, a_2, ..., a_n. The array can contain both positive and negative integers, but Kolya doesn't like 0, so the array doesn't contain any zeros.
Kolya doesn't like that the sum of some subsegments of his array can be 0. The subsegment is some consecutive segment of elements of the array.
You have to help Kolya and change his array in such a way that it doesn't contain any subsegments with the sum 0. To reach this goal, you can insert any integers between any pair of adjacent elements of the array (integers can be really any: positive, negative, 0, any by absolute value, even such a huge that they can't be represented in most standard programming languages).
Your task is to find the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 200 000) — the number of elements in Kolya's array.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^{9} ≤ a_i ≤ 10^{9}, a_i ≠ 0) — the description of Kolya's array.
Output
Print the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Examples
Input
4
1 -5 3 2
Output
1
Input
5
4 -2 3 -9 2
Output
0
Input
9
-1 1 -1 1 -1 1 1 -1 -1
Output
6
Input
8
16 -5 -11 -15 10 5 4 -4
Output
3
Note
Consider the first example. There is only one subsegment with the sum 0. It starts in the second element and ends in the fourth element. It's enough to insert one element so the array doesn't contain any subsegments with the sum equal to zero. For example, it is possible to insert the integer 1 between second and third elements of the array.
There are no subsegments having sum 0 in the second example so you don't need to do anything.
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
from sys import stdin,stdout
import math
from bisect import bisect_left
from collections import Counter,deque,defaultdict
L=lambda:list(map(int, stdin.readline().strip().split()))
M=lambda:map(int, stdin.readline().strip().split())
I=lambda:int(stdin.readline().strip())
S=lambda:stdin.readline().strip()
C=lambda:stdin.readline().strip().split()
def pr(a):return(" ".join(list(map(str,a))))
#_______________--------------------------______________#
def solve():
n = I()
a = L()
ans, s = 0, 0
se = {0}
for i in a:
s += i
if s in se:
ans+=1
se ={0}
s = i
se |= {s}
print(ans)
for _ in range(1):
solve()
```
| 108,036 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya got an integer array a_1, a_2, ..., a_n. The array can contain both positive and negative integers, but Kolya doesn't like 0, so the array doesn't contain any zeros.
Kolya doesn't like that the sum of some subsegments of his array can be 0. The subsegment is some consecutive segment of elements of the array.
You have to help Kolya and change his array in such a way that it doesn't contain any subsegments with the sum 0. To reach this goal, you can insert any integers between any pair of adjacent elements of the array (integers can be really any: positive, negative, 0, any by absolute value, even such a huge that they can't be represented in most standard programming languages).
Your task is to find the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 200 000) — the number of elements in Kolya's array.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^{9} ≤ a_i ≤ 10^{9}, a_i ≠ 0) — the description of Kolya's array.
Output
Print the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Examples
Input
4
1 -5 3 2
Output
1
Input
5
4 -2 3 -9 2
Output
0
Input
9
-1 1 -1 1 -1 1 1 -1 -1
Output
6
Input
8
16 -5 -11 -15 10 5 4 -4
Output
3
Note
Consider the first example. There is only one subsegment with the sum 0. It starts in the second element and ends in the fourth element. It's enough to insert one element so the array doesn't contain any subsegments with the sum equal to zero. For example, it is possible to insert the integer 1 between second and third elements of the array.
There are no subsegments having sum 0 in the second example so you don't need to do anything.
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
def checker(lst, n):
k, s, c = 0, set(), 0
for i in range(n):
k += lst[i]
if k == 0 or k in s:
c += 1
s.clear()
k = lst[i]
s.add(k)
return c
n = int(input())
a = [int(i) for i in input().split()]
print(checker(a,n))
```
| 108,037 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya got an integer array a_1, a_2, ..., a_n. The array can contain both positive and negative integers, but Kolya doesn't like 0, so the array doesn't contain any zeros.
Kolya doesn't like that the sum of some subsegments of his array can be 0. The subsegment is some consecutive segment of elements of the array.
You have to help Kolya and change his array in such a way that it doesn't contain any subsegments with the sum 0. To reach this goal, you can insert any integers between any pair of adjacent elements of the array (integers can be really any: positive, negative, 0, any by absolute value, even such a huge that they can't be represented in most standard programming languages).
Your task is to find the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 200 000) — the number of elements in Kolya's array.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^{9} ≤ a_i ≤ 10^{9}, a_i ≠ 0) — the description of Kolya's array.
Output
Print the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Examples
Input
4
1 -5 3 2
Output
1
Input
5
4 -2 3 -9 2
Output
0
Input
9
-1 1 -1 1 -1 1 1 -1 -1
Output
6
Input
8
16 -5 -11 -15 10 5 4 -4
Output
3
Note
Consider the first example. There is only one subsegment with the sum 0. It starts in the second element and ends in the fourth element. It's enough to insert one element so the array doesn't contain any subsegments with the sum equal to zero. For example, it is possible to insert the integer 1 between second and third elements of the array.
There are no subsegments having sum 0 in the second example so you don't need to do anything.
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
import collections
n=int(input())
arr=list(map(int,input().split()))
ans=0
sums=0
s=set()
for val in arr:
s.add(sums)
sums+=val
if sums in s:
ans+=1
sums=val
s=set()
s.add(0)
print(ans)
```
| 108,038 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya got an integer array a_1, a_2, ..., a_n. The array can contain both positive and negative integers, but Kolya doesn't like 0, so the array doesn't contain any zeros.
Kolya doesn't like that the sum of some subsegments of his array can be 0. The subsegment is some consecutive segment of elements of the array.
You have to help Kolya and change his array in such a way that it doesn't contain any subsegments with the sum 0. To reach this goal, you can insert any integers between any pair of adjacent elements of the array (integers can be really any: positive, negative, 0, any by absolute value, even such a huge that they can't be represented in most standard programming languages).
Your task is to find the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 200 000) — the number of elements in Kolya's array.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^{9} ≤ a_i ≤ 10^{9}, a_i ≠ 0) — the description of Kolya's array.
Output
Print the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Examples
Input
4
1 -5 3 2
Output
1
Input
5
4 -2 3 -9 2
Output
0
Input
9
-1 1 -1 1 -1 1 1 -1 -1
Output
6
Input
8
16 -5 -11 -15 10 5 4 -4
Output
3
Note
Consider the first example. There is only one subsegment with the sum 0. It starts in the second element and ends in the fourth element. It's enough to insert one element so the array doesn't contain any subsegments with the sum equal to zero. For example, it is possible to insert the integer 1 between second and third elements of the array.
There are no subsegments having sum 0 in the second example so you don't need to do anything.
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
from collections import Counter
import string
import math
import sys
from fractions import Fraction
def array_int():
return [int(i) for i in sys.stdin.readline().split()]
def vary(arrber_of_variables):
if arrber_of_variables==1:
return int(sys.stdin.readline())
if arrber_of_variables>=2:
return map(int,sys.stdin.readline().split())
def makedict(var):
return dict(Counter(var))
# i am noob wanted to be better and trying hard for that
def printDivisors(n):
divisors=[]
# Note that this loop runs till square root
i = 1
while i <= math.sqrt(n):
if (n % i == 0) :
# If divisors are equal, print only one
if (n//i == i) :
divisors.append(i)
else :
# Otherwise print both
divisors.extend((i,n//i))
i = i + 1
return divisors
def countTotalBits(num):
# convert number into it's binary and
# remove first two characters 0b.
binary = bin(num)[2:]
return(len(binary))
def isPrime(n) :
# Corner cases
if (n <= 1) :
return False
if (n <= 3) :
return True
# This is checked so that we can skip
# middle five numbers in below loop
if (n % 2 == 0 or n % 3 == 0) :
return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
""" def dfs(node,val):
global tree,visited
visited[node]=1
ans[node]=val
val^=1
for i in tree[node]:
if visited[i]==-1:
dfs(i,val) """
n=vary(1)
num=array_int()
sum=0
st=set()
count=0
for i in range(n):
sum+=num[i]
if sum==0 or sum in st:
count+=1
st.clear()
st.add(num[i])
sum=num[i]
else:
st.add(sum)
print(count)
```
| 108,039 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya got an integer array a_1, a_2, ..., a_n. The array can contain both positive and negative integers, but Kolya doesn't like 0, so the array doesn't contain any zeros.
Kolya doesn't like that the sum of some subsegments of his array can be 0. The subsegment is some consecutive segment of elements of the array.
You have to help Kolya and change his array in such a way that it doesn't contain any subsegments with the sum 0. To reach this goal, you can insert any integers between any pair of adjacent elements of the array (integers can be really any: positive, negative, 0, any by absolute value, even such a huge that they can't be represented in most standard programming languages).
Your task is to find the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 200 000) — the number of elements in Kolya's array.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^{9} ≤ a_i ≤ 10^{9}, a_i ≠ 0) — the description of Kolya's array.
Output
Print the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Examples
Input
4
1 -5 3 2
Output
1
Input
5
4 -2 3 -9 2
Output
0
Input
9
-1 1 -1 1 -1 1 1 -1 -1
Output
6
Input
8
16 -5 -11 -15 10 5 4 -4
Output
3
Note
Consider the first example. There is only one subsegment with the sum 0. It starts in the second element and ends in the fourth element. It's enough to insert one element so the array doesn't contain any subsegments with the sum equal to zero. For example, it is possible to insert the integer 1 between second and third elements of the array.
There are no subsegments having sum 0 in the second example so you don't need to do anything.
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
n = int(input())
l = list(map(int,input().split()))
num = {0}
count,s = 0,0
for i in l:
s += i
if s in num:
num = {0}
count += 1
s = i
num.add(s)
print(count)
```
| 108,040 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya got an integer array a_1, a_2, ..., a_n. The array can contain both positive and negative integers, but Kolya doesn't like 0, so the array doesn't contain any zeros.
Kolya doesn't like that the sum of some subsegments of his array can be 0. The subsegment is some consecutive segment of elements of the array.
You have to help Kolya and change his array in such a way that it doesn't contain any subsegments with the sum 0. To reach this goal, you can insert any integers between any pair of adjacent elements of the array (integers can be really any: positive, negative, 0, any by absolute value, even such a huge that they can't be represented in most standard programming languages).
Your task is to find the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 200 000) — the number of elements in Kolya's array.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^{9} ≤ a_i ≤ 10^{9}, a_i ≠ 0) — the description of Kolya's array.
Output
Print the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Examples
Input
4
1 -5 3 2
Output
1
Input
5
4 -2 3 -9 2
Output
0
Input
9
-1 1 -1 1 -1 1 1 -1 -1
Output
6
Input
8
16 -5 -11 -15 10 5 4 -4
Output
3
Note
Consider the first example. There is only one subsegment with the sum 0. It starts in the second element and ends in the fourth element. It's enough to insert one element so the array doesn't contain any subsegments with the sum equal to zero. For example, it is possible to insert the integer 1 between second and third elements of the array.
There are no subsegments having sum 0 in the second example so you don't need to do anything.
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
pre = ans = 0
visited = set([0])
for i in a:
pre += i
if pre in visited:
ans += 1
visited.clear()
visited.add(0)
pre = i
visited.add(pre)
print(ans)
```
| 108,041 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya got an integer array a_1, a_2, ..., a_n. The array can contain both positive and negative integers, but Kolya doesn't like 0, so the array doesn't contain any zeros.
Kolya doesn't like that the sum of some subsegments of his array can be 0. The subsegment is some consecutive segment of elements of the array.
You have to help Kolya and change his array in such a way that it doesn't contain any subsegments with the sum 0. To reach this goal, you can insert any integers between any pair of adjacent elements of the array (integers can be really any: positive, negative, 0, any by absolute value, even such a huge that they can't be represented in most standard programming languages).
Your task is to find the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 200 000) — the number of elements in Kolya's array.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^{9} ≤ a_i ≤ 10^{9}, a_i ≠ 0) — the description of Kolya's array.
Output
Print the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Examples
Input
4
1 -5 3 2
Output
1
Input
5
4 -2 3 -9 2
Output
0
Input
9
-1 1 -1 1 -1 1 1 -1 -1
Output
6
Input
8
16 -5 -11 -15 10 5 4 -4
Output
3
Note
Consider the first example. There is only one subsegment with the sum 0. It starts in the second element and ends in the fourth element. It's enough to insert one element so the array doesn't contain any subsegments with the sum equal to zero. For example, it is possible to insert the integer 1 between second and third elements of the array.
There are no subsegments having sum 0 in the second example so you don't need to do anything.
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
#! /usr/bin/python3
import os
import sys
from io import BytesIO, IOBase
import math
def main1():
for _ in range(int(input())):
n, x = map(int, input().split())
if n <= 2:
print(1)
else:
n -= 2
print(1 + math.ceil(n / x))
def main2():
for _ in range(int(input())):
n, m = map(int, input().split())
flag = 0
for i in range(n):
mat = []
for j in range(2):
mat.append(list(map(int, input().split())))
if mat[0][1] == mat[1][0]:
flag = 1
if m % 2 or flag == 0:
print("NO")
else:
print("YES")
def main3():
for _ in range(int(input())):
n = int(input())
ans = float("inf")
for i in range(1, math.floor(math.sqrt(n)) + 1):
ans = min(ans, i - 1 + ((n -i) + i - 1) // i)
print(ans)
def main4():
n = int(input())
a = list(map(int, input().split()))
ls = [0] * n
ls[0] = a[0]
for i in range(1, n):
ls[i] = ls[i-1] + a[i]
ans = 0
d = dict()
d[0] = 0
d[ls[0]] = 0
prev_pos = 0
for i in range(1, n):
if ls[i] in d:
pos = d[ls[i]] + 1
if pos >= prev_pos:
prev_pos = i
ans += 1
d[ls[i]] = i
print(ans)
def main5():
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
max_win = min(a[0], b[1]) + min(a[1], b[2]) + min(a[2], b[0])
min_win = max(0, a[0] - b[0] - b[2]) + max(0, a[1] - b[1] - b[0]) + max(0, a[2] - b[2] - b[1])
print(min_win, max_win)
def main6():
pass
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main4()
```
| 108,042 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya got an integer array a_1, a_2, ..., a_n. The array can contain both positive and negative integers, but Kolya doesn't like 0, so the array doesn't contain any zeros.
Kolya doesn't like that the sum of some subsegments of his array can be 0. The subsegment is some consecutive segment of elements of the array.
You have to help Kolya and change his array in such a way that it doesn't contain any subsegments with the sum 0. To reach this goal, you can insert any integers between any pair of adjacent elements of the array (integers can be really any: positive, negative, 0, any by absolute value, even such a huge that they can't be represented in most standard programming languages).
Your task is to find the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 200 000) — the number of elements in Kolya's array.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^{9} ≤ a_i ≤ 10^{9}, a_i ≠ 0) — the description of Kolya's array.
Output
Print the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Examples
Input
4
1 -5 3 2
Output
1
Input
5
4 -2 3 -9 2
Output
0
Input
9
-1 1 -1 1 -1 1 1 -1 -1
Output
6
Input
8
16 -5 -11 -15 10 5 4 -4
Output
3
Note
Consider the first example. There is only one subsegment with the sum 0. It starts in the second element and ends in the fourth element. It's enough to insert one element so the array doesn't contain any subsegments with the sum equal to zero. For example, it is possible to insert the integer 1 between second and third elements of the array.
There are no subsegments having sum 0 in the second example so you don't need to do anything.
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
def main():
n = int(input())
a = list(map(int, input().split()))
d = set([0])
presum = 0
ans = 0
for v in a:
presum += v
if presum in d:
ans += 1
d.clear()
d.add(v)
d.add(0)
presum = v
else:
d.add(presum)
print(ans)
main()
```
| 108,043 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya got an integer array a_1, a_2, ..., a_n. The array can contain both positive and negative integers, but Kolya doesn't like 0, so the array doesn't contain any zeros.
Kolya doesn't like that the sum of some subsegments of his array can be 0. The subsegment is some consecutive segment of elements of the array.
You have to help Kolya and change his array in such a way that it doesn't contain any subsegments with the sum 0. To reach this goal, you can insert any integers between any pair of adjacent elements of the array (integers can be really any: positive, negative, 0, any by absolute value, even such a huge that they can't be represented in most standard programming languages).
Your task is to find the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 200 000) — the number of elements in Kolya's array.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^{9} ≤ a_i ≤ 10^{9}, a_i ≠ 0) — the description of Kolya's array.
Output
Print the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Examples
Input
4
1 -5 3 2
Output
1
Input
5
4 -2 3 -9 2
Output
0
Input
9
-1 1 -1 1 -1 1 1 -1 -1
Output
6
Input
8
16 -5 -11 -15 10 5 4 -4
Output
3
Note
Consider the first example. There is only one subsegment with the sum 0. It starts in the second element and ends in the fourth element. It's enough to insert one element so the array doesn't contain any subsegments with the sum equal to zero. For example, it is possible to insert the integer 1 between second and third elements of the array.
There are no subsegments having sum 0 in the second example so you don't need to do anything.
Submitted Solution:
```
#### IMPORTANT LIBRARY ####
############################
### DO NOT USE import random --> 250ms to load the library
############################
### In case of extra libraries: https://github.com/cheran-senthil/PyRival
######################
####### IMPORT #######
######################
from functools import cmp_to_key
from collections import deque
from heapq import heappush, heappop
from math import log, ceil
######################
#### STANDARD I/O ####
######################
import sys
import os
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def print(*args, **kwargs):
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
def inp():
return sys.stdin.readline().rstrip("\r\n") # for fast input
def ii():
return int(inp())
def li(lag = 0):
l = list(map(int, inp().split()))
if lag != 0:
for i in range(len(l)):
l[i] += lag
return l
def mi(lag = 0):
matrix = list()
for i in range(n):
matrix.append(li(lag))
return matrix
def sli(): #string list
return list(map(str, inp().split()))
def print_list(lista, space = " "):
print(space.join(map(str, lista)))
######################
##### UNION FIND #####
######################
class UnionFind:
def __init__(self, n):
self.parent = list(range(n))
self.size = [1] * n
self.num_sets = n
def find(self, a):
to_update = []
while a != self.parent[a]:
to_update.append(a)
a = self.parent[a]
for b in to_update:
self.parent[b] = a
return self.parent[a]
def merge(self, a, b):
a = self.find(a)
b = self.find(b)
if a == b:
return
if self.size[a] < self.size[b]:
a, b = b, a
self.num_sets -= 1
self.parent[b] = a
self.size[a] += self.size[b]
def set_size(self, a):
return self.size[self.find(a)]
def __len__(self):
return self.num_sets
######################
### BISECT METHODS ###
######################
def bisect_left(a, x):
"""i tale che a[i] >= x e a[i-1] < x"""
left = 0
right = len(a)
while left < right:
mid = (left+right)//2
if a[mid] < x:
left = mid+1
else:
right = mid
return left
def bisect_right(a, x):
"""i tale che a[i] > x e a[i-1] <= x"""
left = 0
right = len(a)
while left < right:
mid = (left+right)//2
if a[mid] > x:
right = mid
else:
left = mid+1
return left
def bisect_elements(a, x):
"""elementi pari a x nell'árray sortato"""
return bisect_right(a, x) - bisect_left(a, x)
######################
#### CUSTOM SORT #####
######################
def custom_sort(lista):
def cmp(x,y):
if x+y>y+x:
return 1
else:
return -1
return sorted(lista, key = cmp_to_key(cmp))
######################
### MOD OPERATION ####
######################
MOD = 10**9 + 7
maxN = 10**5
FACT = [0] * maxN
def add(x, y):
return (x+y) % MOD
def multiply(x, y):
return (x*y) % MOD
def power(x, y):
if y == 0:
return 1
elif y % 2:
return multiply(x, power(x, y-1))
else:
a = power(x, y//2)
return multiply(a, a)
def inverse(x):
return power(x, MOD-2)
def divide(x, y):
return multiply(x, inverse(y))
def allFactorials():
FACT[0] = 1
for i in range(1, maxN):
FACT[i] = multiply(i, FACT[i-1])
def coeffBinom(n, k):
if n < k:
return 0
return divide(FACT[n], multiply(FACT[k], FACT[n-k]))
######################
#### GCD & PRIMES ####
######################
def primes(N):
smallest_prime = [1] * (N+1)
prime = []
smallest_prime[0] = 0
smallest_prime[1] = 0
for i in range(2, N+1):
if smallest_prime[i] == 1:
prime.append(i)
smallest_prime[i] = i
j = 0
while (j < len(prime) and i * prime[j] <= N):
smallest_prime[i * prime[j]] = min(prime[j], smallest_prime[i])
j += 1
return prime, smallest_prime
def gcd(a, b):
s, t, r = 0, 1, b
old_s, old_t, old_r = 1, 0, a
while r != 0:
quotient = old_r//r
old_r, r = r, old_r - quotient*r
old_s, s = s, old_s - quotient*s
old_t, t = t, old_t - quotient*t
return old_r, old_s, old_t #gcd, x, y for ax+by=gcd
######################
#### GRAPH ALGOS #####
######################
# ZERO BASED GRAPH
def create_graph(n, m, undirected = 1, unweighted = 1):
graph = [[] for i in range(n)]
if unweighted:
for i in range(m):
[x, y] = li(lag = -1)
graph[x].append(y)
if undirected:
graph[y].append(x)
else:
for i in range(m):
[x, y, w] = li(lag = -1)
w += 1
graph[x].append([y,w])
if undirected:
graph[y].append([x,w])
return graph
def create_tree(n, unweighted = 1):
children = [[] for i in range(n)]
if unweighted:
for i in range(n-1):
[x, y] = li(lag = -1)
children[x].append(y)
children[y].append(x)
else:
for i in range(n-1):
[x, y, w] = li(lag = -1)
w += 1
children[x].append([y, w])
children[y].append([x, w])
return children
def create_edges(m, unweighted = 0):
edges = list()
if unweighted:
for i in range(m):
edges.append(li(lag = -1))
else:
for i in range(m):
[x, y, w] = li(lag = -1)
w += 1
edges.append([w,x,y])
return edges
def dist(tree, n, A, B = -1):
s = [[A, 0]]
massimo, massimo_nodo = 0, 0
distanza = -1
v = [-1] * n
while s:
el, dis = s.pop()
if dis > massimo:
massimo = dis
massimo_nodo = el
if el == B:
distanza = dis
for child in tree[el]:
if v[child] == -1:
v[child] = 1
s.append([child, dis+1])
return massimo, massimo_nodo, distanza
def diameter(tree):
_, foglia, _ = dist(tree, n, 0)
diam, _, _ = dist(tree, n, foglia)
return diam
def dfs(graph, n, A):
v = [-1] * n
s = [[A, 0]]
v[A] = 0
while s:
el, dis = s.pop()
for child in graph[el]:
if v[child] == -1:
v[child] = dis + 1
s.append([child, dis + 1])
return v #visited: -1 if not visited, otherwise v[B] is the distance in terms of edges
def bfs(graph, n, A):
v = [-1] * n
s = deque()
s.append([A, 0])
v[A] = 0
while s:
el, dis = s.popleft()
for child in graph[el]:
if v[child] == -1:
v[child] = dis + 1
s.append([child, dis + 1])
return v #visited: -1 if not visited, otherwise v[B] is the distance in terms of edges
def connected(graph, n):
v = dfs(graph, n, 0)
for el in v:
if el == -1:
return False
return True
# NON DIMENTICARTI DI PRENDERE GRAPH COME DIRETTO
def topological(graph, n):
indegree = [0] * n
for el in range(n):
for child in graph[el]:
indegree[child] += 1
s = deque()
for el in range(n):
if indegree[el] == 0:
s.append(el)
order = []
while s:
el = s.popleft()
order.append(el)
for child in graph[el]:
indegree[child] -= 1
if indegree[child] == 0:
s.append(child)
if n == len(order):
return False, order #False == no cycle
else:
return True, [] #True == there is a cycle and order is useless
# ASSUMING CONNECTED
def bipartite(graph, n):
color = [-1] * n
color[0] = 0
s = [0]
while s:
el = s.pop()
for child in graph[el]:
if color[child] == color[el]:
return False
if color[child] == -1:
s.append(child)
color[child] = 1 - color[el]
return True
# SHOULD BE DIRECTED AND WEIGHTED
def dijkstra(graph, n, A):
dist = [float('inf') for i in range(n)]
prev = [-1 for i in range(n)]
dist[A] = 0
pq = []
heappush(pq, [0, A])
while pq:
[d_v, v] = heappop(pq)
if (d_v != dist[v]):
continue
for to, w in graph[v]:
if dist[v] + w < dist[to]:
dist[to] = dist[v] + w
prev[to] = v
heappush(pq, [dist[to], to])
return dist, prev
# SHOULD BE DIRECTED AND WEIGHTED
def dijkstra_0_1(graph, n, A):
dist = [float('inf') for i in range(n)]
dist[A] = 0
p = deque()
p.append(A)
while p:
v = p.popleft()
for to, w in graph[v]:
if dist[v] + w < dist[to]:
dist[to] = dist[v] + w
if w == 1:
q.append(to)
else:
q.appendleft(to)
return dist
#SHOULD BE WEIGHTED (AND UNDIRECTED)
def floyd_warshall(graph, n):
dist = [[float('inf') for _ in range(n)] for _ in range(n)]
for i in range(n):
dist[i][i] = 0
for child, d in graph[i]:
dist[i][child] = d
dist[child][i] = d
for k in range(n):
for i in range(n):
for j in range(j):
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
return dist
#EDGES [w,x,y]
def minimum_spanning_tree(edges, n):
edges = sorted(edges)
union_find = UnionFind(n) #implemented above
used_edges = list()
for w, x, y in edges:
if union_find.find(x) != union_find.find(y):
union_find.merge(x, y)
used_edges.append([w,x,y])
return used_edges
#FROM A GIVEN ROOT, RECOVER THE STRUCTURE
def parents_children_root_unrooted_tree(tree, n, root = 0):
q = deque()
visited = [0] * n
parent = [-1] * n
children = [[] for i in range(n)]
q.append(root)
while q:
all_done = 1
visited[q[0]] = 1
for child in tree[q[0]]:
if not visited[child]:
all_done = 0
q.appendleft(child)
if all_done:
for child in tree[q[0]]:
if parent[child] == -1:
parent[q[0]] = child
children[child].append(q[0])
q.popleft()
return parent, children
# CALCULATING LONGEST PATH FOR ALL THE NODES
def all_longest_path_passing_from_node(parent, children, n):
q = deque()
visited = [len(children[i]) for i in range(n)]
downwards = [[0,0] for i in range(n)]
upward = [1] * n
longest_path = [1] * n
for i in range(n):
if not visited[i]:
q.append(i)
downwards[i] = [1,0]
while q:
node = q.popleft()
if parent[node] != -1:
visited[parent[node]] -= 1
if not visited[parent[node]]:
q.append(parent[node])
else:
root = node
for child in children[node]:
downwards[node] = sorted([downwards[node][0], downwards[node][1], downwards[child][0] + 1], reverse = True)[0:2]
s = [node]
while s:
node = s.pop()
if parent[node] != -1:
if downwards[parent[node]][0] == downwards[node][0] + 1:
upward[node] = 1 + max(upward[parent[node]], downwards[parent[node]][1])
else:
upward[node] = 1 + max(upward[parent[node]], downwards[parent[node]][0])
longest_path[node] = downwards[node][0] + downwards[node][1] + upward[node] - min([downwards[node][0], downwards[node][1], upward[node]]) - 1
for child in children[node]:
s.append(child)
return longest_path
def finding_ancestors(parent, queries, n):
steps = int(ceil(log(n, 2)))
ancestors = [[-1 for i in range(n)] for j in range(steps)]
ancestors[0] = parent
for i in range(1, steps):
for node in range(n):
if ancestors[i-1][node] != -1:
ancestors[i][node] = ancestors[i-1][ancestors[i-1][node]]
result = []
for node, k in queries:
ans = node
if k >= n:
ans = -1
i = 0
while k > 0 and ans != -1:
if k % 2:
ans = ancestors[i][ans]
k = k // 2
i += 1
result.append(ans)
return result #Preprocessing in O(n log n). For each query O(log k)
### TBD SUCCESSOR GRAPH 7.5
### TBD TREE QUERIES 10.2 da 2 a 4
### TBD ADVANCED TREE 10.3
### TBD GRAPHS AND MATRICES 11.3.3 e 11.4.3 e 11.5.3 (ON GAMES)
######################
####### OTHERS #######
######################
def prefix_sum(arr):
r = [0] * (len(arr)+1)
for i, el in enumerate(arr):
r[i+1] = r[i] + el
return r
def nearest_from_the_left_smaller_elements(arr):
n = len(arr)
res = [-1] * n
s = []
for i, el in enumerate(arr):
while s and s[-1] >= el:
s.pop()
if s:
res[i] = s[-1]
s.append(el)
return res
def sliding_window_minimum(arr, k):
res = []
q = deque()
for i, el in enumerate(arr):
while q and arr[q[-1]] >= el:
q.pop()
q.append(i)
while q and q[0] <= i - k:
q.popleft()
if i >= k-1:
res.append(arr[q[0]])
return res
### TBD COUNT ELEMENT SMALLER THAN SELF
######################
## END OF LIBRARIES ##
######################
n = ii()
a = li()
i = 0
pre = 0
s = 0
d = set()
d.add(0)
while i < n:
if pre + a[i] in d:
s += 1
d = set()
d.add(0)
pre = 0
else:
pre += a[i]
d.add(pre)
i += 1
print(s)
```
Yes
| 108,044 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya got an integer array a_1, a_2, ..., a_n. The array can contain both positive and negative integers, but Kolya doesn't like 0, so the array doesn't contain any zeros.
Kolya doesn't like that the sum of some subsegments of his array can be 0. The subsegment is some consecutive segment of elements of the array.
You have to help Kolya and change his array in such a way that it doesn't contain any subsegments with the sum 0. To reach this goal, you can insert any integers between any pair of adjacent elements of the array (integers can be really any: positive, negative, 0, any by absolute value, even such a huge that they can't be represented in most standard programming languages).
Your task is to find the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 200 000) — the number of elements in Kolya's array.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^{9} ≤ a_i ≤ 10^{9}, a_i ≠ 0) — the description of Kolya's array.
Output
Print the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Examples
Input
4
1 -5 3 2
Output
1
Input
5
4 -2 3 -9 2
Output
0
Input
9
-1 1 -1 1 -1 1 1 -1 -1
Output
6
Input
8
16 -5 -11 -15 10 5 4 -4
Output
3
Note
Consider the first example. There is only one subsegment with the sum 0. It starts in the second element and ends in the fourth element. It's enough to insert one element so the array doesn't contain any subsegments with the sum equal to zero. For example, it is possible to insert the integer 1 between second and third elements of the array.
There are no subsegments having sum 0 in the second example so you don't need to do anything.
Submitted Solution:
```
if __name__ == '__main__':
n = int( input() )
arr = list( map( int, input().split() ) )
Set = set([0])
prefix_sum = 0
count = 0
for i in range( n ) :
prefix_sum += arr[i]
if prefix_sum in Set :
count += 1
# print(count)
Set = set([0])
prefix_sum = arr[i]
Set.add( prefix_sum )
print(count)
```
Yes
| 108,045 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya got an integer array a_1, a_2, ..., a_n. The array can contain both positive and negative integers, but Kolya doesn't like 0, so the array doesn't contain any zeros.
Kolya doesn't like that the sum of some subsegments of his array can be 0. The subsegment is some consecutive segment of elements of the array.
You have to help Kolya and change his array in such a way that it doesn't contain any subsegments with the sum 0. To reach this goal, you can insert any integers between any pair of adjacent elements of the array (integers can be really any: positive, negative, 0, any by absolute value, even such a huge that they can't be represented in most standard programming languages).
Your task is to find the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 200 000) — the number of elements in Kolya's array.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^{9} ≤ a_i ≤ 10^{9}, a_i ≠ 0) — the description of Kolya's array.
Output
Print the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Examples
Input
4
1 -5 3 2
Output
1
Input
5
4 -2 3 -9 2
Output
0
Input
9
-1 1 -1 1 -1 1 1 -1 -1
Output
6
Input
8
16 -5 -11 -15 10 5 4 -4
Output
3
Note
Consider the first example. There is only one subsegment with the sum 0. It starts in the second element and ends in the fourth element. It's enough to insert one element so the array doesn't contain any subsegments with the sum equal to zero. For example, it is possible to insert the integer 1 between second and third elements of the array.
There are no subsegments having sum 0 in the second example so you don't need to do anything.
Submitted Solution:
```
n = int(input())
arr = list(map(int, input().strip().split()))
d = {}
d[0] = -1
ans = s = curr = 0
for i in range(len(arr)):
s += arr[i]
if s in d and curr <= d[s] + 1:
ans += 1
curr = i
d[s] = i
print(ans)
```
Yes
| 108,046 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya got an integer array a_1, a_2, ..., a_n. The array can contain both positive and negative integers, but Kolya doesn't like 0, so the array doesn't contain any zeros.
Kolya doesn't like that the sum of some subsegments of his array can be 0. The subsegment is some consecutive segment of elements of the array.
You have to help Kolya and change his array in such a way that it doesn't contain any subsegments with the sum 0. To reach this goal, you can insert any integers between any pair of adjacent elements of the array (integers can be really any: positive, negative, 0, any by absolute value, even such a huge that they can't be represented in most standard programming languages).
Your task is to find the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 200 000) — the number of elements in Kolya's array.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^{9} ≤ a_i ≤ 10^{9}, a_i ≠ 0) — the description of Kolya's array.
Output
Print the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Examples
Input
4
1 -5 3 2
Output
1
Input
5
4 -2 3 -9 2
Output
0
Input
9
-1 1 -1 1 -1 1 1 -1 -1
Output
6
Input
8
16 -5 -11 -15 10 5 4 -4
Output
3
Note
Consider the first example. There is only one subsegment with the sum 0. It starts in the second element and ends in the fourth element. It's enough to insert one element so the array doesn't contain any subsegments with the sum equal to zero. For example, it is possible to insert the integer 1 between second and third elements of the array.
There are no subsegments having sum 0 in the second example so you don't need to do anything.
Submitted Solution:
```
from sys import stdin,stdout
input=stdin.readline
n=int(input())
arr=list(map(int, input().split()))
c=0
su=0
dic={}
i=0
fixed=-1
dic[0]=-1
for d in arr:
su+=d
if su==0:
if dic[su] >= fixed - 1:
# print(i)
c += 1
fixed = i
dic[su] = i
elif su in dic:
# print("yes",i,c,su,dic[su],fixed)
if dic[su]>=fixed-1:
# print(i)
c+=1
fixed=i
dic[su]=i
# print("no", i, c, su, dic[su], fixed)
if su not in dic:
dic[su]=i
i+=1
print(c)
# print(str(dic))
```
Yes
| 108,047 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya got an integer array a_1, a_2, ..., a_n. The array can contain both positive and negative integers, but Kolya doesn't like 0, so the array doesn't contain any zeros.
Kolya doesn't like that the sum of some subsegments of his array can be 0. The subsegment is some consecutive segment of elements of the array.
You have to help Kolya and change his array in such a way that it doesn't contain any subsegments with the sum 0. To reach this goal, you can insert any integers between any pair of adjacent elements of the array (integers can be really any: positive, negative, 0, any by absolute value, even such a huge that they can't be represented in most standard programming languages).
Your task is to find the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 200 000) — the number of elements in Kolya's array.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^{9} ≤ a_i ≤ 10^{9}, a_i ≠ 0) — the description of Kolya's array.
Output
Print the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Examples
Input
4
1 -5 3 2
Output
1
Input
5
4 -2 3 -9 2
Output
0
Input
9
-1 1 -1 1 -1 1 1 -1 -1
Output
6
Input
8
16 -5 -11 -15 10 5 4 -4
Output
3
Note
Consider the first example. There is only one subsegment with the sum 0. It starts in the second element and ends in the fourth element. It's enough to insert one element so the array doesn't contain any subsegments with the sum equal to zero. For example, it is possible to insert the integer 1 between second and third elements of the array.
There are no subsegments having sum 0 in the second example so you don't need to do anything.
Submitted Solution:
```
def main():
length = int(input())
array = list(map(int, input().split(' ')))
print(findSubSeg(length, array))
def findSubSeg(length, array):
if length == 1:
return 0
zeroNum = 0
step = 1
headLoc = 0
flag = False
newArray = []
while not flag and step < length:
headLoc = 0
tailLoc = -1
for i in range(length-step):
if i <= tailLoc:
continue
if sum(array[i:i+step+1]) == 0:
bestLoc = findBestLoc(array, length, i, i+step)
newArray.append(array[headLoc:bestLoc])
tailLoc = bestLoc - 1
headLoc = tailLoc + 1
zeroNum += 1
flag = True
step += 1
if not flag:
return 0
newArray.append(array[headLoc:])
for elem in newArray:
zeroNum += findSubSeg(len(elem), elem)
return zeroNum
def findBestLoc(array, length, headLoc, tailLoc):
bestLoc = tailLoc
for i in range(tailLoc - headLoc, 0, -1):
verify = 0
step = 0
while headLoc + i + step < length:
verify += array[headLoc+i+step]
if verify == 0:
break
step += 1
if verify != 0:
bestLoc = headLoc + i
return bestLoc
if __name__ == '__main__':
main()
```
No
| 108,048 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya got an integer array a_1, a_2, ..., a_n. The array can contain both positive and negative integers, but Kolya doesn't like 0, so the array doesn't contain any zeros.
Kolya doesn't like that the sum of some subsegments of his array can be 0. The subsegment is some consecutive segment of elements of the array.
You have to help Kolya and change his array in such a way that it doesn't contain any subsegments with the sum 0. To reach this goal, you can insert any integers between any pair of adjacent elements of the array (integers can be really any: positive, negative, 0, any by absolute value, even such a huge that they can't be represented in most standard programming languages).
Your task is to find the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 200 000) — the number of elements in Kolya's array.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^{9} ≤ a_i ≤ 10^{9}, a_i ≠ 0) — the description of Kolya's array.
Output
Print the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Examples
Input
4
1 -5 3 2
Output
1
Input
5
4 -2 3 -9 2
Output
0
Input
9
-1 1 -1 1 -1 1 1 -1 -1
Output
6
Input
8
16 -5 -11 -15 10 5 4 -4
Output
3
Note
Consider the first example. There is only one subsegment with the sum 0. It starts in the second element and ends in the fourth element. It's enough to insert one element so the array doesn't contain any subsegments with the sum equal to zero. For example, it is possible to insert the integer 1 between second and third elements of the array.
There are no subsegments having sum 0 in the second example so you don't need to do anything.
Submitted Solution:
```
from collections import *
from functools import *
import math
import sys
# sys.stdin = open("Desktop//ip.txt",'r')
# sys.stdout = open("Desktop//op.txt",'w')
inp = sys.stdin.readline
out = sys.stdout.write
def mi():
return map(int,inp().split())
def li():
return list(mi())
def ii():
return int(inp())
def main():
n=ii()
a=li()
currsum = 0
dic = defaultdict(int)
ans = 0
for i in a:
currsum += i
if currsum in dic:
ans += dic[currsum]
currsum = i
dic[currsum]+=1
print(ans)
main()
```
No
| 108,049 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya got an integer array a_1, a_2, ..., a_n. The array can contain both positive and negative integers, but Kolya doesn't like 0, so the array doesn't contain any zeros.
Kolya doesn't like that the sum of some subsegments of his array can be 0. The subsegment is some consecutive segment of elements of the array.
You have to help Kolya and change his array in such a way that it doesn't contain any subsegments with the sum 0. To reach this goal, you can insert any integers between any pair of adjacent elements of the array (integers can be really any: positive, negative, 0, any by absolute value, even such a huge that they can't be represented in most standard programming languages).
Your task is to find the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 200 000) — the number of elements in Kolya's array.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^{9} ≤ a_i ≤ 10^{9}, a_i ≠ 0) — the description of Kolya's array.
Output
Print the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Examples
Input
4
1 -5 3 2
Output
1
Input
5
4 -2 3 -9 2
Output
0
Input
9
-1 1 -1 1 -1 1 1 -1 -1
Output
6
Input
8
16 -5 -11 -15 10 5 4 -4
Output
3
Note
Consider the first example. There is only one subsegment with the sum 0. It starts in the second element and ends in the fourth element. It's enough to insert one element so the array doesn't contain any subsegments with the sum equal to zero. For example, it is possible to insert the integer 1 between second and third elements of the array.
There are no subsegments having sum 0 in the second example so you don't need to do anything.
Submitted Solution:
```
n = int(input())
arr = list(map(lambda x: int(x), input().split(' ')))
count = {0: 1}
ans = 0
ssum = 0
for x in arr:
ssum += x
if ssum in count:
ans += count[ssum]
count = {0: 1}
ssum = x
else:
count[ssum] = 1
print(ans)
```
No
| 108,050 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya got an integer array a_1, a_2, ..., a_n. The array can contain both positive and negative integers, but Kolya doesn't like 0, so the array doesn't contain any zeros.
Kolya doesn't like that the sum of some subsegments of his array can be 0. The subsegment is some consecutive segment of elements of the array.
You have to help Kolya and change his array in such a way that it doesn't contain any subsegments with the sum 0. To reach this goal, you can insert any integers between any pair of adjacent elements of the array (integers can be really any: positive, negative, 0, any by absolute value, even such a huge that they can't be represented in most standard programming languages).
Your task is to find the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 200 000) — the number of elements in Kolya's array.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^{9} ≤ a_i ≤ 10^{9}, a_i ≠ 0) — the description of Kolya's array.
Output
Print the minimum number of integers you have to insert into Kolya's array in such a way that the resulting array doesn't contain any subsegments with the sum 0.
Examples
Input
4
1 -5 3 2
Output
1
Input
5
4 -2 3 -9 2
Output
0
Input
9
-1 1 -1 1 -1 1 1 -1 -1
Output
6
Input
8
16 -5 -11 -15 10 5 4 -4
Output
3
Note
Consider the first example. There is only one subsegment with the sum 0. It starts in the second element and ends in the fourth element. It's enough to insert one element so the array doesn't contain any subsegments with the sum equal to zero. For example, it is possible to insert the integer 1 between second and third elements of the array.
There are no subsegments having sum 0 in the second example so you don't need to do anything.
Submitted Solution:
```
t = int(input())
arr = list(map(int, input().split()))
to_add = 0
last_plus = 0
last_minus = 0
start_plus = 0
end_plus = 0
start_minus = 0
end_minus = 0
total = 0
total_index = 0
last_updated = ""
intervals = []
for i, number in enumerate(arr):
if number > 0:
if last_updated == "-":
last_plus = 0
start_plus = i
last_plus += abs(number)
total += number
last_updated = "+"
elif number < 0:
if last_updated == "+":
last_minus = 0
start_minus = i
last_minus += abs(number)
total += number
last_updated = "-"
if last_plus == last_minus:
intervals.append((min(start_minus, start_plus), i))
total = number
total_index = i
elif total == 0:
intervals.append((total_index, i))
total_index = i + 1
x = set()
for item in intervals:
x.add(item[0])
print(len(x))
```
No
| 108,051 |
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").
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)
```
| 108,052 |
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").
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)
```
| 108,053 |
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").
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)
```
| 108,054 |
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").
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()
```
| 108,055 |
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").
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
```
| 108,056 |
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").
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())
```
| 108,057 |
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").
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)
```
| 108,058 |
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").
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)
```
| 108,059 |
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)
```
Yes
| 108,060 |
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)
```
Yes
| 108,061 |
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)
```
Yes
| 108,062 |
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)
```
Yes
| 108,063 |
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())
```
No
| 108,064 |
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)
```
No
| 108,065 |
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)
```
No
| 108,066 |
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)
```
No
| 108,067 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a sequence a with n elements 1, 2, 3, ..., k - 1, k, k - 1, k - 2, ..., k - (n - k) (k ≤ n < 2k).
Let's call as inversion in a a pair of indices i < j such that a[i] > a[j].
Suppose, you have some permutation p of size k and you build a sequence b of size n in the following manner: b[i] = p[a[i]].
Your goal is to find such permutation p that the total number of inversions in b doesn't exceed the total number of inversions in a, and b is lexicographically maximum.
Small reminder: the sequence of k integers is called a permutation if it contains all integers from 1 to k exactly once.
Another small reminder: a sequence s is lexicographically smaller than another sequence t, if either s is a prefix of t, or for the first i such that s_i ≠ t_i, s_i < t_i holds (in the first position that these sequences are different, s has smaller number than t).
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers n and k (k ≤ n < 2k; 1 ≤ k ≤ 10^5) — the length of the sequence a and its maximum.
It's guaranteed that the total sum of k over test cases doesn't exceed 10^5.
Output
For each test case, print k integers — the permutation p which maximizes b lexicographically without increasing the total number of inversions.
It can be proven that p exists and is unique.
Example
Input
4
1 1
2 2
3 2
4 3
Output
1
1 2
2 1
1 3 2
Note
In the first test case, the sequence a = [1], there is only one permutation p = [1].
In the second test case, the sequence a = [1, 2]. There is no inversion in a, so there is only one permutation p = [1, 2] which doesn't increase the number of inversions.
In the third test case, a = [1, 2, 1] and has 1 inversion. If we use p = [2, 1], then b = [p[a[1]], p[a[2]], p[a[3]]] = [2, 1, 2] and also has 1 inversion.
In the fourth test case, a = [1, 2, 3, 2], and since p = [1, 3, 2] then b = [1, 3, 2, 3]. Both a and b have 1 inversion and b is the lexicographically maximum.
Tags: constructive algorithms, math
Correct Solution:
```
for i in range(int(input())):
n,k=map(int,input().split())
g=[]
for j in range(2*k-n):
g.append(j+1)
if (n-k)==0:
print(' '.join(map(str,g)))
else:
h=[]
for j in range(k-1-n+k):
h.append(j+1)
for j in range(k-(k-1-n+k)):
h.append(k-j)
print(' '.join(map(str,h)))
```
| 108,068 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a sequence a with n elements 1, 2, 3, ..., k - 1, k, k - 1, k - 2, ..., k - (n - k) (k ≤ n < 2k).
Let's call as inversion in a a pair of indices i < j such that a[i] > a[j].
Suppose, you have some permutation p of size k and you build a sequence b of size n in the following manner: b[i] = p[a[i]].
Your goal is to find such permutation p that the total number of inversions in b doesn't exceed the total number of inversions in a, and b is lexicographically maximum.
Small reminder: the sequence of k integers is called a permutation if it contains all integers from 1 to k exactly once.
Another small reminder: a sequence s is lexicographically smaller than another sequence t, if either s is a prefix of t, or for the first i such that s_i ≠ t_i, s_i < t_i holds (in the first position that these sequences are different, s has smaller number than t).
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers n and k (k ≤ n < 2k; 1 ≤ k ≤ 10^5) — the length of the sequence a and its maximum.
It's guaranteed that the total sum of k over test cases doesn't exceed 10^5.
Output
For each test case, print k integers — the permutation p which maximizes b lexicographically without increasing the total number of inversions.
It can be proven that p exists and is unique.
Example
Input
4
1 1
2 2
3 2
4 3
Output
1
1 2
2 1
1 3 2
Note
In the first test case, the sequence a = [1], there is only one permutation p = [1].
In the second test case, the sequence a = [1, 2]. There is no inversion in a, so there is only one permutation p = [1, 2] which doesn't increase the number of inversions.
In the third test case, a = [1, 2, 1] and has 1 inversion. If we use p = [2, 1], then b = [p[a[1]], p[a[2]], p[a[3]]] = [2, 1, 2] and also has 1 inversion.
In the fourth test case, a = [1, 2, 3, 2], and since p = [1, 3, 2] then b = [1, 3, 2, 3]. Both a and b have 1 inversion and b is the lexicographically maximum.
Tags: constructive algorithms, math
Correct Solution:
```
"""
ID: happyn61
LANG: PYTHON3
PROB: loan
"""
#from collections import defaultdict
import sys
import heapq
from collections import deque
#fin = open ('loan.in', 'r')
#fout = open ('loan.out', 'w')
#print(dic["4734"])
def find(parent,i):
if parent[i] != i:
parent[i]=find(parent,parent[i])
return parent[i]
# A utility function to do union of two subsets
def union(parent,rank,xx,yy):
x=find(parent,xx)
y=find(parent,yy)
if rank[x]>rank[y]:
parent[y]=x
elif rank[y]>rank[x]:
parent[x]=y
else:
parent[y]=x
rank[x]+=1
ans=0
#NQ=sys.stdin.readline().strip().split()
n=int(sys.stdin.readline().strip())
#N1=int(NQ[0])
#N2=int(NQ[1])
#N3=int(NQ[1])
for j in range(n):
AB=sys.stdin.readline().strip().split()
n=int(AB[0])
m=int(AB[1])
l=[str(i+1) for i in range(m)]
if 2*m-1-n==0:
l.reverse()
print(" ".join(l))
else:
ll=l[2*m-1-n:]
ll.reverse()
k=l[:2*m-1-n]+ll
print(" ".join(k))
#l=sys.stdin.readline().strip().split()
#s1=sys.stdin.readline().strip()
#s2=sys.stdin.readline().strip()
#print(pre,post,ll,rr,m1,m2,pre[ll],post[n-1-rr],post[n-1-rr][2])
#if F:
# print("yes")
#else:
# print("no")
#return True
#for x,y in occupy:
# l[x][y]="X"
#for ll in l:
# print("".join(ll))
```
| 108,069 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a sequence a with n elements 1, 2, 3, ..., k - 1, k, k - 1, k - 2, ..., k - (n - k) (k ≤ n < 2k).
Let's call as inversion in a a pair of indices i < j such that a[i] > a[j].
Suppose, you have some permutation p of size k and you build a sequence b of size n in the following manner: b[i] = p[a[i]].
Your goal is to find such permutation p that the total number of inversions in b doesn't exceed the total number of inversions in a, and b is lexicographically maximum.
Small reminder: the sequence of k integers is called a permutation if it contains all integers from 1 to k exactly once.
Another small reminder: a sequence s is lexicographically smaller than another sequence t, if either s is a prefix of t, or for the first i such that s_i ≠ t_i, s_i < t_i holds (in the first position that these sequences are different, s has smaller number than t).
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers n and k (k ≤ n < 2k; 1 ≤ k ≤ 10^5) — the length of the sequence a and its maximum.
It's guaranteed that the total sum of k over test cases doesn't exceed 10^5.
Output
For each test case, print k integers — the permutation p which maximizes b lexicographically without increasing the total number of inversions.
It can be proven that p exists and is unique.
Example
Input
4
1 1
2 2
3 2
4 3
Output
1
1 2
2 1
1 3 2
Note
In the first test case, the sequence a = [1], there is only one permutation p = [1].
In the second test case, the sequence a = [1, 2]. There is no inversion in a, so there is only one permutation p = [1, 2] which doesn't increase the number of inversions.
In the third test case, a = [1, 2, 1] and has 1 inversion. If we use p = [2, 1], then b = [p[a[1]], p[a[2]], p[a[3]]] = [2, 1, 2] and also has 1 inversion.
In the fourth test case, a = [1, 2, 3, 2], and since p = [1, 3, 2] then b = [1, 3, 2, 3]. Both a and b have 1 inversion and b is the lexicographically maximum.
Tags: constructive algorithms, math
Correct Solution:
```
"""
Code of Ayush Tiwari
Codeforces: servermonk
Codechef: ayush572000
"""
#import sys
#input = sys.stdin.buffer.readline
#Fast IO
import os, sys
from io import IOBase, BytesIO
py2 = round(0.5)
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
BUFSIZE = 8192
class FastIO(BytesIO):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.writable = "x" in file.mode or "w" in file.mode
self.write = super(FastIO, self).write if self.writable else None
def _fill(self):
s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
return s
def read(self):
while self._fill(): pass
return super(FastIO,self).read()
def readline(self):
while self.newlines == 0:
s = self._fill(); self.newlines = s.count(b"\n") + (not s)
self.newlines -= 1
return super(FastIO, self).readline()
def flush(self):
if self.writable:
os.write(self._fd, self.getvalue())
self.truncate(0), self.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
if py2:
self.write = self.buffer.write
self.read = self.buffer.read
self.readline = self.buffer.readline
else:
self.write = lambda s:self.buffer.write(s.encode('ascii'))
self.read = lambda:self.buffer.read().decode('ascii')
self.readline = lambda:self.buffer.readline().decode('ascii')
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')
# Cout implemented in Python
import sys
class ostream:
def __lshift__(self,a):
sys.stdout.write(str(a))
return self
cout = ostream()
endl = '\n'
def solution():
# This is the main code
n,k=map(int,input().split())
l=[]
for i in range(1,2*k-n):
l.append(i)
for i in range(k,2*k-n-1,-1):
l.append(i)
print(*l)
t=int(input())
for _ in range(t):
solution()
```
| 108,070 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a sequence a with n elements 1, 2, 3, ..., k - 1, k, k - 1, k - 2, ..., k - (n - k) (k ≤ n < 2k).
Let's call as inversion in a a pair of indices i < j such that a[i] > a[j].
Suppose, you have some permutation p of size k and you build a sequence b of size n in the following manner: b[i] = p[a[i]].
Your goal is to find such permutation p that the total number of inversions in b doesn't exceed the total number of inversions in a, and b is lexicographically maximum.
Small reminder: the sequence of k integers is called a permutation if it contains all integers from 1 to k exactly once.
Another small reminder: a sequence s is lexicographically smaller than another sequence t, if either s is a prefix of t, or for the first i such that s_i ≠ t_i, s_i < t_i holds (in the first position that these sequences are different, s has smaller number than t).
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers n and k (k ≤ n < 2k; 1 ≤ k ≤ 10^5) — the length of the sequence a and its maximum.
It's guaranteed that the total sum of k over test cases doesn't exceed 10^5.
Output
For each test case, print k integers — the permutation p which maximizes b lexicographically without increasing the total number of inversions.
It can be proven that p exists and is unique.
Example
Input
4
1 1
2 2
3 2
4 3
Output
1
1 2
2 1
1 3 2
Note
In the first test case, the sequence a = [1], there is only one permutation p = [1].
In the second test case, the sequence a = [1, 2]. There is no inversion in a, so there is only one permutation p = [1, 2] which doesn't increase the number of inversions.
In the third test case, a = [1, 2, 1] and has 1 inversion. If we use p = [2, 1], then b = [p[a[1]], p[a[2]], p[a[3]]] = [2, 1, 2] and also has 1 inversion.
In the fourth test case, a = [1, 2, 3, 2], and since p = [1, 3, 2] then b = [1, 3, 2, 3]. Both a and b have 1 inversion and b is the lexicographically maximum.
Tags: constructive algorithms, math
Correct Solution:
```
for _ in range(int(input())):
n, k = map(int, input().split())
if n == 1 or n == 2 or n == k:
print(*[i for i in range(1, n+1)])
else:
a = [i+1 for i in range(n-2*(n-k)-1, k)]
a.reverse()
print(*[i+1 for i in range(n-2*(n-k)-1)], *a)
```
| 108,071 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a sequence a with n elements 1, 2, 3, ..., k - 1, k, k - 1, k - 2, ..., k - (n - k) (k ≤ n < 2k).
Let's call as inversion in a a pair of indices i < j such that a[i] > a[j].
Suppose, you have some permutation p of size k and you build a sequence b of size n in the following manner: b[i] = p[a[i]].
Your goal is to find such permutation p that the total number of inversions in b doesn't exceed the total number of inversions in a, and b is lexicographically maximum.
Small reminder: the sequence of k integers is called a permutation if it contains all integers from 1 to k exactly once.
Another small reminder: a sequence s is lexicographically smaller than another sequence t, if either s is a prefix of t, or for the first i such that s_i ≠ t_i, s_i < t_i holds (in the first position that these sequences are different, s has smaller number than t).
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers n and k (k ≤ n < 2k; 1 ≤ k ≤ 10^5) — the length of the sequence a and its maximum.
It's guaranteed that the total sum of k over test cases doesn't exceed 10^5.
Output
For each test case, print k integers — the permutation p which maximizes b lexicographically without increasing the total number of inversions.
It can be proven that p exists and is unique.
Example
Input
4
1 1
2 2
3 2
4 3
Output
1
1 2
2 1
1 3 2
Note
In the first test case, the sequence a = [1], there is only one permutation p = [1].
In the second test case, the sequence a = [1, 2]. There is no inversion in a, so there is only one permutation p = [1, 2] which doesn't increase the number of inversions.
In the third test case, a = [1, 2, 1] and has 1 inversion. If we use p = [2, 1], then b = [p[a[1]], p[a[2]], p[a[3]]] = [2, 1, 2] and also has 1 inversion.
In the fourth test case, a = [1, 2, 3, 2], and since p = [1, 3, 2] then b = [1, 3, 2, 3]. Both a and b have 1 inversion and b is the lexicographically maximum.
Tags: constructive algorithms, math
Correct Solution:
```
for t in range(int(input())):n,k = map(int,input().split());print(*(list(range(1,k-(n-k))) + list(range(k,k-(n-k)-1,-1))))
```
| 108,072 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a sequence a with n elements 1, 2, 3, ..., k - 1, k, k - 1, k - 2, ..., k - (n - k) (k ≤ n < 2k).
Let's call as inversion in a a pair of indices i < j such that a[i] > a[j].
Suppose, you have some permutation p of size k and you build a sequence b of size n in the following manner: b[i] = p[a[i]].
Your goal is to find such permutation p that the total number of inversions in b doesn't exceed the total number of inversions in a, and b is lexicographically maximum.
Small reminder: the sequence of k integers is called a permutation if it contains all integers from 1 to k exactly once.
Another small reminder: a sequence s is lexicographically smaller than another sequence t, if either s is a prefix of t, or for the first i such that s_i ≠ t_i, s_i < t_i holds (in the first position that these sequences are different, s has smaller number than t).
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers n and k (k ≤ n < 2k; 1 ≤ k ≤ 10^5) — the length of the sequence a and its maximum.
It's guaranteed that the total sum of k over test cases doesn't exceed 10^5.
Output
For each test case, print k integers — the permutation p which maximizes b lexicographically without increasing the total number of inversions.
It can be proven that p exists and is unique.
Example
Input
4
1 1
2 2
3 2
4 3
Output
1
1 2
2 1
1 3 2
Note
In the first test case, the sequence a = [1], there is only one permutation p = [1].
In the second test case, the sequence a = [1, 2]. There is no inversion in a, so there is only one permutation p = [1, 2] which doesn't increase the number of inversions.
In the third test case, a = [1, 2, 1] and has 1 inversion. If we use p = [2, 1], then b = [p[a[1]], p[a[2]], p[a[3]]] = [2, 1, 2] and also has 1 inversion.
In the fourth test case, a = [1, 2, 3, 2], and since p = [1, 3, 2] then b = [1, 3, 2, 3]. Both a and b have 1 inversion and b is the lexicographically maximum.
Tags: constructive algorithms, math
Correct Solution:
```
import sys
input = sys.stdin.readline
t=int(input())
for tests in range(t):
n,k=map(int,input().split())
aa=k-(n-k)
#print(aa)
print(*list(range(1,aa))+list(range(k,aa-1,-1)))
```
| 108,073 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a sequence a with n elements 1, 2, 3, ..., k - 1, k, k - 1, k - 2, ..., k - (n - k) (k ≤ n < 2k).
Let's call as inversion in a a pair of indices i < j such that a[i] > a[j].
Suppose, you have some permutation p of size k and you build a sequence b of size n in the following manner: b[i] = p[a[i]].
Your goal is to find such permutation p that the total number of inversions in b doesn't exceed the total number of inversions in a, and b is lexicographically maximum.
Small reminder: the sequence of k integers is called a permutation if it contains all integers from 1 to k exactly once.
Another small reminder: a sequence s is lexicographically smaller than another sequence t, if either s is a prefix of t, or for the first i such that s_i ≠ t_i, s_i < t_i holds (in the first position that these sequences are different, s has smaller number than t).
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers n and k (k ≤ n < 2k; 1 ≤ k ≤ 10^5) — the length of the sequence a and its maximum.
It's guaranteed that the total sum of k over test cases doesn't exceed 10^5.
Output
For each test case, print k integers — the permutation p which maximizes b lexicographically without increasing the total number of inversions.
It can be proven that p exists and is unique.
Example
Input
4
1 1
2 2
3 2
4 3
Output
1
1 2
2 1
1 3 2
Note
In the first test case, the sequence a = [1], there is only one permutation p = [1].
In the second test case, the sequence a = [1, 2]. There is no inversion in a, so there is only one permutation p = [1, 2] which doesn't increase the number of inversions.
In the third test case, a = [1, 2, 1] and has 1 inversion. If we use p = [2, 1], then b = [p[a[1]], p[a[2]], p[a[3]]] = [2, 1, 2] and also has 1 inversion.
In the fourth test case, a = [1, 2, 3, 2], and since p = [1, 3, 2] then b = [1, 3, 2, 3]. Both a and b have 1 inversion and b is the lexicographically maximum.
Tags: constructive algorithms, math
Correct Solution:
```
import sys
import os
import math
import copy
from bisect import bisect
from io import BytesIO, IOBase
from math import sqrt,floor,factorial,gcd,log,ceil
from collections import deque,Counter,defaultdict
from itertools import permutations,combinations,accumulate
def Int(): return int(sys.stdin.readline())
def Mint(): return map(int,sys.stdin.readline().split())
def Lstr(): return list(sys.stdin.readline().strip())
def Str(): return sys.stdin.readline().strip()
def Mstr(): return map(str,sys.stdin.readline().strip().split())
def List(): return list(map(int,sys.stdin.readline().split()))
def Hash(): return dict()
def Mod(): return 1000000007
def Mat2x2(n): return [List() for _ in range(n)]
def Lcm(x,y): return (x*y)//gcd(x,y)
def dtob(n): return bin(n).replace("0b","")
def btod(n): return int(n,2)
def watch(x): return print(x)
def common(l1, l2): return set(l1).intersection(l2)
def Most_frequent(list): return max(set(list), key = list.count)
def solution():
for _ in range(Int()):
n,k=Mint()
a=[]
for i in range(1,k+1):
a.append(i)
x=k-1
for i in range(k+1,n+1):
a.append(x)
x-=1
b=Counter(a)
ans=[]
for i in range(n):
if(b[a[i]]==2):
b[a[i]]=1
else:
ans.append(a[i])
print(*ans)
if __name__ == "__main__":
solution()
```
| 108,074 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a sequence a with n elements 1, 2, 3, ..., k - 1, k, k - 1, k - 2, ..., k - (n - k) (k ≤ n < 2k).
Let's call as inversion in a a pair of indices i < j such that a[i] > a[j].
Suppose, you have some permutation p of size k and you build a sequence b of size n in the following manner: b[i] = p[a[i]].
Your goal is to find such permutation p that the total number of inversions in b doesn't exceed the total number of inversions in a, and b is lexicographically maximum.
Small reminder: the sequence of k integers is called a permutation if it contains all integers from 1 to k exactly once.
Another small reminder: a sequence s is lexicographically smaller than another sequence t, if either s is a prefix of t, or for the first i such that s_i ≠ t_i, s_i < t_i holds (in the first position that these sequences are different, s has smaller number than t).
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers n and k (k ≤ n < 2k; 1 ≤ k ≤ 10^5) — the length of the sequence a and its maximum.
It's guaranteed that the total sum of k over test cases doesn't exceed 10^5.
Output
For each test case, print k integers — the permutation p which maximizes b lexicographically without increasing the total number of inversions.
It can be proven that p exists and is unique.
Example
Input
4
1 1
2 2
3 2
4 3
Output
1
1 2
2 1
1 3 2
Note
In the first test case, the sequence a = [1], there is only one permutation p = [1].
In the second test case, the sequence a = [1, 2]. There is no inversion in a, so there is only one permutation p = [1, 2] which doesn't increase the number of inversions.
In the third test case, a = [1, 2, 1] and has 1 inversion. If we use p = [2, 1], then b = [p[a[1]], p[a[2]], p[a[3]]] = [2, 1, 2] and also has 1 inversion.
In the fourth test case, a = [1, 2, 3, 2], and since p = [1, 3, 2] then b = [1, 3, 2, 3]. Both a and b have 1 inversion and b is the lexicographically maximum.
Tags: constructive algorithms, math
Correct Solution:
```
T = int(input())
for t in range(T):
n, k = tuple([int(x) for x in input().split()])
last_num = k - (n-k)
result = []
start_reverse = False
cur_num = 1
for i in range(1, k+1):
if i < last_num:
result.append(cur_num)
cur_num += 1
else:
if start_reverse == False:
start_reverse = True
cur_num = k
result.append(cur_num)
cur_num -= 1
print(" ".join([str(x) for x in result]))
```
| 108,075 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a sequence a with n elements 1, 2, 3, ..., k - 1, k, k - 1, k - 2, ..., k - (n - k) (k ≤ n < 2k).
Let's call as inversion in a a pair of indices i < j such that a[i] > a[j].
Suppose, you have some permutation p of size k and you build a sequence b of size n in the following manner: b[i] = p[a[i]].
Your goal is to find such permutation p that the total number of inversions in b doesn't exceed the total number of inversions in a, and b is lexicographically maximum.
Small reminder: the sequence of k integers is called a permutation if it contains all integers from 1 to k exactly once.
Another small reminder: a sequence s is lexicographically smaller than another sequence t, if either s is a prefix of t, or for the first i such that s_i ≠ t_i, s_i < t_i holds (in the first position that these sequences are different, s has smaller number than t).
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers n and k (k ≤ n < 2k; 1 ≤ k ≤ 10^5) — the length of the sequence a and its maximum.
It's guaranteed that the total sum of k over test cases doesn't exceed 10^5.
Output
For each test case, print k integers — the permutation p which maximizes b lexicographically without increasing the total number of inversions.
It can be proven that p exists and is unique.
Example
Input
4
1 1
2 2
3 2
4 3
Output
1
1 2
2 1
1 3 2
Note
In the first test case, the sequence a = [1], there is only one permutation p = [1].
In the second test case, the sequence a = [1, 2]. There is no inversion in a, so there is only one permutation p = [1, 2] which doesn't increase the number of inversions.
In the third test case, a = [1, 2, 1] and has 1 inversion. If we use p = [2, 1], then b = [p[a[1]], p[a[2]], p[a[3]]] = [2, 1, 2] and also has 1 inversion.
In the fourth test case, a = [1, 2, 3, 2], and since p = [1, 3, 2] then b = [1, 3, 2, 3]. Both a and b have 1 inversion and b is the lexicographically maximum.
Submitted Solution:
```
t=int(input())
for _ in range(t):
n,k=map(int,input().split())
a=[i for i in range(1,k+1)]
print(*(a[:-(n-k)-1]+a[-1:-(n-k)-2:-1]))
```
Yes
| 108,076 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a sequence a with n elements 1, 2, 3, ..., k - 1, k, k - 1, k - 2, ..., k - (n - k) (k ≤ n < 2k).
Let's call as inversion in a a pair of indices i < j such that a[i] > a[j].
Suppose, you have some permutation p of size k and you build a sequence b of size n in the following manner: b[i] = p[a[i]].
Your goal is to find such permutation p that the total number of inversions in b doesn't exceed the total number of inversions in a, and b is lexicographically maximum.
Small reminder: the sequence of k integers is called a permutation if it contains all integers from 1 to k exactly once.
Another small reminder: a sequence s is lexicographically smaller than another sequence t, if either s is a prefix of t, or for the first i such that s_i ≠ t_i, s_i < t_i holds (in the first position that these sequences are different, s has smaller number than t).
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers n and k (k ≤ n < 2k; 1 ≤ k ≤ 10^5) — the length of the sequence a and its maximum.
It's guaranteed that the total sum of k over test cases doesn't exceed 10^5.
Output
For each test case, print k integers — the permutation p which maximizes b lexicographically without increasing the total number of inversions.
It can be proven that p exists and is unique.
Example
Input
4
1 1
2 2
3 2
4 3
Output
1
1 2
2 1
1 3 2
Note
In the first test case, the sequence a = [1], there is only one permutation p = [1].
In the second test case, the sequence a = [1, 2]. There is no inversion in a, so there is only one permutation p = [1, 2] which doesn't increase the number of inversions.
In the third test case, a = [1, 2, 1] and has 1 inversion. If we use p = [2, 1], then b = [p[a[1]], p[a[2]], p[a[3]]] = [2, 1, 2] and also has 1 inversion.
In the fourth test case, a = [1, 2, 3, 2], and since p = [1, 3, 2] then b = [1, 3, 2, 3]. Both a and b have 1 inversion and b is the lexicographically maximum.
Submitted Solution:
```
for _ in range(int(input())):
n, k = map(int, input().split())
for i in range(1, 2*k-n):print(i, end=' ')
for i in range(k, 2*k-n-1, -1):print(i, end=' ')
print()
```
Yes
| 108,077 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a sequence a with n elements 1, 2, 3, ..., k - 1, k, k - 1, k - 2, ..., k - (n - k) (k ≤ n < 2k).
Let's call as inversion in a a pair of indices i < j such that a[i] > a[j].
Suppose, you have some permutation p of size k and you build a sequence b of size n in the following manner: b[i] = p[a[i]].
Your goal is to find such permutation p that the total number of inversions in b doesn't exceed the total number of inversions in a, and b is lexicographically maximum.
Small reminder: the sequence of k integers is called a permutation if it contains all integers from 1 to k exactly once.
Another small reminder: a sequence s is lexicographically smaller than another sequence t, if either s is a prefix of t, or for the first i such that s_i ≠ t_i, s_i < t_i holds (in the first position that these sequences are different, s has smaller number than t).
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers n and k (k ≤ n < 2k; 1 ≤ k ≤ 10^5) — the length of the sequence a and its maximum.
It's guaranteed that the total sum of k over test cases doesn't exceed 10^5.
Output
For each test case, print k integers — the permutation p which maximizes b lexicographically without increasing the total number of inversions.
It can be proven that p exists and is unique.
Example
Input
4
1 1
2 2
3 2
4 3
Output
1
1 2
2 1
1 3 2
Note
In the first test case, the sequence a = [1], there is only one permutation p = [1].
In the second test case, the sequence a = [1, 2]. There is no inversion in a, so there is only one permutation p = [1, 2] which doesn't increase the number of inversions.
In the third test case, a = [1, 2, 1] and has 1 inversion. If we use p = [2, 1], then b = [p[a[1]], p[a[2]], p[a[3]]] = [2, 1, 2] and also has 1 inversion.
In the fourth test case, a = [1, 2, 3, 2], and since p = [1, 3, 2] then b = [1, 3, 2, 3]. Both a and b have 1 inversion and b is the lexicographically maximum.
Submitted Solution:
```
'''
4
1 1
2 2
3 2
4 3
'''
n=int(input())
for i in range(0,n):
o=input().rstrip().split(' ')
N=int(o[0])
K=int(o[1])
if N==K:
for j in range(1,K+1):
print(j,end=' ')
print()
else:
T=K-(N-K);
H=K-T;
L=[0]*K;
for j in range(len(L)-1,-1,-1):
if H>0:
H-=1;
else:
L[j]=K;
G=j;
break;
E=1;
for j in range(0,G):
L[j]=E;
E+=1;
E=K-1;
for j in range(G+1,len(L)):
L[j]=E;
E-=1;
print(*L)
```
Yes
| 108,078 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a sequence a with n elements 1, 2, 3, ..., k - 1, k, k - 1, k - 2, ..., k - (n - k) (k ≤ n < 2k).
Let's call as inversion in a a pair of indices i < j such that a[i] > a[j].
Suppose, you have some permutation p of size k and you build a sequence b of size n in the following manner: b[i] = p[a[i]].
Your goal is to find such permutation p that the total number of inversions in b doesn't exceed the total number of inversions in a, and b is lexicographically maximum.
Small reminder: the sequence of k integers is called a permutation if it contains all integers from 1 to k exactly once.
Another small reminder: a sequence s is lexicographically smaller than another sequence t, if either s is a prefix of t, or for the first i such that s_i ≠ t_i, s_i < t_i holds (in the first position that these sequences are different, s has smaller number than t).
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers n and k (k ≤ n < 2k; 1 ≤ k ≤ 10^5) — the length of the sequence a and its maximum.
It's guaranteed that the total sum of k over test cases doesn't exceed 10^5.
Output
For each test case, print k integers — the permutation p which maximizes b lexicographically without increasing the total number of inversions.
It can be proven that p exists and is unique.
Example
Input
4
1 1
2 2
3 2
4 3
Output
1
1 2
2 1
1 3 2
Note
In the first test case, the sequence a = [1], there is only one permutation p = [1].
In the second test case, the sequence a = [1, 2]. There is no inversion in a, so there is only one permutation p = [1, 2] which doesn't increase the number of inversions.
In the third test case, a = [1, 2, 1] and has 1 inversion. If we use p = [2, 1], then b = [p[a[1]], p[a[2]], p[a[3]]] = [2, 1, 2] and also has 1 inversion.
In the fourth test case, a = [1, 2, 3, 2], and since p = [1, 3, 2] then b = [1, 3, 2, 3]. Both a and b have 1 inversion and b is the lexicographically maximum.
Submitted Solution:
```
from collections import Counter
import string
import math
import sys
# sys.setrecursionlimit(10**6)
from fractions import Fraction
def array_int():
return [int(i) for i in sys.stdin.readline().split()]
def vary(arrber_of_variables):
if arrber_of_variables==1:
return int(sys.stdin.readline())
if arrber_of_variables>=2:
return map(int,sys.stdin.readline().split())
def makedict(var):
return dict(Counter(var))
testcases=vary(1)
for _ in range(testcases):
n,k=vary(2)
num=[i for i in range(1,k+1)]
if n==k:
print(*num)
else:
l = [i for i in range(1,2*k-n)]
for i in range(n-k+1):
l.append(k-i)
print(*l)
```
Yes
| 108,079 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a sequence a with n elements 1, 2, 3, ..., k - 1, k, k - 1, k - 2, ..., k - (n - k) (k ≤ n < 2k).
Let's call as inversion in a a pair of indices i < j such that a[i] > a[j].
Suppose, you have some permutation p of size k and you build a sequence b of size n in the following manner: b[i] = p[a[i]].
Your goal is to find such permutation p that the total number of inversions in b doesn't exceed the total number of inversions in a, and b is lexicographically maximum.
Small reminder: the sequence of k integers is called a permutation if it contains all integers from 1 to k exactly once.
Another small reminder: a sequence s is lexicographically smaller than another sequence t, if either s is a prefix of t, or for the first i such that s_i ≠ t_i, s_i < t_i holds (in the first position that these sequences are different, s has smaller number than t).
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers n and k (k ≤ n < 2k; 1 ≤ k ≤ 10^5) — the length of the sequence a and its maximum.
It's guaranteed that the total sum of k over test cases doesn't exceed 10^5.
Output
For each test case, print k integers — the permutation p which maximizes b lexicographically without increasing the total number of inversions.
It can be proven that p exists and is unique.
Example
Input
4
1 1
2 2
3 2
4 3
Output
1
1 2
2 1
1 3 2
Note
In the first test case, the sequence a = [1], there is only one permutation p = [1].
In the second test case, the sequence a = [1, 2]. There is no inversion in a, so there is only one permutation p = [1, 2] which doesn't increase the number of inversions.
In the third test case, a = [1, 2, 1] and has 1 inversion. If we use p = [2, 1], then b = [p[a[1]], p[a[2]], p[a[3]]] = [2, 1, 2] and also has 1 inversion.
In the fourth test case, a = [1, 2, 3, 2], and since p = [1, 3, 2] then b = [1, 3, 2, 3]. Both a and b have 1 inversion and b is the lexicographically maximum.
Submitted Solution:
```
for _ in range(int(input())):
n,k=map(int,input().split())
if n==k:
for i in range(1,k+1):
print(i,end=' ')
print('')
else:
ar=[]
for i in range(1,k+1):
ar.append(i)
if k>=2:
ar[k-1],ar[k-2]=ar[k-2],ar[k-1]
for i in ar:
print(i,end=' ')
print('')
```
No
| 108,080 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a sequence a with n elements 1, 2, 3, ..., k - 1, k, k - 1, k - 2, ..., k - (n - k) (k ≤ n < 2k).
Let's call as inversion in a a pair of indices i < j such that a[i] > a[j].
Suppose, you have some permutation p of size k and you build a sequence b of size n in the following manner: b[i] = p[a[i]].
Your goal is to find such permutation p that the total number of inversions in b doesn't exceed the total number of inversions in a, and b is lexicographically maximum.
Small reminder: the sequence of k integers is called a permutation if it contains all integers from 1 to k exactly once.
Another small reminder: a sequence s is lexicographically smaller than another sequence t, if either s is a prefix of t, or for the first i such that s_i ≠ t_i, s_i < t_i holds (in the first position that these sequences are different, s has smaller number than t).
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers n and k (k ≤ n < 2k; 1 ≤ k ≤ 10^5) — the length of the sequence a and its maximum.
It's guaranteed that the total sum of k over test cases doesn't exceed 10^5.
Output
For each test case, print k integers — the permutation p which maximizes b lexicographically without increasing the total number of inversions.
It can be proven that p exists and is unique.
Example
Input
4
1 1
2 2
3 2
4 3
Output
1
1 2
2 1
1 3 2
Note
In the first test case, the sequence a = [1], there is only one permutation p = [1].
In the second test case, the sequence a = [1, 2]. There is no inversion in a, so there is only one permutation p = [1, 2] which doesn't increase the number of inversions.
In the third test case, a = [1, 2, 1] and has 1 inversion. If we use p = [2, 1], then b = [p[a[1]], p[a[2]], p[a[3]]] = [2, 1, 2] and also has 1 inversion.
In the fourth test case, a = [1, 2, 3, 2], and since p = [1, 3, 2] then b = [1, 3, 2, 3]. Both a and b have 1 inversion and b is the lexicographically maximum.
Submitted Solution:
```
from sys import stdin
stdin.readline
def mp(): return list(map(int, stdin.readline().strip().split()))
def it():return int(stdin.readline().strip())
for _ in range(it()):
n,k=mp()
t=n-k+1
l=[i for i in range(1,k+1)]
p=l[t-1:]
p.reverse()
w=l[:t-1]+p
print(*w)
```
No
| 108,081 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a sequence a with n elements 1, 2, 3, ..., k - 1, k, k - 1, k - 2, ..., k - (n - k) (k ≤ n < 2k).
Let's call as inversion in a a pair of indices i < j such that a[i] > a[j].
Suppose, you have some permutation p of size k and you build a sequence b of size n in the following manner: b[i] = p[a[i]].
Your goal is to find such permutation p that the total number of inversions in b doesn't exceed the total number of inversions in a, and b is lexicographically maximum.
Small reminder: the sequence of k integers is called a permutation if it contains all integers from 1 to k exactly once.
Another small reminder: a sequence s is lexicographically smaller than another sequence t, if either s is a prefix of t, or for the first i such that s_i ≠ t_i, s_i < t_i holds (in the first position that these sequences are different, s has smaller number than t).
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers n and k (k ≤ n < 2k; 1 ≤ k ≤ 10^5) — the length of the sequence a and its maximum.
It's guaranteed that the total sum of k over test cases doesn't exceed 10^5.
Output
For each test case, print k integers — the permutation p which maximizes b lexicographically without increasing the total number of inversions.
It can be proven that p exists and is unique.
Example
Input
4
1 1
2 2
3 2
4 3
Output
1
1 2
2 1
1 3 2
Note
In the first test case, the sequence a = [1], there is only one permutation p = [1].
In the second test case, the sequence a = [1, 2]. There is no inversion in a, so there is only one permutation p = [1, 2] which doesn't increase the number of inversions.
In the third test case, a = [1, 2, 1] and has 1 inversion. If we use p = [2, 1], then b = [p[a[1]], p[a[2]], p[a[3]]] = [2, 1, 2] and also has 1 inversion.
In the fourth test case, a = [1, 2, 3, 2], and since p = [1, 3, 2] then b = [1, 3, 2, 3]. Both a and b have 1 inversion and b is the lexicographically maximum.
Submitted Solution:
```
for _ in range(int(input())):
n,k=input().split()
n=int(n)
k=int(k)
l=[]
a=2*k-n
for i in range(k):
if(2*k-n>=i+1):
l.append(i+1)
else:
break
for i in range(n-k+1):
l.append(k-i)
print(*l)
```
No
| 108,082 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a sequence a with n elements 1, 2, 3, ..., k - 1, k, k - 1, k - 2, ..., k - (n - k) (k ≤ n < 2k).
Let's call as inversion in a a pair of indices i < j such that a[i] > a[j].
Suppose, you have some permutation p of size k and you build a sequence b of size n in the following manner: b[i] = p[a[i]].
Your goal is to find such permutation p that the total number of inversions in b doesn't exceed the total number of inversions in a, and b is lexicographically maximum.
Small reminder: the sequence of k integers is called a permutation if it contains all integers from 1 to k exactly once.
Another small reminder: a sequence s is lexicographically smaller than another sequence t, if either s is a prefix of t, or for the first i such that s_i ≠ t_i, s_i < t_i holds (in the first position that these sequences are different, s has smaller number than t).
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains two integers n and k (k ≤ n < 2k; 1 ≤ k ≤ 10^5) — the length of the sequence a and its maximum.
It's guaranteed that the total sum of k over test cases doesn't exceed 10^5.
Output
For each test case, print k integers — the permutation p which maximizes b lexicographically without increasing the total number of inversions.
It can be proven that p exists and is unique.
Example
Input
4
1 1
2 2
3 2
4 3
Output
1
1 2
2 1
1 3 2
Note
In the first test case, the sequence a = [1], there is only one permutation p = [1].
In the second test case, the sequence a = [1, 2]. There is no inversion in a, so there is only one permutation p = [1, 2] which doesn't increase the number of inversions.
In the third test case, a = [1, 2, 1] and has 1 inversion. If we use p = [2, 1], then b = [p[a[1]], p[a[2]], p[a[3]]] = [2, 1, 2] and also has 1 inversion.
In the fourth test case, a = [1, 2, 3, 2], and since p = [1, 3, 2] then b = [1, 3, 2, 3]. Both a and b have 1 inversion and b is the lexicographically maximum.
Submitted Solution:
```
# ------- main function -------
def solve():
n,k = map(int,input().split(' '))
inv = n-k
p = [i for i in range(1,k-inv)]
for i in range(k,k-inv-1,-1):
p.append(i)
print(p)
# ------- starting point of program -------
if __name__ == "__main__":
for _ in range(int(input())):
solve()
```
No
| 108,083 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two strings x and y, both consist only of lowercase Latin letters. Let |s| be the length of string s.
Let's call a sequence a a merging sequence if it consists of exactly |x| zeros and exactly |y| ones in some order.
A merge z is produced from a sequence a by the following rules:
* if a_i=0, then remove a letter from the beginning of x and append it to the end of z;
* if a_i=1, then remove a letter from the beginning of y and append it to the end of z.
Two merging sequences a and b are different if there is some position i such that a_i ≠ b_i.
Let's call a string z chaotic if for all i from 2 to |z| z_{i-1} ≠ z_i.
Let s[l,r] for some 1 ≤ l ≤ r ≤ |s| be a substring of consecutive letters of s, starting from position l and ending at position r inclusive.
Let f(l_1, r_1, l_2, r_2) be the number of different merging sequences of x[l_1,r_1] and y[l_2,r_2] that produce chaotic merges. Note that only non-empty substrings of x and y are considered.
Calculate ∑ _{1 ≤ l_1 ≤ r_1 ≤ |x| \\\ 1 ≤ l_2 ≤ r_2 ≤ |y|} f(l_1, r_1, l_2, r_2). Output the answer modulo 998 244 353.
Input
The first line contains a string x (1 ≤ |x| ≤ 1000).
The second line contains a string y (1 ≤ |y| ≤ 1000).
Both strings consist only of lowercase Latin letters.
Output
Print a single integer — the sum of f(l_1, r_1, l_2, r_2) over 1 ≤ l_1 ≤ r_1 ≤ |x| and 1 ≤ l_2 ≤ r_2 ≤ |y| modulo 998 244 353.
Examples
Input
aaa
bb
Output
24
Input
code
forces
Output
1574
Input
aaaaa
aaa
Output
0
Input
justamassivetesttocheck
howwellyouhandlemodulooperations
Output
667387032
Note
In the first example there are:
* 6 pairs of substrings "a" and "b", each with valid merging sequences "01" and "10";
* 3 pairs of substrings "a" and "bb", each with a valid merging sequence "101";
* 4 pairs of substrings "aa" and "b", each with a valid merging sequence "010";
* 2 pairs of substrings "aa" and "bb", each with valid merging sequences "0101" and "1010";
* 2 pairs of substrings "aaa" and "b", each with no valid merging sequences;
* 1 pair of substrings "aaa" and "bb" with a valid merging sequence "01010";
Thus, the answer is 6 ⋅ 2 + 3 ⋅ 1 + 4 ⋅ 1 + 2 ⋅ 2 + 2 ⋅ 0 + 1 ⋅ 1 = 24.
Tags: combinatorics, dp, math, strings
Correct Solution:
```
import sys
input=sys.stdin.buffer.readline
S=list(input())
T=list(input())
N=len(S)-2
M=len(T)-2
S.append(20)
mod=998244353
DP=[[[0]*8 for j in range(M+2)] for i in range(N+2)]
for i in range(N):
for j in range(M):
DP[i][j][0]=1
for i in range(N+1):
for j in range(M+1):
for k in range(8):
if k&4:
if S[i-1]!=S[i]:
DP[i+1][j][k|1]+=DP[i][j][k]
if DP[i+1][j][k|1]>=mod:
DP[i+1][j][k|1]-=mod
if S[i-1]!=T[j]:
DP[i][j+1][(k|2)^4]+=DP[i][j][k]
if DP[i][j+1][(k|2)^4]>=mod:
DP[i][j+1][(k|2)^4]-=mod
else:
if T[j-1]!=S[i] or k==0:
DP[i+1][j][(k|1)^4]+=DP[i][j][k]
if DP[i+1][j][(k|1)^4]>=mod:
DP[i+1][j][(k|1)^4]-=mod
if T[j-1]!=T[j] or k==0:
DP[i][j+1][k|2]+=DP[i][j][k]
if DP[i][j+1][k|2]>=mod:
DP[i][j+1][k|2]-=mod
ANS=0
for i in range(N+1):
for j in range(M+1):
ANS+=DP[i][j][3]+DP[i][j][7]
print(ANS%mod)
```
| 108,084 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two strings x and y, both consist only of lowercase Latin letters. Let |s| be the length of string s.
Let's call a sequence a a merging sequence if it consists of exactly |x| zeros and exactly |y| ones in some order.
A merge z is produced from a sequence a by the following rules:
* if a_i=0, then remove a letter from the beginning of x and append it to the end of z;
* if a_i=1, then remove a letter from the beginning of y and append it to the end of z.
Two merging sequences a and b are different if there is some position i such that a_i ≠ b_i.
Let's call a string z chaotic if for all i from 2 to |z| z_{i-1} ≠ z_i.
Let s[l,r] for some 1 ≤ l ≤ r ≤ |s| be a substring of consecutive letters of s, starting from position l and ending at position r inclusive.
Let f(l_1, r_1, l_2, r_2) be the number of different merging sequences of x[l_1,r_1] and y[l_2,r_2] that produce chaotic merges. Note that only non-empty substrings of x and y are considered.
Calculate ∑ _{1 ≤ l_1 ≤ r_1 ≤ |x| \\\ 1 ≤ l_2 ≤ r_2 ≤ |y|} f(l_1, r_1, l_2, r_2). Output the answer modulo 998 244 353.
Input
The first line contains a string x (1 ≤ |x| ≤ 1000).
The second line contains a string y (1 ≤ |y| ≤ 1000).
Both strings consist only of lowercase Latin letters.
Output
Print a single integer — the sum of f(l_1, r_1, l_2, r_2) over 1 ≤ l_1 ≤ r_1 ≤ |x| and 1 ≤ l_2 ≤ r_2 ≤ |y| modulo 998 244 353.
Examples
Input
aaa
bb
Output
24
Input
code
forces
Output
1574
Input
aaaaa
aaa
Output
0
Input
justamassivetesttocheck
howwellyouhandlemodulooperations
Output
667387032
Note
In the first example there are:
* 6 pairs of substrings "a" and "b", each with valid merging sequences "01" and "10";
* 3 pairs of substrings "a" and "bb", each with a valid merging sequence "101";
* 4 pairs of substrings "aa" and "b", each with a valid merging sequence "010";
* 2 pairs of substrings "aa" and "bb", each with valid merging sequences "0101" and "1010";
* 2 pairs of substrings "aaa" and "b", each with no valid merging sequences;
* 1 pair of substrings "aaa" and "bb" with a valid merging sequence "01010";
Thus, the answer is 6 ⋅ 2 + 3 ⋅ 1 + 4 ⋅ 1 + 2 ⋅ 2 + 2 ⋅ 0 + 1 ⋅ 1 = 24.
Tags: combinatorics, dp, math, strings
Correct Solution:
```
import sys
input = sys.stdin.readline
mod = 998244353
tot = 0
x = ' ' + input().strip()
y = ' ' + input().strip()
s = [x,y]
dp = [[[[0]*4 for j in range(2)] for k in range(len(y))] for i in range(len(x))]
for i in range(1,len(x)):
for j in range(1,len(y)):
dp[i][j-1][0][2] = 1
dp[i-1][j][1][1] = 1
for i in range(len(x)):
for j in range(len(y)):
s_idx = [i,j]
tot = (tot + dp[i][j][0][3] + dp[i][j][1][3]) % mod
for c in range(2):
for nex in range(2):
for ney in range(2):
if i < len(x)-1 and s[c][s_idx[c]] != x[i+1]:
dp[i+1][j][0][2+ney] = (dp[i+1][j][0][2+ney] + dp[i][j][c][2*nex+ney]) % mod
if j < len(y)-1 and s[c][s_idx[c]] != y[j+1]:
dp[i][j+1][1][2*nex+1] = (dp[i][j+1][1][2*nex+1] + dp[i][j][c][2*nex+ney]) % mod
print(tot)
```
| 108,085 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two strings x and y, both consist only of lowercase Latin letters. Let |s| be the length of string s.
Let's call a sequence a a merging sequence if it consists of exactly |x| zeros and exactly |y| ones in some order.
A merge z is produced from a sequence a by the following rules:
* if a_i=0, then remove a letter from the beginning of x and append it to the end of z;
* if a_i=1, then remove a letter from the beginning of y and append it to the end of z.
Two merging sequences a and b are different if there is some position i such that a_i ≠ b_i.
Let's call a string z chaotic if for all i from 2 to |z| z_{i-1} ≠ z_i.
Let s[l,r] for some 1 ≤ l ≤ r ≤ |s| be a substring of consecutive letters of s, starting from position l and ending at position r inclusive.
Let f(l_1, r_1, l_2, r_2) be the number of different merging sequences of x[l_1,r_1] and y[l_2,r_2] that produce chaotic merges. Note that only non-empty substrings of x and y are considered.
Calculate ∑ _{1 ≤ l_1 ≤ r_1 ≤ |x| \\\ 1 ≤ l_2 ≤ r_2 ≤ |y|} f(l_1, r_1, l_2, r_2). Output the answer modulo 998 244 353.
Input
The first line contains a string x (1 ≤ |x| ≤ 1000).
The second line contains a string y (1 ≤ |y| ≤ 1000).
Both strings consist only of lowercase Latin letters.
Output
Print a single integer — the sum of f(l_1, r_1, l_2, r_2) over 1 ≤ l_1 ≤ r_1 ≤ |x| and 1 ≤ l_2 ≤ r_2 ≤ |y| modulo 998 244 353.
Examples
Input
aaa
bb
Output
24
Input
code
forces
Output
1574
Input
aaaaa
aaa
Output
0
Input
justamassivetesttocheck
howwellyouhandlemodulooperations
Output
667387032
Note
In the first example there are:
* 6 pairs of substrings "a" and "b", each with valid merging sequences "01" and "10";
* 3 pairs of substrings "a" and "bb", each with a valid merging sequence "101";
* 4 pairs of substrings "aa" and "b", each with a valid merging sequence "010";
* 2 pairs of substrings "aa" and "bb", each with valid merging sequences "0101" and "1010";
* 2 pairs of substrings "aaa" and "b", each with no valid merging sequences;
* 1 pair of substrings "aaa" and "bb" with a valid merging sequence "01010";
Thus, the answer is 6 ⋅ 2 + 3 ⋅ 1 + 4 ⋅ 1 + 2 ⋅ 2 + 2 ⋅ 0 + 1 ⋅ 1 = 24.
Tags: combinatorics, dp, math, strings
Correct Solution:
```
import sys
from sys import stdin
x = stdin.readline()[:-1]
xl = len(x)
y = stdin.readline()[:-1]
yl = len(y)
x += "?"
y += "!"
mod = 998244353
dp = [[[0,0] for i in range(yl+1)] for j in range(xl+1)]
dp[-1][-1] = [1,0]
for a in range(-1,xl):
for b in range(-1,yl):
if a == b == -1:
for na in range(xl):
dp[na][-1][0] += 1
for nb in range(yl):
dp[-1][nb][1] += 1
elif a == -1: #put a
for na in range(xl):
if y[b] != x[na]:
dp[na][b][0] += dp[a][b][1]
dp[na][b][0] %= mod
elif b == -1: #put b
for nb in range(yl):
if y[nb] != x[a]:
dp[a][nb][1] += dp[a][b][0]
dp[a][nb][1] %= mod
for f in range(2):
if a != -1: #put after a
if f == 0:
if a+1<xl and x[a+1] != x[a]:
dp[a+1][b][0] += dp[a][b][f]
dp[a+1][b][0] %= mod
else:
if a+1<xl and x[a+1] != y[b]:
dp[a+1][b][0] += dp[a][b][f]
dp[a+1][b][0] %= mod
if b != -1: #put b
if f == 0:
if b+1<yl and y[b+1] != x[a]:
dp[a][b+1][1] += dp[a][b][f]
dp[a][b+1][1] %= mod
else:
if b+1<yl and y[b+1] != y[b]:
dp[a][b+1][1] += dp[a][b][f]
dp[a][b+1][1] %= mod
#print (dp)
ans = 0
for i in range(xl):
for j in range(yl):
ans += sum(dp[i][j])
print (ans % mod)
```
| 108,086 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two strings x and y, both consist only of lowercase Latin letters. Let |s| be the length of string s.
Let's call a sequence a a merging sequence if it consists of exactly |x| zeros and exactly |y| ones in some order.
A merge z is produced from a sequence a by the following rules:
* if a_i=0, then remove a letter from the beginning of x and append it to the end of z;
* if a_i=1, then remove a letter from the beginning of y and append it to the end of z.
Two merging sequences a and b are different if there is some position i such that a_i ≠ b_i.
Let's call a string z chaotic if for all i from 2 to |z| z_{i-1} ≠ z_i.
Let s[l,r] for some 1 ≤ l ≤ r ≤ |s| be a substring of consecutive letters of s, starting from position l and ending at position r inclusive.
Let f(l_1, r_1, l_2, r_2) be the number of different merging sequences of x[l_1,r_1] and y[l_2,r_2] that produce chaotic merges. Note that only non-empty substrings of x and y are considered.
Calculate ∑ _{1 ≤ l_1 ≤ r_1 ≤ |x| \\\ 1 ≤ l_2 ≤ r_2 ≤ |y|} f(l_1, r_1, l_2, r_2). Output the answer modulo 998 244 353.
Input
The first line contains a string x (1 ≤ |x| ≤ 1000).
The second line contains a string y (1 ≤ |y| ≤ 1000).
Both strings consist only of lowercase Latin letters.
Output
Print a single integer — the sum of f(l_1, r_1, l_2, r_2) over 1 ≤ l_1 ≤ r_1 ≤ |x| and 1 ≤ l_2 ≤ r_2 ≤ |y| modulo 998 244 353.
Examples
Input
aaa
bb
Output
24
Input
code
forces
Output
1574
Input
aaaaa
aaa
Output
0
Input
justamassivetesttocheck
howwellyouhandlemodulooperations
Output
667387032
Note
In the first example there are:
* 6 pairs of substrings "a" and "b", each with valid merging sequences "01" and "10";
* 3 pairs of substrings "a" and "bb", each with a valid merging sequence "101";
* 4 pairs of substrings "aa" and "b", each with a valid merging sequence "010";
* 2 pairs of substrings "aa" and "bb", each with valid merging sequences "0101" and "1010";
* 2 pairs of substrings "aaa" and "b", each with no valid merging sequences;
* 1 pair of substrings "aaa" and "bb" with a valid merging sequence "01010";
Thus, the answer is 6 ⋅ 2 + 3 ⋅ 1 + 4 ⋅ 1 + 2 ⋅ 2 + 2 ⋅ 0 + 1 ⋅ 1 = 24.
Tags: combinatorics, dp, math, strings
Correct Solution:
```
import sys;input=sys.stdin.buffer.readline;S=list(input());T=list(input());N=len(S)-2;M=len(T)-2;S.append(20);mod=998244353;DP=[[[0]*8 for j in range(M+2)] for i in range(N+2)]
for i in range(N):
for j in range(M): DP[i][j][0]=1
for i in range(N+1):
for j in range(M+1):
for k in range(8):
if k&4:
if S[i-1]!=S[i]:
DP[i+1][j][k|1]+=DP[i][j][k]
if DP[i+1][j][k|1]>=mod: DP[i+1][j][k|1]-=mod
if S[i-1]!=T[j]:
DP[i][j+1][(k|2)^4]+=DP[i][j][k]
if DP[i][j+1][(k|2)^4]>=mod: DP[i][j+1][(k|2)^4]-=mod
else:
if T[j-1]!=S[i] or k==0:
DP[i+1][j][(k|1)^4]+=DP[i][j][k]
if DP[i+1][j][(k|1)^4]>=mod: DP[i+1][j][(k|1)^4]-=mod
if T[j-1]!=T[j] or k==0:
DP[i][j+1][k|2]+=DP[i][j][k]
if DP[i][j+1][k|2]>=mod: DP[i][j+1][k|2]-=mod
print(sum([DP[i][j][3]+DP[i][j][7] for i in range(N+1) for j in range(M+1)])%mod)
```
| 108,087 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two strings x and y, both consist only of lowercase Latin letters. Let |s| be the length of string s.
Let's call a sequence a a merging sequence if it consists of exactly |x| zeros and exactly |y| ones in some order.
A merge z is produced from a sequence a by the following rules:
* if a_i=0, then remove a letter from the beginning of x and append it to the end of z;
* if a_i=1, then remove a letter from the beginning of y and append it to the end of z.
Two merging sequences a and b are different if there is some position i such that a_i ≠ b_i.
Let's call a string z chaotic if for all i from 2 to |z| z_{i-1} ≠ z_i.
Let s[l,r] for some 1 ≤ l ≤ r ≤ |s| be a substring of consecutive letters of s, starting from position l and ending at position r inclusive.
Let f(l_1, r_1, l_2, r_2) be the number of different merging sequences of x[l_1,r_1] and y[l_2,r_2] that produce chaotic merges. Note that only non-empty substrings of x and y are considered.
Calculate ∑ _{1 ≤ l_1 ≤ r_1 ≤ |x| \\\ 1 ≤ l_2 ≤ r_2 ≤ |y|} f(l_1, r_1, l_2, r_2). Output the answer modulo 998 244 353.
Input
The first line contains a string x (1 ≤ |x| ≤ 1000).
The second line contains a string y (1 ≤ |y| ≤ 1000).
Both strings consist only of lowercase Latin letters.
Output
Print a single integer — the sum of f(l_1, r_1, l_2, r_2) over 1 ≤ l_1 ≤ r_1 ≤ |x| and 1 ≤ l_2 ≤ r_2 ≤ |y| modulo 998 244 353.
Examples
Input
aaa
bb
Output
24
Input
code
forces
Output
1574
Input
aaaaa
aaa
Output
0
Input
justamassivetesttocheck
howwellyouhandlemodulooperations
Output
667387032
Note
In the first example there are:
* 6 pairs of substrings "a" and "b", each with valid merging sequences "01" and "10";
* 3 pairs of substrings "a" and "bb", each with a valid merging sequence "101";
* 4 pairs of substrings "aa" and "b", each with a valid merging sequence "010";
* 2 pairs of substrings "aa" and "bb", each with valid merging sequences "0101" and "1010";
* 2 pairs of substrings "aaa" and "b", each with no valid merging sequences;
* 1 pair of substrings "aaa" and "bb" with a valid merging sequence "01010";
Thus, the answer is 6 ⋅ 2 + 3 ⋅ 1 + 4 ⋅ 1 + 2 ⋅ 2 + 2 ⋅ 0 + 1 ⋅ 1 = 24.
Tags: combinatorics, dp, math, strings
Correct Solution:
```
def popcount(x):
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007f
def eratosthenes(n):
res=[0 for i in range(n+1)]
prime=set([])
for i in range(2,n+1):
if not res[i]:
prime.add(i)
for j in range(1,n//i+1):
res[i*j]=1
return prime
def factorization(n):
res=[]
for p in prime:
if n%p==0:
while n%p==0:
n//=p
res.append(p)
if n!=1:
res.append(n)
return res
def euler_phi(n):
res = n
for x in range(2,n+1):
if x ** 2 > n:
break
if n%x==0:
res = res//x * (x-1)
while n%x==0:
n //= x
if n!=1:
res = res//n * (n-1)
return res
def ind(b,n):
res=0
while n%b==0:
res+=1
n//=b
return res
def isPrimeMR(n):
d = n - 1
d = d // (d & -d)
L = [2, 3, 5, 7, 11, 13, 17]
for a in L:
t = d
y = pow(a, t, n)
if y == 1: continue
while y != n - 1:
y = (y * y) % n
if y == 1 or t == n - 1: return 0
t <<= 1
return 1
def findFactorRho(n):
from math import gcd
m = 1 << n.bit_length() // 8
for c in range(1, 99):
f = lambda x: (x * x + c) % n
y, r, q, g = 2, 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = f(y)
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = f(y)
q = q * abs(x - y) % n
g = gcd(q, n)
k += m
r <<= 1
if g == n:
g = 1
while g == 1:
ys = f(ys)
g = gcd(abs(x - ys), n)
if g < n:
if isPrimeMR(g): return g
elif isPrimeMR(n // g): return n // g
return findFactorRho(g)
def primeFactor(n):
i = 2
ret = {}
rhoFlg = 0
while i*i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k: ret[i] = k
i += 1 + i % 2
if i == 101 and n >= 2 ** 20:
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
rhoFlg = 1
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1: ret[n] = 1
if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
return ret
def divisors(n):
res = [1]
prime = primeFactor(n)
for p in prime:
newres = []
for d in res:
for j in range(prime[p]+1):
newres.append(d*p**j)
res = newres
res.sort()
return res
def xorfactorial(num):#排他的論理和の階乗
if num==0:
return 0
elif num==1:
return 1
elif num==2:
return 3
elif num==3:
return 0
else:
x=baseorder(num)
return (2**x)*((num-2**x+1)%2)+function(num-2**x)
def xorconv(n,X,Y):
if n==0:
res=[(X[0]*Y[0])%mod]
return res
x=[X[i]+X[i+2**(n-1)] for i in range(2**(n-1))]
y=[Y[i]+Y[i+2**(n-1)] for i in range(2**(n-1))]
z=[X[i]-X[i+2**(n-1)] for i in range(2**(n-1))]
w=[Y[i]-Y[i+2**(n-1)] for i in range(2**(n-1))]
res1=xorconv(n-1,x,y)
res2=xorconv(n-1,z,w)
former=[(res1[i]+res2[i])*inv for i in range(2**(n-1))]
latter=[(res1[i]-res2[i])*inv for i in range(2**(n-1))]
former=list(map(lambda x:x%mod,former))
latter=list(map(lambda x:x%mod,latter))
return former+latter
def merge_sort(A,B):
pos_A,pos_B = 0,0
n,m = len(A),len(B)
res = []
while pos_A < n and pos_B < m:
a,b = A[pos_A],B[pos_B]
if a < b:
res.append(a)
pos_A += 1
else:
res.append(b)
pos_B += 1
res += A[pos_A:]
res += B[pos_B:]
return res
class UnionFindVerSize():
def __init__(self, N):
self._parent = [n for n in range(0, N)]
self._size = [1] * N
self.group = N
def find_root(self, x):
if self._parent[x] == x: return x
self._parent[x] = self.find_root(self._parent[x])
stack = [x]
while self._parent[stack[-1]]!=stack[-1]:
stack.append(self._parent[stack[-1]])
for v in stack:
self._parent[v] = stack[-1]
return self._parent[x]
def unite(self, x, y):
gx = self.find_root(x)
gy = self.find_root(y)
if gx == gy: return
self.group -= 1
if self._size[gx] < self._size[gy]:
self._parent[gx] = gy
self._size[gy] += self._size[gx]
else:
self._parent[gy] = gx
self._size[gx] += self._size[gy]
def get_size(self, x):
return self._size[self.find_root(x)]
def is_same_group(self, x, y):
return self.find_root(x) == self.find_root(y)
class WeightedUnionFind():
def __init__(self,N):
self.parent = [i for i in range(N)]
self.size = [1 for i in range(N)]
self.val = [0 for i in range(N)]
self.flag = True
self.edge = [[] for i in range(N)]
def dfs(self,v,pv):
stack = [(v,pv)]
new_parent = self.parent[pv]
while stack:
v,pv = stack.pop()
self.parent[v] = new_parent
for nv,w in self.edge[v]:
if nv!=pv:
self.val[nv] = self.val[v] + w
stack.append((nv,v))
def unite(self,x,y,w):
if not self.flag:
return
if self.parent[x]==self.parent[y]:
self.flag = (self.val[x] - self.val[y] == w)
return
if self.size[self.parent[x]]>self.size[self.parent[y]]:
self.edge[x].append((y,-w))
self.edge[y].append((x,w))
self.size[x] += self.size[y]
self.val[y] = self.val[x] - w
self.dfs(y,x)
else:
self.edge[x].append((y,-w))
self.edge[y].append((x,w))
self.size[y] += self.size[x]
self.val[x] = self.val[y] + w
self.dfs(x,y)
class Dijkstra():
class Edge():
def __init__(self, _to, _cost):
self.to = _to
self.cost = _cost
def __init__(self, V):
self.G = [[] for i in range(V)]
self._E = 0
self._V = V
@property
def E(self):
return self._E
@property
def V(self):
return self._V
def add_edge(self, _from, _to, _cost):
self.G[_from].append(self.Edge(_to, _cost))
self._E += 1
def shortest_path(self, s):
import heapq
que = []
d = [10**15] * self.V
d[s] = 0
heapq.heappush(que, (0, s))
while len(que) != 0:
cost, v = heapq.heappop(que)
if d[v] < cost: continue
for i in range(len(self.G[v])):
e = self.G[v][i]
if d[e.to] > d[v] + e.cost:
d[e.to] = d[v] + e.cost
heapq.heappush(que, (d[e.to], e.to))
return d
#Z[i]:length of the longest list starting from S[i] which is also a prefix of S
#O(|S|)
def Z_algorithm(s):
N = len(s)
Z_alg = [0]*N
Z_alg[0] = N
i = 1
j = 0
while i < N:
while i+j < N and s[j] == s[i+j]:
j += 1
Z_alg[i] = j
if j == 0:
i += 1
continue
k = 1
while i+k < N and k + Z_alg[k]<j:
Z_alg[i+k] = Z_alg[k]
k += 1
i += k
j -= k
return Z_alg
class BIT():
def __init__(self,n):
self.BIT=[0]*(n+1)
self.num=n
def query(self,idx):
res_sum = 0
while idx > 0:
res_sum += self.BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def update(self,idx,x):
while idx <= self.num:
self.BIT[idx] += x
idx += idx&(-idx)
return
class dancinglink():
def __init__(self,n,debug=False):
self.n = n
self.debug = debug
self._left = [i-1 for i in range(n)]
self._right = [i+1 for i in range(n)]
self.exist = [True for i in range(n)]
def pop(self,k):
if self.debug:
assert self.exist[k]
L = self._left[k]
R = self._right[k]
if L!=-1:
if R!=self.n:
self._right[L],self._left[R] = R,L
else:
self._right[L] = self.n
elif R!=self.n:
self._left[R] = -1
self.exist[k] = False
def left(self,idx,k=1):
if self.debug:
assert self.exist[idx]
res = idx
while k:
res = self._left[res]
if res==-1:
break
k -= 1
return res
def right(self,idx,k=1):
if self.debug:
assert self.exist[idx]
res = idx
while k:
res = self._right[res]
if res==self.n:
break
k -= 1
return res
class SparseTable():
def __init__(self,A,merge_func,ide_ele):
N=len(A)
n=N.bit_length()
self.table=[[ide_ele for i in range(n)] for i in range(N)]
self.merge_func=merge_func
for i in range(N):
self.table[i][0]=A[i]
for j in range(1,n):
for i in range(0,N-2**j+1):
f=self.table[i][j-1]
s=self.table[i+2**(j-1)][j-1]
self.table[i][j]=self.merge_func(f,s)
def query(self,s,t):
b=t-s+1
m=b.bit_length()-1
return self.merge_func(self.table[s][m],self.table[t-2**m+1][m])
class BinaryTrie:
class node:
def __init__(self,val):
self.left = None
self.right = None
self.max = val
def __init__(self):
self.root = self.node(-10**15)
def append(self,key,val):
pos = self.root
for i in range(29,-1,-1):
pos.max = max(pos.max,val)
if key>>i & 1:
if pos.right is None:
pos.right = self.node(val)
pos = pos.right
else:
pos = pos.right
else:
if pos.left is None:
pos.left = self.node(val)
pos = pos.left
else:
pos = pos.left
pos.max = max(pos.max,val)
def search(self,M,xor):
res = -10**15
pos = self.root
for i in range(29,-1,-1):
if pos is None:
break
if M>>i & 1:
if xor>>i & 1:
if pos.right:
res = max(res,pos.right.max)
pos = pos.left
else:
if pos.left:
res = max(res,pos.left.max)
pos = pos.right
else:
if xor>>i & 1:
pos = pos.right
else:
pos = pos.left
if pos:
res = max(res,pos.max)
return res
def solveequation(edge,ans,n,m):
#edge=[[to,dire,id]...]
x=[0]*m
used=[False]*n
for v in range(n):
if used[v]:
continue
y = dfs(v)
if y!=0:
return False
return x
def dfs(v):
used[v]=True
r=ans[v]
for to,dire,id in edge[v]:
if used[to]:
continue
y=dfs(to)
if dire==-1:
x[id]=y
else:
x[id]=-y
r+=y
return r
class Matrix():
mod=10**9+7
def set_mod(m):
Matrix.mod=m
def __init__(self,L):
self.row=len(L)
self.column=len(L[0])
self._matrix=L
for i in range(self.row):
for j in range(self.column):
self._matrix[i][j]%=Matrix.mod
def __getitem__(self,item):
if type(item)==int:
raise IndexError("you must specific row and column")
elif len(item)!=2:
raise IndexError("you must specific row and column")
i,j=item
return self._matrix[i][j]
def __setitem__(self,item,val):
if type(item)==int:
raise IndexError("you must specific row and column")
elif len(item)!=2:
raise IndexError("you must specific row and column")
i,j=item
self._matrix[i][j]=val
def __add__(self,other):
if (self.row,self.column)!=(other.row,other.column):
raise SizeError("sizes of matrixes are different")
res=[[0 for j in range(self.column)] for i in range(self.row)]
for i in range(self.row):
for j in range(self.column):
res[i][j]=self._matrix[i][j]+other._matrix[i][j]
res[i][j]%=Matrix.mod
return Matrix(res)
def __sub__(self,other):
if (self.row,self.column)!=(other.row,other.column):
raise SizeError("sizes of matrixes are different")
res=[[0 for j in range(self.column)] for i in range(self.row)]
for i in range(self.row):
for j in range(self.column):
res[i][j]=self._matrix[i][j]-other._matrix[i][j]
res[i][j]%=Matrix.mod
return Matrix(res)
def __mul__(self,other):
if type(other)!=int:
if self.column!=other.row:
raise SizeError("sizes of matrixes are different")
res=[[0 for j in range(other.column)] for i in range(self.row)]
for i in range(self.row):
for j in range(other.column):
temp=0
for k in range(self.column):
temp+=self._matrix[i][k]*other._matrix[k][j]
res[i][j]=temp%Matrix.mod
return Matrix(res)
else:
n=other
res=[[(n*self._matrix[i][j])%Matrix.mod for j in range(self.column)] for i in range(self.row)]
return Matrix(res)
def __pow__(self,m):
if self.column!=self.row:
raise MatrixPowError("the size of row must be the same as that of column")
n=self.row
res=Matrix([[int(i==j) for i in range(n)] for j in range(n)])
while m:
if m%2==1:
res=res*self
self=self*self
m//=2
return res
def __str__(self):
res=[]
for i in range(self.row):
for j in range(self.column):
res.append(str(self._matrix[i][j]))
res.append(" ")
res.append("\n")
res=res[:len(res)-1]
return "".join(res)
class SegmentTree:
def __init__(self, init_val, segfunc, ide_ele):
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
for i in range(n):
self.tree[self.num + i] = init_val[i]
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
def bisect_l(self,l,r,x):
l += self.num
r += self.num
Lmin = -1
Rmin = -1
while l<r:
if l & 1:
if self.tree[l] <= x and Lmin==-1:
Lmin = l
l += 1
if r & 1:
if self.tree[r-1] <=x:
Rmin = r-1
l >>= 1
r >>= 1
if Lmin != -1:
pos = Lmin
while pos<self.num:
if self.tree[2 * pos] <=x:
pos = 2 * pos
else:
pos = 2 * pos +1
return pos-self.num
elif Rmin != -1:
pos = Rmin
while pos<self.num:
if self.tree[2 * pos] <=x:
pos = 2 * pos
else:
pos = 2 * pos +1
return pos-self.num
else:
return -1
import sys,random,bisect
from collections import deque,defaultdict
from heapq import heapify,heappop,heappush
from itertools import permutations
from math import log,gcd
input = lambda :sys.stdin.readline().rstrip()
mi = lambda :map(int,input().split())
li = lambda :list(mi())
mod = 998244353
x = input()
n = len(x)
y = input()
m = len(y)
dp_x = [[1 for j in range(m+1)] for i in range(n+1)]
dp_y = [[1 for j in range(m+1)] for i in range(n+1)]
dp_x[n][m] = 1
dp_y[n][m] = 1
res = 0
for i in range(n,-1,-1):
for j in range(m,-1,-1):
if i!=n:
res += dp_x[i+1][j]
res %= mod
if j!=m:
res += dp_y[i][j+1]
res %= mod
if i!=0:
if i!=n and x[i-1]!=x[i]:
dp_x[i][j] += dp_x[i+1][j]
dp_x[i][j] %= mod
if j!=m and x[i-1]!=y[j]:
dp_x[i][j] += dp_y[i][j+1]
dp_x[i][j] %= mod
if j!=0:
if i!=n and y[j-1]!=x[i]:
dp_y[i][j] += dp_x[i+1][j]
dp_y[i][j] %= mod
if j!=m and y[j-1]!=y[j]:
dp_y[i][j] += dp_y[i][j+1]
dp_y[i][j] %= mod
for i in range(n):
pre = ""
L = 0
for j in range(i,n):
if x[j]!=pre:
L += 1
pre = x[j]
else:
break
res -= L * (m+1)
res %= mod
for i in range(m):
pre = ""
L = 0
for j in range(i,m):
if y[j]!=pre:
L += 1
pre = y[j]
else:
break
res -= L * (n+1)
res %= mod
print(res)
```
| 108,088 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two strings x and y, both consist only of lowercase Latin letters. Let |s| be the length of string s.
Let's call a sequence a a merging sequence if it consists of exactly |x| zeros and exactly |y| ones in some order.
A merge z is produced from a sequence a by the following rules:
* if a_i=0, then remove a letter from the beginning of x and append it to the end of z;
* if a_i=1, then remove a letter from the beginning of y and append it to the end of z.
Two merging sequences a and b are different if there is some position i such that a_i ≠ b_i.
Let's call a string z chaotic if for all i from 2 to |z| z_{i-1} ≠ z_i.
Let s[l,r] for some 1 ≤ l ≤ r ≤ |s| be a substring of consecutive letters of s, starting from position l and ending at position r inclusive.
Let f(l_1, r_1, l_2, r_2) be the number of different merging sequences of x[l_1,r_1] and y[l_2,r_2] that produce chaotic merges. Note that only non-empty substrings of x and y are considered.
Calculate ∑ _{1 ≤ l_1 ≤ r_1 ≤ |x| \\\ 1 ≤ l_2 ≤ r_2 ≤ |y|} f(l_1, r_1, l_2, r_2). Output the answer modulo 998 244 353.
Input
The first line contains a string x (1 ≤ |x| ≤ 1000).
The second line contains a string y (1 ≤ |y| ≤ 1000).
Both strings consist only of lowercase Latin letters.
Output
Print a single integer — the sum of f(l_1, r_1, l_2, r_2) over 1 ≤ l_1 ≤ r_1 ≤ |x| and 1 ≤ l_2 ≤ r_2 ≤ |y| modulo 998 244 353.
Examples
Input
aaa
bb
Output
24
Input
code
forces
Output
1574
Input
aaaaa
aaa
Output
0
Input
justamassivetesttocheck
howwellyouhandlemodulooperations
Output
667387032
Note
In the first example there are:
* 6 pairs of substrings "a" and "b", each with valid merging sequences "01" and "10";
* 3 pairs of substrings "a" and "bb", each with a valid merging sequence "101";
* 4 pairs of substrings "aa" and "b", each with a valid merging sequence "010";
* 2 pairs of substrings "aa" and "bb", each with valid merging sequences "0101" and "1010";
* 2 pairs of substrings "aaa" and "b", each with no valid merging sequences;
* 1 pair of substrings "aaa" and "bb" with a valid merging sequence "01010";
Thus, the answer is 6 ⋅ 2 + 3 ⋅ 1 + 4 ⋅ 1 + 2 ⋅ 2 + 2 ⋅ 0 + 1 ⋅ 1 = 24.
Tags: combinatorics, dp, math, strings
Correct Solution:
```
mod = 998244353
eps = 10**-9
def main():
import sys
input = sys.stdin.readline
S = input().rstrip('\n')
T = input().rstrip('\n')
NS = len(S)
NT = len(T)
dp_S = [[0] * (NT+1) for _ in range(NS+1)]
dp_T = [[0] * (NT+1) for _ in range(NS+1)]
for i in range(1, NS+1):
dp_S[i][0] = 1
for j in range(1, NT+1):
dp_T[0][j] = 1
for i in range(NS+1):
for j in range(NT+1):
if i == j == 0:
continue
elif i == 0:
if S[0] != T[j-1]:
dp_S[1][j] = (dp_S[1][j] + dp_T[0][j])%mod
if j+1 <= NT:
if T[j-1] != T[j]:
dp_T[0][j+1] = (dp_T[0][j+1] + dp_T[0][j])%mod
elif j == 0:
if T[0] != S[i-1]:
dp_T[i][1] = (dp_T[i][1] + dp_S[i][0]) % mod
if i + 1 <= NS:
if S[i - 1] != S[i]:
dp_S[i+1][0] = (dp_S[i+1][0] + dp_S[i][0]) % mod
else:
if i+1 <= NS:
if S[i-1] != S[i]:
dp_S[i+1][j] = (dp_S[i+1][j] + dp_S[i][j])%mod
if T[j-1] != S[i]:
dp_S[i+1][j] = (dp_S[i+1][j] + dp_T[i][j] + dp_T[0][j])%mod
if j+1 <= NT:
if T[j-1] != T[j]:
dp_T[i][j+1] = (dp_T[i][j+1] + dp_T[i][j])%mod
if S[i-1] != T[j]:
dp_T[i][j+1] = (dp_T[i][j+1] + dp_S[i][j] + dp_S[i][0])%mod
ans = 0
for i in range(1, NS+1):
for j in range(1, NT+1):
ans = (ans + dp_S[i][j] + dp_T[i][j])%mod
print(ans)
if __name__ == '__main__':
main()
```
| 108,089 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two strings x and y, both consist only of lowercase Latin letters. Let |s| be the length of string s.
Let's call a sequence a a merging sequence if it consists of exactly |x| zeros and exactly |y| ones in some order.
A merge z is produced from a sequence a by the following rules:
* if a_i=0, then remove a letter from the beginning of x and append it to the end of z;
* if a_i=1, then remove a letter from the beginning of y and append it to the end of z.
Two merging sequences a and b are different if there is some position i such that a_i ≠ b_i.
Let's call a string z chaotic if for all i from 2 to |z| z_{i-1} ≠ z_i.
Let s[l,r] for some 1 ≤ l ≤ r ≤ |s| be a substring of consecutive letters of s, starting from position l and ending at position r inclusive.
Let f(l_1, r_1, l_2, r_2) be the number of different merging sequences of x[l_1,r_1] and y[l_2,r_2] that produce chaotic merges. Note that only non-empty substrings of x and y are considered.
Calculate ∑ _{1 ≤ l_1 ≤ r_1 ≤ |x| \\\ 1 ≤ l_2 ≤ r_2 ≤ |y|} f(l_1, r_1, l_2, r_2). Output the answer modulo 998 244 353.
Input
The first line contains a string x (1 ≤ |x| ≤ 1000).
The second line contains a string y (1 ≤ |y| ≤ 1000).
Both strings consist only of lowercase Latin letters.
Output
Print a single integer — the sum of f(l_1, r_1, l_2, r_2) over 1 ≤ l_1 ≤ r_1 ≤ |x| and 1 ≤ l_2 ≤ r_2 ≤ |y| modulo 998 244 353.
Examples
Input
aaa
bb
Output
24
Input
code
forces
Output
1574
Input
aaaaa
aaa
Output
0
Input
justamassivetesttocheck
howwellyouhandlemodulooperations
Output
667387032
Note
In the first example there are:
* 6 pairs of substrings "a" and "b", each with valid merging sequences "01" and "10";
* 3 pairs of substrings "a" and "bb", each with a valid merging sequence "101";
* 4 pairs of substrings "aa" and "b", each with a valid merging sequence "010";
* 2 pairs of substrings "aa" and "bb", each with valid merging sequences "0101" and "1010";
* 2 pairs of substrings "aaa" and "b", each with no valid merging sequences;
* 1 pair of substrings "aaa" and "bb" with a valid merging sequence "01010";
Thus, the answer is 6 ⋅ 2 + 3 ⋅ 1 + 4 ⋅ 1 + 2 ⋅ 2 + 2 ⋅ 0 + 1 ⋅ 1 = 24.
Tags: combinatorics, dp, math, strings
Correct Solution:
```
from bisect import *
from collections import *
from math import gcd,ceil,sqrt,floor,inf
from heapq import *
from itertools import *
from operator import add,mul,sub,xor,truediv,floordiv
from functools import *
#------------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#------------------------------------------------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def A(n):return [0]*n
def AI(n,x): return [x]*n
def A2(n,m): return [[0]*m for i in range(n)]
def G(n): return [[] for i in range(n)]
def GP(it): return [[ch,len(list(g))] for ch,g in groupby(it)]
#------------------------------------------------------------------------
from types import GeneratorType
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
mod=10**9+7
farr=[1]
ifa=[]
def fact(x,mod=0):
if mod:
while x>=len(farr):
farr.append(farr[-1]*len(farr)%mod)
else:
while x>=len(farr):
farr.append(farr[-1]*len(farr))
return farr[x]
def ifact(x,mod):
global ifa
fact(x,mod)
ifa.append(pow(farr[-1],mod-2,mod))
for i in range(x,0,-1):
ifa.append(ifa[-1]*i%mod)
ifa.reverse()
def per(i,j,mod=0):
if i<j: return 0
if not mod:
return fact(i)//fact(i-j)
return farr[i]*ifa[i-j]%mod
def com(i,j,mod=0):
if i<j: return 0
if not mod:
return per(i,j)//fact(j)
return per(i,j,mod)*ifa[j]%mod
def catalan(n):
return com(2*n,n)//(n+1)
def isprime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True
def floorsum(a,b,c,n):#sum((a*i+b)//c for i in range(n+1))
if a==0:return b//c*(n+1)
if a>=c or b>=c: return floorsum(a%c,b%c,c,n)+b//c*(n+1)+a//c*n*(n+1)//2
m=(a*n+b)//c
return n*m-floorsum(c,c-b-1,a,m-1)
def inverse(a,m):
a%=m
if a<=1: return a
return ((1-inverse(m,a)*m)//a)%m
def lowbit(n):
return n&-n
class BIT:
def __init__(self,arr):
self.arr=arr
self.n=len(arr)-1
def update(self,x,v):
while x<=self.n:
self.arr[x]+=v
x+=x&-x
def query(self,x):
ans=0
while x:
ans+=self.arr[x]
x&=x-1
return ans
class ST:
def __init__(self,arr):#n!=0
n=len(arr)
mx=n.bit_length()#取不到
self.st=[[0]*mx for i in range(n)]
for i in range(n):
self.st[i][0]=arr[i]
for j in range(1,mx):
for i in range(n-(1<<j)+1):
self.st[i][j]=max(self.st[i][j-1],self.st[i+(1<<j-1)][j-1])
def query(self,l,r):
if l>r:return -inf
s=(r+1-l).bit_length()-1
return max(self.st[l][s],self.st[r-(1<<s)+1][s])
'''
class DSU:#容量+路径压缩
def __init__(self,n):
self.c=[-1]*n
def same(self,x,y):
return self.find(x)==self.find(y)
def find(self,x):
if self.c[x]<0:
return x
self.c[x]=self.find(self.c[x])
return self.c[x]
def union(self,u,v):
u,v=self.find(u),self.find(v)
if u==v:
return False
if self.c[u]>self.c[v]:
u,v=v,u
self.c[u]+=self.c[v]
self.c[v]=u
return True
def size(self,x): return -self.c[self.find(x)]'''
class UFS:#秩+路径
def __init__(self,n):
self.parent=[i for i in range(n)]
self.ranks=[0]*n
def find(self,x):
if x!=self.parent[x]:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def union(self,u,v):
pu,pv=self.find(u),self.find(v)
if pu==pv:
return False
if self.ranks[pu]>=self.ranks[pv]:
self.parent[pv]=pu
if self.ranks[pv]==self.ranks[pu]:
self.ranks[pu]+=1
else:
self.parent[pu]=pv
def Prime(n):
c=0
prime=[]
flag=[0]*(n+1)
for i in range(2,n+1):
if not flag[i]:
prime.append(i)
c+=1
for j in range(c):
if i*prime[j]>n: break
flag[i*prime[j]]=prime[j]
if i%prime[j]==0: break
return flag
def dij(s,graph):
d={}
d[s]=0
heap=[(0,s)]
seen=set()
while heap:
dis,u=heappop(heap)
if u in seen:
continue
seen.add(u)
for v,w in graph[u]:
if v not in d or d[v]>d[u]+w:
d[v]=d[u]+w
heappush(heap,(d[v],v))
return d
def bell(s,g):#bellman-Ford
dis=AI(n,inf)
dis[s]=0
for i in range(n-1):
for u,v,w in edge:
if dis[v]>dis[u]+w:
dis[v]=dis[u]+w
change=A(n)
for i in range(n):
for u,v,w in edge:
if dis[v]>dis[u]+w:
dis[v]=dis[u]+w
change[v]=1
return dis
def lcm(a,b): return a*b//gcd(a,b)
def lis(nums):
res=[]
for k in nums:
i=bisect.bisect_left(res,k)
if i==len(res):
res.append(k)
else:
res[i]=k
return len(res)
def RP(nums):#逆序对
n = len(nums)
s=set(nums)
d={}
for i,k in enumerate(sorted(s),1):
d[k]=i
bi=BIT([0]*(len(s)+1))
ans=0
for i in range(n-1,-1,-1):
ans+=bi.query(d[nums[i]]-1)
bi.update(d[nums[i]],1)
return ans
class DLN:
def __init__(self,val):
self.val=val
self.pre=None
self.next=None
def nb(i,j,n,m):
for ni,nj in [[i+1,j],[i-1,j],[i,j-1],[i,j+1]]:
if 0<=ni<n and 0<=nj<m:
yield ni,nj
def topo(n):
q=deque()
res=[]
for i in range(1,n+1):
if ind[i]==0:
q.append(i)
res.append(i)
while q:
u=q.popleft()
for v in g[u]:
ind[v]-=1
if ind[v]==0:
q.append(v)
res.append(v)
return res
@bootstrap
def gdfs(r,p):
if len(g[r])==1 and p!=-1:
yield None
for ch in g[r]:
if ch!=p:
yield gdfs(ch,r)
yield None
t=1
for i in range(t):
x=input()
x=list(x)
y=input()
y=list(y)
x=list(map(lambda ch: ord(ch)-97,x))
y=list(map(lambda ch: ord(ch)-97,y))
ans=0
mod=998244353
m,n=len(x),len(y)
v1=[1]*(m+1)
v2=[1]*(n+1)
for i in range(m-2,-1,-1):
if x[i]!=x[i+1]:
v1[i]+=v1[i+1]
for i in range(n-2,-1,-1):
if y[i]!=y[i+1]:
v2[i]+=v2[i+1]
#print(x,y,v1,v2)
dp=[[[0]*27 for j in range(n+1)] for i in range(m+1)]
for i in range(m-1,-1,-1):
for j in range(n-1,-1,-1):
for k in range(27):
if x[i]==k:
if y[j]!=k:
dp[i][j][k]=(dp[i][j+1][y[j]]+v1[i])%mod
elif y[j]==k:
dp[i][j][k]=(dp[i+1][j][x[i]]+v2[j])%mod
else:
#print(i,j,k)
dp[i][j][k]=(dp[i+1][j][x[i]]+dp[i][j+1][y[j]]+(x[i]!=y[j])*(v2[j]+v1[i]))%mod
for i in range(m):
for j in range(n):
ans=(ans+dp[i][j][26])%mod
print(ans)
'''
sys.setrecursionlimit(200000)
import threading
threading.stack_size(10**8)
t=threading.Thr
ead(target=main)
t.start()
t.join()
'''
'''
sys.setrecursionlimit(200000)
import threading
threading.stack_size(10**8)
t=threading.Thread(target=main)
t.start()
t.join()
'''
```
| 108,090 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two strings x and y, both consist only of lowercase Latin letters. Let |s| be the length of string s.
Let's call a sequence a a merging sequence if it consists of exactly |x| zeros and exactly |y| ones in some order.
A merge z is produced from a sequence a by the following rules:
* if a_i=0, then remove a letter from the beginning of x and append it to the end of z;
* if a_i=1, then remove a letter from the beginning of y and append it to the end of z.
Two merging sequences a and b are different if there is some position i such that a_i ≠ b_i.
Let's call a string z chaotic if for all i from 2 to |z| z_{i-1} ≠ z_i.
Let s[l,r] for some 1 ≤ l ≤ r ≤ |s| be a substring of consecutive letters of s, starting from position l and ending at position r inclusive.
Let f(l_1, r_1, l_2, r_2) be the number of different merging sequences of x[l_1,r_1] and y[l_2,r_2] that produce chaotic merges. Note that only non-empty substrings of x and y are considered.
Calculate ∑ _{1 ≤ l_1 ≤ r_1 ≤ |x| \\\ 1 ≤ l_2 ≤ r_2 ≤ |y|} f(l_1, r_1, l_2, r_2). Output the answer modulo 998 244 353.
Input
The first line contains a string x (1 ≤ |x| ≤ 1000).
The second line contains a string y (1 ≤ |y| ≤ 1000).
Both strings consist only of lowercase Latin letters.
Output
Print a single integer — the sum of f(l_1, r_1, l_2, r_2) over 1 ≤ l_1 ≤ r_1 ≤ |x| and 1 ≤ l_2 ≤ r_2 ≤ |y| modulo 998 244 353.
Examples
Input
aaa
bb
Output
24
Input
code
forces
Output
1574
Input
aaaaa
aaa
Output
0
Input
justamassivetesttocheck
howwellyouhandlemodulooperations
Output
667387032
Note
In the first example there are:
* 6 pairs of substrings "a" and "b", each with valid merging sequences "01" and "10";
* 3 pairs of substrings "a" and "bb", each with a valid merging sequence "101";
* 4 pairs of substrings "aa" and "b", each with a valid merging sequence "010";
* 2 pairs of substrings "aa" and "bb", each with valid merging sequences "0101" and "1010";
* 2 pairs of substrings "aaa" and "b", each with no valid merging sequences;
* 1 pair of substrings "aaa" and "bb" with a valid merging sequence "01010";
Thus, the answer is 6 ⋅ 2 + 3 ⋅ 1 + 4 ⋅ 1 + 2 ⋅ 2 + 2 ⋅ 0 + 1 ⋅ 1 = 24.
Tags: combinatorics, dp, math, strings
Correct Solution:
```
# O(16*n^2)
import sys
input = sys.stdin.readline
mod = 998244353
tot = 0
x = ' ' + input().strip()
y = ' ' + input().strip()
s = [x,y]
# the idea is to go from the dp that finds number of chaotic merges of x and y
# given that the substrings merged must begin at the start of x and y (are just prefixes)
# to the dp where the start of the substrings for the merge can be anything
# this is done by adding 1 at dp[i][j-1][0][1][0] and dp[i-1][j][1][0][1]
# (the same way we would start the dp normally if i == 1 and j == 1 (prefixes from above))
# dp[i][j][c][nex][ney] = the number of chaotic merges of a substring of x and y such that
# either substring of x is empty or ends at i and either substring of y is empty or ends at j
# however both substrings cannot be empty
# c = 0 -> last character is from x otherwise from y
# nex -> 1 if substring from x is not empty else 0
# ney -> 1 if substring from y is not empty else 0
# note that instead of an extra dimension for each nex and ney they are merged to reduce memory (or else MLE)
dp = [[[[0]*4 for j in range(2)] for k in range(len(y))] for i in range(len(x))]
# base case
for i in range(1,len(x)):
for j in range(1,len(y)):
# to start the dp of chaotic merges of x[i:] and y[j:]
dp[i][j-1][0][2] = 1
dp[i-1][j][1][1] = 1
# transitions
for i in range(len(x)):
for j in range(len(y)):
s_idx = [i,j]
# add num of chaotic merges of subs that end at i and j to tot
tot = (tot + dp[i][j][0][3] + dp[i][j][1][3]) % mod
# transition
for c in range(2):
for nex in range(2):
for ney in range(2):
# add x[i+1] to the end of the merge and transition
if i < len(x)-1 and s[c][s_idx[c]] != x[i+1]:
dp[i+1][j][0][2+ney] = (dp[i+1][j][0][2+ney] + dp[i][j][c][2*nex+ney]) % mod
# add y[j+1] to the end of the merge and transition
if j < len(y)-1 and s[c][s_idx[c]] != y[j+1]:
dp[i][j+1][1][2*nex+1] = (dp[i][j+1][1][2*nex+1] + dp[i][j][c][2*nex+ney]) % mod
print(tot)
```
| 108,091 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two strings x and y, both consist only of lowercase Latin letters. Let |s| be the length of string s.
Let's call a sequence a a merging sequence if it consists of exactly |x| zeros and exactly |y| ones in some order.
A merge z is produced from a sequence a by the following rules:
* if a_i=0, then remove a letter from the beginning of x and append it to the end of z;
* if a_i=1, then remove a letter from the beginning of y and append it to the end of z.
Two merging sequences a and b are different if there is some position i such that a_i ≠ b_i.
Let's call a string z chaotic if for all i from 2 to |z| z_{i-1} ≠ z_i.
Let s[l,r] for some 1 ≤ l ≤ r ≤ |s| be a substring of consecutive letters of s, starting from position l and ending at position r inclusive.
Let f(l_1, r_1, l_2, r_2) be the number of different merging sequences of x[l_1,r_1] and y[l_2,r_2] that produce chaotic merges. Note that only non-empty substrings of x and y are considered.
Calculate ∑ _{1 ≤ l_1 ≤ r_1 ≤ |x| \\\ 1 ≤ l_2 ≤ r_2 ≤ |y|} f(l_1, r_1, l_2, r_2). Output the answer modulo 998 244 353.
Input
The first line contains a string x (1 ≤ |x| ≤ 1000).
The second line contains a string y (1 ≤ |y| ≤ 1000).
Both strings consist only of lowercase Latin letters.
Output
Print a single integer — the sum of f(l_1, r_1, l_2, r_2) over 1 ≤ l_1 ≤ r_1 ≤ |x| and 1 ≤ l_2 ≤ r_2 ≤ |y| modulo 998 244 353.
Examples
Input
aaa
bb
Output
24
Input
code
forces
Output
1574
Input
aaaaa
aaa
Output
0
Input
justamassivetesttocheck
howwellyouhandlemodulooperations
Output
667387032
Note
In the first example there are:
* 6 pairs of substrings "a" and "b", each with valid merging sequences "01" and "10";
* 3 pairs of substrings "a" and "bb", each with a valid merging sequence "101";
* 4 pairs of substrings "aa" and "b", each with a valid merging sequence "010";
* 2 pairs of substrings "aa" and "bb", each with valid merging sequences "0101" and "1010";
* 2 pairs of substrings "aaa" and "b", each with no valid merging sequences;
* 1 pair of substrings "aaa" and "bb" with a valid merging sequence "01010";
Thus, the answer is 6 ⋅ 2 + 3 ⋅ 1 + 4 ⋅ 1 + 2 ⋅ 2 + 2 ⋅ 0 + 1 ⋅ 1 = 24.
Submitted Solution:
```
S=list(input())
T=list(input())
N=len(S)-2
M=len(T)-2
S.append(20)
mod=998244353
DP=[[[0]*8 for j in range(M+2)] for i in range(N+2)]
for i in range(N):
for j in range(M):
DP[i][j][0]=1
for i in range(N+1):
for j in range(M+1):
for k in range(8):
if k&4:
if S[i-1]!=S[i]:
DP[i+1][j][k|1]+=DP[i][j][k]
if DP[i+1][j][k|1]>=mod:
DP[i+1][j][k|1]-=mod
if S[i-1]!=T[j]:
DP[i][j+1][(k|2)^4]+=DP[i][j][k]
if DP[i][j+1][(k|2)^4]>=mod:
DP[i][j+1][(k|2)^4]-=mod
else:
if T[j-1]!=S[i] or k==0:
DP[i+1][j][(k|1)^4]+=DP[i][j][k]
if DP[i+1][j][(k|1)^4]>=mod:
DP[i+1][j][(k|1)^4]-=mod
if T[j-1]!=T[j] or k==0:
DP[i][j+1][k|2]+=DP[i][j][k]
if DP[i][j+1][k|2]>=mod:
DP[i][j+1][k|2]-=mod
ANS=0
for i in range(N+1):
for j in range(M+1):
ANS+=DP[i][j][3]+DP[i][j][7]
print(ANS%mod)
```
No
| 108,092 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an interactive problem!
Nastia has a hidden permutation p of length n consisting of integers from 1 to n. You, for some reason, want to figure out the permutation. To do that, you can give her an integer t (1 ≤ t ≤ 2), two different indices i and j (1 ≤ i, j ≤ n, i ≠ j), and an integer x (1 ≤ x ≤ n - 1).
Depending on t, she will answer:
* t = 1: max{(min{(x, p_i)}, min{(x + 1, p_j)})};
* t = 2: min{(max{(x, p_i)}, max{(x + 1, p_j)})}.
You can ask Nastia at most ⌊ \frac {3 ⋅ n} { 2} ⌋ + 30 times. It is guaranteed that she will not change her permutation depending on your queries. Can you guess the permutation?
Input
The input consists of several test cases. In the beginning, you receive the integer T (1 ≤ T ≤ 10 000) — the number of test cases.
At the beginning of each test case, you receive an integer n (3 ≤ n ≤ 10^4) — the length of the permutation p.
It's guaranteed that the permutation is fixed beforehand and that the sum of n in one test doesn't exceed 2 ⋅ 10^4.
Interaction
To ask a question, print "? t i j x" (t = 1 or t = 2, 1 ≤ i, j ≤ n, i ≠ j, 1 ≤ x ≤ n - 1) Then, you should read the answer.
If we answer with −1 instead of a valid answer, that means you exceeded the number of queries or made an invalid query. Exit immediately after receiving −1 and you will see the Wrong Answer verdict. Otherwise, you can get an arbitrary verdict because your solution will continue to read from a closed stream.
To print the answer, print "! p_1 p_2 … p_{n} (without quotes). Note that answering doesn't count as one of the ⌊ \frac {3 ⋅ n} {2} ⌋ + 30 queries.
After printing a query or printing the answer, do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* See the documentation for other languages.
Hacks
To hack the solution, use the following test format.
The first line should contain a single integer T (1 ≤ T ≤ 10 000) — the number of test cases.
For each test case in the first line print a single integer n (3 ≤ n ≤ 10^4) — the length of the hidden permutation p.
In the second line print n space-separated integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n), where p is permutation.
Note that the sum of n over all test cases should not exceed 2 ⋅ 10^4.
Example
Input
2
4
3
2
5
3
Output
? 2 4 1 3
? 1 2 4 2
! 3 1 4 2
? 2 3 4 2
! 2 5 3 4 1
Note
Consider the first test case.
The hidden permutation is [3, 1, 4, 2].
We print: "? 2 4 1 3" and get back min{(max{(3, p_4}), max{(4, p_1)})} = 3.
We print: "? 1 2 4 2" and get back max{(min{(2, p_2)}, min{(3, p_4)})} = 2.
Consider the second test case.
The hidden permutation is [2, 5, 3, 4, 1].
We print: "? 2 3 4 2" and get back min{(max{(2, p_3}), max{(3, p_4)})} = 3.
Tags: constructive algorithms, interactive
Correct Solution:
```
import math,sys
## from itertools import permutations, combinations;import heapq,random;
from collections import defaultdict,deque
import bisect as bi
def yes():print('YES')
def no():print('NO')
# sys.stdin=open('input.txt','r');sys.stdout=open('output.txt','w');
def I():return (int(sys.stdin.readline()))
def In():return(map(int,sys.stdin.readline().split()))
def Sn():return sys.stdin.readline().strip()
#sys.setrecursionlimit(1500)
def dict(a):
d={}
for x in a:
if d.get(x,-1)!=-1:
d[x]+=1
else:
d[x]=1
return d
def find_gt(a, x):
'Find leftmost value greater than x'
i = bi.bisect_left(a, x)
if i != len(a):
return i
else:
return -1
def query(type,st,end,x):
print('?',type,st,end,x,flush=True)
def main():
try:
global topi,ans
n=I()
d={}
st=-1
ans=[0]*(n+1)
topi=n-1
end = n-1 if n&1==1 else n
for i in range(0,end,2):
query(1,i+1,i+2,topi)
q=I()
if q==topi:
query(1,i+2,i+1,topi)
x=I()
if x==n:
st=i+1
break
elif q==n:
st=i+2
break
if st==-1:
st=n
ans[st]=n
for i in range(st-1,0,-1):
query(2,i,st,1)
q=I()
ans[i]=q
for i in range(st+1,n+1):
query(2,i,st,1)
q=I()
ans[i]=q
print('!',*ans[1:],flush=True)
except:
pass
M = 998244353
P = 1000000007
if __name__ == '__main__':
for _ in range(I()):main()
# for _ in range(1):main()
#End#
# ******************* All The Best ******************* #
```
| 108,093 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem!
Nastia has a hidden permutation p of length n consisting of integers from 1 to n. You, for some reason, want to figure out the permutation. To do that, you can give her an integer t (1 ≤ t ≤ 2), two different indices i and j (1 ≤ i, j ≤ n, i ≠ j), and an integer x (1 ≤ x ≤ n - 1).
Depending on t, she will answer:
* t = 1: max{(min{(x, p_i)}, min{(x + 1, p_j)})};
* t = 2: min{(max{(x, p_i)}, max{(x + 1, p_j)})}.
You can ask Nastia at most ⌊ \frac {3 ⋅ n} { 2} ⌋ + 30 times. It is guaranteed that she will not change her permutation depending on your queries. Can you guess the permutation?
Input
The input consists of several test cases. In the beginning, you receive the integer T (1 ≤ T ≤ 10 000) — the number of test cases.
At the beginning of each test case, you receive an integer n (3 ≤ n ≤ 10^4) — the length of the permutation p.
It's guaranteed that the permutation is fixed beforehand and that the sum of n in one test doesn't exceed 2 ⋅ 10^4.
Interaction
To ask a question, print "? t i j x" (t = 1 or t = 2, 1 ≤ i, j ≤ n, i ≠ j, 1 ≤ x ≤ n - 1) Then, you should read the answer.
If we answer with −1 instead of a valid answer, that means you exceeded the number of queries or made an invalid query. Exit immediately after receiving −1 and you will see the Wrong Answer verdict. Otherwise, you can get an arbitrary verdict because your solution will continue to read from a closed stream.
To print the answer, print "! p_1 p_2 … p_{n} (without quotes). Note that answering doesn't count as one of the ⌊ \frac {3 ⋅ n} {2} ⌋ + 30 queries.
After printing a query or printing the answer, do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* See the documentation for other languages.
Hacks
To hack the solution, use the following test format.
The first line should contain a single integer T (1 ≤ T ≤ 10 000) — the number of test cases.
For each test case in the first line print a single integer n (3 ≤ n ≤ 10^4) — the length of the hidden permutation p.
In the second line print n space-separated integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n), where p is permutation.
Note that the sum of n over all test cases should not exceed 2 ⋅ 10^4.
Example
Input
2
4
3
2
5
3
Output
? 2 4 1 3
? 1 2 4 2
! 3 1 4 2
? 2 3 4 2
! 2 5 3 4 1
Note
Consider the first test case.
The hidden permutation is [3, 1, 4, 2].
We print: "? 2 4 1 3" and get back min{(max{(3, p_4}), max{(4, p_1)})} = 3.
We print: "? 1 2 4 2" and get back max{(min{(2, p_2)}, min{(3, p_4)})} = 2.
Consider the second test case.
The hidden permutation is [2, 5, 3, 4, 1].
We print: "? 2 3 4 2" and get back min{(max{(2, p_3}), max{(3, p_4)})} = 3.
Submitted Solution:
```
import sys
from collections import defaultdict
from math import ceil, floor, log10, log2
def solve():
ans = [-1 for i in range(n + 1)]
ans[0] = '!'
i = 1
maxxind = ceil(n / 2)
while i <= (n // 2):
print('?', 1, i, n - i + 1, n - 1, flush=True)
rep = int(input())
if rep == n:
maxxind = n - i + 1
ans[n - i + 1] = n
break
if rep == n - 1:
print('?', 1, n - i + 1, i, n - 1, flush=True)
rep = int(input())
if rep == n:
maxind = n - i + 1
ans[i] = n
break
i += 1
for i in range(1, n + 1):
if ans[i] == -1:
print('?', 2, i, maxxind, 1, flush=True)
rep = int(input())
ans[i] = rep
res = ' '.join(map(str, ans))
print(res, flush=True)
return
if __name__ == '__main__':
T = int(input())
for t in range(1, T + 1):
n = int(input())
solve()
```
No
| 108,094 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem!
Nastia has a hidden permutation p of length n consisting of integers from 1 to n. You, for some reason, want to figure out the permutation. To do that, you can give her an integer t (1 ≤ t ≤ 2), two different indices i and j (1 ≤ i, j ≤ n, i ≠ j), and an integer x (1 ≤ x ≤ n - 1).
Depending on t, she will answer:
* t = 1: max{(min{(x, p_i)}, min{(x + 1, p_j)})};
* t = 2: min{(max{(x, p_i)}, max{(x + 1, p_j)})}.
You can ask Nastia at most ⌊ \frac {3 ⋅ n} { 2} ⌋ + 30 times. It is guaranteed that she will not change her permutation depending on your queries. Can you guess the permutation?
Input
The input consists of several test cases. In the beginning, you receive the integer T (1 ≤ T ≤ 10 000) — the number of test cases.
At the beginning of each test case, you receive an integer n (3 ≤ n ≤ 10^4) — the length of the permutation p.
It's guaranteed that the permutation is fixed beforehand and that the sum of n in one test doesn't exceed 2 ⋅ 10^4.
Interaction
To ask a question, print "? t i j x" (t = 1 or t = 2, 1 ≤ i, j ≤ n, i ≠ j, 1 ≤ x ≤ n - 1) Then, you should read the answer.
If we answer with −1 instead of a valid answer, that means you exceeded the number of queries or made an invalid query. Exit immediately after receiving −1 and you will see the Wrong Answer verdict. Otherwise, you can get an arbitrary verdict because your solution will continue to read from a closed stream.
To print the answer, print "! p_1 p_2 … p_{n} (without quotes). Note that answering doesn't count as one of the ⌊ \frac {3 ⋅ n} {2} ⌋ + 30 queries.
After printing a query or printing the answer, do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* See the documentation for other languages.
Hacks
To hack the solution, use the following test format.
The first line should contain a single integer T (1 ≤ T ≤ 10 000) — the number of test cases.
For each test case in the first line print a single integer n (3 ≤ n ≤ 10^4) — the length of the hidden permutation p.
In the second line print n space-separated integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n), where p is permutation.
Note that the sum of n over all test cases should not exceed 2 ⋅ 10^4.
Example
Input
2
4
3
2
5
3
Output
? 2 4 1 3
? 1 2 4 2
! 3 1 4 2
? 2 3 4 2
! 2 5 3 4 1
Note
Consider the first test case.
The hidden permutation is [3, 1, 4, 2].
We print: "? 2 4 1 3" and get back min{(max{(3, p_4}), max{(4, p_1)})} = 3.
We print: "? 1 2 4 2" and get back max{(min{(2, p_2)}, min{(3, p_4)})} = 2.
Consider the second test case.
The hidden permutation is [2, 5, 3, 4, 1].
We print: "? 2 3 4 2" and get back min{(max{(2, p_3}), max{(3, p_4)})} = 3.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#######################################
for t in range(int(input())):
n=int(input())
p=[10**5]*n
if n==3:
print('?',1,1,2,n-1,flush=True)
a=int(input())
print('?',2,1,2,1,flush=True)
b=int(input())
print('?',1,2,3,n-1,flush=True)
c=int(input())
print('?',2,2,3,1,flush=True)
d=int(input())
if b==d:
p[1]=1
x=a
p[0]=x
if x==2:
p[2]=3
else:
p[2]=2
elif a==c:
p[1]=3
x=b
p[0]=x
if x==1:
p[2]=2
else:
p[2]=1
else:
if b==2:
p[0]=3
p[1]=2
p[2]=1
else:
p[0]=1
p[1]=2
p[2]=3
else:
if n%2:
x=n-1
else:
x=n
l=[]
for i in range(0,x,2):
print('?',1,i+1,i+2,n-1,flush=True)
a=int(input())
print('?',2,i+1,i+2,1,flush=True)
b=int(input())
l.append([b,a])
for i in range(len(l)-1):
if l[i][0]<l[i+1][0]:
print('?',2,2*i+1,2*i+3,1,flush=True)
a=int(input())
if a==l[i][0]:
p[2*i]=a
p[2*i+1]=l[i][1]
else:
p[2*i]=l[i][1]
p[2*i+1]=l[i][0]
elif l[i][0]<l[i+1][1]:
print('?',2,2*i+1,2*i+4,1,flush=True)
a=int(input())
if a==l[i][0]:
p[2*i]=l[i][0]
p[2*i+1]=l[i][1]
else:
p[2*i]=l[i][1]
p[2*i+1]=l[i][0]
else:
print('?',1,2*i+1,2*i+3,n-1,flush=True)
a=int(input())
if a==l[i][0]:
p[2*i]=a
p[2*i+1]=l[i][1]
else:
p[2*i]=l[i][1]
p[2*i+1]=l[i][0]
a=min(p)
b=p.index(a)
if a==1:
print('?',1,b+1,x-1,n-1,flush=True)
c=int(input())
p[x-2]=c
print('?',1,b+1,x,n-1,flush=True)
c=int(input())
p[x-1]=c
elif a==2:
print('?',1,b+1,x-1,n-1,flush=True)
c=int(input())
if c!=2:
p[x-2]=c
if c==l[-1][0]:
p[x-1]=l[-1][1]
else:
p[x-1]=l[-1][0]
else:
p[x-2]=1
p[x-1]=l[-1][1]
else:
print('?',2,b+1,x-1,1,flush=True)
c=int(input())
p[x-2]=c
if c==1:
p[x-1]=2
else:
p[x-1]=1
if n%2:
a=min(p)
b=p.index(a)
if a==1:
print('?',1,b+1,n,n-1,flush=True)
c=int(input())
p[n-1]=c
else:
p[n-1]=1
print('!',*p,flush=True)
```
No
| 108,095 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem!
Nastia has a hidden permutation p of length n consisting of integers from 1 to n. You, for some reason, want to figure out the permutation. To do that, you can give her an integer t (1 ≤ t ≤ 2), two different indices i and j (1 ≤ i, j ≤ n, i ≠ j), and an integer x (1 ≤ x ≤ n - 1).
Depending on t, she will answer:
* t = 1: max{(min{(x, p_i)}, min{(x + 1, p_j)})};
* t = 2: min{(max{(x, p_i)}, max{(x + 1, p_j)})}.
You can ask Nastia at most ⌊ \frac {3 ⋅ n} { 2} ⌋ + 30 times. It is guaranteed that she will not change her permutation depending on your queries. Can you guess the permutation?
Input
The input consists of several test cases. In the beginning, you receive the integer T (1 ≤ T ≤ 10 000) — the number of test cases.
At the beginning of each test case, you receive an integer n (3 ≤ n ≤ 10^4) — the length of the permutation p.
It's guaranteed that the permutation is fixed beforehand and that the sum of n in one test doesn't exceed 2 ⋅ 10^4.
Interaction
To ask a question, print "? t i j x" (t = 1 or t = 2, 1 ≤ i, j ≤ n, i ≠ j, 1 ≤ x ≤ n - 1) Then, you should read the answer.
If we answer with −1 instead of a valid answer, that means you exceeded the number of queries or made an invalid query. Exit immediately after receiving −1 and you will see the Wrong Answer verdict. Otherwise, you can get an arbitrary verdict because your solution will continue to read from a closed stream.
To print the answer, print "! p_1 p_2 … p_{n} (without quotes). Note that answering doesn't count as one of the ⌊ \frac {3 ⋅ n} {2} ⌋ + 30 queries.
After printing a query or printing the answer, do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* See the documentation for other languages.
Hacks
To hack the solution, use the following test format.
The first line should contain a single integer T (1 ≤ T ≤ 10 000) — the number of test cases.
For each test case in the first line print a single integer n (3 ≤ n ≤ 10^4) — the length of the hidden permutation p.
In the second line print n space-separated integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n), where p is permutation.
Note that the sum of n over all test cases should not exceed 2 ⋅ 10^4.
Example
Input
2
4
3
2
5
3
Output
? 2 4 1 3
? 1 2 4 2
! 3 1 4 2
? 2 3 4 2
! 2 5 3 4 1
Note
Consider the first test case.
The hidden permutation is [3, 1, 4, 2].
We print: "? 2 4 1 3" and get back min{(max{(3, p_4}), max{(4, p_1)})} = 3.
We print: "? 1 2 4 2" and get back max{(min{(2, p_2)}, min{(3, p_4)})} = 2.
Consider the second test case.
The hidden permutation is [2, 5, 3, 4, 1].
We print: "? 2 3 4 2" and get back min{(max{(2, p_3}), max{(3, p_4)})} = 3.
Submitted Solution:
```
#!/usr/bin/python3
import sys
input = sys.stdin.readline
import random
def get_small(i, j):
print("?", 2, i, j, 1, flush=True)
ret1 = int(input())
print("?", 2, j, i, 1, flush=True)
ret2 = int(input())
return min(ret1, ret2)
def get_large(i, j):
print("?", 1, i, j, n-1, flush=True)
ret1 = int(input())
print("?", 1, j, i, n-1, flush=True)
ret2 = int(input())
return max(ret1, ret2)
t = int(input())
for _ in range(t):
n = int(input())
v12 = []
v12.append(get_small(1, 2))
v12.append(get_large(1, 2))
v13 = []
v13.append(get_small(1, 3))
v13.append(get_large(1, 3))
if v12[0] in v13:
if v12[1] != 1 and v12[1] != n:
key = v12[1]
base = 0
else:
key = v12[0]
base = 1
else:
if v12[0] != 1 and v12[0] != n:
key = v12[0]
base = 0
else:
key = v12[1]
base = 1
key_is_big = (key >= n // 2)
ans = [None] * n
ans[base] = key
for i in range(n):
if i == base:
continue
if key_is_big:
print("?", 2, base+1, i+1, 1, flush=True)
ret = int(input())
if ret != key:
ans[i] = ret
continue
print("?", 1, base+1, i+1, n-1, flush=True)
ret = int(input())
if ret != key:
ans[i] = ret
else:
print("?", 1, base+1, i+1, n-1, flush=True)
ret = int(input())
if ret != key:
ans[i] = ret
continue
print("?", 2, base+1, i+1, 1, flush=True)
ret = int(input())
if ret != key:
ans[i] = ret
print("!", *ans)
exit()
```
No
| 108,096 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem!
Nastia has a hidden permutation p of length n consisting of integers from 1 to n. You, for some reason, want to figure out the permutation. To do that, you can give her an integer t (1 ≤ t ≤ 2), two different indices i and j (1 ≤ i, j ≤ n, i ≠ j), and an integer x (1 ≤ x ≤ n - 1).
Depending on t, she will answer:
* t = 1: max{(min{(x, p_i)}, min{(x + 1, p_j)})};
* t = 2: min{(max{(x, p_i)}, max{(x + 1, p_j)})}.
You can ask Nastia at most ⌊ \frac {3 ⋅ n} { 2} ⌋ + 30 times. It is guaranteed that she will not change her permutation depending on your queries. Can you guess the permutation?
Input
The input consists of several test cases. In the beginning, you receive the integer T (1 ≤ T ≤ 10 000) — the number of test cases.
At the beginning of each test case, you receive an integer n (3 ≤ n ≤ 10^4) — the length of the permutation p.
It's guaranteed that the permutation is fixed beforehand and that the sum of n in one test doesn't exceed 2 ⋅ 10^4.
Interaction
To ask a question, print "? t i j x" (t = 1 or t = 2, 1 ≤ i, j ≤ n, i ≠ j, 1 ≤ x ≤ n - 1) Then, you should read the answer.
If we answer with −1 instead of a valid answer, that means you exceeded the number of queries or made an invalid query. Exit immediately after receiving −1 and you will see the Wrong Answer verdict. Otherwise, you can get an arbitrary verdict because your solution will continue to read from a closed stream.
To print the answer, print "! p_1 p_2 … p_{n} (without quotes). Note that answering doesn't count as one of the ⌊ \frac {3 ⋅ n} {2} ⌋ + 30 queries.
After printing a query or printing the answer, do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* See the documentation for other languages.
Hacks
To hack the solution, use the following test format.
The first line should contain a single integer T (1 ≤ T ≤ 10 000) — the number of test cases.
For each test case in the first line print a single integer n (3 ≤ n ≤ 10^4) — the length of the hidden permutation p.
In the second line print n space-separated integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n), where p is permutation.
Note that the sum of n over all test cases should not exceed 2 ⋅ 10^4.
Example
Input
2
4
3
2
5
3
Output
? 2 4 1 3
? 1 2 4 2
! 3 1 4 2
? 2 3 4 2
! 2 5 3 4 1
Note
Consider the first test case.
The hidden permutation is [3, 1, 4, 2].
We print: "? 2 4 1 3" and get back min{(max{(3, p_4}), max{(4, p_1)})} = 3.
We print: "? 1 2 4 2" and get back max{(min{(2, p_2)}, min{(3, p_4)})} = 2.
Consider the second test case.
The hidden permutation is [2, 5, 3, 4, 1].
We print: "? 2 3 4 2" and get back min{(max{(2, p_3}), max{(3, p_4)})} = 3.
Submitted Solution:
```
'''Author- Akshit Monga'''
from sys import stdin, stdout
input = stdin.readline
def query(k,i,j,x):
print('?',k,i,j,x,flush=True)
val=int(input())
return val
def find1(ind):
for i in range(1,n+1):
if i==ind or arr[i]!=-1:
continue
arr[i]=query(2,i,ind,1)
# print('!',*arr,flush=True)
def find2(ind):
for i in range(1,n+1):
if i==ind or arr[i]!=-1:
continue
arr[i]=query(1,ind,i,n-1)
# print('!',*arr,flush=True)
t = int(input())
for _ in range(t):
n=int(input())
arr=[-1 for i in range(n+1)]
for j in range(1,n+1,3):
i=j-1
val1 = query(1, i+1, i+2, n - 1)
if val1 == n - 1:
val2 = query(1, i+2, i+1, n - 1)
if val2 == n:
arr[i+1] = n
if arr[i+1] == n:
find1(i+1)
break
val3 = query(2, i+1, i+2, 1)
if val3 == 2:
val4 = query(2, i+2, i+1, 1)
if val4 == 1:
arr[i+2] = 1
if arr[i+2] == 1:
find2(i+2)
break
val5 = query(1, i+2, i+3, n - 1)
if val5 == n - 1:
val6 = query(1, i+3, i+2, n - 1)
if val6 == n:
arr[i+2] = n
if arr[i+2] == n:
find1(i+2)
break
val7 = query(2, i+2, i+3, 1)
if val7 == 2:
val8 = query(2, i+3, i+2, 1)
if val8 == 1:
arr[i+3] = 1
if arr[i+3] == 1:
find2(i+3)
break
# val1 val3 val5 val7
p = [val1, val3]
q = [val5, val7]
for k in p:
for j in q:
if k == j:
arr[i+2] = k
break
if arr[i+2] != -1:
break
for k in p:
if k != arr[i+2]:
arr[i+1] = k
break
for k in q:
if k != arr[i+2]:
arr[i+3] = k
break
for i in range(1,n+1):
if arr[i]==-1:
val1=query(1,1,i,n-1)
if val1!=arr[1]:
arr[i]=val1
else:
val2=query(2,i,1,1)
arr[i]=val2
print('!',*arr[1:],flush=True)
```
No
| 108,097 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Suppose you have two points p = (x_p, y_p) and q = (x_q, y_q). Let's denote the Manhattan distance between them as d(p, q) = |x_p - x_q| + |y_p - y_q|.
Let's say that three points p, q, r form a bad triple if d(p, r) = d(p, q) + d(q, r).
Let's say that an array b_1, b_2, ..., b_m is good if it is impossible to choose three distinct indices i, j, k such that the points (b_i, i), (b_j, j) and (b_k, k) form a bad triple.
You are given an array a_1, a_2, ..., a_n. Calculate the number of good subarrays of a. A subarray of the array a is the array a_l, a_{l + 1}, ..., a_r for some 1 ≤ l ≤ r ≤ n.
Note that, according to the definition, subarrays of length 1 and 2 are good.
Input
The first line contains one integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of array a.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
It's guaranteed that the sum of n doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print the number of good subarrays of array a.
Example
Input
3
4
2 4 1 3
5
6 9 1 9 6
2
13 37
Output
10
12
3
Note
In the first test case, it can be proven that any subarray of a is good. For example, subarray [a_2, a_3, a_4] is good since it contains only three elements and:
* d((a_2, 2), (a_4, 4)) = |4 - 3| + |2 - 4| = 3 < d((a_2, 2), (a_3, 3)) + d((a_3, 3), (a_4, 4)) = 3 + 1 + 2 + 1 = 7;
* d((a_2, 2), (a_3, 3)) < d((a_2, 2), (a_4, 4)) + d((a_4, 4), (a_3, 3));
* d((a_3, 3), (a_4, 4)) < d((a_3, 3), (a_2, 2)) + d((a_2, 2), (a_4, 4));
In the second test case, for example, subarray [a_1, a_2, a_3, a_4] is not good, since it contains a bad triple (a_1, 1), (a_2, 2), (a_4, 4):
* d((a_1, 1), (a_4, 4)) = |6 - 9| + |1 - 4| = 6;
* d((a_1, 1), (a_2, 2)) = |6 - 9| + |1 - 2| = 4;
* d((a_2, 2), (a_4, 4)) = |9 - 9| + |2 - 4| = 2;
So, d((a_1, 1), (a_4, 4)) = d((a_1, 1), (a_2, 2)) + d((a_2, 2), (a_4, 4)).
Tags: brute force, geometry, greedy, implementation
Correct Solution:
```
def fuk(a):
if a[0]<=a[1]<=a[2]:
return 1
if a[0]>=a[1]>=a[2]:
return 1
return 0
def fukk(a):
if a[0]<=a[1]<=a[2]:
return 1
if a[1]<=a[2]<=a[3]:
return 1
if a[0]<=a[2]<=a[3]:
return 1
if a[0]<=a[1]<=a[3]:
return 1
if a[0]>=a[1]>=a[2]:
return 1
if a[1]>=a[2]>=a[3]:
return 1
if a[0]>=a[2]>=a[3]:
return 1
if a[0]>=a[1]>=a[3]:
return 1
return 0
for _ in range(int(input())):
n = int(input())
l = list(map(int,input().split()))
ans = 0
ll = []
if n>=3:
for i in range(3):
ll.append(l[i])
for i in range(3,n):
if fuk(ll):
ans+=1
ll.pop(0)
ll.append(l[i])
ans+=(fuk(ll))
ll = []
if n>3:
for i in range(4):
ll.append(l[i])
for i in range(4,n):
if fukk(ll):
ans+=1
ll.pop(0)
ll.append(l[i])
ans+=(fukk(ll))
q = 0
for i in range(n):
if i<=3:
q+=(n-i)
else:
break
print(q-ans)
```
| 108,098 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Suppose you have two points p = (x_p, y_p) and q = (x_q, y_q). Let's denote the Manhattan distance between them as d(p, q) = |x_p - x_q| + |y_p - y_q|.
Let's say that three points p, q, r form a bad triple if d(p, r) = d(p, q) + d(q, r).
Let's say that an array b_1, b_2, ..., b_m is good if it is impossible to choose three distinct indices i, j, k such that the points (b_i, i), (b_j, j) and (b_k, k) form a bad triple.
You are given an array a_1, a_2, ..., a_n. Calculate the number of good subarrays of a. A subarray of the array a is the array a_l, a_{l + 1}, ..., a_r for some 1 ≤ l ≤ r ≤ n.
Note that, according to the definition, subarrays of length 1 and 2 are good.
Input
The first line contains one integer t (1 ≤ t ≤ 5000) — the number of test cases.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of array a.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
It's guaranteed that the sum of n doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print the number of good subarrays of array a.
Example
Input
3
4
2 4 1 3
5
6 9 1 9 6
2
13 37
Output
10
12
3
Note
In the first test case, it can be proven that any subarray of a is good. For example, subarray [a_2, a_3, a_4] is good since it contains only three elements and:
* d((a_2, 2), (a_4, 4)) = |4 - 3| + |2 - 4| = 3 < d((a_2, 2), (a_3, 3)) + d((a_3, 3), (a_4, 4)) = 3 + 1 + 2 + 1 = 7;
* d((a_2, 2), (a_3, 3)) < d((a_2, 2), (a_4, 4)) + d((a_4, 4), (a_3, 3));
* d((a_3, 3), (a_4, 4)) < d((a_3, 3), (a_2, 2)) + d((a_2, 2), (a_4, 4));
In the second test case, for example, subarray [a_1, a_2, a_3, a_4] is not good, since it contains a bad triple (a_1, 1), (a_2, 2), (a_4, 4):
* d((a_1, 1), (a_4, 4)) = |6 - 9| + |1 - 4| = 6;
* d((a_1, 1), (a_2, 2)) = |6 - 9| + |1 - 2| = 4;
* d((a_2, 2), (a_4, 4)) = |9 - 9| + |2 - 4| = 2;
So, d((a_1, 1), (a_4, 4)) = d((a_1, 1), (a_2, 2)) + d((a_2, 2), (a_4, 4)).
Tags: brute force, geometry, greedy, implementation
Correct Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
ans = 0
for i in range(n):
if i+2 < n:
if a[i] == a[i+1]:
continue
elif a[i] < a[i+1]:
if a[i+1] <= a[i+2]:
continue
else:
ans += 1
if i+3 < n:
if a[i] <= a[i+2]:
continue
else:
if a[i+2] >= a[i+3] or a[i+1] <= a[i+3]:
continue
else:
ans += 1
else:
if a[i+1] >= a[i+2]:
continue
else:
ans += 1
if i+3 < n:
if a[i] >= a[i+2]:
continue
else:
if a[i+2] <= a[i+3] or a[i+1] >= a[i+3]:
continue
else:
ans += 1
print(ans + n + (n-1))
```
| 108,099 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.