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 |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
We all know that GukiZ often plays with arrays.
Now he is thinking about this problem: how many arrays a, of length n, with non-negative elements strictly less then 2l meet the following condition: <image>? Here operation <image> means bitwise AND (in Pascal it is equivalent to and, in C/C++/Java/Python it is equivalent to &), operation <image> means bitwise OR (in Pascal it is equivalent to <image>, in C/C++/Java/Python it is equivalent to |).
Because the answer can be quite large, calculate it modulo m. This time GukiZ hasn't come up with solution, and needs you to help him!
Input
First and the only line of input contains four integers n, k, l, m (2 ≤ n ≤ 1018, 0 ≤ k ≤ 1018, 0 ≤ l ≤ 64, 1 ≤ m ≤ 109 + 7).
Output
In the single line print the number of arrays satisfying the condition above modulo m.
Examples
Input
2 1 2 10
Output
3
Input
2 1 1 3
Output
1
Input
3 3 2 10
Output
9
Note
In the first sample, satisfying arrays are {1, 1}, {3, 1}, {1, 3}.
In the second sample, only satisfying array is {1, 1}.
In the third sample, satisfying arrays are {0, 3, 3}, {1, 3, 2}, {1, 3, 3}, {2, 3, 1}, {2, 3, 3}, {3, 3, 0}, {3, 3, 1}, {3, 3, 2}, {3, 3, 3}. | instruction | 0 | 59,256 | 12 | 118,512 |
Tags: combinatorics, implementation, math, matrices, number theory
Correct Solution:
```
"""
Codeforces Contest 307 Div 2 Problem D
Author : chaotic_iak
Language: Python 3.4.2
"""
################################################### SOLUTION
def multiply(M1, M2):
if len(M1[0]) != len(M2): raise ValueError
a = len(M1)
b = len(M2[0])
c = len(M1[0])
# M1: a x c, M2: c x b, M: a x b
ans = [[0]*b for _ in range(a)]
for i in range(a):
for j in range(b):
for k in range(c):
ans[i][j] += M1[i][k] * M2[k][j]
return ans
def solve(n, m):
M = [[0,1,0],[1,1,0],[0,1,2]]
if n == 0:
return [[1,0,0],[0,1,0],[0,0,1]]
if n == 1:
return M
P = solve(n//2, m)
S = multiply(P, P)
if n%2: S = multiply(S, M)
for i in range(3):
for j in range(3):
S[i][j] = S[i][j] % m
return S
def main():
n,k,l,m = read()
kb = bin(k)[2:]
if l == 0 and k == 0: return 1 % m
if len(kb) > l: return 0
kb = "0" * (l - len(kb)) + kb
zero, one = 0, 0
for i in kb:
if i == "0":
zero += 1
else:
one += 1
multiplier = solve(n, m)
_, _, ans_one = multiply(multiplier, [[1],[0],[0]])
multiplier = multiply(multiplier, solve(2, m))
_, ans_zero, _ = multiply(multiplier, [[1],[0],[0]])
return (pow(ans_zero[0], zero, m) * pow(ans_one[0], one, m)) % m
#################################################### HELPERS
def read(mode=2):
# 0: String
# 1: List of strings
# 2: List of integers
inputs = input().strip()
if mode == 0: return inputs
if mode == 1: return inputs.split()
if mode == 2: return list(map(int, inputs.split()))
def write(s="\n"):
if s is None: s = ""
if isinstance(s, list): s = " ".join(map(str, s))
s = str(s)
print(s, end="")
write(main())
``` | output | 1 | 59,256 | 12 | 118,513 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dark is going to attend Motarack's birthday. Dark decided that the gift he is going to give to Motarack is an array a of n non-negative integers.
Dark created that array 1000 years ago, so some elements in that array disappeared. Dark knows that Motarack hates to see an array that has two adjacent elements with a high absolute difference between them. He doesn't have much time so he wants to choose an integer k (0 ≤ k ≤ 10^{9}) and replaces all missing elements in the array a with k.
Let m be the maximum absolute difference between all adjacent elements (i.e. the maximum value of |a_i - a_{i+1}| for all 1 ≤ i ≤ n - 1) in the array a after Dark replaces all missing elements with k.
Dark should choose an integer k so that m is minimized. Can you help him?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^{5}) — the size of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (-1 ≤ a_i ≤ 10 ^ {9}). If a_i = -1, then the i-th integer is missing. It is guaranteed that at least one integer is missing in every test case.
It is guaranteed, that the sum of n for all test cases does not exceed 4 ⋅ 10 ^ {5}.
Output
Print the answers for each test case in the following format:
You should print two integers, the minimum possible value of m and an integer k (0 ≤ k ≤ 10^{9}) that makes the maximum absolute difference between adjacent elements in the array a equal to m.
Make sure that after replacing all the missing elements with k, the maximum absolute difference between adjacent elements becomes m.
If there is more than one possible k, you can print any of them.
Example
Input
7
5
-1 10 -1 12 -1
5
-1 40 35 -1 35
6
-1 -1 9 -1 3 -1
2
-1 -1
2
0 -1
4
1 -1 3 -1
7
1 -1 7 5 2 -1 5
Output
1 11
5 35
3 6
0 42
0 0
1 2
3 4
Note
In the first test case after replacing all missing elements with 11 the array becomes [11, 10, 11, 12, 11]. The absolute difference between any adjacent elements is 1. It is impossible to choose a value of k, such that the absolute difference between any adjacent element will be ≤ 0. So, the answer is 1.
In the third test case after replacing all missing elements with 6 the array becomes [6, 6, 9, 6, 3, 6].
* |a_1 - a_2| = |6 - 6| = 0;
* |a_2 - a_3| = |6 - 9| = 3;
* |a_3 - a_4| = |9 - 6| = 3;
* |a_4 - a_5| = |6 - 3| = 3;
* |a_5 - a_6| = |3 - 6| = 3.
So, the maximum difference between any adjacent elements is 3. | instruction | 0 | 59,834 | 12 | 119,668 |
Tags: binary search, greedy, ternary search
Correct Solution:
```
# Template 1.0
import sys, re, math
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from heapq import heappush, heappop, heapify, nlargest, nsmallest
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def sortListWithIndex(listOfTuples, idx): return (sorted(listOfTuples, key=lambda x: x[idx]))
def sortDictWithVal(passedDic):
temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))
toret = {}
for tup in temp:
toret[tup[0]] = tup[1]
return toret
def sortDictWithKey(passedDic):
return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
t = INT()
while(t!=0):
n =INT()
a = LIST()
foo = set()
mx = 0
mn = INF
for i in range(n):
if(a[i]==-1):
if(i==0):
if(a[i+1]==-1):
continue
else:
foo.add(a[i+1])
elif(i==n-1):
if(a[i-1]==-1):
continue
else:
foo.add(a[i-1])
else:
if(a[i+1]!=-1):
foo.add(a[i+1])
if(a[i-1]!=-1):
foo.add(a[i-1])
if(len(foo)!=0):
mx = max(foo)
mn = min(foo)
k = (mx+mn)//2
else:
k = 0
overall = 0
for j in range(n):
if(a[j]==-1):
a[j]=k
# print(a)
for j in range(1, n):
overall = max(overall, abs(a[j]-a[j-1]))
print(overall, k)
t-=1
``` | output | 1 | 59,834 | 12 | 119,669 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dark is going to attend Motarack's birthday. Dark decided that the gift he is going to give to Motarack is an array a of n non-negative integers.
Dark created that array 1000 years ago, so some elements in that array disappeared. Dark knows that Motarack hates to see an array that has two adjacent elements with a high absolute difference between them. He doesn't have much time so he wants to choose an integer k (0 ≤ k ≤ 10^{9}) and replaces all missing elements in the array a with k.
Let m be the maximum absolute difference between all adjacent elements (i.e. the maximum value of |a_i - a_{i+1}| for all 1 ≤ i ≤ n - 1) in the array a after Dark replaces all missing elements with k.
Dark should choose an integer k so that m is minimized. Can you help him?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^{5}) — the size of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (-1 ≤ a_i ≤ 10 ^ {9}). If a_i = -1, then the i-th integer is missing. It is guaranteed that at least one integer is missing in every test case.
It is guaranteed, that the sum of n for all test cases does not exceed 4 ⋅ 10 ^ {5}.
Output
Print the answers for each test case in the following format:
You should print two integers, the minimum possible value of m and an integer k (0 ≤ k ≤ 10^{9}) that makes the maximum absolute difference between adjacent elements in the array a equal to m.
Make sure that after replacing all the missing elements with k, the maximum absolute difference between adjacent elements becomes m.
If there is more than one possible k, you can print any of them.
Example
Input
7
5
-1 10 -1 12 -1
5
-1 40 35 -1 35
6
-1 -1 9 -1 3 -1
2
-1 -1
2
0 -1
4
1 -1 3 -1
7
1 -1 7 5 2 -1 5
Output
1 11
5 35
3 6
0 42
0 0
1 2
3 4
Note
In the first test case after replacing all missing elements with 11 the array becomes [11, 10, 11, 12, 11]. The absolute difference between any adjacent elements is 1. It is impossible to choose a value of k, such that the absolute difference between any adjacent element will be ≤ 0. So, the answer is 1.
In the third test case after replacing all missing elements with 6 the array becomes [6, 6, 9, 6, 3, 6].
* |a_1 - a_2| = |6 - 6| = 0;
* |a_2 - a_3| = |6 - 9| = 3;
* |a_3 - a_4| = |9 - 6| = 3;
* |a_4 - a_5| = |6 - 3| = 3;
* |a_5 - a_6| = |3 - 6| = 3.
So, the maximum difference between any adjacent elements is 3. | instruction | 0 | 59,835 | 12 | 119,670 |
Tags: binary search, greedy, ternary search
Correct Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
nei = []
default = 0
for x, y in zip(a, a[1:]):
if x==-1 and y!=-1:
nei.append(y)
if x!=-1 and y==-1:
nei.append(x)
if x!=-1 and y!=-1:
default=max(default, abs(x-y))
if not nei:
print(0, 1)
continue
mi = min(nei)
ma = max(nei)
k = (mi+ma)//2
m = max(abs(mi-k),abs(ma-k), default)
print(m, k)
``` | output | 1 | 59,835 | 12 | 119,671 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dark is going to attend Motarack's birthday. Dark decided that the gift he is going to give to Motarack is an array a of n non-negative integers.
Dark created that array 1000 years ago, so some elements in that array disappeared. Dark knows that Motarack hates to see an array that has two adjacent elements with a high absolute difference between them. He doesn't have much time so he wants to choose an integer k (0 ≤ k ≤ 10^{9}) and replaces all missing elements in the array a with k.
Let m be the maximum absolute difference between all adjacent elements (i.e. the maximum value of |a_i - a_{i+1}| for all 1 ≤ i ≤ n - 1) in the array a after Dark replaces all missing elements with k.
Dark should choose an integer k so that m is minimized. Can you help him?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^{5}) — the size of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (-1 ≤ a_i ≤ 10 ^ {9}). If a_i = -1, then the i-th integer is missing. It is guaranteed that at least one integer is missing in every test case.
It is guaranteed, that the sum of n for all test cases does not exceed 4 ⋅ 10 ^ {5}.
Output
Print the answers for each test case in the following format:
You should print two integers, the minimum possible value of m and an integer k (0 ≤ k ≤ 10^{9}) that makes the maximum absolute difference between adjacent elements in the array a equal to m.
Make sure that after replacing all the missing elements with k, the maximum absolute difference between adjacent elements becomes m.
If there is more than one possible k, you can print any of them.
Example
Input
7
5
-1 10 -1 12 -1
5
-1 40 35 -1 35
6
-1 -1 9 -1 3 -1
2
-1 -1
2
0 -1
4
1 -1 3 -1
7
1 -1 7 5 2 -1 5
Output
1 11
5 35
3 6
0 42
0 0
1 2
3 4
Note
In the first test case after replacing all missing elements with 11 the array becomes [11, 10, 11, 12, 11]. The absolute difference between any adjacent elements is 1. It is impossible to choose a value of k, such that the absolute difference between any adjacent element will be ≤ 0. So, the answer is 1.
In the third test case after replacing all missing elements with 6 the array becomes [6, 6, 9, 6, 3, 6].
* |a_1 - a_2| = |6 - 6| = 0;
* |a_2 - a_3| = |6 - 9| = 3;
* |a_3 - a_4| = |9 - 6| = 3;
* |a_4 - a_5| = |6 - 3| = 3;
* |a_5 - a_6| = |3 - 6| = 3.
So, the maximum difference between any adjacent elements is 3. | instruction | 0 | 59,836 | 12 | 119,672 |
Tags: binary search, greedy, ternary search
Correct Solution:
```
import sys
input = sys.stdin.buffer.readline
def print(*vals):
sys.stdout.write(" ".join(map(str,vals)) + '\n')
def max_diff(integers,k,n):
max_diff = 0
for i in range(n-1):
if integers[i] == -1 and integers[i+1] != -1:
max_diff = max(max_diff, abs(k - integers[i+1]))
elif integers[i+1] == -1 and integers[i] != -1:
max_diff = max(max_diff, abs(integers[i] - k))
else:
max_diff = max(max_diff, abs(integers[i] - integers[i+1]))
return max_diff
def prog():
for _ in range(int(input())):
n = int(input())
integers = list(map(int,input().split()))
L = 0
R = 10**9
while L != R:
diff = (R-L)//3
m1 = L + diff
m2 = R - diff
val1 = max_diff(integers,m1,n)
val2 = max_diff(integers,m2,n)
if val1 > val2:
L = m1 + 1
else:
R = m2 - 1
print(max_diff(integers,R,n),R)
prog()
``` | output | 1 | 59,836 | 12 | 119,673 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dark is going to attend Motarack's birthday. Dark decided that the gift he is going to give to Motarack is an array a of n non-negative integers.
Dark created that array 1000 years ago, so some elements in that array disappeared. Dark knows that Motarack hates to see an array that has two adjacent elements with a high absolute difference between them. He doesn't have much time so he wants to choose an integer k (0 ≤ k ≤ 10^{9}) and replaces all missing elements in the array a with k.
Let m be the maximum absolute difference between all adjacent elements (i.e. the maximum value of |a_i - a_{i+1}| for all 1 ≤ i ≤ n - 1) in the array a after Dark replaces all missing elements with k.
Dark should choose an integer k so that m is minimized. Can you help him?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^{5}) — the size of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (-1 ≤ a_i ≤ 10 ^ {9}). If a_i = -1, then the i-th integer is missing. It is guaranteed that at least one integer is missing in every test case.
It is guaranteed, that the sum of n for all test cases does not exceed 4 ⋅ 10 ^ {5}.
Output
Print the answers for each test case in the following format:
You should print two integers, the minimum possible value of m and an integer k (0 ≤ k ≤ 10^{9}) that makes the maximum absolute difference between adjacent elements in the array a equal to m.
Make sure that after replacing all the missing elements with k, the maximum absolute difference between adjacent elements becomes m.
If there is more than one possible k, you can print any of them.
Example
Input
7
5
-1 10 -1 12 -1
5
-1 40 35 -1 35
6
-1 -1 9 -1 3 -1
2
-1 -1
2
0 -1
4
1 -1 3 -1
7
1 -1 7 5 2 -1 5
Output
1 11
5 35
3 6
0 42
0 0
1 2
3 4
Note
In the first test case after replacing all missing elements with 11 the array becomes [11, 10, 11, 12, 11]. The absolute difference between any adjacent elements is 1. It is impossible to choose a value of k, such that the absolute difference between any adjacent element will be ≤ 0. So, the answer is 1.
In the third test case after replacing all missing elements with 6 the array becomes [6, 6, 9, 6, 3, 6].
* |a_1 - a_2| = |6 - 6| = 0;
* |a_2 - a_3| = |6 - 9| = 3;
* |a_3 - a_4| = |9 - 6| = 3;
* |a_4 - a_5| = |6 - 3| = 3;
* |a_5 - a_6| = |3 - 6| = 3.
So, the maximum difference between any adjacent elements is 3. | instruction | 0 | 59,837 | 12 | 119,674 |
Tags: binary search, greedy, ternary search
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
l, h = 1000010000, -1
for i in range(n):
if a[i] >= 0:
if (i and a[i - 1] < 0) or (i + 1 < n and a[i + 1] < 0):
l = min(l, a[i])
h = max(h, a[i])
if l > h:
print(0, 0)
else:
x = (l + h) // 2
y = h - x
for i in range(1, n):
if a[i - 1] >= 0 and a[i] >= 0:
y = max(y, abs(a[i] - a[i - 1]))
print(y, x)
``` | output | 1 | 59,837 | 12 | 119,675 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dark is going to attend Motarack's birthday. Dark decided that the gift he is going to give to Motarack is an array a of n non-negative integers.
Dark created that array 1000 years ago, so some elements in that array disappeared. Dark knows that Motarack hates to see an array that has two adjacent elements with a high absolute difference between them. He doesn't have much time so he wants to choose an integer k (0 ≤ k ≤ 10^{9}) and replaces all missing elements in the array a with k.
Let m be the maximum absolute difference between all adjacent elements (i.e. the maximum value of |a_i - a_{i+1}| for all 1 ≤ i ≤ n - 1) in the array a after Dark replaces all missing elements with k.
Dark should choose an integer k so that m is minimized. Can you help him?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^{5}) — the size of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (-1 ≤ a_i ≤ 10 ^ {9}). If a_i = -1, then the i-th integer is missing. It is guaranteed that at least one integer is missing in every test case.
It is guaranteed, that the sum of n for all test cases does not exceed 4 ⋅ 10 ^ {5}.
Output
Print the answers for each test case in the following format:
You should print two integers, the minimum possible value of m and an integer k (0 ≤ k ≤ 10^{9}) that makes the maximum absolute difference between adjacent elements in the array a equal to m.
Make sure that after replacing all the missing elements with k, the maximum absolute difference between adjacent elements becomes m.
If there is more than one possible k, you can print any of them.
Example
Input
7
5
-1 10 -1 12 -1
5
-1 40 35 -1 35
6
-1 -1 9 -1 3 -1
2
-1 -1
2
0 -1
4
1 -1 3 -1
7
1 -1 7 5 2 -1 5
Output
1 11
5 35
3 6
0 42
0 0
1 2
3 4
Note
In the first test case after replacing all missing elements with 11 the array becomes [11, 10, 11, 12, 11]. The absolute difference between any adjacent elements is 1. It is impossible to choose a value of k, such that the absolute difference between any adjacent element will be ≤ 0. So, the answer is 1.
In the third test case after replacing all missing elements with 6 the array becomes [6, 6, 9, 6, 3, 6].
* |a_1 - a_2| = |6 - 6| = 0;
* |a_2 - a_3| = |6 - 9| = 3;
* |a_3 - a_4| = |9 - 6| = 3;
* |a_4 - a_5| = |6 - 3| = 3;
* |a_5 - a_6| = |3 - 6| = 3.
So, the maximum difference between any adjacent elements is 3. | instruction | 0 | 59,838 | 12 | 119,676 |
Tags: binary search, greedy, ternary search
Correct Solution:
```
t = int(input())
while t > 0:
n = int(input())
a = [int(ele) for ele in input().split()]
b = set([])
for i in range(n):
if a[i] == -1:
if i == 0:
if a[i+1] != -1:
b.add(a[i+1])
elif i > 0 and i < n-1:
if a[i-1] != -1:
b.add(a[i-1])
if a[i+1] != -1:
b.add(a[i+1])
else:
if a[i-1] != -1:
b.add(a[i-1])
if a.count(-1) == 0:
diff = -1
for i in range(n-1):
if abs(a[i]-a[i+1]) > diff:
diff = abs(a[i]-a[i+1])
print(diff, 1)
else:
if len(b) == 0:
for i in range(n):
if a[i] == -1:
a[i] = 1
print(0, 1)
else:
mini = min(b)
maxi = max(b)
ele = int((mini+maxi)/2)
for i in range(n):
if a[i] == -1:
a[i] = ele
diff = -1
for i in range(n-1):
if abs(a[i]-a[i+1]) > diff:
diff = abs(a[i]-a[i+1])
print(diff, ele)
t -= 1
``` | output | 1 | 59,838 | 12 | 119,677 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dark is going to attend Motarack's birthday. Dark decided that the gift he is going to give to Motarack is an array a of n non-negative integers.
Dark created that array 1000 years ago, so some elements in that array disappeared. Dark knows that Motarack hates to see an array that has two adjacent elements with a high absolute difference between them. He doesn't have much time so he wants to choose an integer k (0 ≤ k ≤ 10^{9}) and replaces all missing elements in the array a with k.
Let m be the maximum absolute difference between all adjacent elements (i.e. the maximum value of |a_i - a_{i+1}| for all 1 ≤ i ≤ n - 1) in the array a after Dark replaces all missing elements with k.
Dark should choose an integer k so that m is minimized. Can you help him?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^{5}) — the size of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (-1 ≤ a_i ≤ 10 ^ {9}). If a_i = -1, then the i-th integer is missing. It is guaranteed that at least one integer is missing in every test case.
It is guaranteed, that the sum of n for all test cases does not exceed 4 ⋅ 10 ^ {5}.
Output
Print the answers for each test case in the following format:
You should print two integers, the minimum possible value of m and an integer k (0 ≤ k ≤ 10^{9}) that makes the maximum absolute difference between adjacent elements in the array a equal to m.
Make sure that after replacing all the missing elements with k, the maximum absolute difference between adjacent elements becomes m.
If there is more than one possible k, you can print any of them.
Example
Input
7
5
-1 10 -1 12 -1
5
-1 40 35 -1 35
6
-1 -1 9 -1 3 -1
2
-1 -1
2
0 -1
4
1 -1 3 -1
7
1 -1 7 5 2 -1 5
Output
1 11
5 35
3 6
0 42
0 0
1 2
3 4
Note
In the first test case after replacing all missing elements with 11 the array becomes [11, 10, 11, 12, 11]. The absolute difference between any adjacent elements is 1. It is impossible to choose a value of k, such that the absolute difference between any adjacent element will be ≤ 0. So, the answer is 1.
In the third test case after replacing all missing elements with 6 the array becomes [6, 6, 9, 6, 3, 6].
* |a_1 - a_2| = |6 - 6| = 0;
* |a_2 - a_3| = |6 - 9| = 3;
* |a_3 - a_4| = |9 - 6| = 3;
* |a_4 - a_5| = |6 - 3| = 3;
* |a_5 - a_6| = |3 - 6| = 3.
So, the maximum difference between any adjacent elements is 3. | instruction | 0 | 59,839 | 12 | 119,678 |
Tags: binary search, greedy, ternary search
Correct Solution:
```
#1301B
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
ans = []
for i in range(len(a)):
if a[i] == -1:
if i > 0 and a[i-1] != -1:
ans.append(a[i-1])
if i < n-1 and a[i+1] != -1:
ans.append(a[i+1])
if len(ans) == 0:
amin = 1
amax = 1
else:
amin = min(ans)
amax = max(ans)
k = (amin+amax)//2
m = 0
for i in range(1, len(a)):
if a[i-1] == -1:
a[i-1] = k
if a[i] == -1:
a[i] = k
m = max(m, abs(a[i]-a[i-1]))
print(m, k)
``` | output | 1 | 59,839 | 12 | 119,679 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dark is going to attend Motarack's birthday. Dark decided that the gift he is going to give to Motarack is an array a of n non-negative integers.
Dark created that array 1000 years ago, so some elements in that array disappeared. Dark knows that Motarack hates to see an array that has two adjacent elements with a high absolute difference between them. He doesn't have much time so he wants to choose an integer k (0 ≤ k ≤ 10^{9}) and replaces all missing elements in the array a with k.
Let m be the maximum absolute difference between all adjacent elements (i.e. the maximum value of |a_i - a_{i+1}| for all 1 ≤ i ≤ n - 1) in the array a after Dark replaces all missing elements with k.
Dark should choose an integer k so that m is minimized. Can you help him?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^{5}) — the size of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (-1 ≤ a_i ≤ 10 ^ {9}). If a_i = -1, then the i-th integer is missing. It is guaranteed that at least one integer is missing in every test case.
It is guaranteed, that the sum of n for all test cases does not exceed 4 ⋅ 10 ^ {5}.
Output
Print the answers for each test case in the following format:
You should print two integers, the minimum possible value of m and an integer k (0 ≤ k ≤ 10^{9}) that makes the maximum absolute difference between adjacent elements in the array a equal to m.
Make sure that after replacing all the missing elements with k, the maximum absolute difference between adjacent elements becomes m.
If there is more than one possible k, you can print any of them.
Example
Input
7
5
-1 10 -1 12 -1
5
-1 40 35 -1 35
6
-1 -1 9 -1 3 -1
2
-1 -1
2
0 -1
4
1 -1 3 -1
7
1 -1 7 5 2 -1 5
Output
1 11
5 35
3 6
0 42
0 0
1 2
3 4
Note
In the first test case after replacing all missing elements with 11 the array becomes [11, 10, 11, 12, 11]. The absolute difference between any adjacent elements is 1. It is impossible to choose a value of k, such that the absolute difference between any adjacent element will be ≤ 0. So, the answer is 1.
In the third test case after replacing all missing elements with 6 the array becomes [6, 6, 9, 6, 3, 6].
* |a_1 - a_2| = |6 - 6| = 0;
* |a_2 - a_3| = |6 - 9| = 3;
* |a_3 - a_4| = |9 - 6| = 3;
* |a_4 - a_5| = |6 - 3| = 3;
* |a_5 - a_6| = |3 - 6| = 3.
So, the maximum difference between any adjacent elements is 3. | instruction | 0 | 59,840 | 12 | 119,680 |
Tags: binary search, greedy, ternary search
Correct Solution:
```
def calc(val,lista):
mx=0
for i in range(1,len(lista)):
x,y=lista[i],lista[i-1]
if x==-1:
x=val
if y==-1:
y=val
mx=max(mx,abs(x-y))
return(mx)
for _ in range(int(input())):
n=int(input())
a=[int(i) for i in input().split()]
l,ret,h,m=0,0,10000000000,10000000000
while l<h:
mid=(l+(h-1))//2
mx1=calc(mid,a)
mx2=calc(mid+1,a)
#print(mx1,mx2,l,h,mid,ret)
if mx1<=mx2:
m=mx1
#ret=mid
h=mid
else:
m=mx2
ret=mid+1
l=mid+1
if m==10000000000:
m=0
print(m,ret)
``` | output | 1 | 59,840 | 12 | 119,681 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dark is going to attend Motarack's birthday. Dark decided that the gift he is going to give to Motarack is an array a of n non-negative integers.
Dark created that array 1000 years ago, so some elements in that array disappeared. Dark knows that Motarack hates to see an array that has two adjacent elements with a high absolute difference between them. He doesn't have much time so he wants to choose an integer k (0 ≤ k ≤ 10^{9}) and replaces all missing elements in the array a with k.
Let m be the maximum absolute difference between all adjacent elements (i.e. the maximum value of |a_i - a_{i+1}| for all 1 ≤ i ≤ n - 1) in the array a after Dark replaces all missing elements with k.
Dark should choose an integer k so that m is minimized. Can you help him?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^{5}) — the size of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (-1 ≤ a_i ≤ 10 ^ {9}). If a_i = -1, then the i-th integer is missing. It is guaranteed that at least one integer is missing in every test case.
It is guaranteed, that the sum of n for all test cases does not exceed 4 ⋅ 10 ^ {5}.
Output
Print the answers for each test case in the following format:
You should print two integers, the minimum possible value of m and an integer k (0 ≤ k ≤ 10^{9}) that makes the maximum absolute difference between adjacent elements in the array a equal to m.
Make sure that after replacing all the missing elements with k, the maximum absolute difference between adjacent elements becomes m.
If there is more than one possible k, you can print any of them.
Example
Input
7
5
-1 10 -1 12 -1
5
-1 40 35 -1 35
6
-1 -1 9 -1 3 -1
2
-1 -1
2
0 -1
4
1 -1 3 -1
7
1 -1 7 5 2 -1 5
Output
1 11
5 35
3 6
0 42
0 0
1 2
3 4
Note
In the first test case after replacing all missing elements with 11 the array becomes [11, 10, 11, 12, 11]. The absolute difference between any adjacent elements is 1. It is impossible to choose a value of k, such that the absolute difference between any adjacent element will be ≤ 0. So, the answer is 1.
In the third test case after replacing all missing elements with 6 the array becomes [6, 6, 9, 6, 3, 6].
* |a_1 - a_2| = |6 - 6| = 0;
* |a_2 - a_3| = |6 - 9| = 3;
* |a_3 - a_4| = |9 - 6| = 3;
* |a_4 - a_5| = |6 - 3| = 3;
* |a_5 - a_6| = |3 - 6| = 3.
So, the maximum difference between any adjacent elements is 3. | instruction | 0 | 59,841 | 12 | 119,682 |
Tags: binary search, greedy, ternary search
Correct Solution:
```
num_t = int(input())
for _ in range(num_t):
input()
arr = [int(i) for i in input().split()]
min_p = float('inf')
max_p = float('-inf')
found = False
for i in range(len(arr)):
if arr[i] == -1 and i - 1 >= 0 and arr[i - 1] != -1:
min_p = min(arr[i - 1], min_p)
max_p = max(arr[i - 1], max_p)
found = True
if arr[i] == -1 and i + 1 < len(arr) and arr[i + 1] != -1:
min_p = min(arr[i + 1], min_p)
max_p = max(arr[i + 1], max_p)
found = True
if not found:
print (0, 0)
continue
k = (max_p + min_p) // 2
m = float('-inf')
for i in range(1, len(arr)):
if arr[i] != -1 and arr[i - 1] != -1:
m = max(abs(arr[i] - arr[i - 1]), m)
print (max(m, max_p - k, k - min_p), k)
``` | output | 1 | 59,841 | 12 | 119,683 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dark is going to attend Motarack's birthday. Dark decided that the gift he is going to give to Motarack is an array a of n non-negative integers.
Dark created that array 1000 years ago, so some elements in that array disappeared. Dark knows that Motarack hates to see an array that has two adjacent elements with a high absolute difference between them. He doesn't have much time so he wants to choose an integer k (0 ≤ k ≤ 10^{9}) and replaces all missing elements in the array a with k.
Let m be the maximum absolute difference between all adjacent elements (i.e. the maximum value of |a_i - a_{i+1}| for all 1 ≤ i ≤ n - 1) in the array a after Dark replaces all missing elements with k.
Dark should choose an integer k so that m is minimized. Can you help him?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^{5}) — the size of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (-1 ≤ a_i ≤ 10 ^ {9}). If a_i = -1, then the i-th integer is missing. It is guaranteed that at least one integer is missing in every test case.
It is guaranteed, that the sum of n for all test cases does not exceed 4 ⋅ 10 ^ {5}.
Output
Print the answers for each test case in the following format:
You should print two integers, the minimum possible value of m and an integer k (0 ≤ k ≤ 10^{9}) that makes the maximum absolute difference between adjacent elements in the array a equal to m.
Make sure that after replacing all the missing elements with k, the maximum absolute difference between adjacent elements becomes m.
If there is more than one possible k, you can print any of them.
Example
Input
7
5
-1 10 -1 12 -1
5
-1 40 35 -1 35
6
-1 -1 9 -1 3 -1
2
-1 -1
2
0 -1
4
1 -1 3 -1
7
1 -1 7 5 2 -1 5
Output
1 11
5 35
3 6
0 42
0 0
1 2
3 4
Note
In the first test case after replacing all missing elements with 11 the array becomes [11, 10, 11, 12, 11]. The absolute difference between any adjacent elements is 1. It is impossible to choose a value of k, such that the absolute difference between any adjacent element will be ≤ 0. So, the answer is 1.
In the third test case after replacing all missing elements with 6 the array becomes [6, 6, 9, 6, 3, 6].
* |a_1 - a_2| = |6 - 6| = 0;
* |a_2 - a_3| = |6 - 9| = 3;
* |a_3 - a_4| = |9 - 6| = 3;
* |a_4 - a_5| = |6 - 3| = 3;
* |a_5 - a_6| = |3 - 6| = 3.
So, the maximum difference between any adjacent elements is 3.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
arr = list(map(int,input().split()))
m = 0
for i in range(1,n):
if arr[i]!=-1 and arr[i-1]!=-1:
m = max(m,abs(arr[i]-arr[i-1]))
maxx = 0
minn = 10**9
for i in range(1,n-1):
if arr[i]==-1:
if arr[i-1]!=-1:
maxx = max(maxx,arr[i-1])
minn = min(minn,arr[i-1])
if arr[i+1]!=-1:
maxx = max(maxx,arr[i+1])
minn = min(minn,arr[i+1])
if arr[0]==-1:
if arr[1]!=-1:
maxx = max(maxx, arr[1])
minn = min(minn, arr[1])
if arr[-1]==-1:
if arr[-2]!=-1:
maxx = max(maxx,arr[-2])
minn = min(minn, arr[-2])
if m==0:
if maxx==0 and minn==10**9:
print(0,1)
else:
x = (maxx+minn)//2
print(max(maxx-x, x-minn),x)
else:
b = False
x = (maxx+minn)//2
if max(maxx-x,x-minn)>m:
print(max(maxx-x,x-minn),x)
else:
print(m,x)
``` | instruction | 0 | 59,842 | 12 | 119,684 |
Yes | output | 1 | 59,842 | 12 | 119,685 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dark is going to attend Motarack's birthday. Dark decided that the gift he is going to give to Motarack is an array a of n non-negative integers.
Dark created that array 1000 years ago, so some elements in that array disappeared. Dark knows that Motarack hates to see an array that has two adjacent elements with a high absolute difference between them. He doesn't have much time so he wants to choose an integer k (0 ≤ k ≤ 10^{9}) and replaces all missing elements in the array a with k.
Let m be the maximum absolute difference between all adjacent elements (i.e. the maximum value of |a_i - a_{i+1}| for all 1 ≤ i ≤ n - 1) in the array a after Dark replaces all missing elements with k.
Dark should choose an integer k so that m is minimized. Can you help him?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^{5}) — the size of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (-1 ≤ a_i ≤ 10 ^ {9}). If a_i = -1, then the i-th integer is missing. It is guaranteed that at least one integer is missing in every test case.
It is guaranteed, that the sum of n for all test cases does not exceed 4 ⋅ 10 ^ {5}.
Output
Print the answers for each test case in the following format:
You should print two integers, the minimum possible value of m and an integer k (0 ≤ k ≤ 10^{9}) that makes the maximum absolute difference between adjacent elements in the array a equal to m.
Make sure that after replacing all the missing elements with k, the maximum absolute difference between adjacent elements becomes m.
If there is more than one possible k, you can print any of them.
Example
Input
7
5
-1 10 -1 12 -1
5
-1 40 35 -1 35
6
-1 -1 9 -1 3 -1
2
-1 -1
2
0 -1
4
1 -1 3 -1
7
1 -1 7 5 2 -1 5
Output
1 11
5 35
3 6
0 42
0 0
1 2
3 4
Note
In the first test case after replacing all missing elements with 11 the array becomes [11, 10, 11, 12, 11]. The absolute difference between any adjacent elements is 1. It is impossible to choose a value of k, such that the absolute difference between any adjacent element will be ≤ 0. So, the answer is 1.
In the third test case after replacing all missing elements with 6 the array becomes [6, 6, 9, 6, 3, 6].
* |a_1 - a_2| = |6 - 6| = 0;
* |a_2 - a_3| = |6 - 9| = 3;
* |a_3 - a_4| = |9 - 6| = 3;
* |a_4 - a_5| = |6 - 3| = 3;
* |a_5 - a_6| = |3 - 6| = 3.
So, the maximum difference between any adjacent elements is 3.
Submitted Solution:
```
# n = int(input())
# A, B, C = [], [], []
# for i in range(n):
# A.append(input())
# B.append(input())
# C.append(input())
# ans = ['NO'] * n
# for i in range(len(A)):
# c = 0
# for j in range(len(A[i])):
# if A[i][j] == C[i][j] or B[i][j] == C[i][j]:
# c += 1
# if c == len(A[i]):
# ans[i] = 'YES'
#
# for a in ans:
# print(a)
t = int(input())
ans = []
for i in range(t):
n = int(input())
a = [int(p) for p in input().split(' ')]
m = 0
s = set()
for j in range(0, n):
if a[j] == -1:
if j > 0 and a[j - 1] != -1:
s.add(a[j - 1])
if j < n - 1 and a[j + 1] != -1:
s.add(a[j + 1])
s = list(s)
s.sort()
k = 0
if s:
k = (s[0] + s[-1]) // 2
m = 0
if a[0] == -1:
a[0] = k
for j in range(1, n):
if a[j] == -1:
a[j] = k
m = max(m, abs(a[j] - a[j - 1]))
ans.append([m, k])
for a in ans:
print(int(a[0]), int(a[1]))
# 7
# 5
# -1 10 -1 12 -1
# 5
# -1 40 35 -1 35
# 6
# -1 -1 9 -1 3 -1
# 2
# -1 -1
# 2
# 0 -1
# 4
# 1 -1 3 -1
# 7
# 1 -1 7 5 2 -1 5
``` | instruction | 0 | 59,843 | 12 | 119,686 |
Yes | output | 1 | 59,843 | 12 | 119,687 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dark is going to attend Motarack's birthday. Dark decided that the gift he is going to give to Motarack is an array a of n non-negative integers.
Dark created that array 1000 years ago, so some elements in that array disappeared. Dark knows that Motarack hates to see an array that has two adjacent elements with a high absolute difference between them. He doesn't have much time so he wants to choose an integer k (0 ≤ k ≤ 10^{9}) and replaces all missing elements in the array a with k.
Let m be the maximum absolute difference between all adjacent elements (i.e. the maximum value of |a_i - a_{i+1}| for all 1 ≤ i ≤ n - 1) in the array a after Dark replaces all missing elements with k.
Dark should choose an integer k so that m is minimized. Can you help him?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^{5}) — the size of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (-1 ≤ a_i ≤ 10 ^ {9}). If a_i = -1, then the i-th integer is missing. It is guaranteed that at least one integer is missing in every test case.
It is guaranteed, that the sum of n for all test cases does not exceed 4 ⋅ 10 ^ {5}.
Output
Print the answers for each test case in the following format:
You should print two integers, the minimum possible value of m and an integer k (0 ≤ k ≤ 10^{9}) that makes the maximum absolute difference between adjacent elements in the array a equal to m.
Make sure that after replacing all the missing elements with k, the maximum absolute difference between adjacent elements becomes m.
If there is more than one possible k, you can print any of them.
Example
Input
7
5
-1 10 -1 12 -1
5
-1 40 35 -1 35
6
-1 -1 9 -1 3 -1
2
-1 -1
2
0 -1
4
1 -1 3 -1
7
1 -1 7 5 2 -1 5
Output
1 11
5 35
3 6
0 42
0 0
1 2
3 4
Note
In the first test case after replacing all missing elements with 11 the array becomes [11, 10, 11, 12, 11]. The absolute difference between any adjacent elements is 1. It is impossible to choose a value of k, such that the absolute difference between any adjacent element will be ≤ 0. So, the answer is 1.
In the third test case after replacing all missing elements with 6 the array becomes [6, 6, 9, 6, 3, 6].
* |a_1 - a_2| = |6 - 6| = 0;
* |a_2 - a_3| = |6 - 9| = 3;
* |a_3 - a_4| = |9 - 6| = 3;
* |a_4 - a_5| = |6 - 3| = 3;
* |a_5 - a_6| = |3 - 6| = 3.
So, the maximum difference between any adjacent elements is 3.
Submitted Solution:
```
t = int(input())
for z in range(t):
n = int(input())
a = list(map(int, input().split()))
ma = 0
mi = 10**9
maM = 0
i = 0
j = 1
f = 0
while j < n:
if a[j] == -1 and a[i] != -1:
f = 1
if a[i] > ma:
ma = a[i]
if a[i] < mi:
mi = a[i]
if a[i] == -1 and a[j] != -1:
f = 1
if a[j] > ma:
ma = a[j]
if a[j] < mi:
mi = a[j]
if a[i] != -1 and a[j] != -1:
if abs(a[i] - a[j]) > maM:
maM = abs(a[i] - a[j])
i+=1
j+=1
k = (ma + mi)//2
m1 = max(abs(ma - k), abs(mi - k))
m = max(m1, maM)
if f == 0 and maM == 0:
print(0, k)
else:
print(m, k)
``` | instruction | 0 | 59,844 | 12 | 119,688 |
Yes | output | 1 | 59,844 | 12 | 119,689 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dark is going to attend Motarack's birthday. Dark decided that the gift he is going to give to Motarack is an array a of n non-negative integers.
Dark created that array 1000 years ago, so some elements in that array disappeared. Dark knows that Motarack hates to see an array that has two adjacent elements with a high absolute difference between them. He doesn't have much time so he wants to choose an integer k (0 ≤ k ≤ 10^{9}) and replaces all missing elements in the array a with k.
Let m be the maximum absolute difference between all adjacent elements (i.e. the maximum value of |a_i - a_{i+1}| for all 1 ≤ i ≤ n - 1) in the array a after Dark replaces all missing elements with k.
Dark should choose an integer k so that m is minimized. Can you help him?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^{5}) — the size of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (-1 ≤ a_i ≤ 10 ^ {9}). If a_i = -1, then the i-th integer is missing. It is guaranteed that at least one integer is missing in every test case.
It is guaranteed, that the sum of n for all test cases does not exceed 4 ⋅ 10 ^ {5}.
Output
Print the answers for each test case in the following format:
You should print two integers, the minimum possible value of m and an integer k (0 ≤ k ≤ 10^{9}) that makes the maximum absolute difference between adjacent elements in the array a equal to m.
Make sure that after replacing all the missing elements with k, the maximum absolute difference between adjacent elements becomes m.
If there is more than one possible k, you can print any of them.
Example
Input
7
5
-1 10 -1 12 -1
5
-1 40 35 -1 35
6
-1 -1 9 -1 3 -1
2
-1 -1
2
0 -1
4
1 -1 3 -1
7
1 -1 7 5 2 -1 5
Output
1 11
5 35
3 6
0 42
0 0
1 2
3 4
Note
In the first test case after replacing all missing elements with 11 the array becomes [11, 10, 11, 12, 11]. The absolute difference between any adjacent elements is 1. It is impossible to choose a value of k, such that the absolute difference between any adjacent element will be ≤ 0. So, the answer is 1.
In the third test case after replacing all missing elements with 6 the array becomes [6, 6, 9, 6, 3, 6].
* |a_1 - a_2| = |6 - 6| = 0;
* |a_2 - a_3| = |6 - 9| = 3;
* |a_3 - a_4| = |9 - 6| = 3;
* |a_4 - a_5| = |6 - 3| = 3;
* |a_5 - a_6| = |3 - 6| = 3.
So, the maximum difference between any adjacent elements is 3.
Submitted Solution:
```
t=int(input())
while (t>0):
t=t-1
n=int(input())
a=list(map(int,input().split()))
b=[]
c=[]
for i in range(n-1):
if (a[i+1]==-1 and a[i]!=-1):
b.append(a[i])
elif (a[i]==-1 and a[i+1]!=-1):
b.append(a[i+1])
if (len(b)<=0):
x=42
else:
x=(max(b)+min(b))//2
for i in range(n):
if (a[i]==-1):
a[i]=x
for i in range(n-1):
c.append(abs(a[i]-a[i+1]))
print(max(c),x)
``` | instruction | 0 | 59,845 | 12 | 119,690 |
Yes | output | 1 | 59,845 | 12 | 119,691 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dark is going to attend Motarack's birthday. Dark decided that the gift he is going to give to Motarack is an array a of n non-negative integers.
Dark created that array 1000 years ago, so some elements in that array disappeared. Dark knows that Motarack hates to see an array that has two adjacent elements with a high absolute difference between them. He doesn't have much time so he wants to choose an integer k (0 ≤ k ≤ 10^{9}) and replaces all missing elements in the array a with k.
Let m be the maximum absolute difference between all adjacent elements (i.e. the maximum value of |a_i - a_{i+1}| for all 1 ≤ i ≤ n - 1) in the array a after Dark replaces all missing elements with k.
Dark should choose an integer k so that m is minimized. Can you help him?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^{5}) — the size of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (-1 ≤ a_i ≤ 10 ^ {9}). If a_i = -1, then the i-th integer is missing. It is guaranteed that at least one integer is missing in every test case.
It is guaranteed, that the sum of n for all test cases does not exceed 4 ⋅ 10 ^ {5}.
Output
Print the answers for each test case in the following format:
You should print two integers, the minimum possible value of m and an integer k (0 ≤ k ≤ 10^{9}) that makes the maximum absolute difference between adjacent elements in the array a equal to m.
Make sure that after replacing all the missing elements with k, the maximum absolute difference between adjacent elements becomes m.
If there is more than one possible k, you can print any of them.
Example
Input
7
5
-1 10 -1 12 -1
5
-1 40 35 -1 35
6
-1 -1 9 -1 3 -1
2
-1 -1
2
0 -1
4
1 -1 3 -1
7
1 -1 7 5 2 -1 5
Output
1 11
5 35
3 6
0 42
0 0
1 2
3 4
Note
In the first test case after replacing all missing elements with 11 the array becomes [11, 10, 11, 12, 11]. The absolute difference between any adjacent elements is 1. It is impossible to choose a value of k, such that the absolute difference between any adjacent element will be ≤ 0. So, the answer is 1.
In the third test case after replacing all missing elements with 6 the array becomes [6, 6, 9, 6, 3, 6].
* |a_1 - a_2| = |6 - 6| = 0;
* |a_2 - a_3| = |6 - 9| = 3;
* |a_3 - a_4| = |9 - 6| = 3;
* |a_4 - a_5| = |6 - 3| = 3;
* |a_5 - a_6| = |3 - 6| = 3.
So, the maximum difference between any adjacent elements is 3.
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int,input().split()))
minAdj = max(a)
maxAdj = min(a)
if a[0] == -1:
if a[1] != -1:
if a[1] > maxAdj:
maxAdj = a[1]
if a[1] < minAdj:
minAdj = a[1]
if a[n-1] == -1:
if a[n-1] != -1:
if a[n-1] > maxAdj:
maxAdj = a[n-1]
if a[n-1] < minAdj:
minAdj = a[n-1]
for i in range(1, n-1):
if a[i - 1] != -1:
if a[i - 1] > maxAdj:
maxAdj = a[i - 1]
if a[i - 1] < minAdj:
minAdj = a[i - 1]
if a[i + 1] != -1:
if a[i + 1] > maxAdj:
maxAdj = a[i + 1]
if a[i + 1] < minAdj:
minAdj = a[i + 1]
if minAdj == -1 and maxAdj == -1:
minAdj = 0
maxAdj = 0
elif minAdj == -1:
minAdj = maxAdj
elif maxAdj == -1:
maxAdj = minAdj
m = 0
k = (maxAdj + minAdj)//2
if a[0] == -1:
a[0] = k
for i in range(1,n):
if a[i] == -1:
a[i] = k
m = max(a[i] - a[i - 1],m)
print(*[m,k])
``` | instruction | 0 | 59,846 | 12 | 119,692 |
No | output | 1 | 59,846 | 12 | 119,693 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dark is going to attend Motarack's birthday. Dark decided that the gift he is going to give to Motarack is an array a of n non-negative integers.
Dark created that array 1000 years ago, so some elements in that array disappeared. Dark knows that Motarack hates to see an array that has two adjacent elements with a high absolute difference between them. He doesn't have much time so he wants to choose an integer k (0 ≤ k ≤ 10^{9}) and replaces all missing elements in the array a with k.
Let m be the maximum absolute difference between all adjacent elements (i.e. the maximum value of |a_i - a_{i+1}| for all 1 ≤ i ≤ n - 1) in the array a after Dark replaces all missing elements with k.
Dark should choose an integer k so that m is minimized. Can you help him?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^{5}) — the size of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (-1 ≤ a_i ≤ 10 ^ {9}). If a_i = -1, then the i-th integer is missing. It is guaranteed that at least one integer is missing in every test case.
It is guaranteed, that the sum of n for all test cases does not exceed 4 ⋅ 10 ^ {5}.
Output
Print the answers for each test case in the following format:
You should print two integers, the minimum possible value of m and an integer k (0 ≤ k ≤ 10^{9}) that makes the maximum absolute difference between adjacent elements in the array a equal to m.
Make sure that after replacing all the missing elements with k, the maximum absolute difference between adjacent elements becomes m.
If there is more than one possible k, you can print any of them.
Example
Input
7
5
-1 10 -1 12 -1
5
-1 40 35 -1 35
6
-1 -1 9 -1 3 -1
2
-1 -1
2
0 -1
4
1 -1 3 -1
7
1 -1 7 5 2 -1 5
Output
1 11
5 35
3 6
0 42
0 0
1 2
3 4
Note
In the first test case after replacing all missing elements with 11 the array becomes [11, 10, 11, 12, 11]. The absolute difference between any adjacent elements is 1. It is impossible to choose a value of k, such that the absolute difference between any adjacent element will be ≤ 0. So, the answer is 1.
In the third test case after replacing all missing elements with 6 the array becomes [6, 6, 9, 6, 3, 6].
* |a_1 - a_2| = |6 - 6| = 0;
* |a_2 - a_3| = |6 - 9| = 3;
* |a_3 - a_4| = |9 - 6| = 3;
* |a_4 - a_5| = |6 - 3| = 3;
* |a_5 - a_6| = |3 - 6| = 3.
So, the maximum difference between any adjacent elements is 3.
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Sun Jan 5 22:03:30 2020
@author: B JAGDISH REDDY
arr=[int(i) for i in input().split(" ")]
a=[]
k=0
if(sum(arr)%2==1):
print("YES")
else:
for i in range(n):
if arr[i]%2==1:
a.append(arr[i])
for i in range(n):
if arr[i]%2==0:
k=i
break
if(len(a)!=0):
arr[k]=a[0]
if(sum(arr)%2==1):
print("YES")
else:
print("NO")
n=0
prev=0
c=0
for j in range(len(s)):
if(s[j]=='1'):
prev=j
break
n=prev
cur=prev
for j in range(n+1,len(s)):
if(s[j]=='1'):
if(j-prev==1):
prev=j
else:
n=j-cur-1
c=c+n
cur=j
print(c)
///////////////////////////
a=list(input())
b=list(input())
c=list(input())
p=1
swap=0
for j in range(len(a)):
if(a[j]!=b[j] and c[j]==b[j]):
a[j]=c[j]
swap+=1
elif(a[j]!=b[j] and c[j]==a[j]):
b[j]=a[j]
swap+=1
elif(a[j]==b[j] and b[j]==c[j]):
swap+=1
if(swap==len(a)):
for k in range(len(a)):
if(a[k]!=b[k]):
p=0
break
if(p):
print("YES")
else:
print("NO")
else:
print("NO")
"""
n=int(input())
for i in range(n):
l=int(input())
a=[int(i) for i in input().split(" ")]
s=0
c=0
k=0
temp=0
for i in range(l):
if(a[i]>=0):
s=s+a[i]
c+=1
if(c>0):
k=s//c
for i in range(l):
if(a[i]==-1):
a[i]=k
for i in range(l-1):
if(temp<abs(a[i]-a[i+1])):
temp=abs(a[i]-a[i+1])
print(temp,k)
``` | instruction | 0 | 59,847 | 12 | 119,694 |
No | output | 1 | 59,847 | 12 | 119,695 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dark is going to attend Motarack's birthday. Dark decided that the gift he is going to give to Motarack is an array a of n non-negative integers.
Dark created that array 1000 years ago, so some elements in that array disappeared. Dark knows that Motarack hates to see an array that has two adjacent elements with a high absolute difference between them. He doesn't have much time so he wants to choose an integer k (0 ≤ k ≤ 10^{9}) and replaces all missing elements in the array a with k.
Let m be the maximum absolute difference between all adjacent elements (i.e. the maximum value of |a_i - a_{i+1}| for all 1 ≤ i ≤ n - 1) in the array a after Dark replaces all missing elements with k.
Dark should choose an integer k so that m is minimized. Can you help him?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^{5}) — the size of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (-1 ≤ a_i ≤ 10 ^ {9}). If a_i = -1, then the i-th integer is missing. It is guaranteed that at least one integer is missing in every test case.
It is guaranteed, that the sum of n for all test cases does not exceed 4 ⋅ 10 ^ {5}.
Output
Print the answers for each test case in the following format:
You should print two integers, the minimum possible value of m and an integer k (0 ≤ k ≤ 10^{9}) that makes the maximum absolute difference between adjacent elements in the array a equal to m.
Make sure that after replacing all the missing elements with k, the maximum absolute difference between adjacent elements becomes m.
If there is more than one possible k, you can print any of them.
Example
Input
7
5
-1 10 -1 12 -1
5
-1 40 35 -1 35
6
-1 -1 9 -1 3 -1
2
-1 -1
2
0 -1
4
1 -1 3 -1
7
1 -1 7 5 2 -1 5
Output
1 11
5 35
3 6
0 42
0 0
1 2
3 4
Note
In the first test case after replacing all missing elements with 11 the array becomes [11, 10, 11, 12, 11]. The absolute difference between any adjacent elements is 1. It is impossible to choose a value of k, such that the absolute difference between any adjacent element will be ≤ 0. So, the answer is 1.
In the third test case after replacing all missing elements with 6 the array becomes [6, 6, 9, 6, 3, 6].
* |a_1 - a_2| = |6 - 6| = 0;
* |a_2 - a_3| = |6 - 9| = 3;
* |a_3 - a_4| = |9 - 6| = 3;
* |a_4 - a_5| = |6 - 3| = 3;
* |a_5 - a_6| = |3 - 6| = 3.
So, the maximum difference between any adjacent elements is 3.
Submitted Solution:
```
from math import ceil,sqrt,gcd
def ii(): return int(input())
def si(): return input()
def mi(): return map(int,input().strip().split(" "))
def li(): return list(mi())
t=ii()
while(t):
t-=1
n=ii()
a=li()
s=1
f=0
b=a[:]
f1=0
for i in range(n-1):
if(f==0):
if(a[i]!=-1):
s=a[i]
f=1
else:
a[i]=s
else:
if(a[i]==-1 and a[i+1]!=-1):
x=abs(a[i-1]-a[i+1])//2
if(a[i-1]>a[i+1]):
if(f1):
s=max(s,a[i-1]-x)
else:
s=a[i-1]-x
else:
if(f1):
s=max(s,a[i-1]+x)
else:
s=a[i-1]+x
f1=1
if(a[i]==-1):
a[i]=s
if(a[n-1]==-1):
a[n-1]=s
if(f==0):
print(0,1)
else:
x=0
for i in range(n):
if(b[i]==-1):
b[i]=s
x=abs(b[1]-b[0])
for i in range(1,n-1):
s1=max(abs(b[i]-b[i-1]),abs(b[i]-b[i+1]))
x=max(x,s1)
print(x,s)
``` | instruction | 0 | 59,848 | 12 | 119,696 |
No | output | 1 | 59,848 | 12 | 119,697 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dark is going to attend Motarack's birthday. Dark decided that the gift he is going to give to Motarack is an array a of n non-negative integers.
Dark created that array 1000 years ago, so some elements in that array disappeared. Dark knows that Motarack hates to see an array that has two adjacent elements with a high absolute difference between them. He doesn't have much time so he wants to choose an integer k (0 ≤ k ≤ 10^{9}) and replaces all missing elements in the array a with k.
Let m be the maximum absolute difference between all adjacent elements (i.e. the maximum value of |a_i - a_{i+1}| for all 1 ≤ i ≤ n - 1) in the array a after Dark replaces all missing elements with k.
Dark should choose an integer k so that m is minimized. Can you help him?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^{5}) — the size of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (-1 ≤ a_i ≤ 10 ^ {9}). If a_i = -1, then the i-th integer is missing. It is guaranteed that at least one integer is missing in every test case.
It is guaranteed, that the sum of n for all test cases does not exceed 4 ⋅ 10 ^ {5}.
Output
Print the answers for each test case in the following format:
You should print two integers, the minimum possible value of m and an integer k (0 ≤ k ≤ 10^{9}) that makes the maximum absolute difference between adjacent elements in the array a equal to m.
Make sure that after replacing all the missing elements with k, the maximum absolute difference between adjacent elements becomes m.
If there is more than one possible k, you can print any of them.
Example
Input
7
5
-1 10 -1 12 -1
5
-1 40 35 -1 35
6
-1 -1 9 -1 3 -1
2
-1 -1
2
0 -1
4
1 -1 3 -1
7
1 -1 7 5 2 -1 5
Output
1 11
5 35
3 6
0 42
0 0
1 2
3 4
Note
In the first test case after replacing all missing elements with 11 the array becomes [11, 10, 11, 12, 11]. The absolute difference between any adjacent elements is 1. It is impossible to choose a value of k, such that the absolute difference between any adjacent element will be ≤ 0. So, the answer is 1.
In the third test case after replacing all missing elements with 6 the array becomes [6, 6, 9, 6, 3, 6].
* |a_1 - a_2| = |6 - 6| = 0;
* |a_2 - a_3| = |6 - 9| = 3;
* |a_3 - a_4| = |9 - 6| = 3;
* |a_4 - a_5| = |6 - 3| = 3;
* |a_5 - a_6| = |3 - 6| = 3.
So, the maximum difference between any adjacent elements is 3.
Submitted Solution:
```
import sys
input = sys.stdin.readline
def solve():
n = int(input())
al = list(map(int,input().split()))
av = nm = 0
for i in range(n):
if al[i]!=-1:
if (i>0 and al[i-1]==-1) or (i<n-1 and al[i+1]==-1):
nm+=1
av+=al[i]
if nm==0:
print(0,1)
return
k = av//nm + (1 if (av/nm)%1>0.5 else 0)
for i in range(n):
if al[i]==-1: al[i] = k;
mx = 0;
for i in range(n-1): mx = max(mx,abs(al[i]-al[i+1]))
print(mx,k)
def main():
t = int(input())
for _ in range(t):
solve()
main()
``` | instruction | 0 | 59,849 | 12 | 119,698 |
No | output | 1 | 59,849 | 12 | 119,699 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ehab has an array a of length n. He has just enough free time to make a new array consisting of n copies of the old array, written back-to-back. What will be the length of the new array's longest increasing subsequence?
A sequence a is a subsequence of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements. The longest increasing subsequence of an array is the longest subsequence such that its elements are ordered in strictly increasing order.
Input
The first line contains an integer t — the number of test cases you need to solve. The description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (1 ≤ a_i ≤ 10^9) — the elements of the array a.
The sum of n across the test cases doesn't exceed 10^5.
Output
For each testcase, output the length of the longest increasing subsequence of a if you concatenate it to itself n times.
Example
Input
2
3
3 2 1
6
3 1 4 1 5 9
Output
3
5
Note
In the first sample, the new array is [3,2,1,3,2,1,3,2,1]. The longest increasing subsequence is marked in bold.
In the second sample, the longest increasing subsequence will be [1,3,4,5,9]. | instruction | 0 | 59,850 | 12 | 119,700 |
Tags: greedy, implementation
Correct Solution:
```
for _ in range(int(input())):
num=int(input())
li=[int(i) for i in input().split()]
print(len(set(li)))
``` | output | 1 | 59,850 | 12 | 119,701 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ehab has an array a of length n. He has just enough free time to make a new array consisting of n copies of the old array, written back-to-back. What will be the length of the new array's longest increasing subsequence?
A sequence a is a subsequence of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements. The longest increasing subsequence of an array is the longest subsequence such that its elements are ordered in strictly increasing order.
Input
The first line contains an integer t — the number of test cases you need to solve. The description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (1 ≤ a_i ≤ 10^9) — the elements of the array a.
The sum of n across the test cases doesn't exceed 10^5.
Output
For each testcase, output the length of the longest increasing subsequence of a if you concatenate it to itself n times.
Example
Input
2
3
3 2 1
6
3 1 4 1 5 9
Output
3
5
Note
In the first sample, the new array is [3,2,1,3,2,1,3,2,1]. The longest increasing subsequence is marked in bold.
In the second sample, the longest increasing subsequence will be [1,3,4,5,9]. | instruction | 0 | 59,851 | 12 | 119,702 |
Tags: greedy, implementation
Correct Solution:
```
import sys
input = sys.stdin.readline
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
k = inp()
for i in range(k):
count = 0
n = inp()
l = inlt()
print(len(list(set(l))))
``` | output | 1 | 59,851 | 12 | 119,703 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ehab has an array a of length n. He has just enough free time to make a new array consisting of n copies of the old array, written back-to-back. What will be the length of the new array's longest increasing subsequence?
A sequence a is a subsequence of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements. The longest increasing subsequence of an array is the longest subsequence such that its elements are ordered in strictly increasing order.
Input
The first line contains an integer t — the number of test cases you need to solve. The description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (1 ≤ a_i ≤ 10^9) — the elements of the array a.
The sum of n across the test cases doesn't exceed 10^5.
Output
For each testcase, output the length of the longest increasing subsequence of a if you concatenate it to itself n times.
Example
Input
2
3
3 2 1
6
3 1 4 1 5 9
Output
3
5
Note
In the first sample, the new array is [3,2,1,3,2,1,3,2,1]. The longest increasing subsequence is marked in bold.
In the second sample, the longest increasing subsequence will be [1,3,4,5,9]. | instruction | 0 | 59,852 | 12 | 119,704 |
Tags: greedy, implementation
Correct Solution:
```
t = int(input())
while t:
n = int(input())
a = list(map(int , input().split()))
print(len(set(a)))
t = t - 1
``` | output | 1 | 59,852 | 12 | 119,705 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ehab has an array a of length n. He has just enough free time to make a new array consisting of n copies of the old array, written back-to-back. What will be the length of the new array's longest increasing subsequence?
A sequence a is a subsequence of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements. The longest increasing subsequence of an array is the longest subsequence such that its elements are ordered in strictly increasing order.
Input
The first line contains an integer t — the number of test cases you need to solve. The description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (1 ≤ a_i ≤ 10^9) — the elements of the array a.
The sum of n across the test cases doesn't exceed 10^5.
Output
For each testcase, output the length of the longest increasing subsequence of a if you concatenate it to itself n times.
Example
Input
2
3
3 2 1
6
3 1 4 1 5 9
Output
3
5
Note
In the first sample, the new array is [3,2,1,3,2,1,3,2,1]. The longest increasing subsequence is marked in bold.
In the second sample, the longest increasing subsequence will be [1,3,4,5,9]. | instruction | 0 | 59,853 | 12 | 119,706 |
Tags: greedy, implementation
Correct Solution:
```
from sys import stdin
inf=stdin
for qw in range(int(inf.readline())):
n=int(inf.readline())
arr=list(map(int,inf.readline().split(" ")))
print(len(set(arr)))
#n=int(inf.readline())
#s=inf.readline()
# s="bacabcab"
# changed=False
# while not changed:
# print(s)
# changed=True
# i=0
# ll=len(s)
# while(i+1<ll and ord(s[i])!=ord(s[i+1])+1):
# i+=1
# j=i+1
# while(j+1<ll and ord(s[j])==ord(s[j+1])+1):
# j+=1
# if(i+1!=ll):
# s=s[:i]+s[j+1:]
# changed=False
# print(i,j,s[:i],s[j+1:])
# i=0
# ll=len(s)
# while(i+1<ll and ord(s[i])!=ord(s[i+1])-1):
# i+=1
# j=i+1
# while(j+1<ll and ord(s[j])==ord(s[j+1])-1):
# j+=1
# if(i+1!=ll):
# s=s[:i+1]+s[j+2:]
# changed=False
# print(i,j,s[:i+1],s[j+2:])
# print(len(s))
# for i in dicti:
# temp=0
# for j in helper:
# if(j[0]<=i[0] and j[1]<=i[1]):
# temp+=(i[0]-j[0]+1)*(i[1]-j[1]+1)
# if(j[1]<=i[0] and j[0]<=i[1] and j[0]!=j[1]):
# temp+=(i[0]-j[1]+1)*(i[1]-j[0]+1)
# count+=temp*dicti[i]
# def all_partitions(string):
# for cutpoints in range(1 << (len(string)-1)):
# result = []
# lastcut = 0
# for i in range(len(string)-1):
# if (1<<i) & cutpoints != 0:
# result.append(string[lastcut:(i+1)])
# lastcut = i+1
# result.append(string[lastcut:])
# yield result
# maxyet=0
# store={'h': -6, 'e': -7, 'l': -8, 'o': 3, 'he': 3, 'hel': -3, 'el': 0, 'hell': 6, 'ell': -5, 'll': 10, 'hello': -3, 'ello': -8, 'llo': 9, 'lo': -6}
# def quality(stri):
# return store[stri]
# for partition in all_partitions("hel"):
# temp=0
# for i in partition:
# temp+=quality(i)
# if(temp>maxyet):
# print(partition)
# maxyet=temp
# print(maxyet)
``` | output | 1 | 59,853 | 12 | 119,707 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ehab has an array a of length n. He has just enough free time to make a new array consisting of n copies of the old array, written back-to-back. What will be the length of the new array's longest increasing subsequence?
A sequence a is a subsequence of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements. The longest increasing subsequence of an array is the longest subsequence such that its elements are ordered in strictly increasing order.
Input
The first line contains an integer t — the number of test cases you need to solve. The description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (1 ≤ a_i ≤ 10^9) — the elements of the array a.
The sum of n across the test cases doesn't exceed 10^5.
Output
For each testcase, output the length of the longest increasing subsequence of a if you concatenate it to itself n times.
Example
Input
2
3
3 2 1
6
3 1 4 1 5 9
Output
3
5
Note
In the first sample, the new array is [3,2,1,3,2,1,3,2,1]. The longest increasing subsequence is marked in bold.
In the second sample, the longest increasing subsequence will be [1,3,4,5,9]. | instruction | 0 | 59,854 | 12 | 119,708 |
Tags: greedy, implementation
Correct Solution:
```
t=int(input())
for i in range(t):
n=int(input())
l=[int(s) for s in input().split()]
print(len(set(l)))
``` | output | 1 | 59,854 | 12 | 119,709 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ehab has an array a of length n. He has just enough free time to make a new array consisting of n copies of the old array, written back-to-back. What will be the length of the new array's longest increasing subsequence?
A sequence a is a subsequence of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements. The longest increasing subsequence of an array is the longest subsequence such that its elements are ordered in strictly increasing order.
Input
The first line contains an integer t — the number of test cases you need to solve. The description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (1 ≤ a_i ≤ 10^9) — the elements of the array a.
The sum of n across the test cases doesn't exceed 10^5.
Output
For each testcase, output the length of the longest increasing subsequence of a if you concatenate it to itself n times.
Example
Input
2
3
3 2 1
6
3 1 4 1 5 9
Output
3
5
Note
In the first sample, the new array is [3,2,1,3,2,1,3,2,1]. The longest increasing subsequence is marked in bold.
In the second sample, the longest increasing subsequence will be [1,3,4,5,9]. | instruction | 0 | 59,855 | 12 | 119,710 |
Tags: greedy, implementation
Correct Solution:
```
t = int(input())
for i in range (0, t):
n = int(input())
a = list(map(int, input().split()))
print(len(set(a)))
``` | output | 1 | 59,855 | 12 | 119,711 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ehab has an array a of length n. He has just enough free time to make a new array consisting of n copies of the old array, written back-to-back. What will be the length of the new array's longest increasing subsequence?
A sequence a is a subsequence of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements. The longest increasing subsequence of an array is the longest subsequence such that its elements are ordered in strictly increasing order.
Input
The first line contains an integer t — the number of test cases you need to solve. The description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (1 ≤ a_i ≤ 10^9) — the elements of the array a.
The sum of n across the test cases doesn't exceed 10^5.
Output
For each testcase, output the length of the longest increasing subsequence of a if you concatenate it to itself n times.
Example
Input
2
3
3 2 1
6
3 1 4 1 5 9
Output
3
5
Note
In the first sample, the new array is [3,2,1,3,2,1,3,2,1]. The longest increasing subsequence is marked in bold.
In the second sample, the longest increasing subsequence will be [1,3,4,5,9]. | instruction | 0 | 59,856 | 12 | 119,712 |
Tags: greedy, implementation
Correct Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
ans = len(set(a))
print(ans)
``` | output | 1 | 59,856 | 12 | 119,713 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ehab has an array a of length n. He has just enough free time to make a new array consisting of n copies of the old array, written back-to-back. What will be the length of the new array's longest increasing subsequence?
A sequence a is a subsequence of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements. The longest increasing subsequence of an array is the longest subsequence such that its elements are ordered in strictly increasing order.
Input
The first line contains an integer t — the number of test cases you need to solve. The description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (1 ≤ a_i ≤ 10^9) — the elements of the array a.
The sum of n across the test cases doesn't exceed 10^5.
Output
For each testcase, output the length of the longest increasing subsequence of a if you concatenate it to itself n times.
Example
Input
2
3
3 2 1
6
3 1 4 1 5 9
Output
3
5
Note
In the first sample, the new array is [3,2,1,3,2,1,3,2,1]. The longest increasing subsequence is marked in bold.
In the second sample, the longest increasing subsequence will be [1,3,4,5,9]. | instruction | 0 | 59,857 | 12 | 119,714 |
Tags: greedy, implementation
Correct Solution:
```
import sys
t=int(sys.stdin.readline().strip())
for i in range(0,t):
len1=int(sys.stdin.readline().strip())
array=list(map(int,sys.stdin.readline().strip().split()))
print(len(set(array)))
``` | output | 1 | 59,857 | 12 | 119,715 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ehab has an array a of length n. He has just enough free time to make a new array consisting of n copies of the old array, written back-to-back. What will be the length of the new array's longest increasing subsequence?
A sequence a is a subsequence of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements. The longest increasing subsequence of an array is the longest subsequence such that its elements are ordered in strictly increasing order.
Input
The first line contains an integer t — the number of test cases you need to solve. The description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (1 ≤ a_i ≤ 10^9) — the elements of the array a.
The sum of n across the test cases doesn't exceed 10^5.
Output
For each testcase, output the length of the longest increasing subsequence of a if you concatenate it to itself n times.
Example
Input
2
3
3 2 1
6
3 1 4 1 5 9
Output
3
5
Note
In the first sample, the new array is [3,2,1,3,2,1,3,2,1]. The longest increasing subsequence is marked in bold.
In the second sample, the longest increasing subsequence will be [1,3,4,5,9].
Submitted Solution:
```
t = int(input())
for i in range(t):
n = int(input())
l = [int(i) for i in input().split(" ")]
l.sort()
out = list(dict.fromkeys(l))
print(len(out))
``` | instruction | 0 | 59,858 | 12 | 119,716 |
Yes | output | 1 | 59,858 | 12 | 119,717 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ehab has an array a of length n. He has just enough free time to make a new array consisting of n copies of the old array, written back-to-back. What will be the length of the new array's longest increasing subsequence?
A sequence a is a subsequence of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements. The longest increasing subsequence of an array is the longest subsequence such that its elements are ordered in strictly increasing order.
Input
The first line contains an integer t — the number of test cases you need to solve. The description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (1 ≤ a_i ≤ 10^9) — the elements of the array a.
The sum of n across the test cases doesn't exceed 10^5.
Output
For each testcase, output the length of the longest increasing subsequence of a if you concatenate it to itself n times.
Example
Input
2
3
3 2 1
6
3 1 4 1 5 9
Output
3
5
Note
In the first sample, the new array is [3,2,1,3,2,1,3,2,1]. The longest increasing subsequence is marked in bold.
In the second sample, the longest increasing subsequence will be [1,3,4,5,9].
Submitted Solution:
```
t = int(input())
ans = []
for i in range(t):
n = int(input())
a = input().split()
a = set(a)
ans.append(len(a))
for i in ans:
print(i)
``` | instruction | 0 | 59,859 | 12 | 119,718 |
Yes | output | 1 | 59,859 | 12 | 119,719 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ehab has an array a of length n. He has just enough free time to make a new array consisting of n copies of the old array, written back-to-back. What will be the length of the new array's longest increasing subsequence?
A sequence a is a subsequence of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements. The longest increasing subsequence of an array is the longest subsequence such that its elements are ordered in strictly increasing order.
Input
The first line contains an integer t — the number of test cases you need to solve. The description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (1 ≤ a_i ≤ 10^9) — the elements of the array a.
The sum of n across the test cases doesn't exceed 10^5.
Output
For each testcase, output the length of the longest increasing subsequence of a if you concatenate it to itself n times.
Example
Input
2
3
3 2 1
6
3 1 4 1 5 9
Output
3
5
Note
In the first sample, the new array is [3,2,1,3,2,1,3,2,1]. The longest increasing subsequence is marked in bold.
In the second sample, the longest increasing subsequence will be [1,3,4,5,9].
Submitted Solution:
```
import sys
def main():
t = int(sys.stdin.readline())
count = {}
for i in range(t):
sys.stdin.readline()
ans = set(map(int, sys.stdin.readline().split()))
sys.stdout.write(f'{len(ans)}\n')
if __name__ == '__main__':
main()
``` | instruction | 0 | 59,860 | 12 | 119,720 |
Yes | output | 1 | 59,860 | 12 | 119,721 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ehab has an array a of length n. He has just enough free time to make a new array consisting of n copies of the old array, written back-to-back. What will be the length of the new array's longest increasing subsequence?
A sequence a is a subsequence of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements. The longest increasing subsequence of an array is the longest subsequence such that its elements are ordered in strictly increasing order.
Input
The first line contains an integer t — the number of test cases you need to solve. The description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (1 ≤ a_i ≤ 10^9) — the elements of the array a.
The sum of n across the test cases doesn't exceed 10^5.
Output
For each testcase, output the length of the longest increasing subsequence of a if you concatenate it to itself n times.
Example
Input
2
3
3 2 1
6
3 1 4 1 5 9
Output
3
5
Note
In the first sample, the new array is [3,2,1,3,2,1,3,2,1]. The longest increasing subsequence is marked in bold.
In the second sample, the longest increasing subsequence will be [1,3,4,5,9].
Submitted Solution:
```
for i in[*open(0)][2::2]:print(len(set([*map(int,i.split())])))
``` | instruction | 0 | 59,861 | 12 | 119,722 |
Yes | output | 1 | 59,861 | 12 | 119,723 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ehab has an array a of length n. He has just enough free time to make a new array consisting of n copies of the old array, written back-to-back. What will be the length of the new array's longest increasing subsequence?
A sequence a is a subsequence of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements. The longest increasing subsequence of an array is the longest subsequence such that its elements are ordered in strictly increasing order.
Input
The first line contains an integer t — the number of test cases you need to solve. The description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (1 ≤ a_i ≤ 10^9) — the elements of the array a.
The sum of n across the test cases doesn't exceed 10^5.
Output
For each testcase, output the length of the longest increasing subsequence of a if you concatenate it to itself n times.
Example
Input
2
3
3 2 1
6
3 1 4 1 5 9
Output
3
5
Note
In the first sample, the new array is [3,2,1,3,2,1,3,2,1]. The longest increasing subsequence is marked in bold.
In the second sample, the longest increasing subsequence will be [1,3,4,5,9].
Submitted Solution:
```
for i in range(int(input())):
p=int(input())
p=map(int,input().split())
m=list(p)
a=sorted(m)
print(m[-1])
``` | instruction | 0 | 59,862 | 12 | 119,724 |
No | output | 1 | 59,862 | 12 | 119,725 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ehab has an array a of length n. He has just enough free time to make a new array consisting of n copies of the old array, written back-to-back. What will be the length of the new array's longest increasing subsequence?
A sequence a is a subsequence of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements. The longest increasing subsequence of an array is the longest subsequence such that its elements are ordered in strictly increasing order.
Input
The first line contains an integer t — the number of test cases you need to solve. The description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (1 ≤ a_i ≤ 10^9) — the elements of the array a.
The sum of n across the test cases doesn't exceed 10^5.
Output
For each testcase, output the length of the longest increasing subsequence of a if you concatenate it to itself n times.
Example
Input
2
3
3 2 1
6
3 1 4 1 5 9
Output
3
5
Note
In the first sample, the new array is [3,2,1,3,2,1,3,2,1]. The longest increasing subsequence is marked in bold.
In the second sample, the longest increasing subsequence will be [1,3,4,5,9].
Submitted Solution:
```
t=int(input())
while(t):
t=t-1
a=int(input())
a=list(map(int,input().split()))
print(len(a))
``` | instruction | 0 | 59,863 | 12 | 119,726 |
No | output | 1 | 59,863 | 12 | 119,727 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ehab has an array a of length n. He has just enough free time to make a new array consisting of n copies of the old array, written back-to-back. What will be the length of the new array's longest increasing subsequence?
A sequence a is a subsequence of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements. The longest increasing subsequence of an array is the longest subsequence such that its elements are ordered in strictly increasing order.
Input
The first line contains an integer t — the number of test cases you need to solve. The description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (1 ≤ a_i ≤ 10^9) — the elements of the array a.
The sum of n across the test cases doesn't exceed 10^5.
Output
For each testcase, output the length of the longest increasing subsequence of a if you concatenate it to itself n times.
Example
Input
2
3
3 2 1
6
3 1 4 1 5 9
Output
3
5
Note
In the first sample, the new array is [3,2,1,3,2,1,3,2,1]. The longest increasing subsequence is marked in bold.
In the second sample, the longest increasing subsequence will be [1,3,4,5,9].
Submitted Solution:
```
#CopyCopyCopyCopyCopy
for _ in range(int(input())):
print(len(set(list(map(int,input().split())))))
``` | instruction | 0 | 59,864 | 12 | 119,728 |
No | output | 1 | 59,864 | 12 | 119,729 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ehab has an array a of length n. He has just enough free time to make a new array consisting of n copies of the old array, written back-to-back. What will be the length of the new array's longest increasing subsequence?
A sequence a is a subsequence of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements. The longest increasing subsequence of an array is the longest subsequence such that its elements are ordered in strictly increasing order.
Input
The first line contains an integer t — the number of test cases you need to solve. The description of the test cases follows.
The first line of each test case contains an integer n (1 ≤ n ≤ 10^5) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (1 ≤ a_i ≤ 10^9) — the elements of the array a.
The sum of n across the test cases doesn't exceed 10^5.
Output
For each testcase, output the length of the longest increasing subsequence of a if you concatenate it to itself n times.
Example
Input
2
3
3 2 1
6
3 1 4 1 5 9
Output
3
5
Note
In the first sample, the new array is [3,2,1,3,2,1,3,2,1]. The longest increasing subsequence is marked in bold.
In the second sample, the longest increasing subsequence will be [1,3,4,5,9].
Submitted Solution:
```
import random
def bubble_sort(l):
for t in range(len(l)):
for i in range(len(l)-1):
if l[i] > l[i+1]:
l[i+1], l[i] = l[i: i+2]
return l
num_cases = int(input())
for i in range(num_cases):
n = int(input())
case = list(map(lambda x: int(x),input().split(" ") ))
unfound = set()
prev = case.pop(0)
count = 1
for num in case:
if num > prev:
count += 1
prev = num
else:
if n > 0:
if num not in unfound:
unfound.add(num)
n -= 1
count += 1
print(count)
``` | instruction | 0 | 59,865 | 12 | 119,730 |
No | output | 1 | 59,865 | 12 | 119,731 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three sequences: a_1, a_2, …, a_n; b_1, b_2, …, b_n; c_1, c_2, …, c_n.
For each i, a_i ≠ b_i, a_i ≠ c_i, b_i ≠ c_i.
Find a sequence p_1, p_2, …, p_n, that satisfy the following conditions:
* p_i ∈ \\{a_i, b_i, c_i\}
* p_i ≠ p_{(i mod n) + 1}.
In other words, for each element, you need to choose one of the three possible values, such that no two adjacent elements (where we consider elements i,i+1 adjacent for i<n and also elements 1 and n) will have equal value.
It can be proved that in the given constraints solution always exists. You don't need to minimize/maximize anything, you need to find any proper sequence.
Input
The first line of input contains one integer t (1 ≤ t ≤ 100): the number of test cases.
The first line of each test case contains one integer n (3 ≤ n ≤ 100): the number of elements in the given sequences.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 100).
The third line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 100).
The fourth line contains n integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 100).
It is guaranteed that a_i ≠ b_i, a_i ≠ c_i, b_i ≠ c_i for all i.
Output
For each test case, print n integers: p_1, p_2, …, p_n (p_i ∈ \\{a_i, b_i, c_i\}, p_i ≠ p_{i mod n + 1}).
If there are several solutions, you can print any.
Example
Input
5
3
1 1 1
2 2 2
3 3 3
4
1 2 1 2
2 1 2 1
3 4 3 4
7
1 3 3 1 1 1 1
2 4 4 3 2 2 4
4 2 2 2 4 4 2
3
1 2 1
2 3 3
3 1 2
10
1 1 1 2 2 2 3 3 3 1
2 2 2 3 3 3 1 1 1 2
3 3 3 1 1 1 2 2 2 3
Output
1 2 3
1 2 1 2
1 3 4 3 2 4 2
1 3 2
1 2 3 1 2 3 1 2 3 2
Note
In the first test case p = [1, 2, 3].
It is a correct answer, because:
* p_1 = 1 = a_1, p_2 = 2 = b_2, p_3 = 3 = c_3
* p_1 ≠ p_2 , p_2 ≠ p_3 , p_3 ≠ p_1
All possible correct answers to this test case are: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1].
In the second test case p = [1, 2, 1, 2].
In this sequence p_1 = a_1, p_2 = a_2, p_3 = a_3, p_4 = a_4. Also we can see, that no two adjacent elements of the sequence are equal.
In the third test case p = [1, 3, 4, 3, 2, 4, 2].
In this sequence p_1 = a_1, p_2 = a_2, p_3 = b_3, p_4 = b_4, p_5 = b_5, p_6 = c_6, p_7 = c_7. Also we can see, that no two adjacent elements of the sequence are equal. | instruction | 0 | 59,900 | 12 | 119,800 |
Tags: constructive algorithms
Correct Solution:
```
def proA(n,arr,arr2,arr3):
temp=[]
for i in range(n):
for j in [arr,arr2,arr3]:
if(len(temp)==n-1 and temp[0]==j[i]):
continue
if(temp!=[]):
if(temp[-1]==j[i]):
continue
temp.append(j[i])
break
printA(temp)
def printA(arr):
for i in arr:
print(i,end=' ')
print()
t=int(input())
for i in range(t):
n=int(input())
arr=list(map(int,input().split()))
arr2=list(map(int,input().split()))
arr3=list(map(int,input().split()))
proA(n,arr,arr2,arr3)
``` | output | 1 | 59,900 | 12 | 119,801 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three sequences: a_1, a_2, …, a_n; b_1, b_2, …, b_n; c_1, c_2, …, c_n.
For each i, a_i ≠ b_i, a_i ≠ c_i, b_i ≠ c_i.
Find a sequence p_1, p_2, …, p_n, that satisfy the following conditions:
* p_i ∈ \\{a_i, b_i, c_i\}
* p_i ≠ p_{(i mod n) + 1}.
In other words, for each element, you need to choose one of the three possible values, such that no two adjacent elements (where we consider elements i,i+1 adjacent for i<n and also elements 1 and n) will have equal value.
It can be proved that in the given constraints solution always exists. You don't need to minimize/maximize anything, you need to find any proper sequence.
Input
The first line of input contains one integer t (1 ≤ t ≤ 100): the number of test cases.
The first line of each test case contains one integer n (3 ≤ n ≤ 100): the number of elements in the given sequences.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 100).
The third line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 100).
The fourth line contains n integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 100).
It is guaranteed that a_i ≠ b_i, a_i ≠ c_i, b_i ≠ c_i for all i.
Output
For each test case, print n integers: p_1, p_2, …, p_n (p_i ∈ \\{a_i, b_i, c_i\}, p_i ≠ p_{i mod n + 1}).
If there are several solutions, you can print any.
Example
Input
5
3
1 1 1
2 2 2
3 3 3
4
1 2 1 2
2 1 2 1
3 4 3 4
7
1 3 3 1 1 1 1
2 4 4 3 2 2 4
4 2 2 2 4 4 2
3
1 2 1
2 3 3
3 1 2
10
1 1 1 2 2 2 3 3 3 1
2 2 2 3 3 3 1 1 1 2
3 3 3 1 1 1 2 2 2 3
Output
1 2 3
1 2 1 2
1 3 4 3 2 4 2
1 3 2
1 2 3 1 2 3 1 2 3 2
Note
In the first test case p = [1, 2, 3].
It is a correct answer, because:
* p_1 = 1 = a_1, p_2 = 2 = b_2, p_3 = 3 = c_3
* p_1 ≠ p_2 , p_2 ≠ p_3 , p_3 ≠ p_1
All possible correct answers to this test case are: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1].
In the second test case p = [1, 2, 1, 2].
In this sequence p_1 = a_1, p_2 = a_2, p_3 = a_3, p_4 = a_4. Also we can see, that no two adjacent elements of the sequence are equal.
In the third test case p = [1, 3, 4, 3, 2, 4, 2].
In this sequence p_1 = a_1, p_2 = a_2, p_3 = b_3, p_4 = b_4, p_5 = b_5, p_6 = c_6, p_7 = c_7. Also we can see, that no two adjacent elements of the sequence are equal. | instruction | 0 | 59,901 | 12 | 119,802 |
Tags: constructive algorithms
Correct Solution:
```
from sys import stdin, stdout
import math,sys,heapq
from itertools import permutations, combinations
from collections import defaultdict,deque,OrderedDict
from os import path
import random
import bisect as bi
def yes():print('YES')
def no():print('NO')
if (path.exists('input.txt')):
#------------------Sublime--------------------------------------#
sys.stdin=open('input.txt','r');sys.stdout=open('output.txt','w');
def I():return (int(input()))
def In():return(map(int,input().split()))
else:
#------------------PYPY FAst I/o--------------------------------#
def I():return (int(stdin.readline()))
def In():return(map(int,stdin.readline().split()))
#sys.setrecursionlimit(1500)
def dict(a):
d={}
for x in a:
if d.get(x,-1)!=-1:
d[x]+=1
else:
d[x]=1
return d
def find_gt(a, x):
'Find leftmost value greater than x'
i = bi.bisect_left(a, x)
if i != len(a):
return i
else:
return -1
def main():
try:
n=I()
l=list(In())
l1=list(In())
l2=list(In())
ans=[]
for x in range(n):
if x==0:
ans.append(l[0])
elif x==n-1:
if ans[-1]!=l[x] and l[x]!=ans[0]:
ans.append(l[x])
elif ans[-1]!=l1[x] and l1[x]!=ans[0]:
ans.append(l1[x])
else:
ans.append(l2[x])
else:
if ans[-1]!=l[x]:
ans.append(l[x])
elif ans[-1]!=l1[x]:
ans.append(l1[x])
else:
ans.append(l2[x])
print(*ans)
except:
pass
M = 998244353
P = 1000000007
if __name__ == '__main__':
for _ in range(I()):main()
#for _ in range(1):main()
``` | output | 1 | 59,901 | 12 | 119,803 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three sequences: a_1, a_2, …, a_n; b_1, b_2, …, b_n; c_1, c_2, …, c_n.
For each i, a_i ≠ b_i, a_i ≠ c_i, b_i ≠ c_i.
Find a sequence p_1, p_2, …, p_n, that satisfy the following conditions:
* p_i ∈ \\{a_i, b_i, c_i\}
* p_i ≠ p_{(i mod n) + 1}.
In other words, for each element, you need to choose one of the three possible values, such that no two adjacent elements (where we consider elements i,i+1 adjacent for i<n and also elements 1 and n) will have equal value.
It can be proved that in the given constraints solution always exists. You don't need to minimize/maximize anything, you need to find any proper sequence.
Input
The first line of input contains one integer t (1 ≤ t ≤ 100): the number of test cases.
The first line of each test case contains one integer n (3 ≤ n ≤ 100): the number of elements in the given sequences.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 100).
The third line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 100).
The fourth line contains n integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 100).
It is guaranteed that a_i ≠ b_i, a_i ≠ c_i, b_i ≠ c_i for all i.
Output
For each test case, print n integers: p_1, p_2, …, p_n (p_i ∈ \\{a_i, b_i, c_i\}, p_i ≠ p_{i mod n + 1}).
If there are several solutions, you can print any.
Example
Input
5
3
1 1 1
2 2 2
3 3 3
4
1 2 1 2
2 1 2 1
3 4 3 4
7
1 3 3 1 1 1 1
2 4 4 3 2 2 4
4 2 2 2 4 4 2
3
1 2 1
2 3 3
3 1 2
10
1 1 1 2 2 2 3 3 3 1
2 2 2 3 3 3 1 1 1 2
3 3 3 1 1 1 2 2 2 3
Output
1 2 3
1 2 1 2
1 3 4 3 2 4 2
1 3 2
1 2 3 1 2 3 1 2 3 2
Note
In the first test case p = [1, 2, 3].
It is a correct answer, because:
* p_1 = 1 = a_1, p_2 = 2 = b_2, p_3 = 3 = c_3
* p_1 ≠ p_2 , p_2 ≠ p_3 , p_3 ≠ p_1
All possible correct answers to this test case are: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1].
In the second test case p = [1, 2, 1, 2].
In this sequence p_1 = a_1, p_2 = a_2, p_3 = a_3, p_4 = a_4. Also we can see, that no two adjacent elements of the sequence are equal.
In the third test case p = [1, 3, 4, 3, 2, 4, 2].
In this sequence p_1 = a_1, p_2 = a_2, p_3 = b_3, p_4 = b_4, p_5 = b_5, p_6 = c_6, p_7 = c_7. Also we can see, that no two adjacent elements of the sequence are equal. | instruction | 0 | 59,902 | 12 | 119,804 |
Tags: constructive algorithms
Correct Solution:
```
## necessary imports
import sys
input = sys.stdin.readline
# biesect_left is essentially an equivalent of lower_bound function in
# cpp and returns the first index not smaller than x.
from bisect import bisect_left;
from bisect import bisect_right;
from math import ceil, factorial;
def ceil(x):
if x != int(x):
x = int(x) + 1;
return x;
# swap_array function
def swaparr(arr, a,b):
temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
## gcd function
def gcd(a,b):
if b == 0:
return a;
return gcd(b, a % b);
## nCr function efficient using Binomial Cofficient
def nCr(n, k, modulus = 1):
if(k > n - k):
k = n - k;
res = 1;
for i in range(k):
res = res * (n - i);
res = res / (i + 1);
res %= modulus;
return int(res);
## prime factorization
def primefs(n):
## if n == 1 ## calculating primes
primes = {}
while(n%2 == 0 and n > 0):
primes[2] = primes.get(2, 0) + 1
n = n//2
for i in range(3, int(n**0.5)+2, 2):
while(n%i == 0 and n > 0):
primes[i] = primes.get(i, 0) + 1
n = n//i
if n > 2:
primes[n] = primes.get(n, 0) + 1
## prime factoriazation of n is stored in dictionary
## primes and can be accesed. O(sqrt n)
return primes
## MODULAR EXPONENTIATION FUNCTION
def power(x, y, p):
res = 1
x = x % p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) :
res = (res * x) % p
y = y >> 1
x = (x * x) % p
return res
## DISJOINT SET UNINON FUNCTIONS
def swap(a,b):
temp = a
a = b
b = temp
return a,b;
# find function with path compression included (recursive)
# def find(x, link):
# if link[x] == x:
# return x
# link[x] = find(link[x], link);
# return link[x];
# find function with path compression (ITERATIVE)
def find(x, link):
p = x;
while( p != link[p]):
p = link[p];
while( x != p):
nex = link[x];
link[x] = p;
x = nex;
return p;
# the union function which makes union(x,y)
# of two nodes x and y
def union(x, y, link, size):
x = find(x, link)
y = find(y, link)
if size[x] < size[y]:
x,y = swap(x,y)
if x != y:
size[x] += size[y]
link[y] = x
## returns an array of boolean if primes or not USING SIEVE OF ERATOSTHANES
def sieve(n):
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
#### PRIME FACTORIZATION IN O(log n) using Sieve ####
MAXN = int(1e6 + 5)
def spf_sieve():
spf[1] = 1;
for i in range(2, MAXN):
spf[i] = i;
for i in range(4, MAXN, 2):
spf[i] = 2;
for i in range(3, ceil(MAXN ** 0.5), 2):
if spf[i] == i:
for j in range(i*i, MAXN, i):
if spf[j] == j:
spf[j] = i;
## function for storing smallest prime factors (spf) in the array
################## un-comment below 2 lines when using factorization #################
# spf = [0 for i in range(MAXN)]
# spf_sieve();
def factoriazation(x):
ret = {};
while x != 1:
ret[spf[x]] = ret.get(spf[x], 0) + 1;
x = x//spf[x]
return ret;
## this function is useful for multiple queries only, o/w use
## primefs function above. complexity O(log n)
## taking integer array input
def int_array():
return list(map(int, input().strip().split()));
def float_array():
return list(map(float, input().strip().split()));
## taking string array input
def str_array():
return input().strip().split();
#defining a couple constants
MOD = int(1e9)+7;
CMOD = 998244353;
INF = float('inf'); NINF = -float('inf');
################### ---------------- TEMPLATE ENDS HERE ---------------- ###################
for _ in range(int(input())):
n = int(input()); this = [];
a = int_array(); b = int_array(); c = int_array();
for i in range(n):
this.append((a[i], b[i], c[i]));
ans = [];
for i in range(n):
if i == 0:
ans.append(this[i][0]);
elif i == n - 1:
if ans:
for j in this[i]:
if j != ans[-1] and j != ans[0]:
ans.append(j);
break;
else:
for j in this[i]:
if j != ans[-1]:
ans.append(j);
break;
print(*ans);
``` | output | 1 | 59,902 | 12 | 119,805 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three sequences: a_1, a_2, …, a_n; b_1, b_2, …, b_n; c_1, c_2, …, c_n.
For each i, a_i ≠ b_i, a_i ≠ c_i, b_i ≠ c_i.
Find a sequence p_1, p_2, …, p_n, that satisfy the following conditions:
* p_i ∈ \\{a_i, b_i, c_i\}
* p_i ≠ p_{(i mod n) + 1}.
In other words, for each element, you need to choose one of the three possible values, such that no two adjacent elements (where we consider elements i,i+1 adjacent for i<n and also elements 1 and n) will have equal value.
It can be proved that in the given constraints solution always exists. You don't need to minimize/maximize anything, you need to find any proper sequence.
Input
The first line of input contains one integer t (1 ≤ t ≤ 100): the number of test cases.
The first line of each test case contains one integer n (3 ≤ n ≤ 100): the number of elements in the given sequences.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 100).
The third line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 100).
The fourth line contains n integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 100).
It is guaranteed that a_i ≠ b_i, a_i ≠ c_i, b_i ≠ c_i for all i.
Output
For each test case, print n integers: p_1, p_2, …, p_n (p_i ∈ \\{a_i, b_i, c_i\}, p_i ≠ p_{i mod n + 1}).
If there are several solutions, you can print any.
Example
Input
5
3
1 1 1
2 2 2
3 3 3
4
1 2 1 2
2 1 2 1
3 4 3 4
7
1 3 3 1 1 1 1
2 4 4 3 2 2 4
4 2 2 2 4 4 2
3
1 2 1
2 3 3
3 1 2
10
1 1 1 2 2 2 3 3 3 1
2 2 2 3 3 3 1 1 1 2
3 3 3 1 1 1 2 2 2 3
Output
1 2 3
1 2 1 2
1 3 4 3 2 4 2
1 3 2
1 2 3 1 2 3 1 2 3 2
Note
In the first test case p = [1, 2, 3].
It is a correct answer, because:
* p_1 = 1 = a_1, p_2 = 2 = b_2, p_3 = 3 = c_3
* p_1 ≠ p_2 , p_2 ≠ p_3 , p_3 ≠ p_1
All possible correct answers to this test case are: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1].
In the second test case p = [1, 2, 1, 2].
In this sequence p_1 = a_1, p_2 = a_2, p_3 = a_3, p_4 = a_4. Also we can see, that no two adjacent elements of the sequence are equal.
In the third test case p = [1, 3, 4, 3, 2, 4, 2].
In this sequence p_1 = a_1, p_2 = a_2, p_3 = b_3, p_4 = b_4, p_5 = b_5, p_6 = c_6, p_7 = c_7. Also we can see, that no two adjacent elements of the sequence are equal. | instruction | 0 | 59,903 | 12 | 119,806 |
Tags: constructive algorithms
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
A=list(map(int,input().split()))
B=list(map(int,input().split()))
C=list(map(int,input().split()))
res=[]
last = -1
for i in range(n):
if i==n-1:
if A[i] !=last and A[i]!=int(res[0]):
res.append(str(A[i]))
last = A[i]
elif B[i] != last and B[i]!=int(res[0]):
res.append(str(B[i]))
last = B[i]
else:
res.append(str(C[i]))
last = C[i]
else:
if A[i] !=last:
res.append(str(A[i]))
last = A[i]
elif B[i] != last:
res.append(str(B[i]))
last = B[i]
else:
res.append(str(C[i]))
last = C[i]
print(" ".join(res))
``` | output | 1 | 59,903 | 12 | 119,807 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three sequences: a_1, a_2, …, a_n; b_1, b_2, …, b_n; c_1, c_2, …, c_n.
For each i, a_i ≠ b_i, a_i ≠ c_i, b_i ≠ c_i.
Find a sequence p_1, p_2, …, p_n, that satisfy the following conditions:
* p_i ∈ \\{a_i, b_i, c_i\}
* p_i ≠ p_{(i mod n) + 1}.
In other words, for each element, you need to choose one of the three possible values, such that no two adjacent elements (where we consider elements i,i+1 adjacent for i<n and also elements 1 and n) will have equal value.
It can be proved that in the given constraints solution always exists. You don't need to minimize/maximize anything, you need to find any proper sequence.
Input
The first line of input contains one integer t (1 ≤ t ≤ 100): the number of test cases.
The first line of each test case contains one integer n (3 ≤ n ≤ 100): the number of elements in the given sequences.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 100).
The third line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 100).
The fourth line contains n integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 100).
It is guaranteed that a_i ≠ b_i, a_i ≠ c_i, b_i ≠ c_i for all i.
Output
For each test case, print n integers: p_1, p_2, …, p_n (p_i ∈ \\{a_i, b_i, c_i\}, p_i ≠ p_{i mod n + 1}).
If there are several solutions, you can print any.
Example
Input
5
3
1 1 1
2 2 2
3 3 3
4
1 2 1 2
2 1 2 1
3 4 3 4
7
1 3 3 1 1 1 1
2 4 4 3 2 2 4
4 2 2 2 4 4 2
3
1 2 1
2 3 3
3 1 2
10
1 1 1 2 2 2 3 3 3 1
2 2 2 3 3 3 1 1 1 2
3 3 3 1 1 1 2 2 2 3
Output
1 2 3
1 2 1 2
1 3 4 3 2 4 2
1 3 2
1 2 3 1 2 3 1 2 3 2
Note
In the first test case p = [1, 2, 3].
It is a correct answer, because:
* p_1 = 1 = a_1, p_2 = 2 = b_2, p_3 = 3 = c_3
* p_1 ≠ p_2 , p_2 ≠ p_3 , p_3 ≠ p_1
All possible correct answers to this test case are: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1].
In the second test case p = [1, 2, 1, 2].
In this sequence p_1 = a_1, p_2 = a_2, p_3 = a_3, p_4 = a_4. Also we can see, that no two adjacent elements of the sequence are equal.
In the third test case p = [1, 3, 4, 3, 2, 4, 2].
In this sequence p_1 = a_1, p_2 = a_2, p_3 = b_3, p_4 = b_4, p_5 = b_5, p_6 = c_6, p_7 = c_7. Also we can see, that no two adjacent elements of the sequence are equal. | instruction | 0 | 59,904 | 12 | 119,808 |
Tags: constructive algorithms
Correct Solution:
```
from collections import *
from itertools import *
from bisect import *
def inp():
return int(input())
def arrinp():
return [int(x) for x in input().split()]
def main():
t = inp()
for _ in range(t):
n = inp()
A = arrinp()
B = arrinp()
C = arrinp()
P = [-1 for i in range(n)]
i = 1
P[0] = A[0]
k= 1
def select(x, k):
if(x==0):
return A[k]
elif(x==1):
return B[k]
elif(x==2):
return C[k]
while(i<n and k<n):
x = 0
while x<3 and (P[i-1] == select(x,k)):
x +=1
P[i] = select(x,k)
i+=1
k+=1
x = 0
k -= 1
while(P[-1]==P[0] or P[-1]==P[-2]):
P[-1] = select(x,k)
x = int((x+1)%3)
print(*P, sep = ' ')
if __name__ == '__main__':
main()
``` | output | 1 | 59,904 | 12 | 119,809 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three sequences: a_1, a_2, …, a_n; b_1, b_2, …, b_n; c_1, c_2, …, c_n.
For each i, a_i ≠ b_i, a_i ≠ c_i, b_i ≠ c_i.
Find a sequence p_1, p_2, …, p_n, that satisfy the following conditions:
* p_i ∈ \\{a_i, b_i, c_i\}
* p_i ≠ p_{(i mod n) + 1}.
In other words, for each element, you need to choose one of the three possible values, such that no two adjacent elements (where we consider elements i,i+1 adjacent for i<n and also elements 1 and n) will have equal value.
It can be proved that in the given constraints solution always exists. You don't need to minimize/maximize anything, you need to find any proper sequence.
Input
The first line of input contains one integer t (1 ≤ t ≤ 100): the number of test cases.
The first line of each test case contains one integer n (3 ≤ n ≤ 100): the number of elements in the given sequences.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 100).
The third line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 100).
The fourth line contains n integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 100).
It is guaranteed that a_i ≠ b_i, a_i ≠ c_i, b_i ≠ c_i for all i.
Output
For each test case, print n integers: p_1, p_2, …, p_n (p_i ∈ \\{a_i, b_i, c_i\}, p_i ≠ p_{i mod n + 1}).
If there are several solutions, you can print any.
Example
Input
5
3
1 1 1
2 2 2
3 3 3
4
1 2 1 2
2 1 2 1
3 4 3 4
7
1 3 3 1 1 1 1
2 4 4 3 2 2 4
4 2 2 2 4 4 2
3
1 2 1
2 3 3
3 1 2
10
1 1 1 2 2 2 3 3 3 1
2 2 2 3 3 3 1 1 1 2
3 3 3 1 1 1 2 2 2 3
Output
1 2 3
1 2 1 2
1 3 4 3 2 4 2
1 3 2
1 2 3 1 2 3 1 2 3 2
Note
In the first test case p = [1, 2, 3].
It is a correct answer, because:
* p_1 = 1 = a_1, p_2 = 2 = b_2, p_3 = 3 = c_3
* p_1 ≠ p_2 , p_2 ≠ p_3 , p_3 ≠ p_1
All possible correct answers to this test case are: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1].
In the second test case p = [1, 2, 1, 2].
In this sequence p_1 = a_1, p_2 = a_2, p_3 = a_3, p_4 = a_4. Also we can see, that no two adjacent elements of the sequence are equal.
In the third test case p = [1, 3, 4, 3, 2, 4, 2].
In this sequence p_1 = a_1, p_2 = a_2, p_3 = b_3, p_4 = b_4, p_5 = b_5, p_6 = c_6, p_7 = c_7. Also we can see, that no two adjacent elements of the sequence are equal. | instruction | 0 | 59,905 | 12 | 119,810 |
Tags: constructive algorithms
Correct Solution:
```
T = int(input())
for t in range(T):
N = int(input())
A = [int(_) for _ in input().split()]
B = [int(_) for _ in input().split()]
C = [int(_) for _ in input().split()]
R = []
for i in range(N):
if i == 0:
R.append(A[i])
continue
if i == N-1:
if A[i] != R[0] and A[i] != R[-1]:
R.append(A[i])
elif B[i] != R[0] and B[i] != R[-1]:
R.append(B[i])
else:
R.append(C[i])
continue
if A[i] != R[-1]:
R.append(A[i])
else:
R.append(B[i])
print(' '.join(map(str, R)))
``` | output | 1 | 59,905 | 12 | 119,811 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three sequences: a_1, a_2, …, a_n; b_1, b_2, …, b_n; c_1, c_2, …, c_n.
For each i, a_i ≠ b_i, a_i ≠ c_i, b_i ≠ c_i.
Find a sequence p_1, p_2, …, p_n, that satisfy the following conditions:
* p_i ∈ \\{a_i, b_i, c_i\}
* p_i ≠ p_{(i mod n) + 1}.
In other words, for each element, you need to choose one of the three possible values, such that no two adjacent elements (where we consider elements i,i+1 adjacent for i<n and also elements 1 and n) will have equal value.
It can be proved that in the given constraints solution always exists. You don't need to minimize/maximize anything, you need to find any proper sequence.
Input
The first line of input contains one integer t (1 ≤ t ≤ 100): the number of test cases.
The first line of each test case contains one integer n (3 ≤ n ≤ 100): the number of elements in the given sequences.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 100).
The third line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 100).
The fourth line contains n integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 100).
It is guaranteed that a_i ≠ b_i, a_i ≠ c_i, b_i ≠ c_i for all i.
Output
For each test case, print n integers: p_1, p_2, …, p_n (p_i ∈ \\{a_i, b_i, c_i\}, p_i ≠ p_{i mod n + 1}).
If there are several solutions, you can print any.
Example
Input
5
3
1 1 1
2 2 2
3 3 3
4
1 2 1 2
2 1 2 1
3 4 3 4
7
1 3 3 1 1 1 1
2 4 4 3 2 2 4
4 2 2 2 4 4 2
3
1 2 1
2 3 3
3 1 2
10
1 1 1 2 2 2 3 3 3 1
2 2 2 3 3 3 1 1 1 2
3 3 3 1 1 1 2 2 2 3
Output
1 2 3
1 2 1 2
1 3 4 3 2 4 2
1 3 2
1 2 3 1 2 3 1 2 3 2
Note
In the first test case p = [1, 2, 3].
It is a correct answer, because:
* p_1 = 1 = a_1, p_2 = 2 = b_2, p_3 = 3 = c_3
* p_1 ≠ p_2 , p_2 ≠ p_3 , p_3 ≠ p_1
All possible correct answers to this test case are: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1].
In the second test case p = [1, 2, 1, 2].
In this sequence p_1 = a_1, p_2 = a_2, p_3 = a_3, p_4 = a_4. Also we can see, that no two adjacent elements of the sequence are equal.
In the third test case p = [1, 3, 4, 3, 2, 4, 2].
In this sequence p_1 = a_1, p_2 = a_2, p_3 = b_3, p_4 = b_4, p_5 = b_5, p_6 = c_6, p_7 = c_7. Also we can see, that no two adjacent elements of the sequence are equal. | instruction | 0 | 59,906 | 12 | 119,812 |
Tags: constructive algorithms
Correct Solution:
```
#include <CodeforcesSolutions.h>
#include <ONLINE_JUDGE <solution.cf(contestID = "1408",questionID = "A",method = "GET")>.h>
"""
Author : thekushalghosh
Team : CodeDiggers
I prefer Python language over the C++ language :p :D
Visit my website : thekushalghosh.github.io
"""
import sys,math,cmath,time,collections
start_time = time.time()
##########################################################################
################# ---- THE ACTUAL CODE STARTS BELOW ---- #################
def solve():
n = inp()
a = inlt()
b = inlt()
c = inlt()
q = [a[0]]
for i in range(1,len(a)):
if a[i] == q[-1]:
q.append(b[i])
else:
q.append(a[i])
if len(a) >= 2 and q[-1] == q[0]:
if q[0] != a[-1] and q[-2] != a[-1]:
q[-1] = a[-1]
elif q[0] != b[-1] and q[-2] != b[-1]:
q[-1] = b[-1]
else:
q[-1] = c[-1]
print(*q)
################## ---- THE ACTUAL CODE ENDS ABOVE ---- ##################
##########################################################################
def main():
global tt
if not ONLINE_JUDGE:
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
t = 1
t = inp()
for tt in range(1,t + 1):
solve()
if not ONLINE_JUDGE:
print("Time Elapsed :",time.time() - start_time,"seconds")
sys.stdout.close()
#---------------------- USER DEFINED INPUT FUNCTIONS ----------------------#
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
return(input().strip())
def invr():
return(map(int,input().split()))
#------------------ USER DEFINED PROGRAMMING FUNCTIONS ------------------#
def counter(a):
q = [0] * max(a)
for i in range(len(a)):
q[a[i] - 1] = q[a[i] - 1] + 1
return(q)
def counter_elements(a):
q = dict()
for i in range(len(a)):
if a[i] not in q:
q[a[i]] = 0
q[a[i]] = q[a[i]] + 1
return(q)
def string_counter(a):
q = [0] * 26
for i in range(len(a)):
q[ord(a[i]) - 97] = q[ord(a[i]) - 97] + 1
return(q)
def factorial(n,m = 1000000007):
q = 1
for i in range(n):
q = (q * (i + 1)) % m
return(q)
def factors(n):
q = []
for i in range(1,int(n ** 0.5) + 1):
if n % i == 0: q.append(i); q.append(n // i)
return(list(sorted(list(set(q)))))
def prime_factors(n):
q = []
while n % 2 == 0: q.append(2); n = n // 2
for i in range(3,int(n ** 0.5) + 1,2):
while n % i == 0: q.append(i); n = n // i
if n > 2: q.append(n)
return(list(sorted(q)))
def transpose(a):
n,m = len(a),len(a[0])
b = [[0] * n for i in range(m)]
for i in range(m):
for j in range(n):
b[i][j] = a[j][i]
return(b)
def ceil(a, b):
return -(-a // b)
#-----------------------------------------------------------------------#
ONLINE_JUDGE = __debug__
if ONLINE_JUDGE:
input = sys.stdin.readline
main()
``` | output | 1 | 59,906 | 12 | 119,813 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given three sequences: a_1, a_2, …, a_n; b_1, b_2, …, b_n; c_1, c_2, …, c_n.
For each i, a_i ≠ b_i, a_i ≠ c_i, b_i ≠ c_i.
Find a sequence p_1, p_2, …, p_n, that satisfy the following conditions:
* p_i ∈ \\{a_i, b_i, c_i\}
* p_i ≠ p_{(i mod n) + 1}.
In other words, for each element, you need to choose one of the three possible values, such that no two adjacent elements (where we consider elements i,i+1 adjacent for i<n and also elements 1 and n) will have equal value.
It can be proved that in the given constraints solution always exists. You don't need to minimize/maximize anything, you need to find any proper sequence.
Input
The first line of input contains one integer t (1 ≤ t ≤ 100): the number of test cases.
The first line of each test case contains one integer n (3 ≤ n ≤ 100): the number of elements in the given sequences.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 100).
The third line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 100).
The fourth line contains n integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 100).
It is guaranteed that a_i ≠ b_i, a_i ≠ c_i, b_i ≠ c_i for all i.
Output
For each test case, print n integers: p_1, p_2, …, p_n (p_i ∈ \\{a_i, b_i, c_i\}, p_i ≠ p_{i mod n + 1}).
If there are several solutions, you can print any.
Example
Input
5
3
1 1 1
2 2 2
3 3 3
4
1 2 1 2
2 1 2 1
3 4 3 4
7
1 3 3 1 1 1 1
2 4 4 3 2 2 4
4 2 2 2 4 4 2
3
1 2 1
2 3 3
3 1 2
10
1 1 1 2 2 2 3 3 3 1
2 2 2 3 3 3 1 1 1 2
3 3 3 1 1 1 2 2 2 3
Output
1 2 3
1 2 1 2
1 3 4 3 2 4 2
1 3 2
1 2 3 1 2 3 1 2 3 2
Note
In the first test case p = [1, 2, 3].
It is a correct answer, because:
* p_1 = 1 = a_1, p_2 = 2 = b_2, p_3 = 3 = c_3
* p_1 ≠ p_2 , p_2 ≠ p_3 , p_3 ≠ p_1
All possible correct answers to this test case are: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1].
In the second test case p = [1, 2, 1, 2].
In this sequence p_1 = a_1, p_2 = a_2, p_3 = a_3, p_4 = a_4. Also we can see, that no two adjacent elements of the sequence are equal.
In the third test case p = [1, 3, 4, 3, 2, 4, 2].
In this sequence p_1 = a_1, p_2 = a_2, p_3 = b_3, p_4 = b_4, p_5 = b_5, p_6 = c_6, p_7 = c_7. Also we can see, that no two adjacent elements of the sequence are equal. | instruction | 0 | 59,907 | 12 | 119,814 |
Tags: constructive algorithms
Correct Solution:
```
def func(a, b, c):
p = [i for i in a]
lenp = len(p)
for i in range(lenp-1):
next = (i + 1) % lenp
# print("now and next", i, next)
if p[i] == p[next]:
if p[i] != b[next]:
p[next] = b[next]
else:
p[next] = c[next]
if a[-1] != p[0] and a[-1] != p[-2]:
p[-1] = a[-1]
elif b[-1] != p[0] and b[-1] != p[-2]:
p[-1] = b[-1]
elif c[-1] != p[0] and c[-1] != p[-2]:
p[-1] = c[-1]
return p
t = int(input())
for i in range(t):
n = int(input())
a = list(map(int, input().rstrip().split()))
b = list(map(int, input().rstrip().split()))
c = list(map(int, input().rstrip().split()))
# print("input", a, b, c)
print(" ".join(map(str, func(a, b, c))))
``` | output | 1 | 59,907 | 12 | 119,815 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got an array a, consisting of n integers. The array elements are indexed from 1 to n. Let's determine a two step operation like that:
1. First we build by the array a an array s of partial sums, consisting of n elements. Element number i (1 ≤ i ≤ n) of array s equals <image>. The operation x mod y means that we take the remainder of the division of number x by number y.
2. Then we write the contents of the array s to the array a. Element number i (1 ≤ i ≤ n) of the array s becomes the i-th element of the array a (ai = si).
You task is to find array a after exactly k described operations are applied.
Input
The first line contains two space-separated integers n and k (1 ≤ n ≤ 2000, 0 ≤ k ≤ 109). The next line contains n space-separated integers a1, a2, ..., an — elements of the array a (0 ≤ ai ≤ 109).
Output
Print n integers — elements of the array a after the operations are applied to it. Print the elements in the order of increasing of their indexes in the array a. Separate the printed numbers by spaces.
Examples
Input
3 1
1 2 3
Output
1 3 6
Input
5 0
3 14 15 92 6
Output
3 14 15 92 6 | instruction | 0 | 60,034 | 12 | 120,068 |
Tags: combinatorics, math, number theory
Correct Solution:
```
def ncr(n, r, p):
# initialize numerator
# and denominator
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den,
p - 2, p)) % p
p=10**9+7
n,k=map(int,input().split())
b=list(map(int,input().split()))
if k==0:
print(*b)
else:
k-=1
res=[]
for r in range(1,n+1):
res.append(ncr(r+k-1,r-1,p))
ans=[]
for i in range(n):
j=i
val=0
while(j>=0):
val+=res[j]*b[i-j]
j+=-1
ans.append(val%p)
print(*ans)
``` | output | 1 | 60,034 | 12 | 120,069 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got an array a, consisting of n integers. The array elements are indexed from 1 to n. Let's determine a two step operation like that:
1. First we build by the array a an array s of partial sums, consisting of n elements. Element number i (1 ≤ i ≤ n) of array s equals <image>. The operation x mod y means that we take the remainder of the division of number x by number y.
2. Then we write the contents of the array s to the array a. Element number i (1 ≤ i ≤ n) of the array s becomes the i-th element of the array a (ai = si).
You task is to find array a after exactly k described operations are applied.
Input
The first line contains two space-separated integers n and k (1 ≤ n ≤ 2000, 0 ≤ k ≤ 109). The next line contains n space-separated integers a1, a2, ..., an — elements of the array a (0 ≤ ai ≤ 109).
Output
Print n integers — elements of the array a after the operations are applied to it. Print the elements in the order of increasing of their indexes in the array a. Separate the printed numbers by spaces.
Examples
Input
3 1
1 2 3
Output
1 3 6
Input
5 0
3 14 15 92 6
Output
3 14 15 92 6 | instruction | 0 | 60,035 | 12 | 120,070 |
Tags: combinatorics, math, number theory
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
def main():
mod = 10**9+7
n,k = map(int,input().split())
a = list(map(int,input().split()))
coeff = [1]
for i in range(n):
coeff.append((coeff[-1]*(k+i)*pow(i+1,mod-2,mod))%mod)
ans = []
for i in range(n):
x = 0
for j in range(i,-1,-1):
x = (x+a[j]*coeff[i-j])%mod
ans.append(x)
print(*ans)
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | output | 1 | 60,035 | 12 | 120,071 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got an array a, consisting of n integers. The array elements are indexed from 1 to n. Let's determine a two step operation like that:
1. First we build by the array a an array s of partial sums, consisting of n elements. Element number i (1 ≤ i ≤ n) of array s equals <image>. The operation x mod y means that we take the remainder of the division of number x by number y.
2. Then we write the contents of the array s to the array a. Element number i (1 ≤ i ≤ n) of the array s becomes the i-th element of the array a (ai = si).
You task is to find array a after exactly k described operations are applied.
Input
The first line contains two space-separated integers n and k (1 ≤ n ≤ 2000, 0 ≤ k ≤ 109). The next line contains n space-separated integers a1, a2, ..., an — elements of the array a (0 ≤ ai ≤ 109).
Output
Print n integers — elements of the array a after the operations are applied to it. Print the elements in the order of increasing of their indexes in the array a. Separate the printed numbers by spaces.
Examples
Input
3 1
1 2 3
Output
1 3 6
Input
5 0
3 14 15 92 6
Output
3 14 15 92 6 | instruction | 0 | 60,036 | 12 | 120,072 |
Tags: combinatorics, math, number theory
Correct Solution:
```
n, k = map(int, input().split())
a = list(map(int, input().split()))
m = 1000000007
r = [ 0, 1 ]
for i in range(2, n+1):
r.append( (- (m // i) * r[m % i]) % m )
c = [ 1 ]
for i in range(1, n):
c.append((c[i-1] * (k+i-1) * r[i]) % m)
ans = []
for i in range(n):
t = 0
for j in range(i+1):
t = (t + a[j] * c[i-j]) % m
ans.append(t)
for i in range(n):
print(ans[i], end=' ')
``` | output | 1 | 60,036 | 12 | 120,073 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got an array a, consisting of n integers. The array elements are indexed from 1 to n. Let's determine a two step operation like that:
1. First we build by the array a an array s of partial sums, consisting of n elements. Element number i (1 ≤ i ≤ n) of array s equals <image>. The operation x mod y means that we take the remainder of the division of number x by number y.
2. Then we write the contents of the array s to the array a. Element number i (1 ≤ i ≤ n) of the array s becomes the i-th element of the array a (ai = si).
You task is to find array a after exactly k described operations are applied.
Input
The first line contains two space-separated integers n and k (1 ≤ n ≤ 2000, 0 ≤ k ≤ 109). The next line contains n space-separated integers a1, a2, ..., an — elements of the array a (0 ≤ ai ≤ 109).
Output
Print n integers — elements of the array a after the operations are applied to it. Print the elements in the order of increasing of their indexes in the array a. Separate the printed numbers by spaces.
Examples
Input
3 1
1 2 3
Output
1 3 6
Input
5 0
3 14 15 92 6
Output
3 14 15 92 6 | instruction | 0 | 60,037 | 12 | 120,074 |
Tags: combinatorics, math, number theory
Correct Solution:
```
n, k = map(int, input().split())
num = list(map(int, input().split()))
MOD = 10 ** 9 + 7
cf = [1]
for i in range(1, 2020):
cf.append((cf[-1] * (k + i - 1) * pow(i, MOD - 2, MOD)) % MOD)
ans = [0 for i in range(n)]
for i in range(n):
for j in range(i + 1):
ans[i] = (ans[i] + cf[i - j] * num[j]) % MOD
print(' '.join(map(str, ans)))
# Made By Mostafa_Khaled
``` | output | 1 | 60,037 | 12 | 120,075 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got an array a, consisting of n integers. The array elements are indexed from 1 to n. Let's determine a two step operation like that:
1. First we build by the array a an array s of partial sums, consisting of n elements. Element number i (1 ≤ i ≤ n) of array s equals <image>. The operation x mod y means that we take the remainder of the division of number x by number y.
2. Then we write the contents of the array s to the array a. Element number i (1 ≤ i ≤ n) of the array s becomes the i-th element of the array a (ai = si).
You task is to find array a after exactly k described operations are applied.
Input
The first line contains two space-separated integers n and k (1 ≤ n ≤ 2000, 0 ≤ k ≤ 109). The next line contains n space-separated integers a1, a2, ..., an — elements of the array a (0 ≤ ai ≤ 109).
Output
Print n integers — elements of the array a after the operations are applied to it. Print the elements in the order of increasing of their indexes in the array a. Separate the printed numbers by spaces.
Examples
Input
3 1
1 2 3
Output
1 3 6
Input
5 0
3 14 15 92 6
Output
3 14 15 92 6
Submitted Solution:
```
def ncr(n, r, p):
# initialize numerator
# and denominator
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den,
p - 2, p)) % p
p=10**9+7
n,k=map(int,input().split())
b=list(map(int,input().split()))
if k==0:
print(*b)
else:
k-=1
res=[]
for r in range(1,n+1):
res.append(ncr(r+k-1,r-1,p))
ans=[]
for i in range(n):
j=i
val=0
while(j>=0):
val+=res[j]*b[i-j]
j+=-1
ans.append(val)
print(*ans)
``` | instruction | 0 | 60,038 | 12 | 120,076 |
No | output | 1 | 60,038 | 12 | 120,077 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's denote a function
<image>
You are given an array a consisting of n integers. You have to calculate the sum of d(ai, aj) over all pairs (i, j) such that 1 ≤ i ≤ j ≤ n.
Input
The first line contains one integer n (1 ≤ n ≤ 200000) — the number of elements in a.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109) — elements of the array.
Output
Print one integer — the sum of d(ai, aj) over all pairs (i, j) such that 1 ≤ i ≤ j ≤ n.
Examples
Input
5
1 2 3 1 3
Output
4
Input
4
6 6 5 5
Output
0
Input
4
6 6 4 4
Output
-8
Note
In the first example:
1. d(a1, a2) = 0;
2. d(a1, a3) = 2;
3. d(a1, a4) = 0;
4. d(a1, a5) = 2;
5. d(a2, a3) = 0;
6. d(a2, a4) = 0;
7. d(a2, a5) = 0;
8. d(a3, a4) = - 2;
9. d(a3, a5) = 0;
10. d(a4, a5) = 2. | instruction | 0 | 60,348 | 12 | 120,696 |
Tags: data structures, math
Correct Solution:
```
def update(fenwick, idx, val, n):
while idx<n:
fenwick[idx]+=val
idx+=(idx & (-idx))
def get_sum(fenwick, idx):
sum=0
while idx>0:
sum+=fenwick[idx]
idx-=(idx & (-idx))
return sum
def count_smaller_elements(arr):
temp=arr.copy()
temp.sort()
curr_size=1
Hashed_Value={}
## Hashing values so that we can implement fenwick of size N instead of size Max Value
for item in temp:
if item not in Hashed_Value:
Hashed_Value[item]=curr_size
curr_size+=1
fenwick=[0]*(curr_size)
for i in range(n):
temp[i]=Hashed_Value[arr[i]]
temp=temp[::-1]
count_smaller=[0]*n
for i in range(n):
count_smaller[i]=get_sum(fenwick, temp[i]-1)
update(fenwick, temp[i] , 1 ,curr_size)
return count_smaller[::-1]
n=int(input())
l1=list(map(int,input().split()))
d1={}
ans=0
for i in range(-1,-n-1,-1):
if l1[i] not in d1:
ans-=l1[i]*(abs(i)-1)
else :
ans-=(l1[i])*(abs(i)-1-d1[l1[i]])
if l1[i] not in d1:
d1[l1[i]]=1
else :
d1[l1[i]]+=1
d1={}
for i in range(n):
if l1[i] not in d1:
ans+=l1[i]*i
else :
ans+=l1[i]*(i-d1[l1[i]])
if l1[i] not in d1:
d1[l1[i]]=1
else :
d1[l1[i]]+=1
for item in l1:
if item-1 in d1:
ans-=d1[item-1]
if item+1 in d1:
ans+=d1[item+1]
if item not in d1:
d1[item]=1
else :
d1[item]+=1
print(ans)
``` | output | 1 | 60,348 | 12 | 120,697 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's denote a function
<image>
You are given an array a consisting of n integers. You have to calculate the sum of d(ai, aj) over all pairs (i, j) such that 1 ≤ i ≤ j ≤ n.
Input
The first line contains one integer n (1 ≤ n ≤ 200000) — the number of elements in a.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109) — elements of the array.
Output
Print one integer — the sum of d(ai, aj) over all pairs (i, j) such that 1 ≤ i ≤ j ≤ n.
Examples
Input
5
1 2 3 1 3
Output
4
Input
4
6 6 5 5
Output
0
Input
4
6 6 4 4
Output
-8
Note
In the first example:
1. d(a1, a2) = 0;
2. d(a1, a3) = 2;
3. d(a1, a4) = 0;
4. d(a1, a5) = 2;
5. d(a2, a3) = 0;
6. d(a2, a4) = 0;
7. d(a2, a5) = 0;
8. d(a3, a4) = - 2;
9. d(a3, a5) = 0;
10. d(a4, a5) = 2. | instruction | 0 | 60,349 | 12 | 120,698 |
Tags: data structures, math
Correct Solution:
```
maxN = 2 * 10**5
n = int(input())
bad = 0
ghabl = 0
a = list(map(int, input().split()))
for i in range(n):
if (i):
bad += a[i] - a[0]
Sum = bad
for i in range(1, n):
bad -= (a[i] - a[i - 1])
bad -= ((n - 1) - i) * (a[i] - a[i - 1])
Sum += bad
maP = dict()
maP["pedram"] = 1
for i in range(n):
if a[i] in maP:
maP[a[i]] += 1
else:
maP[a[i]] = 1
if a[i] - 1 in maP:
Sum -= maP[a[i] - 1]
if a[i] + 1 in maP:
Sum += maP[a[i] + 1]
print(Sum)
``` | output | 1 | 60,349 | 12 | 120,699 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's denote a function
<image>
You are given an array a consisting of n integers. You have to calculate the sum of d(ai, aj) over all pairs (i, j) such that 1 ≤ i ≤ j ≤ n.
Input
The first line contains one integer n (1 ≤ n ≤ 200000) — the number of elements in a.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109) — elements of the array.
Output
Print one integer — the sum of d(ai, aj) over all pairs (i, j) such that 1 ≤ i ≤ j ≤ n.
Examples
Input
5
1 2 3 1 3
Output
4
Input
4
6 6 5 5
Output
0
Input
4
6 6 4 4
Output
-8
Note
In the first example:
1. d(a1, a2) = 0;
2. d(a1, a3) = 2;
3. d(a1, a4) = 0;
4. d(a1, a5) = 2;
5. d(a2, a3) = 0;
6. d(a2, a4) = 0;
7. d(a2, a5) = 0;
8. d(a3, a4) = - 2;
9. d(a3, a5) = 0;
10. d(a4, a5) = 2. | instruction | 0 | 60,350 | 12 | 120,700 |
Tags: data structures, math
Correct Solution:
```
n = int(input())
t = input().split()
x = {int(i): 0 for i in t}
result = 0
for i in range(1, n + 1):
a = int(t[i - 1])
x[a] += 1
result += a * (2 * i - n - 1)
if a + 1 in x:
result += x[a + 1]
if a - 1 in x:
result -= x[a - 1]
print(result)
``` | output | 1 | 60,350 | 12 | 120,701 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's denote a function
<image>
You are given an array a consisting of n integers. You have to calculate the sum of d(ai, aj) over all pairs (i, j) such that 1 ≤ i ≤ j ≤ n.
Input
The first line contains one integer n (1 ≤ n ≤ 200000) — the number of elements in a.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109) — elements of the array.
Output
Print one integer — the sum of d(ai, aj) over all pairs (i, j) such that 1 ≤ i ≤ j ≤ n.
Examples
Input
5
1 2 3 1 3
Output
4
Input
4
6 6 5 5
Output
0
Input
4
6 6 4 4
Output
-8
Note
In the first example:
1. d(a1, a2) = 0;
2. d(a1, a3) = 2;
3. d(a1, a4) = 0;
4. d(a1, a5) = 2;
5. d(a2, a3) = 0;
6. d(a2, a4) = 0;
7. d(a2, a5) = 0;
8. d(a3, a4) = - 2;
9. d(a3, a5) = 0;
10. d(a4, a5) = 2. | instruction | 0 | 60,351 | 12 | 120,702 |
Tags: data structures, math
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
p = [0] * (n+1)
for i in range(n) :
p[i+1] = p[i] + a[i]
mp = dict()
cnt = 0
for i in range(n) :
f1 = mp.setdefault(a[i])
f2 = mp.setdefault(a[i] - 1)
f3 = mp.setdefault(a[i] + 1)
if (f1 == None) :
f1 = 0
if (f2 == None) :
f2 = 0
if (f3 == None) :
f3 = 0
mp[a[i]] = f1 + 1
cnt += i * a[i] - p[i] + f3 - f2
print(cnt)
``` | output | 1 | 60,351 | 12 | 120,703 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.