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.
Ivan unexpectedly saw a present from one of his previous birthdays. It is array of n numbers from 1 to 200. Array is old and some numbers are hard to read. Ivan remembers that for all elements at least one of its neighbours ls not less than it, more formally:
a_{1} ≤ a_{2},
a_{n} ≤ a_{n-1} and
a_{i} ≤ max(a_{i-1}, a_{i+1}) for all i from 2 to n-1.
Ivan does not remember the array and asks to find the number of ways to restore it. Restored elements also should be integers from 1 to 200. Since the number of ways can be big, print it modulo 998244353.
Input
First line of input contains one integer n (2 ≤ n ≤ 10^{5}) — size of the array.
Second line of input contains n integers a_{i} — elements of array. Either a_{i} = -1 or 1 ≤ a_{i} ≤ 200. a_{i} = -1 means that i-th element can't be read.
Output
Print number of ways to restore the array modulo 998244353.
Examples
Input
3
1 -1 2
Output
1
Input
2
-1 -1
Output
200
Note
In the first example, only possible value of a_{2} is 2.
In the second example, a_{1} = a_{2} so there are 200 different values because all restored elements should be integers between 1 and 200. | instruction | 0 | 49,646 | 12 | 99,292 |
Tags: dp
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
dp=[[0,0] for i in range(201)]
for i in range(201):
dp[i][1]=1
mod=998244353
for i in range(1,n+1):
dp1=[[0,0] for _ in range(201)]
for j in range(1, 201):
if a[i - 1] == -1 or a[i - 1] == j:
dp1[j][0] = (dp1[j][0] + dp[j - 1][1] + dp[j - 1][0]) % mod
dp1[j][1] = (dp1[j][1] + dp[200][1] - dp[j - 1][1] + dp[j][0] - dp[j - 1][0]) % mod
dp1[j][0]=(dp1[j][0]+dp1[j-1][0])%mod
dp1[j][1] = (dp1[j][1] + dp1[j - 1][1]) % mod
dp = dp1
print(dp[200][1])
``` | output | 1 | 49,646 | 12 | 99,293 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan unexpectedly saw a present from one of his previous birthdays. It is array of n numbers from 1 to 200. Array is old and some numbers are hard to read. Ivan remembers that for all elements at least one of its neighbours ls not less than it, more formally:
a_{1} ≤ a_{2},
a_{n} ≤ a_{n-1} and
a_{i} ≤ max(a_{i-1}, a_{i+1}) for all i from 2 to n-1.
Ivan does not remember the array and asks to find the number of ways to restore it. Restored elements also should be integers from 1 to 200. Since the number of ways can be big, print it modulo 998244353.
Input
First line of input contains one integer n (2 ≤ n ≤ 10^{5}) — size of the array.
Second line of input contains n integers a_{i} — elements of array. Either a_{i} = -1 or 1 ≤ a_{i} ≤ 200. a_{i} = -1 means that i-th element can't be read.
Output
Print number of ways to restore the array modulo 998244353.
Examples
Input
3
1 -1 2
Output
1
Input
2
-1 -1
Output
200
Note
In the first example, only possible value of a_{2} is 2.
In the second example, a_{1} = a_{2} so there are 200 different values because all restored elements should be integers between 1 and 200. | instruction | 0 | 49,647 | 12 | 99,294 |
Tags: dp
Correct Solution:
```
import os
from io import BytesIO
from math import trunc
if os.name == 'nt':
input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
MX = 201
MOD = 998244353
MODF = float(MOD)
MODF_inv = 1.0 / MODF
quickmod1 = lambda x: x - MODF * trunc(x / MODF)
def quickmod(a):
return a - MODF * trunc(a * MODF_inv)
def main():
n = int(input())
a = map(int, input().split())
dp0 = [1.0] * MX
dp1 = [0.0] * MX
for x in a:
pomdp0 = [0.0] * MX
pomdp1 = [0.0] * MX
if x == -1:
for val in range(1, MX):
pomdp0[val] = quickmod(
pomdp0[val - 1] + dp1[val - 1] + dp0[val - 1])
pomdp1[val] = quickmod(
pomdp1[val - 1] + dp1[MX - 1] - dp1[val - 1] + dp0[val] -
dp0[val - 1])
else:
pomdp0[x] = quickmod(dp1[x - 1] + dp0[x - 1])
pomdp1[x] = quickmod(dp1[MX - 1] - dp1[x - 1] + dp0[x] - dp0[x - 1])
for val in range(x + 1, MX):
pomdp0[val] = pomdp0[val - 1]
pomdp1[val] = pomdp1[val - 1]
dp0, dp1 = pomdp0, pomdp1
print(int(dp1[MX - 1] if n > 1 else dp0[MX - 1]) % MOD)
if __name__ == "__main__":
main()
``` | output | 1 | 49,647 | 12 | 99,295 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan unexpectedly saw a present from one of his previous birthdays. It is array of n numbers from 1 to 200. Array is old and some numbers are hard to read. Ivan remembers that for all elements at least one of its neighbours ls not less than it, more formally:
a_{1} ≤ a_{2},
a_{n} ≤ a_{n-1} and
a_{i} ≤ max(a_{i-1}, a_{i+1}) for all i from 2 to n-1.
Ivan does not remember the array and asks to find the number of ways to restore it. Restored elements also should be integers from 1 to 200. Since the number of ways can be big, print it modulo 998244353.
Input
First line of input contains one integer n (2 ≤ n ≤ 10^{5}) — size of the array.
Second line of input contains n integers a_{i} — elements of array. Either a_{i} = -1 or 1 ≤ a_{i} ≤ 200. a_{i} = -1 means that i-th element can't be read.
Output
Print number of ways to restore the array modulo 998244353.
Examples
Input
3
1 -1 2
Output
1
Input
2
-1 -1
Output
200
Note
In the first example, only possible value of a_{2} is 2.
In the second example, a_{1} = a_{2} so there are 200 different values because all restored elements should be integers between 1 and 200. | instruction | 0 | 49,649 | 12 | 99,298 |
Tags: dp
Correct Solution:
```
import os
from io import BytesIO
from math import trunc
input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
MOD = 998244353
MODF = float(MOD)
MAGIC = 6755399441055744.0
SHRT = 65536.0
MODF_INV = 1.0 / MODF
SHRT_INV = 1.0 / SHRT
fround = lambda x: (x + MAGIC) - MAGIC
fmod = lambda a: a - MODF * fround(MODF_INV * a)
fmul = lambda a, b: fmod(fmod(a * SHRT) * fround(SHRT_INV * b) + a * (b - SHRT * fround(b * SHRT_INV)))
def main():
n = int(input())
a = [int(i) for i in input().split()]
f0, f1 = [1.0] * 201, [0.0] * 201
nf0, nf1 = [0.0] * 201, [0.0] * 201
for i in range(n):
if a[i] == -1:
for j in range(200):
nf0[j + 1] = fmod(nf0[j] + f0[j] + f1[j])
nf1[j + 1] = fmod(nf1[j] - f0[j] + f0[j + 1] - f1[j] + f1[200])
else:
for j in range(200):
nf0[j + 1], nf1[j + 1] = nf0[j], nf1[j]
if j + 1 == a[i]:
nf0[j + 1] = fmod(nf0[j] + f0[j] + f1[j])
nf1[j + 1] = fmod(nf1[j] - f0[j] + f0[j + 1] - f1[j] + f1[200])
f0, f1, nf0, nf1 = nf0, nf1, f0, f1
nf0[0] = 0.0
os.write(1, str(int(fmod(f1[200])) % MOD).encode())
if __name__ == '__main__':
main()
``` | output | 1 | 49,649 | 12 | 99,299 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan unexpectedly saw a present from one of his previous birthdays. It is array of n numbers from 1 to 200. Array is old and some numbers are hard to read. Ivan remembers that for all elements at least one of its neighbours ls not less than it, more formally:
a_{1} ≤ a_{2},
a_{n} ≤ a_{n-1} and
a_{i} ≤ max(a_{i-1}, a_{i+1}) for all i from 2 to n-1.
Ivan does not remember the array and asks to find the number of ways to restore it. Restored elements also should be integers from 1 to 200. Since the number of ways can be big, print it modulo 998244353.
Input
First line of input contains one integer n (2 ≤ n ≤ 10^{5}) — size of the array.
Second line of input contains n integers a_{i} — elements of array. Either a_{i} = -1 or 1 ≤ a_{i} ≤ 200. a_{i} = -1 means that i-th element can't be read.
Output
Print number of ways to restore the array modulo 998244353.
Examples
Input
3
1 -1 2
Output
1
Input
2
-1 -1
Output
200
Note
In the first example, only possible value of a_{2} is 2.
In the second example, a_{1} = a_{2} so there are 200 different values because all restored elements should be integers between 1 and 200. | instruction | 0 | 49,650 | 12 | 99,300 |
Tags: dp
Correct Solution:
```
from math import trunc
MX = 201
MOD = 998244353
MODF = MOD * 1.0
quickmod = lambda x: x - MODF * trunc(x / MODF)
def main():
n = int(input())
a = map(int, input().split())
dp0 = [1.0] * MX
dp1 = [0.0] * MX
for x in a:
pomdp0 = [0.0] * MX
pomdp1 = [0.0] * MX
if x == -1:
for val in range(1, MX):
pomdp0[val] = quickmod(
pomdp0[val - 1] + dp1[val - 1] + dp0[val - 1])
pomdp1[val] = quickmod(
pomdp1[val - 1] + dp1[MX - 1] - dp1[val - 1] + dp0[val] -
dp0[val - 1])
else:
pomdp0[x] = quickmod(dp1[x - 1] + dp0[x - 1])
pomdp1[x] = quickmod(dp1[MX - 1] - dp1[x - 1] + dp0[x] - dp0[x - 1])
for val in range(x + 1, MX):
pomdp0[val] = pomdp0[val - 1]
pomdp1[val] = pomdp1[val - 1]
dp0, dp1 = pomdp0, pomdp1
print(int(dp1[MX - 1] if n > 1 else dp0[MX - 1]) % MOD)
if __name__ == "__main__":
main()
``` | output | 1 | 49,650 | 12 | 99,301 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan unexpectedly saw a present from one of his previous birthdays. It is array of n numbers from 1 to 200. Array is old and some numbers are hard to read. Ivan remembers that for all elements at least one of its neighbours ls not less than it, more formally:
a_{1} ≤ a_{2},
a_{n} ≤ a_{n-1} and
a_{i} ≤ max(a_{i-1}, a_{i+1}) for all i from 2 to n-1.
Ivan does not remember the array and asks to find the number of ways to restore it. Restored elements also should be integers from 1 to 200. Since the number of ways can be big, print it modulo 998244353.
Input
First line of input contains one integer n (2 ≤ n ≤ 10^{5}) — size of the array.
Second line of input contains n integers a_{i} — elements of array. Either a_{i} = -1 or 1 ≤ a_{i} ≤ 200. a_{i} = -1 means that i-th element can't be read.
Output
Print number of ways to restore the array modulo 998244353.
Examples
Input
3
1 -1 2
Output
1
Input
2
-1 -1
Output
200
Note
In the first example, only possible value of a_{2} is 2.
In the second example, a_{1} = a_{2} so there are 200 different values because all restored elements should be integers between 1 and 200. | instruction | 0 | 49,651 | 12 | 99,302 |
Tags: dp
Correct Solution:
```
MOD = 998244353.0
float_prec = 1801439850948198.4
float_mod = lambda x: x if -float_prec < x < float_prec else x % MOD
n = int(input())
a = [int(i) for i in input().split()]
f0, f1 = [1.0] * 201, [0.0] * 201
for i in range(n):
nf0, nf1 = [0.0] * 201, [0.0] * 201
if a[i] == -1:
for j in range(200):
nf0[j + 1] = float_mod(nf0[j] + f0[j] + f1[j])
nf1[j + 1] = float_mod(nf1[j] - f0[j] + f0[j + 1] - f1[j] + f1[200])
else:
for j in range(200):
nf0[j + 1], nf1[j + 1] = nf0[j], nf1[j]
if j + 1 == a[i]:
nf0[j + 1] = float_mod(nf0[j] + f0[j] + f1[j])
nf1[j + 1] = float_mod(nf1[j] - f0[j] + f0[j + 1] - f1[j] + f1[200])
f0, f1 = nf0, nf1
print(int(f1[200] % MOD))
``` | output | 1 | 49,651 | 12 | 99,303 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan unexpectedly saw a present from one of his previous birthdays. It is array of n numbers from 1 to 200. Array is old and some numbers are hard to read. Ivan remembers that for all elements at least one of its neighbours ls not less than it, more formally:
a_{1} ≤ a_{2},
a_{n} ≤ a_{n-1} and
a_{i} ≤ max(a_{i-1}, a_{i+1}) for all i from 2 to n-1.
Ivan does not remember the array and asks to find the number of ways to restore it. Restored elements also should be integers from 1 to 200. Since the number of ways can be big, print it modulo 998244353.
Input
First line of input contains one integer n (2 ≤ n ≤ 10^{5}) — size of the array.
Second line of input contains n integers a_{i} — elements of array. Either a_{i} = -1 or 1 ≤ a_{i} ≤ 200. a_{i} = -1 means that i-th element can't be read.
Output
Print number of ways to restore the array modulo 998244353.
Examples
Input
3
1 -1 2
Output
1
Input
2
-1 -1
Output
200
Note
In the first example, only possible value of a_{2} is 2.
In the second example, a_{1} = a_{2} so there are 200 different values because all restored elements should be integers between 1 and 200. | instruction | 0 | 49,652 | 12 | 99,304 |
Tags: dp
Correct Solution:
```
import os
from io import BytesIO
from math import trunc
input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
MX = 201
MOD = 998244353
MODF = float(MOD)
quickmod = lambda x: x - MODF * trunc(x / MODF)
def main():
n = int(input())
a = map(int, input().split())
dp0 = [1.0] * MX
dp1 = [0.0] * MX
for x in a:
pomdp0 = [0.0] * MX
pomdp1 = [0.0] * MX
if x == -1:
for val in range(1, MX):
pomdp0[val] = quickmod(
pomdp0[val - 1] + dp1[val - 1] + dp0[val - 1])
pomdp1[val] = quickmod(
pomdp1[val - 1] + dp1[MX - 1] - dp1[val - 1] + dp0[val] -
dp0[val - 1])
else:
pomdp0[x] = quickmod(dp1[x - 1] + dp0[x - 1])
pomdp1[x] = quickmod(dp1[MX - 1] - dp1[x - 1] + dp0[x] - dp0[x - 1])
for val in range(x + 1, MX):
pomdp0[val] = pomdp0[val - 1]
pomdp1[val] = pomdp1[val - 1]
dp0, dp1 = pomdp0, pomdp1
print(int(dp1[MX - 1] if n > 1 else dp0[MX - 1]) % MOD)
if __name__ == "__main__":
main()
``` | output | 1 | 49,652 | 12 | 99,305 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ivan unexpectedly saw a present from one of his previous birthdays. It is array of n numbers from 1 to 200. Array is old and some numbers are hard to read. Ivan remembers that for all elements at least one of its neighbours ls not less than it, more formally:
a_{1} ≤ a_{2},
a_{n} ≤ a_{n-1} and
a_{i} ≤ max(a_{i-1}, a_{i+1}) for all i from 2 to n-1.
Ivan does not remember the array and asks to find the number of ways to restore it. Restored elements also should be integers from 1 to 200. Since the number of ways can be big, print it modulo 998244353.
Input
First line of input contains one integer n (2 ≤ n ≤ 10^{5}) — size of the array.
Second line of input contains n integers a_{i} — elements of array. Either a_{i} = -1 or 1 ≤ a_{i} ≤ 200. a_{i} = -1 means that i-th element can't be read.
Output
Print number of ways to restore the array modulo 998244353.
Examples
Input
3
1 -1 2
Output
1
Input
2
-1 -1
Output
200
Note
In the first example, only possible value of a_{2} is 2.
In the second example, a_{1} = a_{2} so there are 200 different values because all restored elements should be integers between 1 and 200. | instruction | 0 | 49,653 | 12 | 99,306 |
Tags: dp
Correct Solution:
```
MOD = 998244353.0
float_prec = 1801439850948198.4
float_mod = lambda x: x if -float_prec < x < float_prec else x % MOD
n = int(input())
a = [int(i) for i in input().split()]
f0, f1 = [1.0] * 201, [0.0] * 201
for i in range(n):
nf0, nf1 = [0.0] * 201, [0.0] * 201
if a[i] == -1:
for j in range(200):
nf0[j + 1] = float_mod(nf0[j] + f0[j] + f1[j])
nf1[j + 1] = float_mod(nf1[j] - f0[j] + f0[j + 1] - f1[j] + f1[200])
else:
for j in range(200):
nf0[j + 1], nf1[j + 1] = nf0[j], nf1[j]
if j + 1 == a[i]:
nf0[j + 1] = float_mod(nf0[j] + f0[j] + f1[j])
nf1[j + 1] = float_mod(nf1[j] - f0[j] + f0[j + 1] - f1[j] + f1[200])
f0, f1 = nf0, nf1
print(int(f1[200] % MOD))
hc = 1
``` | output | 1 | 49,653 | 12 | 99,307 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ivan unexpectedly saw a present from one of his previous birthdays. It is array of n numbers from 1 to 200. Array is old and some numbers are hard to read. Ivan remembers that for all elements at least one of its neighbours ls not less than it, more formally:
a_{1} ≤ a_{2},
a_{n} ≤ a_{n-1} and
a_{i} ≤ max(a_{i-1}, a_{i+1}) for all i from 2 to n-1.
Ivan does not remember the array and asks to find the number of ways to restore it. Restored elements also should be integers from 1 to 200. Since the number of ways can be big, print it modulo 998244353.
Input
First line of input contains one integer n (2 ≤ n ≤ 10^{5}) — size of the array.
Second line of input contains n integers a_{i} — elements of array. Either a_{i} = -1 or 1 ≤ a_{i} ≤ 200. a_{i} = -1 means that i-th element can't be read.
Output
Print number of ways to restore the array modulo 998244353.
Examples
Input
3
1 -1 2
Output
1
Input
2
-1 -1
Output
200
Note
In the first example, only possible value of a_{2} is 2.
In the second example, a_{1} = a_{2} so there are 200 different values because all restored elements should be integers between 1 and 200.
Submitted Solution:
```
import os
from io import BytesIO
from math import trunc
input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
MX = 201
MOD = 998244353
MODF = MOD * 1.0
quickmod = lambda x: x - MODF * trunc(x / MODF)
def main():
n = int(input())
a = map(int, input().split())
dp0 = [1.0] * MX
dp1 = [0.0] * MX
for x in a:
pomdp0 = [0.0] * MX
pomdp1 = [0.0] * MX
if x == -1:
for val in range(1, MX):
pomdp0[val] = quickmod(
pomdp0[val - 1] + dp1[val - 1] + dp0[val - 1])
pomdp1[val] = quickmod(
pomdp1[val - 1] + dp1[MX - 1] - dp1[val - 1] + dp0[val] -
dp0[val - 1])
else:
pomdp0[x] = quickmod(dp1[x - 1] + dp0[x - 1])
pomdp1[x] = quickmod(dp1[MX - 1] - dp1[x - 1] + dp0[x] - dp0[x - 1])
for val in range(x + 1, MX):
pomdp0[val] = pomdp0[val - 1]
pomdp1[val] = pomdp1[val - 1]
dp0, dp1 = pomdp0, pomdp1
print(int(dp1[MX - 1] if n > 1 else dp0[MX - 1]) % MOD)
if __name__ == "__main__":
main()
``` | instruction | 0 | 49,654 | 12 | 99,308 |
Yes | output | 1 | 49,654 | 12 | 99,309 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ivan unexpectedly saw a present from one of his previous birthdays. It is array of n numbers from 1 to 200. Array is old and some numbers are hard to read. Ivan remembers that for all elements at least one of its neighbours ls not less than it, more formally:
a_{1} ≤ a_{2},
a_{n} ≤ a_{n-1} and
a_{i} ≤ max(a_{i-1}, a_{i+1}) for all i from 2 to n-1.
Ivan does not remember the array and asks to find the number of ways to restore it. Restored elements also should be integers from 1 to 200. Since the number of ways can be big, print it modulo 998244353.
Input
First line of input contains one integer n (2 ≤ n ≤ 10^{5}) — size of the array.
Second line of input contains n integers a_{i} — elements of array. Either a_{i} = -1 or 1 ≤ a_{i} ≤ 200. a_{i} = -1 means that i-th element can't be read.
Output
Print number of ways to restore the array modulo 998244353.
Examples
Input
3
1 -1 2
Output
1
Input
2
-1 -1
Output
200
Note
In the first example, only possible value of a_{2} is 2.
In the second example, a_{1} = a_{2} so there are 200 different values because all restored elements should be integers between 1 and 200.
Submitted Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
import sys
from io import BytesIO, IOBase
from array import array
def main():
n=int(input())
dp=[[0,0] for _ in range(201)]
a=list(map(int,input().split()))
mod=998244353
for i in range(201):
dp[i][1]=1
for i in range(1,n+1):
dp1=[[0,0] for _ in range(201)]
for j in range(1,201):
if a[i-1]==-1 or a[i-1]==j:
dp1[j][1]=(dp1[j][1]+dp[200][1]-dp[j-1][1]+dp[j][0]-dp[j-1][0])%mod
dp1[j][0]=(dp1[j][0]+dp[j-1][1]+dp[j-1][0])%mod
dp1[j][0]=(dp1[j][0]+dp1[j-1][0])%mod
dp1[j][1]=(dp1[j][1]+dp1[j-1][1])%mod
dp=dp1
print(dp[200][1])
# 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()
``` | instruction | 0 | 49,655 | 12 | 99,310 |
Yes | output | 1 | 49,655 | 12 | 99,311 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ivan unexpectedly saw a present from one of his previous birthdays. It is array of n numbers from 1 to 200. Array is old and some numbers are hard to read. Ivan remembers that for all elements at least one of its neighbours ls not less than it, more formally:
a_{1} ≤ a_{2},
a_{n} ≤ a_{n-1} and
a_{i} ≤ max(a_{i-1}, a_{i+1}) for all i from 2 to n-1.
Ivan does not remember the array and asks to find the number of ways to restore it. Restored elements also should be integers from 1 to 200. Since the number of ways can be big, print it modulo 998244353.
Input
First line of input contains one integer n (2 ≤ n ≤ 10^{5}) — size of the array.
Second line of input contains n integers a_{i} — elements of array. Either a_{i} = -1 or 1 ≤ a_{i} ≤ 200. a_{i} = -1 means that i-th element can't be read.
Output
Print number of ways to restore the array modulo 998244353.
Examples
Input
3
1 -1 2
Output
1
Input
2
-1 -1
Output
200
Note
In the first example, only possible value of a_{2} is 2.
In the second example, a_{1} = a_{2} so there are 200 different values because all restored elements should be integers between 1 and 200.
Submitted Solution:
```
import os
from io import BytesIO
input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
MOD = 998244353
MODF = 1.0*MOD
MODF_inv = 1.0/MODF
from math import trunc
def quickmod(a):
return a-MODF*trunc(a*MODF_inv)
def main():
n = int(input())
a = [int(i) for i in input().split()]
f0, f1 = [1.0] * 201, [0.0] * 201
nf0, nf1 = [0.0] * 201, [0.0] * 201
for i in range(n):
if a[i] == -1:
for j in range(200):
nf0[j + 1] = quickmod(nf0[j] + f0[j] + f1[j])
nf1[j + 1] = quickmod(nf1[j] - f0[j] + f0[j + 1] - f1[j] + f1[200])
else:
for j in range(200):
nf0[j + 1], nf1[j + 1] = nf0[j], nf1[j]
if j + 1 == a[i]:
nf0[j + 1] = quickmod(nf0[j] + f0[j] + f1[j])
nf1[j + 1] = quickmod(nf1[j] - f0[j] + f0[j + 1] - f1[j] + f1[200])
f0, f1, nf0, nf1 = nf0, nf1, f0, f1
nf0[0]=0.0
os.write(1, str(int(quickmod(f1[200]))%MOD).encode())
if __name__ == '__main__':
main()
``` | instruction | 0 | 49,656 | 12 | 99,312 |
Yes | output | 1 | 49,656 | 12 | 99,313 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ivan unexpectedly saw a present from one of his previous birthdays. It is array of n numbers from 1 to 200. Array is old and some numbers are hard to read. Ivan remembers that for all elements at least one of its neighbours ls not less than it, more formally:
a_{1} ≤ a_{2},
a_{n} ≤ a_{n-1} and
a_{i} ≤ max(a_{i-1}, a_{i+1}) for all i from 2 to n-1.
Ivan does not remember the array and asks to find the number of ways to restore it. Restored elements also should be integers from 1 to 200. Since the number of ways can be big, print it modulo 998244353.
Input
First line of input contains one integer n (2 ≤ n ≤ 10^{5}) — size of the array.
Second line of input contains n integers a_{i} — elements of array. Either a_{i} = -1 or 1 ≤ a_{i} ≤ 200. a_{i} = -1 means that i-th element can't be read.
Output
Print number of ways to restore the array modulo 998244353.
Examples
Input
3
1 -1 2
Output
1
Input
2
-1 -1
Output
200
Note
In the first example, only possible value of a_{2} is 2.
In the second example, a_{1} = a_{2} so there are 200 different values because all restored elements should be integers between 1 and 200.
Submitted Solution:
```
import os
from io import BytesIO
input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
MOD = 998244353
MODF = 1.0*MOD
from math import trunc
def quickmod(a):
return a-MODF*trunc(a/MODF)
def main():
n = int(input())
a = [int(i) for i in input().split()]
f0, f1 = [1.0] * 201, [0.0] * 201
nf0, nf1 = [0.0] * 201, [0.0] * 201
for i in range(n):
if a[i] == -1:
for j in range(200):
nf0[j + 1] = quickmod(nf0[j] + f0[j] + f1[j])
nf1[j + 1] = quickmod(nf1[j] - f0[j] + f0[j + 1] - f1[j] + f1[200])
else:
for j in range(200):
nf0[j + 1], nf1[j + 1] = nf0[j], nf1[j]
if j + 1 == a[i]:
nf0[j + 1] = quickmod(nf0[j] + f0[j] + f1[j])
nf1[j + 1] = quickmod(nf1[j] - f0[j] + f0[j + 1] - f1[j] + f1[200])
f0, f1, nf0, nf1 = nf0, nf1, f0, f1
nf0[0]=0.0
os.write(1, str(int(quickmod(f1[200]))%MOD).encode())
if __name__ == '__main__':
main()
``` | instruction | 0 | 49,657 | 12 | 99,314 |
Yes | output | 1 | 49,657 | 12 | 99,315 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ivan unexpectedly saw a present from one of his previous birthdays. It is array of n numbers from 1 to 200. Array is old and some numbers are hard to read. Ivan remembers that for all elements at least one of its neighbours ls not less than it, more formally:
a_{1} ≤ a_{2},
a_{n} ≤ a_{n-1} and
a_{i} ≤ max(a_{i-1}, a_{i+1}) for all i from 2 to n-1.
Ivan does not remember the array and asks to find the number of ways to restore it. Restored elements also should be integers from 1 to 200. Since the number of ways can be big, print it modulo 998244353.
Input
First line of input contains one integer n (2 ≤ n ≤ 10^{5}) — size of the array.
Second line of input contains n integers a_{i} — elements of array. Either a_{i} = -1 or 1 ≤ a_{i} ≤ 200. a_{i} = -1 means that i-th element can't be read.
Output
Print number of ways to restore the array modulo 998244353.
Examples
Input
3
1 -1 2
Output
1
Input
2
-1 -1
Output
200
Note
In the first example, only possible value of a_{2} is 2.
In the second example, a_{1} = a_{2} so there are 200 different values because all restored elements should be integers between 1 and 200.
Submitted Solution:
```
import math
n = int(input())
cl = list(map(int, input().split()))
t = 0
mn = 1
res = 1
for i in range(n):
if cl[i]==-1:
if i!=n-2:
t+=1
else:
if t!=0:
res=res*(cl[i]-mn+1)*t
t = 0
else:
mn = cl[i]
if t!=0:
res = res*(200-mn+1)*t
print(res%998244353)
``` | instruction | 0 | 49,658 | 12 | 99,316 |
No | output | 1 | 49,658 | 12 | 99,317 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ivan unexpectedly saw a present from one of his previous birthdays. It is array of n numbers from 1 to 200. Array is old and some numbers are hard to read. Ivan remembers that for all elements at least one of its neighbours ls not less than it, more formally:
a_{1} ≤ a_{2},
a_{n} ≤ a_{n-1} and
a_{i} ≤ max(a_{i-1}, a_{i+1}) for all i from 2 to n-1.
Ivan does not remember the array and asks to find the number of ways to restore it. Restored elements also should be integers from 1 to 200. Since the number of ways can be big, print it modulo 998244353.
Input
First line of input contains one integer n (2 ≤ n ≤ 10^{5}) — size of the array.
Second line of input contains n integers a_{i} — elements of array. Either a_{i} = -1 or 1 ≤ a_{i} ≤ 200. a_{i} = -1 means that i-th element can't be read.
Output
Print number of ways to restore the array modulo 998244353.
Examples
Input
3
1 -1 2
Output
1
Input
2
-1 -1
Output
200
Note
In the first example, only possible value of a_{2} is 2.
In the second example, a_{1} = a_{2} so there are 200 different values because all restored elements should be integers between 1 and 200.
Submitted Solution:
```
n = int(input())
A = list(map(int, input().split()))
counted = [0 for i in range(1,403)]
MOD = 998244353
res = 0
if n == 100000 :
for i in A :
if i != A :
print(i)
exit(0)
hit = 0
for i in A :
if i == -1 : continue
if counted[i] == 0 :
hit = hit+1
counted[i] = 1
if hit == 1 : res = res-1
elif hit == 0 : res = res-200
def fun() :
global res
dp = [[0 for j in range(1,203)] for i in range(1,100003)]
if A[1] == -1 :
for i in range(1,201) : dp[1][i] = i
else :
for i in range(A[1],201) : dp[1][i] = 1
for i in range(2, n) :
if A[i] == -1 :
for j in range(1,201) :
dp[i][j] = dp[i-1][j]
else :
dp[i][A[i]] = dp[i-1][A[i]]
for j in range(1, 201) :
dp[i][j] = (dp[i][j] + dp[i][j-1])%MOD
# for i in range(1, n) :
# print("I", i)
# print(dp[i][0:5])
if A[n] == -1 :
res = res + dp[n-1][200]
else :
res = res + dp[n-1][A[n]] - dp[n-1][A[n]-1];
# print(res)
A = [0] + A
fun()
A = A[1:]
list.reverse(A)
A = [0] + A
fun()
print(res)
``` | instruction | 0 | 49,659 | 12 | 99,318 |
No | output | 1 | 49,659 | 12 | 99,319 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ivan unexpectedly saw a present from one of his previous birthdays. It is array of n numbers from 1 to 200. Array is old and some numbers are hard to read. Ivan remembers that for all elements at least one of its neighbours ls not less than it, more formally:
a_{1} ≤ a_{2},
a_{n} ≤ a_{n-1} and
a_{i} ≤ max(a_{i-1}, a_{i+1}) for all i from 2 to n-1.
Ivan does not remember the array and asks to find the number of ways to restore it. Restored elements also should be integers from 1 to 200. Since the number of ways can be big, print it modulo 998244353.
Input
First line of input contains one integer n (2 ≤ n ≤ 10^{5}) — size of the array.
Second line of input contains n integers a_{i} — elements of array. Either a_{i} = -1 or 1 ≤ a_{i} ≤ 200. a_{i} = -1 means that i-th element can't be read.
Output
Print number of ways to restore the array modulo 998244353.
Examples
Input
3
1 -1 2
Output
1
Input
2
-1 -1
Output
200
Note
In the first example, only possible value of a_{2} is 2.
In the second example, a_{1} = a_{2} so there are 200 different values because all restored elements should be integers between 1 and 200.
Submitted Solution:
```
n = int(input())
lacuna = []
mi = 1
lacuna_length = 0
is_in_lacuna = False
arr = [int(x) for x in input().split(' ')]
if arr[-1] == -1:
arr.append(200)
if arr[-2] == -1:
arr[-2] = arr[-1]
import sys
if n == 100000:
print(42)
sys.exit(0)
for e in arr:
if is_in_lacuna:
if e == -1:
lacuna_length += 1
else:
lacuna.append(((e - mi + 1), lacuna_length))
mi = e
is_in_lacuna = False
else:
if e == -1:
is_in_lacuna = True
lacuna_length = 1
else:
mi = e
p = 998244353
from math import factorial
sum_modulo = 1
for dh, dl in lacuna:
#print(dh, dl)
n = dh + dl - 1
k = dl
cur_var = factorial(n) / (factorial(k) * (factorial(n - k))) % p
#print(cur_var)
sum_modulo = (sum_modulo * cur_var) % p
print(int(sum_modulo))
``` | instruction | 0 | 49,660 | 12 | 99,320 |
No | output | 1 | 49,660 | 12 | 99,321 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ivan unexpectedly saw a present from one of his previous birthdays. It is array of n numbers from 1 to 200. Array is old and some numbers are hard to read. Ivan remembers that for all elements at least one of its neighbours ls not less than it, more formally:
a_{1} ≤ a_{2},
a_{n} ≤ a_{n-1} and
a_{i} ≤ max(a_{i-1}, a_{i+1}) for all i from 2 to n-1.
Ivan does not remember the array and asks to find the number of ways to restore it. Restored elements also should be integers from 1 to 200. Since the number of ways can be big, print it modulo 998244353.
Input
First line of input contains one integer n (2 ≤ n ≤ 10^{5}) — size of the array.
Second line of input contains n integers a_{i} — elements of array. Either a_{i} = -1 or 1 ≤ a_{i} ≤ 200. a_{i} = -1 means that i-th element can't be read.
Output
Print number of ways to restore the array modulo 998244353.
Examples
Input
3
1 -1 2
Output
1
Input
2
-1 -1
Output
200
Note
In the first example, only possible value of a_{2} is 2.
In the second example, a_{1} = a_{2} so there are 200 different values because all restored elements should be integers between 1 and 200.
Submitted Solution:
```
def main():
n = int(input())
a = list(map(int, input().split()))
if n == 2 and sum(a) == -2:
return 200
unknown = list()
for i in range(n):
if a[i] == -1:
unknown.append((i, a[i]))
w = len(unknown)
if w == 1:
if unknown[0][0] == n-1:
return len(range(a[n-2], 200))
elif unknown[0][0] == 0:
return len(range(1, a[1]))
else:
return len(range(a[unknown[0][0] - 1], a[unknown[0][0] + 1]))
if __name__ == '__main__':
print(main())
``` | instruction | 0 | 49,661 | 12 | 99,322 |
No | output | 1 | 49,661 | 12 | 99,323 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is a number of elements in the array.
You are given an array a consisting of n integers. The value of the i-th element of the array is a_i.
You are also given a set of m segments. The j-th segment is [l_j; r_j], where 1 ≤ l_j ≤ r_j ≤ n.
You can choose some subset of the given set of segments and decrease values on each of the chosen segments by one (independently). For example, if the initial array a = [0, 0, 0, 0, 0] and the given segments are [1; 3] and [2; 4] then you can choose both of them and the array will become b = [-1, -2, -2, -1, 0].
You have to choose some subset of the given segments (each segment can be chosen at most once) in such a way that if you apply this subset of segments to the array a and obtain the array b then the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i will be maximum possible.
Note that you can choose the empty set.
If there are multiple answers, you can print any.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 300, 0 ≤ m ≤ 300) — the length of the array a and the number of segments, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^6 ≤ a_i ≤ 10^6), where a_i is the value of the i-th element of the array a.
The next m lines are contain two integers each. The j-th of them contains two integers l_j and r_j (1 ≤ l_j ≤ r_j ≤ n), where l_j and r_j are the ends of the j-th segment.
Output
In the first line of the output print one integer d — the maximum possible value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i if b is the array obtained by applying some subset of the given segments to the array a.
In the second line of the output print one integer q (0 ≤ q ≤ m) — the number of segments you apply.
In the third line print q distinct integers c_1, c_2, ..., c_q in any order (1 ≤ c_k ≤ m) — indices of segments you apply to the array a in such a way that the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i of the obtained array b is maximum possible.
If there are multiple answers, you can print any.
Examples
Input
5 4
2 -2 3 1 2
1 3
4 5
2 5
1 3
Output
6
2
1 4
Input
5 4
2 -2 3 1 4
3 5
3 4
2 4
2 5
Output
7
2
3 2
Input
1 0
1000000
Output
0
0
Note
In the first example the obtained array b will be [0, -4, 1, 1, 2] so the answer is 6.
In the second example the obtained array b will be [2, -3, 1, -1, 4] so the answer is 7.
In the third example you cannot do anything so the answer is 0. | instruction | 0 | 49,662 | 12 | 99,324 |
Tags: brute force, greedy, implementation
Correct Solution:
```
# Author : nitish420 --------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
def main():
n,m=map(int,input().split())
arr=list(map(int,input().split()))
left=[[] for _ in range(n)]
right=[[] for _ in range(n)]
seg=[]
for _ in range(m):
l,r=map(int,input().split())
l-=1
r-=1
left[r].append(l)
right[l].append(r)
seg.append((l,r))
dff=[0]*n
ans=[-10**10]*n
mm=arr[0]
for i in range(n):
ans[i]=max(ans[i],arr[i]-mm)
for l in left[i]:
for j in range(l,i+1):
dff[j]-=1
mm=min(mm,arr[j]+dff[j])
mm=min(mm,arr[i]+dff[i])
dff=[0]*n
mm=arr[n-1]
for i in range(n-1,-1,-1):
ans[i]=max(ans[i],arr[i]-mm)
for r in right[i]:
for j in range(i,r+1):
dff[j]-=1
mm=min(mm,arr[j]+dff[j])
mm=min(mm,arr[i]+dff[i])
final=max(ans)
idx=ans.index(final)
que=[]
for i,item in enumerate(seg):
l,r=item
if l<=idx<=r:
continue
que.append(i+1)
print(final)
print(len(que))
print(*que)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = 'x' in file.mode or 'r' not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b'\n') + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode('ascii'))
self.read = lambda: self.buffer.read().decode('ascii')
self.readline = lambda: self.buffer.readline().decode('ascii')
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')
# endregion
if __name__ == '__main__':
main()
``` | output | 1 | 49,662 | 12 | 99,325 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is a number of elements in the array.
You are given an array a consisting of n integers. The value of the i-th element of the array is a_i.
You are also given a set of m segments. The j-th segment is [l_j; r_j], where 1 ≤ l_j ≤ r_j ≤ n.
You can choose some subset of the given set of segments and decrease values on each of the chosen segments by one (independently). For example, if the initial array a = [0, 0, 0, 0, 0] and the given segments are [1; 3] and [2; 4] then you can choose both of them and the array will become b = [-1, -2, -2, -1, 0].
You have to choose some subset of the given segments (each segment can be chosen at most once) in such a way that if you apply this subset of segments to the array a and obtain the array b then the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i will be maximum possible.
Note that you can choose the empty set.
If there are multiple answers, you can print any.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 300, 0 ≤ m ≤ 300) — the length of the array a and the number of segments, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^6 ≤ a_i ≤ 10^6), where a_i is the value of the i-th element of the array a.
The next m lines are contain two integers each. The j-th of them contains two integers l_j and r_j (1 ≤ l_j ≤ r_j ≤ n), where l_j and r_j are the ends of the j-th segment.
Output
In the first line of the output print one integer d — the maximum possible value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i if b is the array obtained by applying some subset of the given segments to the array a.
In the second line of the output print one integer q (0 ≤ q ≤ m) — the number of segments you apply.
In the third line print q distinct integers c_1, c_2, ..., c_q in any order (1 ≤ c_k ≤ m) — indices of segments you apply to the array a in such a way that the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i of the obtained array b is maximum possible.
If there are multiple answers, you can print any.
Examples
Input
5 4
2 -2 3 1 2
1 3
4 5
2 5
1 3
Output
6
2
1 4
Input
5 4
2 -2 3 1 4
3 5
3 4
2 4
2 5
Output
7
2
3 2
Input
1 0
1000000
Output
0
0
Note
In the first example the obtained array b will be [0, -4, 1, 1, 2] so the answer is 6.
In the second example the obtained array b will be [2, -3, 1, -1, 4] so the answer is 7.
In the third example you cannot do anything so the answer is 0. | instruction | 0 | 49,663 | 12 | 99,326 |
Tags: brute force, greedy, implementation
Correct Solution:
```
R=lambda:map(int,input().split())
n,m=R()
l=list(R())
d=max(l)-min(l)
s=[]
qc=[]
for i in range(m):
s.append(list(R()))
for i in range(1,n+1):
str=l.copy()
c=[]
for j in range(m):
if not (i in range(s[j][0],s[j][1]+1)):
c.append(j+1)
for t in range(s[j][0]-1,s[j][1]):
str[t]-=1
distance=max(str)-min(str)
if distance>d:
d=distance
qc=c
print(d,len(qc),sep='\n')
print(*qc)
``` | output | 1 | 49,663 | 12 | 99,327 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is a number of elements in the array.
You are given an array a consisting of n integers. The value of the i-th element of the array is a_i.
You are also given a set of m segments. The j-th segment is [l_j; r_j], where 1 ≤ l_j ≤ r_j ≤ n.
You can choose some subset of the given set of segments and decrease values on each of the chosen segments by one (independently). For example, if the initial array a = [0, 0, 0, 0, 0] and the given segments are [1; 3] and [2; 4] then you can choose both of them and the array will become b = [-1, -2, -2, -1, 0].
You have to choose some subset of the given segments (each segment can be chosen at most once) in such a way that if you apply this subset of segments to the array a and obtain the array b then the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i will be maximum possible.
Note that you can choose the empty set.
If there are multiple answers, you can print any.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 300, 0 ≤ m ≤ 300) — the length of the array a and the number of segments, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^6 ≤ a_i ≤ 10^6), where a_i is the value of the i-th element of the array a.
The next m lines are contain two integers each. The j-th of them contains two integers l_j and r_j (1 ≤ l_j ≤ r_j ≤ n), where l_j and r_j are the ends of the j-th segment.
Output
In the first line of the output print one integer d — the maximum possible value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i if b is the array obtained by applying some subset of the given segments to the array a.
In the second line of the output print one integer q (0 ≤ q ≤ m) — the number of segments you apply.
In the third line print q distinct integers c_1, c_2, ..., c_q in any order (1 ≤ c_k ≤ m) — indices of segments you apply to the array a in such a way that the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i of the obtained array b is maximum possible.
If there are multiple answers, you can print any.
Examples
Input
5 4
2 -2 3 1 2
1 3
4 5
2 5
1 3
Output
6
2
1 4
Input
5 4
2 -2 3 1 4
3 5
3 4
2 4
2 5
Output
7
2
3 2
Input
1 0
1000000
Output
0
0
Note
In the first example the obtained array b will be [0, -4, 1, 1, 2] so the answer is 6.
In the second example the obtained array b will be [2, -3, 1, -1, 4] so the answer is 7.
In the third example you cannot do anything so the answer is 0. | instruction | 0 | 49,664 | 12 | 99,328 |
Tags: brute force, greedy, implementation
Correct Solution:
```
import sys
input=sys.stdin.readline
n,m=map(int,input().split())
x=[*map(int,input().split())]
seg=[]
for i in range(m):
a=[*map(int,input().split())]
seg.append(a)
ans=-1
ansi=[]
for i in range(len(x)):
tx=x[:]
oi=[]
for n,j in enumerate(seg):
a,b=j
if not (a-1<=i<=b-1):
oi.append(n+1)
for k in range(a-1,b):
tx[k]-=1
m=max(tx)-min(tx)
if m>ans:
ans=m
ansi=oi[:]
print(ans)
print(len(ansi))
for i in ansi:
print(i,end=" ")
``` | output | 1 | 49,664 | 12 | 99,329 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is a number of elements in the array.
You are given an array a consisting of n integers. The value of the i-th element of the array is a_i.
You are also given a set of m segments. The j-th segment is [l_j; r_j], where 1 ≤ l_j ≤ r_j ≤ n.
You can choose some subset of the given set of segments and decrease values on each of the chosen segments by one (independently). For example, if the initial array a = [0, 0, 0, 0, 0] and the given segments are [1; 3] and [2; 4] then you can choose both of them and the array will become b = [-1, -2, -2, -1, 0].
You have to choose some subset of the given segments (each segment can be chosen at most once) in such a way that if you apply this subset of segments to the array a and obtain the array b then the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i will be maximum possible.
Note that you can choose the empty set.
If there are multiple answers, you can print any.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 300, 0 ≤ m ≤ 300) — the length of the array a and the number of segments, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^6 ≤ a_i ≤ 10^6), where a_i is the value of the i-th element of the array a.
The next m lines are contain two integers each. The j-th of them contains two integers l_j and r_j (1 ≤ l_j ≤ r_j ≤ n), where l_j and r_j are the ends of the j-th segment.
Output
In the first line of the output print one integer d — the maximum possible value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i if b is the array obtained by applying some subset of the given segments to the array a.
In the second line of the output print one integer q (0 ≤ q ≤ m) — the number of segments you apply.
In the third line print q distinct integers c_1, c_2, ..., c_q in any order (1 ≤ c_k ≤ m) — indices of segments you apply to the array a in such a way that the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i of the obtained array b is maximum possible.
If there are multiple answers, you can print any.
Examples
Input
5 4
2 -2 3 1 2
1 3
4 5
2 5
1 3
Output
6
2
1 4
Input
5 4
2 -2 3 1 4
3 5
3 4
2 4
2 5
Output
7
2
3 2
Input
1 0
1000000
Output
0
0
Note
In the first example the obtained array b will be [0, -4, 1, 1, 2] so the answer is 6.
In the second example the obtained array b will be [2, -3, 1, -1, 4] so the answer is 7.
In the third example you cannot do anything so the answer is 0. | instruction | 0 | 49,665 | 12 | 99,330 |
Tags: brute force, greedy, implementation
Correct Solution:
```
n,q=map(int,input().split())
l=[int(i) for i in input().split()]
eff=[0]*(n+5)
qry=[]
for i in range(q):
a,b=map(int,input().split())
a-=1
b-=1
qry.append([a,b])
maxi=0
res=[]
for ans in range(n):
l1=l[:]
now=l[ans]
apply=[]
for j in range(q):
a=qry[j][0]
b=qry[j][1]
if a<=ans<=b:
pass
else:
apply.append(j)
for i in range(a,b+1):
l1[i]-=1
if (now-min(l1)>maxi):
maxi=now-min(l1)
res=apply
print(maxi)
print(len(res))
if not res:
exit()
for i in res:
print(i+1,end=' ')
``` | output | 1 | 49,665 | 12 | 99,331 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is a number of elements in the array.
You are given an array a consisting of n integers. The value of the i-th element of the array is a_i.
You are also given a set of m segments. The j-th segment is [l_j; r_j], where 1 ≤ l_j ≤ r_j ≤ n.
You can choose some subset of the given set of segments and decrease values on each of the chosen segments by one (independently). For example, if the initial array a = [0, 0, 0, 0, 0] and the given segments are [1; 3] and [2; 4] then you can choose both of them and the array will become b = [-1, -2, -2, -1, 0].
You have to choose some subset of the given segments (each segment can be chosen at most once) in such a way that if you apply this subset of segments to the array a and obtain the array b then the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i will be maximum possible.
Note that you can choose the empty set.
If there are multiple answers, you can print any.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 300, 0 ≤ m ≤ 300) — the length of the array a and the number of segments, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^6 ≤ a_i ≤ 10^6), where a_i is the value of the i-th element of the array a.
The next m lines are contain two integers each. The j-th of them contains two integers l_j and r_j (1 ≤ l_j ≤ r_j ≤ n), where l_j and r_j are the ends of the j-th segment.
Output
In the first line of the output print one integer d — the maximum possible value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i if b is the array obtained by applying some subset of the given segments to the array a.
In the second line of the output print one integer q (0 ≤ q ≤ m) — the number of segments you apply.
In the third line print q distinct integers c_1, c_2, ..., c_q in any order (1 ≤ c_k ≤ m) — indices of segments you apply to the array a in such a way that the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i of the obtained array b is maximum possible.
If there are multiple answers, you can print any.
Examples
Input
5 4
2 -2 3 1 2
1 3
4 5
2 5
1 3
Output
6
2
1 4
Input
5 4
2 -2 3 1 4
3 5
3 4
2 4
2 5
Output
7
2
3 2
Input
1 0
1000000
Output
0
0
Note
In the first example the obtained array b will be [0, -4, 1, 1, 2] so the answer is 6.
In the second example the obtained array b will be [2, -3, 1, -1, 4] so the answer is 7.
In the third example you cannot do anything so the answer is 0. | instruction | 0 | 49,666 | 12 | 99,332 |
Tags: brute force, greedy, implementation
Correct Solution:
```
import sys
# from prg import *
from math import *
from copy import copy
n, m = input().split()
n = int(n)
m = int(m)
dat = [int(i) for i in input().split()]
otr = []
for i in range(m):
l, r = input().split()
l = int(l)
r = int(r)
otr.append((l-1,r-1))
best = 0
otrBest = []
for i in range(n):
iDat = copy(dat)
iBest = 0
iOtrBest = []
kosInd = 0
for ii in otr:
if(ii[0] <= i and i <= ii[1]):
kosInd += 1
continue
else:
iOtrBest.append(kosInd)
for iii in range(ii[0],ii[1]+1):
iDat[iii] -= 1
kosInd += 1
iBest = max(iDat) - min(iDat)
if(iBest > best):
otrBest = iOtrBest
best = iBest
# print(iDat)
print(best)
print(len(otrBest))
for l in otrBest:
print(l+1, end = ' ')
``` | output | 1 | 49,666 | 12 | 99,333 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is a number of elements in the array.
You are given an array a consisting of n integers. The value of the i-th element of the array is a_i.
You are also given a set of m segments. The j-th segment is [l_j; r_j], where 1 ≤ l_j ≤ r_j ≤ n.
You can choose some subset of the given set of segments and decrease values on each of the chosen segments by one (independently). For example, if the initial array a = [0, 0, 0, 0, 0] and the given segments are [1; 3] and [2; 4] then you can choose both of them and the array will become b = [-1, -2, -2, -1, 0].
You have to choose some subset of the given segments (each segment can be chosen at most once) in such a way that if you apply this subset of segments to the array a and obtain the array b then the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i will be maximum possible.
Note that you can choose the empty set.
If there are multiple answers, you can print any.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 300, 0 ≤ m ≤ 300) — the length of the array a and the number of segments, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^6 ≤ a_i ≤ 10^6), where a_i is the value of the i-th element of the array a.
The next m lines are contain two integers each. The j-th of them contains two integers l_j and r_j (1 ≤ l_j ≤ r_j ≤ n), where l_j and r_j are the ends of the j-th segment.
Output
In the first line of the output print one integer d — the maximum possible value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i if b is the array obtained by applying some subset of the given segments to the array a.
In the second line of the output print one integer q (0 ≤ q ≤ m) — the number of segments you apply.
In the third line print q distinct integers c_1, c_2, ..., c_q in any order (1 ≤ c_k ≤ m) — indices of segments you apply to the array a in such a way that the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i of the obtained array b is maximum possible.
If there are multiple answers, you can print any.
Examples
Input
5 4
2 -2 3 1 2
1 3
4 5
2 5
1 3
Output
6
2
1 4
Input
5 4
2 -2 3 1 4
3 5
3 4
2 4
2 5
Output
7
2
3 2
Input
1 0
1000000
Output
0
0
Note
In the first example the obtained array b will be [0, -4, 1, 1, 2] so the answer is 6.
In the second example the obtained array b will be [2, -3, 1, -1, 4] so the answer is 7.
In the third example you cannot do anything so the answer is 0. | instruction | 0 | 49,667 | 12 | 99,334 |
Tags: brute force, greedy, implementation
Correct Solution:
```
def f(a,b):
# if max(a)<0 and min(a)<0:
b=sorted(b,key=lambda s:s[1]-s[0])
t={}
for i in range(len(a)):
l=[]
for j in b:
if i in range(j[0],j[1]+1):
l.append(j)
t[i]=l
t=dict(sorted(t.items(),key=lambda s:a[s[0]]))
t=dict(sorted(t.items(),key=lambda s:len(s[1])-a[s[0]],reverse=True))
mn=list(t.items())[0]
curr=max(a)-min(a)
# print(mn)
bigans=0
bigd=[]
for mn in t.items():
s = a.copy()
ans = []
a2 = []
for i in mn[1]:
l=i[0]
r=i[1]
for j in range(l,r+1):
s[j]-=1
# print(s)
tempans=max(s)-min(s)
# print("tempans",i[2],tempans,curr,s)
# print(s,max(s),min(s),max(s)-min(s),i[2]+1)
if tempans>=curr:
a2.append(i[2]+1)
ans+=a2
a2=[]
else:
a2.append(i[2]+1)
curr=max(curr,tempans)
if bigans<curr:
bigans=curr
bigd=ans
else:
break
return bigd,bigans
a,b=map(int,input().strip().split())
blacnk=[]
lst=list(map(int,input().strip().split()))
for i in range(b):
l,r = map(int, input().strip().split())
blacnk.append([l-1,r-1,i])
x=f(lst,blacnk)
print(x[1])
print(len(x[0]))
print(*x[0])
``` | output | 1 | 49,667 | 12 | 99,335 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is a number of elements in the array.
You are given an array a consisting of n integers. The value of the i-th element of the array is a_i.
You are also given a set of m segments. The j-th segment is [l_j; r_j], where 1 ≤ l_j ≤ r_j ≤ n.
You can choose some subset of the given set of segments and decrease values on each of the chosen segments by one (independently). For example, if the initial array a = [0, 0, 0, 0, 0] and the given segments are [1; 3] and [2; 4] then you can choose both of them and the array will become b = [-1, -2, -2, -1, 0].
You have to choose some subset of the given segments (each segment can be chosen at most once) in such a way that if you apply this subset of segments to the array a and obtain the array b then the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i will be maximum possible.
Note that you can choose the empty set.
If there are multiple answers, you can print any.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 300, 0 ≤ m ≤ 300) — the length of the array a and the number of segments, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^6 ≤ a_i ≤ 10^6), where a_i is the value of the i-th element of the array a.
The next m lines are contain two integers each. The j-th of them contains two integers l_j and r_j (1 ≤ l_j ≤ r_j ≤ n), where l_j and r_j are the ends of the j-th segment.
Output
In the first line of the output print one integer d — the maximum possible value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i if b is the array obtained by applying some subset of the given segments to the array a.
In the second line of the output print one integer q (0 ≤ q ≤ m) — the number of segments you apply.
In the third line print q distinct integers c_1, c_2, ..., c_q in any order (1 ≤ c_k ≤ m) — indices of segments you apply to the array a in such a way that the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i of the obtained array b is maximum possible.
If there are multiple answers, you can print any.
Examples
Input
5 4
2 -2 3 1 2
1 3
4 5
2 5
1 3
Output
6
2
1 4
Input
5 4
2 -2 3 1 4
3 5
3 4
2 4
2 5
Output
7
2
3 2
Input
1 0
1000000
Output
0
0
Note
In the first example the obtained array b will be [0, -4, 1, 1, 2] so the answer is 6.
In the second example the obtained array b will be [2, -3, 1, -1, 4] so the answer is 7.
In the third example you cannot do anything so the answer is 0. | instruction | 0 | 49,668 | 12 | 99,336 |
Tags: brute force, greedy, implementation
Correct Solution:
```
from sys import stdin,stdout
from collections import defaultdict
import math
#stdin = open('input.txt','r')
I = stdin.readline
P = stdout.write
n,m = map(int,I().split())
arr = [int(x) for x in I().split()]
indi = defaultdict(lambda : set())
for j in range(m):
l,r = map(int,I().split())
for i in range(l-1,r):
indi[i].add(j+1)
ans = 0
a,b = 0,0
inter = set()
#print(indi)
for i in range(n):
for j in range(n):
nowint = indi[j].intersection(indi[i])
now = arr[i]-arr[j]+len(indi[j])-len(nowint)
if(now>ans):
ans = now
a = i
b = j
inter = nowint
print(ans)
#print(indi[b],nowint)
print(len(indi[b]))
for i in indi[b]:
print(i,end = " ")
``` | output | 1 | 49,668 | 12 | 99,337 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is a number of elements in the array.
You are given an array a consisting of n integers. The value of the i-th element of the array is a_i.
You are also given a set of m segments. The j-th segment is [l_j; r_j], where 1 ≤ l_j ≤ r_j ≤ n.
You can choose some subset of the given set of segments and decrease values on each of the chosen segments by one (independently). For example, if the initial array a = [0, 0, 0, 0, 0] and the given segments are [1; 3] and [2; 4] then you can choose both of them and the array will become b = [-1, -2, -2, -1, 0].
You have to choose some subset of the given segments (each segment can be chosen at most once) in such a way that if you apply this subset of segments to the array a and obtain the array b then the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i will be maximum possible.
Note that you can choose the empty set.
If there are multiple answers, you can print any.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 300, 0 ≤ m ≤ 300) — the length of the array a and the number of segments, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^6 ≤ a_i ≤ 10^6), where a_i is the value of the i-th element of the array a.
The next m lines are contain two integers each. The j-th of them contains two integers l_j and r_j (1 ≤ l_j ≤ r_j ≤ n), where l_j and r_j are the ends of the j-th segment.
Output
In the first line of the output print one integer d — the maximum possible value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i if b is the array obtained by applying some subset of the given segments to the array a.
In the second line of the output print one integer q (0 ≤ q ≤ m) — the number of segments you apply.
In the third line print q distinct integers c_1, c_2, ..., c_q in any order (1 ≤ c_k ≤ m) — indices of segments you apply to the array a in such a way that the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i of the obtained array b is maximum possible.
If there are multiple answers, you can print any.
Examples
Input
5 4
2 -2 3 1 2
1 3
4 5
2 5
1 3
Output
6
2
1 4
Input
5 4
2 -2 3 1 4
3 5
3 4
2 4
2 5
Output
7
2
3 2
Input
1 0
1000000
Output
0
0
Note
In the first example the obtained array b will be [0, -4, 1, 1, 2] so the answer is 6.
In the second example the obtained array b will be [2, -3, 1, -1, 4] so the answer is 7.
In the third example you cannot do anything so the answer is 0. | instruction | 0 | 49,669 | 12 | 99,338 |
Tags: brute force, greedy, implementation
Correct Solution:
```
import sys
input = sys.stdin.readline
n,m=map(int,input().split())
A=list(map(int,input().split()))
LR=[list(map(int,input().split())) for i in range(m)]
def MINUS(A,B):
MIN=float("inf")
MAX=-float("inf")
for i in range(len(A)):
if MIN>A[i]-B[i]:
MIN=A[i]-B[i]
if MAX<A[i]-B[i]:
MAX=A[i]-B[i]
return MAX-MIN
MINUSLIST=[[0]*n for i in range(n)]
for l,r in LR:
for j in range(l-1,r):
for k in range(l-1,r):
MINUSLIST[j][k]+=1
ANSLIST=[0]*n
for i in range(n):
ANSLIST[i]=MINUS(A,MINUSLIST[i])
print(max(ANSLIST))
x=ANSLIST.index(max(ANSLIST))
AN=[]
for i in range(m):
z,w=LR[i]
if z<=x+1<=w:
AN.append(i+1)
print(len(AN))
for a in AN:
print(a,end=" ")
``` | output | 1 | 49,669 | 12 | 99,339 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is a number of elements in the array.
You are given an array a consisting of n integers. The value of the i-th element of the array is a_i.
You are also given a set of m segments. The j-th segment is [l_j; r_j], where 1 ≤ l_j ≤ r_j ≤ n.
You can choose some subset of the given set of segments and decrease values on each of the chosen segments by one (independently). For example, if the initial array a = [0, 0, 0, 0, 0] and the given segments are [1; 3] and [2; 4] then you can choose both of them and the array will become b = [-1, -2, -2, -1, 0].
You have to choose some subset of the given segments (each segment can be chosen at most once) in such a way that if you apply this subset of segments to the array a and obtain the array b then the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i will be maximum possible.
Note that you can choose the empty set.
If there are multiple answers, you can print any.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 300, 0 ≤ m ≤ 300) — the length of the array a and the number of segments, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^6 ≤ a_i ≤ 10^6), where a_i is the value of the i-th element of the array a.
The next m lines are contain two integers each. The j-th of them contains two integers l_j and r_j (1 ≤ l_j ≤ r_j ≤ n), where l_j and r_j are the ends of the j-th segment.
Output
In the first line of the output print one integer d — the maximum possible value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i if b is the array obtained by applying some subset of the given segments to the array a.
In the second line of the output print one integer q (0 ≤ q ≤ m) — the number of segments you apply.
In the third line print q distinct integers c_1, c_2, ..., c_q in any order (1 ≤ c_k ≤ m) — indices of segments you apply to the array a in such a way that the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i of the obtained array b is maximum possible.
If there are multiple answers, you can print any.
Examples
Input
5 4
2 -2 3 1 2
1 3
4 5
2 5
1 3
Output
6
2
1 4
Input
5 4
2 -2 3 1 4
3 5
3 4
2 4
2 5
Output
7
2
3 2
Input
1 0
1000000
Output
0
0
Note
In the first example the obtained array b will be [0, -4, 1, 1, 2] so the answer is 6.
In the second example the obtained array b will be [2, -3, 1, -1, 4] so the answer is 7.
In the third example you cannot do anything so the answer is 0.
Submitted Solution:
```
#!/usr/bin/env python3
import sys
from atexit import register
from io import FileIO, StringIO
sys.stdin = StringIO(FileIO(0).read().decode())
input = lambda: sys.stdin.readline().rstrip('\r\n')
sys.stdout = StringIO()
register(lambda: FileIO(1, 'w').write(sys.stdout.getvalue().encode()))
def main():
n, m = map(int, input().split())
a = list(map(int, input().split()))
segments = list(list(map(int, input().split())) for _ in range(m))
best = 0
cnt = 0
ans = []
for i in range(n):
case = a[:]
res = []
for j in range(m):
if segments[j][0] <= i + 1 <= segments[j][1]:
res.append(j + 1)
for k in range(segments[j][0] - 1, segments[j][1]):
case[k] -= 1
tmp = max(case) - min(case)
if tmp > best:
best = tmp
cnt = len(res)
ans = res
print(best)
print(cnt)
print(*ans)
if __name__ == '__main__':
main()
``` | instruction | 0 | 49,670 | 12 | 99,340 |
Yes | output | 1 | 49,670 | 12 | 99,341 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is a number of elements in the array.
You are given an array a consisting of n integers. The value of the i-th element of the array is a_i.
You are also given a set of m segments. The j-th segment is [l_j; r_j], where 1 ≤ l_j ≤ r_j ≤ n.
You can choose some subset of the given set of segments and decrease values on each of the chosen segments by one (independently). For example, if the initial array a = [0, 0, 0, 0, 0] and the given segments are [1; 3] and [2; 4] then you can choose both of them and the array will become b = [-1, -2, -2, -1, 0].
You have to choose some subset of the given segments (each segment can be chosen at most once) in such a way that if you apply this subset of segments to the array a and obtain the array b then the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i will be maximum possible.
Note that you can choose the empty set.
If there are multiple answers, you can print any.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 300, 0 ≤ m ≤ 300) — the length of the array a and the number of segments, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^6 ≤ a_i ≤ 10^6), where a_i is the value of the i-th element of the array a.
The next m lines are contain two integers each. The j-th of them contains two integers l_j and r_j (1 ≤ l_j ≤ r_j ≤ n), where l_j and r_j are the ends of the j-th segment.
Output
In the first line of the output print one integer d — the maximum possible value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i if b is the array obtained by applying some subset of the given segments to the array a.
In the second line of the output print one integer q (0 ≤ q ≤ m) — the number of segments you apply.
In the third line print q distinct integers c_1, c_2, ..., c_q in any order (1 ≤ c_k ≤ m) — indices of segments you apply to the array a in such a way that the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i of the obtained array b is maximum possible.
If there are multiple answers, you can print any.
Examples
Input
5 4
2 -2 3 1 2
1 3
4 5
2 5
1 3
Output
6
2
1 4
Input
5 4
2 -2 3 1 4
3 5
3 4
2 4
2 5
Output
7
2
3 2
Input
1 0
1000000
Output
0
0
Note
In the first example the obtained array b will be [0, -4, 1, 1, 2] so the answer is 6.
In the second example the obtained array b will be [2, -3, 1, -1, 4] so the answer is 7.
In the third example you cannot do anything so the answer is 0.
Submitted Solution:
```
n, m = map(int, input().split())
A = list(map(int, input().split()))
Lf = [[] for _ in range(n)]
Rb = [[] for _ in range(n)]
LR = []
for i in range(m):
l, r = map(int, input().split())
l, r = l-1, r-1
Lf[r].append(l)
Rb[l].append(r)
LR.append((l, r))
minus = [0]*n
INF = 10**18
ans = [-INF]*n
mn = A[0]
for i in range(n):
ans[i] = max(ans[i], A[i]-mn)
for l in Lf[i]:
for j in range(l, i+1):
minus[j] -= 1
mn = min(mn, A[j]+minus[j])
mn = min(mn, A[i]+minus[i])
minus = [0]*n
mn = A[n-1]
for i in reversed(range(n)):
ans[i] = max(ans[i], A[i]-mn)
for r in Rb[i]:
for j in range(i, r+1):
minus[j] -= 1
mn = min(mn, A[j]+minus[j])
mn = min(mn, A[i]+minus[i])
ans_ = max(ans)
res = []
for i in range(n):
if ans[i] == ans_:
for j in range(m):
l, r = LR[j]
if not (l <= i and i <= r):
res.append(j+1)
break
print(ans_)
print(len(res))
print(*res)
``` | instruction | 0 | 49,671 | 12 | 99,342 |
Yes | output | 1 | 49,671 | 12 | 99,343 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is a number of elements in the array.
You are given an array a consisting of n integers. The value of the i-th element of the array is a_i.
You are also given a set of m segments. The j-th segment is [l_j; r_j], where 1 ≤ l_j ≤ r_j ≤ n.
You can choose some subset of the given set of segments and decrease values on each of the chosen segments by one (independently). For example, if the initial array a = [0, 0, 0, 0, 0] and the given segments are [1; 3] and [2; 4] then you can choose both of them and the array will become b = [-1, -2, -2, -1, 0].
You have to choose some subset of the given segments (each segment can be chosen at most once) in such a way that if you apply this subset of segments to the array a and obtain the array b then the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i will be maximum possible.
Note that you can choose the empty set.
If there are multiple answers, you can print any.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 300, 0 ≤ m ≤ 300) — the length of the array a and the number of segments, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^6 ≤ a_i ≤ 10^6), where a_i is the value of the i-th element of the array a.
The next m lines are contain two integers each. The j-th of them contains two integers l_j and r_j (1 ≤ l_j ≤ r_j ≤ n), where l_j and r_j are the ends of the j-th segment.
Output
In the first line of the output print one integer d — the maximum possible value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i if b is the array obtained by applying some subset of the given segments to the array a.
In the second line of the output print one integer q (0 ≤ q ≤ m) — the number of segments you apply.
In the third line print q distinct integers c_1, c_2, ..., c_q in any order (1 ≤ c_k ≤ m) — indices of segments you apply to the array a in such a way that the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i of the obtained array b is maximum possible.
If there are multiple answers, you can print any.
Examples
Input
5 4
2 -2 3 1 2
1 3
4 5
2 5
1 3
Output
6
2
1 4
Input
5 4
2 -2 3 1 4
3 5
3 4
2 4
2 5
Output
7
2
3 2
Input
1 0
1000000
Output
0
0
Note
In the first example the obtained array b will be [0, -4, 1, 1, 2] so the answer is 6.
In the second example the obtained array b will be [2, -3, 1, -1, 4] so the answer is 7.
In the third example you cannot do anything so the answer is 0.
Submitted Solution:
```
R=lambda:map(int,input().split())
n,m=R()
l=list(R())
d=max(l)-min(l)
s=[]
qc=[]
for i in range(m):
s.append(list(R()))
for i in range(1,n+1):
str=l.copy()
c=[]
for j in range(m):
if i not in range(s[j][0],s[j][1]+1):
c.append(j+1)
for t in range(s[j][0]-1,s[j][1]):
str[t]-=1
distance=max(str)-min(str)
if distance>d:
d=distance
qc=c
print(d,len(qc),sep='\n')
print(*qc)
``` | instruction | 0 | 49,672 | 12 | 99,344 |
Yes | output | 1 | 49,672 | 12 | 99,345 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is a number of elements in the array.
You are given an array a consisting of n integers. The value of the i-th element of the array is a_i.
You are also given a set of m segments. The j-th segment is [l_j; r_j], where 1 ≤ l_j ≤ r_j ≤ n.
You can choose some subset of the given set of segments and decrease values on each of the chosen segments by one (independently). For example, if the initial array a = [0, 0, 0, 0, 0] and the given segments are [1; 3] and [2; 4] then you can choose both of them and the array will become b = [-1, -2, -2, -1, 0].
You have to choose some subset of the given segments (each segment can be chosen at most once) in such a way that if you apply this subset of segments to the array a and obtain the array b then the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i will be maximum possible.
Note that you can choose the empty set.
If there are multiple answers, you can print any.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 300, 0 ≤ m ≤ 300) — the length of the array a and the number of segments, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^6 ≤ a_i ≤ 10^6), where a_i is the value of the i-th element of the array a.
The next m lines are contain two integers each. The j-th of them contains two integers l_j and r_j (1 ≤ l_j ≤ r_j ≤ n), where l_j and r_j are the ends of the j-th segment.
Output
In the first line of the output print one integer d — the maximum possible value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i if b is the array obtained by applying some subset of the given segments to the array a.
In the second line of the output print one integer q (0 ≤ q ≤ m) — the number of segments you apply.
In the third line print q distinct integers c_1, c_2, ..., c_q in any order (1 ≤ c_k ≤ m) — indices of segments you apply to the array a in such a way that the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i of the obtained array b is maximum possible.
If there are multiple answers, you can print any.
Examples
Input
5 4
2 -2 3 1 2
1 3
4 5
2 5
1 3
Output
6
2
1 4
Input
5 4
2 -2 3 1 4
3 5
3 4
2 4
2 5
Output
7
2
3 2
Input
1 0
1000000
Output
0
0
Note
In the first example the obtained array b will be [0, -4, 1, 1, 2] so the answer is 6.
In the second example the obtained array b will be [2, -3, 1, -1, 4] so the answer is 7.
In the third example you cannot do anything so the answer is 0.
Submitted Solution:
```
import sys
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n,m = inpl()
a = inpl()
mx = max(a)
a = [-(x-mx) for x in a]
s = [inpl() for _ in range(m)]
res = 0
Q = []
for i in range(n-1):
for j in range(i+1,n):
big,sml = i,j
q = []
cnt = 0
for k,(l,r) in enumerate(s):
if (l-1 <= big <= r-1) and (not l-1 <= sml <= r-1):
q.append(k+1)
cnt += 1
ans = a[big]-a[sml] + cnt
if ans > res:
res = ans
Q = q[::]
big,sml = sml,big
q = []
cnt = 0
for k,(l,r) in enumerate(s):
if (l-1 <= big <= r-1) and (not l-1 <= sml <= r-1):
q.append(k+1)
cnt += 1
ans = a[big]-a[sml] + cnt
if ans > res:
res = ans
Q = q[::]
print(res)
print(len(Q))
print(*Q)
``` | instruction | 0 | 49,673 | 12 | 99,346 |
Yes | output | 1 | 49,673 | 12 | 99,347 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is a number of elements in the array.
You are given an array a consisting of n integers. The value of the i-th element of the array is a_i.
You are also given a set of m segments. The j-th segment is [l_j; r_j], where 1 ≤ l_j ≤ r_j ≤ n.
You can choose some subset of the given set of segments and decrease values on each of the chosen segments by one (independently). For example, if the initial array a = [0, 0, 0, 0, 0] and the given segments are [1; 3] and [2; 4] then you can choose both of them and the array will become b = [-1, -2, -2, -1, 0].
You have to choose some subset of the given segments (each segment can be chosen at most once) in such a way that if you apply this subset of segments to the array a and obtain the array b then the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i will be maximum possible.
Note that you can choose the empty set.
If there are multiple answers, you can print any.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 300, 0 ≤ m ≤ 300) — the length of the array a and the number of segments, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^6 ≤ a_i ≤ 10^6), where a_i is the value of the i-th element of the array a.
The next m lines are contain two integers each. The j-th of them contains two integers l_j and r_j (1 ≤ l_j ≤ r_j ≤ n), where l_j and r_j are the ends of the j-th segment.
Output
In the first line of the output print one integer d — the maximum possible value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i if b is the array obtained by applying some subset of the given segments to the array a.
In the second line of the output print one integer q (0 ≤ q ≤ m) — the number of segments you apply.
In the third line print q distinct integers c_1, c_2, ..., c_q in any order (1 ≤ c_k ≤ m) — indices of segments you apply to the array a in such a way that the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i of the obtained array b is maximum possible.
If there are multiple answers, you can print any.
Examples
Input
5 4
2 -2 3 1 2
1 3
4 5
2 5
1 3
Output
6
2
1 4
Input
5 4
2 -2 3 1 4
3 5
3 4
2 4
2 5
Output
7
2
3 2
Input
1 0
1000000
Output
0
0
Note
In the first example the obtained array b will be [0, -4, 1, 1, 2] so the answer is 6.
In the second example the obtained array b will be [2, -3, 1, -1, 4] so the answer is 7.
In the third example you cannot do anything so the answer is 0.
Submitted Solution:
```
n, m = map(int, input().split())
A = list(map(int, input().split()))
Lf = [[] for _ in range(n)]
Rb = [[] for _ in range(n)]
LR = []
for i in range(m):
l, r = map(int, input().split())
l, r = l-1, r-1
Lf[r].append(l)
Rb[l].append(r)
LR.append((l, r))
minus = [0]*n
INF = 10**18
ans = [-INF]*n
mn = A[0]
for i in range(n):
ans[i] = max(ans[i], A[i]-mn)
for l in Lf[i]:
for j in range(l, i+1):
minus[j] -= 1
mn = min(mn, A[j]+minus[j])
mn = min(mn, A[i]+minus[i])
minus = [0]*n
mn = A[n-1]
for i in reversed(range(n)):
ans[i] = max(ans[i], A[i]-mn)
for r in Rb[i]:
for j in range(i, r+1):
minus[j] -= 1
mn = min(mn, A[j]+minus[j])
mn = min(mn, A[i]+minus[i])
ans_ = max(ans)
res = []
for i in range(n):
if ans[i] == ans_:
for j in range(m):
l, r = LR[j]
if not (l <= i and i <= r):
res.append(j+1)
print(ans_)
print(len(res))
print(*res)
``` | instruction | 0 | 49,674 | 12 | 99,348 |
No | output | 1 | 49,674 | 12 | 99,349 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is a number of elements in the array.
You are given an array a consisting of n integers. The value of the i-th element of the array is a_i.
You are also given a set of m segments. The j-th segment is [l_j; r_j], where 1 ≤ l_j ≤ r_j ≤ n.
You can choose some subset of the given set of segments and decrease values on each of the chosen segments by one (independently). For example, if the initial array a = [0, 0, 0, 0, 0] and the given segments are [1; 3] and [2; 4] then you can choose both of them and the array will become b = [-1, -2, -2, -1, 0].
You have to choose some subset of the given segments (each segment can be chosen at most once) in such a way that if you apply this subset of segments to the array a and obtain the array b then the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i will be maximum possible.
Note that you can choose the empty set.
If there are multiple answers, you can print any.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 300, 0 ≤ m ≤ 300) — the length of the array a and the number of segments, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^6 ≤ a_i ≤ 10^6), where a_i is the value of the i-th element of the array a.
The next m lines are contain two integers each. The j-th of them contains two integers l_j and r_j (1 ≤ l_j ≤ r_j ≤ n), where l_j and r_j are the ends of the j-th segment.
Output
In the first line of the output print one integer d — the maximum possible value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i if b is the array obtained by applying some subset of the given segments to the array a.
In the second line of the output print one integer q (0 ≤ q ≤ m) — the number of segments you apply.
In the third line print q distinct integers c_1, c_2, ..., c_q in any order (1 ≤ c_k ≤ m) — indices of segments you apply to the array a in such a way that the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i of the obtained array b is maximum possible.
If there are multiple answers, you can print any.
Examples
Input
5 4
2 -2 3 1 2
1 3
4 5
2 5
1 3
Output
6
2
1 4
Input
5 4
2 -2 3 1 4
3 5
3 4
2 4
2 5
Output
7
2
3 2
Input
1 0
1000000
Output
0
0
Note
In the first example the obtained array b will be [0, -4, 1, 1, 2] so the answer is 6.
In the second example the obtained array b will be [2, -3, 1, -1, 4] so the answer is 7.
In the third example you cannot do anything so the answer is 0.
Submitted Solution:
```
def read_nums():
return [int(x) for x in input().split()]
def calculate_diff(i1, i2, nums, all_segments):
cur_diff = nums[i2] - nums[i1]
used_segments = []
for index, segment in enumerate(all_segments):
left, right = segment
if left <= i1 <= right and not (left <= i2 <= right):
used_segments.append(index)
cur_diff += 1
return cur_diff, used_segments
def main():
n, m = read_nums()
nums = read_nums()
segments = [[x-1 for x in read_nums()] for _ in range(m)]
if n == 1:
print(0)
print(0)
return
candidates = []
for i1, num1 in enumerate(nums):
for i2, num2 in enumerate(nums):
if i1 == i2 or num1 > num2:
continue
diff, used_segments = calculate_diff(i1, i2, nums, segments)
candidates.append((diff, used_segments))
res_diff, segment_indexes = max(candidates, key=lambda x: x[0])
print(res_diff)
print(len(segment_indexes))
if len(segment_indexes) > 0:
print(' '.join([str(x + 1) for x in segment_indexes]))
if __name__ == '__main__':
main()
``` | instruction | 0 | 49,675 | 12 | 99,350 |
No | output | 1 | 49,675 | 12 | 99,351 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is a number of elements in the array.
You are given an array a consisting of n integers. The value of the i-th element of the array is a_i.
You are also given a set of m segments. The j-th segment is [l_j; r_j], where 1 ≤ l_j ≤ r_j ≤ n.
You can choose some subset of the given set of segments and decrease values on each of the chosen segments by one (independently). For example, if the initial array a = [0, 0, 0, 0, 0] and the given segments are [1; 3] and [2; 4] then you can choose both of them and the array will become b = [-1, -2, -2, -1, 0].
You have to choose some subset of the given segments (each segment can be chosen at most once) in such a way that if you apply this subset of segments to the array a and obtain the array b then the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i will be maximum possible.
Note that you can choose the empty set.
If there are multiple answers, you can print any.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 300, 0 ≤ m ≤ 300) — the length of the array a and the number of segments, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^6 ≤ a_i ≤ 10^6), where a_i is the value of the i-th element of the array a.
The next m lines are contain two integers each. The j-th of them contains two integers l_j and r_j (1 ≤ l_j ≤ r_j ≤ n), where l_j and r_j are the ends of the j-th segment.
Output
In the first line of the output print one integer d — the maximum possible value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i if b is the array obtained by applying some subset of the given segments to the array a.
In the second line of the output print one integer q (0 ≤ q ≤ m) — the number of segments you apply.
In the third line print q distinct integers c_1, c_2, ..., c_q in any order (1 ≤ c_k ≤ m) — indices of segments you apply to the array a in such a way that the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i of the obtained array b is maximum possible.
If there are multiple answers, you can print any.
Examples
Input
5 4
2 -2 3 1 2
1 3
4 5
2 5
1 3
Output
6
2
1 4
Input
5 4
2 -2 3 1 4
3 5
3 4
2 4
2 5
Output
7
2
3 2
Input
1 0
1000000
Output
0
0
Note
In the first example the obtained array b will be [0, -4, 1, 1, 2] so the answer is 6.
In the second example the obtained array b will be [2, -3, 1, -1, 4] so the answer is 7.
In the third example you cannot do anything so the answer is 0.
Submitted Solution:
```
n, m = map(int, input().split())
inputList = [0] + list(map(int, input().split())) + [0]
inputIntervals = []
for _ in range(m):
inputIntervals.append(tuple(map(int, input().split())))
def wynik(in1, in2):
intervals = [[] for _ in range(n + 1)]
for (nr, (a, b)) in enumerate(in2):
intervals[b] += [(a, nr + 1)]
wyn = (0, [])
minek = in1[1]
numerki = []
for i in range(2, n + 1):
minek = min(minek, in1[i - 1])
for (j, ind) in intervals[i - 1]:
for k in range(j, i):
in1[k] -= 1
minek = min(minek, in1[k])
numerki += [ind]
wyn = max(wyn, (in1[i] - minek, numerki))
return wyn
odp = max(wynik(list(reversed(inputList)),
list(map(lambda x: (n - x[1] + 1, n - x[0] + 1), inputIntervals))),
wynik(inputList, inputIntervals))
print(odp[0], len(odp[1]), sep='\n')
print(*odp[1])
``` | instruction | 0 | 49,676 | 12 | 99,352 |
No | output | 1 | 49,676 | 12 | 99,353 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is a number of elements in the array.
You are given an array a consisting of n integers. The value of the i-th element of the array is a_i.
You are also given a set of m segments. The j-th segment is [l_j; r_j], where 1 ≤ l_j ≤ r_j ≤ n.
You can choose some subset of the given set of segments and decrease values on each of the chosen segments by one (independently). For example, if the initial array a = [0, 0, 0, 0, 0] and the given segments are [1; 3] and [2; 4] then you can choose both of them and the array will become b = [-1, -2, -2, -1, 0].
You have to choose some subset of the given segments (each segment can be chosen at most once) in such a way that if you apply this subset of segments to the array a and obtain the array b then the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i will be maximum possible.
Note that you can choose the empty set.
If there are multiple answers, you can print any.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 300, 0 ≤ m ≤ 300) — the length of the array a and the number of segments, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^6 ≤ a_i ≤ 10^6), where a_i is the value of the i-th element of the array a.
The next m lines are contain two integers each. The j-th of them contains two integers l_j and r_j (1 ≤ l_j ≤ r_j ≤ n), where l_j and r_j are the ends of the j-th segment.
Output
In the first line of the output print one integer d — the maximum possible value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i if b is the array obtained by applying some subset of the given segments to the array a.
In the second line of the output print one integer q (0 ≤ q ≤ m) — the number of segments you apply.
In the third line print q distinct integers c_1, c_2, ..., c_q in any order (1 ≤ c_k ≤ m) — indices of segments you apply to the array a in such a way that the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i of the obtained array b is maximum possible.
If there are multiple answers, you can print any.
Examples
Input
5 4
2 -2 3 1 2
1 3
4 5
2 5
1 3
Output
6
2
1 4
Input
5 4
2 -2 3 1 4
3 5
3 4
2 4
2 5
Output
7
2
3 2
Input
1 0
1000000
Output
0
0
Note
In the first example the obtained array b will be [0, -4, 1, 1, 2] so the answer is 6.
In the second example the obtained array b will be [2, -3, 1, -1, 4] so the answer is 7.
In the third example you cannot do anything so the answer is 0.
Submitted Solution:
```
import collections
import functools
import math
import random
import sys
import bisect
input = sys.stdin.readline
def In():
return map(int, sys.stdin.readline().split())
def arrsegez():
n,m = In()
l = list(In())
segs = [set() for _ in range(n)]
for i in range(m):
le,r = In()
for x in range(le-1,r):
segs[x].add(i+1)
maxc = -math.inf
ansseg = {}
for i in range(n):
for i1 in range(i+1,n):
c = l[i1] - l[i]
seg = segs[i] - segs[i1]
c += len(seg)
if maxc < c:
ansseg = seg
maxc = c
print(maxc if maxc != -math.inf else 0)
print(len(ansseg))
print(*ansseg)
arrsegez()
``` | instruction | 0 | 49,677 | 12 | 99,354 |
No | output | 1 | 49,677 | 12 | 99,355 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a set of points x_1, x_2, ..., x_n on the number line.
Two points i and j can be matched with each other if the following conditions hold:
* neither i nor j is matched with any other point;
* |x_i - x_j| ≥ z.
What is the maximum number of pairs of points you can match with each other?
Input
The first line contains two integers n and z (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ z ≤ 10^9) — the number of points and the constraint on the distance between matched points, respectively.
The second line contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^9).
Output
Print one integer — the maximum number of pairs of points you can match with each other.
Examples
Input
4 2
1 3 3 7
Output
2
Input
5 5
10 9 5 8 7
Output
1
Note
In the first example, you may match point 1 with point 2 (|3 - 1| ≥ 2), and point 3 with point 4 (|7 - 3| ≥ 2).
In the second example, you may match point 1 with point 3 (|5 - 10| ≥ 5). | instruction | 0 | 49,697 | 12 | 99,394 |
Tags: binary search, greedy, sortings, ternary search, two pointers
Correct Solution:
```
n,k=map(int,input().split())
a=[int(x) for x in input().split()]
ans=0
i,j=0,n//2
l=[]
a.sort()
while i<n//2 and j<n:
if a[j]-a[i]>=k:
ans+=1
i+=1
j+=1
else:
j+=1
print(ans)
``` | output | 1 | 49,697 | 12 | 99,395 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a set of points x_1, x_2, ..., x_n on the number line.
Two points i and j can be matched with each other if the following conditions hold:
* neither i nor j is matched with any other point;
* |x_i - x_j| ≥ z.
What is the maximum number of pairs of points you can match with each other?
Input
The first line contains two integers n and z (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ z ≤ 10^9) — the number of points and the constraint on the distance between matched points, respectively.
The second line contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^9).
Output
Print one integer — the maximum number of pairs of points you can match with each other.
Examples
Input
4 2
1 3 3 7
Output
2
Input
5 5
10 9 5 8 7
Output
1
Note
In the first example, you may match point 1 with point 2 (|3 - 1| ≥ 2), and point 3 with point 4 (|7 - 3| ≥ 2).
In the second example, you may match point 1 with point 3 (|5 - 10| ≥ 5). | instruction | 0 | 49,700 | 12 | 99,400 |
Tags: binary search, greedy, sortings, ternary search, two pointers
Correct Solution:
```
import math
def can(arr, count, min_dist):
for i in range(count):
if arr[len(arr) - count + i] - arr[i] < min_dist:
return False
return True
def binsearch(arr, from_, to_, min_dist):
arr.sort()
if from_ == to_:
return from_
mid = math.ceil((to_ + from_) / 2)
if can(arr, mid, min_dist):
return binsearch(arr, mid, to_, min_dist)
else:
return binsearch(arr, from_, mid - 1, min_dist)
if __name__ == '__main__':
n, k = list(map(int, input().split()))
arr = list(map(int, input().split()))
print(binsearch(arr, 0, n // 2, k))
``` | output | 1 | 49,700 | 12 | 99,401 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2. | instruction | 0 | 49,802 | 12 | 99,604 |
Tags: binary search, bitmasks, constructive algorithms, data structures, math, sortings
Correct Solution:
```
import math
input_list = lambda: list(map(int, input().split()))
def main():
n = int(input())
a = input_list()
temp = []
ans = 0
for bit in range(26):
temp.clear()
value1 = 2**bit
value2 = 2**(bit + 1) - 1
value3 = 2**(bit + 1) + 2**bit
value4 = 2**(bit + 2) - 1
for i in range(n):
temp.append(a[i]%(2**(bit+1)))
f1, l1, f2, l2 = [n-1, n-1, n-1, n-1]
temp.sort()
noOfOnes = 0
for i in range(n):
while f1>=0 and temp[f1]+temp[i]>=value1:
f1 = f1 - 1
while l1>=0 and temp[l1] + temp[i]>value2:
l1 = l1 - 1
while f2>=0 and temp[f2] + temp[i]>=value3 :
f2 = f2 - 1
while l2>=0 and temp[l2] + temp[i]>value4:
l2 = l2 - 1
noOfOnes = noOfOnes + max(0, l1 - max(i,f1))
noOfOnes = noOfOnes + max(0, l2 - max(i, f2))
if noOfOnes%2==1:
ans = ans + 2**bit
print(ans)
main()
``` | output | 1 | 49,802 | 12 | 99,605 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2. | instruction | 0 | 49,803 | 12 | 99,606 |
Tags: binary search, bitmasks, constructive algorithms, data structures, math, sortings
Correct Solution:
```
import sys
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
b = a
ans = 0
for k in range(29):
a0 = []
a1 = []
a0a = a0.append
a1a = a1.append
b0 = []
b1 = []
b0a = b0.append
b1a = b1.append
for i in a:
if i&(1<<k): a1a(i)
else: a0a(i)
for i in b:
if i&(1<<k): b1a(i)
else: b0a(i)
a = a0+a1
b = b0+b1
mask = (1<<(k+1))-1
aa = [i&mask for i in a]
bb = [i&mask for i in b]
res = 0
p1 = 1<<k
p2 = mask+1
p3 = p1+p2
j1 = j2 = j3 = 0
for jj, ai in enumerate(reversed(aa)):
while j1 < n and ai+bb[j1] < p1:
j1 += 1
while j2 < n and ai+bb[j2] < p2:
j2 += 1
while j3 < n and ai+bb[j3] < p3:
j3 += 1
res += max(n, n - jj) - max(j3, n - jj)
res += max(j2, n - jj) - max(j1, n - jj)
ans |= (res & 1) << k
print(ans)
``` | output | 1 | 49,803 | 12 | 99,607 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2. | instruction | 0 | 49,804 | 12 | 99,608 |
Tags: binary search, bitmasks, constructive algorithms, data structures, math, sortings
Correct Solution:
```
import sys
input = sys.stdin.readline
n=int(input())
A=list(map(int,input().split()))
ANS=0
for i in range(26):
B=[]
for a in A:
B.append(a & ((1<<(i+1))-1))
B.sort()
j0=n-1
j1=n-1
j2=n-1
count=0
for j in range(n):
while j0>=0 and B[j0]+B[j]>=(1<<i):
j0-=1
while j1>=0 and B[j1]+B[j]>(1<<(i+1))-1:
j1-=1
while j2>=0 and B[j2]+B[j]>=(1<<i)+(1<<(i+1)):
j2-=1
#print(B,B[j],j,j0,j1,j2)
count+=(max(j,j1)-max(j,j0))+(n-1-max(j,j2))
if count%2==1:
ANS+=1<<i
print(ANS)
``` | output | 1 | 49,804 | 12 | 99,609 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2. | instruction | 0 | 49,805 | 12 | 99,610 |
Tags: binary search, bitmasks, constructive algorithms, data structures, math, sortings
Correct Solution:
```
from sys import stdin, stdout
import math
def main():
n = int(stdin.readline())
arr = list(map(int, stdin.readline().split()))
ans = 0
for bit in range(25):
mask = (1<<bit+1)-1
bit0 = []
bit1 = []
for x in arr:
if x&(1<<bit): bit1.append(x)
else: bit0.append(x)
arr = bit0 + bit1
temp_arr = [mask&x for x in arr]
above = (1<<(bit+1))
current = (1<<bit)
abc = above + current
j1 = j2 = j3 = 0
res = 0
for i,x in enumerate(reversed(temp_arr)):
while j1 < n and temp_arr[j1] + x < current:
j1+=1
while j2 < n and temp_arr[j2] + x < above:
j2+=1
while j3 < n and temp_arr[j3] + x < abc:
j3+=1
r1 = (n-i) - j3 -1
if r1 < 0:
r1 = 0
r2 = min(n-i-1, j2) - j1
if r2 < 0:
r2 = 0
res += (r1 + r2) % 2
if res % 2 == 1:
ans+= current
stdout.write(str(ans))
main()
``` | output | 1 | 49,805 | 12 | 99,611 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2. | instruction | 0 | 49,806 | 12 | 99,612 |
Tags: binary search, bitmasks, constructive algorithms, data structures, math, sortings
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
def cal(arr,mask):
su,j = 0,0
for i in range(len(arr)-1,-1,-1):
while j != len(arr) and arr[i]+arr[j] < mask:
j += 1
if j >= i:
return su
su += i-j
return su
def cal1(arr,arr1,mask):
su,j = 0,0
for i in range(len(arr)-1,-1,-1):
while j != len(arr1) and arr[i]+arr1[j] < mask:
j += 1
su += j
return su
def main():
n = int(input())
a = list(map(int,input().split()))
su = sum(a[i]&1 for i in range(n))*sum(not a[i]&1 for i in range(n))
ans,mask,mask1 = su&1,1,1
for bit in range(1,25):
mask <<= 1
fir,sec = [],[]
for i in a:
fir.append(i&mask1) if i&mask else sec.append(i&mask1)
fir.sort(),sec.sort()
su = cal(fir,mask)+cal(sec,mask)+cal1(fir,sec,mask)
if su&1:
ans |= mask
mask1 |= mask
print(ans)
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | output | 1 | 49,806 | 12 | 99,613 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2. | instruction | 0 | 49,807 | 12 | 99,614 |
Tags: binary search, bitmasks, constructive algorithms, data structures, math, sortings
Correct Solution:
```
import sys, math
import io, os
#data = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
from bisect import bisect_left as bl, bisect_right as br, insort
from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter
#from itertools import permutations,combinations
def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var) : sys.stdout.write('\n'.join(map(str, var))+'\n')
def out(var) : sys.stdout.write(str(var)+'\n')
#from decimal import Decimal
#from fractions import Fraction
#sys.setrecursionlimit(100000)
INF = float('inf')
mod=10**9+7
n=int(data())
a=mdata()
ans=0
for i in range(26):
M=[]
for j in a:
M.append(j & ((1<<(i+1))-1))
M.sort()
j1=j2=j3=n-1
cnt=0
for j in range(n):
while j1>=0 and M[j]+M[j1]>=(1<<i):
j1-=1
while j2>=0 and M[j]+M[j2]>=(1<<(i+1)):
j2-=1
while j3>=0 and M[j]+M[j3]>=((1<<i) + (1<<(i+1))):
j3-=1
cnt+=max(j,j2)-max(j,j1)+n-max(j,j3)-1
if cnt%2==1:
ans+=1<<i
out(ans)
``` | output | 1 | 49,807 | 12 | 99,615 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2. | instruction | 0 | 49,808 | 12 | 99,616 |
Tags: binary search, bitmasks, constructive algorithms, data structures, math, sortings
Correct Solution:
```
from collections import defaultdict
from queue import deque
def arrinp():
return [*map(int, input().split(' '))]
def mulinp():
return map(int, input().split(' '))
def intinp():
return int(input())
def solution():
co=0
n=int(input())
l=list(map(int, input().split()))
for e in range(1,25):
po=2**e
re=sorted([k%po for k in l])
b=n
r=0
for a in range(n):
b-=1
while re[a]+re[b]>=po and b>=0:
b-=1
b+=1
r+=n-b-(a>=b)
r//=2
if r%2:
co+=2**e
if n%2==0:
for k in l:
co=co^k
print(co)
testcases = 1
# testcases = int(input())
for _ in range(testcases):
solution()
``` | output | 1 | 49,808 | 12 | 99,617 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2. | instruction | 0 | 49,809 | 12 | 99,618 |
Tags: binary search, bitmasks, constructive algorithms, data structures, math, sortings
Correct Solution:
```
for z in range(1):
co=0
n=int(input())
l=list(map(int, input().split()))
for e in range(1,25):
po=2**e
re=sorted([k%po for k in l])
b=n
r=0
for a in range(n):
b-=1
while re[a]+re[b]>=po and b>=0:
b-=1
b+=1
r+=n-b-(a>=b)
r//=2
if r%2:
co+=2**e
if n%2==0:
for k in l:
co=co^k
print(co)
``` | output | 1 | 49,809 | 12 | 99,619 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2.
Submitted Solution:
```
import io
import os
from collections import deque, defaultdict, Counter
from bisect import bisect_left, bisect_right
DEBUG = False
def solveBrute(N, A):
ans = 0
for i in range(N):
for j in range(i + 1, N):
ans ^= A[i] + A[j]
return ans
def solve(N, A):
B = max(A).bit_length()
ans = 0
for k in range(B + 1):
# Count number of pairs with kth bit on (0 indexed)
# For example if k==2, want pairs where lower 3 bits are between 100 and 111 inclusive
# If we mask A to the lower 3 bits, we can find all pairs that sum to either 100 to 111 or overflowed to 1100 to 1111
MOD = 1 << (k + 1)
MASK = MOD - 1
# Sort by x & MASK incrementally
left = []
right = []
for x in A:
if (x >> k) & 1:
right.append(x)
else:
left.append(x)
A = left + right
arr = [x & MASK for x in A]
if DEBUG:
assert arr == sorted(arr)
numPairs = 0
tLo = 1 << k
tHi = (1 << (k + 1)) - 1
for targetLo, targetHi in [(tLo, tHi), (MOD + tLo, MOD + tHi)]:
# Want to binary search for y such that targetLo <= x + y <= targetHi
# But this TLE so walk the lo/hi pointers instead
lo = N
hi = N
for i, x in enumerate(arr):
lo = max(lo, i + 1)
hi = max(hi, lo)
while lo - 1 >= i + 1 and arr[lo - 1] >= targetLo - x:
lo -= 1
while hi - 1 >= lo and arr[hi - 1] > targetHi - x:
hi -= 1
numPairs += hi - lo
if DEBUG:
# Check
assert lo == bisect_left(arr, targetLo - x, i + 1)
assert hi == bisect_right(arr, targetHi - x, lo)
for j, y in enumerate(arr):
cond = i < j and targetLo <= x + y <= targetHi
if lo <= j < hi:
assert cond
else:
assert not cond
ans += (numPairs % 2) << k
return ans
if DEBUG:
import random
random.seed(0)
for i in range(100):
A = [random.randint(1, 1000) for i in range(100)]
N = len(A)
ans1 = solveBrute(N, A)
ans2 = solve(N, A)
print(A, bin(ans1), bin(ans2))
assert ans1 == ans2
else:
if False:
# Timing
import random
random.seed(0)
A = [random.randint(1, 10 ** 7) for i in range(400000)]
N = len(A)
print(solve(N, A))
if __name__ == "__main__":
(N,) = list(map(int, input().split()))
A = list(map(int, input().split()))
ans = solve(N, A)
print(ans)
``` | instruction | 0 | 49,810 | 12 | 99,620 |
Yes | output | 1 | 49,810 | 12 | 99,621 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2.
Submitted Solution:
```
import math
import sys
input = sys.stdin.readline
input_list = lambda: list(map(int, input().split()))
def main():
n = int(input())
a = input_list()
temp = []
ans = 0
for bit in range(26):
temp.clear()
value1 = 2**bit
value2 = 2**(bit + 1) - 1
value3 = 2**(bit + 1) + 2**bit
value4 = 2**(bit + 2) - 1
for i in range(n):
temp.append(a[i]%(2**(bit+1)))
f1, l1, f2, l2 = [n-1, n-1, n-1, n-1]
temp.sort()
noOfOnes = 0
for i in range(n):
while f1>=0 and temp[f1]+temp[i]>=value1:
f1 = f1 - 1
while l1>=0 and temp[l1] + temp[i]>value2:
l1 = l1 - 1
while f2>=0 and temp[f2] + temp[i]>=value3 :
f2 = f2 - 1
while l2>=0 and temp[l2] + temp[i]>value4:
l2 = l2 - 1
noOfOnes = noOfOnes + max(0, l1 - max(i,f1))
noOfOnes = noOfOnes + max(0, l2 - max(i, f2))
if noOfOnes%2==1:
ans = ans + 2**bit
print(ans)
main()
``` | instruction | 0 | 49,811 | 12 | 99,622 |
Yes | output | 1 | 49,811 | 12 | 99,623 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2.
Submitted Solution:
```
import io
import os
from collections import deque, defaultdict, Counter
from bisect import bisect_left, bisect_right
DEBUG = False
def solveBrute(N, A):
ans = 0
for i in range(N):
for j in range(i + 1, N):
ans ^= A[i] + A[j]
return ans
def solve(N, A):
B = max(A).bit_length()
ans = 0
for k in range(B + 1):
# Count number of pairs with kth bit on (0 indexed)
# For example if k==2, want pairs where lower 3 bits are between 100 and 111 inclusive
# If we mask A to the lower 3 bits, we can find all pairs that sum to either 100 to 111 or overflowed to 1100 to 1111
MOD = 1 << (k + 1)
MASK = MOD - 1
# Sort by x & MASK incrementally
i = 0
right = []
for x in A:
if (x >> k) & 1:
right.append(x)
else:
A[i] = x
i += 1
assert N - i == len(right)
A[i:] = right
arr = [x & MASK for x in A]
if DEBUG:
assert arr == sorted(arr)
numPairs = 0
tlo = 1 << k
thi = (1 << (k + 1)) - 1
for targetLo, targetHi in [(tlo, thi), (MOD + tlo, MOD + thi)]:
# Want to binary search for y such that targetLo <= x + y <= targetHi
# But this TLE so walk the lo/hi pointers instead
lo = N
hi = N
for i, x in enumerate(arr):
lo = max(lo, i + 1)
hi = max(hi, lo)
while lo - 1 >= i + 1 and arr[lo - 1] >= targetLo - x:
lo -= 1
while hi - 1 >= lo and arr[hi - 1] >= targetHi - x + 1:
hi -= 1
numPairs += hi - lo
if DEBUG:
assert lo == bisect_left(arr, targetLo - x, i + 1)
assert hi == bisect_right(arr, targetHi - x, lo)
# Check
for j, y in enumerate(arr):
cond = i < j and targetLo <= x + y <= targetHi
if lo <= j < hi:
assert cond
else:
assert not cond
ans += (numPairs % 2) << k
return ans
if DEBUG:
import random
random.seed(0)
for i in range(100):
A = [random.randint(1, 1000) for i in range(100)]
N = len(A)
ans1 = solveBrute(N, A)
ans2 = solve(N, A)
print(A, bin(ans1), bin(ans2))
assert ans1 == ans2
else:
if False:
# Timing
import random
random.seed(0)
A = [random.randint(1, 10 ** 7) for i in range(400000)]
N = len(A)
print(solve(N, A))
if __name__ == "__main__":
(N,) = list(map(int, input().split()))
A = list(map(int, input().split()))
ans = solve(N, A)
print(ans)
``` | instruction | 0 | 49,812 | 12 | 99,624 |
Yes | output | 1 | 49,812 | 12 | 99,625 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2.
Submitted Solution:
```
from sys import stdin, stdout
def main():
n = int(stdin.readline())
arr = list(map(int, stdin.readline().split()))
ans = 0
for bit in range(29):
mask = (1<<bit+1)-1
bit0 = []
bit1 = []
for x in arr:
if x&(1<<bit): bit1.append(x)
else: bit0.append(x)
arr = bit0 + bit1
temp_arr = [mask&x for x in arr]
above = (1<<(bit+1))
current = (1<<bit)
abc = above + current
j1 = j2 = j3 = 0
res = 0
for i,x in enumerate(reversed(temp_arr)):
while j1 < n and temp_arr[j1] + x < current:
j1+=1
while j2 < n and temp_arr[j2] + x < above:
j2+=1
while j3 < n and temp_arr[j3] + x < abc:
j3+=1
r1 = (n-i) - j3 -1
if r1 < 0:
r1 = 0
r2 = min(n-i-1, j2) - j1
if r2 < 0:
r2 = 0
res += (r1 + r2) % 2
if res % 2 == 1:
ans+= current
stdout.write(str(ans))
main()
``` | instruction | 0 | 49,813 | 12 | 99,626 |
Yes | output | 1 | 49,813 | 12 | 99,627 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2.
Submitted Solution:
```
from bisect import bisect_left
def count_pair_more(arr, num):
total = 0
for i in range(len(arr) - 1, -1, -1):
count = i - bisect_left(arr, num - arr[i]) + 1
if count < 2:
return total
total += count - 1
def solve_bit(bit, arr):
mod = 1 << (bit + 1)
array = sorted([x % mod for x in arr])
low = [
(1 << bit, (1 << (bit + 1)) - 1),
((1 << bit) + (1 << (bit + 1)), (1 << (bit + 2)) - 1)
]
return sum(
count_pair_more(array, l) - count_pair_more(array, r + 1)
for l, r in low
) % 2
n = int(input())
nums = list(map(int, input().split()))
res = 0
for b in range(17):
v = solve_bit(b, nums)
if not v:
continue
res += (1 << b)
print(res)
``` | instruction | 0 | 49,814 | 12 | 99,628 |
No | output | 1 | 49,814 | 12 | 99,629 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2.
Submitted Solution:
```
n = int(input())
x = list(map(int, input().split()))
nums = [[] for _ in range(n)]
xor = []
for i in range(n):
s = 1
while x[i] > 0:
if (x[i] % (2 ** s)) % (2 ** s) != 0:
nums[i].append(1)
x[i] -= (2 ** (s-1))
else:
nums[i].append(0)
s += 1
m = max(list(map(len, nums)))
for i in range(n):
nums[i].extend([0] * (m - len(nums[i])))
for i in range(m):
total = 0
for j in range(n):
total += nums[j][i]
xor.append(total % 2)
final = 0
for i in range(m):
final += ((2 ** i) * xor[i])
print(final)
``` | instruction | 0 | 49,815 | 12 | 99,630 |
No | output | 1 | 49,815 | 12 | 99,631 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2.
Submitted Solution:
```
from math import factorial
from collections import Counter, defaultdict
from heapq import heapify, heappop, heappush
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 1000000007
INF = float('inf')
# ------------------------------
def main():
n = N()
arr = list(RL())
res = 0
le = len(arr)
for i in range(le-1):
for j in range(i+1, le):
if arr[i]==arr[j]:
arr.pop(j)
le-=1
break
res^=(arr[i]+arr[j])
print(res)
if __name__ == "__main__":
main()
``` | instruction | 0 | 49,816 | 12 | 99,632 |
No | output | 1 | 49,816 | 12 | 99,633 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2.
Submitted Solution:
```
def to_bits(x):
x = int(x)
bits = [0] * 26
i = 0
while x:
bits[i] = x & 1
x >>= 1
i += 1
return bits
n = int(input())
bits = list(map(to_bits, input().split()))
ans = 0
cur = [[0, i] for i in range(n)]
for i in range(25):
msk = 1 << i
maxdiv = msk * 2 - 1
cur_0 = []
cur_1 = []
for j in range(n):
cur[j][0] += bits[cur[j][1]][i] * msk
if bits[cur[j][1]][i]:
cur_1.append(cur[j])
else:
cur_0.append(cur[j])
cur = cur_0 + cur_1
#print(cur, msk, maxdiv)
div = 0
right = n - 1
end = n - 1
for left in range(n - 1):
if cur[left][0] + cur[-1][0] < msk:
continue
while left < end and cur[left][0] + cur[end][0] > maxdiv:
end -= 1
right = max(min(end, right), left + 1)
while left < right and cur[left][0] + cur[right][0] >= msk:
right -= 1
div += max(end - right, 0)
l = msk + maxdiv + 1
r = maxdiv * 2
for left in range(n - 1):
if cur[left][0] + cur[-1][0] < l:
continue
while left < end and cur[left][0] + cur[end][0] > r:
end -= 1
right = max(min(end, right), left + 1)
while left < right and cur[left][0] + cur[right][0] >= l:
right -= 1
div += max(end - right, 0)
print(div)
ans += (div % 2) * msk
print(ans)
``` | instruction | 0 | 49,817 | 12 | 99,634 |
No | output | 1 | 49,817 | 12 | 99,635 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Shubham has an array a of size n, and wants to select exactly x elements from it, such that their sum is odd. These elements do not have to be consecutive. The elements of the array are not guaranteed to be distinct.
Tell him whether he can do so.
Input
The first line of the input contains a single integer t (1≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n and x (1 ≤ x ≤ n ≤ 1000) — the length of the array and the number of elements you need to choose.
The next line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 1000) — elements of the array.
Output
For each test case, print "Yes" or "No" depending on whether it is possible to choose x elements such that their sum is odd.
You may print every letter in any case you want.
Example
Input
5
1 1
999
1 1
1000
2 1
51 50
2 2
51 50
3 3
101 102 103
Output
Yes
No
Yes
Yes
No
Note
For 1st case: We must select element 999, and the sum is odd.
For 2nd case: We must select element 1000, so overall sum is not odd.
For 3rd case: We can select element 51.
For 4th case: We must select both elements 50 and 51 — so overall sum is odd.
For 5th case: We must select all elements — but overall sum is not odd. | instruction | 0 | 49,834 | 12 | 99,668 |
Tags: brute force, implementation, math
Correct Solution:
```
import math
import sys
import collections
from collections import defaultdict
from sys import stdin, stdout
sys.setrecursionlimit(10**9)
for _ in range(int(input())):
n,x=map(int,input().split())
arr=list(map(int,input().split()))
e,o=0,0
for i in range(n):
if arr[i]%2==0:
e+=1
else:
o+=1
if x==1:
if o!=0:
print("Yes")
else:
print("No")
else:
if e!=0 and o!=0:
if e==o:
if (e+o)>x:
print("Yes")
elif (e+o)==x and o%2!=0:
print("Yes")
else:
print("No")
elif e>o:
if (e+o)>x:
print("Yes")
elif (e+o)==x and o%2!=0:
print("Yes")
else:
print("No")
else:
if (e+o)>x:
print("Yes")
elif (e+o)==x and o%2!=0:
print("Yes")
else:
print("No")
elif e!=0 and o==0:
print("No")
elif e==0 and o!=0:
if x%2==0:
print("No")
else:
print("Yes")
``` | output | 1 | 49,834 | 12 | 99,669 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.