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.
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,352 | 12 | 120,704 |
Tags: data structures, math
Correct Solution:
```
from bisect import bisect
def main():
n = int(input())
an = [(i, int(s)) for i, s in enumerate(input().split())][:n]
ans = sum(a * (-n + 1 + 2 * i) for i, a in an)
group = {}
for i, a in an:
if a not in group:
group[a] = []
group[a].append(i)
group = list(sorted(group.items(), key=lambda t: t[0]))
# print(group)
for i in range(len(group) - 1):
if group[i][0] + 1 == group[i + 1][0]:
idx_s1 = group[i][1]
idx_s2 = group[i + 1][1]
for idx in idx_s1:
smaller = bisect(idx_s2, idx)
larger = len(idx_s2) - smaller
ans = ans - larger + smaller
print(ans)
if __name__ == '__main__':
main()
``` | output | 1 | 60,352 | 12 | 120,705 |
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,353 | 12 | 120,706 |
Tags: data structures, math
Correct Solution:
```
def ii():
return int(input())
def mi():
return map(int, input().split())
def li():
return list(mi())
from collections import defaultdict
n = ii()
a = li()
def solve(a):
d = defaultdict(int)
s = 0
for i in range(n):
x = a[i]
s += (i - d[x] - d[x-1] - d[x+1]) * x
d[x] += 1
return s
ans = solve(a) - solve(a[::-1])
print(ans)
``` | output | 1 | 60,353 | 12 | 120,707 |
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,354 | 12 | 120,708 |
Tags: data structures, math
Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Tue Dec 12 20:33:55 2017
@author: savit
"""
dic={}
n=int(input())
sum1=0
a=list(map(int,input().split()))
for i in range(n-1,-1,-1):
try:
dic[a[i]]+=1
except:
dic[a[i]]=1
sum1+=a[i]*(-n+1+2*i)
try:
#print(dic[a[i]+1],'dec',a[i])
sum1-=dic[a[i]+1]
except:
pass
try:
#print(dic[a[i]-1],'inc',a[i])
sum1+=dic[a[i]-1]
except:
pass
print(sum1)
``` | output | 1 | 60,354 | 12 | 120,709 |
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,355 | 12 | 120,710 |
Tags: data structures, math
Correct Solution:
```
m = {}
A = [0] * 200001
B = []
sum1 = 0
ans = 0
n = int(input())
B = (input().split(' '))
for i in range(n):
A[i] = int(B[i])
sum1 += A[i]
if A[i] in m:
m[A[i]] += 1
else:
m[A[i]] = 1
np = n
for i in range(n):
if A[i] in m:
a1 = m[A[i]]
else:
a1 = 0
if A[i] + 1 in m:
a2 = m[A[i] + 1]
else:
a2 = 0
if A[i] - 1 in m:
a3 = m[A[i] - 1]
else:
a3 = 0
val1 = (sum1 - A[i] * a1 - (A[i] - 1) * a3 - (A[i] + 1) * a2)
val2 = (np - a1 - a3 - a2) * A[i]
ans += (val1 - val2)
# print((sum1 - A[i] * a1 - (A[i] - 1) * a3 - (A[i] + 1) * a2) - (np - a1 - a3 - a2) * A[i]
m[A[i]] -= 1;
sum1 -= A[i];
np -= 1;
print(ans)
``` | output | 1 | 60,355 | 12 | 120,711 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. You can perform the following operations with it:
1. Choose some positions i and j (1 ≤ i, j ≤ n, i ≠ j), write the value of a_i ⋅ a_j into the j-th cell and remove the number from the i-th cell;
2. Choose some position i and remove the number from the i-th cell (this operation can be performed no more than once and at any point of time, not necessarily in the beginning).
The number of elements decreases by one after each operation. However, the indexing of positions stays the same. Deleted numbers can't be used in the later operations.
Your task is to perform exactly n - 1 operations with the array in such a way that the only number that remains in the array is maximum possible. This number can be rather large, so instead of printing it you need to print any sequence of operations which leads to this maximum number. Read the output format to understand what exactly you need to print.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print n - 1 lines. The k-th line should contain one of the two possible operations.
The operation of the first type should look like this: 1~ i_k~ j_k, where 1 is the type of operation, i_k and j_k are the positions of the chosen elements.
The operation of the second type should look like this: 2~ i_k, where 2 is the type of operation, i_k is the position of the chosen element. Note that there should be no more than one such operation.
If there are multiple possible sequences of operations leading to the maximum number — print any of them.
Examples
Input
5
5 -2 0 1 -3
Output
2 3
1 1 2
1 2 4
1 4 5
Input
5
5 2 0 4 0
Output
1 3 5
2 5
1 1 2
1 2 4
Input
2
2 -1
Output
2 2
Input
4
0 -10 0 0
Output
1 1 2
1 2 3
1 3 4
Input
4
0 0 0 0
Output
1 1 2
1 2 3
1 3 4
Note
Let X be the removed number in the array. Let's take a look at all the examples:
The first example has, for example, the following sequence of transformations of the array: [5, -2, 0, 1, -3] → [5, -2, X, 1, -3] → [X, -10, X, 1, -3] → [X, X, X, -10, -3] → [X, X, X, X, 30]. Thus, the maximum answer is 30. Note, that other sequences that lead to the answer 30 are also correct.
The second example has, for example, the following sequence of transformations of the array: [5, 2, 0, 4, 0] → [5, 2, X, 4, 0] → [5, 2, X, 4, X] → [X, 10, X, 4, X] → [X, X, X, 40, X]. The following answer is also allowed:
1 5 3
1 4 2
1 2 1
2 3
Then the sequence of transformations of the array will look like this: [5, 2, 0, 4, 0] → [5, 2, 0, 4, X] → [5, 8, 0, X, X] → [40, X, 0, X, X] → [40, X, X, X, X].
The third example can have the following sequence of transformations of the array: [2, -1] → [2, X].
The fourth example can have the following sequence of transformations of the array: [0, -10, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
The fifth example can have the following sequence of transformations of the array: [0, 0, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0]. | instruction | 0 | 60,640 | 12 | 121,280 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
n=int(input())
l=list(map(int,input().split()))
neg=[]
zer=[]
ans=[]
s=set()
st=1
ma=-9999999999999999999999999999999
count=0
d=dict()
for i in range(n):
if l[i]<0:
neg.append(i+1)
ma=max(l[i],ma)
if l[i] in d:
d[l[i]]+=1
else:
d.update({l[i]:1})
if l[i]!=ma or d[l[i]]>1:
st=i+1
elif l[i]==0:
zer.append(i+1)
else:
st=i+1
if len(neg)%2==1:
ind=l.index(ma)
for i in range(1,len(zer)):
ans.append([1,zer[i],zer[0]])
s.add(zer[i]-1)
if len(zer)!=0:
ans.append([1,zer[0],ind+1])
s.add(zer[0]-1)
ans.append([2,ind+1])
s.add(ind)
for i in range(n):
if i in s or i==st-1:
continue
ans.append([1,i+1,st])
else:
for i in range(1,len(zer)):
ans.append([1,zer[i],zer[0]])
s.add(zer[i]-1)
if len(zer)!=0:
ans.append([2,zer[0]])
s.add(zer[0]-1)
for i in range(n):
if i in s or i==st-1:
continue
ans.append([1,i+1,st])
for i in range(n-1):
print(*ans[i],sep=" ")
``` | output | 1 | 60,640 | 12 | 121,281 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. You can perform the following operations with it:
1. Choose some positions i and j (1 ≤ i, j ≤ n, i ≠ j), write the value of a_i ⋅ a_j into the j-th cell and remove the number from the i-th cell;
2. Choose some position i and remove the number from the i-th cell (this operation can be performed no more than once and at any point of time, not necessarily in the beginning).
The number of elements decreases by one after each operation. However, the indexing of positions stays the same. Deleted numbers can't be used in the later operations.
Your task is to perform exactly n - 1 operations with the array in such a way that the only number that remains in the array is maximum possible. This number can be rather large, so instead of printing it you need to print any sequence of operations which leads to this maximum number. Read the output format to understand what exactly you need to print.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print n - 1 lines. The k-th line should contain one of the two possible operations.
The operation of the first type should look like this: 1~ i_k~ j_k, where 1 is the type of operation, i_k and j_k are the positions of the chosen elements.
The operation of the second type should look like this: 2~ i_k, where 2 is the type of operation, i_k is the position of the chosen element. Note that there should be no more than one such operation.
If there are multiple possible sequences of operations leading to the maximum number — print any of them.
Examples
Input
5
5 -2 0 1 -3
Output
2 3
1 1 2
1 2 4
1 4 5
Input
5
5 2 0 4 0
Output
1 3 5
2 5
1 1 2
1 2 4
Input
2
2 -1
Output
2 2
Input
4
0 -10 0 0
Output
1 1 2
1 2 3
1 3 4
Input
4
0 0 0 0
Output
1 1 2
1 2 3
1 3 4
Note
Let X be the removed number in the array. Let's take a look at all the examples:
The first example has, for example, the following sequence of transformations of the array: [5, -2, 0, 1, -3] → [5, -2, X, 1, -3] → [X, -10, X, 1, -3] → [X, X, X, -10, -3] → [X, X, X, X, 30]. Thus, the maximum answer is 30. Note, that other sequences that lead to the answer 30 are also correct.
The second example has, for example, the following sequence of transformations of the array: [5, 2, 0, 4, 0] → [5, 2, X, 4, 0] → [5, 2, X, 4, X] → [X, 10, X, 4, X] → [X, X, X, 40, X]. The following answer is also allowed:
1 5 3
1 4 2
1 2 1
2 3
Then the sequence of transformations of the array will look like this: [5, 2, 0, 4, 0] → [5, 2, 0, 4, X] → [5, 8, 0, X, X] → [40, X, 0, X, X] → [40, X, X, X, X].
The third example can have the following sequence of transformations of the array: [2, -1] → [2, X].
The fourth example can have the following sequence of transformations of the array: [0, -10, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
The fifth example can have the following sequence of transformations of the array: [0, 0, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0]. | instruction | 0 | 60,641 | 12 | 121,282 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
n = int(input())
t = n
num = list(map(int, input().split()))
visited = [True] * n
negative = 0
mn = -10 ** 10
pos = -1
zero = 0
pos_zero = []
for i in range(n):
q = num[i]
if q == 0:
zero += 1
pos_zero.append(i)
elif q < 0:
negative += 1
if pos == -1:
pos = i
if mn < q:
mn = q
pos = i
for i in range(len(pos_zero) - 1):
print(1, pos_zero[i] + 1, pos_zero[i + 1] + 1)
visited[pos_zero[i]] = False
t -= zero
if zero > 0 and negative % 2 == 1 and t > 0:
print(1, pos + 1, pos_zero[-1] + 1)
t -= 1
visited[pos] = False
if negative % 2 == 1 and zero == 0 and t > 0:
visited[pos] = False
print(2, pos + 1)
elif zero > 0 and t > 0 and zero < n:
visited[pos_zero[-1]] = False
print(2, pos_zero[-1] + 1)
i = -1
old, cur = None, None
while n - i > 1:
i += 1
if visited[i]:
if old is None:
old = i
visited[i] = False
continue
if cur is None:
cur = i
print(1, old + 1, cur + 1)
old, cur = cur, None
visited[old] = False
continue
``` | output | 1 | 60,641 | 12 | 121,283 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. You can perform the following operations with it:
1. Choose some positions i and j (1 ≤ i, j ≤ n, i ≠ j), write the value of a_i ⋅ a_j into the j-th cell and remove the number from the i-th cell;
2. Choose some position i and remove the number from the i-th cell (this operation can be performed no more than once and at any point of time, not necessarily in the beginning).
The number of elements decreases by one after each operation. However, the indexing of positions stays the same. Deleted numbers can't be used in the later operations.
Your task is to perform exactly n - 1 operations with the array in such a way that the only number that remains in the array is maximum possible. This number can be rather large, so instead of printing it you need to print any sequence of operations which leads to this maximum number. Read the output format to understand what exactly you need to print.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print n - 1 lines. The k-th line should contain one of the two possible operations.
The operation of the first type should look like this: 1~ i_k~ j_k, where 1 is the type of operation, i_k and j_k are the positions of the chosen elements.
The operation of the second type should look like this: 2~ i_k, where 2 is the type of operation, i_k is the position of the chosen element. Note that there should be no more than one such operation.
If there are multiple possible sequences of operations leading to the maximum number — print any of them.
Examples
Input
5
5 -2 0 1 -3
Output
2 3
1 1 2
1 2 4
1 4 5
Input
5
5 2 0 4 0
Output
1 3 5
2 5
1 1 2
1 2 4
Input
2
2 -1
Output
2 2
Input
4
0 -10 0 0
Output
1 1 2
1 2 3
1 3 4
Input
4
0 0 0 0
Output
1 1 2
1 2 3
1 3 4
Note
Let X be the removed number in the array. Let's take a look at all the examples:
The first example has, for example, the following sequence of transformations of the array: [5, -2, 0, 1, -3] → [5, -2, X, 1, -3] → [X, -10, X, 1, -3] → [X, X, X, -10, -3] → [X, X, X, X, 30]. Thus, the maximum answer is 30. Note, that other sequences that lead to the answer 30 are also correct.
The second example has, for example, the following sequence of transformations of the array: [5, 2, 0, 4, 0] → [5, 2, X, 4, 0] → [5, 2, X, 4, X] → [X, 10, X, 4, X] → [X, X, X, 40, X]. The following answer is also allowed:
1 5 3
1 4 2
1 2 1
2 3
Then the sequence of transformations of the array will look like this: [5, 2, 0, 4, 0] → [5, 2, 0, 4, X] → [5, 8, 0, X, X] → [40, X, 0, X, X] → [40, X, X, X, X].
The third example can have the following sequence of transformations of the array: [2, -1] → [2, X].
The fourth example can have the following sequence of transformations of the array: [0, -10, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
The fifth example can have the following sequence of transformations of the array: [0, 0, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0]. | instruction | 0 | 60,642 | 12 | 121,284 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
n = int(input())
a = list(map(int,input().split()))
hu = 0
humax = -float("inf")
huind = None
able = set(range(n))
ans = []
mae = -1
for i in range(n):
if a[i] == 0:
if mae == -1:
mae = i
able.discard(i)
else:
ans.append([1,mae+1,i+1])
able.discard(i)
mae = i
if a[i]<0:
hu +=1
if a[i] > humax:
humax =a[i]
huind = i
if hu %2 == 1:
if mae == -1:
ans.append([2,huind+1])
able.discard(huind)
mae = huind
else:
ans.append([1,mae+1,huind+1])
able.discard(huind)
ans.append([2,huind+1])
mae = huind
if able == set():
ans.pop(-2)
able.add(0)
if a[mae] == 0:
ans.append([2,mae+1])
if able == set():
ans.pop()
mae = -1
for i in able:
if mae == -1:
mae = i
else:
ans.append([1,mae+1,i+1])
mae = i
for i in ans:
print(*i)
``` | output | 1 | 60,642 | 12 | 121,285 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. You can perform the following operations with it:
1. Choose some positions i and j (1 ≤ i, j ≤ n, i ≠ j), write the value of a_i ⋅ a_j into the j-th cell and remove the number from the i-th cell;
2. Choose some position i and remove the number from the i-th cell (this operation can be performed no more than once and at any point of time, not necessarily in the beginning).
The number of elements decreases by one after each operation. However, the indexing of positions stays the same. Deleted numbers can't be used in the later operations.
Your task is to perform exactly n - 1 operations with the array in such a way that the only number that remains in the array is maximum possible. This number can be rather large, so instead of printing it you need to print any sequence of operations which leads to this maximum number. Read the output format to understand what exactly you need to print.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print n - 1 lines. The k-th line should contain one of the two possible operations.
The operation of the first type should look like this: 1~ i_k~ j_k, where 1 is the type of operation, i_k and j_k are the positions of the chosen elements.
The operation of the second type should look like this: 2~ i_k, where 2 is the type of operation, i_k is the position of the chosen element. Note that there should be no more than one such operation.
If there are multiple possible sequences of operations leading to the maximum number — print any of them.
Examples
Input
5
5 -2 0 1 -3
Output
2 3
1 1 2
1 2 4
1 4 5
Input
5
5 2 0 4 0
Output
1 3 5
2 5
1 1 2
1 2 4
Input
2
2 -1
Output
2 2
Input
4
0 -10 0 0
Output
1 1 2
1 2 3
1 3 4
Input
4
0 0 0 0
Output
1 1 2
1 2 3
1 3 4
Note
Let X be the removed number in the array. Let's take a look at all the examples:
The first example has, for example, the following sequence of transformations of the array: [5, -2, 0, 1, -3] → [5, -2, X, 1, -3] → [X, -10, X, 1, -3] → [X, X, X, -10, -3] → [X, X, X, X, 30]. Thus, the maximum answer is 30. Note, that other sequences that lead to the answer 30 are also correct.
The second example has, for example, the following sequence of transformations of the array: [5, 2, 0, 4, 0] → [5, 2, X, 4, 0] → [5, 2, X, 4, X] → [X, 10, X, 4, X] → [X, X, X, 40, X]. The following answer is also allowed:
1 5 3
1 4 2
1 2 1
2 3
Then the sequence of transformations of the array will look like this: [5, 2, 0, 4, 0] → [5, 2, 0, 4, X] → [5, 8, 0, X, X] → [40, X, 0, X, X] → [40, X, X, X, X].
The third example can have the following sequence of transformations of the array: [2, -1] → [2, X].
The fourth example can have the following sequence of transformations of the array: [0, -10, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
The fifth example can have the following sequence of transformations of the array: [0, 0, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0]. | instruction | 0 | 60,643 | 12 | 121,286 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
n = int(input())
v = list(map(int, input().split()))
out, best, sub, zero = [0]*n, -1<<30, [], []
for i in range(n):
if v[i] < 0:
sub.append(i)
if best < v[i]:
best = v[i]
isb = i
elif v[i] == 0:
zero.append(i)
op = 0
def f(v):
global op
if op == n-1:
return
op += 1
for x in v:
print(x, end = ' ')
print()
out[v[1]-1] = 1
if len(zero) == 0:
if len(sub)&1:
f([2, isb+1])
else:
for i in range(len(zero)-1):
f([1, zero[i]+1, zero[i+1]+1])
if len(sub)&1:
f([1, isb+1, zero[-1]+1])
f([2, zero[-1]+1])
for i in range(n-1):
if out[i]:
continue
j = i+1
while j < n and out[j]:
j += 1
if j < n:
f([1, i+1, j+1])
``` | output | 1 | 60,643 | 12 | 121,287 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. You can perform the following operations with it:
1. Choose some positions i and j (1 ≤ i, j ≤ n, i ≠ j), write the value of a_i ⋅ a_j into the j-th cell and remove the number from the i-th cell;
2. Choose some position i and remove the number from the i-th cell (this operation can be performed no more than once and at any point of time, not necessarily in the beginning).
The number of elements decreases by one after each operation. However, the indexing of positions stays the same. Deleted numbers can't be used in the later operations.
Your task is to perform exactly n - 1 operations with the array in such a way that the only number that remains in the array is maximum possible. This number can be rather large, so instead of printing it you need to print any sequence of operations which leads to this maximum number. Read the output format to understand what exactly you need to print.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print n - 1 lines. The k-th line should contain one of the two possible operations.
The operation of the first type should look like this: 1~ i_k~ j_k, where 1 is the type of operation, i_k and j_k are the positions of the chosen elements.
The operation of the second type should look like this: 2~ i_k, where 2 is the type of operation, i_k is the position of the chosen element. Note that there should be no more than one such operation.
If there are multiple possible sequences of operations leading to the maximum number — print any of them.
Examples
Input
5
5 -2 0 1 -3
Output
2 3
1 1 2
1 2 4
1 4 5
Input
5
5 2 0 4 0
Output
1 3 5
2 5
1 1 2
1 2 4
Input
2
2 -1
Output
2 2
Input
4
0 -10 0 0
Output
1 1 2
1 2 3
1 3 4
Input
4
0 0 0 0
Output
1 1 2
1 2 3
1 3 4
Note
Let X be the removed number in the array. Let's take a look at all the examples:
The first example has, for example, the following sequence of transformations of the array: [5, -2, 0, 1, -3] → [5, -2, X, 1, -3] → [X, -10, X, 1, -3] → [X, X, X, -10, -3] → [X, X, X, X, 30]. Thus, the maximum answer is 30. Note, that other sequences that lead to the answer 30 are also correct.
The second example has, for example, the following sequence of transformations of the array: [5, 2, 0, 4, 0] → [5, 2, X, 4, 0] → [5, 2, X, 4, X] → [X, 10, X, 4, X] → [X, X, X, 40, X]. The following answer is also allowed:
1 5 3
1 4 2
1 2 1
2 3
Then the sequence of transformations of the array will look like this: [5, 2, 0, 4, 0] → [5, 2, 0, 4, X] → [5, 8, 0, X, X] → [40, X, 0, X, X] → [40, X, X, X, X].
The third example can have the following sequence of transformations of the array: [2, -1] → [2, X].
The fourth example can have the following sequence of transformations of the array: [0, -10, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
The fifth example can have the following sequence of transformations of the array: [0, 0, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0]. | instruction | 0 | 60,644 | 12 | 121,288 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
import atexit
import io
import sys
_INPUT_LINES = sys.stdin.read().splitlines()
input = iter(_INPUT_LINES).__next__
_OUTPUT_BUFFER = io.StringIO()
sys.stdout = _OUTPUT_BUFFER
@atexit.register
def write():
sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
def main():
n = int(input())
arr = [(x[1], x[0] + 1) for x in enumerate(list(map(int, input().split())))]
neg = []
pos = []
zer = []
ops = 0
for v in arr:
if v[0] == 0:
zer.append(v)
elif v[0] > 0:
pos.append(v)
else:
neg.append(v)
extra = True
while len(zer) > 1:
pair = zer.pop()
print(1, pair[1], zer[-1][1])
ops += 1
if ops == n - 1:
exit(0)
if (len(neg) & 1) == 1 and len(zer) == 1:
pair = neg.pop(neg.index(max(neg)))
print(1, pair[1], zer[0][1])
ops += 1
if ops == n - 1:
exit(0)
pair = zer.pop()
print(2, pair[1])
extra = False
ops += 1
if ops == n - 1:
exit(0)
if ops == n - 1:
exit(0)
if len(zer) > 0:
pair = zer.pop()
print(2, pair[1])
extra = False
ops += 1
if ops == n - 1:
exit(0)
if extra is True and (len(neg) & 1) == 1:
pair = neg.pop(neg.index(max(neg)))
print(2, pair[1])
ops += 1
all = neg + pos
if ops == n - 1:
exit(0)
for i in range(len(all) - 1):
first = all[i]
second = all[i + 1]
print(1, first[1], second[1])
if __name__ == "__main__":
main()
``` | output | 1 | 60,644 | 12 | 121,289 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. You can perform the following operations with it:
1. Choose some positions i and j (1 ≤ i, j ≤ n, i ≠ j), write the value of a_i ⋅ a_j into the j-th cell and remove the number from the i-th cell;
2. Choose some position i and remove the number from the i-th cell (this operation can be performed no more than once and at any point of time, not necessarily in the beginning).
The number of elements decreases by one after each operation. However, the indexing of positions stays the same. Deleted numbers can't be used in the later operations.
Your task is to perform exactly n - 1 operations with the array in such a way that the only number that remains in the array is maximum possible. This number can be rather large, so instead of printing it you need to print any sequence of operations which leads to this maximum number. Read the output format to understand what exactly you need to print.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print n - 1 lines. The k-th line should contain one of the two possible operations.
The operation of the first type should look like this: 1~ i_k~ j_k, where 1 is the type of operation, i_k and j_k are the positions of the chosen elements.
The operation of the second type should look like this: 2~ i_k, where 2 is the type of operation, i_k is the position of the chosen element. Note that there should be no more than one such operation.
If there are multiple possible sequences of operations leading to the maximum number — print any of them.
Examples
Input
5
5 -2 0 1 -3
Output
2 3
1 1 2
1 2 4
1 4 5
Input
5
5 2 0 4 0
Output
1 3 5
2 5
1 1 2
1 2 4
Input
2
2 -1
Output
2 2
Input
4
0 -10 0 0
Output
1 1 2
1 2 3
1 3 4
Input
4
0 0 0 0
Output
1 1 2
1 2 3
1 3 4
Note
Let X be the removed number in the array. Let's take a look at all the examples:
The first example has, for example, the following sequence of transformations of the array: [5, -2, 0, 1, -3] → [5, -2, X, 1, -3] → [X, -10, X, 1, -3] → [X, X, X, -10, -3] → [X, X, X, X, 30]. Thus, the maximum answer is 30. Note, that other sequences that lead to the answer 30 are also correct.
The second example has, for example, the following sequence of transformations of the array: [5, 2, 0, 4, 0] → [5, 2, X, 4, 0] → [5, 2, X, 4, X] → [X, 10, X, 4, X] → [X, X, X, 40, X]. The following answer is also allowed:
1 5 3
1 4 2
1 2 1
2 3
Then the sequence of transformations of the array will look like this: [5, 2, 0, 4, 0] → [5, 2, 0, 4, X] → [5, 8, 0, X, X] → [40, X, 0, X, X] → [40, X, X, X, X].
The third example can have the following sequence of transformations of the array: [2, -1] → [2, X].
The fourth example can have the following sequence of transformations of the array: [0, -10, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
The fifth example can have the following sequence of transformations of the array: [0, 0, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0]. | instruction | 0 | 60,645 | 12 | 121,290 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
# -*- coding:utf-8 -*-
"""
created by shuangquan.huang at 11/21/18
"""
N = int(input())
A = [int(x) for x in input().split()]
B = [abs(x) for x in A]
zeros = [i for i in range(N) if A[i] == 0]
positives = [i for i in range(N) if A[i] > 0]
negs = [(abs(A[i]), i) for i in range(N) if A[i] < 0]
idx = []
if len(negs) % 2 == 0:
if len(zeros) > 1:
print('\n'.join(['1 {} {}'.format(i+1, zeros[0] + 1) for i in zeros[1:]]))
if len(zeros) < N:
print('2 {}'.format(zeros[0] + 1))
elif len(zeros) == 1:
print('2 {}'.format(zeros[0] + 1))
else:
pass
idx = [i for v, i in negs] + positives
else:
negs.sort()
negs = [i for v, i in negs]
if len(zeros) > 0:
print('\n'.join(['1 {} {}'.format(i + 1, zeros[0] + 1) for i in zeros[1:]]))
print('1 {} {}'.format(zeros[0]+1, negs[0]+1))
if len(zeros) + 1 < N:
print('2 {}'.format(negs[0] + 1))
else:
print('2 {}'.format(negs[0] + 1))
idx = positives + negs[1:]
if idx:
mx = -1
mxVal = float('-inf')
for i in idx:
if B[i] > mxVal:
mxVal = B[i]
mx = i
print('\n'.join(['1 {} {}'.format(u + 1, mx + 1) for u in idx if u != mx]))
``` | output | 1 | 60,645 | 12 | 121,291 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. You can perform the following operations with it:
1. Choose some positions i and j (1 ≤ i, j ≤ n, i ≠ j), write the value of a_i ⋅ a_j into the j-th cell and remove the number from the i-th cell;
2. Choose some position i and remove the number from the i-th cell (this operation can be performed no more than once and at any point of time, not necessarily in the beginning).
The number of elements decreases by one after each operation. However, the indexing of positions stays the same. Deleted numbers can't be used in the later operations.
Your task is to perform exactly n - 1 operations with the array in such a way that the only number that remains in the array is maximum possible. This number can be rather large, so instead of printing it you need to print any sequence of operations which leads to this maximum number. Read the output format to understand what exactly you need to print.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print n - 1 lines. The k-th line should contain one of the two possible operations.
The operation of the first type should look like this: 1~ i_k~ j_k, where 1 is the type of operation, i_k and j_k are the positions of the chosen elements.
The operation of the second type should look like this: 2~ i_k, where 2 is the type of operation, i_k is the position of the chosen element. Note that there should be no more than one such operation.
If there are multiple possible sequences of operations leading to the maximum number — print any of them.
Examples
Input
5
5 -2 0 1 -3
Output
2 3
1 1 2
1 2 4
1 4 5
Input
5
5 2 0 4 0
Output
1 3 5
2 5
1 1 2
1 2 4
Input
2
2 -1
Output
2 2
Input
4
0 -10 0 0
Output
1 1 2
1 2 3
1 3 4
Input
4
0 0 0 0
Output
1 1 2
1 2 3
1 3 4
Note
Let X be the removed number in the array. Let's take a look at all the examples:
The first example has, for example, the following sequence of transformations of the array: [5, -2, 0, 1, -3] → [5, -2, X, 1, -3] → [X, -10, X, 1, -3] → [X, X, X, -10, -3] → [X, X, X, X, 30]. Thus, the maximum answer is 30. Note, that other sequences that lead to the answer 30 are also correct.
The second example has, for example, the following sequence of transformations of the array: [5, 2, 0, 4, 0] → [5, 2, X, 4, 0] → [5, 2, X, 4, X] → [X, 10, X, 4, X] → [X, X, X, 40, X]. The following answer is also allowed:
1 5 3
1 4 2
1 2 1
2 3
Then the sequence of transformations of the array will look like this: [5, 2, 0, 4, 0] → [5, 2, 0, 4, X] → [5, 8, 0, X, X] → [40, X, 0, X, X] → [40, X, X, X, X].
The third example can have the following sequence of transformations of the array: [2, -1] → [2, X].
The fourth example can have the following sequence of transformations of the array: [0, -10, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
The fifth example can have the following sequence of transformations of the array: [0, 0, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0]. | instruction | 0 | 60,646 | 12 | 121,292 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
n = int(input())
l = list(map(int, input().split()))
neg = list()
zero = list()
mneg = None
for i in range(n):
if l[i] == 0: zero.append(i)
elif l[i] < 0:
neg.append(i)
if mneg is None or l[i] > l[mneg]: mneg = i
if len(neg)%2 == 0:
i = 0
while len(zero)-1 > i:
print(1, zero[i]+1, zero[i+1]+1,sep=" ")
i += 1
if len(zero)-1 == i and len(zero) != n:
print(2, zero[i]+1)
i, j = 0, 1
while j < n and i < n:
if l[i] != 0:
if l[j] != 0 and j > i:
print(1, i+1, j+1, sep=" ")
i = j
j = i+1
else:
j = j+1
else:
i = i+1
else:
i = 0
while len(zero)-1 > i:
print(1, zero[i]+1, zero[i+1]+1,sep=" ")
i += 1
if len(zero)-1 == i:
print(1, zero[i]+1, mneg+1, sep=" ")
if len(zero) != n - 1:
print(2, mneg+1)
l[mneg] = 0
else:
if len(zero) != n - 1:
print(2, mneg+1)
l[mneg] = 0
i, j = 0, 1
while j < n and i < n:
if l[i] != 0:
if l[j] != 0 and j > i:
print(1, i+1, j+1, sep=" ")
i = j
j = i+1
else:
j = j+1
else:
i = i+1
``` | output | 1 | 60,646 | 12 | 121,293 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. You can perform the following operations with it:
1. Choose some positions i and j (1 ≤ i, j ≤ n, i ≠ j), write the value of a_i ⋅ a_j into the j-th cell and remove the number from the i-th cell;
2. Choose some position i and remove the number from the i-th cell (this operation can be performed no more than once and at any point of time, not necessarily in the beginning).
The number of elements decreases by one after each operation. However, the indexing of positions stays the same. Deleted numbers can't be used in the later operations.
Your task is to perform exactly n - 1 operations with the array in such a way that the only number that remains in the array is maximum possible. This number can be rather large, so instead of printing it you need to print any sequence of operations which leads to this maximum number. Read the output format to understand what exactly you need to print.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print n - 1 lines. The k-th line should contain one of the two possible operations.
The operation of the first type should look like this: 1~ i_k~ j_k, where 1 is the type of operation, i_k and j_k are the positions of the chosen elements.
The operation of the second type should look like this: 2~ i_k, where 2 is the type of operation, i_k is the position of the chosen element. Note that there should be no more than one such operation.
If there are multiple possible sequences of operations leading to the maximum number — print any of them.
Examples
Input
5
5 -2 0 1 -3
Output
2 3
1 1 2
1 2 4
1 4 5
Input
5
5 2 0 4 0
Output
1 3 5
2 5
1 1 2
1 2 4
Input
2
2 -1
Output
2 2
Input
4
0 -10 0 0
Output
1 1 2
1 2 3
1 3 4
Input
4
0 0 0 0
Output
1 1 2
1 2 3
1 3 4
Note
Let X be the removed number in the array. Let's take a look at all the examples:
The first example has, for example, the following sequence of transformations of the array: [5, -2, 0, 1, -3] → [5, -2, X, 1, -3] → [X, -10, X, 1, -3] → [X, X, X, -10, -3] → [X, X, X, X, 30]. Thus, the maximum answer is 30. Note, that other sequences that lead to the answer 30 are also correct.
The second example has, for example, the following sequence of transformations of the array: [5, 2, 0, 4, 0] → [5, 2, X, 4, 0] → [5, 2, X, 4, X] → [X, 10, X, 4, X] → [X, X, X, 40, X]. The following answer is also allowed:
1 5 3
1 4 2
1 2 1
2 3
Then the sequence of transformations of the array will look like this: [5, 2, 0, 4, 0] → [5, 2, 0, 4, X] → [5, 8, 0, X, X] → [40, X, 0, X, X] → [40, X, X, X, X].
The third example can have the following sequence of transformations of the array: [2, -1] → [2, X].
The fourth example can have the following sequence of transformations of the array: [0, -10, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
The fifth example can have the following sequence of transformations of the array: [0, 0, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0]. | instruction | 0 | 60,647 | 12 | 121,294 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
n=int(input())
b=list(map(int,input().split()))
k=0
c=[]
r=1000000000000
for j in range(n):
if b[j]==0:
c.append(j+1)
elif b[j]<0:
k+=1
if abs(b[j])<r:
r=abs(b[j])
q=j+1
if b[j]!=0:
p=j
for j in range(n):
if b[j]!=0 and k!=0 and j!=(q-1):
s=j
f=[]
j=1
while(j<len(c)):
f.append([1, c[j], c[0]])
j+=1
if k%2!=0:
if len(c)>0 and len(f)!=(n-1):
f.append([1, q, c[0]])
if len(f)!=(n-1):
f.append([2, c[0]])
for j in range(n):
if b[j]!=0 and j!=(q-1) and j!=s:
f.append([1, j+1, s+1])
else:
if len(f)!=(n-1):
f.append([2, q])
for j in range(n):
if b[j]!=0 and j!=(q-1) and j!=s:
f.append([1, j+1, s+1])
else:
if len(c)>0:
if len(f)!=(n-1):
f.append([2, c[0]])
for j in range(n):
if b[j]!=0 and j!=p:
f.append([1, j+1, p+1])
else:
for j in range(n):
if b[j] != 0 and j != p:
f.append([1, j + 1, p + 1])
for j in f:
print(*j)
``` | output | 1 | 60,647 | 12 | 121,295 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. You can perform the following operations with it:
1. Choose some positions i and j (1 ≤ i, j ≤ n, i ≠ j), write the value of a_i ⋅ a_j into the j-th cell and remove the number from the i-th cell;
2. Choose some position i and remove the number from the i-th cell (this operation can be performed no more than once and at any point of time, not necessarily in the beginning).
The number of elements decreases by one after each operation. However, the indexing of positions stays the same. Deleted numbers can't be used in the later operations.
Your task is to perform exactly n - 1 operations with the array in such a way that the only number that remains in the array is maximum possible. This number can be rather large, so instead of printing it you need to print any sequence of operations which leads to this maximum number. Read the output format to understand what exactly you need to print.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print n - 1 lines. The k-th line should contain one of the two possible operations.
The operation of the first type should look like this: 1~ i_k~ j_k, where 1 is the type of operation, i_k and j_k are the positions of the chosen elements.
The operation of the second type should look like this: 2~ i_k, where 2 is the type of operation, i_k is the position of the chosen element. Note that there should be no more than one such operation.
If there are multiple possible sequences of operations leading to the maximum number — print any of them.
Examples
Input
5
5 -2 0 1 -3
Output
2 3
1 1 2
1 2 4
1 4 5
Input
5
5 2 0 4 0
Output
1 3 5
2 5
1 1 2
1 2 4
Input
2
2 -1
Output
2 2
Input
4
0 -10 0 0
Output
1 1 2
1 2 3
1 3 4
Input
4
0 0 0 0
Output
1 1 2
1 2 3
1 3 4
Note
Let X be the removed number in the array. Let's take a look at all the examples:
The first example has, for example, the following sequence of transformations of the array: [5, -2, 0, 1, -3] → [5, -2, X, 1, -3] → [X, -10, X, 1, -3] → [X, X, X, -10, -3] → [X, X, X, X, 30]. Thus, the maximum answer is 30. Note, that other sequences that lead to the answer 30 are also correct.
The second example has, for example, the following sequence of transformations of the array: [5, 2, 0, 4, 0] → [5, 2, X, 4, 0] → [5, 2, X, 4, X] → [X, 10, X, 4, X] → [X, X, X, 40, X]. The following answer is also allowed:
1 5 3
1 4 2
1 2 1
2 3
Then the sequence of transformations of the array will look like this: [5, 2, 0, 4, 0] → [5, 2, 0, 4, X] → [5, 8, 0, X, X] → [40, X, 0, X, X] → [40, X, X, X, X].
The third example can have the following sequence of transformations of the array: [2, -1] → [2, X].
The fourth example can have the following sequence of transformations of the array: [0, -10, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
The fifth example can have the following sequence of transformations of the array: [0, 0, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
Submitted Solution:
```
import sys
n = int(input())
l = list(map(int,sys.stdin.readline().rstrip().split()))
temp = [i for i in range(1,n+1)]
temp = set(temp)
lt = n
neg = []
cntn = 0
cnt0 = 0
f0 = 0
f1 = 0
ze = []
idx = -1
mn = -10**9-10
for i in range(n):
if(l[i]<0):
cntn+=1
f1 = 1
if(l[i]>mn):
mn = l[i]
idx = i+1
elif(l[i]==0):
f0 =1
cnt0+=1
ze.append(i+1)
if(f0):
if(f1):
if(cntn%2):
for i in range(cnt0-1):
print(1,ze[i],ze[i+1])
temp.remove(ze[i])
lt-=1
print(1,ze[cnt0-1],idx)
temp.remove(ze[cnt0-1])
lt-=1
if(lt>1):
print(2,idx)
temp.remove(idx)
lt-=1
else:
for i in range(cnt0-1):
print(1,ze[i],ze[i+1])
temp.remove(ze[i])
lt-=1
if(lt>1):
print(2,ze[cnt0-1])
temp.remove(ze[cnt0-1])
lt-=1
else:
for i in range(cnt0-1):
print(1,ze[i],ze[i+1])
temp.remove(ze[i])
lt-=1
if(lt>1):
print(2,ze[cnt0-1])
temp.remove(ze[cnt0-1])
lt-=1
else:
if(f1):
if(cntn%2):
neg.sort(key = lambda x:x[0],reverse=True)
print(2,idx)
temp.remove(idx)
lt-=1
temp = list(temp)
for i in range(lt-1):
print(1,temp[i],temp[i+1])
``` | instruction | 0 | 60,648 | 12 | 121,296 |
Yes | output | 1 | 60,648 | 12 | 121,297 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. You can perform the following operations with it:
1. Choose some positions i and j (1 ≤ i, j ≤ n, i ≠ j), write the value of a_i ⋅ a_j into the j-th cell and remove the number from the i-th cell;
2. Choose some position i and remove the number from the i-th cell (this operation can be performed no more than once and at any point of time, not necessarily in the beginning).
The number of elements decreases by one after each operation. However, the indexing of positions stays the same. Deleted numbers can't be used in the later operations.
Your task is to perform exactly n - 1 operations with the array in such a way that the only number that remains in the array is maximum possible. This number can be rather large, so instead of printing it you need to print any sequence of operations which leads to this maximum number. Read the output format to understand what exactly you need to print.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print n - 1 lines. The k-th line should contain one of the two possible operations.
The operation of the first type should look like this: 1~ i_k~ j_k, where 1 is the type of operation, i_k and j_k are the positions of the chosen elements.
The operation of the second type should look like this: 2~ i_k, where 2 is the type of operation, i_k is the position of the chosen element. Note that there should be no more than one such operation.
If there are multiple possible sequences of operations leading to the maximum number — print any of them.
Examples
Input
5
5 -2 0 1 -3
Output
2 3
1 1 2
1 2 4
1 4 5
Input
5
5 2 0 4 0
Output
1 3 5
2 5
1 1 2
1 2 4
Input
2
2 -1
Output
2 2
Input
4
0 -10 0 0
Output
1 1 2
1 2 3
1 3 4
Input
4
0 0 0 0
Output
1 1 2
1 2 3
1 3 4
Note
Let X be the removed number in the array. Let's take a look at all the examples:
The first example has, for example, the following sequence of transformations of the array: [5, -2, 0, 1, -3] → [5, -2, X, 1, -3] → [X, -10, X, 1, -3] → [X, X, X, -10, -3] → [X, X, X, X, 30]. Thus, the maximum answer is 30. Note, that other sequences that lead to the answer 30 are also correct.
The second example has, for example, the following sequence of transformations of the array: [5, 2, 0, 4, 0] → [5, 2, X, 4, 0] → [5, 2, X, 4, X] → [X, 10, X, 4, X] → [X, X, X, 40, X]. The following answer is also allowed:
1 5 3
1 4 2
1 2 1
2 3
Then the sequence of transformations of the array will look like this: [5, 2, 0, 4, 0] → [5, 2, 0, 4, X] → [5, 8, 0, X, X] → [40, X, 0, X, X] → [40, X, X, X, X].
The third example can have the following sequence of transformations of the array: [2, -1] → [2, X].
The fourth example can have the following sequence of transformations of the array: [0, -10, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
The fifth example can have the following sequence of transformations of the array: [0, 0, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
Submitted Solution:
```
import sys
n = int(input())
l = list(map(int,sys.stdin.readline().rstrip().split()))
temp = [i for i in range(1,n+1)]
temp = set(temp)
lt = n
neg = []
cntn = 0
cnt0 = 0
f0 = 0
f1 = 0
ze = []
idx = -1
mn = -10**9-10
for i in range(n):
if(l[i]<0):
cntn+=1
f1 = 1
if(l[i]>mn):
mn = l[i]
idx = i+1
elif(l[i]==0):
f0 =1
cnt0+=1
ze.append(i+1)
if(f0):
if(f1):
if(cntn%2):
for i in range(cnt0-1):
print(1,ze[i],ze[i+1])
temp.remove(ze[i])
lt-=1
print(1,ze[cnt0-1],idx)
temp.remove(ze[cnt0-1])
lt-=1
if(lt>1):
print(2,idx)
temp.remove(idx)
lt-=1
temp = list(temp)
for i in range(lt-1):
print(1,temp[i],temp[i+1])
else:
for i in range(cnt0-1):
print(1,ze[i],ze[i+1])
temp.remove(ze[i])
lt-=1
if(lt>1):
print(2,ze[cnt0-1])
temp.remove(ze[cnt0-1])
lt-=1
temp = list(temp)
for i in range(lt-1):
print(1,temp[i],temp[i+1])
else:
for i in range(cnt0-1):
print(1,ze[i],ze[i+1])
temp.remove(ze[i])
lt-=1
if(lt>1):
print(2,ze[cnt0-1])
temp.remove(ze[cnt0-1])
lt-=1
temp = list(temp)
for i in range(lt-1):
print(1,temp[i],temp[i+1])
else:
if(f1):
if(cntn%2):
neg.sort(key = lambda x:x[0],reverse=True)
print(2,idx)
temp.remove(idx)
lt-=1
temp = list(temp)
for i in range(lt-1):
print(1,temp[i],temp[i+1])
else:
temp = list(temp)
for i in range(lt-1):
print(1,temp[i],temp[i+1])
else:
temp = list(temp)
for i in range(lt-1):
print(1,temp[i],temp[i+1])
``` | instruction | 0 | 60,649 | 12 | 121,298 |
Yes | output | 1 | 60,649 | 12 | 121,299 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. You can perform the following operations with it:
1. Choose some positions i and j (1 ≤ i, j ≤ n, i ≠ j), write the value of a_i ⋅ a_j into the j-th cell and remove the number from the i-th cell;
2. Choose some position i and remove the number from the i-th cell (this operation can be performed no more than once and at any point of time, not necessarily in the beginning).
The number of elements decreases by one after each operation. However, the indexing of positions stays the same. Deleted numbers can't be used in the later operations.
Your task is to perform exactly n - 1 operations with the array in such a way that the only number that remains in the array is maximum possible. This number can be rather large, so instead of printing it you need to print any sequence of operations which leads to this maximum number. Read the output format to understand what exactly you need to print.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print n - 1 lines. The k-th line should contain one of the two possible operations.
The operation of the first type should look like this: 1~ i_k~ j_k, where 1 is the type of operation, i_k and j_k are the positions of the chosen elements.
The operation of the second type should look like this: 2~ i_k, where 2 is the type of operation, i_k is the position of the chosen element. Note that there should be no more than one such operation.
If there are multiple possible sequences of operations leading to the maximum number — print any of them.
Examples
Input
5
5 -2 0 1 -3
Output
2 3
1 1 2
1 2 4
1 4 5
Input
5
5 2 0 4 0
Output
1 3 5
2 5
1 1 2
1 2 4
Input
2
2 -1
Output
2 2
Input
4
0 -10 0 0
Output
1 1 2
1 2 3
1 3 4
Input
4
0 0 0 0
Output
1 1 2
1 2 3
1 3 4
Note
Let X be the removed number in the array. Let's take a look at all the examples:
The first example has, for example, the following sequence of transformations of the array: [5, -2, 0, 1, -3] → [5, -2, X, 1, -3] → [X, -10, X, 1, -3] → [X, X, X, -10, -3] → [X, X, X, X, 30]. Thus, the maximum answer is 30. Note, that other sequences that lead to the answer 30 are also correct.
The second example has, for example, the following sequence of transformations of the array: [5, 2, 0, 4, 0] → [5, 2, X, 4, 0] → [5, 2, X, 4, X] → [X, 10, X, 4, X] → [X, X, X, 40, X]. The following answer is also allowed:
1 5 3
1 4 2
1 2 1
2 3
Then the sequence of transformations of the array will look like this: [5, 2, 0, 4, 0] → [5, 2, 0, 4, X] → [5, 8, 0, X, X] → [40, X, 0, X, X] → [40, X, X, X, X].
The third example can have the following sequence of transformations of the array: [2, -1] → [2, X].
The fourth example can have the following sequence of transformations of the array: [0, -10, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
The fifth example can have the following sequence of transformations of the array: [0, 0, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
def solve(zero):
if not zero: return 0
if len(zero) == 1:
return zero[0]
for i in range(len(zero)-1):
print(1,zero[i],zero[i+1])
return zero[-1]
pos = []
neg = []
zero = []
for i,v in enumerate(a):
if v > 0:
pos.append(i+1)
elif v < 0:
neg.append(i+1)
else:
zero.append(i+1)
if len(neg) % 2 == 0:
if zero:
index = solve(zero)
if zero and len(pos+neg) > 0: print(2, index)
solve(pos + neg)
elif len(neg) % 2 == 1:
if zero:
index = solve(zero)
index1 = max(neg, key= lambda x:a[x-1])
print(1, index, index1)
neg.remove(index1)
else:
index1 = max(neg, key= lambda x:a[x-1])
neg.remove(index1)
if len(pos+neg) > 0: print(2, index1)
solve(pos + neg)
``` | instruction | 0 | 60,650 | 12 | 121,300 |
Yes | output | 1 | 60,650 | 12 | 121,301 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. You can perform the following operations with it:
1. Choose some positions i and j (1 ≤ i, j ≤ n, i ≠ j), write the value of a_i ⋅ a_j into the j-th cell and remove the number from the i-th cell;
2. Choose some position i and remove the number from the i-th cell (this operation can be performed no more than once and at any point of time, not necessarily in the beginning).
The number of elements decreases by one after each operation. However, the indexing of positions stays the same. Deleted numbers can't be used in the later operations.
Your task is to perform exactly n - 1 operations with the array in such a way that the only number that remains in the array is maximum possible. This number can be rather large, so instead of printing it you need to print any sequence of operations which leads to this maximum number. Read the output format to understand what exactly you need to print.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print n - 1 lines. The k-th line should contain one of the two possible operations.
The operation of the first type should look like this: 1~ i_k~ j_k, where 1 is the type of operation, i_k and j_k are the positions of the chosen elements.
The operation of the second type should look like this: 2~ i_k, where 2 is the type of operation, i_k is the position of the chosen element. Note that there should be no more than one such operation.
If there are multiple possible sequences of operations leading to the maximum number — print any of them.
Examples
Input
5
5 -2 0 1 -3
Output
2 3
1 1 2
1 2 4
1 4 5
Input
5
5 2 0 4 0
Output
1 3 5
2 5
1 1 2
1 2 4
Input
2
2 -1
Output
2 2
Input
4
0 -10 0 0
Output
1 1 2
1 2 3
1 3 4
Input
4
0 0 0 0
Output
1 1 2
1 2 3
1 3 4
Note
Let X be the removed number in the array. Let's take a look at all the examples:
The first example has, for example, the following sequence of transformations of the array: [5, -2, 0, 1, -3] → [5, -2, X, 1, -3] → [X, -10, X, 1, -3] → [X, X, X, -10, -3] → [X, X, X, X, 30]. Thus, the maximum answer is 30. Note, that other sequences that lead to the answer 30 are also correct.
The second example has, for example, the following sequence of transformations of the array: [5, 2, 0, 4, 0] → [5, 2, X, 4, 0] → [5, 2, X, 4, X] → [X, 10, X, 4, X] → [X, X, X, 40, X]. The following answer is also allowed:
1 5 3
1 4 2
1 2 1
2 3
Then the sequence of transformations of the array will look like this: [5, 2, 0, 4, 0] → [5, 2, 0, 4, X] → [5, 8, 0, X, X] → [40, X, 0, X, X] → [40, X, X, X, X].
The third example can have the following sequence of transformations of the array: [2, -1] → [2, X].
The fourth example can have the following sequence of transformations of the array: [0, -10, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
The fifth example can have the following sequence of transformations of the array: [0, 0, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
Submitted Solution:
```
#########################################################################################################\
#########################################################################################################
###################################The_Apurv_Rathore#####################################################
#########################################################################################################
#########################################################################################################
import sys,os,io
from sys import stdin
from math import log, gcd, ceil
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from bisect import bisect_left , bisect_right
import math
alphabets = list('abcdefghijklmnopqrstuvwxyz')
def isPrime(x):
for i in range(2,x):
if i*i>x:
break
if (x%i==0):
return False
return True
def ncr(n, r, p):
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
def primeFactors(n):
l = []
while n % 2 == 0:
l.append(2)
n = n / 2
for i in range(3,int(math.sqrt(n))+1,2):
while n % i== 0:
l.append(int(i))
n = n / i
if n > 2:
l.append(n)
return list(set(l))
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 # y = y/2
x = (x * x) % p
return res
def SieveOfEratosthenes(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
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def si():
return input()
def prefix_sum(arr):
r = [0] * (len(arr)+1)
for i, el in enumerate(arr):
r[i+1] = r[i] + el
return r
def divideCeil(n,x):
if (n%x==0):
return n//x
return n//x+1
def ii():
return int(input())
def li():
return list(map(int,input().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
def power_set(L):
"""
L is a list.
The function returns the power set, but as a list of lists.
"""
cardinality=len(L)
n=2 ** cardinality
powerset = []
for i in range(n):
a=bin(i)[2:]
subset=[]
for j in range(len(a)):
if a[-j-1]=='1':
subset.append(L[j])
powerset.append(subset)
#the function could stop here closing with
#return powerset
powerset_orderred=[]
for k in range(cardinality+1):
for w in powerset:
if len(w)==k:
powerset_orderred.append(w)
return powerset_orderred
def fastPlrintNextLines(a):
# 12
# 3
# 1
#like this
#a is list of strings
print('\n'.join(map(str,a)))
def sortByFirstAndSecond(A):
A = sorted(A,key = lambda x:x[0])
A = sorted(A,key = lambda x:x[1])
return list(A)
#__________________________TEMPLATE__________________OVER_______________________________________________________
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r") ; sys.stdout = open("output.txt","w")
else:
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
t = 1
# t = int(input())
for _ in range(t):
n = ii()
l = li()
ans = []
prev = -1
for i in range(n):
if (l[i]==0):
if (prev==-1):
prev = i
else:
ans.append([1,prev+1,i+1])
prev = i
temp = [-1,-1]
if (prev!=-1):
negcnt = 0
maxneg = -100000000000000000000
for i in l:
if (i<0):
maxneg = max(maxneg,i)
negcnt+=1
if negcnt%2==1:
ans.append([1,l.index(maxneg)+1,prev+1])
l[l.index(maxneg)] = 0
temp = ([2,prev+1])
else:
negcnt = 0
maxneg = -100000000000000000000
for i in l:
if (i<0):
maxneg = max(maxneg,i)
negcnt+=1
if negcnt%2==1:
ans.append([2,l.index(maxneg)+1])
l[l.index(maxneg)] = 0
prev = -1
# print(l)
for i in range(n):
if (l[i]!=0):
if (prev==-1):
prev = i
else:
# print("i",i)
ans.append([1,prev+1,i+1])
prev = i
if (prev!=-1 and temp!=[-1,-1]):
ans.append(temp)
for i in ans:
print(*i)
``` | instruction | 0 | 60,651 | 12 | 121,302 |
Yes | output | 1 | 60,651 | 12 | 121,303 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. You can perform the following operations with it:
1. Choose some positions i and j (1 ≤ i, j ≤ n, i ≠ j), write the value of a_i ⋅ a_j into the j-th cell and remove the number from the i-th cell;
2. Choose some position i and remove the number from the i-th cell (this operation can be performed no more than once and at any point of time, not necessarily in the beginning).
The number of elements decreases by one after each operation. However, the indexing of positions stays the same. Deleted numbers can't be used in the later operations.
Your task is to perform exactly n - 1 operations with the array in such a way that the only number that remains in the array is maximum possible. This number can be rather large, so instead of printing it you need to print any sequence of operations which leads to this maximum number. Read the output format to understand what exactly you need to print.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print n - 1 lines. The k-th line should contain one of the two possible operations.
The operation of the first type should look like this: 1~ i_k~ j_k, where 1 is the type of operation, i_k and j_k are the positions of the chosen elements.
The operation of the second type should look like this: 2~ i_k, where 2 is the type of operation, i_k is the position of the chosen element. Note that there should be no more than one such operation.
If there are multiple possible sequences of operations leading to the maximum number — print any of them.
Examples
Input
5
5 -2 0 1 -3
Output
2 3
1 1 2
1 2 4
1 4 5
Input
5
5 2 0 4 0
Output
1 3 5
2 5
1 1 2
1 2 4
Input
2
2 -1
Output
2 2
Input
4
0 -10 0 0
Output
1 1 2
1 2 3
1 3 4
Input
4
0 0 0 0
Output
1 1 2
1 2 3
1 3 4
Note
Let X be the removed number in the array. Let's take a look at all the examples:
The first example has, for example, the following sequence of transformations of the array: [5, -2, 0, 1, -3] → [5, -2, X, 1, -3] → [X, -10, X, 1, -3] → [X, X, X, -10, -3] → [X, X, X, X, 30]. Thus, the maximum answer is 30. Note, that other sequences that lead to the answer 30 are also correct.
The second example has, for example, the following sequence of transformations of the array: [5, 2, 0, 4, 0] → [5, 2, X, 4, 0] → [5, 2, X, 4, X] → [X, 10, X, 4, X] → [X, X, X, 40, X]. The following answer is also allowed:
1 5 3
1 4 2
1 2 1
2 3
Then the sequence of transformations of the array will look like this: [5, 2, 0, 4, 0] → [5, 2, 0, 4, X] → [5, 8, 0, X, X] → [40, X, 0, X, X] → [40, X, X, X, X].
The third example can have the following sequence of transformations of the array: [2, -1] → [2, X].
The fourth example can have the following sequence of transformations of the array: [0, -10, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
The fifth example can have the following sequence of transformations of the array: [0, 0, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
Submitted Solution:
```
n = int(input())
vector = [int(i) for i in input().split()]
usado = []
nusado = []
pos = -1
cn = 0
cz = 0
resp = []
ultimo = -1
i = 0
while i < n:
v = vector[i]
if v < 0:
cn+=1
if pos == -1 or (vector[pos] < v):
pos = i
nusado.append(i)
elif v == 0:
cz+=1
usado.append(i)
else:
if ultimo != -1:
print(1,ultimo+1,i+1)
ultimo = i
i+=1
ultimate = ultimo
if cz == n or (cz == n - 1 and cn == 1):
i = 1
while i < n:
resp.append("%d %d %d" %(1,i,i+1))
i+=1
else:
cross = -1
if cn%2 == 1:
cross = pos
usado.append(pos)
ultimo = -1
i = 0
for i in usado:
if ultimo != -1:
resp.append("%d %d %d" % (1,ultimo+1,i+1))
ultimo = i
i+=1
if ultimo != -1:
print(2,ultimo+1)
i = 0
ultimo = ultimate
for i in nusado:
if i != cross:
if ultimo != -1:
resp.append("%d %d %d" % (1,ultimo+1,i+1))
ultimo = i
i+=1
print("\n".join(resp))
``` | instruction | 0 | 60,652 | 12 | 121,304 |
No | output | 1 | 60,652 | 12 | 121,305 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. You can perform the following operations with it:
1. Choose some positions i and j (1 ≤ i, j ≤ n, i ≠ j), write the value of a_i ⋅ a_j into the j-th cell and remove the number from the i-th cell;
2. Choose some position i and remove the number from the i-th cell (this operation can be performed no more than once and at any point of time, not necessarily in the beginning).
The number of elements decreases by one after each operation. However, the indexing of positions stays the same. Deleted numbers can't be used in the later operations.
Your task is to perform exactly n - 1 operations with the array in such a way that the only number that remains in the array is maximum possible. This number can be rather large, so instead of printing it you need to print any sequence of operations which leads to this maximum number. Read the output format to understand what exactly you need to print.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print n - 1 lines. The k-th line should contain one of the two possible operations.
The operation of the first type should look like this: 1~ i_k~ j_k, where 1 is the type of operation, i_k and j_k are the positions of the chosen elements.
The operation of the second type should look like this: 2~ i_k, where 2 is the type of operation, i_k is the position of the chosen element. Note that there should be no more than one such operation.
If there are multiple possible sequences of operations leading to the maximum number — print any of them.
Examples
Input
5
5 -2 0 1 -3
Output
2 3
1 1 2
1 2 4
1 4 5
Input
5
5 2 0 4 0
Output
1 3 5
2 5
1 1 2
1 2 4
Input
2
2 -1
Output
2 2
Input
4
0 -10 0 0
Output
1 1 2
1 2 3
1 3 4
Input
4
0 0 0 0
Output
1 1 2
1 2 3
1 3 4
Note
Let X be the removed number in the array. Let's take a look at all the examples:
The first example has, for example, the following sequence of transformations of the array: [5, -2, 0, 1, -3] → [5, -2, X, 1, -3] → [X, -10, X, 1, -3] → [X, X, X, -10, -3] → [X, X, X, X, 30]. Thus, the maximum answer is 30. Note, that other sequences that lead to the answer 30 are also correct.
The second example has, for example, the following sequence of transformations of the array: [5, 2, 0, 4, 0] → [5, 2, X, 4, 0] → [5, 2, X, 4, X] → [X, 10, X, 4, X] → [X, X, X, 40, X]. The following answer is also allowed:
1 5 3
1 4 2
1 2 1
2 3
Then the sequence of transformations of the array will look like this: [5, 2, 0, 4, 0] → [5, 2, 0, 4, X] → [5, 8, 0, X, X] → [40, X, 0, X, X] → [40, X, X, X, X].
The third example can have the following sequence of transformations of the array: [2, -1] → [2, X].
The fourth example can have the following sequence of transformations of the array: [0, -10, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
The fifth example can have the following sequence of transformations of the array: [0, 0, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
Submitted Solution:
```
ps=[];os=[];ns=[]
n=int(input())
ni=-1;e=10e9
a=list(map(int,input().split()))
for i in range(n):
if a[i]>0:
ps.append(i+1)
elif a[i]<0:
ns.append(i+1)
if abs(a[i])<e:
e=abs(a[i])
ni=i+1
else:
os.append(i+1)
fl=0
if len(ns)%2!=0:
print(2,ni)
ns.remove(ni)
fl=1
for i in range(1,len(ns)):
print(1,ns[i-1],ns[i])
if len(ps)>0 and len(ns)>0:
print(1,ns[-1],ps[0])
for i in range(1,len(ps)):
print(1,ps[i-1],ps[i])
for i in range(1,len(os)):
print(1,os[i-1],os[i])
if fl==0 and len(os)>0:
print(2,os[-1])
elif fl==1:
if len(os)>0 and len(ps)>0:
print(1,ps[-1],os[0])
``` | instruction | 0 | 60,653 | 12 | 121,306 |
No | output | 1 | 60,653 | 12 | 121,307 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. You can perform the following operations with it:
1. Choose some positions i and j (1 ≤ i, j ≤ n, i ≠ j), write the value of a_i ⋅ a_j into the j-th cell and remove the number from the i-th cell;
2. Choose some position i and remove the number from the i-th cell (this operation can be performed no more than once and at any point of time, not necessarily in the beginning).
The number of elements decreases by one after each operation. However, the indexing of positions stays the same. Deleted numbers can't be used in the later operations.
Your task is to perform exactly n - 1 operations with the array in such a way that the only number that remains in the array is maximum possible. This number can be rather large, so instead of printing it you need to print any sequence of operations which leads to this maximum number. Read the output format to understand what exactly you need to print.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print n - 1 lines. The k-th line should contain one of the two possible operations.
The operation of the first type should look like this: 1~ i_k~ j_k, where 1 is the type of operation, i_k and j_k are the positions of the chosen elements.
The operation of the second type should look like this: 2~ i_k, where 2 is the type of operation, i_k is the position of the chosen element. Note that there should be no more than one such operation.
If there are multiple possible sequences of operations leading to the maximum number — print any of them.
Examples
Input
5
5 -2 0 1 -3
Output
2 3
1 1 2
1 2 4
1 4 5
Input
5
5 2 0 4 0
Output
1 3 5
2 5
1 1 2
1 2 4
Input
2
2 -1
Output
2 2
Input
4
0 -10 0 0
Output
1 1 2
1 2 3
1 3 4
Input
4
0 0 0 0
Output
1 1 2
1 2 3
1 3 4
Note
Let X be the removed number in the array. Let's take a look at all the examples:
The first example has, for example, the following sequence of transformations of the array: [5, -2, 0, 1, -3] → [5, -2, X, 1, -3] → [X, -10, X, 1, -3] → [X, X, X, -10, -3] → [X, X, X, X, 30]. Thus, the maximum answer is 30. Note, that other sequences that lead to the answer 30 are also correct.
The second example has, for example, the following sequence of transformations of the array: [5, 2, 0, 4, 0] → [5, 2, X, 4, 0] → [5, 2, X, 4, X] → [X, 10, X, 4, X] → [X, X, X, 40, X]. The following answer is also allowed:
1 5 3
1 4 2
1 2 1
2 3
Then the sequence of transformations of the array will look like this: [5, 2, 0, 4, 0] → [5, 2, 0, 4, X] → [5, 8, 0, X, X] → [40, X, 0, X, X] → [40, X, X, X, X].
The third example can have the following sequence of transformations of the array: [2, -1] → [2, X].
The fourth example can have the following sequence of transformations of the array: [0, -10, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
The fifth example can have the following sequence of transformations of the array: [0, 0, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
Submitted Solution:
```
n = int(input())
num = list(map(int, input().split()))
visited = [True] * n
negative = 0
mn = -10**10
pos = -1
zero = 0
pos_zero = []
for i in range(n):
q = num[i]
if q == 0:
zero += 1
pos_zero.append(i)
elif q < 0:
negative += 1
if pos == -1:
pos = i
if mn < q:
mn = q
pos = i
for i in range(len(pos_zero)-1):
print(1, pos_zero[i] + 1, pos_zero[i+1] + 1)
visited[pos_zero[i]] = False
if len(pos_zero) > 0:
n -= len(pos_zero)-1
if zero > 0 and negative % 2 == 1 and n > 1:
print(1, pos+1, pos_zero[-1]+1)
visited[pos] = False
n -= 1
elif negative % 2 == 1 and zero == 0 and n > 1:
visited[pos] = False
n -= 1
print(2, pos+1)
elif zero > 0 and n > 1:
visited[pos_zero[-1]] = False
n -= 1
print(2, pos_zero[-1]+1)
i = -1
old, cur = None, None
while n - i > 0:
i += 1
if visited[i]:
if old is None:
old = i
visited[i] = False
continue
if cur is None:
cur = i
print(1, old + 1, cur + 1)
old, cur = cur, None
continue
``` | instruction | 0 | 60,654 | 12 | 121,308 |
No | output | 1 | 60,654 | 12 | 121,309 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. You can perform the following operations with it:
1. Choose some positions i and j (1 ≤ i, j ≤ n, i ≠ j), write the value of a_i ⋅ a_j into the j-th cell and remove the number from the i-th cell;
2. Choose some position i and remove the number from the i-th cell (this operation can be performed no more than once and at any point of time, not necessarily in the beginning).
The number of elements decreases by one after each operation. However, the indexing of positions stays the same. Deleted numbers can't be used in the later operations.
Your task is to perform exactly n - 1 operations with the array in such a way that the only number that remains in the array is maximum possible. This number can be rather large, so instead of printing it you need to print any sequence of operations which leads to this maximum number. Read the output format to understand what exactly you need to print.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print n - 1 lines. The k-th line should contain one of the two possible operations.
The operation of the first type should look like this: 1~ i_k~ j_k, where 1 is the type of operation, i_k and j_k are the positions of the chosen elements.
The operation of the second type should look like this: 2~ i_k, where 2 is the type of operation, i_k is the position of the chosen element. Note that there should be no more than one such operation.
If there are multiple possible sequences of operations leading to the maximum number — print any of them.
Examples
Input
5
5 -2 0 1 -3
Output
2 3
1 1 2
1 2 4
1 4 5
Input
5
5 2 0 4 0
Output
1 3 5
2 5
1 1 2
1 2 4
Input
2
2 -1
Output
2 2
Input
4
0 -10 0 0
Output
1 1 2
1 2 3
1 3 4
Input
4
0 0 0 0
Output
1 1 2
1 2 3
1 3 4
Note
Let X be the removed number in the array. Let's take a look at all the examples:
The first example has, for example, the following sequence of transformations of the array: [5, -2, 0, 1, -3] → [5, -2, X, 1, -3] → [X, -10, X, 1, -3] → [X, X, X, -10, -3] → [X, X, X, X, 30]. Thus, the maximum answer is 30. Note, that other sequences that lead to the answer 30 are also correct.
The second example has, for example, the following sequence of transformations of the array: [5, 2, 0, 4, 0] → [5, 2, X, 4, 0] → [5, 2, X, 4, X] → [X, 10, X, 4, X] → [X, X, X, 40, X]. The following answer is also allowed:
1 5 3
1 4 2
1 2 1
2 3
Then the sequence of transformations of the array will look like this: [5, 2, 0, 4, 0] → [5, 2, 0, 4, X] → [5, 8, 0, X, X] → [40, X, 0, X, X] → [40, X, X, X, X].
The third example can have the following sequence of transformations of the array: [2, -1] → [2, X].
The fourth example can have the following sequence of transformations of the array: [0, -10, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
The fifth example can have the following sequence of transformations of the array: [0, 0, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
Submitted Solution:
```
INF = float('inf')
def solution(n, a):
neg = []
zero = []
pos = []
for i, v in enumerate(a):
if v == 0:
zero.append((v, i))
elif v < 0:
neg.append((v, i))
else:
pos.append((v, i))
neg.sort()
ans = []
if len(neg) % 2 == 0:
if zero:
a[zero[0][1]] = INF
ans.append((2, zero[0][1]))
else:
a[neg[0][1]] = INF
ans.append((2, neg[0][1]))
for i in range(n - 1):
if a[i + 1] == INF and i + 2 < n:
ans.append((1, i, i + 2))
elif a[i] != INF and a[i + 1] != INF:
ans.append((1, i, i + 1))
return ans
n = int(input())
a = [int(c) for c in input().split()]
ans = solution(n, a)
for an in ans:
print(' '.join(str(s + 1) for s in an))
``` | instruction | 0 | 60,655 | 12 | 121,310 |
No | output | 1 | 60,655 | 12 | 121,311 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers a_1, a_2, ... , a_n.
In one operation you can choose two elements of the array and replace them with the element equal to their sum (it does not matter where you insert the new element). For example, from the array [2, 1, 4] you can obtain the following arrays: [3, 4], [1, 6] and [2, 5].
Your task is to find the maximum possible number of elements divisible by 3 that are in the array after performing this operation an arbitrary (possibly, zero) number of times.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
The first line of each query contains one integer n (1 ≤ n ≤ 100).
The second line of each query contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9).
Output
For each query print one integer in a single line — the maximum possible number of elements divisible by 3 that are in the array after performing described operation an arbitrary (possibly, zero) number of times.
Example
Input
2
5
3 1 2 3 1
7
1 1 1 1 1 2 2
Output
3
3
Note
In the first query of the example you can apply the following sequence of operations to obtain 3 elements divisible by 3: [3, 1, 2, 3, 1] → [3, 3, 3, 1].
In the second query you can obtain 3 elements divisible by 3 with the following sequence of operations: [1, 1, 1, 1, 1, 2, 2] → [1, 1, 1, 1, 2, 3] → [1, 1, 1, 3, 3] → [2, 1, 3, 3] → [3, 3, 3]. | instruction | 0 | 60,710 | 12 | 121,420 |
Tags: math
Correct Solution:
```
for _____ in range(int(input())):
n = int(input())
arr = list(map(int,input().split()))
d = {0:0,1:0,2:0}
for it in arr:
d[it%3] +=1
a,b,c = d[0],d[1],d[2]
if b < c:
ctx = a + b + (c-b)//3
elif c < b:
ctx = a + c + (b-c)//3
else:
ctx = a + b
print(ctx)
``` | output | 1 | 60,710 | 12 | 121,421 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers a_1, a_2, ... , a_n.
In one operation you can choose two elements of the array and replace them with the element equal to their sum (it does not matter where you insert the new element). For example, from the array [2, 1, 4] you can obtain the following arrays: [3, 4], [1, 6] and [2, 5].
Your task is to find the maximum possible number of elements divisible by 3 that are in the array after performing this operation an arbitrary (possibly, zero) number of times.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
The first line of each query contains one integer n (1 ≤ n ≤ 100).
The second line of each query contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9).
Output
For each query print one integer in a single line — the maximum possible number of elements divisible by 3 that are in the array after performing described operation an arbitrary (possibly, zero) number of times.
Example
Input
2
5
3 1 2 3 1
7
1 1 1 1 1 2 2
Output
3
3
Note
In the first query of the example you can apply the following sequence of operations to obtain 3 elements divisible by 3: [3, 1, 2, 3, 1] → [3, 3, 3, 1].
In the second query you can obtain 3 elements divisible by 3 with the following sequence of operations: [1, 1, 1, 1, 1, 2, 2] → [1, 1, 1, 1, 2, 3] → [1, 1, 1, 3, 3] → [2, 1, 3, 3] → [3, 3, 3]. | instruction | 0 | 60,712 | 12 | 121,424 |
Tags: math
Correct Solution:
```
cases = int(input())
while cases:
cases -= 1
num = int(input())
arr = list(map(int, input().split()))
ans = 0
ones = 0
twos = 0
for n in arr:
md = n % 3
if md == 0:
ans += 1
elif md == 1:
ones += 1
else:
twos += 1
mn = min(ones, twos)
ans += mn
ones -= mn
twos -= mn
ans += twos // 3
ans += ones // 3
print(ans)
``` | output | 1 | 60,712 | 12 | 121,425 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers a_1, a_2, ... , a_n.
In one operation you can choose two elements of the array and replace them with the element equal to their sum (it does not matter where you insert the new element). For example, from the array [2, 1, 4] you can obtain the following arrays: [3, 4], [1, 6] and [2, 5].
Your task is to find the maximum possible number of elements divisible by 3 that are in the array after performing this operation an arbitrary (possibly, zero) number of times.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
The first line of each query contains one integer n (1 ≤ n ≤ 100).
The second line of each query contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9).
Output
For each query print one integer in a single line — the maximum possible number of elements divisible by 3 that are in the array after performing described operation an arbitrary (possibly, zero) number of times.
Example
Input
2
5
3 1 2 3 1
7
1 1 1 1 1 2 2
Output
3
3
Note
In the first query of the example you can apply the following sequence of operations to obtain 3 elements divisible by 3: [3, 1, 2, 3, 1] → [3, 3, 3, 1].
In the second query you can obtain 3 elements divisible by 3 with the following sequence of operations: [1, 1, 1, 1, 1, 2, 2] → [1, 1, 1, 1, 2, 3] → [1, 1, 1, 3, 3] → [2, 1, 3, 3] → [3, 3, 3].
Submitted Solution:
```
import io, sys, atexit, os
import math as ma
from sys import exit
from decimal import Decimal as dec
from itertools import permutations
def li ():
return list (map (int, input ().split ()))
def num ():
return map (int, input ().split ())
def nu ():
return int (input ())
def find_gcd ( x, y ):
while (y):
x, y = y, x % y
return x
def lcm ( x, y ):
gg = find_gcd (x, y)
return (x * y // gg)
mm = 1000000007
yp = 0
def solve ():
t = nu()
for _ in range (t):
n=nu()
a=li()
for i in range(n):
a[i]=a[i]%3
pp=0
qq=0
cc=0
for i in range(n):
if(a[i]==0):
cc+=1
if(a[i]==1):
pp+=1
if(a[i]==2):
qq+=1
if(qq>0 and pp>0):
cc+=min(qq,pp)
zz=min(pp,qq)
qq-=zz
pp-=zz
if(pp>0):
cc+=pp//3
pp-=pp//3
if(qq>0):
cc+=qq//3
qq-=qq//3
print(cc)
if __name__ == "__main__":
solve ()
``` | instruction | 0 | 60,714 | 12 | 121,428 |
Yes | output | 1 | 60,714 | 12 | 121,429 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers a_1, a_2, ... , a_n.
In one operation you can choose two elements of the array and replace them with the element equal to their sum (it does not matter where you insert the new element). For example, from the array [2, 1, 4] you can obtain the following arrays: [3, 4], [1, 6] and [2, 5].
Your task is to find the maximum possible number of elements divisible by 3 that are in the array after performing this operation an arbitrary (possibly, zero) number of times.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
The first line of each query contains one integer n (1 ≤ n ≤ 100).
The second line of each query contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9).
Output
For each query print one integer in a single line — the maximum possible number of elements divisible by 3 that are in the array after performing described operation an arbitrary (possibly, zero) number of times.
Example
Input
2
5
3 1 2 3 1
7
1 1 1 1 1 2 2
Output
3
3
Note
In the first query of the example you can apply the following sequence of operations to obtain 3 elements divisible by 3: [3, 1, 2, 3, 1] → [3, 3, 3, 1].
In the second query you can obtain 3 elements divisible by 3 with the following sequence of operations: [1, 1, 1, 1, 1, 2, 2] → [1, 1, 1, 1, 2, 3] → [1, 1, 1, 3, 3] → [2, 1, 3, 3] → [3, 3, 3].
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
l = list(map(int,input().split()))
seti = set()
l.sort()
count = 0
for i in range(n):
if l[i]%3 == 0:
seti.add(i)
count+=1
for i in range(n):
if l[i]%3!=0:
for j in range(i+1,n):
if l[j]%3!=0:
if (l[i]+l[j])%3 == 0 and j not in seti and i not in seti:
count+=1
seti.add(j)
seti.add(i)
break
k = 0
for i in range(n):
if i not in seti:
k+=l[i]
if k%3 == 0:
count+=1
print(count)
``` | instruction | 0 | 60,716 | 12 | 121,432 |
Yes | output | 1 | 60,716 | 12 | 121,433 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers a_1, a_2, ... , a_n.
In one operation you can choose two elements of the array and replace them with the element equal to their sum (it does not matter where you insert the new element). For example, from the array [2, 1, 4] you can obtain the following arrays: [3, 4], [1, 6] and [2, 5].
Your task is to find the maximum possible number of elements divisible by 3 that are in the array after performing this operation an arbitrary (possibly, zero) number of times.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
The first line of each query contains one integer n (1 ≤ n ≤ 100).
The second line of each query contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9).
Output
For each query print one integer in a single line — the maximum possible number of elements divisible by 3 that are in the array after performing described operation an arbitrary (possibly, zero) number of times.
Example
Input
2
5
3 1 2 3 1
7
1 1 1 1 1 2 2
Output
3
3
Note
In the first query of the example you can apply the following sequence of operations to obtain 3 elements divisible by 3: [3, 1, 2, 3, 1] → [3, 3, 3, 1].
In the second query you can obtain 3 elements divisible by 3 with the following sequence of operations: [1, 1, 1, 1, 1, 2, 2] → [1, 1, 1, 1, 2, 3] → [1, 1, 1, 3, 3] → [2, 1, 3, 3] → [3, 3, 3].
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
a = map(int, input().split())
sum_of_a = sum(a)
print(min(n, sum_of_a // 3))
``` | instruction | 0 | 60,718 | 12 | 121,436 |
No | output | 1 | 60,718 | 12 | 121,437 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Consider the infinite sequence s of positive integers, created by repeating the following steps:
1. Find the lexicographically smallest triple of positive integers (a, b, c) such that
* a ⊕ b ⊕ c = 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
* a, b, c are not in s.
Here triple of integers (a_1, b_1, c_1) is considered to be lexicographically smaller than triple (a_2, b_2, c_2) if sequence [a_1, b_1, c_1] is lexicographically smaller than sequence [a_2, b_2, c_2].
2. Append a, b, c to s in this order.
3. Go back to the first step.
You have integer n. Find the n-th element of s.
You have to answer t independent test cases.
A sequence a is lexicographically smaller than a sequence b if in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
Each of the next t lines contains a single integer n (1≤ n ≤ 10^{16}) — the position of the element you want to know.
Output
In each of the t lines, output the answer to the corresponding test case.
Example
Input
9
1
2
3
4
5
6
7
8
9
Output
1
2
3
4
8
12
5
10
15
Note
The first elements of s are 1, 2, 3, 4, 8, 12, 5, 10, 15, ... | instruction | 0 | 60,801 | 12 | 121,602 |
Tags: bitmasks, brute force, constructive algorithms, divide and conquer, math
Correct Solution:
```
from math import *
from sys import stdin, stdout
MAXR=64
class ba:
u=0
v=0
def getBool( z):
ans=ba()
if(z==0):
ans.u='0'
ans.v='0'
elif(z==1):
ans.u='0'
ans.v='1'
elif(z==2):
ans.u='1'
ans.v='0'
else:
ans.u='1'
ans.v='1'
return ans
def getInt(u, v):
if(u=='0' and v=='0'):
return 0
elif(u=='0' and v=='1'):
return 1
elif(u=='1' and v=='0'):
return 2
else:
return 3
x=[[0,1,2,3],[0,2,3,1],[0,3,1,2]];
t = int(stdin.readline())
# t=int(input()
for w in range(t):
# cin>>a;
a = int(stdin.readline())
# a=int(input())
q=int(log(a,4))
q=int(pow(4,q))
d=int(a-q)
f=int(d%3)
ques=int(q+int(d/3))
ans=['0' for i in range(MAXR)]
qu=list(bin(ques)[2:].zfill(MAXR))
for i in range(0,MAXR,2):
# print(i,i+1)
l=getInt(qu[i],qu[i+1])
e=x[f][l]
y=getBool(e)
ans[i]=y.u
ans[i+1]=y.v
ans=str(int('0b'+("".join(ans)),2))+'\n'
stdout.write(ans)
# print()
# cout<<ans.to_ullong()<<"\n";
``` | output | 1 | 60,801 | 12 | 121,603 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Consider the infinite sequence s of positive integers, created by repeating the following steps:
1. Find the lexicographically smallest triple of positive integers (a, b, c) such that
* a ⊕ b ⊕ c = 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
* a, b, c are not in s.
Here triple of integers (a_1, b_1, c_1) is considered to be lexicographically smaller than triple (a_2, b_2, c_2) if sequence [a_1, b_1, c_1] is lexicographically smaller than sequence [a_2, b_2, c_2].
2. Append a, b, c to s in this order.
3. Go back to the first step.
You have integer n. Find the n-th element of s.
You have to answer t independent test cases.
A sequence a is lexicographically smaller than a sequence b if in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
Each of the next t lines contains a single integer n (1≤ n ≤ 10^{16}) — the position of the element you want to know.
Output
In each of the t lines, output the answer to the corresponding test case.
Example
Input
9
1
2
3
4
5
6
7
8
9
Output
1
2
3
4
8
12
5
10
15
Note
The first elements of s are 1, 2, 3, 4, 8, 12, 5, 10, 15, ... | instruction | 0 | 60,802 | 12 | 121,604 |
Tags: bitmasks, brute force, constructive algorithms, divide and conquer, math
Correct Solution:
```
tail = [["00","00","00"],
["01","10","11"],
["10","11","01"],
["11","01","10"]]
top = ["01", "10", "11"]
S=[]
E=[]
cur=1
for i in range(32):
S.append(cur)
E.append(4*cur-1)
cur *= 4
def convert(s):
cur=1
ans=0
for x in s[::-1]:
if x=="1":
ans|=cur
cur<<=1
return ans
def solve(n):
i=0
while n >E[i]:
i+=1
remain=n-S[i]
d, r = remain // 3, remain % 3
ans=[]
for _ in range(i):
ans.append(tail[d%4][r])
d//=4
ans.append(top[(n-1)%3])
return convert("".join(ans[::-1]))
print("\n".join([str(solve(int(input()))) for _ in range(int(input()))]))
``` | output | 1 | 60,802 | 12 | 121,605 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Consider the infinite sequence s of positive integers, created by repeating the following steps:
1. Find the lexicographically smallest triple of positive integers (a, b, c) such that
* a ⊕ b ⊕ c = 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
* a, b, c are not in s.
Here triple of integers (a_1, b_1, c_1) is considered to be lexicographically smaller than triple (a_2, b_2, c_2) if sequence [a_1, b_1, c_1] is lexicographically smaller than sequence [a_2, b_2, c_2].
2. Append a, b, c to s in this order.
3. Go back to the first step.
You have integer n. Find the n-th element of s.
You have to answer t independent test cases.
A sequence a is lexicographically smaller than a sequence b if in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
Each of the next t lines contains a single integer n (1≤ n ≤ 10^{16}) — the position of the element you want to know.
Output
In each of the t lines, output the answer to the corresponding test case.
Example
Input
9
1
2
3
4
5
6
7
8
9
Output
1
2
3
4
8
12
5
10
15
Note
The first elements of s are 1, 2, 3, 4, 8, 12, 5, 10, 15, ... | instruction | 0 | 60,803 | 12 | 121,606 |
Tags: bitmasks, brute force, constructive algorithms, divide and conquer, math
Correct Solution:
```
def level(m):
l = 0
while m - (1 << (l*2)) >= 0:
m -= (1 << (l*2))
l += 1
return l, m
def to_bin(l, r):
ls = []
for __ in range(l):
ls.append(r % 4)
r //= 4
return ls
def off(b, t):
magic = [
[0, 1, 2, 3],
[0, 2, 3, 1],
[0, 3, 1, 2]
]
base = 1
ans = 0
for d in b:
ans += base * magic[t][d]
base *= 4
return ans
def basic(l, t):
return 4 ** l * (t + 1)
def get_ans(n):
m, t = divmod(n-1, 3)
l, r = level(m)
b = to_bin(l, r)
o = off(b, t)
s = basic(l, t)
return s + o
input = __import__('sys').stdin.readline
T = int(input())
for __ in range(T):
print(get_ans(int(input())))
``` | output | 1 | 60,803 | 12 | 121,607 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Consider the infinite sequence s of positive integers, created by repeating the following steps:
1. Find the lexicographically smallest triple of positive integers (a, b, c) such that
* a ⊕ b ⊕ c = 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
* a, b, c are not in s.
Here triple of integers (a_1, b_1, c_1) is considered to be lexicographically smaller than triple (a_2, b_2, c_2) if sequence [a_1, b_1, c_1] is lexicographically smaller than sequence [a_2, b_2, c_2].
2. Append a, b, c to s in this order.
3. Go back to the first step.
You have integer n. Find the n-th element of s.
You have to answer t independent test cases.
A sequence a is lexicographically smaller than a sequence b if in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
Each of the next t lines contains a single integer n (1≤ n ≤ 10^{16}) — the position of the element you want to know.
Output
In each of the t lines, output the answer to the corresponding test case.
Example
Input
9
1
2
3
4
5
6
7
8
9
Output
1
2
3
4
8
12
5
10
15
Note
The first elements of s are 1, 2, 3, 4, 8, 12, 5, 10, 15, ... | instruction | 0 | 60,804 | 12 | 121,608 |
Tags: bitmasks, brute force, constructive algorithms, divide and conquer, math
Correct Solution:
```
from collections import defaultdict
from queue import deque
from sys import stdin, stdout
from math import log2
def arrinp():
return [*map(int, stdin.readline().split(' '))]
def mulinp():
return map(int, stdin.readline().split(' '))
def intinp():
return int(stdin.readline())
def solution():
n = intinp()
if n <= 3:
print(n)
return
if n % 3 == 1:
k = n.bit_length()-1
if k & 1:
k -= 1
print(2**k + (n-2**k) // 3)
elif n % 3 == 2:
n1 = n-1
k = n1.bit_length()-1
if k & 1:
k -= 1
ans1 = 2**k + (n1-2**k) // 3
ans = 0
cnt = 0
while ans1:
a = ans1 % 4
if a == 1:
a = 2
elif a == 2:
a = 3
elif a == 3:
a = 1
ans += a * (4**cnt)
cnt += 1
ans1 >>= 2
print(ans)
else:
n1 = n - 2
k = n1.bit_length()-1
if k & 1:
k -= 1
ans1 = 2 ** k + (n1 - 2 ** k) // 3
ans = 0
cnt = 0
while ans1:
a = ans1 % 4
if a == 1:
a = 3
elif a == 2:
a = 1
elif a == 3:
a = 2
ans += a * (4 ** cnt)
cnt += 1
ans1 >>= 2
print(ans)
testcases = 1
testcases = intinp()
for _ in range(testcases):
solution()
``` | output | 1 | 60,804 | 12 | 121,609 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Consider the infinite sequence s of positive integers, created by repeating the following steps:
1. Find the lexicographically smallest triple of positive integers (a, b, c) such that
* a ⊕ b ⊕ c = 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
* a, b, c are not in s.
Here triple of integers (a_1, b_1, c_1) is considered to be lexicographically smaller than triple (a_2, b_2, c_2) if sequence [a_1, b_1, c_1] is lexicographically smaller than sequence [a_2, b_2, c_2].
2. Append a, b, c to s in this order.
3. Go back to the first step.
You have integer n. Find the n-th element of s.
You have to answer t independent test cases.
A sequence a is lexicographically smaller than a sequence b if in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
Each of the next t lines contains a single integer n (1≤ n ≤ 10^{16}) — the position of the element you want to know.
Output
In each of the t lines, output the answer to the corresponding test case.
Example
Input
9
1
2
3
4
5
6
7
8
9
Output
1
2
3
4
8
12
5
10
15
Note
The first elements of s are 1, 2, 3, 4, 8, 12, 5, 10, 15, ... | instruction | 0 | 60,805 | 12 | 121,610 |
Tags: bitmasks, brute force, constructive algorithms, divide and conquer, math
Correct Solution:
```
# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------- fast io --------------------
from math import gcd, ceil
def prod(a, mod=10**9+7):
ans = 1
for each in a:
ans = (ans * each) % mod
return ans
def lcm(a, b): return a * b // gcd(a, b)
def binary(x, length=16):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
for _ in range(int(input()) if True else 1):
n = int(input())
# if n % 3 == 1:
# 1, 4-7, 16-31, 64-127, 256-511
def f1(x, pow=1):
if x > 4**pow:
return f1(x-4**pow, pow+1)
return 4**pow + (x - 1)
# if n % 3 == 2:
# 2, (8,10,11,9), (32->35,40->43,44->47,36->39)
# follow 1, 3, 4, 2 pattern
def f2(x, pow=1):
if x > 4**pow:
return f2(x-4**pow, pow+1)
alpha = 2*(4**pow)
# x is between 1 and 4^pow
while x > 4:
rem = (x-1) // (4**(pow-1))
alpha += 4**(pow-1)*[0, 2, 3, 1][rem]
x -= 4**(pow-1) * rem
pow -= 1
return alpha + [0,2,3,1][x-1]
# if n % 3 == 0:
# use previous two numbers to calculate
if n <= 3:
print(n)
continue
if n % 3 == 1:
n //= 3
print(f1(n))
elif n % 3 == 2:
n //= 3
print(f2(n))
elif n % 3 == 0:
n //= 3
n -= 1
print(f1(n)^f2(n))
``` | output | 1 | 60,805 | 12 | 121,611 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Consider the infinite sequence s of positive integers, created by repeating the following steps:
1. Find the lexicographically smallest triple of positive integers (a, b, c) such that
* a ⊕ b ⊕ c = 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
* a, b, c are not in s.
Here triple of integers (a_1, b_1, c_1) is considered to be lexicographically smaller than triple (a_2, b_2, c_2) if sequence [a_1, b_1, c_1] is lexicographically smaller than sequence [a_2, b_2, c_2].
2. Append a, b, c to s in this order.
3. Go back to the first step.
You have integer n. Find the n-th element of s.
You have to answer t independent test cases.
A sequence a is lexicographically smaller than a sequence b if in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
Each of the next t lines contains a single integer n (1≤ n ≤ 10^{16}) — the position of the element you want to know.
Output
In each of the t lines, output the answer to the corresponding test case.
Example
Input
9
1
2
3
4
5
6
7
8
9
Output
1
2
3
4
8
12
5
10
15
Note
The first elements of s are 1, 2, 3, 4, 8, 12, 5, 10, 15, ... | instruction | 0 | 60,806 | 12 | 121,612 |
Tags: bitmasks, brute force, constructive algorithms, divide and conquer, math
Correct Solution:
```
import sys
nums = [0,2,3,1]
def justSecond(fi):
if fi < 128:
j = partial.index(fi)
return partial[j+1]
prev = justSecond(fi//4)
return prev * 4 + nums[fi%4]
lines = sys.stdin.readlines()
f = int(lines[0].strip())
partial = [1, 2, 3, 4, 8, 12, 5, 10, 15, 6, 11, 13, 7, 9, 14, 16, 32, 48, 17, 34, 51, 18, 35, 49, 19, 33, 50, 20, 40, 60, 21, 42, 63, 22, 43, 61, 23, 41, 62, 24, 44, 52, 25, 46, 55, 26, 47, 53, 27, 45, 54, 28, 36, 56, 29, 38, 59, 30, 39, 57, 31, 37, 58, 64, 128, 192, 65, 130, 195, 66, 131, 193, 67, 129, 194, 68, 136, 204, 69, 138, 207, 70, 139, 205, 71, 137, 206, 72, 140, 196, 73, 142, 199, 74, 143, 197, 75, 141, 198, 76, 132, 200, 77, 134, 203, 78, 135, 201, 79, 133, 202, 80, 160, 240, 81, 162, 243, 82, 163, 241, 83, 161, 242, 84, 168, 252, 85, 170, 255, 86, 171, 253, 87, 169, 254, 88, 172, 244, 89, 174, 247, 90, 175, 245, 91, 173, 246, 92, 164, 248, 93, 166, 251, 94, 167, 249, 95, 165, 250, 96, 176, 208, 97, 178, 211, 98, 179, 209, 99, 177, 210, 100, 184, 220, 101, 186, 223, 102, 187, 221, 103, 185, 222, 104, 188, 212, 105, 190, 215, 106, 191, 213, 107, 189, 214, 108, 180, 216, 109, 182, 219, 110, 183, 217, 111, 181, 218, 112, 144, 224, 113, 146, 227, 114, 147, 225, 115, 145, 226, 116, 152, 236, 117, 154, 239, 118, 155, 237, 119, 153, 238, 120, 156, 228, 121, 158, 231, 122, 159, 229, 123, 157, 230, 124, 148, 232, 125, 150, 235, 126, 151, 233, 127, 149, 234, 256, 512, 768]
for t in range(f):
n = int(lines[t+1].strip())
if n <= 255:
print(partial[n-1]); continue
idx = n % 3
pow = (len(bin(n)[3:])//2)
lowPow4 = 4 ** pow
pirveli = lowPow4 + (n - lowPow4)//3
meore = justSecond(pirveli)
if idx == 1: print(pirveli)
elif idx == 2: print(meore)
else: print(pirveli ^ meore)
``` | output | 1 | 60,806 | 12 | 121,613 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Consider the infinite sequence s of positive integers, created by repeating the following steps:
1. Find the lexicographically smallest triple of positive integers (a, b, c) such that
* a ⊕ b ⊕ c = 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
* a, b, c are not in s.
Here triple of integers (a_1, b_1, c_1) is considered to be lexicographically smaller than triple (a_2, b_2, c_2) if sequence [a_1, b_1, c_1] is lexicographically smaller than sequence [a_2, b_2, c_2].
2. Append a, b, c to s in this order.
3. Go back to the first step.
You have integer n. Find the n-th element of s.
You have to answer t independent test cases.
A sequence a is lexicographically smaller than a sequence b if in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
Each of the next t lines contains a single integer n (1≤ n ≤ 10^{16}) — the position of the element you want to know.
Output
In each of the t lines, output the answer to the corresponding test case.
Example
Input
9
1
2
3
4
5
6
7
8
9
Output
1
2
3
4
8
12
5
10
15
Note
The first elements of s are 1, 2, 3, 4, 8, 12, 5, 10, 15, ... | instruction | 0 | 60,807 | 12 | 121,614 |
Tags: bitmasks, brute force, constructive algorithms, divide and conquer, math
Correct Solution:
```
# Closed = [False] * (10000)
# Closed[0] = True
# for i in range(100):
# a = Closed.index(False)
# Closed[a] = True
# for b in range(a+1, 10000):
# if Closed[b]:
# continue
# c = a ^ b
# if not Closed[c] and b < c:
# print(i, f"{a:b}, {b:b}, {c:b}")
# Closed[b] = Closed[c] = True
# break
# region fastio # from https://codeforces.com/contest/1333/submission/75948789
import sys, io, os
BUFSIZE = 8192
class FastIO(io.IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = io.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(io.IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
T = int(input())
for _ in range(T):
N = int(input())
i, m = divmod(N-1, 3)
s = 0
for d in range(100):
s += 4**d
if s > i:
s -= 4**d
break
#print(i, d, s)
a = 1<<d*2
l = i-s
a += l
b = 1 << d*2+1
for bit in range(0, 80, 2):
b |= [0,2,3,1][l>>bit&3]<<bit
c = a^b
print([a,b,c][m])
``` | output | 1 | 60,807 | 12 | 121,615 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Consider the infinite sequence s of positive integers, created by repeating the following steps:
1. Find the lexicographically smallest triple of positive integers (a, b, c) such that
* a ⊕ b ⊕ c = 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
* a, b, c are not in s.
Here triple of integers (a_1, b_1, c_1) is considered to be lexicographically smaller than triple (a_2, b_2, c_2) if sequence [a_1, b_1, c_1] is lexicographically smaller than sequence [a_2, b_2, c_2].
2. Append a, b, c to s in this order.
3. Go back to the first step.
You have integer n. Find the n-th element of s.
You have to answer t independent test cases.
A sequence a is lexicographically smaller than a sequence b if in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
Each of the next t lines contains a single integer n (1≤ n ≤ 10^{16}) — the position of the element you want to know.
Output
In each of the t lines, output the answer to the corresponding test case.
Example
Input
9
1
2
3
4
5
6
7
8
9
Output
1
2
3
4
8
12
5
10
15
Note
The first elements of s are 1, 2, 3, 4, 8, 12, 5, 10, 15, ... | instruction | 0 | 60,808 | 12 | 121,616 |
Tags: bitmasks, brute force, constructive algorithms, divide and conquer, math
Correct Solution:
```
mod = 1000000007
eps = 10**-9
def main():
import sys
input = sys.stdin.buffer.readline
for _ in range(int(input())):
N = int(input())
if N <= 3:
print(N)
continue
if N%3 == 1:
k = N.bit_length()-1
if k&1:
k -= 1
print(2**k + (N-2**k) // 3)
elif N%3 == 2:
N1 = N-1
k = N1.bit_length()-1
if k&1:
k -= 1
ans1 = 2**k + (N1-2**k) // 3
ans = 0
cnt = 0
while ans1:
a = ans1 % 4
if a == 1:
a = 2
elif a == 2:
a = 3
elif a == 3:
a = 1
ans += a * (4**cnt)
cnt += 1
ans1 >>= 2
print(ans)
else:
N1 = N - 2
k = N1.bit_length()-1
if k & 1:
k -= 1
ans1 = 2 ** k + (N1 - 2 ** k) // 3
ans = 0
cnt = 0
while ans1:
a = ans1 % 4
if a == 1:
a = 3
elif a == 2:
a = 1
elif a == 3:
a = 2
ans += a * (4 ** cnt)
cnt += 1
ans1 >>= 2
print(ans)
if __name__ == '__main__':
main()
``` | output | 1 | 60,808 | 12 | 121,617 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example. | instruction | 0 | 60,833 | 12 | 121,666 |
Tags: dp
Correct Solution:
```
"""
pppppppppppppppppppp
ppppp ppppppppppppppppppp
ppppppp ppppppppppppppppppppp
pppppppp pppppppppppppppppppppp
pppppppppppppppppppppppppppppppp
pppppppppppppppppppppppp
ppppppppppppppppppppppppppppppppppppppppppppppp pppppppppppppppppppp
pppppppppppppppppppppppppppppppppppppppppppppppp ppppppppppppppppppppp
ppppppppppppppppppppppppppppppppppppppppppppppppp pppppppppppppppppppppp
ppppppppppppppppppppppppppppppppppppppppppppppp pppppppppppppppppppppppp
pppppppppppppppppppppppppppppppppppppppppppppp pppppppppppppppppppppppppp
ppppppppppppppppppppppppppppppppppppppppppppp pppppppppppppppppppppppppppp
pppppppppppppppppppppppppppppppp pppppppppppppppppppppppppppppppp
pppppppppppppppppppppppppppp pppppppppppppppppppppppppppppppppppppppppppppp
ppppppppppppppppppppppppppp pppppppppppppppppppppppppppppppppppppppppppppppp
pppppppppppppppppppppppp pppppppppppppppppppppppppppppppppppppppppppppppppp
ppppppppppppppppppppppp ppppppppppppppppppppppppppppppppppppppppppppppppp
pppppppppppppppppppppp ppppppppppppppppppppppppppppppppppppppppppppppp
ppppppppppppppppppppp ppppppppppppppppppppppppppppppppppppppppppppp
pppppppppppppppppppppppp
pppppppppppppppppppppppppppppppp
pppppppppppppppppppppp pppppppp
ppppppppppppppppppppp ppppppp
ppppppppppppppppppp ppppp
pppppppppppppppppppp
"""
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush, nsmallest
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
from decimal import Decimal
# sys.setrecursionlimit(10 ** 6)
# sys.stdin = open("input.txt", "r")
# sys.stdout = open("output.txt", "w")
mod = pow(10, 9) + 7
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(var, end="\n"): sys.stdout.write(str(var)+"\n")
def outa(*var, end="\n"): sys.stdout.write(' '.join(map(str, var)) + end)
def l(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]
def isSubsetSum(a, length, s):
subset = ([[False for i in range(s + 1)] for i in range(length + 1)])
for i in range(length + 1):
subset[i][0] = True
for i in range(1, s + 1):
subset[0][i] = False
for i in range(1, length + 1):
for j in range(1, s + 1):
if j < a[i - 1]:
subset[i][j] = subset[i - 1][j]
if j >= a[i - 1]:
subset[i][j] = (subset[i - 1][j] or subset[i - 1][j - a[i - 1]])
return subset[length][s]
for _ in range(int(data())):
n = int(data())
arr = l()
new = []
cnt = 1
high = arr[0]
for i in range(1, 2 * n):
if arr[i] > high:
new.append(cnt)
cnt = 1
high = arr[i]
continue
cnt += 1
new.append(cnt)
out(("YES", "NO")[not isSubsetSum(new, len(new), n)])
``` | output | 1 | 60,833 | 12 | 121,667 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example. | instruction | 0 | 60,834 | 12 | 121,668 |
Tags: dp
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
b=[a[0]]
c=[1]
for i in range(1,2*n):
if a[i]>b[-1]:
b.append(a[i])
c.append(1)
else:
c[-1]+=1
m=len(c)
dp=[[0 for _ in range(n+1)] for _ in range(m+1)]
dp[0][0]=1
for i in range(1,m+1):
dp[i][0]=1
for i in range(1,m+1):
for j in range(1,n+1):
if j>=c[i-1]:
dp[i][j]=dp[i-1][j] or dp[i-1][j-c[i-1]]
else:
dp[i][j]=dp[i-1][j]
if dp[m][n]:
print("YES")
else:
print("NO")
``` | output | 1 | 60,834 | 12 | 121,669 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example. | instruction | 0 | 60,835 | 12 | 121,670 |
Tags: dp
Correct Solution:
```
t = int(input())
for tt in range(0, t):
n = int(input())
p = map(int, input().split())
blocks = []
mx = -1
block = 0
for x in p:
if x > mx:
if block > 0:
blocks.append(block)
block = 0
mx = x
block += 1
if block > 0:
blocks.append(block)
can = [0] * (n + 1)
can[0] = 1
for x in blocks:
if n - x >= 0:
for i in range(n - x, -1, -1):
if can[i]:
can[i + x] = 1
if can[n] == 1:
print("YES")
else:
print("NO")
``` | output | 1 | 60,835 | 12 | 121,671 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example. | instruction | 0 | 60,836 | 12 | 121,672 |
Tags: dp
Correct Solution:
```
t = int(input())
for _ in range(t):
n, p = int(input()), list(map(int, input().split()))
v, w = [], []
i, k = 0, 0
while i < 2*n:
j = i + 1
while j < 2 * n and p[j] < p[i]:
j += 1
v.append(j - i)
w.append(j - i)
k += 1
i = j
#print(v)
dp = [[0] * (n + 1) for _ in range(k+1)]
for i in range(1, k+1):
for j in range(1, n+1):
dp[i][j] = dp[i-1][j]
if j >= w[i-1]:
dp[i][j] = max(dp[i][j], dp[i-1][j-w[i-1]] + v[i-1])
if dp[k][n] == n:
print("YES")
else:
print("NO")
``` | output | 1 | 60,836 | 12 | 121,673 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example. | instruction | 0 | 60,837 | 12 | 121,674 |
Tags: dp
Correct Solution:
```
######################################################
############Created by Devesh Kumar###################
#############devesh1102@gmail.com####################
##########For CodeForces(Devesh1102)#################
#####################2020#############################
######################################################
import sys
input = sys.stdin.readline
# import sys
import heapq
import copy
import math
import decimal
# import sys.stdout.flush as flush
# from decimal import *
#heapq.heapify(li)
#
#heapq.heappush(li,4)
#
#heapq.heappop(li)
#
# & Bitwise AND Operator 10 & 7 = 2
# | Bitwise OR Operator 10 | 7 = 15
# ^ Bitwise XOR Operator 10 ^ 7 = 13
# << Bitwise Left Shift operator 10<<2 = 40
# >> Bitwise Right Shift Operator
# '''############ ---- Input Functions ---- #######Start#####'''
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def insr2():
s = input()
return((s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
############ ---- Input Functions ---- #######End
# #####
def pr_list(a):
print(*a, sep=" ")
def main():
tests = inp()
# tests = 1
mod = 1000000007
limit = 10**18
ans = 0
stack = []
hashm = {}
arr = []
heapq.heapify(arr)
for test in range(tests):
n = inp()
a= inlt()
pair = []
i = 0
while(i<2*n):
curr = 1
val = a[i]
i = i +1
while(i<2*n and a[i] < val):
curr = curr +1
i = i +1
pair.append(curr)
# print(pair)
dp = [0 for i in range(2*n+1)]
dp[0] =1
for i in pair:
# print(dp)
curr = copy.deepcopy(dp)
for j in range(2*n):
if i+j <= 2*n and dp[j] == 1:
curr[i+j] = 1
dp = curr
if dp[n] == 1:
print("Yes")
else:
print("No")
if __name__== "__main__":
main()
``` | output | 1 | 60,837 | 12 | 121,675 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example. | instruction | 0 | 60,838 | 12 | 121,676 |
Tags: dp
Correct Solution:
```
tests = int(input())
for t in range(tests):
n = int(input())
ls = list(map(int, input().split()))
curr = ls[0]
groups = []
group_len = 1
for item in ls[1:]:
if curr > item:
group_len += 1
else:
groups.append(group_len)
group_len = 1
curr = item
groups.append(group_len)
group_len = len(groups)
dp = [None for i in range(group_len)]
if groups[0] < n:
dp[0] = [0, groups[0]]
else:
dp[0] = [0]
for i in range(1,group_len):
curr = groups[i]
previous_ls = dp[i-1]
new = set(previous_ls)
for prev in previous_ls:
if prev + curr <= n:
new.add(prev+curr)
dp[i] = list(new)
check=False
for item in dp[group_len-1]:
if item == n:
print('YES')
check=True
break
if not check:
print('NO')
``` | output | 1 | 60,838 | 12 | 121,677 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example. | instruction | 0 | 60,839 | 12 | 121,678 |
Tags: dp
Correct Solution:
```
import sys
input = lambda: sys.stdin.readline().rstrip('\n\r')
for _ in range(int(input())):
n = int(input())
P = list(map(int, input().split()))
pos = {v: i for i, v in enumerate(P)}
prev = 2*n
maxx = list(P)
for i in range(1, 2*n):
maxx[i] = max(maxx[i-1], P[i])
lens = []
for i in range(2*n-1, -1, -1):
if P[i] == maxx[i]:
lens.append(prev-i)
prev = i
DP = [False] * (n+1)
DP[0] = True
for l in lens:
for i in range(n-l, -1, -1):
if DP[i]: DP[i+l] = True
print('YES' if DP[n] else 'NO')
``` | output | 1 | 60,839 | 12 | 121,679 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example. | instruction | 0 | 60,840 | 12 | 121,680 |
Tags: dp
Correct Solution:
```
def dp(arr,n):
sub = [[False for i in range(n+1)] for i in range(len(arr)+1)]
for i in range(len(arr)+1):
sub[i][0] = True
for i in range(1,len(arr)+1):
for j in range(1,n+1):
if (j<arr[i-1]):
sub[i][j] = sub[i-1][j]
else:
sub[i][j] = (sub[i-1][j] or sub[i-1][j-arr[i-1]])
return sub[len(arr)][n]
def func(n,arr):
s = set()
l = n*2
end = n*2
sub = []
for i in range(2*n-1,-1,-1):
if (arr[i] == l):
sub.append(end-i)
end = i
l-=1
while(True):
if l not in s:
break
l-=1
else:
s.add(arr[i])
#print(sub)
return dp(sub,n)
for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
if (func(n,arr)):
print("YES")
else:
print("NO")
``` | output | 1 | 60,840 | 12 | 121,681 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example.
Submitted Solution:
```
from sys import stdin
def subset_sum(A, n):
DP = [[True]*(n+1) for _ in range(len(A)+1)]
for i in range(1, n+1):
DP[0][i] = False
for i in range(1, len(A)+1):
for j in range(1, n+1):
if A[i-1] > j:
DP[i][j] = DP[i-1][j]
else:
DP[i][j] = DP[i-1][j] or DP[i-1][j-A[i-1]]
return DP[-1][-1]
t = int(stdin.readline().strip())
for _ in range(t):
n = int(stdin.readline().strip())
P = list(map(int, stdin.readline().strip().split(' ')))
maximum = P[0]
count = 1
A = []
for i in range(1, 2*n):
if P[i] > maximum:
A.append(count)
count = 1
maximum = P[i]
else:
count += 1
if count != 0:
A.append(count)
print("YES" if subset_sum(A, n) else "NO")
``` | instruction | 0 | 60,841 | 12 | 121,682 |
Yes | output | 1 | 60,841 | 12 | 121,683 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example.
Submitted Solution:
```
q = int(input())
for _ in range(q):
n = int(input())
dat = list(map(int, input().split()))
buf = []
prev = dat[0]
cnt = 1
for i in range(1,n*2):
#print(" > ", i, dat[i])
if prev > dat[i]:
cnt += 1
else:
buf.append(cnt)
cnt = 1
prev = dat[i]
buf.append(cnt)
#print(dat)
#print(buf)
dp = [None] * 20100
for i in range(len(buf)):
for j in range(2005, -1, -1):
if dp[j] is None:
continue
dp[j + buf[i]] = True
dp[buf[i]] = True
#print(dp[:20])
if dp[n] is True:
print("YES")
else:
print("NO")
``` | instruction | 0 | 60,842 | 12 | 121,684 |
Yes | output | 1 | 60,842 | 12 | 121,685 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example.
Submitted Solution:
```
import math
from sys import stdin,stdout
def isSubsetSum(set, n, sum):
subset =([[False for i in range(sum + 1)]
for i in range(n + 1)])
for i in range(n + 1):
subset[i][0] = True
for i in range(1, sum + 1):
subset[0][i]= False
for i in range(1, n + 1):
for j in range(1, sum + 1):
if j<set[i-1]:
subset[i][j] = subset[i-1][j]
if j>= set[i-1]:
subset[i][j] = (subset[i-1][j] or
subset[i - 1][j-set[i-1]])
return subset[n][sum]
for _ in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
ans=[]
j=1
c=1
i=0
while i<2*n and j<2*n:
if l[i]>l[j]:
j+=1
c+=1
else:
ans.append(c)
c=1
i=j
j+=1
ans.append(j-i)
if (isSubsetSum(ans,len(ans),n) == True):
print("YES")
else:
print("NO")
``` | instruction | 0 | 60,843 | 12 | 121,686 |
Yes | output | 1 | 60,843 | 12 | 121,687 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example.
Submitted Solution:
```
t=int(input())
while(t>0):
t-=1
n=int(input())
p=list(map(int, input().split()))
l=[]
j=0
for i in range(1, 2*n):
if j==i or p[j] > p[i]:
if i!=2*n-1:
continue
else:
l.append(i-j)
j=i
if i==2*n-1:
l.append(2*n-j)
m=[0]*n
ln=len(l)
for i in range(ln):
for j in range(n-1, -1, -1):
if j+l[i]+1<=n and m[j]:
m[j+l[i]]=1
if l[i]<=n:
m[l[i]-1]=1
if m[-1]==1:
print("YES")
else:
print("NO")
``` | instruction | 0 | 60,844 | 12 | 121,688 |
Yes | output | 1 | 60,844 | 12 | 121,689 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example.
Submitted Solution:
```
import sys
inputlist=sys.stdin.readlines()
number_of_testcases=int(inputlist[0].strip())
for i in range(number_of_testcases):
winnerlist=["First","Second"]
n=int(inputlist[2*i+1].strip())
numberslist=list(map(int,inputlist[2*i+2].strip().split(' ')))
max_now=numberslist[0]
decreasing_numbers=1
decreasing_numbers_list=[]
extra_elements=0
for i in range(1,2*n):
if(numberslist[i]>max_now):
max_now=numberslist[i]
'''
if(decreasing_numbers!=1):
#print(decreasing_numbers)
decreasing_numbers_list.append(decreasing_numbers)
else:
extra_elements+=1
'''
decreasing_numbers_list.append(decreasing_numbers)
decreasing_numbers=1
else:
decreasing_numbers+=1
'''
if(decreasing_numbers!=1):
decreasing_numbers_list.append(decreasing_numbers)
else:
extra_elements+=1
'''
decreasing_numbers_list.append(decreasing_numbers)
decreasing_numbers_list.sort(reverse=True)
#print(decreasing_numbers_list)
elements1=0
elements2=0
for i in decreasing_numbers_list:
if(elements1<=elements2):
elements1+=i
else:
elements2+=i
#print(elements1,elements2)
#print(abs(elements1-elements2))
#print(extra_elements)
if(elements1==elements2):
print('YES')
else:
print('NO')
``` | instruction | 0 | 60,845 | 12 | 121,690 |
No | output | 1 | 60,845 | 12 | 121,691 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example.
Submitted Solution:
```
'''Author- Akshit Monga'''
def isSubsetSum(set, n, sum):
# Base Cases
if (sum == 0):
return True
if (n == 0 and sum != 0):
return False
# If last element is greater than
# sum, then ignore it
if (set[n - 1] > sum):
return isSubsetSum(set, n - 1, sum);
# else, check if sum can be obtained
# by any of the following
# (a) including the last element
# (b) excluding the last element
return isSubsetSum(
set, n - 1, sum) or isSubsetSum(
set, n - 1, sum - set[n - 1])
import sys
# input=sys.stdin.readline
t = int(input())
for _ in range(t):
n=int(input())
arr=[int(x) for x in input().split()]
counter=2*n
subsets=[]
count=0
temp=[]
for i in arr[::-1]:
if i==counter:
temp.append(i)
counter-=1
# counter=min(temp)-1
temp=[]
subsets.append(count+1)
count=0
else:
temp.append(i)
count+=1
if count:
subsets.append(count)
if isSubsetSum(subsets,len(subsets),n):
print("YES")
else:
print("NO")
``` | instruction | 0 | 60,846 | 12 | 121,692 |
No | output | 1 | 60,846 | 12 | 121,693 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example.
Submitted Solution:
```
from math import *
from collections import *
from random import *
from bisect import *
import sys
input=sys.stdin.readline
d={'1':'0','0':'1'}
def isSub(set, n, sum):
subset =([[False for i in range(sum + 1)]
for i in range(n + 1)])
for i in range(n + 1):
subset[i][0] = True
for i in range(1, sum + 1):
subset[0][i]= False
for i in range(1, n + 1):
for j in range(1, sum + 1):
if j<set[i-1]:
subset[i][j] = subset[i-1][j]
if j>= set[i-1]:
subset[i][j] = (subset[i-1][j] or
subset[i - 1][j-set[i-1]])
return subset[n][sum]
t=int(input())
while(t):
t-=1
n=int(input())
a=list(map(int,input().split()))
r=[]
c=0
ref=2*n
for i in range(2*n-1,-1,-1):
if(a[i]==ref):
c+=1
r.append(c)
c=0
ref-=1
else:
c+=1
if(c):
r.append(c)
if(isSub(r,len(r),n)==True):
print("YES")
else:
print("NO")
``` | instruction | 0 | 60,847 | 12 | 121,694 |
No | output | 1 | 60,847 | 12 | 121,695 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example.
Submitted Solution:
```
def max_element(arr, l, r):
el = arr[l]
ans = l
for i in range(l, r + 1):
if(arr[i] > el):
el = arr[i]
ans = i
return ans
def max_inds(arr, l, r):
if l >= r: return [l]
else:
cur = max_element(arr, l, r)
if cur == l: return [cur]
else: return [cur] + max_inds(arr, l, cur - 1)
t = int(input())
for i in range(t):
n = int(input())
arr = [int(x) for x in input().split()]
dl = []
r = len(arr) - 1
for j in max_inds(arr, 0, r):
dl.append(r - j + 1)
r = j - 1
ans = 1
groupSize = 10
x = 10**groupSize
for j in dl:
ans *= (1 + x**j)
for j in range(0, n):
ans //= x
if ans % x: print("YES")
else: print("NO")
``` | instruction | 0 | 60,848 | 12 | 121,696 |
No | output | 1 | 60,848 | 12 | 121,697 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a_1, a_2, ..., a_n where all a_i are integers and greater than 0.
In one operation, you can choose two different indices i and j (1 ≤ i, j ≤ n). If gcd(a_i, a_j) is equal to the minimum element of the whole array a, you can swap a_i and a_j. gcd(x, y) denotes the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers x and y.
Now you'd like to make a non-decreasing using the operation any number of times (possibly zero). Determine if you can do this.
An array a is non-decreasing if and only if a_1 ≤ a_2 ≤ … ≤ a_n.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^5) — the length of array a.
The second line of each test case contains n positive integers a_1, a_2, … a_n (1 ≤ a_i ≤ 10^9) — the array itself.
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
For each test case, output "YES" if it is possible to make the array a non-decreasing using the described operation, or "NO" if it is impossible to do so.
Example
Input
4
1
8
6
4 3 6 6 2 9
4
4 5 6 7
5
7 5 2 2 4
Output
YES
YES
YES
NO
Note
In the first and third sample, the array is already non-decreasing.
In the second sample, we can swap a_1 and a_3 first, and swap a_1 and a_5 second to make the array non-decreasing.
In the forth sample, we cannot the array non-decreasing using the operation. | instruction | 0 | 60,849 | 12 | 121,698 |
Tags: constructive algorithms, math, number theory, sortings
Correct Solution:
```
for _ in range(int(input())):
a=int(input());b=list(map(int,input().split()));c=sorted(b);z="YES";k=c[0]
for i in range(a):
if b[i]!=c[i]:
if b[i]%k!=0 or c[i]%k!=0:z="NO";break
print(z)
``` | output | 1 | 60,849 | 12 | 121,699 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.