message stringlengths 2 433k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Long time ago there was a symmetric array a_1,a_2,…,a_{2n} consisting of 2n distinct integers. Array a_1,a_2,…,a_{2n} is called symmetric if for each integer 1 ≤ i ≤ 2n, there exists an integer 1 ≤ j ≤ 2n such that a_i = -a_j.
For each integer 1 ≤ i ≤ 2n, Nezzar wrote down an integer d_i equal to the sum of absolute differences from a_i to all integers in a, i. e. d_i = ∑_{j = 1}^{2n} {|a_i - a_j|}.
Now a million years has passed and Nezzar can barely remember the array d and totally forget a. Nezzar wonders if there exists any symmetric array a consisting of 2n distinct integers that generates the array d.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains 2n integers d_1, d_2, …, d_{2n} (0 ≤ d_i ≤ 10^{12}).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print "YES" in a single line if there exists a possible array a. Otherwise, print "NO".
You can print letters in any case (upper or lower).
Example
Input
6
2
8 12 8 12
2
7 7 9 11
2
7 11 7 11
1
1 1
4
40 56 48 40 80 56 80 48
6
240 154 210 162 174 154 186 240 174 186 162 210
Output
YES
NO
NO
NO
NO
YES
Note
In the first test case, a=[1,-3,-1,3] is one possible symmetric array that generates the array d=[8,12,8,12].
In the second test case, it can be shown that there is no symmetric array consisting of distinct integers that can generate array d.
Submitted Solution:
```
import math
YES = 'YES'
NO = 'NO'
MOD = 1000000007
#a = [0]*n
#m = [[0] * m] * n
def input_int():
return int(input())
def input_list():
return input().split(' ')
def input_list_int():
return list(map(int, input_list()))
def solve():
n = input_int()
a = input_list_int()
m = []
cmp = {}
for i in range(0, 2 * n) :
if a[i] not in cmp :
cmp[a[i]] = 0
cmp[a[i]] += 1
if cmp[a[i]] == 2 :
del cmp[a[i]]
m.append(a[i])
if len(cmp) > 0 :
print(NO)
else :
m.sort(reverse = True)
delim = 2 * n
last = 0
x = []
#print(m)
for i in range(0, n) :
m[i] -= last
mul = m[i] / delim
last += 2 * mul
x.append(mul)
delim -= 2
x.sort()
has = 1
for i in range(0, n) :
if x[i] <= 0 or int(x[i]) != x[i] :
has = 0
if i > 0 and x[i] == x[i - 1] :
has = 0
#print(x)
print(YES if has == 1 else NO)
query_count = input_int()
while query_count:
query_count -= 1
solve()
``` | instruction | 0 | 9,307 | 12 | 18,614 |
Yes | output | 1 | 9,307 | 12 | 18,615 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Long time ago there was a symmetric array a_1,a_2,…,a_{2n} consisting of 2n distinct integers. Array a_1,a_2,…,a_{2n} is called symmetric if for each integer 1 ≤ i ≤ 2n, there exists an integer 1 ≤ j ≤ 2n such that a_i = -a_j.
For each integer 1 ≤ i ≤ 2n, Nezzar wrote down an integer d_i equal to the sum of absolute differences from a_i to all integers in a, i. e. d_i = ∑_{j = 1}^{2n} {|a_i - a_j|}.
Now a million years has passed and Nezzar can barely remember the array d and totally forget a. Nezzar wonders if there exists any symmetric array a consisting of 2n distinct integers that generates the array d.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains 2n integers d_1, d_2, …, d_{2n} (0 ≤ d_i ≤ 10^{12}).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print "YES" in a single line if there exists a possible array a. Otherwise, print "NO".
You can print letters in any case (upper or lower).
Example
Input
6
2
8 12 8 12
2
7 7 9 11
2
7 11 7 11
1
1 1
4
40 56 48 40 80 56 80 48
6
240 154 210 162 174 154 186 240 174 186 162 210
Output
YES
NO
NO
NO
NO
YES
Note
In the first test case, a=[1,-3,-1,3] is one possible symmetric array that generates the array d=[8,12,8,12].
In the second test case, it can be shown that there is no symmetric array consisting of distinct integers that can generate array d.
Submitted Solution:
```
def isPair(a):
ret = 0
for x in a:
ret ^= x
return ret == 0
T = int(input())
for cas in range(T):
n = int(input())
a = list(map(int,input().split()))
a.sort()
if not isPair(a):
print("NO")
continue
tot = 0
b = [0 for i in range(2*n+2)]
fl = True
for i in range(2*n,n,-1):
if (a[2*(i-n)-1]-2*tot) % (2*(i-n)):
fl = False
break
b[i] = (a[2*(i-n)-1]-2*tot) // (2*(i-n))
if b[i] <= 0:
fl = False
break
tot += b[i]
for i in range(n+1,2*n):
if b[i] == b[i+1]:
fl = False
break
print("YES" if fl else "NO")
``` | instruction | 0 | 9,308 | 12 | 18,616 |
Yes | output | 1 | 9,308 | 12 | 18,617 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Long time ago there was a symmetric array a_1,a_2,…,a_{2n} consisting of 2n distinct integers. Array a_1,a_2,…,a_{2n} is called symmetric if for each integer 1 ≤ i ≤ 2n, there exists an integer 1 ≤ j ≤ 2n such that a_i = -a_j.
For each integer 1 ≤ i ≤ 2n, Nezzar wrote down an integer d_i equal to the sum of absolute differences from a_i to all integers in a, i. e. d_i = ∑_{j = 1}^{2n} {|a_i - a_j|}.
Now a million years has passed and Nezzar can barely remember the array d and totally forget a. Nezzar wonders if there exists any symmetric array a consisting of 2n distinct integers that generates the array d.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains 2n integers d_1, d_2, …, d_{2n} (0 ≤ d_i ≤ 10^{12}).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print "YES" in a single line if there exists a possible array a. Otherwise, print "NO".
You can print letters in any case (upper or lower).
Example
Input
6
2
8 12 8 12
2
7 7 9 11
2
7 11 7 11
1
1 1
4
40 56 48 40 80 56 80 48
6
240 154 210 162 174 154 186 240 174 186 162 210
Output
YES
NO
NO
NO
NO
YES
Note
In the first test case, a=[1,-3,-1,3] is one possible symmetric array that generates the array d=[8,12,8,12].
In the second test case, it can be shown that there is no symmetric array consisting of distinct integers that can generate array d.
Submitted Solution:
```
def solve():
n = int(input())
arr = list(map(int, input().split()))
diff = 0
arr.sort()
dif = []
for a in range(1, 2 * n, 2):
if arr[a] != arr[a - 1] or arr[a] % 2 != 0:
print("NO")
return
diff = arr[a] - arr[0]
dif.append(diff // 2)
sdif = [2 * sum(dif)]
for a in range(n - 1):
sdif.append(sdif[-1] - 2 * dif[a + 1])
if arr[0] - sdif[0] >= 0:
if (arr[0] - sdif[0]) % (2 * n) == 0:
print("YES")
else:
print("NO")
return
for b in range(1, len(sdif)):
if n == 2 * b:
continue
if abs(sdif[b - 1] - arr[0]) % abs(2 * n - 4 * b) == 0:
if -dif[b - 1] >= ((arr[0] - sdif[b - 1]) // (2 * n - 4 * b)) >= -dif[b]:
print("YES")
return
print("NO")
return
for _ in range(int(input())):
solve()
``` | instruction | 0 | 9,309 | 12 | 18,618 |
No | output | 1 | 9,309 | 12 | 18,619 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Long time ago there was a symmetric array a_1,a_2,…,a_{2n} consisting of 2n distinct integers. Array a_1,a_2,…,a_{2n} is called symmetric if for each integer 1 ≤ i ≤ 2n, there exists an integer 1 ≤ j ≤ 2n such that a_i = -a_j.
For each integer 1 ≤ i ≤ 2n, Nezzar wrote down an integer d_i equal to the sum of absolute differences from a_i to all integers in a, i. e. d_i = ∑_{j = 1}^{2n} {|a_i - a_j|}.
Now a million years has passed and Nezzar can barely remember the array d and totally forget a. Nezzar wonders if there exists any symmetric array a consisting of 2n distinct integers that generates the array d.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains 2n integers d_1, d_2, …, d_{2n} (0 ≤ d_i ≤ 10^{12}).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print "YES" in a single line if there exists a possible array a. Otherwise, print "NO".
You can print letters in any case (upper or lower).
Example
Input
6
2
8 12 8 12
2
7 7 9 11
2
7 11 7 11
1
1 1
4
40 56 48 40 80 56 80 48
6
240 154 210 162 174 154 186 240 174 186 162 210
Output
YES
NO
NO
NO
NO
YES
Note
In the first test case, a=[1,-3,-1,3] is one possible symmetric array that generates the array d=[8,12,8,12].
In the second test case, it can be shown that there is no symmetric array consisting of distinct integers that can generate array d.
Submitted Solution:
```
def solve(n, s):
counter = 0
for i in range(2*n):
if s[i] % 8 == 0: counter += 1
if s[i] % 2 or s.count(s[i]) % 2: return "No"
if counter > n: return "No"
return "Yes"
for _ in range(int(input())):
n = int(input())
s = list(map(int, input().split()))
print(solve(n, s))
``` | instruction | 0 | 9,310 | 12 | 18,620 |
No | output | 1 | 9,310 | 12 | 18,621 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Long time ago there was a symmetric array a_1,a_2,…,a_{2n} consisting of 2n distinct integers. Array a_1,a_2,…,a_{2n} is called symmetric if for each integer 1 ≤ i ≤ 2n, there exists an integer 1 ≤ j ≤ 2n such that a_i = -a_j.
For each integer 1 ≤ i ≤ 2n, Nezzar wrote down an integer d_i equal to the sum of absolute differences from a_i to all integers in a, i. e. d_i = ∑_{j = 1}^{2n} {|a_i - a_j|}.
Now a million years has passed and Nezzar can barely remember the array d and totally forget a. Nezzar wonders if there exists any symmetric array a consisting of 2n distinct integers that generates the array d.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains 2n integers d_1, d_2, …, d_{2n} (0 ≤ d_i ≤ 10^{12}).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print "YES" in a single line if there exists a possible array a. Otherwise, print "NO".
You can print letters in any case (upper or lower).
Example
Input
6
2
8 12 8 12
2
7 7 9 11
2
7 11 7 11
1
1 1
4
40 56 48 40 80 56 80 48
6
240 154 210 162 174 154 186 240 174 186 162 210
Output
YES
NO
NO
NO
NO
YES
Note
In the first test case, a=[1,-3,-1,3] is one possible symmetric array that generates the array d=[8,12,8,12].
In the second test case, it can be shown that there is no symmetric array consisting of distinct integers that can generate array d.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
p = list(map(int,input().split()))
d = {}
for i in p:
if i not in d:
d[i] = 1
else:
d[i]+=1
f2 = 0
for i in d:
if d[i]%2==1:
f2 = 1
for i in p:
if i%2==1:
f2 = 1
if f2:
print("NO")
else:
arr = list(set(p))
arr.sort(reverse=True)
prev_sum = 0
flag = True
# print(arr)
s = set()
for i in arr:
num = (i - prev_sum)
den = 2*(n)
curr = num//den
if num<=0:
flag = False
break
if num%den!=0:
flag = False
break
if curr not in s:
s.add(curr)
else:
flag = False
break
n-=1
prev_sum += 2*curr
if flag:
print("YES")
else:
print("NO")
``` | instruction | 0 | 9,311 | 12 | 18,622 |
No | output | 1 | 9,311 | 12 | 18,623 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Long time ago there was a symmetric array a_1,a_2,…,a_{2n} consisting of 2n distinct integers. Array a_1,a_2,…,a_{2n} is called symmetric if for each integer 1 ≤ i ≤ 2n, there exists an integer 1 ≤ j ≤ 2n such that a_i = -a_j.
For each integer 1 ≤ i ≤ 2n, Nezzar wrote down an integer d_i equal to the sum of absolute differences from a_i to all integers in a, i. e. d_i = ∑_{j = 1}^{2n} {|a_i - a_j|}.
Now a million years has passed and Nezzar can barely remember the array d and totally forget a. Nezzar wonders if there exists any symmetric array a consisting of 2n distinct integers that generates the array d.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains 2n integers d_1, d_2, …, d_{2n} (0 ≤ d_i ≤ 10^{12}).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print "YES" in a single line if there exists a possible array a. Otherwise, print "NO".
You can print letters in any case (upper or lower).
Example
Input
6
2
8 12 8 12
2
7 7 9 11
2
7 11 7 11
1
1 1
4
40 56 48 40 80 56 80 48
6
240 154 210 162 174 154 186 240 174 186 162 210
Output
YES
NO
NO
NO
NO
YES
Note
In the first test case, a=[1,-3,-1,3] is one possible symmetric array that generates the array d=[8,12,8,12].
In the second test case, it can be shown that there is no symmetric array consisting of distinct integers that can generate array d.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
d = list(map(int, input().split()))
if sum(d) %4 == 0:
print('YES')
else:
print('NO')
``` | instruction | 0 | 9,312 | 12 | 18,624 |
No | output | 1 | 9,312 | 12 | 18,625 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To AmShZ, all arrays are equal, but some arrays are more-equal than others. Specifically, the arrays consisting of n elements from 1 to n that can be turned into permutations of numbers from 1 to n by adding a non-negative integer to each element.
Mashtali who wants to appear in every problem statement thinks that an array b consisting of k elements is compatible with a more-equal array a consisting of n elements if for each 1 ≤ i ≤ k we have 1 ≤ b_i ≤ n and also a_{b_1} = a_{b_2} = … = a_{b_k}.
Find the number of pairs of arrays a and b such that a is a more-equal array consisting of n elements and b is an array compatible with a consisting of k elements modulo 998244353.
Note that the elements of b are not necessarily distinct, same holds for a.
Input
The first line of input contains two integers n and k (1 ≤ n ≤ 10^9 , 1 ≤ k ≤ 10^5).
Output
Print a single integer — the answer to the problem modulo 998244353.
Examples
Input
1 1
Output
1
Input
2 2
Output
8
Input
5 4
Output
50400
Input
20 100
Output
807645526
Input
10000000 10000
Output
883232350
Note
There are eight possible pairs for the second example:
1. a = \{1, 1\}, b = \{1, 1\}
2. a = \{1, 1\}, b = \{1, 2\}
3. a = \{1, 1\}, b = \{2, 1\}
4. a = \{1, 1\}, b = \{2, 2\}
5. a = \{1, 2\}, b = \{1, 1\}
6. a = \{1, 2\}, b = \{2, 2\}
7. a = \{2, 1\}, b = \{1, 1\}
8. a = \{2, 1\}, b = \{2, 2\}
Submitted Solution:
```
def build_maxheap(A):
n=len(A)
i=n//2
while(i>=1):
min_heapify(A,i)
i=i-1
return A
``` | instruction | 0 | 9,329 | 12 | 18,658 |
No | output | 1 | 9,329 | 12 | 18,659 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To AmShZ, all arrays are equal, but some arrays are more-equal than others. Specifically, the arrays consisting of n elements from 1 to n that can be turned into permutations of numbers from 1 to n by adding a non-negative integer to each element.
Mashtali who wants to appear in every problem statement thinks that an array b consisting of k elements is compatible with a more-equal array a consisting of n elements if for each 1 ≤ i ≤ k we have 1 ≤ b_i ≤ n and also a_{b_1} = a_{b_2} = … = a_{b_k}.
Find the number of pairs of arrays a and b such that a is a more-equal array consisting of n elements and b is an array compatible with a consisting of k elements modulo 998244353.
Note that the elements of b are not necessarily distinct, same holds for a.
Input
The first line of input contains two integers n and k (1 ≤ n ≤ 10^9 , 1 ≤ k ≤ 10^5).
Output
Print a single integer — the answer to the problem modulo 998244353.
Examples
Input
1 1
Output
1
Input
2 2
Output
8
Input
5 4
Output
50400
Input
20 100
Output
807645526
Input
10000000 10000
Output
883232350
Note
There are eight possible pairs for the second example:
1. a = \{1, 1\}, b = \{1, 1\}
2. a = \{1, 1\}, b = \{1, 2\}
3. a = \{1, 1\}, b = \{2, 1\}
4. a = \{1, 1\}, b = \{2, 2\}
5. a = \{1, 2\}, b = \{1, 1\}
6. a = \{1, 2\}, b = \{2, 2\}
7. a = \{2, 1\}, b = \{1, 1\}
8. a = \{2, 1\}, b = \{2, 2\}
Submitted Solution:
```
print(1)
``` | instruction | 0 | 9,330 | 12 | 18,660 |
No | output | 1 | 9,330 | 12 | 18,661 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Once at a team training Vasya, Petya and Sasha got a problem on implementing linear search in an array.
According to the boys, linear search works as follows. The array elements in a pre-selected order are in turn compared with the number that you need to find. Once you find the array element that is equal to the required one, the search ends. The efficiency of the algorithm is the number of performed comparisons. The fewer comparisons the linear search has made, the more effective it is.
Vasya believes that a linear search would work better if it sequentially iterates through the elements, starting with the 1-st one (in this problem we consider the elements of the array indexed from 1 to n) and ending with the n-th one. And Petya says that Vasya is wrong: the search will need less comparisons if it sequentially iterates the elements starting from the n-th and ending with the 1-st one. Sasha argues that the two approaches are equivalent.
To finally begin the task, the teammates decided to settle the debate and compare the two approaches on an example. For this, they took an array that is a permutation of integers from 1 to n, and generated m queries of the form: find element with value bi in the array. They want to calculate for both approaches how many comparisons in total the linear search will need to respond to all queries. If the first search needs fewer comparisons, then the winner of the dispute is Vasya. If the second one does, then the winner is Petya. If both approaches make the same number of comparisons, then Sasha's got the upper hand.
But the problem is, linear search is too slow. That's why the boys aren't going to find out who is right before the end of the training, unless you come in here. Help them to determine who will win the dispute.
Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of elements in the array. The second line contains n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ n) — the elements of array.
The third line contains integer m (1 ≤ m ≤ 105) — the number of queries. The last line contains m space-separated integers b1, b2, ..., bm (1 ≤ bi ≤ n) — the search queries. Note that the queries can repeat.
Output
Print two integers, showing how many comparisons Vasya's approach needs and how many comparisons Petya's approach needs. Separate the numbers by spaces.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2
1 2
1
1
Output
1 2
Input
2
2 1
1
1
Output
2 1
Input
3
3 1 2
3
1 2 3
Output
6 6
Note
In the first sample Vasya's approach will make one comparison (it starts with the 1-st element and immediately finds the required number), and Petya's approach makes two comparisons (first he compares with the 2-nd array element, doesn't find the search item and compares with the 1-st element).
In the second sample, on the contrary, Vasya's approach will need two comparisons (first with 1-st element, and then with the 2-nd), and Petya's approach will find the required value in one comparison (the first comparison with the 2-nd element). | instruction | 0 | 9,364 | 12 | 18,728 |
Tags: implementation
Correct Solution:
```
from collections import defaultdict
def main():
n = int(input())
a = [int(c) for c in input().split()]
m = int(input())
q = [int(c) for c in input().split()]
cache = defaultdict(list)
for i, e in enumerate(a):
cache[e].append(i)
a = b = 0
for e in q:
a += cache[e][0] + 1
b += n - cache[e][-1]
print(a, b)
if __name__ == '__main__':
main()
``` | output | 1 | 9,364 | 12 | 18,729 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Once at a team training Vasya, Petya and Sasha got a problem on implementing linear search in an array.
According to the boys, linear search works as follows. The array elements in a pre-selected order are in turn compared with the number that you need to find. Once you find the array element that is equal to the required one, the search ends. The efficiency of the algorithm is the number of performed comparisons. The fewer comparisons the linear search has made, the more effective it is.
Vasya believes that a linear search would work better if it sequentially iterates through the elements, starting with the 1-st one (in this problem we consider the elements of the array indexed from 1 to n) and ending with the n-th one. And Petya says that Vasya is wrong: the search will need less comparisons if it sequentially iterates the elements starting from the n-th and ending with the 1-st one. Sasha argues that the two approaches are equivalent.
To finally begin the task, the teammates decided to settle the debate and compare the two approaches on an example. For this, they took an array that is a permutation of integers from 1 to n, and generated m queries of the form: find element with value bi in the array. They want to calculate for both approaches how many comparisons in total the linear search will need to respond to all queries. If the first search needs fewer comparisons, then the winner of the dispute is Vasya. If the second one does, then the winner is Petya. If both approaches make the same number of comparisons, then Sasha's got the upper hand.
But the problem is, linear search is too slow. That's why the boys aren't going to find out who is right before the end of the training, unless you come in here. Help them to determine who will win the dispute.
Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of elements in the array. The second line contains n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ n) — the elements of array.
The third line contains integer m (1 ≤ m ≤ 105) — the number of queries. The last line contains m space-separated integers b1, b2, ..., bm (1 ≤ bi ≤ n) — the search queries. Note that the queries can repeat.
Output
Print two integers, showing how many comparisons Vasya's approach needs and how many comparisons Petya's approach needs. Separate the numbers by spaces.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2
1 2
1
1
Output
1 2
Input
2
2 1
1
1
Output
2 1
Input
3
3 1 2
3
1 2 3
Output
6 6
Note
In the first sample Vasya's approach will make one comparison (it starts with the 1-st element and immediately finds the required number), and Petya's approach makes two comparisons (first he compares with the 2-nd array element, doesn't find the search item and compares with the 1-st element).
In the second sample, on the contrary, Vasya's approach will need two comparisons (first with 1-st element, and then with the 2-nd), and Petya's approach will find the required value in one comparison (the first comparison with the 2-nd element). | instruction | 0 | 9,365 | 12 | 18,730 |
Tags: implementation
Correct Solution:
```
n=int(input())
x=list(map(int,input().split()))
d={}
for i,j in enumerate(x):
d[j]=i
a,b=0,0
q=int(input())
r=list(map(int,input().split()))
for i in r:
a+=d[i]+1
b+=n-d[i]
print(a,b)
``` | output | 1 | 9,365 | 12 | 18,731 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Once at a team training Vasya, Petya and Sasha got a problem on implementing linear search in an array.
According to the boys, linear search works as follows. The array elements in a pre-selected order are in turn compared with the number that you need to find. Once you find the array element that is equal to the required one, the search ends. The efficiency of the algorithm is the number of performed comparisons. The fewer comparisons the linear search has made, the more effective it is.
Vasya believes that a linear search would work better if it sequentially iterates through the elements, starting with the 1-st one (in this problem we consider the elements of the array indexed from 1 to n) and ending with the n-th one. And Petya says that Vasya is wrong: the search will need less comparisons if it sequentially iterates the elements starting from the n-th and ending with the 1-st one. Sasha argues that the two approaches are equivalent.
To finally begin the task, the teammates decided to settle the debate and compare the two approaches on an example. For this, they took an array that is a permutation of integers from 1 to n, and generated m queries of the form: find element with value bi in the array. They want to calculate for both approaches how many comparisons in total the linear search will need to respond to all queries. If the first search needs fewer comparisons, then the winner of the dispute is Vasya. If the second one does, then the winner is Petya. If both approaches make the same number of comparisons, then Sasha's got the upper hand.
But the problem is, linear search is too slow. That's why the boys aren't going to find out who is right before the end of the training, unless you come in here. Help them to determine who will win the dispute.
Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of elements in the array. The second line contains n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ n) — the elements of array.
The third line contains integer m (1 ≤ m ≤ 105) — the number of queries. The last line contains m space-separated integers b1, b2, ..., bm (1 ≤ bi ≤ n) — the search queries. Note that the queries can repeat.
Output
Print two integers, showing how many comparisons Vasya's approach needs and how many comparisons Petya's approach needs. Separate the numbers by spaces.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2
1 2
1
1
Output
1 2
Input
2
2 1
1
1
Output
2 1
Input
3
3 1 2
3
1 2 3
Output
6 6
Note
In the first sample Vasya's approach will make one comparison (it starts with the 1-st element and immediately finds the required number), and Petya's approach makes two comparisons (first he compares with the 2-nd array element, doesn't find the search item and compares with the 1-st element).
In the second sample, on the contrary, Vasya's approach will need two comparisons (first with 1-st element, and then with the 2-nd), and Petya's approach will find the required value in one comparison (the first comparison with the 2-nd element). | instruction | 0 | 9,366 | 12 | 18,732 |
Tags: implementation
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
m = int(input())
b = list(map(int, input().split()))
res = [0, 0]
l = [0 for _ in range(max(a) + 1)]
for i, v in enumerate(a):
l[v] = i+1
for v in b:
res[0] += l[v]
res[1] += n+1-l[v]
print(*res)
``` | output | 1 | 9,366 | 12 | 18,733 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Once at a team training Vasya, Petya and Sasha got a problem on implementing linear search in an array.
According to the boys, linear search works as follows. The array elements in a pre-selected order are in turn compared with the number that you need to find. Once you find the array element that is equal to the required one, the search ends. The efficiency of the algorithm is the number of performed comparisons. The fewer comparisons the linear search has made, the more effective it is.
Vasya believes that a linear search would work better if it sequentially iterates through the elements, starting with the 1-st one (in this problem we consider the elements of the array indexed from 1 to n) and ending with the n-th one. And Petya says that Vasya is wrong: the search will need less comparisons if it sequentially iterates the elements starting from the n-th and ending with the 1-st one. Sasha argues that the two approaches are equivalent.
To finally begin the task, the teammates decided to settle the debate and compare the two approaches on an example. For this, they took an array that is a permutation of integers from 1 to n, and generated m queries of the form: find element with value bi in the array. They want to calculate for both approaches how many comparisons in total the linear search will need to respond to all queries. If the first search needs fewer comparisons, then the winner of the dispute is Vasya. If the second one does, then the winner is Petya. If both approaches make the same number of comparisons, then Sasha's got the upper hand.
But the problem is, linear search is too slow. That's why the boys aren't going to find out who is right before the end of the training, unless you come in here. Help them to determine who will win the dispute.
Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of elements in the array. The second line contains n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ n) — the elements of array.
The third line contains integer m (1 ≤ m ≤ 105) — the number of queries. The last line contains m space-separated integers b1, b2, ..., bm (1 ≤ bi ≤ n) — the search queries. Note that the queries can repeat.
Output
Print two integers, showing how many comparisons Vasya's approach needs and how many comparisons Petya's approach needs. Separate the numbers by spaces.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2
1 2
1
1
Output
1 2
Input
2
2 1
1
1
Output
2 1
Input
3
3 1 2
3
1 2 3
Output
6 6
Note
In the first sample Vasya's approach will make one comparison (it starts with the 1-st element and immediately finds the required number), and Petya's approach makes two comparisons (first he compares with the 2-nd array element, doesn't find the search item and compares with the 1-st element).
In the second sample, on the contrary, Vasya's approach will need two comparisons (first with 1-st element, and then with the 2-nd), and Petya's approach will find the required value in one comparison (the first comparison with the 2-nd element). | instruction | 0 | 9,367 | 12 | 18,734 |
Tags: implementation
Correct Solution:
```
n = int(input())
a = {}
for i,j in enumerate(input().split()):
a[j] = i+1
m = int(input())
x, y = 0, 0
for i in input().split():
z = a[i]
x += z
y += n-z+1
print(x,y)
``` | output | 1 | 9,367 | 12 | 18,735 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Once at a team training Vasya, Petya and Sasha got a problem on implementing linear search in an array.
According to the boys, linear search works as follows. The array elements in a pre-selected order are in turn compared with the number that you need to find. Once you find the array element that is equal to the required one, the search ends. The efficiency of the algorithm is the number of performed comparisons. The fewer comparisons the linear search has made, the more effective it is.
Vasya believes that a linear search would work better if it sequentially iterates through the elements, starting with the 1-st one (in this problem we consider the elements of the array indexed from 1 to n) and ending with the n-th one. And Petya says that Vasya is wrong: the search will need less comparisons if it sequentially iterates the elements starting from the n-th and ending with the 1-st one. Sasha argues that the two approaches are equivalent.
To finally begin the task, the teammates decided to settle the debate and compare the two approaches on an example. For this, they took an array that is a permutation of integers from 1 to n, and generated m queries of the form: find element with value bi in the array. They want to calculate for both approaches how many comparisons in total the linear search will need to respond to all queries. If the first search needs fewer comparisons, then the winner of the dispute is Vasya. If the second one does, then the winner is Petya. If both approaches make the same number of comparisons, then Sasha's got the upper hand.
But the problem is, linear search is too slow. That's why the boys aren't going to find out who is right before the end of the training, unless you come in here. Help them to determine who will win the dispute.
Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of elements in the array. The second line contains n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ n) — the elements of array.
The third line contains integer m (1 ≤ m ≤ 105) — the number of queries. The last line contains m space-separated integers b1, b2, ..., bm (1 ≤ bi ≤ n) — the search queries. Note that the queries can repeat.
Output
Print two integers, showing how many comparisons Vasya's approach needs and how many comparisons Petya's approach needs. Separate the numbers by spaces.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2
1 2
1
1
Output
1 2
Input
2
2 1
1
1
Output
2 1
Input
3
3 1 2
3
1 2 3
Output
6 6
Note
In the first sample Vasya's approach will make one comparison (it starts with the 1-st element and immediately finds the required number), and Petya's approach makes two comparisons (first he compares with the 2-nd array element, doesn't find the search item and compares with the 1-st element).
In the second sample, on the contrary, Vasya's approach will need two comparisons (first with 1-st element, and then with the 2-nd), and Petya's approach will find the required value in one comparison (the first comparison with the 2-nd element). | instruction | 0 | 9,368 | 12 | 18,736 |
Tags: implementation
Correct Solution:
```
# end=mid-1
# else:
# start=mid+1
n=int(input())
arr=list(map(int,input().split()))
q=int(input())
qar=list(map(int,input().split()))
a=0
b=0
d={}
for i in range(n):
d[arr[i]]=i+1
arr.sort()
for i in range(q):
idx=d[qar[i]]
a+=idx
b+=(n-idx)+1
print(a,b)
``` | output | 1 | 9,368 | 12 | 18,737 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Once at a team training Vasya, Petya and Sasha got a problem on implementing linear search in an array.
According to the boys, linear search works as follows. The array elements in a pre-selected order are in turn compared with the number that you need to find. Once you find the array element that is equal to the required one, the search ends. The efficiency of the algorithm is the number of performed comparisons. The fewer comparisons the linear search has made, the more effective it is.
Vasya believes that a linear search would work better if it sequentially iterates through the elements, starting with the 1-st one (in this problem we consider the elements of the array indexed from 1 to n) and ending with the n-th one. And Petya says that Vasya is wrong: the search will need less comparisons if it sequentially iterates the elements starting from the n-th and ending with the 1-st one. Sasha argues that the two approaches are equivalent.
To finally begin the task, the teammates decided to settle the debate and compare the two approaches on an example. For this, they took an array that is a permutation of integers from 1 to n, and generated m queries of the form: find element with value bi in the array. They want to calculate for both approaches how many comparisons in total the linear search will need to respond to all queries. If the first search needs fewer comparisons, then the winner of the dispute is Vasya. If the second one does, then the winner is Petya. If both approaches make the same number of comparisons, then Sasha's got the upper hand.
But the problem is, linear search is too slow. That's why the boys aren't going to find out who is right before the end of the training, unless you come in here. Help them to determine who will win the dispute.
Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of elements in the array. The second line contains n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ n) — the elements of array.
The third line contains integer m (1 ≤ m ≤ 105) — the number of queries. The last line contains m space-separated integers b1, b2, ..., bm (1 ≤ bi ≤ n) — the search queries. Note that the queries can repeat.
Output
Print two integers, showing how many comparisons Vasya's approach needs and how many comparisons Petya's approach needs. Separate the numbers by spaces.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2
1 2
1
1
Output
1 2
Input
2
2 1
1
1
Output
2 1
Input
3
3 1 2
3
1 2 3
Output
6 6
Note
In the first sample Vasya's approach will make one comparison (it starts with the 1-st element and immediately finds the required number), and Petya's approach makes two comparisons (first he compares with the 2-nd array element, doesn't find the search item and compares with the 1-st element).
In the second sample, on the contrary, Vasya's approach will need two comparisons (first with 1-st element, and then with the 2-nd), and Petya's approach will find the required value in one comparison (the first comparison with the 2-nd element). | instruction | 0 | 9,369 | 12 | 18,738 |
Tags: implementation
Correct Solution:
```
def approach(n, ans):
global a, ind, b, m
for i in range(m):
ans[0] += ind[b[i]]+1
ans[1] += len(a)-ind[b[i]]
return ans
n = int(input())
a = list(map(int, input().split()))
m = int(input())
b = list(map(int, input().split()))
ind = [0]*(len(a)+1)
for i in range(len(a)):
ind[a[i]] = i
ans = [0, 0]
#print(ind)
ans = approach(n, ans)
print(*ans)
``` | output | 1 | 9,369 | 12 | 18,739 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Once at a team training Vasya, Petya and Sasha got a problem on implementing linear search in an array.
According to the boys, linear search works as follows. The array elements in a pre-selected order are in turn compared with the number that you need to find. Once you find the array element that is equal to the required one, the search ends. The efficiency of the algorithm is the number of performed comparisons. The fewer comparisons the linear search has made, the more effective it is.
Vasya believes that a linear search would work better if it sequentially iterates through the elements, starting with the 1-st one (in this problem we consider the elements of the array indexed from 1 to n) and ending with the n-th one. And Petya says that Vasya is wrong: the search will need less comparisons if it sequentially iterates the elements starting from the n-th and ending with the 1-st one. Sasha argues that the two approaches are equivalent.
To finally begin the task, the teammates decided to settle the debate and compare the two approaches on an example. For this, they took an array that is a permutation of integers from 1 to n, and generated m queries of the form: find element with value bi in the array. They want to calculate for both approaches how many comparisons in total the linear search will need to respond to all queries. If the first search needs fewer comparisons, then the winner of the dispute is Vasya. If the second one does, then the winner is Petya. If both approaches make the same number of comparisons, then Sasha's got the upper hand.
But the problem is, linear search is too slow. That's why the boys aren't going to find out who is right before the end of the training, unless you come in here. Help them to determine who will win the dispute.
Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of elements in the array. The second line contains n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ n) — the elements of array.
The third line contains integer m (1 ≤ m ≤ 105) — the number of queries. The last line contains m space-separated integers b1, b2, ..., bm (1 ≤ bi ≤ n) — the search queries. Note that the queries can repeat.
Output
Print two integers, showing how many comparisons Vasya's approach needs and how many comparisons Petya's approach needs. Separate the numbers by spaces.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2
1 2
1
1
Output
1 2
Input
2
2 1
1
1
Output
2 1
Input
3
3 1 2
3
1 2 3
Output
6 6
Note
In the first sample Vasya's approach will make one comparison (it starts with the 1-st element and immediately finds the required number), and Petya's approach makes two comparisons (first he compares with the 2-nd array element, doesn't find the search item and compares with the 1-st element).
In the second sample, on the contrary, Vasya's approach will need two comparisons (first with 1-st element, and then with the 2-nd), and Petya's approach will find the required value in one comparison (the first comparison with the 2-nd element). | instruction | 0 | 9,370 | 12 | 18,740 |
Tags: implementation
Correct Solution:
```
n = int(input())
arr = list(map(int, input().split()))
size = 1_000_05
freq = [None] * size
freq2 = [None] * size
index = 0
for element in arr:
freq[element] = index + 1
freq2[element] = n - index
index = index + 1
m = int(input())
first = second = 0
queries = list(map(int, input().split()))
for query in queries:
first = first + freq[query]
second = second + freq2[query]
print(first, end =' ')
print(second, end ='')
``` | output | 1 | 9,370 | 12 | 18,741 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Once at a team training Vasya, Petya and Sasha got a problem on implementing linear search in an array.
According to the boys, linear search works as follows. The array elements in a pre-selected order are in turn compared with the number that you need to find. Once you find the array element that is equal to the required one, the search ends. The efficiency of the algorithm is the number of performed comparisons. The fewer comparisons the linear search has made, the more effective it is.
Vasya believes that a linear search would work better if it sequentially iterates through the elements, starting with the 1-st one (in this problem we consider the elements of the array indexed from 1 to n) and ending with the n-th one. And Petya says that Vasya is wrong: the search will need less comparisons if it sequentially iterates the elements starting from the n-th and ending with the 1-st one. Sasha argues that the two approaches are equivalent.
To finally begin the task, the teammates decided to settle the debate and compare the two approaches on an example. For this, they took an array that is a permutation of integers from 1 to n, and generated m queries of the form: find element with value bi in the array. They want to calculate for both approaches how many comparisons in total the linear search will need to respond to all queries. If the first search needs fewer comparisons, then the winner of the dispute is Vasya. If the second one does, then the winner is Petya. If both approaches make the same number of comparisons, then Sasha's got the upper hand.
But the problem is, linear search is too slow. That's why the boys aren't going to find out who is right before the end of the training, unless you come in here. Help them to determine who will win the dispute.
Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of elements in the array. The second line contains n distinct space-separated integers a1, a2, ..., an (1 ≤ ai ≤ n) — the elements of array.
The third line contains integer m (1 ≤ m ≤ 105) — the number of queries. The last line contains m space-separated integers b1, b2, ..., bm (1 ≤ bi ≤ n) — the search queries. Note that the queries can repeat.
Output
Print two integers, showing how many comparisons Vasya's approach needs and how many comparisons Petya's approach needs. Separate the numbers by spaces.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use cin, cout streams or the %I64d specifier.
Examples
Input
2
1 2
1
1
Output
1 2
Input
2
2 1
1
1
Output
2 1
Input
3
3 1 2
3
1 2 3
Output
6 6
Note
In the first sample Vasya's approach will make one comparison (it starts with the 1-st element and immediately finds the required number), and Petya's approach makes two comparisons (first he compares with the 2-nd array element, doesn't find the search item and compares with the 1-st element).
In the second sample, on the contrary, Vasya's approach will need two comparisons (first with 1-st element, and then with the 2-nd), and Petya's approach will find the required value in one comparison (the first comparison with the 2-nd element). | instruction | 0 | 9,371 | 12 | 18,742 |
Tags: implementation
Correct Solution:
```
'''n = int(input())
arr = list(map(int, input().split()))
nn = int(input())
arr3 = list(map(int, input().split()))
cv = 0
cp = 0
for kk in arr3:
xxx = arr.index(kk)
cv += xxx + 1
cp += n - xxx
print(cv, cp)'''
n = int(input())
a = [int(x) for x in input().split()]
m = int(input())
b = [int(x) for x in input().split()]
c = 0
d = 0
w = {}
for i in range(n):
w[a[i]] = i
for j in b:
q = w[j]
c += (q+1)
d += (n-q)
print(c, d)
#print(w)
``` | output | 1 | 9,371 | 12 | 18,743 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer m.
Let M = 2m - 1.
You are also given a set of n integers denoted as the set T. The integers will be provided in base 2 as n binary strings of length m.
A set of integers S is called "good" if the following hold.
1. If <image>, then <image>.
2. If <image>, then <image>
3. <image>
4. All elements of S are less than or equal to M.
Here, <image> and <image> refer to the bitwise XOR and bitwise AND operators, respectively.
Count the number of good sets S, modulo 109 + 7.
Input
The first line will contain two integers m and n (1 ≤ m ≤ 1 000, 1 ≤ n ≤ min(2m, 50)).
The next n lines will contain the elements of T. Each line will contain exactly m zeros and ones. Elements of T will be distinct.
Output
Print a single integer, the number of good sets modulo 109 + 7.
Examples
Input
5 3
11010
00101
11000
Output
4
Input
30 2
010101010101010010101010101010
110110110110110011011011011011
Output
860616440
Note
An example of a valid set S is {00000, 00101, 00010, 00111, 11000, 11010, 11101, 11111}. | instruction | 0 | 9,632 | 12 | 19,264 |
Tags: bitmasks, combinatorics, dp, math
Correct Solution:
```
#Problem Set E: Collaborated with no one
from collections import defaultdict
mod_v = 1000000007
temp_arr = [[1]]
for i in range(1,1010):
a = [1]
for k in range(1,i):
a.append((temp_arr[i-1][k-1]+temp_arr[i-1][k]) % mod_v)
a.append(1)
temp_arr.append(a)
ans_arr = [1]
for i in range(1,1010):
res = 0
for j in range(i):
res += ans_arr[j] * temp_arr[i-1][j]
res %= mod_v
ans_arr.append(res)
n_list=list(map(int, input().split()))
n = n_list[0]
lines = n_list[1]
new_list = [0 for __ in range(n)]
for i in range(lines):
input1 = list(map(int, input()))
for k in range(n):
new_list[k] |= input1[k] << i
default_d = defaultdict(int)
for k in new_list:
default_d[k] += 1
answer = 1
for n in default_d.values():
answer = answer * ans_arr[n] % mod_v
print(answer)
``` | output | 1 | 9,632 | 12 | 19,265 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. Beauty of array is the maximum sum of some consecutive subarray of this array (this subarray may be empty). For example, the beauty of the array [10, -5, 10, -4, 1] is 15, and the beauty of the array [-3, -5, -1] is 0.
You may choose at most one consecutive subarray of a and multiply all values contained in this subarray by x. You want to maximize the beauty of array after applying at most one such operation.
Input
The first line contains two integers n and x (1 ≤ n ≤ 3 ⋅ 10^5, -100 ≤ x ≤ 100) — the length of array a and the integer x respectively.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the array a.
Output
Print one integer — the maximum possible beauty of array a after multiplying all values belonging to some consecutive subarray x.
Examples
Input
5 -2
-3 8 -2 1 -6
Output
22
Input
12 -3
1 3 3 7 1 3 3 7 1 3 3 7
Output
42
Input
5 10
-1 -2 -3 -4 -5
Output
0
Note
In the first test case we need to multiply the subarray [-2, 1, -6], and the array becomes [-3, 8, 4, -2, 12] with beauty 22 ([-3, 8, 4, -2, 12]).
In the second test case we don't need to multiply any subarray at all.
In the third test case no matter which subarray we multiply, the beauty of array will be equal to 0. | instruction | 0 | 9,972 | 12 | 19,944 |
Tags: brute force, data structures, divide and conquer, dp, greedy
Correct Solution:
```
def go():
n, x = map(int, input().split(' '))
a = [int(i) for i in input().split(' ')]
cur1 = cur2 = cur = maximum = 0
for i in range(len(a)):
cur1 = max(0, cur1 + a[i])
cur2 = max(cur1, cur2 + x * a[i])
cur = max(cur + a[i], cur2)
maximum = max(maximum, cur)
return maximum
print(go())
``` | output | 1 | 9,972 | 12 | 19,945 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. Beauty of array is the maximum sum of some consecutive subarray of this array (this subarray may be empty). For example, the beauty of the array [10, -5, 10, -4, 1] is 15, and the beauty of the array [-3, -5, -1] is 0.
You may choose at most one consecutive subarray of a and multiply all values contained in this subarray by x. You want to maximize the beauty of array after applying at most one such operation.
Input
The first line contains two integers n and x (1 ≤ n ≤ 3 ⋅ 10^5, -100 ≤ x ≤ 100) — the length of array a and the integer x respectively.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the array a.
Output
Print one integer — the maximum possible beauty of array a after multiplying all values belonging to some consecutive subarray x.
Examples
Input
5 -2
-3 8 -2 1 -6
Output
22
Input
12 -3
1 3 3 7 1 3 3 7 1 3 3 7
Output
42
Input
5 10
-1 -2 -3 -4 -5
Output
0
Note
In the first test case we need to multiply the subarray [-2, 1, -6], and the array becomes [-3, 8, 4, -2, 12] with beauty 22 ([-3, 8, 4, -2, 12]).
In the second test case we don't need to multiply any subarray at all.
In the third test case no matter which subarray we multiply, the beauty of array will be equal to 0. | instruction | 0 | 9,973 | 12 | 19,946 |
Tags: brute force, data structures, divide and conquer, dp, greedy
Correct Solution:
```
import sys,math,itertools
from collections import Counter,deque,defaultdict
from bisect import bisect_left,bisect_right
from heapq import heappop,heappush,heapify, nlargest
from copy import deepcopy
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_1(): return list(map(lambda x:int(x)-1, sys.stdin.readline().split()))
n,X = inpl()
a = inpl()
dp = [[0]*(n+1) for _ in range(5)]
for i in range(n):
for j in range(5):
tmp = 0
if j == 1 or j == 3: tmp = a[i]
elif j == 2: tmp = a[i]*X
for k in range(j+1):
dp[j][i+1] = max(dp[j][i+1], dp[k][i]+tmp)
res = -INF
for i in range(5):
res = max(res, dp[i][-1])
print(res)
``` | output | 1 | 9,973 | 12 | 19,947 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. Beauty of array is the maximum sum of some consecutive subarray of this array (this subarray may be empty). For example, the beauty of the array [10, -5, 10, -4, 1] is 15, and the beauty of the array [-3, -5, -1] is 0.
You may choose at most one consecutive subarray of a and multiply all values contained in this subarray by x. You want to maximize the beauty of array after applying at most one such operation.
Input
The first line contains two integers n and x (1 ≤ n ≤ 3 ⋅ 10^5, -100 ≤ x ≤ 100) — the length of array a and the integer x respectively.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the array a.
Output
Print one integer — the maximum possible beauty of array a after multiplying all values belonging to some consecutive subarray x.
Examples
Input
5 -2
-3 8 -2 1 -6
Output
22
Input
12 -3
1 3 3 7 1 3 3 7 1 3 3 7
Output
42
Input
5 10
-1 -2 -3 -4 -5
Output
0
Note
In the first test case we need to multiply the subarray [-2, 1, -6], and the array becomes [-3, 8, 4, -2, 12] with beauty 22 ([-3, 8, 4, -2, 12]).
In the second test case we don't need to multiply any subarray at all.
In the third test case no matter which subarray we multiply, the beauty of array will be equal to 0. | instruction | 0 | 9,974 | 12 | 19,948 |
Tags: brute force, data structures, divide and conquer, dp, greedy
Correct Solution:
```
n, x = map(int, input().split())
a = list(map(int, input().split()))
kq=pre=mid=suf=0
for i in a:
pre=max(pre+i,0)
mid=max(mid+(i*x),pre)
suf=max(suf+i,mid)
kq = max(kq, suf)
print(kq)
``` | output | 1 | 9,974 | 12 | 19,949 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. Beauty of array is the maximum sum of some consecutive subarray of this array (this subarray may be empty). For example, the beauty of the array [10, -5, 10, -4, 1] is 15, and the beauty of the array [-3, -5, -1] is 0.
You may choose at most one consecutive subarray of a and multiply all values contained in this subarray by x. You want to maximize the beauty of array after applying at most one such operation.
Input
The first line contains two integers n and x (1 ≤ n ≤ 3 ⋅ 10^5, -100 ≤ x ≤ 100) — the length of array a and the integer x respectively.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the array a.
Output
Print one integer — the maximum possible beauty of array a after multiplying all values belonging to some consecutive subarray x.
Examples
Input
5 -2
-3 8 -2 1 -6
Output
22
Input
12 -3
1 3 3 7 1 3 3 7 1 3 3 7
Output
42
Input
5 10
-1 -2 -3 -4 -5
Output
0
Note
In the first test case we need to multiply the subarray [-2, 1, -6], and the array becomes [-3, 8, 4, -2, 12] with beauty 22 ([-3, 8, 4, -2, 12]).
In the second test case we don't need to multiply any subarray at all.
In the third test case no matter which subarray we multiply, the beauty of array will be equal to 0. | instruction | 0 | 9,975 | 12 | 19,950 |
Tags: brute force, data structures, divide and conquer, dp, greedy
Correct Solution:
```
n, x = map(int, input().split())
a = list(map(int, input().split()))
inf = - 2**64
dp = [[[inf for _ in range(3)] for _ in range(3)] for _ in range(n+1)]
dp[0][0][0] = 0
for i in range(n+1):
for j in range(3):
for k in range(3):
if k < 2:
dp[i][j][k+1] = max(dp[i][j][k+1], dp[i][j][k])
if j < 2:
dp[i][j+1][k] = max(dp[i][j+1][k], dp[i][j][k])
if i < n:
dp[i + 1][j][k] = max(dp[i + 1][j][k], dp[i][j][k] + (a[i] if j == 1 else 0) * int(x if k == 1 else 1))
print(dp[n][2][2])
``` | output | 1 | 9,975 | 12 | 19,951 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. Beauty of array is the maximum sum of some consecutive subarray of this array (this subarray may be empty). For example, the beauty of the array [10, -5, 10, -4, 1] is 15, and the beauty of the array [-3, -5, -1] is 0.
You may choose at most one consecutive subarray of a and multiply all values contained in this subarray by x. You want to maximize the beauty of array after applying at most one such operation.
Input
The first line contains two integers n and x (1 ≤ n ≤ 3 ⋅ 10^5, -100 ≤ x ≤ 100) — the length of array a and the integer x respectively.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the array a.
Output
Print one integer — the maximum possible beauty of array a after multiplying all values belonging to some consecutive subarray x.
Examples
Input
5 -2
-3 8 -2 1 -6
Output
22
Input
12 -3
1 3 3 7 1 3 3 7 1 3 3 7
Output
42
Input
5 10
-1 -2 -3 -4 -5
Output
0
Note
In the first test case we need to multiply the subarray [-2, 1, -6], and the array becomes [-3, 8, 4, -2, 12] with beauty 22 ([-3, 8, 4, -2, 12]).
In the second test case we don't need to multiply any subarray at all.
In the third test case no matter which subarray we multiply, the beauty of array will be equal to 0. | instruction | 0 | 9,976 | 12 | 19,952 |
Tags: brute force, data structures, divide and conquer, dp, greedy
Correct Solution:
```
import sys,math
from collections import defaultdict,deque
input=sys.stdin.readline
n,x=map(int,input().split())
l=list(map(int,input().split()))
dp=[[[0 for _ in range(2)] for _ in range(2)] for _ in range(len(l))]
#print(dp) #index in l,is usable or not,is in use or not
dp[0][0][0]=l[0]
dp[0][1][0]=l[0]
dp[0][1][1]=x*l[0]
ans=max(l[0],l[0]*x,0)
for i in range(1,n):
dp[i][0][0]=max(l[i],l[i]+max(dp[i-1][0][0],dp[i-1][1][1]))
dp[i][1][0]=max(l[i],l[i]+dp[i-1][1][0])
dp[i][1][1]=max(l[i]*x,l[i]*x+max(dp[i-1][1][1],dp[i-1][1][0]))
ans=max(ans,dp[i][0][0],dp[i][1][0],dp[i][1][1])
print(ans)
``` | output | 1 | 9,976 | 12 | 19,953 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. Beauty of array is the maximum sum of some consecutive subarray of this array (this subarray may be empty). For example, the beauty of the array [10, -5, 10, -4, 1] is 15, and the beauty of the array [-3, -5, -1] is 0.
You may choose at most one consecutive subarray of a and multiply all values contained in this subarray by x. You want to maximize the beauty of array after applying at most one such operation.
Input
The first line contains two integers n and x (1 ≤ n ≤ 3 ⋅ 10^5, -100 ≤ x ≤ 100) — the length of array a and the integer x respectively.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the array a.
Output
Print one integer — the maximum possible beauty of array a after multiplying all values belonging to some consecutive subarray x.
Examples
Input
5 -2
-3 8 -2 1 -6
Output
22
Input
12 -3
1 3 3 7 1 3 3 7 1 3 3 7
Output
42
Input
5 10
-1 -2 -3 -4 -5
Output
0
Note
In the first test case we need to multiply the subarray [-2, 1, -6], and the array becomes [-3, 8, 4, -2, 12] with beauty 22 ([-3, 8, 4, -2, 12]).
In the second test case we don't need to multiply any subarray at all.
In the third test case no matter which subarray we multiply, the beauty of array will be equal to 0. | instruction | 0 | 9,977 | 12 | 19,954 |
Tags: brute force, data structures, divide and conquer, dp, greedy
Correct Solution:
```
n, x = map(int, input().split())
a = list(map(int, input().split()))
dp = [[0 for _ in range(n + 1)] for _ in range(3)]
ans = 0
for i in range(n):
dp[0][i + 1] = max(0, dp[0][i] + a[i])
dp[1][i + 1] = max(dp[0][i], dp[1][i]) + a[i] * x
dp[2][i + 1] = max(dp[0][i], dp[1][i], dp[2][i]) + a[i]
ans = max(ans, dp[0][i + 1], dp[1][i + 1], dp[2][i + 1])
print(ans)
``` | output | 1 | 9,977 | 12 | 19,955 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. Beauty of array is the maximum sum of some consecutive subarray of this array (this subarray may be empty). For example, the beauty of the array [10, -5, 10, -4, 1] is 15, and the beauty of the array [-3, -5, -1] is 0.
You may choose at most one consecutive subarray of a and multiply all values contained in this subarray by x. You want to maximize the beauty of array after applying at most one such operation.
Input
The first line contains two integers n and x (1 ≤ n ≤ 3 ⋅ 10^5, -100 ≤ x ≤ 100) — the length of array a and the integer x respectively.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the array a.
Output
Print one integer — the maximum possible beauty of array a after multiplying all values belonging to some consecutive subarray x.
Examples
Input
5 -2
-3 8 -2 1 -6
Output
22
Input
12 -3
1 3 3 7 1 3 3 7 1 3 3 7
Output
42
Input
5 10
-1 -2 -3 -4 -5
Output
0
Note
In the first test case we need to multiply the subarray [-2, 1, -6], and the array becomes [-3, 8, 4, -2, 12] with beauty 22 ([-3, 8, 4, -2, 12]).
In the second test case we don't need to multiply any subarray at all.
In the third test case no matter which subarray we multiply, the beauty of array will be equal to 0. | instruction | 0 | 9,978 | 12 | 19,956 |
Tags: brute force, data structures, divide and conquer, dp, greedy
Correct Solution:
```
from math import *
from collections import *
import sys
sys.setrecursionlimit(10**9)
n,x = map(int,input().split())
a = list(map(int,input().split()))
l = [0 for i in range(n+1)]
r = [0 for i in range(n+1)]
pre = [a[0]]
for i in range(1,n):
pre.append(pre[-1]+a[i])
max_ending_here = 0
max_so_far = 0
for i in range(n):
max_ending_here += a[i]
if(max_ending_here < 0):
max_ending_here = 0
l[i] = max_ending_here
max_ending_here = 0
max_so_far = 0
for i in range(n-1,-1,-1):
max_ending_here += a[i]
if(max_ending_here < 0):
max_ending_here = 0
r[i] = max_ending_here
rans = lans = 0
for i in range(n):
rans = max(rans,r[i+1]+pre[i]*x+lans)
rans = max(rans,l[i])
lans = max(lans,l[i]-pre[i]*x)
print(rans)
``` | output | 1 | 9,978 | 12 | 19,957 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. Beauty of array is the maximum sum of some consecutive subarray of this array (this subarray may be empty). For example, the beauty of the array [10, -5, 10, -4, 1] is 15, and the beauty of the array [-3, -5, -1] is 0.
You may choose at most one consecutive subarray of a and multiply all values contained in this subarray by x. You want to maximize the beauty of array after applying at most one such operation.
Input
The first line contains two integers n and x (1 ≤ n ≤ 3 ⋅ 10^5, -100 ≤ x ≤ 100) — the length of array a and the integer x respectively.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the array a.
Output
Print one integer — the maximum possible beauty of array a after multiplying all values belonging to some consecutive subarray x.
Examples
Input
5 -2
-3 8 -2 1 -6
Output
22
Input
12 -3
1 3 3 7 1 3 3 7 1 3 3 7
Output
42
Input
5 10
-1 -2 -3 -4 -5
Output
0
Note
In the first test case we need to multiply the subarray [-2, 1, -6], and the array becomes [-3, 8, 4, -2, 12] with beauty 22 ([-3, 8, 4, -2, 12]).
In the second test case we don't need to multiply any subarray at all.
In the third test case no matter which subarray we multiply, the beauty of array will be equal to 0. | instruction | 0 | 9,979 | 12 | 19,958 |
Tags: brute force, data structures, divide and conquer, dp, greedy
Correct Solution:
```
n,x=map(int,input().split())
a=list(map(int,input().split()))
b=[[0]*3 for i in range(n)]
m=0
for i in range(n):
if i==0:
b[i][0]=max(a[i],0)
b[i][1]=max(x*a[i],b[i][0])
b[i][2]=max(a[i],b[i][1])
else:
b[i][0]=max(b[i-1][0]+a[i],0)
b[i][1]=max(b[i-1][1]+x*a[i],b[i][0])
b[i][2]=max(b[i-1][2]+a[i],b[i][1])
if m<b[i][2]:
m=b[i][2]
print(m)
``` | output | 1 | 9,979 | 12 | 19,959 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. Beauty of array is the maximum sum of some consecutive subarray of this array (this subarray may be empty). For example, the beauty of the array [10, -5, 10, -4, 1] is 15, and the beauty of the array [-3, -5, -1] is 0.
You may choose at most one consecutive subarray of a and multiply all values contained in this subarray by x. You want to maximize the beauty of array after applying at most one such operation.
Input
The first line contains two integers n and x (1 ≤ n ≤ 3 ⋅ 10^5, -100 ≤ x ≤ 100) — the length of array a and the integer x respectively.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the array a.
Output
Print one integer — the maximum possible beauty of array a after multiplying all values belonging to some consecutive subarray x.
Examples
Input
5 -2
-3 8 -2 1 -6
Output
22
Input
12 -3
1 3 3 7 1 3 3 7 1 3 3 7
Output
42
Input
5 10
-1 -2 -3 -4 -5
Output
0
Note
In the first test case we need to multiply the subarray [-2, 1, -6], and the array becomes [-3, 8, 4, -2, 12] with beauty 22 ([-3, 8, 4, -2, 12]).
In the second test case we don't need to multiply any subarray at all.
In the third test case no matter which subarray we multiply, the beauty of array will be equal to 0.
Submitted Solution:
```
n,x=map(int,input().split())
a=list(map(int,input().split()))
dp=[[0 for i in range(3)] for j in range(n+1)]
a=[0]+a
#3 dps lagenge >:|)
res=0
for i in range(1,n+1):
dp[i][0]= max(0,dp[i-1][0]+a[i],a[i]) #current le ya na le
dp[i][1]=max(0,dp[i-1][0]+a[i]*x,dp[i-1][1]+a[i]*x,a[i]*x) #check and see which gives the best ans
dp[i][2]= max(0,a[i],dp[i-1][0]+a[i],dp[i-1][1]+a[i],dp[i-1][2]+a[i]) #main dp
res=max(res,dp[i][0],dp[i][1],dp[i][2])
#print(dp)
print(res)
``` | instruction | 0 | 9,980 | 12 | 19,960 |
Yes | output | 1 | 9,980 | 12 | 19,961 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. Beauty of array is the maximum sum of some consecutive subarray of this array (this subarray may be empty). For example, the beauty of the array [10, -5, 10, -4, 1] is 15, and the beauty of the array [-3, -5, -1] is 0.
You may choose at most one consecutive subarray of a and multiply all values contained in this subarray by x. You want to maximize the beauty of array after applying at most one such operation.
Input
The first line contains two integers n and x (1 ≤ n ≤ 3 ⋅ 10^5, -100 ≤ x ≤ 100) — the length of array a and the integer x respectively.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the array a.
Output
Print one integer — the maximum possible beauty of array a after multiplying all values belonging to some consecutive subarray x.
Examples
Input
5 -2
-3 8 -2 1 -6
Output
22
Input
12 -3
1 3 3 7 1 3 3 7 1 3 3 7
Output
42
Input
5 10
-1 -2 -3 -4 -5
Output
0
Note
In the first test case we need to multiply the subarray [-2, 1, -6], and the array becomes [-3, 8, 4, -2, 12] with beauty 22 ([-3, 8, 4, -2, 12]).
In the second test case we don't need to multiply any subarray at all.
In the third test case no matter which subarray we multiply, the beauty of array will be equal to 0.
Submitted Solution:
```
n,k = map(int,input().split())
l = [*map(int,input().split())]
dp = [[0] * 3 for i in range(n)]
for i in range(n):
for j in range(3):
dp[i][j] = float("inf")
ans = 0
for i in range(n):
if(i == 0):
dp[i][0] = max(l[i],0)
dp[i][1] = max(l[i] * k, 0)
dp[i][2] = max(l[i], 0)
else:
dp[i][0] = max(dp[i - 1][0] + l[i], 0)
dp[i][1] = max(max(dp[i - 1][0],dp[i -1][1]) + l[i] * k, 0)
dp[i][2] = max(max(dp[i - 1][1],dp[i - 1][2]) + l[i], 0)
ans = max(ans, max(dp[i][0],dp[i][1],dp[i][2]))
print(ans)
``` | instruction | 0 | 9,981 | 12 | 19,962 |
Yes | output | 1 | 9,981 | 12 | 19,963 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. Beauty of array is the maximum sum of some consecutive subarray of this array (this subarray may be empty). For example, the beauty of the array [10, -5, 10, -4, 1] is 15, and the beauty of the array [-3, -5, -1] is 0.
You may choose at most one consecutive subarray of a and multiply all values contained in this subarray by x. You want to maximize the beauty of array after applying at most one such operation.
Input
The first line contains two integers n and x (1 ≤ n ≤ 3 ⋅ 10^5, -100 ≤ x ≤ 100) — the length of array a and the integer x respectively.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the array a.
Output
Print one integer — the maximum possible beauty of array a after multiplying all values belonging to some consecutive subarray x.
Examples
Input
5 -2
-3 8 -2 1 -6
Output
22
Input
12 -3
1 3 3 7 1 3 3 7 1 3 3 7
Output
42
Input
5 10
-1 -2 -3 -4 -5
Output
0
Note
In the first test case we need to multiply the subarray [-2, 1, -6], and the array becomes [-3, 8, 4, -2, 12] with beauty 22 ([-3, 8, 4, -2, 12]).
In the second test case we don't need to multiply any subarray at all.
In the third test case no matter which subarray we multiply, the beauty of array will be equal to 0.
Submitted Solution:
```
import sys
import math as mt
import bisect
#input=sys.stdin.readline
#t=int(input())
t=1
def solve():
suma=dp[0][3]
for i in range(1,n):
dp[i][0]=0
dp[i][1]=l[i]+dp[i-1][1]
dp[i][2]=x*l[i]+dp[i-1][2]
dp[i][3]=l[i]+dp[i-1][3]
for j in range(1,4):
dp[i][j]=max(dp[i][j-1],dp[i][j])
suma=max(dp[i][3],suma)
return suma
for _ in range(t):
#n=int(input())
n,x=map(int,input().split())
#x,y,k=map(int,input().split())
#n,h=(map(int,input().split()))
l=list(map(int,input().split()))
dp=[[0 for j in range(4)] for i in range(n)]
dp[0][0]=0
dp[0][1]=l[0]
dp[0][2]=x*l[0]
dp[0][3]=l[0]
for j in range(1,4):
dp[0][j]=max(dp[0][j],dp[0][j-1])
print(solve())
``` | instruction | 0 | 9,982 | 12 | 19,964 |
Yes | output | 1 | 9,982 | 12 | 19,965 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. Beauty of array is the maximum sum of some consecutive subarray of this array (this subarray may be empty). For example, the beauty of the array [10, -5, 10, -4, 1] is 15, and the beauty of the array [-3, -5, -1] is 0.
You may choose at most one consecutive subarray of a and multiply all values contained in this subarray by x. You want to maximize the beauty of array after applying at most one such operation.
Input
The first line contains two integers n and x (1 ≤ n ≤ 3 ⋅ 10^5, -100 ≤ x ≤ 100) — the length of array a and the integer x respectively.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the array a.
Output
Print one integer — the maximum possible beauty of array a after multiplying all values belonging to some consecutive subarray x.
Examples
Input
5 -2
-3 8 -2 1 -6
Output
22
Input
12 -3
1 3 3 7 1 3 3 7 1 3 3 7
Output
42
Input
5 10
-1 -2 -3 -4 -5
Output
0
Note
In the first test case we need to multiply the subarray [-2, 1, -6], and the array becomes [-3, 8, 4, -2, 12] with beauty 22 ([-3, 8, 4, -2, 12]).
In the second test case we don't need to multiply any subarray at all.
In the third test case no matter which subarray we multiply, the beauty of array will be equal to 0.
Submitted Solution:
```
n, x = map(int, input().split())
arr = [int(x) for x in input().split()]
dp = [[0 for _ in range(n)] for _ in range(3)]
dp[0][0] = max(arr[0], 0)
dp[1][0] = max(arr[0] * x, 0)
dp[2][0] = max(arr[0], 0)
answer = max(dp[0][0], dp[1][0], dp[2][0])
for i in range(1, n):
dp[0][i] = max(dp[0][i - 1] + arr[i], arr[i], 0)
dp[1][i] = max(dp[0][i - 1] + arr[i] * x, dp[1][i - 1] + arr[i] * x, arr[i] * x, 0)
dp[2][i] = max(dp[1][i - 1] + arr[i], dp[2][i - 1] + arr[i], arr[i], 0)
answer = max(answer, dp[0][i], dp[1][i], dp[2][i])
print(answer)
``` | instruction | 0 | 9,983 | 12 | 19,966 |
Yes | output | 1 | 9,983 | 12 | 19,967 |
Evaluate the correctness of the submitted Python 2 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. Beauty of array is the maximum sum of some consecutive subarray of this array (this subarray may be empty). For example, the beauty of the array [10, -5, 10, -4, 1] is 15, and the beauty of the array [-3, -5, -1] is 0.
You may choose at most one consecutive subarray of a and multiply all values contained in this subarray by x. You want to maximize the beauty of array after applying at most one such operation.
Input
The first line contains two integers n and x (1 ≤ n ≤ 3 ⋅ 10^5, -100 ≤ x ≤ 100) — the length of array a and the integer x respectively.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the array a.
Output
Print one integer — the maximum possible beauty of array a after multiplying all values belonging to some consecutive subarray x.
Examples
Input
5 -2
-3 8 -2 1 -6
Output
22
Input
12 -3
1 3 3 7 1 3 3 7 1 3 3 7
Output
42
Input
5 10
-1 -2 -3 -4 -5
Output
0
Note
In the first test case we need to multiply the subarray [-2, 1, -6], and the array becomes [-3, 8, 4, -2, 12] with beauty 22 ([-3, 8, 4, -2, 12]).
In the second test case we don't need to multiply any subarray at all.
In the third test case no matter which subarray we multiply, the beauty of array will be equal to 0.
Submitted Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
def in_num():
return int(raw_input())
def in_arr():
return map(int,raw_input().split())
def pr_num(n):
stdout.write(str(n)+'\n')
def pr_arr(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+
n,x=in_arr()
l=in_arr()
dp=[[[-1000000000000,-1000000000000,-1000000000000] for i in range(3)] for j in range(n+1)]
dp[0][0][0]=0
for i in range(n+1):
for j in range(3):
for k in range(3):
if k<2:
dp[i][j][k+1]=max(dp[i][j][k+1], dp[i][j][k])
if j<2:
dp[i][j+1][k]=max(dp[i][j+1][k],dp[i][j][k])
if i<n and j==1:
if k==1:
dp[i+1][j][k]=max(dp[i+1][j][k],dp[i][j][k]+(l[i]*x))
else:
dp[i+1][j][k]=max(dp[i+1][j][k],dp[i][j][k]+(l[i]))
elif i<n:
dp[i+1][j][k]=max(dp[i+1][j][k],dp[i][j][k])
pr_num(dp[n][2][2])
``` | instruction | 0 | 9,984 | 12 | 19,968 |
Yes | output | 1 | 9,984 | 12 | 19,969 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. Beauty of array is the maximum sum of some consecutive subarray of this array (this subarray may be empty). For example, the beauty of the array [10, -5, 10, -4, 1] is 15, and the beauty of the array [-3, -5, -1] is 0.
You may choose at most one consecutive subarray of a and multiply all values contained in this subarray by x. You want to maximize the beauty of array after applying at most one such operation.
Input
The first line contains two integers n and x (1 ≤ n ≤ 3 ⋅ 10^5, -100 ≤ x ≤ 100) — the length of array a and the integer x respectively.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the array a.
Output
Print one integer — the maximum possible beauty of array a after multiplying all values belonging to some consecutive subarray x.
Examples
Input
5 -2
-3 8 -2 1 -6
Output
22
Input
12 -3
1 3 3 7 1 3 3 7 1 3 3 7
Output
42
Input
5 10
-1 -2 -3 -4 -5
Output
0
Note
In the first test case we need to multiply the subarray [-2, 1, -6], and the array becomes [-3, 8, 4, -2, 12] with beauty 22 ([-3, 8, 4, -2, 12]).
In the second test case we don't need to multiply any subarray at all.
In the third test case no matter which subarray we multiply, the beauty of array will be equal to 0.
Submitted Solution:
```
n, m = map(int, input().split())
dp = [0]*(n+1)
nums = list(map(int, input().split()))
dp[0] = max(nums[0],0)
for i in range(1,n):
dp[i] = max(nums[i]+dp[i-1], nums[i])
rdp = [0]*(n+1)
for i in range(n-1,-1,-1):
rdp[i] = min(nums[i]+rdp[i+1], nums[i])
if m > 0:
print(max(dp)*m)
else:
ans = 0
for i in range(n+1):
if i == 0:
ans = max(rdp[i]*m, ans)
elif i == n:
ans = max(dp[i-1], ans)
else:
ans = max(dp[i-1]+rdp[i]*m, ans)
print(ans)
``` | instruction | 0 | 9,985 | 12 | 19,970 |
No | output | 1 | 9,985 | 12 | 19,971 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. Beauty of array is the maximum sum of some consecutive subarray of this array (this subarray may be empty). For example, the beauty of the array [10, -5, 10, -4, 1] is 15, and the beauty of the array [-3, -5, -1] is 0.
You may choose at most one consecutive subarray of a and multiply all values contained in this subarray by x. You want to maximize the beauty of array after applying at most one such operation.
Input
The first line contains two integers n and x (1 ≤ n ≤ 3 ⋅ 10^5, -100 ≤ x ≤ 100) — the length of array a and the integer x respectively.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the array a.
Output
Print one integer — the maximum possible beauty of array a after multiplying all values belonging to some consecutive subarray x.
Examples
Input
5 -2
-3 8 -2 1 -6
Output
22
Input
12 -3
1 3 3 7 1 3 3 7 1 3 3 7
Output
42
Input
5 10
-1 -2 -3 -4 -5
Output
0
Note
In the first test case we need to multiply the subarray [-2, 1, -6], and the array becomes [-3, 8, 4, -2, 12] with beauty 22 ([-3, 8, 4, -2, 12]).
In the second test case we don't need to multiply any subarray at all.
In the third test case no matter which subarray we multiply, the beauty of array will be equal to 0.
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Mon Apr 29 11:12:46 2019
@author: John Nguyen
"""
import random
def findmax(a):
max_so_far = 0
max_ending_here = 0
k = 0
j = 0
for i in range(0, len(a)):
max_ending_here += a[i]
if max_ending_here <0:
max_ending_here = 0
k = i
elif max_ending_here > max_so_far:
max_so_far = max_ending_here
j = i
return max_so_far, [k,j]
def findmin(a):
min_so_far = 0
min_ending_here = 0
k = 0
j = 0
for i in range(0,len(a)):
min_ending_here += a[i]
if min_ending_here > 0:
min_ending_here = 0
k = i
elif min_ending_here < min_so_far:
min_so_far = min_ending_here
j = i
return min_so_far, [k,j]
n, x = input().split()
n = int(n)
x = int(x)
a = input().split()
for i in range(0,n):
a[i] = int(a[i])
max_value, max_index = findmax(a)
min_value, min_index = findmin(a)
if max_value> 0 and x >0:
print(max_value*x)
elif min_value < 0 and x < 0:
i,j = min_index
subsets = a[i+1:j+1]
for k in range(0, len(subsets)):
subsets[k] = subsets[k]*x
a[i+1:j+1] = subsets
new_max = findmax(a)
if new_max[0] > max_value:
print(new_max[0])
else:
print(max_value)
else:
print(max_value)
``` | instruction | 0 | 9,986 | 12 | 19,972 |
No | output | 1 | 9,986 | 12 | 19,973 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. Beauty of array is the maximum sum of some consecutive subarray of this array (this subarray may be empty). For example, the beauty of the array [10, -5, 10, -4, 1] is 15, and the beauty of the array [-3, -5, -1] is 0.
You may choose at most one consecutive subarray of a and multiply all values contained in this subarray by x. You want to maximize the beauty of array after applying at most one such operation.
Input
The first line contains two integers n and x (1 ≤ n ≤ 3 ⋅ 10^5, -100 ≤ x ≤ 100) — the length of array a and the integer x respectively.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the array a.
Output
Print one integer — the maximum possible beauty of array a after multiplying all values belonging to some consecutive subarray x.
Examples
Input
5 -2
-3 8 -2 1 -6
Output
22
Input
12 -3
1 3 3 7 1 3 3 7 1 3 3 7
Output
42
Input
5 10
-1 -2 -3 -4 -5
Output
0
Note
In the first test case we need to multiply the subarray [-2, 1, -6], and the array becomes [-3, 8, 4, -2, 12] with beauty 22 ([-3, 8, 4, -2, 12]).
In the second test case we don't need to multiply any subarray at all.
In the third test case no matter which subarray we multiply, the beauty of array will be equal to 0.
Submitted Solution:
```
n,x=map(int, input().split())
A=list(map(int,input().split()))
DP=[[0]*3 for _ in range(n+1)]
ans=0
for i in range(1,n+1):
DP[i][0]=max(DP[i-1][0]+A[i-1],A[i-1])
DP[i][1]=max(DP[i-1][0]+A[i-1]*x,DP[i-1][1]+A[i-1]*x,A[i-1]*x)
DP[i][2]=max(DP[i-1][1]+A[i-1]*x,DP[i-1][2]+A[i-1]*x,A[i-1])
ans=max(ans,max(DP[i]))
print(ans)
``` | instruction | 0 | 9,987 | 12 | 19,974 |
No | output | 1 | 9,987 | 12 | 19,975 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. Beauty of array is the maximum sum of some consecutive subarray of this array (this subarray may be empty). For example, the beauty of the array [10, -5, 10, -4, 1] is 15, and the beauty of the array [-3, -5, -1] is 0.
You may choose at most one consecutive subarray of a and multiply all values contained in this subarray by x. You want to maximize the beauty of array after applying at most one such operation.
Input
The first line contains two integers n and x (1 ≤ n ≤ 3 ⋅ 10^5, -100 ≤ x ≤ 100) — the length of array a and the integer x respectively.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the array a.
Output
Print one integer — the maximum possible beauty of array a after multiplying all values belonging to some consecutive subarray x.
Examples
Input
5 -2
-3 8 -2 1 -6
Output
22
Input
12 -3
1 3 3 7 1 3 3 7 1 3 3 7
Output
42
Input
5 10
-1 -2 -3 -4 -5
Output
0
Note
In the first test case we need to multiply the subarray [-2, 1, -6], and the array becomes [-3, 8, 4, -2, 12] with beauty 22 ([-3, 8, 4, -2, 12]).
In the second test case we don't need to multiply any subarray at all.
In the third test case no matter which subarray we multiply, the beauty of array will be equal to 0.
Submitted Solution:
```
from sys import stdin, stdout
from math import gcd
nmbr = lambda : int(input())
lst = lambda : list(map(int, input().split()))
for _ in range(1):#nmbr()):
n,x=lst()
a=lst()
dppos=[i for i in range(n)]
dp=[a[i] for i in range(n)]
pre=[0]*n
pre[0]=a[0]
for i in range(1,n):
pre[i]=max(a[i],pre[i-1]+a[i])
suf=[0]*n
suf[n-1]=a[n-1]
for i in range(n-2,-1,-1):
suf[i]=max(a[i],a[i]+suf[i+1])
for i in range(1,n):
if dp[i-1]+a[i]>=a[i]:
dp[i]=a[i]+dp[i-1]
dppos[i]=dppos[i-1]
else:
dppos[i]=i
dp[i]=a[i]
# print(dp)
# print(dppos)
ans=max(0,max(pre))
for i in range(n):
sm=dp[i]
leftsm=rightsm=0
if dppos[i]-1>=0:leftsm=pre[dppos[i]-1]
if i+1<n:rightsm=suf[i+1]
ans=max(ans, dp[i]*x+leftsm+rightsm)
# print(ans)
dppos=[i for i in range(n)]
dp=[a[i] for i in range(n)]
for i in range(1,n):
if dp[i-1]+a[i]<=a[i]:
dppos[i]=dppos[i-1]
dp[i]=dp[i-1]+a[i]
else:
dppos[i]=i
dp[i]=a[i]
# print(dp)
# print(dppos)
for i in range(n):
sm=dp[i]
leftsm=rightsm=0
if dppos[i]-1>=0:leftsm=pre[dppos[i]-1]
if i+1<n:rightsm=suf[i+1]
ans=max(ans, dp[i]*x+leftsm+rightsm)
# print(ans)
print(ans)
``` | instruction | 0 | 9,988 | 12 | 19,976 |
No | output | 1 | 9,988 | 12 | 19,977 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers a and b. You can perform a sequence of operations: during the first operation you choose one of these numbers and increase it by 1; during the second operation you choose one of these numbers and increase it by 2, and so on. You choose the number of these operations yourself.
For example, if a = 1 and b = 3, you can perform the following sequence of three operations:
1. add 1 to a, then a = 2 and b = 3;
2. add 2 to b, then a = 2 and b = 5;
3. add 3 to a, then a = 5 and b = 5.
Calculate the minimum number of operations required to make a and b equal.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The only line of each test case contains two integers a and b (1 ≤ a, b ≤ 10^9).
Output
For each test case print one integer — the minimum numbers of operations required to make a and b equal.
Example
Input
3
1 3
11 11
30 20
Output
3
0
4
Note
First test case considered in the statement.
In the second test case integers a and b are already equal, so you don't need to perform any operations.
In the third test case you have to apply the first, the second, the third and the fourth operation to b (b turns into 20 + 1 + 2 + 3 + 4 = 30). | instruction | 0 | 10,062 | 12 | 20,124 |
Tags: greedy, math
Correct Solution:
```
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
# sys.setrecursionlimit(pow(10, 6))
# sys.stdin = open("input.txt", "r")
# sys.stdout = open("output.txt", "w")
mod = pow(10, 9) + 7
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
def l(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]
for _ in range(int(data())):
a, b = sp()
diff = abs(a-b)
for i in range(100001):
temp = (i * (i + 1)) // 2
if temp >= diff and not ((temp + a + b) & 1):
out(i)
break
``` | output | 1 | 10,062 | 12 | 20,125 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers a and b. You can perform a sequence of operations: during the first operation you choose one of these numbers and increase it by 1; during the second operation you choose one of these numbers and increase it by 2, and so on. You choose the number of these operations yourself.
For example, if a = 1 and b = 3, you can perform the following sequence of three operations:
1. add 1 to a, then a = 2 and b = 3;
2. add 2 to b, then a = 2 and b = 5;
3. add 3 to a, then a = 5 and b = 5.
Calculate the minimum number of operations required to make a and b equal.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The only line of each test case contains two integers a and b (1 ≤ a, b ≤ 10^9).
Output
For each test case print one integer — the minimum numbers of operations required to make a and b equal.
Example
Input
3
1 3
11 11
30 20
Output
3
0
4
Note
First test case considered in the statement.
In the second test case integers a and b are already equal, so you don't need to perform any operations.
In the third test case you have to apply the first, the second, the third and the fourth operation to b (b turns into 20 + 1 + 2 + 3 + 4 = 30). | instruction | 0 | 10,063 | 12 | 20,126 |
Tags: greedy, math
Correct Solution:
```
import math,sys
from collections import Counter, defaultdict, deque
from sys import stdin, stdout
input = stdin.readline
lili=lambda:list(map(int,sys.stdin.readlines()))
li = lambda:list(map(int,input().split()))
#for deque append(),pop(),appendleft(),popleft(),count()
I=lambda:int(input())
S=lambda:input().strip()
t=I()
for i in range(0,t):
a,b=li()
d=abs(a-b)
s=0
i=1
ans=0
while(s<d):
s=s+i
i+=1
ans+=1
if(s==d):
print(ans)
else:
while((d-s)%2):
s=s+i
i+=1
print(i-1)
``` | output | 1 | 10,063 | 12 | 20,127 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers a and b. You can perform a sequence of operations: during the first operation you choose one of these numbers and increase it by 1; during the second operation you choose one of these numbers and increase it by 2, and so on. You choose the number of these operations yourself.
For example, if a = 1 and b = 3, you can perform the following sequence of three operations:
1. add 1 to a, then a = 2 and b = 3;
2. add 2 to b, then a = 2 and b = 5;
3. add 3 to a, then a = 5 and b = 5.
Calculate the minimum number of operations required to make a and b equal.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The only line of each test case contains two integers a and b (1 ≤ a, b ≤ 10^9).
Output
For each test case print one integer — the minimum numbers of operations required to make a and b equal.
Example
Input
3
1 3
11 11
30 20
Output
3
0
4
Note
First test case considered in the statement.
In the second test case integers a and b are already equal, so you don't need to perform any operations.
In the third test case you have to apply the first, the second, the third and the fourth operation to b (b turns into 20 + 1 + 2 + 3 + 4 = 30). | instruction | 0 | 10,066 | 12 | 20,132 |
Tags: greedy, math
Correct Solution:
```
import sys
input = sys.stdin.readline
t=int(input())
NLIST=[N*(N+1)//2 for N in range(10**5)]
import bisect
for test in range(t):
a,b=map(int,input().split())
x=abs(b-a)
N=bisect.bisect_left(NLIST,x)
#print(x,N)
while x%2!=((N+1)//2)%2:
N+=1
print(N)
``` | output | 1 | 10,066 | 12 | 20,133 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of positive integers a = [a_0, a_1, ..., a_{n - 1}] (n ≥ 2).
In one step, the array a is replaced with another array of length n, in which each element is the [greatest common divisor (GCD)](http://tiny.cc/tuy9uz) of two neighboring elements (the element itself and its right neighbor; consider that the right neighbor of the (n - 1)-th element is the 0-th element).
Formally speaking, a new array b = [b_0, b_1, ..., b_{n - 1}] is being built from array a = [a_0, a_1, ..., a_{n - 1}] such that b_i = \gcd(a_i, a_{(i + 1) mod n}), where \gcd(x, y) is the greatest common divisor of x and y, and x mod y is the remainder of x dividing by y. In one step the array b is built and then the array a is replaced with b (that is, the assignment a := b is taking place).
For example, if a = [16, 24, 10, 5] then b = [\gcd(16, 24), \gcd(24, 10), \gcd(10, 5), \gcd(5, 16)] = [8, 2, 5, 1]. Thus, after one step the array a = [16, 24, 10, 5] will be equal to [8, 2, 5, 1].
For a given array a, find the minimum number of steps after which all values a_i become equal (that is, a_0 = a_1 = ... = a_{n - 1}). If the original array a consists of identical elements then consider the number of steps is equal to 0.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
Each test case contains two lines. The first line contains an integer n (2 ≤ n ≤ 2 ⋅ 10^5) — length of the sequence a. The second line contains n integers a_0, a_1, ..., a_{n - 1} (1 ≤ a_i ≤ 10^6).
It is guaranteed that the sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
Print t numbers — answers for each test case.
Example
Input
5
4
16 24 10 5
4
42 42 42 42
3
4 6 4
5
1 2 3 4 5
6
9 9 27 9 9 63
Output
3
0
2
1
1 | instruction | 0 | 10,207 | 12 | 20,414 |
Tags: binary search, brute force, data structures, divide and conquer, number theory, two pointers
Correct Solution:
```
from collections import defaultdict, deque, Counter
from heapq import heapify, heappop, heappush
import math
from copy import deepcopy
from itertools import combinations, permutations, product, combinations_with_replacement
from bisect import bisect_left, bisect_right
import sys
def input():
return sys.stdin.readline().rstrip()
def getN():
return int(input())
def getNM():
return map(int, input().split())
def getList():
return list(map(int, input().split()))
def getListGraph():
return list(map(lambda x:int(x) - 1, input().split()))
def getArray(intn):
return [int(input()) for i in range(intn)]
mod = 10 ** 9 + 7
MOD = 998244353
inf = float('inf')
eps = 10 ** (-10)
dy = [0, 1, 0, -1]
dx = [1, 0, -1, 0]
#############
# Main Code #
#############
# ここの設定を変えて使う
#####segfunc#####
def segfunc(x, y):
return math.gcd(x, y)
#################
#####ide_ele#####
ide_ele = 0
#################
class SegTree:
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
# gcdする
# gcd(a1, a2), gcd(a2, a3)... 輪っかになっている
# だんだんgcdが1とかにならされて行くのでは？
# 操作回数の最小を求める
# 連続部分列Kについていずれの列でもgcdが等しくなる
# gcdはモノイドだぞ セグ木使えば
T = getN()
for _ in range(T):
N = getN()
A = getList()
A += A
def f(x):
seg = SegTree(A, segfunc, ide_ele) # セグ木立てる
res = [seg.query(i, i + x) for i in range(N)]
return all([res[i] == res[0] for i in range(N)])
ok = N + 1
ng = 0
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(mid):
ok = mid
else:
ng = mid
print(ok - 1)
``` | output | 1 | 10,207 | 12 | 20,415 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of positive integers a = [a_0, a_1, ..., a_{n - 1}] (n ≥ 2).
In one step, the array a is replaced with another array of length n, in which each element is the [greatest common divisor (GCD)](http://tiny.cc/tuy9uz) of two neighboring elements (the element itself and its right neighbor; consider that the right neighbor of the (n - 1)-th element is the 0-th element).
Formally speaking, a new array b = [b_0, b_1, ..., b_{n - 1}] is being built from array a = [a_0, a_1, ..., a_{n - 1}] such that b_i = \gcd(a_i, a_{(i + 1) mod n}), where \gcd(x, y) is the greatest common divisor of x and y, and x mod y is the remainder of x dividing by y. In one step the array b is built and then the array a is replaced with b (that is, the assignment a := b is taking place).
For example, if a = [16, 24, 10, 5] then b = [\gcd(16, 24), \gcd(24, 10), \gcd(10, 5), \gcd(5, 16)] = [8, 2, 5, 1]. Thus, after one step the array a = [16, 24, 10, 5] will be equal to [8, 2, 5, 1].
For a given array a, find the minimum number of steps after which all values a_i become equal (that is, a_0 = a_1 = ... = a_{n - 1}). If the original array a consists of identical elements then consider the number of steps is equal to 0.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
Each test case contains two lines. The first line contains an integer n (2 ≤ n ≤ 2 ⋅ 10^5) — length of the sequence a. The second line contains n integers a_0, a_1, ..., a_{n - 1} (1 ≤ a_i ≤ 10^6).
It is guaranteed that the sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
Print t numbers — answers for each test case.
Example
Input
5
4
16 24 10 5
4
42 42 42 42
3
4 6 4
5
1 2 3 4 5
6
9 9 27 9 9 63
Output
3
0
2
1
1 | instruction | 0 | 10,208 | 12 | 20,416 |
Tags: binary search, brute force, data structures, divide and conquer, number theory, two pointers
Correct Solution:
```
import math
import sys
input = sys.stdin.readline
def make_tree(n):
i = 2
while True:
if i >= n * 2:
tree = [0] * i
break
else:
i *= 2
return tree
def initialization(a):
l = len(tree) // 2
for i in range(l, l + len(a)):
tree[i] = a[i - l]
for i in range(l - 1, 0, -1):
tree[i] = math.gcd(tree[2 * i], tree[2 * i + 1])
return
def update(i, x):
i += len(tree) // 2
tree[i] = x
i //= 2
while True:
if i == 0:
break
tree[i] = math.gcd(tree[2 * i], tree[2 * i + 1])
i //= 2
return
def get_gcd(s, t):
s += len(tree) // 2
t += len(tree) // 2
ans = tree[s]
while True:
if s > t:
break
if s % 2 == 0:
s //= 2
else:
ans = math.gcd(ans, tree[s])
s = (s + 1) // 2
if t % 2 == 1:
t //= 2
else:
ans = math.gcd(ans, tree[t])
t = (t - 1) // 2
return ans
def binary_search(c1, c2):
m = (c1 + c2 + 1) // 2
if abs(c1 - c2) <= 1:
return m
else:
if ok(m):
c2 = m
else:
c1 = m
return binary_search(c1, c2)
def ok(m):
g = get_gcd(0, m)
for i in range(1, n):
if get_gcd(i, m + i) ^ g:
return False
return True
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
tree = make_tree(2 * n + 1)
initialization(a + a)
ans = binary_search(-1, n)
print(ans)
``` | output | 1 | 10,208 | 12 | 20,417 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of positive integers a = [a_0, a_1, ..., a_{n - 1}] (n ≥ 2).
In one step, the array a is replaced with another array of length n, in which each element is the [greatest common divisor (GCD)](http://tiny.cc/tuy9uz) of two neighboring elements (the element itself and its right neighbor; consider that the right neighbor of the (n - 1)-th element is the 0-th element).
Formally speaking, a new array b = [b_0, b_1, ..., b_{n - 1}] is being built from array a = [a_0, a_1, ..., a_{n - 1}] such that b_i = \gcd(a_i, a_{(i + 1) mod n}), where \gcd(x, y) is the greatest common divisor of x and y, and x mod y is the remainder of x dividing by y. In one step the array b is built and then the array a is replaced with b (that is, the assignment a := b is taking place).
For example, if a = [16, 24, 10, 5] then b = [\gcd(16, 24), \gcd(24, 10), \gcd(10, 5), \gcd(5, 16)] = [8, 2, 5, 1]. Thus, after one step the array a = [16, 24, 10, 5] will be equal to [8, 2, 5, 1].
For a given array a, find the minimum number of steps after which all values a_i become equal (that is, a_0 = a_1 = ... = a_{n - 1}). If the original array a consists of identical elements then consider the number of steps is equal to 0.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
Each test case contains two lines. The first line contains an integer n (2 ≤ n ≤ 2 ⋅ 10^5) — length of the sequence a. The second line contains n integers a_0, a_1, ..., a_{n - 1} (1 ≤ a_i ≤ 10^6).
It is guaranteed that the sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
Print t numbers — answers for each test case.
Example
Input
5
4
16 24 10 5
4
42 42 42 42
3
4 6 4
5
1 2 3 4 5
6
9 9 27 9 9 63
Output
3
0
2
1
1 | instruction | 0 | 10,209 | 12 | 20,418 |
Tags: binary search, brute force, data structures, divide and conquer, number theory, two pointers
Correct Solution:
```
import sys
from functools import reduce
from math import gcd
#comment these out later
#sys.stdin = open("in.in", "r")
#sys.stdout = open("out.out", "w")
def main():
class RangeQuery:
def __init__(self, data, func=min):
self.func = func
self._data = _data = [list(data)]
i, n = 1, len(_data[0])
while 2 * i <= n:
prev = _data[-1]
_data.append([func(prev[j], prev[j + i]) for j in range(n - 2 * i + 1)])
i <<= 1
def query(self, start, stop):
"""func of data[start, stop)"""
depth = (stop - start).bit_length() - 1
return self.func(self._data[depth][start], self._data[depth][stop - (1 << depth)])
def __getitem__(self, idx):
return self._data[0][idx]
inp = [int(x) for x in sys.stdin.read().split()]; ii = 0
t = inp[ii]; ii += 1
for _ in range(t):
n = inp[ii]; ii += 1
ar = inp[ii:ii+n]; ii += n
ar = ar+ar
spt = RangeQuery(ar, gcd)
target = spt.query(0, n)
ans = 0
for i in range(n):
for l in range(ans+1, n+1):
g = spt.query(i, i+l)
if g == target:
ans = max(ans, l-1)
break
print(ans)
main()
``` | output | 1 | 10,209 | 12 | 20,419 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of positive integers a = [a_0, a_1, ..., a_{n - 1}] (n ≥ 2).
In one step, the array a is replaced with another array of length n, in which each element is the [greatest common divisor (GCD)](http://tiny.cc/tuy9uz) of two neighboring elements (the element itself and its right neighbor; consider that the right neighbor of the (n - 1)-th element is the 0-th element).
Formally speaking, a new array b = [b_0, b_1, ..., b_{n - 1}] is being built from array a = [a_0, a_1, ..., a_{n - 1}] such that b_i = \gcd(a_i, a_{(i + 1) mod n}), where \gcd(x, y) is the greatest common divisor of x and y, and x mod y is the remainder of x dividing by y. In one step the array b is built and then the array a is replaced with b (that is, the assignment a := b is taking place).
For example, if a = [16, 24, 10, 5] then b = [\gcd(16, 24), \gcd(24, 10), \gcd(10, 5), \gcd(5, 16)] = [8, 2, 5, 1]. Thus, after one step the array a = [16, 24, 10, 5] will be equal to [8, 2, 5, 1].
For a given array a, find the minimum number of steps after which all values a_i become equal (that is, a_0 = a_1 = ... = a_{n - 1}). If the original array a consists of identical elements then consider the number of steps is equal to 0.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
Each test case contains two lines. The first line contains an integer n (2 ≤ n ≤ 2 ⋅ 10^5) — length of the sequence a. The second line contains n integers a_0, a_1, ..., a_{n - 1} (1 ≤ a_i ≤ 10^6).
It is guaranteed that the sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
Print t numbers — answers for each test case.
Example
Input
5
4
16 24 10 5
4
42 42 42 42
3
4 6 4
5
1 2 3 4 5
6
9 9 27 9 9 63
Output
3
0
2
1
1 | instruction | 0 | 10,210 | 12 | 20,420 |
Tags: binary search, brute force, data structures, divide and conquer, number theory, two pointers
Correct Solution:
```
import sys,os,io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
from math import gcd
class RangeQuery:
def __init__(self, data, func=gcd):
self.func = func
self._data = _data = [list(data)]
i, n = 1, len(_data[0])
while 2 * i <= n:
prev = _data[-1]
_data.append([func(prev[j], prev[j + i]) for j in range(n - 2 * i + 1)])
i <<= 1
def query(self, start, stop):
"""func of data[start, stop)"""
depth = (stop - start).bit_length() - 1
return self.func(self._data[depth][start], self._data[depth][stop - (1 << depth)])
def __getitem__(self, idx):
return self._data[0][idx]
for _ in range (int(input())):
n = int(input())
a = [int(i) for i in input().split()]
a += a[:]
g = a[0]
for i in a:
g = gcd(i,g)
rmq = RangeQuery(a)
l = 1
h = n
ans = -1
while(l<=h):
mid = (l+h)//2
flag = 0
for i in range (n):
curr = rmq.query(i, i+mid)
if curr != g:
flag = 1
if flag:
l = mid+1
else:
ans = mid-1
h = mid-1
print(ans)
``` | output | 1 | 10,210 | 12 | 20,421 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of positive integers a = [a_0, a_1, ..., a_{n - 1}] (n ≥ 2).
In one step, the array a is replaced with another array of length n, in which each element is the [greatest common divisor (GCD)](http://tiny.cc/tuy9uz) of two neighboring elements (the element itself and its right neighbor; consider that the right neighbor of the (n - 1)-th element is the 0-th element).
Formally speaking, a new array b = [b_0, b_1, ..., b_{n - 1}] is being built from array a = [a_0, a_1, ..., a_{n - 1}] such that b_i = \gcd(a_i, a_{(i + 1) mod n}), where \gcd(x, y) is the greatest common divisor of x and y, and x mod y is the remainder of x dividing by y. In one step the array b is built and then the array a is replaced with b (that is, the assignment a := b is taking place).
For example, if a = [16, 24, 10, 5] then b = [\gcd(16, 24), \gcd(24, 10), \gcd(10, 5), \gcd(5, 16)] = [8, 2, 5, 1]. Thus, after one step the array a = [16, 24, 10, 5] will be equal to [8, 2, 5, 1].
For a given array a, find the minimum number of steps after which all values a_i become equal (that is, a_0 = a_1 = ... = a_{n - 1}). If the original array a consists of identical elements then consider the number of steps is equal to 0.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
Each test case contains two lines. The first line contains an integer n (2 ≤ n ≤ 2 ⋅ 10^5) — length of the sequence a. The second line contains n integers a_0, a_1, ..., a_{n - 1} (1 ≤ a_i ≤ 10^6).
It is guaranteed that the sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
Print t numbers — answers for each test case.
Example
Input
5
4
16 24 10 5
4
42 42 42 42
3
4 6 4
5
1 2 3 4 5
6
9 9 27 9 9 63
Output
3
0
2
1
1 | instruction | 0 | 10,211 | 12 | 20,422 |
Tags: binary search, brute force, data structures, divide and conquer, number theory, two pointers
Correct Solution:
```
import sys
from math import gcd
t = int(sys.stdin.readline())
while(t>0):
n = int(input())
a = list(map(int,sys.stdin.readline().split()))
a = a+a
m = 0
for i in range(n):
x = a[i]
y = a[i+1]
c = 0
j = i+1
while x!=y:
x = gcd(x,a[j])
y = gcd(y,a[j+1])
j += 1
c += 1
m = max(m,c)
print(m)
t-=1
``` | output | 1 | 10,211 | 12 | 20,423 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of positive integers a = [a_0, a_1, ..., a_{n - 1}] (n ≥ 2).
In one step, the array a is replaced with another array of length n, in which each element is the [greatest common divisor (GCD)](http://tiny.cc/tuy9uz) of two neighboring elements (the element itself and its right neighbor; consider that the right neighbor of the (n - 1)-th element is the 0-th element).
Formally speaking, a new array b = [b_0, b_1, ..., b_{n - 1}] is being built from array a = [a_0, a_1, ..., a_{n - 1}] such that b_i = \gcd(a_i, a_{(i + 1) mod n}), where \gcd(x, y) is the greatest common divisor of x and y, and x mod y is the remainder of x dividing by y. In one step the array b is built and then the array a is replaced with b (that is, the assignment a := b is taking place).
For example, if a = [16, 24, 10, 5] then b = [\gcd(16, 24), \gcd(24, 10), \gcd(10, 5), \gcd(5, 16)] = [8, 2, 5, 1]. Thus, after one step the array a = [16, 24, 10, 5] will be equal to [8, 2, 5, 1].
For a given array a, find the minimum number of steps after which all values a_i become equal (that is, a_0 = a_1 = ... = a_{n - 1}). If the original array a consists of identical elements then consider the number of steps is equal to 0.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
Each test case contains two lines. The first line contains an integer n (2 ≤ n ≤ 2 ⋅ 10^5) — length of the sequence a. The second line contains n integers a_0, a_1, ..., a_{n - 1} (1 ≤ a_i ≤ 10^6).
It is guaranteed that the sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
Print t numbers — answers for each test case.
Example
Input
5
4
16 24 10 5
4
42 42 42 42
3
4 6 4
5
1 2 3 4 5
6
9 9 27 9 9 63
Output
3
0
2
1
1 | instruction | 0 | 10,212 | 12 | 20,424 |
Tags: binary search, brute force, data structures, divide and conquer, number theory, two pointers
Correct Solution:
```
def read_ints():
return list(map(int, input().split()))
def gcd(x, y):
if x == 0 or y == 0:
return x + y
if x > y:
return gcd(x % y, y)
else:
return gcd(x, y % x)
def remove_gcd(a):
g = gcd(a[0], a[1])
for i in range(2, len(a)):
g = gcd(g, a[i])
return [x // g for x in a]
def make_cycled(a):
a.extend(a[:-1])
return a
def create_dp(a):
n = len(a)
k = 0
while n > 0:
k += 1
n //= 2
dp = [[0 for _ in range(len(a))] for _ in range(k)]
dp[0] = a
step = 1
for i in range(1, k):
step *= 2
for j in range(len(a)):
if j + step <= len(a):
dp[i][j] = gcd(dp[i - 1][j], dp[i - 1][j + step // 2])
return dp
def get_seq_gcd(dp, l, r):
step = 1
k = -1
while r - l >= step:
step *= 2
k += 1
step //= 2
#print(k, l, r, step)
return gcd(dp[k][l], dp[k][r - step])
def get_answer(dp):
answer = 0
l, r = 0, 1
while l < len(dp[0]):
cur = get_seq_gcd(dp, l, r)
while r < len(dp[0]) and cur > 1:
cur = gcd(cur, dp[0][r])
r += 1
#print(l, r, cur)
answer = max(answer, r - l - 1)
l += 1
if l == r:
r += 1
return answer
t = int(input())
for _ in range(t):
n = int(input())
a = read_ints()
a = remove_gcd(a)
a = make_cycled(a)
dp = create_dp(a)
answer = get_answer(dp)
print(answer)
``` | output | 1 | 10,212 | 12 | 20,425 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of positive integers a = [a_0, a_1, ..., a_{n - 1}] (n ≥ 2).
In one step, the array a is replaced with another array of length n, in which each element is the [greatest common divisor (GCD)](http://tiny.cc/tuy9uz) of two neighboring elements (the element itself and its right neighbor; consider that the right neighbor of the (n - 1)-th element is the 0-th element).
Formally speaking, a new array b = [b_0, b_1, ..., b_{n - 1}] is being built from array a = [a_0, a_1, ..., a_{n - 1}] such that b_i = \gcd(a_i, a_{(i + 1) mod n}), where \gcd(x, y) is the greatest common divisor of x and y, and x mod y is the remainder of x dividing by y. In one step the array b is built and then the array a is replaced with b (that is, the assignment a := b is taking place).
For example, if a = [16, 24, 10, 5] then b = [\gcd(16, 24), \gcd(24, 10), \gcd(10, 5), \gcd(5, 16)] = [8, 2, 5, 1]. Thus, after one step the array a = [16, 24, 10, 5] will be equal to [8, 2, 5, 1].
For a given array a, find the minimum number of steps after which all values a_i become equal (that is, a_0 = a_1 = ... = a_{n - 1}). If the original array a consists of identical elements then consider the number of steps is equal to 0.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
Each test case contains two lines. The first line contains an integer n (2 ≤ n ≤ 2 ⋅ 10^5) — length of the sequence a. The second line contains n integers a_0, a_1, ..., a_{n - 1} (1 ≤ a_i ≤ 10^6).
It is guaranteed that the sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
Print t numbers — answers for each test case.
Example
Input
5
4
16 24 10 5
4
42 42 42 42
3
4 6 4
5
1 2 3 4 5
6
9 9 27 9 9 63
Output
3
0
2
1
1 | instruction | 0 | 10,213 | 12 | 20,426 |
Tags: binary search, brute force, data structures, divide and conquer, number theory, two pointers
Correct Solution:
```
from __future__ import division, print_function
import os,sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
from bisect import bisect_left as lower_bound, bisect_right as upper_bound
def so(): return int(input())
def st(): return input()
def mj(): return map(int,input().strip().split(" "))
def msj(): return map(str,input().strip().split(" "))
def le(): return list(map(int,input().split()))
def lebe():return list(map(int, input()))
def dmain():
sys.setrecursionlimit(1000000)
threading.stack_size(1024000)
thread = threading.Thread(target=main)
thread.start()
def joro(L):
return(''.join(map(str, L)))
def cheems(c,d):
a=1
while(d!=0):
if(d%2==1):
a*=c
c=c*c
d=d//2
return a
def decimalToBinary(n): return bin(n).replace("0b","")
def isprime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True
def npr(n, r):
return factorial(n) // factorial(n - r) if n >= r else 0
def ncr(n, r):
return factorial(n) // (factorial(r) * factorial(n - r)) if n >= r else 0
def lower_bound(li, num):
answer = -1
start = 0
end = len(li) - 1
while (start <= end):
middle = (end + start) // 2
if li[middle] >= num:
answer = middle
end = middle - 1
else:
start = middle + 1
return answer # min index where x is not less than num
def upper_bound(li, num):
answer = -1
start = 0
end = len(li) - 1
while (start <= end):
middle = (end + start) // 2
if li[middle] <= num:
answer = middle
start = middle + 1
else:
end = middle - 1
return answer # max index where x is not greater than num
def tir(a,b,c):
if(0==c):
return 1
if(len(a)<=b):
return 0
if(c!=-1):
return (tir(a,1+b,c+a[b]) or tir(a,b+1,c-a[b]) or tir(a,1+b,c))
else:
return (tir(a,1+b,a[b]) or tir(a,b+1,-a[b]) or tir(a,1+b,-1))
def abs(x):
return x if x >= 0 else -x
def binary_search(li, val, lb, ub):
# print(lb, ub, li)
ans = -1
while (lb <= ub):
mid = (lb + ub) // 2
# print('mid is',mid, li[mid])
if li[mid] > val:
ub = mid - 1
elif val > li[mid]:
lb = mid + 1
else:
ans = mid # return index
break
return ans
def kadane(x): # maximum sum contiguous subarray
sum_so_far = 0
current_sum = 0
for i in x:
current_sum += i
if current_sum < 0:
current_sum = 0
else:
sum_so_far = max(sum_so_far, current_sum)
return sum_so_far
def wubu(m):
import math as my
d=0
while(not m%2):
m=m//2
d=1+d
for i in range(3,int(my.sqrt(m))+1,2):
while(not m%i):
m=m//i
d=1+d
return int(m>1)+d
def pref(li):
pref_sum = [0]
for i in li:
pref_sum.append(pref_sum[-1] + i)
return pref_sum
def SieveOfEratosthenes(n):
prime = [True for i in range(n + 1)]
p = 2
li = []
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n + 1, p):
prime[i] = False
p += 1
for p in range(2, len(prime)):
if prime[p]:
li.append(p)
return li
def primefactors(n):
factors = []
while (n % 2 == 0):
factors.append(2)
n //= 2
for i in range(3, int(sqrt(n)) + 1, 2): # only odd factors left
while n % i == 0:
factors.append(i)
n //= i
if n > 2: # incase of prime
factors.append(n)
return factors
def read():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
def tr(n):
return n*(n+1)//2
def bro(q,r,c):
bec,pot,h=0,0,0
ds=[]
bs=[]
es=[]
for i in range(c):
while(h<len(r) and r[h]<=q[i][0]):
pot=0
ds.clear()
bs.clear()
h=1+h
for i in range(c):
ds.append(q[i][1])
es.append(q[i][1])
ds=list(set(ds))
for i in ds:
bs.append(es.count(i))
print(bs)
for i in range(c):
if(q[i][0]>r[h-1]):
bec=bec+pot-bs[i]
pot=1+pot
return bec
def iu():
import sys
input = sys.stdin.readline
import math as my
import bisect as op
c=0
m=so()
L=le()
L=2*L
for i in range(m):
p,q,r,s=L[i],L[1+i],0,1+i
while(q!=p):
p,q,r,s=my.gcd(L[s],p),my.gcd(L[1+s],q),1+r,1+s
c=max(r,c)
print(c)
def main():
for i in range(so()):
iu()
# region fastio
# template taken from https://github.com/cheran-senthil/PyRival/blob/master/templates/template.py
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
#read()
main()
#dmain()
# Comment Read()
``` | output | 1 | 10,213 | 12 | 20,427 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of positive integers a = [a_0, a_1, ..., a_{n - 1}] (n ≥ 2).
In one step, the array a is replaced with another array of length n, in which each element is the [greatest common divisor (GCD)](http://tiny.cc/tuy9uz) of two neighboring elements (the element itself and its right neighbor; consider that the right neighbor of the (n - 1)-th element is the 0-th element).
Formally speaking, a new array b = [b_0, b_1, ..., b_{n - 1}] is being built from array a = [a_0, a_1, ..., a_{n - 1}] such that b_i = \gcd(a_i, a_{(i + 1) mod n}), where \gcd(x, y) is the greatest common divisor of x and y, and x mod y is the remainder of x dividing by y. In one step the array b is built and then the array a is replaced with b (that is, the assignment a := b is taking place).
For example, if a = [16, 24, 10, 5] then b = [\gcd(16, 24), \gcd(24, 10), \gcd(10, 5), \gcd(5, 16)] = [8, 2, 5, 1]. Thus, after one step the array a = [16, 24, 10, 5] will be equal to [8, 2, 5, 1].
For a given array a, find the minimum number of steps after which all values a_i become equal (that is, a_0 = a_1 = ... = a_{n - 1}). If the original array a consists of identical elements then consider the number of steps is equal to 0.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
Each test case contains two lines. The first line contains an integer n (2 ≤ n ≤ 2 ⋅ 10^5) — length of the sequence a. The second line contains n integers a_0, a_1, ..., a_{n - 1} (1 ≤ a_i ≤ 10^6).
It is guaranteed that the sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
Print t numbers — answers for each test case.
Example
Input
5
4
16 24 10 5
4
42 42 42 42
3
4 6 4
5
1 2 3 4 5
6
9 9 27 9 9 63
Output
3
0
2
1
1 | instruction | 0 | 10,214 | 12 | 20,428 |
Tags: binary search, brute force, data structures, divide and conquer, number theory, two pointers
Correct Solution:
```
import sys
import math
input = sys.stdin.readline
def sieve(n):
prime = [-1]*(n+1)
for i in range(2,n+1):
if prime[i]==-1:
for j in range(i,n+1,i):
if prime[j]==-1:
prime[j] = i
return prime
def PrimeFactors(num):
ans = {}
while num != 1:
p = prime[num]
ans[p] = 1
while num%p==0:
num = num//p
return ans
def solve(ind, p):
ans = 0
for i in range(ind, ind+n):
if p not in pf[i%n]:
return ans
else:
if i not in done:
done[i] = {p:0}
else:
done[i][p] = 0
ans += 1
return ans
prime = sieve(1000010)
for nt in range(int(input())):
n = int(input())
a = list(map(int,input().split()))
hcf = a[0]
for i in a:
hcf = math.gcd(hcf, i)
for i in range(n):
a[i] = a[i]//hcf
pf = []
for i in a:
pf.append(PrimeFactors(i))
ans = 0
done = {}
for i in range(n):
for j in pf[i]:
if i not in done:
done[i] = {}
if j not in done[i]:
ans = max(ans, solve(i, j))
print (ans)
``` | output | 1 | 10,214 | 12 | 20,429 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the beginner programmer has a sequence a, consisting of 2n non-negative integers: a1, a2, ..., a2n. Xenia is currently studying bit operations. To better understand how they work, Xenia decided to calculate some value v for a.
Namely, it takes several iterations to calculate value v. At the first iteration, Xenia writes a new sequence a1 or a2, a3 or a4, ..., a2n - 1 or a2n, consisting of 2n - 1 elements. In other words, she writes down the bit-wise OR of adjacent elements of sequence a. At the second iteration, Xenia writes the bitwise exclusive OR of adjacent elements of the sequence obtained after the first iteration. At the third iteration Xenia writes the bitwise OR of the adjacent elements of the sequence obtained after the second iteration. And so on; the operations of bitwise exclusive OR and bitwise OR alternate. In the end, she obtains a sequence consisting of one element, and that element is v.
Let's consider an example. Suppose that sequence a = (1, 2, 3, 4). Then let's write down all the transformations (1, 2, 3, 4) → (1 or 2 = 3, 3 or 4 = 7) → (3 xor 7 = 4). The result is v = 4.
You are given Xenia's initial sequence. But to calculate value v for a given sequence would be too easy, so you are given additional m queries. Each query is a pair of integers p, b. Query p, b means that you need to perform the assignment ap = b. After each query, you need to print the new value v for the new sequence a.
Input
The first line contains two integers n and m (1 ≤ n ≤ 17, 1 ≤ m ≤ 105). The next line contains 2n integers a1, a2, ..., a2n (0 ≤ ai < 230). Each of the next m lines contains queries. The i-th line contains integers pi, bi (1 ≤ pi ≤ 2n, 0 ≤ bi < 230) — the i-th query.
Output
Print m integers — the i-th integer denotes value v for sequence a after the i-th query.
Examples
Input
2 4
1 6 3 5
1 4
3 4
1 2
1 2
Output
1
3
3
3
Note
For more information on the bit operations, you can follow this link: http://en.wikipedia.org/wiki/Bitwise_operation | instruction | 0 | 10,294 | 12 | 20,588 |
Tags: data structures, trees
Correct Solution:
```
from sys import stdin,stdout
n,m=map(int,input().split())
n=pow(2,n)
tarr=list(map(int,stdin.readline().split()))
arr=[0]*n
arr=arr+tarr
start=n
end=2*n
flag=0
while(start>1):
for i in range(start,end,2):
if(flag):
arr[i>>1]=arr[i]^arr[i+1]
else:
arr[i>>1]=arr[i]|arr[i+1]
flag=flag^1
end=start
start=start>>1
for i in range(m):
p,b=map(int,stdin.readline().split())
arr[n+p-1]=b
pos=n+p-1
flag=0
while(pos>1):
pos=pos>>1
if(flag):
arr[pos]=arr[pos<<1]^arr[(pos<<1)+1]
else:
arr[pos]=arr[pos<<1]|arr[(pos<<1)+1]
flag=flag^1
stdout.write(str(arr[1])+'\n')
``` | output | 1 | 10,294 | 12 | 20,589 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the beginner programmer has a sequence a, consisting of 2n non-negative integers: a1, a2, ..., a2n. Xenia is currently studying bit operations. To better understand how they work, Xenia decided to calculate some value v for a.
Namely, it takes several iterations to calculate value v. At the first iteration, Xenia writes a new sequence a1 or a2, a3 or a4, ..., a2n - 1 or a2n, consisting of 2n - 1 elements. In other words, she writes down the bit-wise OR of adjacent elements of sequence a. At the second iteration, Xenia writes the bitwise exclusive OR of adjacent elements of the sequence obtained after the first iteration. At the third iteration Xenia writes the bitwise OR of the adjacent elements of the sequence obtained after the second iteration. And so on; the operations of bitwise exclusive OR and bitwise OR alternate. In the end, she obtains a sequence consisting of one element, and that element is v.
Let's consider an example. Suppose that sequence a = (1, 2, 3, 4). Then let's write down all the transformations (1, 2, 3, 4) → (1 or 2 = 3, 3 or 4 = 7) → (3 xor 7 = 4). The result is v = 4.
You are given Xenia's initial sequence. But to calculate value v for a given sequence would be too easy, so you are given additional m queries. Each query is a pair of integers p, b. Query p, b means that you need to perform the assignment ap = b. After each query, you need to print the new value v for the new sequence a.
Input
The first line contains two integers n and m (1 ≤ n ≤ 17, 1 ≤ m ≤ 105). The next line contains 2n integers a1, a2, ..., a2n (0 ≤ ai < 230). Each of the next m lines contains queries. The i-th line contains integers pi, bi (1 ≤ pi ≤ 2n, 0 ≤ bi < 230) — the i-th query.
Output
Print m integers — the i-th integer denotes value v for sequence a after the i-th query.
Examples
Input
2 4
1 6 3 5
1 4
3 4
1 2
1 2
Output
1
3
3
3
Note
For more information on the bit operations, you can follow this link: http://en.wikipedia.org/wiki/Bitwise_operation | instruction | 0 | 10,295 | 12 | 20,590 |
Tags: data structures, trees
Correct Solution:
```
'''
Code from : AKASH KUMAR BHAGAT(akay_99)
'''
#-------------------------------------------------------------------------------------
'''
from sys import stdin, stdout
def input():
return stdin.readline().rstrip()
'''
#--------------------------------------------------------------------------------------------------
'''
#For PYPY 2.7
#Dont forget to change the print statments
from sys import stdin, stdout
import sys
range = xrange
input = raw_input
def input():
return stdin.readline().rstrip()
'''
#-----------------------------------------------------------------------------------
#!/usr/bin/env python
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")
# endregion
#---------------------------------------------------------------------------------------------------
#CODE HERE
def assign():
for i in range(x,len(a)+x):
seg[i]=a[i-x]
def op(c,ind):
for i in range(ind,ind*2+1):
if(c%2):
seg[i]=seg[2*i+1]^seg[2*i+2]
else:
seg[i]=seg[2*i+1]| seg[2*i+2]
if(ind==0):
return
op(c+1,ind//2)
def update(p,val):
pos=x+p-1
seg[pos]=val
def cal(c,ind):
#print(ind,c)
i=ind
if(c%2):
seg[i]=seg[2*i+1]^seg[2*i+2]
else:
seg[i]=seg[2*i+1]| seg[2*i+2]
if(i==0):
return 1
cal(c+1,(ind-1)//2)
cal(0,(pos-1)//2)
def built():
assign()
op(0,(len(a)-1)//2)
n,m=[int(i) for i in input().split()]
a=[int(i) for i in input().split()]
seg=[-1]*(2**(n+1))
x=len(a)-1
built()
for _ in range(m):
p,b=[int(i) for i in input().split()]
update(p,b)
print(seg[0])
``` | output | 1 | 10,295 | 12 | 20,591 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the beginner programmer has a sequence a, consisting of 2n non-negative integers: a1, a2, ..., a2n. Xenia is currently studying bit operations. To better understand how they work, Xenia decided to calculate some value v for a.
Namely, it takes several iterations to calculate value v. At the first iteration, Xenia writes a new sequence a1 or a2, a3 or a4, ..., a2n - 1 or a2n, consisting of 2n - 1 elements. In other words, she writes down the bit-wise OR of adjacent elements of sequence a. At the second iteration, Xenia writes the bitwise exclusive OR of adjacent elements of the sequence obtained after the first iteration. At the third iteration Xenia writes the bitwise OR of the adjacent elements of the sequence obtained after the second iteration. And so on; the operations of bitwise exclusive OR and bitwise OR alternate. In the end, she obtains a sequence consisting of one element, and that element is v.
Let's consider an example. Suppose that sequence a = (1, 2, 3, 4). Then let's write down all the transformations (1, 2, 3, 4) → (1 or 2 = 3, 3 or 4 = 7) → (3 xor 7 = 4). The result is v = 4.
You are given Xenia's initial sequence. But to calculate value v for a given sequence would be too easy, so you are given additional m queries. Each query is a pair of integers p, b. Query p, b means that you need to perform the assignment ap = b. After each query, you need to print the new value v for the new sequence a.
Input
The first line contains two integers n and m (1 ≤ n ≤ 17, 1 ≤ m ≤ 105). The next line contains 2n integers a1, a2, ..., a2n (0 ≤ ai < 230). Each of the next m lines contains queries. The i-th line contains integers pi, bi (1 ≤ pi ≤ 2n, 0 ≤ bi < 230) — the i-th query.
Output
Print m integers — the i-th integer denotes value v for sequence a after the i-th query.
Examples
Input
2 4
1 6 3 5
1 4
3 4
1 2
1 2
Output
1
3
3
3
Note
For more information on the bit operations, you can follow this link: http://en.wikipedia.org/wiki/Bitwise_operation | instruction | 0 | 10,296 | 12 | 20,592 |
Tags: data structures, trees
Correct Solution:
```
import sys, os, io
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(sys.stdin.readline())
def ria(): return list(map(int, sys.stdin.readline().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math,datetime,functools,itertools,operator,bisect,fractions,statistics
from collections import deque,defaultdict,OrderedDict,Counter
from fractions import Fraction
from decimal import Decimal
from sys import stdout
from heapq import heappush, heappop, heapify ,_heapify_max,_heappop_max,nsmallest,nlargest
# sys.setrecursionlimit(111111)
INF=999999999999999999999999
alphabets="abcdefghijklmnopqrstuvwxyz"
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
class SegTree:
def __init__(self, n):
self.N = 1 << n.bit_length()
self.tree = [0] * (self.N<<1)
def update(self, i, j, v):
i += self.N
j += self.N
while i <= j:
if i%2==1: self.tree[i] += v
if j%2==0: self.tree[j] += v
i, j = (i+1) >> 1, (j-1) >> 1
def query(self, i):
v = 0
i += self.N
while i > 0:
v += self.tree[i]
i >>= 1
return v
def SieveOfEratosthenes(limit):
"""Returns all primes not greater than limit."""
isPrime = [True]*(limit+1)
isPrime[0] = isPrime[1] = False
primes = []
for i in range(2, limit+1):
if not isPrime[i]:continue
primes += [i]
for j in range(i*i, limit+1, i):
isPrime[j] = False
return primes
N = 1005
# array to store inverse of 1 to N
factorialNumInverse = [None] * (N + 1)
# array to precompute inverse of 1! to N!
naturalNumInverse = [None] * (N + 1)
# array to store factorial of
# first N numbers
fact = [None] * (N + 1)
# Function to precompute inverse of numbers
def InverseofNumber(p):
naturalNumInverse[0] = naturalNumInverse[1] = 1
for i in range(2, N + 1, 1):
naturalNumInverse[i] = (naturalNumInverse[p % i] *
(p - int(p / i)) % p)
# Function to precompute inverse
# of factorials
def InverseofFactorial(p):
factorialNumInverse[0] = factorialNumInverse[1] = 1
# precompute inverse of natural numbers
for i in range(2, N + 1, 1):
factorialNumInverse[i] = (naturalNumInverse[i] *
factorialNumInverse[i - 1]) % p
# Function to calculate factorial of 1 to N
def factorial(p):
fact[0] = 1
# precompute factorials
for i in range(1, N + 1):
fact[i] = (fact[i - 1] * i) % p
# Function to return nCr % p in O(1) time
def Binomial(N, R, p):
# n C r = n!*inverse(r!)*inverse((n-r)!)
ans = ((fact[N] * factorialNumInverse[R])% p *
factorialNumInverse[N - R])% p
return ans
def main():
mod=1000000007
InverseofNumber(mod)
InverseofFactorial(mod)
factorial(mod)
starttime=datetime.datetime.now()
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
###CODE
tc = 1
for _ in range(tc):
n,q=ria()
a=ria()
pow2sum={}
s=0
for i in range(n,-1,-1):
s+=2**i
pow2sum[s]=1
tree=a.copy()
i=0
t=0
la=2**n
while i+1<len(tree):
if t==0:
tree.append(tree[i]|tree[i+1])
else:
tree.append(tree[i]^tree[i+1])
if len(tree) in pow2sum:
t=1-t
i+=2
tree=tree[::-1]
# Note:
# if i even i's parent is (i-2)//2
# if i odd i's parent is (i-1)//2
# if i even i's brother is (i-1)
# if i odd i's brother is (i+1)
# Now lets go
for i in range(q):
posn,b=ria()
initialpos=len(tree)-posn
tree[initialpos]=b
t=0
while initialpos!=0:
if initialpos%2:
brotherpos=initialpos+1
parentpos=(initialpos-1)//2
else:
brotherpos=initialpos-1
parentpos=(initialpos-2)//2
if t==0:
tree[parentpos]=tree[initialpos]|tree[brotherpos]
else:
tree[parentpos]=tree[initialpos]^tree[brotherpos]
t=1-t
initialpos=parentpos
wi(tree[0])
#<--Solving Area Ends
endtime=datetime.datetime.now()
time=(endtime-starttime).total_seconds()*1000
if(os.path.exists('input.txt')):
print("Time:",time,"ms")
class FastReader(io.IOBase):
newlines = 0
def __init__(self, fd, chunk_size=1024 * 8):
self._fd = fd
self._chunk_size = chunk_size
self.buffer = io.BytesIO()
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
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, size=-1):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
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()
class FastWriter(io.IOBase):
def __init__(self, fd):
self._fd = fd
self.buffer = io.BytesIO()
self.write = self.buffer.write
def flush(self):
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class FastStdin(io.IOBase):
def __init__(self, fd=0):
self.buffer = FastReader(fd)
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
class FastStdout(io.IOBase):
def __init__(self, fd=1):
self.buffer = FastWriter(fd)
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.flush = self.buffer.flush
if __name__ == '__main__':
sys.stdin = FastStdin()
sys.stdout = FastStdout()
main()
``` | output | 1 | 10,296 | 12 | 20,593 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the beginner programmer has a sequence a, consisting of 2n non-negative integers: a1, a2, ..., a2n. Xenia is currently studying bit operations. To better understand how they work, Xenia decided to calculate some value v for a.
Namely, it takes several iterations to calculate value v. At the first iteration, Xenia writes a new sequence a1 or a2, a3 or a4, ..., a2n - 1 or a2n, consisting of 2n - 1 elements. In other words, she writes down the bit-wise OR of adjacent elements of sequence a. At the second iteration, Xenia writes the bitwise exclusive OR of adjacent elements of the sequence obtained after the first iteration. At the third iteration Xenia writes the bitwise OR of the adjacent elements of the sequence obtained after the second iteration. And so on; the operations of bitwise exclusive OR and bitwise OR alternate. In the end, she obtains a sequence consisting of one element, and that element is v.
Let's consider an example. Suppose that sequence a = (1, 2, 3, 4). Then let's write down all the transformations (1, 2, 3, 4) → (1 or 2 = 3, 3 or 4 = 7) → (3 xor 7 = 4). The result is v = 4.
You are given Xenia's initial sequence. But to calculate value v for a given sequence would be too easy, so you are given additional m queries. Each query is a pair of integers p, b. Query p, b means that you need to perform the assignment ap = b. After each query, you need to print the new value v for the new sequence a.
Input
The first line contains two integers n and m (1 ≤ n ≤ 17, 1 ≤ m ≤ 105). The next line contains 2n integers a1, a2, ..., a2n (0 ≤ ai < 230). Each of the next m lines contains queries. The i-th line contains integers pi, bi (1 ≤ pi ≤ 2n, 0 ≤ bi < 230) — the i-th query.
Output
Print m integers — the i-th integer denotes value v for sequence a after the i-th query.
Examples
Input
2 4
1 6 3 5
1 4
3 4
1 2
1 2
Output
1
3
3
3
Note
For more information on the bit operations, you can follow this link: http://en.wikipedia.org/wiki/Bitwise_operation | instruction | 0 | 10,297 | 12 | 20,594 |
Tags: data structures, trees
Correct Solution:
```
import sys
input=sys.stdin.readline
import math
# sys.setrecursionlimit(10**9)
def construct(array,cur_pos,tree,start,end):
if(start==end):
# print(cur_pos,"pppp",array[start])
tree[cur_pos]=array[start]
else:
mid=(start+end)//2
w=(n1-int(math.log2(cur_pos+1)))
# print(w,n1,cur_pos+1)
if(w%2!=0):
# print(cur_pos,w)
tree[cur_pos]=(construct(array,2*cur_pos+1,tree,start,mid)|construct(array,2*cur_pos+2,tree,mid+1,end))
else:
# print(cur_pos,w)
tree[cur_pos]=(construct(array,2*cur_pos+1,tree,start,mid)^construct(array,2*cur_pos+2,tree,mid+1,end))
return tree[cur_pos]
def update(cur_pos,l,r,index,increment):
# print(tree)
if(l<=index<=r):
if(l==r):
tree[cur_pos]=increment
else:
mid=(l+r)//2
w=(n1-int(math.log2(cur_pos+1)))
if(w%2!=0):
update(2*cur_pos+1,l,mid,index,increment)
update(2*cur_pos+2,mid+1,r,index,increment)
tree[cur_pos]=tree[2*cur_pos+1]|tree[2*cur_pos+2]
else:
update(2*cur_pos+1,l,mid,index,increment)
update(2*cur_pos+2,mid+1,r,index,increment)
tree[cur_pos]=tree[2*cur_pos+1]^tree[2*cur_pos+2]
return tree[cur_pos]
return 0
l= list(map(int,input().split()))
l1=list(map(int,input().split()))
n=(2**(l[0]))
tree=[0]*(2**(l[0]+1)-1)
n1=int(math.log2(len(tree)))
# print(n1,n,"llll")
construct(l1,0,tree,0,n-1)
# print(tree)
for i in range(l[1]):
# print(tree)
l2=list(map(int,input().split()))
update(0,0,n-1,l2[0]-1,l2[1])
# print(tree,"ppp")
print(tree[0])
``` | output | 1 | 10,297 | 12 | 20,595 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Xenia the beginner programmer has a sequence a, consisting of 2n non-negative integers: a1, a2, ..., a2n. Xenia is currently studying bit operations. To better understand how they work, Xenia decided to calculate some value v for a.
Namely, it takes several iterations to calculate value v. At the first iteration, Xenia writes a new sequence a1 or a2, a3 or a4, ..., a2n - 1 or a2n, consisting of 2n - 1 elements. In other words, she writes down the bit-wise OR of adjacent elements of sequence a. At the second iteration, Xenia writes the bitwise exclusive OR of adjacent elements of the sequence obtained after the first iteration. At the third iteration Xenia writes the bitwise OR of the adjacent elements of the sequence obtained after the second iteration. And so on; the operations of bitwise exclusive OR and bitwise OR alternate. In the end, she obtains a sequence consisting of one element, and that element is v.
Let's consider an example. Suppose that sequence a = (1, 2, 3, 4). Then let's write down all the transformations (1, 2, 3, 4) → (1 or 2 = 3, 3 or 4 = 7) → (3 xor 7 = 4). The result is v = 4.
You are given Xenia's initial sequence. But to calculate value v for a given sequence would be too easy, so you are given additional m queries. Each query is a pair of integers p, b. Query p, b means that you need to perform the assignment ap = b. After each query, you need to print the new value v for the new sequence a.
Input
The first line contains two integers n and m (1 ≤ n ≤ 17, 1 ≤ m ≤ 105). The next line contains 2n integers a1, a2, ..., a2n (0 ≤ ai < 230). Each of the next m lines contains queries. The i-th line contains integers pi, bi (1 ≤ pi ≤ 2n, 0 ≤ bi < 230) — the i-th query.
Output
Print m integers — the i-th integer denotes value v for sequence a after the i-th query.
Examples
Input
2 4
1 6 3 5
1 4
3 4
1 2
1 2
Output
1
3
3
3
Note
For more information on the bit operations, you can follow this link: http://en.wikipedia.org/wiki/Bitwise_operation | instruction | 0 | 10,298 | 12 | 20,596 |
Tags: data structures, trees
Correct Solution:
```
from operator import or_, xor
import sys
greg=1
#Stolen from tchr to test Xenia and Bit Operations speed.
n, m = map(int, input().split())
t = [list(map(int, input().split()))]
for i in range(n):
t += [[(or_, xor)[i & 1](*t[i][j: j + 2]) for j in range(0, len(t[i]), 2)]]
for s in sys.stdin:
p, b = s.split()
p = int(p) - 1
t[0][p] = int(b)
for j in range(n):
p >>= 1
t[j + 1][p] = (or_, xor)[j & 1](*t[j][p << 1: (p << 1) + 2])
print(t[-1][0])
``` | output | 1 | 10,298 | 12 | 20,597 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.