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.
Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. We'll denote the i-th element of permutation p as pi. We'll call number n the size or the length of permutation p1, p2, ..., pn.
You have a sequence of integers a1, a2, ..., an. In one move, you are allowed to decrease or increase any number by one. Count the minimum number of moves, needed to build a permutation from this sequence.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the size of the sought permutation. The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print a single number — the minimum number of moves.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
2
3 0
Output
2
Input
3
-1 -1 2
Output
6
Note
In the first sample you should decrease the first number by one and then increase the second number by one. The resulting permutation is (2, 1).
In the second sample you need 6 moves to build permutation (1, 3, 2). | instruction | 0 | 54,255 | 12 | 108,510 |
Tags: greedy, implementation, sortings
Correct Solution:
```
# SOLVED
# solving: https://vjudge.net/contest/421568#problem/E
# from:
def main2():
n = int(input())
p_list = list(map(int, input().split(" ")))
running_total = 0
p_list.sort()
for i in range(0, n):
running_total += abs(i+1 - p_list[i])
print(running_total)
main2()
``` | output | 1 | 54,255 | 12 | 108,511 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. We'll denote the i-th element of permutation p as pi. We'll call number n the size or the length of permutation p1, p2, ..., pn.
You have a sequence of integers a1, a2, ..., an. In one move, you are allowed to decrease or increase any number by one. Count the minimum number of moves, needed to build a permutation from this sequence.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the size of the sought permutation. The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print a single number — the minimum number of moves.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
2
3 0
Output
2
Input
3
-1 -1 2
Output
6
Note
In the first sample you should decrease the first number by one and then increase the second number by one. The resulting permutation is (2, 1).
In the second sample you need 6 moves to build permutation (1, 3, 2).
Submitted Solution:
```
#!/usr/bin/env python3
from sys import stdin, stdout
def solve():
n = int(stdin.readline().strip())
li = list(map(int, stdin.readline().split()))
li.sort()
lo = [i for i in range(1, n + 1)]
res = 0
for i in range(n):
res += abs(lo[i] - li[i])
print(res)
LOCAL_TEST = not __debug__
if LOCAL_TEST:
infile = __file__.split('.')[0] + '-test.in'
stdin = open(infile, 'r')
tcs = (int(stdin.readline().strip()) if LOCAL_TEST else 1)
t = 1
while t <= tcs:
solve()
t += 1
``` | instruction | 0 | 54,256 | 12 | 108,512 |
Yes | output | 1 | 54,256 | 12 | 108,513 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. We'll denote the i-th element of permutation p as pi. We'll call number n the size or the length of permutation p1, p2, ..., pn.
You have a sequence of integers a1, a2, ..., an. In one move, you are allowed to decrease or increase any number by one. Count the minimum number of moves, needed to build a permutation from this sequence.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the size of the sought permutation. The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print a single number — the minimum number of moves.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
2
3 0
Output
2
Input
3
-1 -1 2
Output
6
Note
In the first sample you should decrease the first number by one and then increase the second number by one. The resulting permutation is (2, 1).
In the second sample you need 6 moves to build permutation (1, 3, 2).
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
l.sort()
ans=0
for i in range(1,n+1):
ans+=abs(l[i-1]-i)
print(ans)
``` | instruction | 0 | 54,257 | 12 | 108,514 |
Yes | output | 1 | 54,257 | 12 | 108,515 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. We'll denote the i-th element of permutation p as pi. We'll call number n the size or the length of permutation p1, p2, ..., pn.
You have a sequence of integers a1, a2, ..., an. In one move, you are allowed to decrease or increase any number by one. Count the minimum number of moves, needed to build a permutation from this sequence.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the size of the sought permutation. The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print a single number — the minimum number of moves.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
2
3 0
Output
2
Input
3
-1 -1 2
Output
6
Note
In the first sample you should decrease the first number by one and then increase the second number by one. The resulting permutation is (2, 1).
In the second sample you need 6 moves to build permutation (1, 3, 2).
Submitted Solution:
```
n=int(input())
a=list(map(int, input().strip().split()))
a.sort()
l=1
p=0
for i in range(0,n):
d=l-a[i]
if d<0:
d=d*-1
p=p+d
l+=1
print(p)
``` | instruction | 0 | 54,258 | 12 | 108,516 |
Yes | output | 1 | 54,258 | 12 | 108,517 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. We'll denote the i-th element of permutation p as pi. We'll call number n the size or the length of permutation p1, p2, ..., pn.
You have a sequence of integers a1, a2, ..., an. In one move, you are allowed to decrease or increase any number by one. Count the minimum number of moves, needed to build a permutation from this sequence.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the size of the sought permutation. The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print a single number — the minimum number of moves.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
2
3 0
Output
2
Input
3
-1 -1 2
Output
6
Note
In the first sample you should decrease the first number by one and then increase the second number by one. The resulting permutation is (2, 1).
In the second sample you need 6 moves to build permutation (1, 3, 2).
Submitted Solution:
```
n=int(input())
print(sum(abs(x-y) for x,y in enumerate(sorted(map(int,input().split())),1)))
``` | instruction | 0 | 54,259 | 12 | 108,518 |
Yes | output | 1 | 54,259 | 12 | 108,519 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. We'll denote the i-th element of permutation p as pi. We'll call number n the size or the length of permutation p1, p2, ..., pn.
You have a sequence of integers a1, a2, ..., an. In one move, you are allowed to decrease or increase any number by one. Count the minimum number of moves, needed to build a permutation from this sequence.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the size of the sought permutation. The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print a single number — the minimum number of moves.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
2
3 0
Output
2
Input
3
-1 -1 2
Output
6
Note
In the first sample you should decrease the first number by one and then increase the second number by one. The resulting permutation is (2, 1).
In the second sample you need 6 moves to build permutation (1, 3, 2).
Submitted Solution:
```
import sys
my_file = sys.stdin
#my_file = open("input.txt", "r")
n = int(my_file.readline())
a = [int(i) for i in my_file.readline().strip().split()]
a.sort()
turns = 0
for i in range(n):
while a[i] < 1:
a[i] += 1
turns += 1
while a[i] >= n-1:
a[i] -= 1
turns += 1
a.sort()
# k = []
# for i in range(1,len(a)+1):
# if i not in a:
# k.append(i)
# print(k)
for i in range(n):
while a.count(a[i]) > 1:
a[i] += 1
turns += 1
print(turns)
``` | instruction | 0 | 54,260 | 12 | 108,520 |
No | output | 1 | 54,260 | 12 | 108,521 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. We'll denote the i-th element of permutation p as pi. We'll call number n the size or the length of permutation p1, p2, ..., pn.
You have a sequence of integers a1, a2, ..., an. In one move, you are allowed to decrease or increase any number by one. Count the minimum number of moves, needed to build a permutation from this sequence.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the size of the sought permutation. The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print a single number — the minimum number of moves.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
2
3 0
Output
2
Input
3
-1 -1 2
Output
6
Note
In the first sample you should decrease the first number by one and then increase the second number by one. The resulting permutation is (2, 1).
In the second sample you need 6 moves to build permutation (1, 3, 2).
Submitted Solution:
```
n = int(input())
w = list(map(int,input().split()))
mov = 0
ans = []
for i in range(n):
if(w[i] > n):
mov += abs(w[i] - n)
ans.append(n)
elif(w[i] <= 0 ):
mov += abs(1 - w[i])
ans.append(1)
else:
ans.append(w[i])
#print(ans)
ans.sort()
for k in range(1,n):
if(ans[k] <= ans[k-1]):
tem = ans[k]
ans[k] = ans[k-1] + 1
mov += abs(tem - (ans[k-1] + 1 ))
print(mov)
``` | instruction | 0 | 54,261 | 12 | 108,522 |
No | output | 1 | 54,261 | 12 | 108,523 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. We'll denote the i-th element of permutation p as pi. We'll call number n the size or the length of permutation p1, p2, ..., pn.
You have a sequence of integers a1, a2, ..., an. In one move, you are allowed to decrease or increase any number by one. Count the minimum number of moves, needed to build a permutation from this sequence.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the size of the sought permutation. The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print a single number — the minimum number of moves.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
2
3 0
Output
2
Input
3
-1 -1 2
Output
6
Note
In the first sample you should decrease the first number by one and then increase the second number by one. The resulting permutation is (2, 1).
In the second sample you need 6 moves to build permutation (1, 3, 2).
Submitted Solution:
```
def mincheck(i,d,min1,max1,c):
for j in range(min1,max1+1):
if j not in d:
c = abs(j-i)
d[j] = 1
return c,j+1
def maxcheck(i,d,min1,max1,c):
for j in range(max1,min1-1,-1):
if j not in d:
c =abs(j-i)
d[j] = 1
return c,j+1
def check(i,d,min1,max1,c):
x , y = i-1,i+1
while x >= min1 or y <= max1:
if x >=min1 and x not in d:
d[x] = 1
return abs(i-x)
if y<=max1 and y not in d:
d[y] = 1
return abs(y-i)
x -= 1
y += 1
#from collections import Counter
#from collections import defaultdict
#import math
n = int(input())
#n,m = map(int,input().split())
l = list(map(int,input().split()))
#t = list(map(int,input().split()))
l.sort()
d = {}
min1 = 1 ; max1 = n
c = 0
for i in l:
#print("i",i)
if i <= 0:
t,min1 = mincheck(i,d,min1,max1,c)
c += t
#print("first",t)
elif i > n:
t,max1 = maxcheck(i,d,min1,max1,c)
c += t
#print("second",t)
elif i in d:
t = check(i,d,min1,max1,c)
c += t
#print("third",t)
else:
d[i] = 1
#print(d)
print(c)
``` | instruction | 0 | 54,262 | 12 | 108,524 |
No | output | 1 | 54,262 | 12 | 108,525 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. We'll denote the i-th element of permutation p as pi. We'll call number n the size or the length of permutation p1, p2, ..., pn.
You have a sequence of integers a1, a2, ..., an. In one move, you are allowed to decrease or increase any number by one. Count the minimum number of moves, needed to build a permutation from this sequence.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the size of the sought permutation. The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print a single number — the minimum number of moves.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
2
3 0
Output
2
Input
3
-1 -1 2
Output
6
Note
In the first sample you should decrease the first number by one and then increase the second number by one. The resulting permutation is (2, 1).
In the second sample you need 6 moves to build permutation (1, 3, 2).
Submitted Solution:
```
import sys
limit = int(sys.stdin.readline())
arr = sorted(list(map(int, sys.stdin.readline().split())))
cnt = 0
if arr[0] <= 0:
cnt += (abs(arr[0]) + 1)
arr[0] = 1
for x in range(1, limit):
if arr[x] <= 0:
cnt += (abs(arr[x]) + 1)
arr[x] = abs(arr[x])
elif arr[x] > limit:
cnt += (arr[x] - limit)
arr[x] = limit
if arr[x] == arr[x - 1]:
arr[x] += 1
cnt += 1
sys.stdout.write(str(cnt))
``` | instruction | 0 | 54,263 | 12 | 108,526 |
No | output | 1 | 54,263 | 12 | 108,527 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence A, where its elements are either in the form + x or -, where x is an integer.
For such a sequence S where its elements are either in the form + x or -, define f(S) as follows:
* iterate through S's elements from the first one to the last one, and maintain a multiset T as you iterate through it.
* for each element, if it's in the form + x, add x to T; otherwise, erase the smallest element from T (if T is empty, do nothing).
* after iterating through all S's elements, compute the sum of all elements in T. f(S) is defined as the sum.
The sequence b is a subsequence of the sequence a if b can be derived from a by removing zero or more elements without changing the order of the remaining elements. For all A's subsequences B, compute the sum of f(B), modulo 998 244 353.
Input
The first line contains an integer n (1≤ n≤ 500) — the length of A.
Each of the next n lines begins with an operator + or -. If the operator is +, then it's followed by an integer x (1≤ x<998 244 353). The i-th line of those n lines describes the i-th element in A.
Output
Print one integer, which is the answer to the problem, modulo 998 244 353.
Examples
Input
4
-
+ 1
+ 2
-
Output
16
Input
15
+ 2432543
-
+ 4567886
+ 65638788
-
+ 578943
-
-
+ 62356680
-
+ 711111
-
+ 998244352
-
-
Output
750759115
Note
In the first example, the following are all possible pairs of B and f(B):
* B= {}, f(B)=0.
* B= {-}, f(B)=0.
* B= {+ 1, -}, f(B)=0.
* B= {-, + 1, -}, f(B)=0.
* B= {+ 2, -}, f(B)=0.
* B= {-, + 2, -}, f(B)=0.
* B= {-}, f(B)=0.
* B= {-, -}, f(B)=0.
* B= {+ 1, + 2}, f(B)=3.
* B= {+ 1, + 2, -}, f(B)=2.
* B= {-, + 1, + 2}, f(B)=3.
* B= {-, + 1, + 2, -}, f(B)=2.
* B= {-, + 1}, f(B)=1.
* B= {+ 1}, f(B)=1.
* B= {-, + 2}, f(B)=2.
* B= {+ 2}, f(B)=2.
The sum of these values is 16. | instruction | 0 | 55,029 | 12 | 110,058 |
Tags: combinatorics, dp, implementation, math, ternary search
Correct Solution:
```
#!/usr/bin/env python3
# from typing import *
import sys
import io
import math
import collections
import decimal
import itertools
import bisect
import heapq
def input():
return sys.stdin.readline()[:-1]
# sys.setrecursionlimit(1000000)
# _INPUT = """4
# + 100
# -
# + 100
# -
# """
# sys.stdin = io.StringIO(_INPUT)
def solve1(N, S):
score = 0
for s in range(1<<N):
hq = []
for i in range(N):
if s & (1<<i):
if S[i][0] == '+':
heapq.heappush(hq, int(S[i][1]))
else:
if hq:
heapq.heappop(hq)
if hq:
score = (score + sum(hq)) % MOD
return score
def solve2(N, S):
M = 0
for s in S:
if s[0] == '+':
M += 1
score = 0
for i in range(N):
if S[i][0] == '+':
x = int(S[i][1])
dp = [0] * M
dp[0] = 1
scale = 1
for j in range(N):
dp1 = [0] * M
if j == i:
for sm in range(M):
dp1[sm] = dp[sm]
elif S[j][0] == '+':
y = int(S[j][1])
if y > x or (y == x and j < i):
dp1 = dp
scale *= 2
else:
for sm in range(M):
dp1[sm] += dp[sm]
if sm+1 < M:
dp1[sm+1] += dp[sm]
else:
for sm in range(M):
dp1[sm] += dp[sm]
if 0 <= sm-1:
dp1[sm-1] += dp[sm]
if j < i and sm == 0:
dp1[sm] += dp[sm]
dp = dp1
n = sum(dp) * scale
score = (score + n * x) % MOD
return score
MOD = 998244353
N = int(input())
S = [input().split() for _ in range(N)]
print(solve2(N, S))
``` | output | 1 | 55,029 | 12 | 110,059 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence A, where its elements are either in the form + x or -, where x is an integer.
For such a sequence S where its elements are either in the form + x or -, define f(S) as follows:
* iterate through S's elements from the first one to the last one, and maintain a multiset T as you iterate through it.
* for each element, if it's in the form + x, add x to T; otherwise, erase the smallest element from T (if T is empty, do nothing).
* after iterating through all S's elements, compute the sum of all elements in T. f(S) is defined as the sum.
The sequence b is a subsequence of the sequence a if b can be derived from a by removing zero or more elements without changing the order of the remaining elements. For all A's subsequences B, compute the sum of f(B), modulo 998 244 353.
Input
The first line contains an integer n (1≤ n≤ 500) — the length of A.
Each of the next n lines begins with an operator + or -. If the operator is +, then it's followed by an integer x (1≤ x<998 244 353). The i-th line of those n lines describes the i-th element in A.
Output
Print one integer, which is the answer to the problem, modulo 998 244 353.
Examples
Input
4
-
+ 1
+ 2
-
Output
16
Input
15
+ 2432543
-
+ 4567886
+ 65638788
-
+ 578943
-
-
+ 62356680
-
+ 711111
-
+ 998244352
-
-
Output
750759115
Note
In the first example, the following are all possible pairs of B and f(B):
* B= {}, f(B)=0.
* B= {-}, f(B)=0.
* B= {+ 1, -}, f(B)=0.
* B= {-, + 1, -}, f(B)=0.
* B= {+ 2, -}, f(B)=0.
* B= {-, + 2, -}, f(B)=0.
* B= {-}, f(B)=0.
* B= {-, -}, f(B)=0.
* B= {+ 1, + 2}, f(B)=3.
* B= {+ 1, + 2, -}, f(B)=2.
* B= {-, + 1, + 2}, f(B)=3.
* B= {-, + 1, + 2, -}, f(B)=2.
* B= {-, + 1}, f(B)=1.
* B= {+ 1}, f(B)=1.
* B= {-, + 2}, f(B)=2.
* B= {+ 2}, f(B)=2.
The sum of these values is 16. | instruction | 0 | 55,030 | 12 | 110,060 |
Tags: combinatorics, dp, implementation, math, ternary search
Correct Solution:
```
mod=998244353
n=(int)(input())
a=[0 for i in range(n+1)]
for i in range(1,n+1):
m=input().split()
if m[0]=="+":
a[i]=(int)(m[1])
ans=0
for t in range(1,n+1):
if a[t]==0:
continue
f=[[0 for i in range(n+2)] for j in range(n+2)]
f[0][0]=1
for i in range(1,n+1):
for j in range(0,i+1):
if a[i]==0:
if ((i<=t) or (j>0)):
f[i][max(j-1,0)]=(f[i][max(j-1,0)]+f[i-1][j])%mod
else :
if ((a[i]<a[t]) or ((a[i]==a[t]) and (i<t))):
f[i][j+1]=(f[i][j+1]+f[i-1][j])%mod
else :
f[i][j]=(f[i][j]+f[i-1][j])%mod
if (i!=t) :
f[i][j]=(f[i][j]+f[i-1][j])%mod
for i in range(0,n+1):
ans=(ans+f[n][i]*a[t])%mod
print(ans)
``` | output | 1 | 55,030 | 12 | 110,061 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence A, where its elements are either in the form + x or -, where x is an integer.
For such a sequence S where its elements are either in the form + x or -, define f(S) as follows:
* iterate through S's elements from the first one to the last one, and maintain a multiset T as you iterate through it.
* for each element, if it's in the form + x, add x to T; otherwise, erase the smallest element from T (if T is empty, do nothing).
* after iterating through all S's elements, compute the sum of all elements in T. f(S) is defined as the sum.
The sequence b is a subsequence of the sequence a if b can be derived from a by removing zero or more elements without changing the order of the remaining elements. For all A's subsequences B, compute the sum of f(B), modulo 998 244 353.
Input
The first line contains an integer n (1≤ n≤ 500) — the length of A.
Each of the next n lines begins with an operator + or -. If the operator is +, then it's followed by an integer x (1≤ x<998 244 353). The i-th line of those n lines describes the i-th element in A.
Output
Print one integer, which is the answer to the problem, modulo 998 244 353.
Examples
Input
4
-
+ 1
+ 2
-
Output
16
Input
15
+ 2432543
-
+ 4567886
+ 65638788
-
+ 578943
-
-
+ 62356680
-
+ 711111
-
+ 998244352
-
-
Output
750759115
Note
In the first example, the following are all possible pairs of B and f(B):
* B= {}, f(B)=0.
* B= {-}, f(B)=0.
* B= {+ 1, -}, f(B)=0.
* B= {-, + 1, -}, f(B)=0.
* B= {+ 2, -}, f(B)=0.
* B= {-, + 2, -}, f(B)=0.
* B= {-}, f(B)=0.
* B= {-, -}, f(B)=0.
* B= {+ 1, + 2}, f(B)=3.
* B= {+ 1, + 2, -}, f(B)=2.
* B= {-, + 1, + 2}, f(B)=3.
* B= {-, + 1, + 2, -}, f(B)=2.
* B= {-, + 1}, f(B)=1.
* B= {+ 1}, f(B)=1.
* B= {-, + 2}, f(B)=2.
* B= {+ 2}, f(B)=2.
The sum of these values is 16. | instruction | 0 | 55,031 | 12 | 110,062 |
Tags: combinatorics, dp, implementation, math, ternary search
Correct Solution:
```
def naiveSolve(inn):
n=len(inn)
ans=0
for mask in range(1<<n):
ls=[]
for i in range(n):
if mask&(1<<i):
if len(inn[i])==1: # -
if ls:
ls.pop(0)
else:
y=int(inn[i].split()[1])
ls.append(y)
ls.sort()
ans+=sum(ls)
return ans
return
def main():
MOD=998244353
n=int(input())
inn=[]
for _ in range(n):
inn.append(input())
ans=0
for i in range(n):
if len(inn[i])==1: # -
continue
x=int(inn[i].split()[1])
# dp=[[0 for _ in range(n)] for __ in range(n)] # dp[i][number of elements<=x]=nWays
# dp[0][0]=1
dp=[0]*n
dp[0]=1 # dp[number of elements <=x]
for j in range(n):
if i==j: # ignore
continue
# copy over if don't take
dp2=dp.copy()
if len(inn[j])==1: # -
for k in range(n-1):
dp2[k]+=dp[k+1]
dp2[k]%=MOD
if j<i: # can subtract nothing
dp2[0]+=dp[0]
dp2[0]%=MOD
else:
y=int(inn[j].split()[1])
isSmaller=False
if y<x:
isSmaller=True
elif y==x and j<i: # to avoid double-counting when 2 elements are the same
isSmaller=True
if isSmaller:
for k in range(1,n):
dp2[k]+=dp[k-1]
dp2[k]%=MOD
else:
for k in range(n):
dp2[k]+=dp[k]
dp2[k]%=MOD
dp=dp2
for j in range(n):
ans+=(dp[j]*x)%MOD
ans%=MOD
print(ans)
# ans2=naiveSolve(inn)
# print(ans2%MOD)
return
import sys
# input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.
def oneLineArrayPrint(arr):
print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))
def readIntArr():
return [int(x) for x in input().split()]
# def readFloatArr():
# return [float(x) for x in input().split()]
def makeArr(defaultValFactory,dimensionArr): # eg. makeArr(lambda:0,[n,m])
dv=defaultValFactory;da=dimensionArr
if len(da)==1:return [dv() for _ in range(da[0])]
else:return [makeArr(dv,da[1:]) for _ in range(da[0])]
def queryInteractive(l,r):
print('? {} {}'.format(l,r))
sys.stdout.flush()
return int(input())
def answerInteractive(x):
print('! {}'.format(x))
sys.stdout.flush()
inf=float('inf')
MOD=10**9+7
# MOD=998244353
from math import gcd,floor,ceil
for _abc in range(1):
main()
``` | output | 1 | 55,031 | 12 | 110,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence A, where its elements are either in the form + x or -, where x is an integer.
For such a sequence S where its elements are either in the form + x or -, define f(S) as follows:
* iterate through S's elements from the first one to the last one, and maintain a multiset T as you iterate through it.
* for each element, if it's in the form + x, add x to T; otherwise, erase the smallest element from T (if T is empty, do nothing).
* after iterating through all S's elements, compute the sum of all elements in T. f(S) is defined as the sum.
The sequence b is a subsequence of the sequence a if b can be derived from a by removing zero or more elements without changing the order of the remaining elements. For all A's subsequences B, compute the sum of f(B), modulo 998 244 353.
Input
The first line contains an integer n (1≤ n≤ 500) — the length of A.
Each of the next n lines begins with an operator + or -. If the operator is +, then it's followed by an integer x (1≤ x<998 244 353). The i-th line of those n lines describes the i-th element in A.
Output
Print one integer, which is the answer to the problem, modulo 998 244 353.
Examples
Input
4
-
+ 1
+ 2
-
Output
16
Input
15
+ 2432543
-
+ 4567886
+ 65638788
-
+ 578943
-
-
+ 62356680
-
+ 711111
-
+ 998244352
-
-
Output
750759115
Note
In the first example, the following are all possible pairs of B and f(B):
* B= {}, f(B)=0.
* B= {-}, f(B)=0.
* B= {+ 1, -}, f(B)=0.
* B= {-, + 1, -}, f(B)=0.
* B= {+ 2, -}, f(B)=0.
* B= {-, + 2, -}, f(B)=0.
* B= {-}, f(B)=0.
* B= {-, -}, f(B)=0.
* B= {+ 1, + 2}, f(B)=3.
* B= {+ 1, + 2, -}, f(B)=2.
* B= {-, + 1, + 2}, f(B)=3.
* B= {-, + 1, + 2, -}, f(B)=2.
* B= {-, + 1}, f(B)=1.
* B= {+ 1}, f(B)=1.
* B= {-, + 2}, f(B)=2.
* B= {+ 2}, f(B)=2.
The sum of these values is 16. | instruction | 0 | 55,032 | 12 | 110,064 |
Tags: combinatorics, dp, implementation, math, ternary search
Correct Solution:
```
def divisors(M):
d=[]
i=1
while M>=i**2:
if M%i==0:
d.append(i)
if i**2!=M:
d.append(M//i)
i=i+1
return d
def popcount(x):
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007f
def eratosthenes(n):
res=[0 for i in range(n+1)]
prime=set([])
for i in range(2,n+1):
if not res[i]:
prime.add(i)
for j in range(1,n//i+1):
res[i*j]=1
return prime
def factorization(n):
res=[]
for p in prime:
if n%p==0:
while n%p==0:
n//=p
res.append(p)
if n!=1:
res.append(n)
return res
def euler_phi(n):
res = n
for x in range(2,n+1):
if x ** 2 > n:
break
if n%x==0:
res = res//x * (x-1)
while n%x==0:
n //= x
if n!=1:
res = res//n * (n-1)
return res
def ind(b,n):
res=0
while n%b==0:
res+=1
n//=b
return res
def isPrimeMR(n):
d = n - 1
d = d // (d & -d)
L = [2, 3, 5, 7, 11, 13, 17]
for a in L:
t = d
y = pow(a, t, n)
if y == 1: continue
while y != n - 1:
y = (y * y) % n
if y == 1 or t == n - 1: return 0
t <<= 1
return 1
def findFactorRho(n):
from math import gcd
m = 1 << n.bit_length() // 8
for c in range(1, 99):
f = lambda x: (x * x + c) % n
y, r, q, g = 2, 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = f(y)
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = f(y)
q = q * abs(x - y) % n
g = gcd(q, n)
k += m
r <<= 1
if g == n:
g = 1
while g == 1:
ys = f(ys)
g = gcd(abs(x - ys), n)
if g < n:
if isPrimeMR(g): return g
elif isPrimeMR(n // g): return n // g
return findFactorRho(g)
def primeFactor(n):
i = 2
ret = {}
rhoFlg = 0
while i*i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k: ret[i] = k
i += 1 + i % 2
if i == 101 and n >= 2 ** 20:
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
rhoFlg = 1
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1: ret[n] = 1
if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
return ret
def divisors(n):
res = [1]
prime = primeFactor(n)
for p in prime:
newres = []
for d in res:
for j in range(prime[p]+1):
newres.append(d*p**j)
res = newres
res.sort()
return res
def xorfactorial(num):
if num==0:
return 0
elif num==1:
return 1
elif num==2:
return 3
elif num==3:
return 0
else:
x=baseorder(num)
return (2**x)*((num-2**x+1)%2)+function(num-2**x)
def xorconv(n,X,Y):
if n==0:
res=[(X[0]*Y[0])%mod]
return res
x=[X[i]+X[i+2**(n-1)] for i in range(2**(n-1))]
y=[Y[i]+Y[i+2**(n-1)] for i in range(2**(n-1))]
z=[X[i]-X[i+2**(n-1)] for i in range(2**(n-1))]
w=[Y[i]-Y[i+2**(n-1)] for i in range(2**(n-1))]
res1=xorconv(n-1,x,y)
res2=xorconv(n-1,z,w)
former=[(res1[i]+res2[i])*inv for i in range(2**(n-1))]
latter=[(res1[i]-res2[i])*inv for i in range(2**(n-1))]
former=list(map(lambda x:x%mod,former))
latter=list(map(lambda x:x%mod,latter))
return former+latter
def merge_sort(A,B):
pos_A,pos_B = 0,0
n,m = len(A),len(B)
res = []
while pos_A < n and pos_B < m:
a,b = A[pos_A],B[pos_B]
if a < b:
res.append(a)
pos_A += 1
else:
res.append(b)
pos_B += 1
res += A[pos_A:]
res += B[pos_B:]
return res
class UnionFindVerSize():
def __init__(self, N):
self._parent = [n for n in range(0, N)]
self._size = [1] * N
self.group = N
def find_root(self, x):
if self._parent[x] == x: return x
self._parent[x] = self.find_root(self._parent[x])
stack = [x]
while self._parent[stack[-1]]!=stack[-1]:
stack.append(self._parent[stack[-1]])
for v in stack:
self._parent[v] = stack[-1]
return self._parent[x]
def unite(self, x, y):
gx = self.find_root(x)
gy = self.find_root(y)
if gx == gy: return
self.group -= 1
if self._size[gx] < self._size[gy]:
self._parent[gx] = gy
self._size[gy] += self._size[gx]
else:
self._parent[gy] = gx
self._size[gx] += self._size[gy]
def get_size(self, x):
return self._size[self.find_root(x)]
def is_same_group(self, x, y):
return self.find_root(x) == self.find_root(y)
class WeightedUnionFind():
def __init__(self,N):
self.parent = [i for i in range(N)]
self.size = [1 for i in range(N)]
self.val = [0 for i in range(N)]
self.flag = True
self.edge = [[] for i in range(N)]
def dfs(self,v,pv):
stack = [(v,pv)]
new_parent = self.parent[pv]
while stack:
v,pv = stack.pop()
self.parent[v] = new_parent
for nv,w in self.edge[v]:
if nv!=pv:
self.val[nv] = self.val[v] + w
stack.append((nv,v))
def unite(self,x,y,w):
if not self.flag:
return
if self.parent[x]==self.parent[y]:
self.flag = (self.val[x] - self.val[y] == w)
return
if self.size[self.parent[x]]>self.size[self.parent[y]]:
self.edge[x].append((y,-w))
self.edge[y].append((x,w))
self.size[x] += self.size[y]
self.val[y] = self.val[x] - w
self.dfs(y,x)
else:
self.edge[x].append((y,-w))
self.edge[y].append((x,w))
self.size[y] += self.size[x]
self.val[x] = self.val[y] + w
self.dfs(x,y)
class Dijkstra():
class Edge():
def __init__(self, _to, _cost):
self.to = _to
self.cost = _cost
def __init__(self, V):
self.G = [[] for i in range(V)]
self._E = 0
self._V = V
@property
def E(self):
return self._E
@property
def V(self):
return self._V
def add_edge(self, _from, _to, _cost):
self.G[_from].append(self.Edge(_to, _cost))
self._E += 1
def shortest_path(self, s):
import heapq
que = []
d = [10**15] * self.V
d[s] = 0
heapq.heappush(que, (0, s))
while len(que) != 0:
cost, v = heapq.heappop(que)
if d[v] < cost: continue
for i in range(len(self.G[v])):
e = self.G[v][i]
if d[e.to] > d[v] + e.cost:
d[e.to] = d[v] + e.cost
heapq.heappush(que, (d[e.to], e.to))
return d
#Z[i]:length of the longest list starting from S[i] which is also a prefix of S
#O(|S|)
def Z_algorithm(s):
N = len(s)
Z_alg = [0]*N
Z_alg[0] = N
i = 1
j = 0
while i < N:
while i+j < N and s[j] == s[i+j]:
j += 1
Z_alg[i] = j
if j == 0:
i += 1
continue
k = 1
while i+k < N and k + Z_alg[k]<j:
Z_alg[i+k] = Z_alg[k]
k += 1
i += k
j -= k
return Z_alg
class BIT():
def __init__(self,n,mod=0):
self.BIT = [0]*(n+1)
self.num = n
self.mod = mod
def query(self,idx):
res_sum = 0
mod = self.mod
while idx > 0:
res_sum += self.BIT[idx]
if mod:
res_sum %= mod
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def update(self,idx,x):
mod = self.mod
while idx <= self.num:
self.BIT[idx] += x
if mod:
self.BIT[idx] %= mod
idx += idx&(-idx)
return
class dancinglink():
def __init__(self,n,debug=False):
self.n = n
self.debug = debug
self._left = [i-1 for i in range(n)]
self._right = [i+1 for i in range(n)]
self.exist = [True for i in range(n)]
def pop(self,k):
if self.debug:
assert self.exist[k]
L = self._left[k]
R = self._right[k]
if L!=-1:
if R!=self.n:
self._right[L],self._left[R] = R,L
else:
self._right[L] = self.n
elif R!=self.n:
self._left[R] = -1
self.exist[k] = False
def left(self,idx,k=1):
if self.debug:
assert self.exist[idx]
res = idx
while k:
res = self._left[res]
if res==-1:
break
k -= 1
return res
def right(self,idx,k=1):
if self.debug:
assert self.exist[idx]
res = idx
while k:
res = self._right[res]
if res==self.n:
break
k -= 1
return res
class SparseTable():
def __init__(self,A,merge_func,ide_ele):
N=len(A)
n=N.bit_length()
self.table=[[ide_ele for i in range(n)] for i in range(N)]
self.merge_func=merge_func
for i in range(N):
self.table[i][0]=A[i]
for j in range(1,n):
for i in range(0,N-2**j+1):
f=self.table[i][j-1]
s=self.table[i+2**(j-1)][j-1]
self.table[i][j]=self.merge_func(f,s)
def query(self,s,t):
b=t-s+1
m=b.bit_length()-1
return self.merge_func(self.table[s][m],self.table[t-2**m+1][m])
class BinaryTrie:
class node:
def __init__(self,val):
self.left = None
self.right = None
self.max = val
def __init__(self):
self.root = self.node(-10**15)
def append(self,key,val):
pos = self.root
for i in range(29,-1,-1):
pos.max = max(pos.max,val)
if key>>i & 1:
if pos.right is None:
pos.right = self.node(val)
pos = pos.right
else:
pos = pos.right
else:
if pos.left is None:
pos.left = self.node(val)
pos = pos.left
else:
pos = pos.left
pos.max = max(pos.max,val)
def search(self,M,xor):
res = -10**15
pos = self.root
for i in range(29,-1,-1):
if pos is None:
break
if M>>i & 1:
if xor>>i & 1:
if pos.right:
res = max(res,pos.right.max)
pos = pos.left
else:
if pos.left:
res = max(res,pos.left.max)
pos = pos.right
else:
if xor>>i & 1:
pos = pos.right
else:
pos = pos.left
if pos:
res = max(res,pos.max)
return res
def solveequation(edge,ans,n,m):
#edge=[[to,dire,id]...]
x=[0]*m
used=[False]*n
for v in range(n):
if used[v]:
continue
y = dfs(v)
if y!=0:
return False
return x
def dfs(v):
used[v]=True
r=ans[v]
for to,dire,id in edge[v]:
if used[to]:
continue
y=dfs(to)
if dire==-1:
x[id]=y
else:
x[id]=-y
r+=y
return r
class SegmentTree:
def __init__(self, init_val, segfunc, ide_ele):
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
self.size = n
for i in range(n):
self.tree[self.num + i] = init_val[i]
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
if r==self.size:
r = self.num
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
def bisect_l(self,l,r,x):
l += self.num
r += self.num
Lmin = -1
Rmin = -1
while l<r:
if l & 1:
if self.tree[l] <= x and Lmin==-1:
Lmin = l
l += 1
if r & 1:
if self.tree[r-1] <=x:
Rmin = r-1
l >>= 1
r >>= 1
if Lmin != -1:
pos = Lmin
while pos<self.num:
if self.tree[2 * pos] <=x:
pos = 2 * pos
else:
pos = 2 * pos +1
return pos-self.num
elif Rmin != -1:
pos = Rmin
while pos<self.num:
if self.tree[2 * pos] <=x:
pos = 2 * pos
else:
pos = 2 * pos +1
return pos-self.num
else:
return -1
import sys,random,bisect
from collections import deque,defaultdict
from heapq import heapify,heappop,heappush
from itertools import permutations
from math import gcd,log
input = lambda :sys.stdin.readline().rstrip()
mi = lambda :map(int,input().split())
li = lambda :list(mi())
mod = 998244353
n = int(input())
A = [input().split() for i in range(n)]
for i in range(n):
if A[i][0]=="+":
A[i][1] = int(A[i][1])
res = 0
for i in range(n):
if A[i][0]=="-":
continue
x = A[i][1]
dp = [0 for i in range(n+1)]
dp[0] = 1
for j in range(i):
ndp = [dp[k] for k in range(n+1)]
for k in range(n+1):
if not dp[k]:
continue
if A[j][0]=="-":
if k!=0:
ndp[k-1] += dp[k]
ndp[k-1] %= mod
else:
ndp[0] += dp[0]
ndp[0] %= mod
elif A[j][0]=="+":
if A[j][1] > x:
ndp[k] += dp[k]
ndp[k] %= mod
elif A[j][1] <= x:
ndp[k+1] += dp[k]
ndp[k+1] %= mod
dp = ndp
for j in range(i+1,n):
ndp = [dp[k] for k in range(n+1)]
for k in range(n+1):
if not dp[k]:
continue
if A[j][0]=="-":
if k!=0:
ndp[k-1] += dp[k]
ndp[k-1] %= mod
elif A[j][0]=="+":
if A[j][1] >= x:
ndp[k] += dp[k]
ndp[k] %= mod
elif A[j][1] < x:
ndp[k+1] += dp[k]
ndp[k+1] %= mod
dp = ndp
for k in range(n+1):
res += x * dp[k]
res %= mod
print(res)
``` | output | 1 | 55,032 | 12 | 110,065 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence A, where its elements are either in the form + x or -, where x is an integer.
For such a sequence S where its elements are either in the form + x or -, define f(S) as follows:
* iterate through S's elements from the first one to the last one, and maintain a multiset T as you iterate through it.
* for each element, if it's in the form + x, add x to T; otherwise, erase the smallest element from T (if T is empty, do nothing).
* after iterating through all S's elements, compute the sum of all elements in T. f(S) is defined as the sum.
The sequence b is a subsequence of the sequence a if b can be derived from a by removing zero or more elements without changing the order of the remaining elements. For all A's subsequences B, compute the sum of f(B), modulo 998 244 353.
Input
The first line contains an integer n (1≤ n≤ 500) — the length of A.
Each of the next n lines begins with an operator + or -. If the operator is +, then it's followed by an integer x (1≤ x<998 244 353). The i-th line of those n lines describes the i-th element in A.
Output
Print one integer, which is the answer to the problem, modulo 998 244 353.
Examples
Input
4
-
+ 1
+ 2
-
Output
16
Input
15
+ 2432543
-
+ 4567886
+ 65638788
-
+ 578943
-
-
+ 62356680
-
+ 711111
-
+ 998244352
-
-
Output
750759115
Note
In the first example, the following are all possible pairs of B and f(B):
* B= {}, f(B)=0.
* B= {-}, f(B)=0.
* B= {+ 1, -}, f(B)=0.
* B= {-, + 1, -}, f(B)=0.
* B= {+ 2, -}, f(B)=0.
* B= {-, + 2, -}, f(B)=0.
* B= {-}, f(B)=0.
* B= {-, -}, f(B)=0.
* B= {+ 1, + 2}, f(B)=3.
* B= {+ 1, + 2, -}, f(B)=2.
* B= {-, + 1, + 2}, f(B)=3.
* B= {-, + 1, + 2, -}, f(B)=2.
* B= {-, + 1}, f(B)=1.
* B= {+ 1}, f(B)=1.
* B= {-, + 2}, f(B)=2.
* B= {+ 2}, f(B)=2.
The sum of these values is 16. | instruction | 0 | 55,033 | 12 | 110,066 |
Tags: combinatorics, dp, implementation, math, ternary search
Correct Solution:
```
n = int(input())
A = []
for i in range(n):
s = input()
if s[0] == '+':
A.append((1, int(s[2:])))
else:
A.append((0, 0))
answer = 0
m = 998244353
for k, elem in enumerate(A):
if elem[0] == 0:
continue
D = [1]
for j, el in enumerate(A):
if k == j:
continue
if el[0] == 0:
new_D = [0] * len(D)
if k > j:
new_D[0] = 2 * D[0]
else:
new_D[0] = D[0]
for i, val in enumerate(D):
if i != 0:
new_D[i] += D[i]
new_D[i - 1] += D[i]
D = new_D
else:
if el[1] > elem[1] or (el[1] == elem[1]) and k < j:
for i, val in enumerate(D):
D[i] = 2 * D[i]
else:
new_D = [0] * (len(D) + 1)
for i, val in enumerate(D):
new_D[i] += val
new_D[i + 1] += val
D = new_D
answer += elem[1] * sum(D)
answer %= m
print(answer)
``` | output | 1 | 55,033 | 12 | 110,067 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence A, where its elements are either in the form + x or -, where x is an integer.
For such a sequence S where its elements are either in the form + x or -, define f(S) as follows:
* iterate through S's elements from the first one to the last one, and maintain a multiset T as you iterate through it.
* for each element, if it's in the form + x, add x to T; otherwise, erase the smallest element from T (if T is empty, do nothing).
* after iterating through all S's elements, compute the sum of all elements in T. f(S) is defined as the sum.
The sequence b is a subsequence of the sequence a if b can be derived from a by removing zero or more elements without changing the order of the remaining elements. For all A's subsequences B, compute the sum of f(B), modulo 998 244 353.
Input
The first line contains an integer n (1≤ n≤ 500) — the length of A.
Each of the next n lines begins with an operator + or -. If the operator is +, then it's followed by an integer x (1≤ x<998 244 353). The i-th line of those n lines describes the i-th element in A.
Output
Print one integer, which is the answer to the problem, modulo 998 244 353.
Examples
Input
4
-
+ 1
+ 2
-
Output
16
Input
15
+ 2432543
-
+ 4567886
+ 65638788
-
+ 578943
-
-
+ 62356680
-
+ 711111
-
+ 998244352
-
-
Output
750759115
Note
In the first example, the following are all possible pairs of B and f(B):
* B= {}, f(B)=0.
* B= {-}, f(B)=0.
* B= {+ 1, -}, f(B)=0.
* B= {-, + 1, -}, f(B)=0.
* B= {+ 2, -}, f(B)=0.
* B= {-, + 2, -}, f(B)=0.
* B= {-}, f(B)=0.
* B= {-, -}, f(B)=0.
* B= {+ 1, + 2}, f(B)=3.
* B= {+ 1, + 2, -}, f(B)=2.
* B= {-, + 1, + 2}, f(B)=3.
* B= {-, + 1, + 2, -}, f(B)=2.
* B= {-, + 1}, f(B)=1.
* B= {+ 1}, f(B)=1.
* B= {-, + 2}, f(B)=2.
* B= {+ 2}, f(B)=2.
The sum of these values is 16. | instruction | 0 | 55,034 | 12 | 110,068 |
Tags: combinatorics, dp, implementation, math, ternary search
Correct Solution:
```
import sys
input = sys.stdin.readline
mod = 998244353
n = int(input())
A = []
for _ in range(n):
s = input().split()
if s[0] == '-': A.append(0)
else: A.append(int(s[1]))
ans = 0
for i in range(n):
if not A[i]: continue
dp = [0] * (n + 1)
dp[0] = 1
greater = 0
for j in range(n):
if j == i: continue
if j < i and A[j] > A[i] or j > i and A[j] >= A[i]:
greater += 1
continue
if A[j] == 0:
for k in range(j + 1):
if j < i or k:
dp[max(0, k - 1)] += dp[k]
else:
for k in range(j, -1, -1):
dp[k + 1] += dp[k]
ans += pow(2, greater, mod) * sum(dp) * A[i] % mod
ans %= mod
print(ans)
``` | output | 1 | 55,034 | 12 | 110,069 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence A, where its elements are either in the form + x or -, where x is an integer.
For such a sequence S where its elements are either in the form + x or -, define f(S) as follows:
* iterate through S's elements from the first one to the last one, and maintain a multiset T as you iterate through it.
* for each element, if it's in the form + x, add x to T; otherwise, erase the smallest element from T (if T is empty, do nothing).
* after iterating through all S's elements, compute the sum of all elements in T. f(S) is defined as the sum.
The sequence b is a subsequence of the sequence a if b can be derived from a by removing zero or more elements without changing the order of the remaining elements. For all A's subsequences B, compute the sum of f(B), modulo 998 244 353.
Input
The first line contains an integer n (1≤ n≤ 500) — the length of A.
Each of the next n lines begins with an operator + or -. If the operator is +, then it's followed by an integer x (1≤ x<998 244 353). The i-th line of those n lines describes the i-th element in A.
Output
Print one integer, which is the answer to the problem, modulo 998 244 353.
Examples
Input
4
-
+ 1
+ 2
-
Output
16
Input
15
+ 2432543
-
+ 4567886
+ 65638788
-
+ 578943
-
-
+ 62356680
-
+ 711111
-
+ 998244352
-
-
Output
750759115
Note
In the first example, the following are all possible pairs of B and f(B):
* B= {}, f(B)=0.
* B= {-}, f(B)=0.
* B= {+ 1, -}, f(B)=0.
* B= {-, + 1, -}, f(B)=0.
* B= {+ 2, -}, f(B)=0.
* B= {-, + 2, -}, f(B)=0.
* B= {-}, f(B)=0.
* B= {-, -}, f(B)=0.
* B= {+ 1, + 2}, f(B)=3.
* B= {+ 1, + 2, -}, f(B)=2.
* B= {-, + 1, + 2}, f(B)=3.
* B= {-, + 1, + 2, -}, f(B)=2.
* B= {-, + 1}, f(B)=1.
* B= {+ 1}, f(B)=1.
* B= {-, + 2}, f(B)=2.
* B= {+ 2}, f(B)=2.
The sum of these values is 16. | instruction | 0 | 55,035 | 12 | 110,070 |
Tags: combinatorics, dp, implementation, math, ternary search
Correct Solution:
```
def main():
mod=998244353
n=int(input())
a=[]
for i in range(n):
t=input()
if t[0]=='-':
a.append(-1)
else:
a.append(int(t.split()[-1]))
ans=0
for i in range(n):
if a[i]==-1:
continue
dp=[0]*(n+1)
dp[0]=1
buf=1
for j in range(n):
if j<i:
if a[j]==-1:
dp[0]=dp[0]*2%mod
for k in range(1,j+1):
dp[k-1]=(dp[k-1]+dp[k])%mod
elif a[j]<=a[i]:
for k in range(j,-1,-1):
dp[k+1]=(dp[k+1]+dp[k])%mod
else:
buf=buf*2%mod
elif i<j:
if a[j]==-1:
for k in range(1,j+1):
dp[k-1]=(dp[k-1]+dp[k])%mod
elif a[j]<a[i]:
for k in range(j,-1,-1):
dp[k+1]=(dp[k+1]+dp[k])%mod
else:
buf=buf*2%mod
ans=(ans+a[i]*sum(dp)*buf)%mod
print(ans)
main()
``` | output | 1 | 55,035 | 12 | 110,071 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence A, where its elements are either in the form + x or -, where x is an integer.
For such a sequence S where its elements are either in the form + x or -, define f(S) as follows:
* iterate through S's elements from the first one to the last one, and maintain a multiset T as you iterate through it.
* for each element, if it's in the form + x, add x to T; otherwise, erase the smallest element from T (if T is empty, do nothing).
* after iterating through all S's elements, compute the sum of all elements in T. f(S) is defined as the sum.
The sequence b is a subsequence of the sequence a if b can be derived from a by removing zero or more elements without changing the order of the remaining elements. For all A's subsequences B, compute the sum of f(B), modulo 998 244 353.
Input
The first line contains an integer n (1≤ n≤ 500) — the length of A.
Each of the next n lines begins with an operator + or -. If the operator is +, then it's followed by an integer x (1≤ x<998 244 353). The i-th line of those n lines describes the i-th element in A.
Output
Print one integer, which is the answer to the problem, modulo 998 244 353.
Examples
Input
4
-
+ 1
+ 2
-
Output
16
Input
15
+ 2432543
-
+ 4567886
+ 65638788
-
+ 578943
-
-
+ 62356680
-
+ 711111
-
+ 998244352
-
-
Output
750759115
Note
In the first example, the following are all possible pairs of B and f(B):
* B= {}, f(B)=0.
* B= {-}, f(B)=0.
* B= {+ 1, -}, f(B)=0.
* B= {-, + 1, -}, f(B)=0.
* B= {+ 2, -}, f(B)=0.
* B= {-, + 2, -}, f(B)=0.
* B= {-}, f(B)=0.
* B= {-, -}, f(B)=0.
* B= {+ 1, + 2}, f(B)=3.
* B= {+ 1, + 2, -}, f(B)=2.
* B= {-, + 1, + 2}, f(B)=3.
* B= {-, + 1, + 2, -}, f(B)=2.
* B= {-, + 1}, f(B)=1.
* B= {+ 1}, f(B)=1.
* B= {-, + 2}, f(B)=2.
* B= {+ 2}, f(B)=2.
The sum of these values is 16. | instruction | 0 | 55,036 | 12 | 110,072 |
Tags: combinatorics, dp, implementation, math, ternary search
Correct Solution:
```
mod = 998244353
eps = 10**-9
def main():
import sys
input = sys.stdin.readline
N = int(input())
Q = []
for i in range(N):
S = input().rstrip('\n')
if S[0] == "+":
_, t = S.split()
Q.append(int(t) + 0.00001 * i)
else:
Q.append(-1)
ans = 0
for i0 in range(N):
a = Q[i0]
if a == -1:
continue
dp = [1]
for i in range(N):
dp_new = [0] * (i+2)
if i != i0:
if Q[i] == -1:
for j in range(i+1):
dp_new[j] = dp[j]
if j:
dp_new[j-1] = (dp_new[j-1] + dp[j])%mod
else:
if i < i0:
dp_new[j] = (dp_new[j] + dp[j])%mod
else:
if Q[i] < a:
for j in range(i+1):
dp_new[j] = (dp_new[j] + dp[j])%mod
dp_new[j+1] = dp[j]
else:
for j in range(i+1):
dp_new[j] = (dp[j] * 2)%mod
else:
for j in range(i+1):
dp_new[j] = dp[j]
dp = dp_new
a = int(a + 0.3)
for j in range(N):
ans = (ans + (a * dp[j])%mod)%mod
print(ans)
if __name__ == '__main__':
main()
``` | output | 1 | 55,036 | 12 | 110,073 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem is the most boring one you've ever seen.
Given a sequence of integers a1, a2, ..., an and a non-negative integer h, our goal is to partition the sequence into two subsequences (not necessarily consist of continuous elements). Each element of the original sequence should be contained in exactly one of the result subsequences. Note, that one of the result subsequences can be empty.
Let's define function f(ai, aj) on pairs of distinct elements (that is i ≠ j) in the original sequence. If ai and aj are in the same subsequence in the current partition then f(ai, aj) = ai + aj otherwise f(ai, aj) = ai + aj + h.
Consider all possible values of the function f for some partition. We'll call the goodness of this partiotion the difference between the maximum value of function f and the minimum value of function f.
Your task is to find a partition of the given sequence a that have the minimal possible goodness among all possible partitions.
Input
The first line of input contains integers n and h (2 ≤ n ≤ 105, 0 ≤ h ≤ 108). In the second line there is a list of n space-separated integers representing a1, a2, ..., an (0 ≤ ai ≤ 108).
Output
The first line of output should contain the required minimum goodness.
The second line describes the optimal partition. You should print n whitespace-separated integers in the second line. The i-th integer is 1 if ai is in the first subsequence otherwise it should be 2.
If there are several possible correct answers you are allowed to print any of them.
Examples
Input
3 2
1 2 3
Output
1
1 2 2
Input
5 10
0 1 0 2 1
Output
3
2 2 2 2 2
Note
In the first sample the values of f are as follows: f(1, 2) = 1 + 2 + 2 = 5, f(1, 3) = 1 + 3 + 2 = 6 and f(2, 3) = 2 + 3 = 5. So the difference between maximum and minimum values of f is 1.
In the second sample the value of h is large, so it's better for one of the sub-sequences to be empty. | instruction | 0 | 55,093 | 12 | 110,186 |
Tags: constructive algorithms
Correct Solution:
```
n,m=map(int,input().split());a=list(map(int,input().split()));p=0;t=[0]*3
for i in range(n):
if(a[i]<a[p]):p=i
if(n==2):print('0\n1 1\n')
else:
a.sort();t[0]=min(a[0]+a[1]+m,a[1]+a[2]);t[1]=max(a[0]+a[n-1]+m,a[n-2]+a[n-1]);t[2]=(a[n-2]+a[n-1])-(a[0]+a[1])
if(t[1]-t[0]>t[2]):p=n
else:t[2]=t[1]-t[0]
print(t[2])
for i in range(n):print(int(i==p)+1,end=' ')
``` | output | 1 | 55,093 | 12 | 110,187 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This problem is the most boring one you've ever seen.
Given a sequence of integers a1, a2, ..., an and a non-negative integer h, our goal is to partition the sequence into two subsequences (not necessarily consist of continuous elements). Each element of the original sequence should be contained in exactly one of the result subsequences. Note, that one of the result subsequences can be empty.
Let's define function f(ai, aj) on pairs of distinct elements (that is i ≠ j) in the original sequence. If ai and aj are in the same subsequence in the current partition then f(ai, aj) = ai + aj otherwise f(ai, aj) = ai + aj + h.
Consider all possible values of the function f for some partition. We'll call the goodness of this partiotion the difference between the maximum value of function f and the minimum value of function f.
Your task is to find a partition of the given sequence a that have the minimal possible goodness among all possible partitions.
Input
The first line of input contains integers n and h (2 ≤ n ≤ 105, 0 ≤ h ≤ 108). In the second line there is a list of n space-separated integers representing a1, a2, ..., an (0 ≤ ai ≤ 108).
Output
The first line of output should contain the required minimum goodness.
The second line describes the optimal partition. You should print n whitespace-separated integers in the second line. The i-th integer is 1 if ai is in the first subsequence otherwise it should be 2.
If there are several possible correct answers you are allowed to print any of them.
Examples
Input
3 2
1 2 3
Output
1
1 2 2
Input
5 10
0 1 0 2 1
Output
3
2 2 2 2 2
Note
In the first sample the values of f are as follows: f(1, 2) = 1 + 2 + 2 = 5, f(1, 3) = 1 + 3 + 2 = 6 and f(2, 3) = 2 + 3 = 5. So the difference between maximum and minimum values of f is 1.
In the second sample the value of h is large, so it's better for one of the sub-sequences to be empty. | instruction | 0 | 55,094 | 12 | 110,188 |
Tags: constructive algorithms
Correct Solution:
```
#https://codeforces.com/problemset/problem/238/B
n, h = map(int, input().split())
a = list(map(int, input().split()))
b = [[x, i] for i, x in enumerate(a)]
b = sorted(b, key=lambda x:x[0])
def solve(a, n, h):
if n == 2:
return 0, [1, 1]
min_ = (a[-1][0] + a[-2][0]) - (a[0][0] + a[1][0])
# move a[0] to 2th-group
min_2 = max(a[-1][0] + a[-2][0], a[-1][0] + a[0][0] + h) - min(a[0][0] + a[1][0] +h, a[1][0] + a[2][0])
ans = [1] * n
if min_2 < min_:
min_ = min_2
ans[a[0][1]] = 2
return min_, ans
min_, ans = solve(b, n, h)
print(min_)
print(' '.join([str(x) for x in ans]))
#5 10
#0 1 0 2 1
#3 2
#1 2 3
``` | output | 1 | 55,094 | 12 | 110,189 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem is the most boring one you've ever seen.
Given a sequence of integers a1, a2, ..., an and a non-negative integer h, our goal is to partition the sequence into two subsequences (not necessarily consist of continuous elements). Each element of the original sequence should be contained in exactly one of the result subsequences. Note, that one of the result subsequences can be empty.
Let's define function f(ai, aj) on pairs of distinct elements (that is i ≠ j) in the original sequence. If ai and aj are in the same subsequence in the current partition then f(ai, aj) = ai + aj otherwise f(ai, aj) = ai + aj + h.
Consider all possible values of the function f for some partition. We'll call the goodness of this partiotion the difference between the maximum value of function f and the minimum value of function f.
Your task is to find a partition of the given sequence a that have the minimal possible goodness among all possible partitions.
Input
The first line of input contains integers n and h (2 ≤ n ≤ 105, 0 ≤ h ≤ 108). In the second line there is a list of n space-separated integers representing a1, a2, ..., an (0 ≤ ai ≤ 108).
Output
The first line of output should contain the required minimum goodness.
The second line describes the optimal partition. You should print n whitespace-separated integers in the second line. The i-th integer is 1 if ai is in the first subsequence otherwise it should be 2.
If there are several possible correct answers you are allowed to print any of them.
Examples
Input
3 2
1 2 3
Output
1
1 2 2
Input
5 10
0 1 0 2 1
Output
3
2 2 2 2 2
Note
In the first sample the values of f are as follows: f(1, 2) = 1 + 2 + 2 = 5, f(1, 3) = 1 + 3 + 2 = 6 and f(2, 3) = 2 + 3 = 5. So the difference between maximum and minimum values of f is 1.
In the second sample the value of h is large, so it's better for one of the sub-sequences to be empty.
Submitted Solution:
```
#https://codeforces.com/problemset/problem/238/B
n, h = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a)
def solve(a, n, h):
if n == 2:
return 0, [1, 1]
min_ = (a[-1] + a[-2]) - (a[0] + a[1])
# move a[0] to 2th-group
min_2 = max(a[-1] + a[-2], a[-1] + a[0] + h) - min(a[0] + a[1] +h, a[1] + a[2])
ans = [1] * n
if min_2 < min_:
min_ = min_2
ans[0] = 2
return min_, ans
min_, ans = solve(a, n, h)
print(min_)
print(' '.join([str(x) for x in ans]))
a
#5 10
#0 1 0 2 1
#3 2
#1 2 3
``` | instruction | 0 | 55,095 | 12 | 110,190 |
No | output | 1 | 55,095 | 12 | 110,191 |
Provide a correct Python 3 solution for this coding contest problem.
For a given sequence $A = \\{a_0, a_1, ... a_{n-1}\\}$, the number of pairs $(i, j)$ where $a_i > a_j$ and $i < j$, is called the number of inversions. The number of inversions is equal to the number of swaps of Bubble Sort defined in the following program:
bubbleSort(A)
cnt = 0 // the number of inversions
for i = 0 to A.length-1
for j = A.length-1 downto i+1
if A[j] < A[j-1]
swap(A[j], A[j-1])
cnt++
return cnt
For the given sequence $A$, print the number of inversions of $A$. Note that you should not use the above program, which brings Time Limit Exceeded.
Constraints
* $ 1 \leq n \leq 200,000$
* $ 0 \leq a_i \leq 10^9$
* $a_i$ are all different
Input
In the first line, an integer $n$, the number of elements in $A$, is given. In the second line, the elements $a_i$ ($i = 0, 1, .. n-1$) are given separated by space characters.
Examples
Input
5
3 5 2 1 4
Output
6
Input
3
3 1 2
Output
2 | instruction | 0 | 55,571 | 12 | 111,142 |
"Correct Solution:
```
def merge(a, left, mid, right):
global cnt
l = a[left:mid] + [sentinel]
r = a[mid:right] + [sentinel]
i = j = 0
for k in range(left, right):
if l[i] <= r[j]:
a[k] = l[i]
i += 1
else:
a[k] = r[j]
j += 1
cnt += mid - left - i
def merge_sort(a, left, right):
if left + 1 < right:
mid = (left + right) // 2
merge_sort(a, left, mid)
merge_sort(a, mid, right)
merge(a, left, mid, right)
n = input()
a = list(map(int, input().split()))
sentinel = 10 ** 9 + 1
cnt = 0
merge_sort(a, 0, len(a))
print(cnt)
``` | output | 1 | 55,571 | 12 | 111,143 |
Provide a correct Python 3 solution for this coding contest problem.
For a given sequence $A = \\{a_0, a_1, ... a_{n-1}\\}$, the number of pairs $(i, j)$ where $a_i > a_j$ and $i < j$, is called the number of inversions. The number of inversions is equal to the number of swaps of Bubble Sort defined in the following program:
bubbleSort(A)
cnt = 0 // the number of inversions
for i = 0 to A.length-1
for j = A.length-1 downto i+1
if A[j] < A[j-1]
swap(A[j], A[j-1])
cnt++
return cnt
For the given sequence $A$, print the number of inversions of $A$. Note that you should not use the above program, which brings Time Limit Exceeded.
Constraints
* $ 1 \leq n \leq 200,000$
* $ 0 \leq a_i \leq 10^9$
* $a_i$ are all different
Input
In the first line, an integer $n$, the number of elements in $A$, is given. In the second line, the elements $a_i$ ($i = 0, 1, .. n-1$) are given separated by space characters.
Examples
Input
5
3 5 2 1 4
Output
6
Input
3
3 1 2
Output
2 | instruction | 0 | 55,572 | 12 | 111,144 |
"Correct Solution:
```
class BinaryIndexedTree(object):
__slots__ = ["tree", "size"]
def __init__(self, size: int):
self.tree = [0]*(size+1)
self.size = size+1
def add(self, index: int, value: int):
tree = self.tree
while index < len(tree):
tree[index] += value
index += index & -index
def sum(self, index: int):
tree, result = self.tree, 0
while index:
result += tree[index]
index -= index & -index
return result
def solve(A):
bit = BinaryIndexedTree(len(A)+1)
ans = 0
for i, n in enumerate(A):
ans += i - bit.sum(n-1)
bit.add(n, 1)
return ans
if __name__ == "__main__":
input()
a = list(map(int, input().split()))
d = {n: i for i, n in enumerate(sorted(a), start=1)}
a = [d[n] for n in a]
print(solve(a))
``` | output | 1 | 55,572 | 12 | 111,145 |
Provide a correct Python 3 solution for this coding contest problem.
For a given sequence $A = \\{a_0, a_1, ... a_{n-1}\\}$, the number of pairs $(i, j)$ where $a_i > a_j$ and $i < j$, is called the number of inversions. The number of inversions is equal to the number of swaps of Bubble Sort defined in the following program:
bubbleSort(A)
cnt = 0 // the number of inversions
for i = 0 to A.length-1
for j = A.length-1 downto i+1
if A[j] < A[j-1]
swap(A[j], A[j-1])
cnt++
return cnt
For the given sequence $A$, print the number of inversions of $A$. Note that you should not use the above program, which brings Time Limit Exceeded.
Constraints
* $ 1 \leq n \leq 200,000$
* $ 0 \leq a_i \leq 10^9$
* $a_i$ are all different
Input
In the first line, an integer $n$, the number of elements in $A$, is given. In the second line, the elements $a_i$ ($i = 0, 1, .. n-1$) are given separated by space characters.
Examples
Input
5
3 5 2 1 4
Output
6
Input
3
3 1 2
Output
2 | instruction | 0 | 55,573 | 12 | 111,146 |
"Correct Solution:
```
# 16D8101012J ItoJun dj Python3
count=0
def merge(A, left, mid, right):
global count
h=[]
L=A[left:mid]+[2**32]
R=A[mid:right]+[2**32]
i=0
j=0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
h.append(L[i])
i += 1
else:
A[k] = R[j]
h.append(R[j])
j += 1
if i < len(L)-1:
count += len(L) - 1 - i
def merge_sort(A, left, right):
if left+1 < right:
mid=(left+right)//2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
if __name__ == "__main__":
n=int(input())
A=list(map(int,input().split()))
merge_sort(A,0,n)
print(count)
``` | output | 1 | 55,573 | 12 | 111,147 |
Provide a correct Python 3 solution for this coding contest problem.
For a given sequence $A = \\{a_0, a_1, ... a_{n-1}\\}$, the number of pairs $(i, j)$ where $a_i > a_j$ and $i < j$, is called the number of inversions. The number of inversions is equal to the number of swaps of Bubble Sort defined in the following program:
bubbleSort(A)
cnt = 0 // the number of inversions
for i = 0 to A.length-1
for j = A.length-1 downto i+1
if A[j] < A[j-1]
swap(A[j], A[j-1])
cnt++
return cnt
For the given sequence $A$, print the number of inversions of $A$. Note that you should not use the above program, which brings Time Limit Exceeded.
Constraints
* $ 1 \leq n \leq 200,000$
* $ 0 \leq a_i \leq 10^9$
* $a_i$ are all different
Input
In the first line, an integer $n$, the number of elements in $A$, is given. In the second line, the elements $a_i$ ($i = 0, 1, .. n-1$) are given separated by space characters.
Examples
Input
5
3 5 2 1 4
Output
6
Input
3
3 1 2
Output
2 | instruction | 0 | 55,574 | 12 | 111,148 |
"Correct Solution:
```
def merge(A, l, m, r):
cnt = 0
n1 = m-l
n2 = r-m
L = A[l:m]
L.append(float("inf"))
R = A[m:r]
R.append(float("inf"))
i_l, i_r = 0, 0
for k in range(l, r):
if L[i_l] <= R[i_r]:
A[k] = L[i_l]
i_l += 1
else:
A[k] = R[i_r]
i_r += 1
cnt += n1 - i_l
return cnt
def merge_sort(A, l, r):
if l + 1 >= r:
return 0
m = (l+r)//2
ans1 = merge_sort(A, l, m)
ans2 = merge_sort(A, m, r)
ans3 = merge(A, l, m, r)
return ans1 + ans2 + ans3
n = int(input())
A = list(map(int, input().split()))
print(merge_sort(A, 0, n))
``` | output | 1 | 55,574 | 12 | 111,149 |
Provide a correct Python 3 solution for this coding contest problem.
For a given sequence $A = \\{a_0, a_1, ... a_{n-1}\\}$, the number of pairs $(i, j)$ where $a_i > a_j$ and $i < j$, is called the number of inversions. The number of inversions is equal to the number of swaps of Bubble Sort defined in the following program:
bubbleSort(A)
cnt = 0 // the number of inversions
for i = 0 to A.length-1
for j = A.length-1 downto i+1
if A[j] < A[j-1]
swap(A[j], A[j-1])
cnt++
return cnt
For the given sequence $A$, print the number of inversions of $A$. Note that you should not use the above program, which brings Time Limit Exceeded.
Constraints
* $ 1 \leq n \leq 200,000$
* $ 0 \leq a_i \leq 10^9$
* $a_i$ are all different
Input
In the first line, an integer $n$, the number of elements in $A$, is given. In the second line, the elements $a_i$ ($i = 0, 1, .. n-1$) are given separated by space characters.
Examples
Input
5
3 5 2 1 4
Output
6
Input
3
3 1 2
Output
2 | instruction | 0 | 55,575 | 12 | 111,150 |
"Correct Solution:
```
INF = int(1e9)
def merge(A, left, mid, right):
n1 = mid - left
n2 = right - mid
n = len(A)
L = A[left:mid] + [INF]
R = A[mid:right] + [INF]
i = 0
j = 0
cnt = 0
for k in range(left, right):
if L[i] <= R[j]:
A[k] = L[i]
i = i + 1
else:
A[k] = R[j]
j = j + 1
cnt = cnt + n1 - i
return cnt
def mergeSort(A, left, right):
if left+1 < right:
mid = (left+right)//2
cnt1 = mergeSort(A, left, mid)
cnt2 = mergeSort(A, mid, right)
cnt3 = merge(A, left, mid, right)
return (cnt1 + cnt2 + cnt3)
else:
return 0
def main():
n = int(input())
a = [int(i) for i in input().split()]
ans = mergeSort(a, 0, n)
print(ans)
main()
``` | output | 1 | 55,575 | 12 | 111,151 |
Provide a correct Python 3 solution for this coding contest problem.
For a given sequence $A = \\{a_0, a_1, ... a_{n-1}\\}$, the number of pairs $(i, j)$ where $a_i > a_j$ and $i < j$, is called the number of inversions. The number of inversions is equal to the number of swaps of Bubble Sort defined in the following program:
bubbleSort(A)
cnt = 0 // the number of inversions
for i = 0 to A.length-1
for j = A.length-1 downto i+1
if A[j] < A[j-1]
swap(A[j], A[j-1])
cnt++
return cnt
For the given sequence $A$, print the number of inversions of $A$. Note that you should not use the above program, which brings Time Limit Exceeded.
Constraints
* $ 1 \leq n \leq 200,000$
* $ 0 \leq a_i \leq 10^9$
* $a_i$ are all different
Input
In the first line, an integer $n$, the number of elements in $A$, is given. In the second line, the elements $a_i$ ($i = 0, 1, .. n-1$) are given separated by space characters.
Examples
Input
5
3 5 2 1 4
Output
6
Input
3
3 1 2
Output
2 | instruction | 0 | 55,576 | 12 | 111,152 |
"Correct Solution:
```
INF = float("inf")
cnt = 0
def merge(A, left, mid, right):
global cnt
L = A[left: mid] + [INF]
R = A[mid: right] + [INF]
i = j = 0
limit = mid - left
for k in range(left, right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
cnt += limit - i
A[k] = R[j]
j += 1
def mergeSort(A, left, right):
if left + 1 < right:
mid = (left + right) // 2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
n = int(input())
S = list(map(int, input().split()))
mergeSort(S, 0, n)
print(cnt)
``` | output | 1 | 55,576 | 12 | 111,153 |
Provide a correct Python 3 solution for this coding contest problem.
For a given sequence $A = \\{a_0, a_1, ... a_{n-1}\\}$, the number of pairs $(i, j)$ where $a_i > a_j$ and $i < j$, is called the number of inversions. The number of inversions is equal to the number of swaps of Bubble Sort defined in the following program:
bubbleSort(A)
cnt = 0 // the number of inversions
for i = 0 to A.length-1
for j = A.length-1 downto i+1
if A[j] < A[j-1]
swap(A[j], A[j-1])
cnt++
return cnt
For the given sequence $A$, print the number of inversions of $A$. Note that you should not use the above program, which brings Time Limit Exceeded.
Constraints
* $ 1 \leq n \leq 200,000$
* $ 0 \leq a_i \leq 10^9$
* $a_i$ are all different
Input
In the first line, an integer $n$, the number of elements in $A$, is given. In the second line, the elements $a_i$ ($i = 0, 1, .. n-1$) are given separated by space characters.
Examples
Input
5
3 5 2 1 4
Output
6
Input
3
3 1 2
Output
2 | instruction | 0 | 55,577 | 12 | 111,154 |
"Correct Solution:
```
def merge(A, left, mid, right):
global cnt
n1 = mid - left
n2 = right - mid
L = A[left:mid] + [INF]
R = A[mid:right] + [INF]
i = 0
j = 0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i = i + 1
else:
A[k] = R[j]
j = j + 1
cnt += mid - left - i
def mergeSort(A, left, right):
if left + 1 < right:
mid = (left + right)//2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
INF = 10000000000
n = int(input())
A = list(map(int,input().split()))
cnt = 0
mergeSort(A,0,n)
print(cnt)
``` | output | 1 | 55,577 | 12 | 111,155 |
Provide a correct Python 3 solution for this coding contest problem.
For a given sequence $A = \\{a_0, a_1, ... a_{n-1}\\}$, the number of pairs $(i, j)$ where $a_i > a_j$ and $i < j$, is called the number of inversions. The number of inversions is equal to the number of swaps of Bubble Sort defined in the following program:
bubbleSort(A)
cnt = 0 // the number of inversions
for i = 0 to A.length-1
for j = A.length-1 downto i+1
if A[j] < A[j-1]
swap(A[j], A[j-1])
cnt++
return cnt
For the given sequence $A$, print the number of inversions of $A$. Note that you should not use the above program, which brings Time Limit Exceeded.
Constraints
* $ 1 \leq n \leq 200,000$
* $ 0 \leq a_i \leq 10^9$
* $a_i$ are all different
Input
In the first line, an integer $n$, the number of elements in $A$, is given. In the second line, the elements $a_i$ ($i = 0, 1, .. n-1$) are given separated by space characters.
Examples
Input
5
3 5 2 1 4
Output
6
Input
3
3 1 2
Output
2 | instruction | 0 | 55,578 | 12 | 111,156 |
"Correct Solution:
```
import sys
MAX = 2*10**5
SENTINEL = 2*10**9
L = [0]*(MAX//2 + 2)
R = [0]*(MAX//2 + 2)
def Merge(A,n,left,mid,right):
cnt = 0
n1 = mid - left
n2 = right - mid
for i in range(n1):
L[i] = A[left + i]
for i in range(n2):
R[i] = A[mid + i]
L[n1] = SENTINEL
R[n2] = SENTINEL
i,j = 0,0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i+=1
else:
A[k] = R[j]
j+=1
cnt += n1 - i
return cnt
def MergeSort(A,n,left,right):
if left + 1 < right:
mid = (left + right)//2
v1 = MergeSort(A,n,left,mid)
v2 = MergeSort(A,n,mid,right)
v3 = Merge(A,n,left,mid,right)
return v1 + v2 + v3
else:
return 0
if __name__ == "__main__":
n = int(input())
A = list(map(int,input().split()))
ans = MergeSort(A,n,0,n)
print(ans)
``` | output | 1 | 55,578 | 12 | 111,157 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a given sequence $A = \\{a_0, a_1, ... a_{n-1}\\}$, the number of pairs $(i, j)$ where $a_i > a_j$ and $i < j$, is called the number of inversions. The number of inversions is equal to the number of swaps of Bubble Sort defined in the following program:
bubbleSort(A)
cnt = 0 // the number of inversions
for i = 0 to A.length-1
for j = A.length-1 downto i+1
if A[j] < A[j-1]
swap(A[j], A[j-1])
cnt++
return cnt
For the given sequence $A$, print the number of inversions of $A$. Note that you should not use the above program, which brings Time Limit Exceeded.
Constraints
* $ 1 \leq n \leq 200,000$
* $ 0 \leq a_i \leq 10^9$
* $a_i$ are all different
Input
In the first line, an integer $n$, the number of elements in $A$, is given. In the second line, the elements $a_i$ ($i = 0, 1, .. n-1$) are given separated by space characters.
Examples
Input
5
3 5 2 1 4
Output
6
Input
3
3 1 2
Output
2
Submitted Solution:
```
count=0
def merge(A, left, mid, right):
global count
h=[]
L=A[left:mid]+[2**32]
R=A[mid:right]+[2**32]
i=0
j=0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
h.append(L[i])
i += 1
else:
A[k] = R[j]
h.append(R[j])
j += 1
if i < len(L)-1:
count += len(L) - 1 - i
def merge_sort(A, left, right):
if left+1 < right:
mid=(left+right)//2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
if __name__ == "__main__":
n=int(input())
A=list(map(int,input().split()))
merge_sort(A,0,n)
print(count)
``` | instruction | 0 | 55,579 | 12 | 111,158 |
Yes | output | 1 | 55,579 | 12 | 111,159 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a given sequence $A = \\{a_0, a_1, ... a_{n-1}\\}$, the number of pairs $(i, j)$ where $a_i > a_j$ and $i < j$, is called the number of inversions. The number of inversions is equal to the number of swaps of Bubble Sort defined in the following program:
bubbleSort(A)
cnt = 0 // the number of inversions
for i = 0 to A.length-1
for j = A.length-1 downto i+1
if A[j] < A[j-1]
swap(A[j], A[j-1])
cnt++
return cnt
For the given sequence $A$, print the number of inversions of $A$. Note that you should not use the above program, which brings Time Limit Exceeded.
Constraints
* $ 1 \leq n \leq 200,000$
* $ 0 \leq a_i \leq 10^9$
* $a_i$ are all different
Input
In the first line, an integer $n$, the number of elements in $A$, is given. In the second line, the elements $a_i$ ($i = 0, 1, .. n-1$) are given separated by space characters.
Examples
Input
5
3 5 2 1 4
Output
6
Input
3
3 1 2
Output
2
Submitted Solution:
```
count=0
def merge(A,left,mid,right):
global count
L=A[left:mid]+[10**9+1]
R=A[mid:right]+[10**9+1]
i=0
j=0
for k in range(left,right):
if L[i]<R[j]:
A[k]=L[i]
i+=1
else:
A[k]=R[j]
j+=1
count+=(mid-left-i)
def mergeSort(A,left,right):
if left+1<right:
mid=(left+right)//2
mergeSort(A,left,mid)
mergeSort(A,mid,right)
merge(A,left,mid,right)
n=int(input())
S=[int(i) for i in input().split()]
mergeSort(S,0,n)
print(count)
``` | instruction | 0 | 55,580 | 12 | 111,160 |
Yes | output | 1 | 55,580 | 12 | 111,161 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a given sequence $A = \\{a_0, a_1, ... a_{n-1}\\}$, the number of pairs $(i, j)$ where $a_i > a_j$ and $i < j$, is called the number of inversions. The number of inversions is equal to the number of swaps of Bubble Sort defined in the following program:
bubbleSort(A)
cnt = 0 // the number of inversions
for i = 0 to A.length-1
for j = A.length-1 downto i+1
if A[j] < A[j-1]
swap(A[j], A[j-1])
cnt++
return cnt
For the given sequence $A$, print the number of inversions of $A$. Note that you should not use the above program, which brings Time Limit Exceeded.
Constraints
* $ 1 \leq n \leq 200,000$
* $ 0 \leq a_i \leq 10^9$
* $a_i$ are all different
Input
In the first line, an integer $n$, the number of elements in $A$, is given. In the second line, the elements $a_i$ ($i = 0, 1, .. n-1$) are given separated by space characters.
Examples
Input
5
3 5 2 1 4
Output
6
Input
3
3 1 2
Output
2
Submitted Solution:
```
import sys
readline = sys.stdin.readline
write = sys.stdout.write
N = int(readline())
*A, = map(int, readline().split())
data = [0]*(N+1)
def add(k, v):
while k <= N:
data[k] += v
k += k & -k
def get(k):
s = 0
while k:
s += data[k]
k -= k & -k
return s
ans = N*(N-1)//2
for a in map({a: i+1 for i, a in enumerate(sorted(A))}.__getitem__, A):
ans -= get(a)
add(a, 1)
write("%d\n" % ans)
``` | instruction | 0 | 55,581 | 12 | 111,162 |
Yes | output | 1 | 55,581 | 12 | 111,163 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a given sequence $A = \\{a_0, a_1, ... a_{n-1}\\}$, the number of pairs $(i, j)$ where $a_i > a_j$ and $i < j$, is called the number of inversions. The number of inversions is equal to the number of swaps of Bubble Sort defined in the following program:
bubbleSort(A)
cnt = 0 // the number of inversions
for i = 0 to A.length-1
for j = A.length-1 downto i+1
if A[j] < A[j-1]
swap(A[j], A[j-1])
cnt++
return cnt
For the given sequence $A$, print the number of inversions of $A$. Note that you should not use the above program, which brings Time Limit Exceeded.
Constraints
* $ 1 \leq n \leq 200,000$
* $ 0 \leq a_i \leq 10^9$
* $a_i$ are all different
Input
In the first line, an integer $n$, the number of elements in $A$, is given. In the second line, the elements $a_i$ ($i = 0, 1, .. n-1$) are given separated by space characters.
Examples
Input
5
3 5 2 1 4
Output
6
Input
3
3 1 2
Output
2
Submitted Solution:
```
INF=1000000005
def merge(a,right,mid,left):
r=a[right:mid]
l=a[mid:left]
i=0
j=0
q=mid-right
r.append(INF)
l.append(INF)
cnt=0
while i+j!=left-right:
if r[i]>l[j]:
a[right+i+j]=l[j]
j+=1
cnt+=q-i
else:
a[right+i+j]=r[i]
i+=1
return cnt
def mergesort(a,right,left):
if right+1<left:
mid=(right+left)//2
v1=mergesort(a,right,mid)
v2=mergesort(a,mid,left)
v3=merge(a,right,mid,left)
return v1+v2+v3
else:
return 0
n=int(input())
a=list(map(int,input().split()))
ans=mergesort(a,0,n)
print(ans)
``` | instruction | 0 | 55,582 | 12 | 111,164 |
Yes | output | 1 | 55,582 | 12 | 111,165 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a given sequence $A = \\{a_0, a_1, ... a_{n-1}\\}$, the number of pairs $(i, j)$ where $a_i > a_j$ and $i < j$, is called the number of inversions. The number of inversions is equal to the number of swaps of Bubble Sort defined in the following program:
bubbleSort(A)
cnt = 0 // the number of inversions
for i = 0 to A.length-1
for j = A.length-1 downto i+1
if A[j] < A[j-1]
swap(A[j], A[j-1])
cnt++
return cnt
For the given sequence $A$, print the number of inversions of $A$. Note that you should not use the above program, which brings Time Limit Exceeded.
Constraints
* $ 1 \leq n \leq 200,000$
* $ 0 \leq a_i \leq 10^9$
* $a_i$ are all different
Input
In the first line, an integer $n$, the number of elements in $A$, is given. In the second line, the elements $a_i$ ($i = 0, 1, .. n-1$) are given separated by space characters.
Examples
Input
5
3 5 2 1 4
Output
6
Input
3
3 1 2
Output
2
Submitted Solution:
```
n = int(input())
a = list(map(int,input().split()))
flag = 1
count = 0
while flag:
flag = 0
for i in range(n-1):
if a[i] > a[i+1]:
a[i], a[i+1] = a[i+1], a[i]
count += 1
flag = 1
print(count)
``` | instruction | 0 | 55,583 | 12 | 111,166 |
No | output | 1 | 55,583 | 12 | 111,167 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a given sequence $A = \\{a_0, a_1, ... a_{n-1}\\}$, the number of pairs $(i, j)$ where $a_i > a_j$ and $i < j$, is called the number of inversions. The number of inversions is equal to the number of swaps of Bubble Sort defined in the following program:
bubbleSort(A)
cnt = 0 // the number of inversions
for i = 0 to A.length-1
for j = A.length-1 downto i+1
if A[j] < A[j-1]
swap(A[j], A[j-1])
cnt++
return cnt
For the given sequence $A$, print the number of inversions of $A$. Note that you should not use the above program, which brings Time Limit Exceeded.
Constraints
* $ 1 \leq n \leq 200,000$
* $ 0 \leq a_i \leq 10^9$
* $a_i$ are all different
Input
In the first line, an integer $n$, the number of elements in $A$, is given. In the second line, the elements $a_i$ ($i = 0, 1, .. n-1$) are given separated by space characters.
Examples
Input
5
3 5 2 1 4
Output
6
Input
3
3 1 2
Output
2
Submitted Solution:
```
def bubble(array):
cnt = 0
for i in range(len(array)):
for j in range(len(array) - 1, i, -1):
if array[j] < array[j-1]:
array[j], array[j-1] = array[j-1], array[j]
cnt += 1
return cnt
n = int(input())
array = [int(x) for x in input().split()]
print(bubble(array))
``` | instruction | 0 | 55,584 | 12 | 111,168 |
No | output | 1 | 55,584 | 12 | 111,169 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a given sequence $A = \\{a_0, a_1, ... a_{n-1}\\}$, the number of pairs $(i, j)$ where $a_i > a_j$ and $i < j$, is called the number of inversions. The number of inversions is equal to the number of swaps of Bubble Sort defined in the following program:
bubbleSort(A)
cnt = 0 // the number of inversions
for i = 0 to A.length-1
for j = A.length-1 downto i+1
if A[j] < A[j-1]
swap(A[j], A[j-1])
cnt++
return cnt
For the given sequence $A$, print the number of inversions of $A$. Note that you should not use the above program, which brings Time Limit Exceeded.
Constraints
* $ 1 \leq n \leq 200,000$
* $ 0 \leq a_i \leq 10^9$
* $a_i$ are all different
Input
In the first line, an integer $n$, the number of elements in $A$, is given. In the second line, the elements $a_i$ ($i = 0, 1, .. n-1$) are given separated by space characters.
Examples
Input
5
3 5 2 1 4
Output
6
Input
3
3 1 2
Output
2
Submitted Solution:
```
from bisect import bisect_left
def count_inversion(A):
cnt = 0
L = len(A)
for i in reversed(range(L - 1)):
j = bisect_left(A, A[i], i + 1, L)
cnt += j - i - 1
tmp = A[i]
del A[i]
A.insert(j - 1, tmp)
return cnt
def main():
n = int(input())
A = [int(x) for x in input().split()]
print(count_inversion(A))
main()
``` | instruction | 0 | 55,585 | 12 | 111,170 |
No | output | 1 | 55,585 | 12 | 111,171 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For a given sequence $A = \\{a_0, a_1, ... a_{n-1}\\}$, the number of pairs $(i, j)$ where $a_i > a_j$ and $i < j$, is called the number of inversions. The number of inversions is equal to the number of swaps of Bubble Sort defined in the following program:
bubbleSort(A)
cnt = 0 // the number of inversions
for i = 0 to A.length-1
for j = A.length-1 downto i+1
if A[j] < A[j-1]
swap(A[j], A[j-1])
cnt++
return cnt
For the given sequence $A$, print the number of inversions of $A$. Note that you should not use the above program, which brings Time Limit Exceeded.
Constraints
* $ 1 \leq n \leq 200,000$
* $ 0 \leq a_i \leq 10^9$
* $a_i$ are all different
Input
In the first line, an integer $n$, the number of elements in $A$, is given. In the second line, the elements $a_i$ ($i = 0, 1, .. n-1$) are given separated by space characters.
Examples
Input
5
3 5 2 1 4
Output
6
Input
3
3 1 2
Output
2
Submitted Solution:
```
# 16D8101012J ItoJun dj Python3
count=0
def merge(A, left, mid, right):
global count
L=A[left:mid]+[2**32]
R=A[mid:right]+[2**32]
i=0
j=0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
count+=1
else:
A[k] = R[j]
j += 1
def merge_sort(A, left, right):
if left+1 < right:
mid=(left+right)//2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
if __name__ == "__main__":
n=int(input())
A=list(map(int,input().split()))
merge_sort(A,0,n)
print(count)
``` | instruction | 0 | 55,586 | 12 | 111,172 |
No | output | 1 | 55,586 | 12 | 111,173 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given two integers n and x, construct an array that satisfies the following conditions:
* for any element a_i in the array, 1 ≤ a_i<2^n;
* there is no non-empty subsegment with [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) equal to 0 or x,
* its length l should be maximized.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
The only line contains two integers n and x (1 ≤ n ≤ 18, 1 ≤ x<2^{18}).
Output
The first line should contain the length of the array l.
If l is positive, the second line should contain l space-separated integers a_1, a_2, ..., a_l (1 ≤ a_i < 2^n) — the elements of the array a.
If there are multiple solutions, print any of them.
Examples
Input
3 5
Output
3
6 1 3
Input
2 4
Output
3
1 3 1
Input
1 1
Output
0
Note
In the first example, the bitwise XOR of the subsegments are \{6,7,4,1,2,3\}. | instruction | 0 | 55,666 | 12 | 111,332 |
Tags: bitmasks, constructive algorithms
Correct Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
#threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
#sys.setrecursionlimit(300000)
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")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=2**30, func=lambda a, b: min(a , b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b:a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] < key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] > k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
class TrieNode:
def __init__(self):
self.children = [None] * 26
self.isEndOfWord = False
class Trie:
def __init__(self):
self.root = self.getNode()
def getNode(self):
return TrieNode()
def _charToIndex(self, ch):
return ord(ch) - ord('a')
def insert(self, key):
pCrawl = self.root
length = len(key)
for level in range(length):
index = self._charToIndex(key[level])
if not pCrawl.children[index]:
pCrawl.children[index] = self.getNode()
pCrawl = pCrawl.children[index]
pCrawl.isEndOfWord = True
def search(self, key):
pCrawl = self.root
length = len(key)
for level in range(length):
index = self._charToIndex(key[level])
if not pCrawl.children[index]:
return False
pCrawl = pCrawl.children[index]
return pCrawl != None and pCrawl.isEndOfWord
#-----------------------------------------trie---------------------------------
class Node:
def __init__(self, data):
self.data = data
self.count=0
self.left = None # left node for 0
self.right = None # right node for 1
class BinaryTrie:
def __init__(self):
self.root = Node(0)
def insert(self, pre_xor):
self.temp = self.root
for i in range(31, -1, -1):
val = pre_xor & (1 << i)
if val:
if not self.temp.right:
self.temp.right = Node(0)
self.temp = self.temp.right
self.temp.count+=1
if not val:
if not self.temp.left:
self.temp.left = Node(0)
self.temp = self.temp.left
self.temp.count += 1
self.temp.data = pre_xor
def query(self, xor):
self.temp = self.root
for i in range(31, -1, -1):
val = xor & (1 << i)
if not val:
if self.temp.left and self.temp.left.count>0:
self.temp = self.temp.left
elif self.temp.right:
self.temp = self.temp.right
else:
if self.temp.right and self.temp.right.count>0:
self.temp = self.temp.right
elif self.temp.left:
self.temp = self.temp.left
self.temp.count-=1
return xor ^ self.temp.data
#-------------------------bin trie-------------------------------------------
for ik in range(1):
n,k=map(int,input().split())
done=set()
l=[]
ans=[]
for i in range(1,2**n):
if i^k not in done and i^k!=0:
l.append(i)
done.add(i)
print(len(l))
if l!=[]:
ans.append(l[0])
for i in range(1,len(l)):
ans.append(l[i]^l[i-1])
print(*ans)
``` | output | 1 | 55,666 | 12 | 111,333 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given two integers n and x, construct an array that satisfies the following conditions:
* for any element a_i in the array, 1 ≤ a_i<2^n;
* there is no non-empty subsegment with [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) equal to 0 or x,
* its length l should be maximized.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
The only line contains two integers n and x (1 ≤ n ≤ 18, 1 ≤ x<2^{18}).
Output
The first line should contain the length of the array l.
If l is positive, the second line should contain l space-separated integers a_1, a_2, ..., a_l (1 ≤ a_i < 2^n) — the elements of the array a.
If there are multiple solutions, print any of them.
Examples
Input
3 5
Output
3
6 1 3
Input
2 4
Output
3
1 3 1
Input
1 1
Output
0
Note
In the first example, the bitwise XOR of the subsegments are \{6,7,4,1,2,3\}. | instruction | 0 | 55,667 | 12 | 111,334 |
Tags: bitmasks, constructive algorithms
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
import sys
from io import BytesIO, IOBase
def main():
n,x=map(int,input().split())
ans=[0]
for i in range(1,pow(2,n)):
if i^x>i:
ans.append(i)
print(len(ans)-1)
for i in range(1,len(ans)):
print(ans[i]^ans[i-1],end=" ")
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | output | 1 | 55,667 | 12 | 111,335 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given two integers n and x, construct an array that satisfies the following conditions:
* for any element a_i in the array, 1 ≤ a_i<2^n;
* there is no non-empty subsegment with [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) equal to 0 or x,
* its length l should be maximized.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
The only line contains two integers n and x (1 ≤ n ≤ 18, 1 ≤ x<2^{18}).
Output
The first line should contain the length of the array l.
If l is positive, the second line should contain l space-separated integers a_1, a_2, ..., a_l (1 ≤ a_i < 2^n) — the elements of the array a.
If there are multiple solutions, print any of them.
Examples
Input
3 5
Output
3
6 1 3
Input
2 4
Output
3
1 3 1
Input
1 1
Output
0
Note
In the first example, the bitwise XOR of the subsegments are \{6,7,4,1,2,3\}. | instruction | 0 | 55,668 | 12 | 111,336 |
Tags: bitmasks, constructive algorithms
Correct Solution:
```
'''
Auther: ghoshashis545 Ashis Ghosh
College: Jalpaiguri Govt Enggineering College
'''
from os import path
from io import BytesIO, IOBase
import sys
from heapq import heappush,heappop
from functools import cmp_to_key as ctk
from collections import deque,Counter,defaultdict as dd
from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
from itertools import permutations
from datetime import datetime
from math import ceil,sqrt,log,gcd
def ii():return int(input())
def si():return input().rstrip()
def mi():return map(int,input().split())
def li():return list(mi())
abc='abcdefghijklmnopqrstuvwxyz'
mod=1000000007
#mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def bo(i):
return ord(i)-ord('0')
file = 1
def ceil(a,b):
return (a+b-1)//b
def solve():
# for _ in range(1,ii()+1):
n,x = mi()
m = {}
pre = []
# we have to check pre array does not contain any two index (l,r) such that
# pre[l]^pre[r] = 0 or x.
# If it's present that meanse a[l+1],a[l+2],...a[r] = 0 or x.
# that violate the given conditions.
for i in range(1,1<<n):
if i == x:
continue
if i^x not in m:
pre.append(i)
m[i] = 1
if len(pre) == 0:
print(0)
return
a = [0]*len(pre)
a[0] = pre[0]
for i in range(1,len(pre)):
a[i] = pre[i]^pre[i-1]
print(len(a))
print(*a)
if __name__ =="__main__":
if(file):
if path.exists('input.txt'):
sys.stdin=open('input.txt', 'r')
sys.stdout=open('output.txt','w')
else:
input=sys.stdin.readline
solve()
``` | output | 1 | 55,668 | 12 | 111,337 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given two integers n and x, construct an array that satisfies the following conditions:
* for any element a_i in the array, 1 ≤ a_i<2^n;
* there is no non-empty subsegment with [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) equal to 0 or x,
* its length l should be maximized.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
The only line contains two integers n and x (1 ≤ n ≤ 18, 1 ≤ x<2^{18}).
Output
The first line should contain the length of the array l.
If l is positive, the second line should contain l space-separated integers a_1, a_2, ..., a_l (1 ≤ a_i < 2^n) — the elements of the array a.
If there are multiple solutions, print any of them.
Examples
Input
3 5
Output
3
6 1 3
Input
2 4
Output
3
1 3 1
Input
1 1
Output
0
Note
In the first example, the bitwise XOR of the subsegments are \{6,7,4,1,2,3\}. | instruction | 0 | 55,669 | 12 | 111,338 |
Tags: bitmasks, constructive algorithms
Correct Solution:
```
def gns():
return [int(x) for x in input().split()]
n,x=gns()
# if len(str(x))>n:
# n+=1
if n==1:
if x==1:
print(0)
quit()
print(1)
print(1)
quit()
b=len(bin(x))-2
if x!=1:
ans=[1]
else:
ans=[2]
cur=1
for i in range(n-2):
if cur==b-1:
cur+=1
ans=ans+[1<<cur]+ans
cur+=1
if x>=(1<<n):
ans=ans+[1<<cur]+ans
# y=((1<<n)-1)^x
y=x
# if x<(1<<n) and (x+1)!=(1<<n):
# ans=[c^y for c in ans]
print(len(ans))
print(' '.join(map(str,ans)))
``` | output | 1 | 55,669 | 12 | 111,339 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given two integers n and x, construct an array that satisfies the following conditions:
* for any element a_i in the array, 1 ≤ a_i<2^n;
* there is no non-empty subsegment with [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) equal to 0 or x,
* its length l should be maximized.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
The only line contains two integers n and x (1 ≤ n ≤ 18, 1 ≤ x<2^{18}).
Output
The first line should contain the length of the array l.
If l is positive, the second line should contain l space-separated integers a_1, a_2, ..., a_l (1 ≤ a_i < 2^n) — the elements of the array a.
If there are multiple solutions, print any of them.
Examples
Input
3 5
Output
3
6 1 3
Input
2 4
Output
3
1 3 1
Input
1 1
Output
0
Note
In the first example, the bitwise XOR of the subsegments are \{6,7,4,1,2,3\}. | instruction | 0 | 55,670 | 12 | 111,340 |
Tags: bitmasks, constructive algorithms
Correct Solution:
```
n,x=map(int,input().split())
a=[True for i in range(pow(2,n))]
check=[]
if x < pow(2,n):
a[x]=False
for i in range(1,pow(2,n)):
if a[i]==True:
check.append(i)
if x^i < pow(2,n):
a[x^i]=False
print(len(check))
#print (check)
if len(check)==1:
print( check[0])
elif len(check) > 1:
print(check[0],end=" ")
for i in range(1,len(check)):
print(check[i-1]^check[i],end=" ")
``` | output | 1 | 55,670 | 12 | 111,341 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given two integers n and x, construct an array that satisfies the following conditions:
* for any element a_i in the array, 1 ≤ a_i<2^n;
* there is no non-empty subsegment with [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) equal to 0 or x,
* its length l should be maximized.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
The only line contains two integers n and x (1 ≤ n ≤ 18, 1 ≤ x<2^{18}).
Output
The first line should contain the length of the array l.
If l is positive, the second line should contain l space-separated integers a_1, a_2, ..., a_l (1 ≤ a_i < 2^n) — the elements of the array a.
If there are multiple solutions, print any of them.
Examples
Input
3 5
Output
3
6 1 3
Input
2 4
Output
3
1 3 1
Input
1 1
Output
0
Note
In the first example, the bitwise XOR of the subsegments are \{6,7,4,1,2,3\}. | instruction | 0 | 55,671 | 12 | 111,342 |
Tags: bitmasks, constructive algorithms
Correct Solution:
```
n , x = map(int,input().split())
mark = [0 for x in range(1 << 18 +1)]
mark[x] = 1
cur = 0
MAXN = 1 << n
ans = []
for i in range(1 , MAXN):
if i != x:
res = i ^ x
if mark[i] == 0:
ans.append(i^cur)
mark[res] = 1
mark[i] = 1
cur = i
print(len(ans))
print(*ans)
``` | output | 1 | 55,671 | 12 | 111,343 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given two integers n and x, construct an array that satisfies the following conditions:
* for any element a_i in the array, 1 ≤ a_i<2^n;
* there is no non-empty subsegment with [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) equal to 0 or x,
* its length l should be maximized.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
The only line contains two integers n and x (1 ≤ n ≤ 18, 1 ≤ x<2^{18}).
Output
The first line should contain the length of the array l.
If l is positive, the second line should contain l space-separated integers a_1, a_2, ..., a_l (1 ≤ a_i < 2^n) — the elements of the array a.
If there are multiple solutions, print any of them.
Examples
Input
3 5
Output
3
6 1 3
Input
2 4
Output
3
1 3 1
Input
1 1
Output
0
Note
In the first example, the bitwise XOR of the subsegments are \{6,7,4,1,2,3\}. | instruction | 0 | 55,672 | 12 | 111,344 |
Tags: bitmasks, constructive algorithms
Correct Solution:
```
n, x = map(int, input().split())
t = 2 ** n
ans = [0]
if x >= t:
ans = [*range(t)]
else:
c = set([0])
for i in range(1, t):
if i ^ x in c:
continue
ans.append(i)
c.add(i)
print(len(ans) - 1)
print(*[ans[i] ^ ans[i - 1] for i in range(1, len(ans))])
``` | output | 1 | 55,672 | 12 | 111,345 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given two integers n and x, construct an array that satisfies the following conditions:
* for any element a_i in the array, 1 ≤ a_i<2^n;
* there is no non-empty subsegment with [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) equal to 0 or x,
* its length l should be maximized.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
The only line contains two integers n and x (1 ≤ n ≤ 18, 1 ≤ x<2^{18}).
Output
The first line should contain the length of the array l.
If l is positive, the second line should contain l space-separated integers a_1, a_2, ..., a_l (1 ≤ a_i < 2^n) — the elements of the array a.
If there are multiple solutions, print any of them.
Examples
Input
3 5
Output
3
6 1 3
Input
2 4
Output
3
1 3 1
Input
1 1
Output
0
Note
In the first example, the bitwise XOR of the subsegments are \{6,7,4,1,2,3\}. | instruction | 0 | 55,673 | 12 | 111,346 |
Tags: bitmasks, constructive algorithms
Correct Solution:
```
n, x = map(int, input().split())
res = []
s = {x}
prev = 0
for i in range(1, 1 << n):
curr = prev ^ i
if curr in s: continue
res.append(curr)
prev = i
s.add(x ^ i)
print(len(res))
print(*res)
``` | output | 1 | 55,673 | 12 | 111,347 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given two integers n and x, construct an array that satisfies the following conditions:
* for any element a_i in the array, 1 ≤ a_i<2^n;
* there is no non-empty subsegment with [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) equal to 0 or x,
* its length l should be maximized.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
The only line contains two integers n and x (1 ≤ n ≤ 18, 1 ≤ x<2^{18}).
Output
The first line should contain the length of the array l.
If l is positive, the second line should contain l space-separated integers a_1, a_2, ..., a_l (1 ≤ a_i < 2^n) — the elements of the array a.
If there are multiple solutions, print any of them.
Examples
Input
3 5
Output
3
6 1 3
Input
2 4
Output
3
1 3 1
Input
1 1
Output
0
Note
In the first example, the bitwise XOR of the subsegments are \{6,7,4,1,2,3\}.
Submitted Solution:
```
from functools import lru_cache
@lru_cache(maxsize=100000)
def rec(n):
if n <= 0:
return []
if n == 1:
return [1]
l = rec(n - 1)
return l + [2 ** (n - 1)] + l
n, x = map(int,input().split())
l = []
if x >= 2 ** n:
l = rec(n)
else:
l = rec(n - 1)
b = len(bin(x))
for i, j in enumerate(l):
c = len(bin(j))
if c >= b:
l[i] *= 2
print(len(l))
if len(l) != 0:
print(*l)
``` | instruction | 0 | 55,675 | 12 | 111,350 |
Yes | output | 1 | 55,675 | 12 | 111,351 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given two integers n and x, construct an array that satisfies the following conditions:
* for any element a_i in the array, 1 ≤ a_i<2^n;
* there is no non-empty subsegment with [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) equal to 0 or x,
* its length l should be maximized.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
The only line contains two integers n and x (1 ≤ n ≤ 18, 1 ≤ x<2^{18}).
Output
The first line should contain the length of the array l.
If l is positive, the second line should contain l space-separated integers a_1, a_2, ..., a_l (1 ≤ a_i < 2^n) — the elements of the array a.
If there are multiple solutions, print any of them.
Examples
Input
3 5
Output
3
6 1 3
Input
2 4
Output
3
1 3 1
Input
1 1
Output
0
Note
In the first example, the bitwise XOR of the subsegments are \{6,7,4,1,2,3\}.
Submitted Solution:
```
n,x=map(int,input().split())
binval=bin(x)[2:]
arr=[]
if(len(binval)>n):
size=n
while(size>0):
for i in range(size):
arr.append(2**i)
size-=1
else:
if(x%2!=0):
size=n
while(size>1):
for i in range(1,size):
arr.append(2**i)
size-=1
else:
index=-1
binval=binval[::-1]
for i in range(len(binval)):
if(binval[i]=='1'):
index=i
break
size=n
while(size>0):
for i in range(size):
if(i!=index):
arr.append(2**i)
size-=1
if(size==index):
size-=1
print(len(arr))
if(len(arr)>0):
print(*arr)
``` | instruction | 0 | 55,678 | 12 | 111,356 |
No | output | 1 | 55,678 | 12 | 111,357 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given two integers n and x, construct an array that satisfies the following conditions:
* for any element a_i in the array, 1 ≤ a_i<2^n;
* there is no non-empty subsegment with [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) equal to 0 or x,
* its length l should be maximized.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
The only line contains two integers n and x (1 ≤ n ≤ 18, 1 ≤ x<2^{18}).
Output
The first line should contain the length of the array l.
If l is positive, the second line should contain l space-separated integers a_1, a_2, ..., a_l (1 ≤ a_i < 2^n) — the elements of the array a.
If there are multiple solutions, print any of them.
Examples
Input
3 5
Output
3
6 1 3
Input
2 4
Output
3
1 3 1
Input
1 1
Output
0
Note
In the first example, the bitwise XOR of the subsegments are \{6,7,4,1,2,3\}.
Submitted Solution:
```
n, x = map(int, input().split())
l = []
seen = set()
for i in range(1, 2**n):
if i not in seen and x^i not in seen and i != x:
l.append(i)
seen.add(i)
seen.add(x^i)
print(len(l))
print(*l)
``` | instruction | 0 | 55,679 | 12 | 111,358 |
No | output | 1 | 55,679 | 12 | 111,359 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We start with a permutation a_1, a_2, …, a_n and with an empty array b. We apply the following operation k times.
On the i-th iteration, we select an index t_i (1 ≤ t_i ≤ n-i+1), remove a_{t_i} from the array, and append one of the numbers a_{t_i-1} or a_{t_i+1} (if t_i-1 or t_i+1 are within the array bounds) to the right end of the array b. Then we move elements a_{t_i+1}, …, a_n to the left in order to fill in the empty space.
You are given the initial permutation a_1, a_2, …, a_n and the resulting array b_1, b_2, …, b_k. All elements of an array b are distinct. Calculate the number of possible sequences of indices t_1, t_2, …, t_k modulo 998 244 353.
Input
Each test contains multiple test cases. The first line contains an integer t (1 ≤ t ≤ 100 000), denoting the number of test cases, followed by a description of the test cases.
The first line of each test case contains two integers n, k (1 ≤ k < n ≤ 200 000): sizes of arrays a and b.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n): elements of a. All elements of a are distinct.
The third line of each test case contains k integers b_1, b_2, …, b_k (1 ≤ b_i ≤ n): elements of b. All elements of b are distinct.
The sum of all n among all test cases is guaranteed to not exceed 200 000.
Output
For each test case print one integer: the number of possible sequences modulo 998 244 353.
Example
Input
3
5 3
1 2 3 4 5
3 2 5
4 3
4 3 2 1
4 3 1
7 4
1 4 7 3 6 2 5
3 2 4 5
Output
2
0
4
Note
\require{cancel}
Let's denote as a_1 a_2 … \cancel{a_i} \underline{a_{i+1}} … a_n → a_1 a_2 … a_{i-1} a_{i+1} … a_{n-1} an operation over an element with index i: removal of element a_i from array a and appending element a_{i+1} to array b.
In the first example test, the following two options can be used to produce the given array b:
* 1 2 \underline{3} \cancel{4} 5 → 1 \underline{2} \cancel{3} 5 → 1 \cancel{2} \underline{5} → 1 2; (t_1, t_2, t_3) = (4, 3, 2);
* 1 2 \underline{3} \cancel{4} 5 → \cancel{1} \underline{2} 3 5 → 2 \cancel{3} \underline{5} → 1 5; (t_1, t_2, t_3) = (4, 1, 2).
In the second example test, it is impossible to achieve the given array no matter the operations used. That's because, on the first application, we removed the element next to 4, namely number 3, which means that it couldn't be added to array b on the second step.
In the third example test, there are four options to achieve the given array b:
* 1 4 \cancel{7} \underline{3} 6 2 5 → 1 4 3 \cancel{6} \underline{2} 5 → \cancel{1} \underline{4} 3 2 5 → 4 3 \cancel{2} \underline{5} → 4 3 5;
* 1 4 \cancel{7} \underline{3} 6 2 5 → 1 4 3 \cancel{6} \underline{2} 5 → 1 \underline{4} \cancel{3} 2 5 → 1 4 \cancel{2} \underline{5} → 1 4 5;
* 1 4 7 \underline{3} \cancel{6} 2 5 → 1 4 7 \cancel{3} \underline{2} 5 → \cancel{1} \underline{4} 7 2 5 → 4 7 \cancel{2} \underline{5} → 4 7 5;
* 1 4 7 \underline{3} \cancel{6} 2 5 → 1 4 7 \cancel{3} \underline{2} 5 → 1 \underline{4} \cancel{7} 2 5 → 1 4 \cancel{2} \underline{5} → 1 4 5; | instruction | 0 | 55,780 | 12 | 111,560 |
Tags: combinatorics, data structures, dsu, greedy, implementation
Correct Solution:
```
"""
#If FastIO not needed, used this and don't forget to strip
#import sys, math
#input = sys.stdin.readline
"""
import os
import sys
from io import BytesIO, IOBase
import heapq as h
from bisect import bisect_left, bisect_right
from types import GeneratorType
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
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 = self.os.read(self._fd, max(self.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 = self.os.read(self._fd, max(self.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:
self.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")
from collections import defaultdict as dd, deque as dq
import math, string
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
MOD = 998244353
"""
Segment tree. How do we determine next lex
1 2 3 4
1 2 4 3
1 3 2 4
1 3 4 2
1 4 2 3
1 4 3 2
2 1 3 4
2 1 4 3
2 3 1 4
2 3 4 1
2 4 1 3
2 4 3 1
What is the qth permutation
"""
def solve():
ans = 1
N, K = getInts()
A = getInts()
C = []
for i, a in enumerate(A):
C.append((a,i))
C.sort()
B = getInts()
to_use = set(B)
#print(C)
for b in B:
ind = C[b-1][1]
ops = [ind+1,ind-1]
tot = 0
for op in ops:
if op < 0 or op > N-1:
continue
if A[op] not in to_use:
tot += 1
if not tot:
return 0
ans *= tot
ans %= MOD
to_use.remove(b)
#print(ans)
return ans
for _ in range(getInt()):
print(solve())
``` | output | 1 | 55,780 | 12 | 111,561 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We start with a permutation a_1, a_2, …, a_n and with an empty array b. We apply the following operation k times.
On the i-th iteration, we select an index t_i (1 ≤ t_i ≤ n-i+1), remove a_{t_i} from the array, and append one of the numbers a_{t_i-1} or a_{t_i+1} (if t_i-1 or t_i+1 are within the array bounds) to the right end of the array b. Then we move elements a_{t_i+1}, …, a_n to the left in order to fill in the empty space.
You are given the initial permutation a_1, a_2, …, a_n and the resulting array b_1, b_2, …, b_k. All elements of an array b are distinct. Calculate the number of possible sequences of indices t_1, t_2, …, t_k modulo 998 244 353.
Input
Each test contains multiple test cases. The first line contains an integer t (1 ≤ t ≤ 100 000), denoting the number of test cases, followed by a description of the test cases.
The first line of each test case contains two integers n, k (1 ≤ k < n ≤ 200 000): sizes of arrays a and b.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n): elements of a. All elements of a are distinct.
The third line of each test case contains k integers b_1, b_2, …, b_k (1 ≤ b_i ≤ n): elements of b. All elements of b are distinct.
The sum of all n among all test cases is guaranteed to not exceed 200 000.
Output
For each test case print one integer: the number of possible sequences modulo 998 244 353.
Example
Input
3
5 3
1 2 3 4 5
3 2 5
4 3
4 3 2 1
4 3 1
7 4
1 4 7 3 6 2 5
3 2 4 5
Output
2
0
4
Note
\require{cancel}
Let's denote as a_1 a_2 … \cancel{a_i} \underline{a_{i+1}} … a_n → a_1 a_2 … a_{i-1} a_{i+1} … a_{n-1} an operation over an element with index i: removal of element a_i from array a and appending element a_{i+1} to array b.
In the first example test, the following two options can be used to produce the given array b:
* 1 2 \underline{3} \cancel{4} 5 → 1 \underline{2} \cancel{3} 5 → 1 \cancel{2} \underline{5} → 1 2; (t_1, t_2, t_3) = (4, 3, 2);
* 1 2 \underline{3} \cancel{4} 5 → \cancel{1} \underline{2} 3 5 → 2 \cancel{3} \underline{5} → 1 5; (t_1, t_2, t_3) = (4, 1, 2).
In the second example test, it is impossible to achieve the given array no matter the operations used. That's because, on the first application, we removed the element next to 4, namely number 3, which means that it couldn't be added to array b on the second step.
In the third example test, there are four options to achieve the given array b:
* 1 4 \cancel{7} \underline{3} 6 2 5 → 1 4 3 \cancel{6} \underline{2} 5 → \cancel{1} \underline{4} 3 2 5 → 4 3 \cancel{2} \underline{5} → 4 3 5;
* 1 4 \cancel{7} \underline{3} 6 2 5 → 1 4 3 \cancel{6} \underline{2} 5 → 1 \underline{4} \cancel{3} 2 5 → 1 4 \cancel{2} \underline{5} → 1 4 5;
* 1 4 7 \underline{3} \cancel{6} 2 5 → 1 4 7 \cancel{3} \underline{2} 5 → \cancel{1} \underline{4} 7 2 5 → 4 7 \cancel{2} \underline{5} → 4 7 5;
* 1 4 7 \underline{3} \cancel{6} 2 5 → 1 4 7 \cancel{3} \underline{2} 5 → 1 \underline{4} \cancel{7} 2 5 → 1 4 \cancel{2} \underline{5} → 1 4 5; | instruction | 0 | 55,781 | 12 | 111,562 |
Tags: combinatorics, data structures, dsu, greedy, implementation
Correct Solution:
```
MOD = 998244353
for _ in range(int(input())):
n,k=map(int,input().split());a=[int(x) for x in input().split()];b=[int(x) for x in input().split()];pos=[0]*(n+1);ind=[-1]*(n+1);ans=1
for i in range(len(b)):pos[b[i]]=1
for i in range(len(a)):ind[a[i]]=i
for i in range(len(b)):
ptr=ind[b[i]];c=0
if((ptr-1)>=0 and pos[a[ptr-1]]==0):c=(c+1)%MOD
if((ptr+1)<n and pos[a[ptr+1]]==0):c=(c+1)%MOD
pos[a[ptr]]=0;ans=(ans*c)%MOD
print(ans)
``` | output | 1 | 55,781 | 12 | 111,563 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We start with a permutation a_1, a_2, …, a_n and with an empty array b. We apply the following operation k times.
On the i-th iteration, we select an index t_i (1 ≤ t_i ≤ n-i+1), remove a_{t_i} from the array, and append one of the numbers a_{t_i-1} or a_{t_i+1} (if t_i-1 or t_i+1 are within the array bounds) to the right end of the array b. Then we move elements a_{t_i+1}, …, a_n to the left in order to fill in the empty space.
You are given the initial permutation a_1, a_2, …, a_n and the resulting array b_1, b_2, …, b_k. All elements of an array b are distinct. Calculate the number of possible sequences of indices t_1, t_2, …, t_k modulo 998 244 353.
Input
Each test contains multiple test cases. The first line contains an integer t (1 ≤ t ≤ 100 000), denoting the number of test cases, followed by a description of the test cases.
The first line of each test case contains two integers n, k (1 ≤ k < n ≤ 200 000): sizes of arrays a and b.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n): elements of a. All elements of a are distinct.
The third line of each test case contains k integers b_1, b_2, …, b_k (1 ≤ b_i ≤ n): elements of b. All elements of b are distinct.
The sum of all n among all test cases is guaranteed to not exceed 200 000.
Output
For each test case print one integer: the number of possible sequences modulo 998 244 353.
Example
Input
3
5 3
1 2 3 4 5
3 2 5
4 3
4 3 2 1
4 3 1
7 4
1 4 7 3 6 2 5
3 2 4 5
Output
2
0
4
Note
\require{cancel}
Let's denote as a_1 a_2 … \cancel{a_i} \underline{a_{i+1}} … a_n → a_1 a_2 … a_{i-1} a_{i+1} … a_{n-1} an operation over an element with index i: removal of element a_i from array a and appending element a_{i+1} to array b.
In the first example test, the following two options can be used to produce the given array b:
* 1 2 \underline{3} \cancel{4} 5 → 1 \underline{2} \cancel{3} 5 → 1 \cancel{2} \underline{5} → 1 2; (t_1, t_2, t_3) = (4, 3, 2);
* 1 2 \underline{3} \cancel{4} 5 → \cancel{1} \underline{2} 3 5 → 2 \cancel{3} \underline{5} → 1 5; (t_1, t_2, t_3) = (4, 1, 2).
In the second example test, it is impossible to achieve the given array no matter the operations used. That's because, on the first application, we removed the element next to 4, namely number 3, which means that it couldn't be added to array b on the second step.
In the third example test, there are four options to achieve the given array b:
* 1 4 \cancel{7} \underline{3} 6 2 5 → 1 4 3 \cancel{6} \underline{2} 5 → \cancel{1} \underline{4} 3 2 5 → 4 3 \cancel{2} \underline{5} → 4 3 5;
* 1 4 \cancel{7} \underline{3} 6 2 5 → 1 4 3 \cancel{6} \underline{2} 5 → 1 \underline{4} \cancel{3} 2 5 → 1 4 \cancel{2} \underline{5} → 1 4 5;
* 1 4 7 \underline{3} \cancel{6} 2 5 → 1 4 7 \cancel{3} \underline{2} 5 → \cancel{1} \underline{4} 7 2 5 → 4 7 \cancel{2} \underline{5} → 4 7 5;
* 1 4 7 \underline{3} \cancel{6} 2 5 → 1 4 7 \cancel{3} \underline{2} 5 → 1 \underline{4} \cancel{7} 2 5 → 1 4 \cancel{2} \underline{5} → 1 4 5; | instruction | 0 | 55,782 | 12 | 111,564 |
Tags: combinatorics, data structures, dsu, greedy, implementation
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 --------------------
for s in range(int(input())):
n,k=map(int,input().split())
arra=list(map(int,input().split()))
arrb=list(map(int,input().split()))
dict1={};mod=998244353
for s in range(n):
dict1[arra[s]]=s
ans=1;enc=set(arrb)
for s in range(k):
count=0
ind=dict1[arrb[s]]
if ind>0 and not(arra[ind-1] in enc):
count+=1
if ind<n-1 and not(arra[ind+1] in enc):
count+=1
enc.remove(arrb[s])
ans*=count;ans=ans%mod
print(ans)
``` | output | 1 | 55,782 | 12 | 111,565 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.