message stringlengths 2 433k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 ≤ ai ≤ 3, 1 ≤ ti, xi ≤ 109) — type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0
Submitted Solution:
```
from bisect import *
d = {}
for q in range(int(input())):
a, t, x = map(int, input().split())
d[x] = p = d.get(x, [])
i = bisect(p, t)
if a == 1: p.insert(t, i)
elif a == 2: p.pop(i - 1)
else: print(i)
``` | instruction | 0 | 61,129 | 12 | 122,258 |
No | output | 1 | 61,129 | 12 | 122,259 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
ZS the Coder is given two permutations p and q of {1, 2, ..., n}, but some of their elements are replaced with 0. The distance between two permutations p and q is defined as the minimum number of moves required to turn p into q. A move consists of swapping exactly 2 elements of p.
ZS the Coder wants to determine the number of ways to replace the zeros with positive integers from the set {1, 2, ..., n} such that p and q are permutations of {1, 2, ..., n} and the distance between p and q is exactly k.
ZS the Coder wants to find the answer for all 0 ≤ k ≤ n - 1. Can you help him?
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 250) — the number of elements in the permutations.
The second line contains n integers, p1, p2, ..., pn (0 ≤ pi ≤ n) — the permutation p. It is guaranteed that there is at least one way to replace zeros such that p is a permutation of {1, 2, ..., n}.
The third line contains n integers, q1, q2, ..., qn (0 ≤ qi ≤ n) — the permutation q. It is guaranteed that there is at least one way to replace zeros such that q is a permutation of {1, 2, ..., n}.
Output
Print n integers, i-th of them should denote the answer for k = i - 1. Since the answer may be quite large, and ZS the Coder loves weird primes, print them modulo 998244353 = 223·7·17 + 1, which is a prime.
Examples
Input
3
1 0 0
0 2 0
Output
1 2 1
Input
4
1 0 0 3
0 0 0 4
Output
0 2 6 4
Input
6
1 3 2 5 4 6
6 4 5 1 0 0
Output
0 0 0 0 1 1
Input
4
1 2 3 4
2 3 4 1
Output
0 0 0 1
Note
In the first sample case, there is the only way to replace zeros so that it takes 0 swaps to convert p into q, namely p = (1, 2, 3), q = (1, 2, 3).
There are two ways to replace zeros so that it takes 1 swap to turn p into q. One of these ways is p = (1, 2, 3), q = (3, 2, 1), then swapping 1 and 3 from p transform it into q. The other way is p = (1, 3, 2), q = (1, 2, 3). Swapping 2 and 3 works in this case.
Finally, there is one way to replace zeros so that it takes 2 swaps to turn p into q, namely p = (1, 3, 2), q = (3, 2, 1). Then, we can transform p into q like following: <image>.
Submitted Solution:
```
print("1 2 1")
``` | instruction | 0 | 61,146 | 12 | 122,292 |
No | output | 1 | 61,146 | 12 | 122,293 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has an array of integers of length n.
Vasya performs the following operations on the array: on each step he finds the longest segment of consecutive equal integers (the leftmost, if there are several such segments) and removes it. For example, if Vasya's array is [13, 13, 7, 7, 7, 2, 2, 2], then after one operation it becomes [13, 13, 2, 2, 2].
Compute the number of operations Vasya should make until the array becomes empty, i.e. Vasya removes all elements from it.
Input
The first line contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array.
The second line contains a sequence a1, a2, ..., an (1 ≤ ai ≤ 109) — Vasya's array.
Output
Print the number of operations Vasya should make to remove all elements from the array.
Examples
Input
4
2 5 5 2
Output
2
Input
5
6 3 4 1 5
Output
5
Input
8
4 4 4 2 2 100 100 100
Output
3
Input
6
10 10 50 10 50 50
Output
4
Note
In the first example, at first Vasya removes two fives at the second and third positions. The array becomes [2, 2]. In the second operation Vasya removes two twos at the first and second positions. After that the array becomes empty.
In the second example Vasya has to perform five operations to make the array empty. In each of them he removes the first element from the array.
In the third example Vasya needs three operations. In the first operation he removes all integers 4, in the second — all integers 100, in the third — all integers 2.
In the fourth example in the first operation Vasya removes the first two integers 10. After that the array becomes [50, 10, 50, 50]. Then in the second operation Vasya removes the two rightmost integers 50, so that the array becomes [50, 10]. In the third operation he removes the remaining 50, and the array becomes [10] after that. In the last, fourth operation he removes the only remaining 10. The array is empty after that. | instruction | 0 | 61,203 | 12 | 122,406 |
Tags: data structures, dsu, flows, implementation, two pointers
Correct Solution:
```
from sys import stdin
from heapq import heappop, heappush, heapify
def main():
n = int(stdin.readline())
a = stdin.readline().split()
q = []
p = 0
c = 0
l = [0] * (n + 1)
r = [0] * (n + 1)
k = [0] * (n + 1)
pa = [0] * (n + 1)
for i, x in enumerate(a):
if x == a[p]:
c += 1
else:
l[p] = p - 1
k[p] = k[i-1] = c
pa[p] = i - 1
pa[i-1] = p
r[i-1] = i
q.append((-c, p))
p = i
c = 1
q.append((-c, p))
l[p] = p - 1
k[p] = k[n-1] = c
pa[p] = n - 1
pa[n-1] = p
r[n-1] = n
heapify(q)
ans = 0
while len(q):
c, p = heappop(q)
c = -c
if k[p] > c:
continue
ans += 1
ls = l[p]
rs = r[pa[p]]
if ls >= 0 and rs < n and a[ls] == a[rs]:
nc = k[ls] + k[rs]
nl, nr = pa[ls], pa[rs]
k[nl] = k[nr] = k[ls] = k[rs] = nc
pa[nr] = nl
pa[nl] = nr
heappush(q, (-nc, nl))
else:
if ls >= 0:
r[ls] = rs
if rs < n:
l[rs] = ls
print (ans)
main()
``` | output | 1 | 61,203 | 12 | 122,407 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has an array of integers of length n.
Vasya performs the following operations on the array: on each step he finds the longest segment of consecutive equal integers (the leftmost, if there are several such segments) and removes it. For example, if Vasya's array is [13, 13, 7, 7, 7, 2, 2, 2], then after one operation it becomes [13, 13, 2, 2, 2].
Compute the number of operations Vasya should make until the array becomes empty, i.e. Vasya removes all elements from it.
Input
The first line contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array.
The second line contains a sequence a1, a2, ..., an (1 ≤ ai ≤ 109) — Vasya's array.
Output
Print the number of operations Vasya should make to remove all elements from the array.
Examples
Input
4
2 5 5 2
Output
2
Input
5
6 3 4 1 5
Output
5
Input
8
4 4 4 2 2 100 100 100
Output
3
Input
6
10 10 50 10 50 50
Output
4
Note
In the first example, at first Vasya removes two fives at the second and third positions. The array becomes [2, 2]. In the second operation Vasya removes two twos at the first and second positions. After that the array becomes empty.
In the second example Vasya has to perform five operations to make the array empty. In each of them he removes the first element from the array.
In the third example Vasya needs three operations. In the first operation he removes all integers 4, in the second — all integers 100, in the third — all integers 2.
In the fourth example in the first operation Vasya removes the first two integers 10. After that the array becomes [50, 10, 50, 50]. Then in the second operation Vasya removes the two rightmost integers 50, so that the array becomes [50, 10]. In the third operation he removes the remaining 50, and the array becomes [10] after that. In the last, fourth operation he removes the only remaining 10. The array is empty after that. | instruction | 0 | 61,204 | 12 | 122,408 |
Tags: data structures, dsu, flows, implementation, two pointers
Correct Solution:
```
from heapq import *
from random import randint
import sys
n = int(input())
a = list(map(int, input().split()))
q = []
p = 0
c = 0
l = [0] * (n + 1)
r = [0] * (n + 1)
k = [0] * (n + 1)
pa = [0] * (n + 1)
for i, x in enumerate(a):
if x == a[p]:
c += 1
else:
l[p] = p - 1
k[p] = k[i-1] = c
pa[p] = i - 1
pa[i-1] = p
r[i-1] = i
q.append((-c, p))
p = i
c = 1
q.append((-c, p))
l[p] = p - 1
k[p] = k[n-1] = c
pa[p] = n - 1
pa[n-1] = p
r[n-1] = n
heapify(q)
ans = 0
while len(q):
c, p = heappop(q)
c = -c
if k[p] > c:
continue
ans += 1
ls = l[p]
rs = r[pa[p]]
if ls >= 0 and rs < n and a[ls] == a[rs]:
nc = k[ls] + k[rs]
nl, nr = pa[ls], pa[rs]
k[nl] = k[nr] = k[ls] = k[rs] = nc
pa[nr] = nl
pa[nl] = nr
heappush(q, (-nc, nl))
else:
if ls >= 0:
r[ls] = rs
if rs < n:
l[rs] = ls
print(ans)
``` | output | 1 | 61,204 | 12 | 122,409 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has an array of integers of length n.
Vasya performs the following operations on the array: on each step he finds the longest segment of consecutive equal integers (the leftmost, if there are several such segments) and removes it. For example, if Vasya's array is [13, 13, 7, 7, 7, 2, 2, 2], then after one operation it becomes [13, 13, 2, 2, 2].
Compute the number of operations Vasya should make until the array becomes empty, i.e. Vasya removes all elements from it.
Input
The first line contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array.
The second line contains a sequence a1, a2, ..., an (1 ≤ ai ≤ 109) — Vasya's array.
Output
Print the number of operations Vasya should make to remove all elements from the array.
Examples
Input
4
2 5 5 2
Output
2
Input
5
6 3 4 1 5
Output
5
Input
8
4 4 4 2 2 100 100 100
Output
3
Input
6
10 10 50 10 50 50
Output
4
Note
In the first example, at first Vasya removes two fives at the second and third positions. The array becomes [2, 2]. In the second operation Vasya removes two twos at the first and second positions. After that the array becomes empty.
In the second example Vasya has to perform five operations to make the array empty. In each of them he removes the first element from the array.
In the third example Vasya needs three operations. In the first operation he removes all integers 4, in the second — all integers 100, in the third — all integers 2.
In the fourth example in the first operation Vasya removes the first two integers 10. After that the array becomes [50, 10, 50, 50]. Then in the second operation Vasya removes the two rightmost integers 50, so that the array becomes [50, 10]. In the third operation he removes the remaining 50, and the array becomes [10] after that. In the last, fourth operation he removes the only remaining 10. The array is empty after that. | instruction | 0 | 61,205 | 12 | 122,410 |
Tags: data structures, dsu, flows, implementation, two pointers
Correct Solution:
```
'''input
4
2 5 5 2
'''
from sys import stdin
import collections
# from random import randint
# heapdict source code
def doc(s):
if hasattr(s, '__call__'):
s = s.__doc__
def f(g):
g.__doc__ = s
return g
return f
class heapdict(collections.MutableMapping):
__marker = object()
@staticmethod
def _parent(i):
return ((i - 1) >> 1)
@staticmethod
def _left(i):
return ((i << 1) + 1)
@staticmethod
def _right(i):
return ((i+1) << 1)
def __init__(self, *args, **kw):
self.heap = []
self.d = {}
self.update(*args, **kw)
@doc(dict.clear)
def clear(self):
self.heap.clear()
self.d.clear()
@doc(dict.__setitem__)
def __setitem__(self, key, value):
if key in self.d:
self.pop(key)
wrapper = [value, key, len(self)]
self.d[key] = wrapper
self.heap.append(wrapper)
self._decrease_key(len(self.heap)-1)
def _min_heapify(self, i):
l = self._left(i)
r = self._right(i)
n = len(self.heap)
if l < n and self.heap[l][0] < self.heap[i][0]:
low = l
else:
low = i
if r < n and self.heap[r][0] < self.heap[low][0]:
low = r
if low != i:
self._swap(i, low)
self._min_heapify(low)
def _decrease_key(self, i):
while i:
parent = self._parent(i)
if self.heap[parent][0] < self.heap[i][0]: break
self._swap(i, parent)
i = parent
def _swap(self, i, j):
self.heap[i], self.heap[j] = self.heap[j], self.heap[i]
self.heap[i][2] = i
self.heap[j][2] = j
@doc(dict.__delitem__)
def __delitem__(self, key):
wrapper = self.d[key]
while wrapper[2]:
parentpos = self._parent(wrapper[2])
parent = self.heap[parentpos]
self._swap(wrapper[2], parent[2])
self.popitem()
@doc(dict.__getitem__)
def __getitem__(self, key):
return self.d[key][0]
@doc(dict.__iter__)
def __iter__(self):
return iter(self.d)
def popitem(self):
"""D.popitem() -> (k, v), remove and return the (key, value) pair with lowest\nvalue; but raise KeyError if D is empty."""
wrapper = self.heap[0]
if len(self.heap) == 1:
self.heap.pop()
else:
self.heap[0] = self.heap.pop(-1)
self.heap[0][2] = 0
self._min_heapify(0)
del self.d[wrapper[1]]
return wrapper[1], wrapper[0]
@doc(dict.__len__)
def __len__(self):
return len(self.d)
def peekitem(self):
"""D.peekitem() -> (k, v), return the (key, value) pair with lowest value;\n but raise KeyError if D is empty."""
return (self.heap[0][1], self.heap[0][0])
del doc
__all__ = ['heapdict']
def create_necessities(arr, n):
size_heap = heapdict()
link = dict()
# for unique indentification
# for last element processing and saving code
arr.append(-1)
count = 1
for i in range(n + 1):
if i == 0:
leader = arr[i]
size = 1
else:
if arr[i] == arr[i - 1]:
size += 1
else:
size_heap[count] = -(size * (10 ** 14)) -((n - i))
link[count] = leader
count += 1
leader = arr[i]
size = 1
# creating neighbours
next_node = dict()
prev_node = dict()
for i in link:
if i == 1:
prev_node[i] = None
if i + 1 < count:
next_node[i] = i + 1
else:
next_node[i] = None
elif i == count:
break
else:
prev_node[i] = i - 1
if i + 1 < count:
next_node[i] = i + 1
else:
next_node[i] = None
# print(prev_node, next_node)
return link, size_heap, prev_node, next_node
# main start
n = int(stdin.readline().strip())
arr = list(map(int, stdin.readline().split()))
# arr = []
# for i in range(200000):
# arr.append(randint(1, 1))
link, size_heap, prev_node, next_node = create_necessities(arr, len(arr))
op = 0
while len(size_heap) > 0:
node, size = size_heap.popitem()
if prev_node[node] != None and next_node[node] != None and link[prev_node[node]] == link[next_node[node]]:
if prev_node[node] in size_heap and next_node[node] in size_heap:
# adjusting the size_heap
temp1 = size_heap[prev_node[node]]
t1 = (-temp1)%(10 ** 14)
temp2 = size_heap[next_node[node]]
t2 = (-temp2)%(10 ** 14)
size_heap[prev_node[node]] = -float('inf')
size_heap.popitem()
size_heap[next_node[node]] = -float('inf')
size_heap.popitem()
size_heap[prev_node[node]] = temp1 + temp2 + t2
# adjusting neighbours
next_node[prev_node[node]] = next_node[next_node[node]]
if next_node[next_node[node]] != None:
prev_node[next_node[next_node[node]]] = prev_node[node]
else:
prev_node[next_node[node]] = prev_node[node]
next_node[prev_node[node]] = next_node[node]
else:
prev_node[next_node[node]] = prev_node[node]
next_node[prev_node[node]] = next_node[node]
op += 1
print(op)
``` | output | 1 | 61,205 | 12 | 122,411 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has an array of integers of length n.
Vasya performs the following operations on the array: on each step he finds the longest segment of consecutive equal integers (the leftmost, if there are several such segments) and removes it. For example, if Vasya's array is [13, 13, 7, 7, 7, 2, 2, 2], then after one operation it becomes [13, 13, 2, 2, 2].
Compute the number of operations Vasya should make until the array becomes empty, i.e. Vasya removes all elements from it.
Input
The first line contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array.
The second line contains a sequence a1, a2, ..., an (1 ≤ ai ≤ 109) — Vasya's array.
Output
Print the number of operations Vasya should make to remove all elements from the array.
Examples
Input
4
2 5 5 2
Output
2
Input
5
6 3 4 1 5
Output
5
Input
8
4 4 4 2 2 100 100 100
Output
3
Input
6
10 10 50 10 50 50
Output
4
Note
In the first example, at first Vasya removes two fives at the second and third positions. The array becomes [2, 2]. In the second operation Vasya removes two twos at the first and second positions. After that the array becomes empty.
In the second example Vasya has to perform five operations to make the array empty. In each of them he removes the first element from the array.
In the third example Vasya needs three operations. In the first operation he removes all integers 4, in the second — all integers 100, in the third — all integers 2.
In the fourth example in the first operation Vasya removes the first two integers 10. After that the array becomes [50, 10, 50, 50]. Then in the second operation Vasya removes the two rightmost integers 50, so that the array becomes [50, 10]. In the third operation he removes the remaining 50, and the array becomes [10] after that. In the last, fourth operation he removes the only remaining 10. The array is empty after that. | instruction | 0 | 61,206 | 12 | 122,412 |
Tags: data structures, dsu, flows, implementation, two pointers
Correct Solution:
```
import heapq
n = int(input())
a = list(map(int, input().split()))
# idx: l, r, length, val
d = {}
pre, l = None, 0
seg = []
for i, x in enumerate(a):
if pre is None:
pre = x
l = 1
else:
if x == pre:
l+=1
else:
seg.append([l, pre])
pre = x
l = 1
if i==len(a)-1:
seg.append([l, x])
Q = []
for i, s in enumerate(seg):
l=None if i ==0 else i-1
r=None if i+1==len(seg) else i+1
d[i] = [l, r, s[0], s[1]]
heapq.heappush(Q, (-s[0], i))
cnt=0
while len(Q) > 0:
length, idx = heapq.heappop(Q)
length = -length
#print(d[idx])
if d[idx][2] != length:
continue
l, r, length, val = d[idx]
d[idx][0]=0
cnt+=1
if l is None and r is None:
break
elif l is None:
d[r][0] = None
elif r is None:
d[l][1] = None
else:
if d[l][3] == d[r][3]:
d[l][1] = d[r][1]
d[l][2] += d[r][2]
d[r][2] = 0
if d[r][1] is not None:
nnr = d[r][1]
d[nnr][0] = l
heapq.heappush(Q, (-d[l][2], l))
else:
d[l][1] = r
d[r][0] = l
print(cnt)
``` | output | 1 | 61,206 | 12 | 122,413 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has an array of integers of length n.
Vasya performs the following operations on the array: on each step he finds the longest segment of consecutive equal integers (the leftmost, if there are several such segments) and removes it. For example, if Vasya's array is [13, 13, 7, 7, 7, 2, 2, 2], then after one operation it becomes [13, 13, 2, 2, 2].
Compute the number of operations Vasya should make until the array becomes empty, i.e. Vasya removes all elements from it.
Input
The first line contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array.
The second line contains a sequence a1, a2, ..., an (1 ≤ ai ≤ 109) — Vasya's array.
Output
Print the number of operations Vasya should make to remove all elements from the array.
Examples
Input
4
2 5 5 2
Output
2
Input
5
6 3 4 1 5
Output
5
Input
8
4 4 4 2 2 100 100 100
Output
3
Input
6
10 10 50 10 50 50
Output
4
Note
In the first example, at first Vasya removes two fives at the second and third positions. The array becomes [2, 2]. In the second operation Vasya removes two twos at the first and second positions. After that the array becomes empty.
In the second example Vasya has to perform five operations to make the array empty. In each of them he removes the first element from the array.
In the third example Vasya needs three operations. In the first operation he removes all integers 4, in the second — all integers 100, in the third — all integers 2.
In the fourth example in the first operation Vasya removes the first two integers 10. After that the array becomes [50, 10, 50, 50]. Then in the second operation Vasya removes the two rightmost integers 50, so that the array becomes [50, 10]. In the third operation he removes the remaining 50, and the array becomes [10] after that. In the last, fourth operation he removes the only remaining 10. The array is empty after that.
Submitted Solution:
```
import heapq
n=int(input())
l=list(map(int,input().split()))
l.append("*")
d=1
st=0
end=0
a=[]
heapq.heapify(a)
start=dict()
ending=dict()
for i in range(1,n+1):
if l[i]!=l[i-1]:
end=i-1
heapq.heappush(a,(-d,st,end))
#print(-d,st,end)
start.update({st:end})
ending.update({end:st})
st=i
d=1
else:
d+=1
left=dict()
right=dict()
for j in start:
left.update({j:j-1})
for j in ending:
right.update({j:j+1})
length=n
w=set()
done=set()
ans=0
#print(start)
#print(ending)
while(length>0):
d,st,end=heapq.heappop(a)
if (d,st,end) in w:
continue
length+=d
#print(d,st,end)
left[end+1]=st-1
right[st-1]=end+1
ans+=1
done.add((d,st,end))
if left[st]>=0 and right[end]<=n-1 and l[right[end]]==l[left[st]]:
#print(left[st])
st1=ending[left[st]]
end1=start[right[end]]
heapq.heappush(a,(-st+st1-end1+end,st1,end1))
w.add((-st+st1,st1,st-1))
w.add((-end1+end,end+1,end1))
print(ans)
``` | instruction | 0 | 61,207 | 12 | 122,414 |
No | output | 1 | 61,207 | 12 | 122,415 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has an array of integers of length n.
Vasya performs the following operations on the array: on each step he finds the longest segment of consecutive equal integers (the leftmost, if there are several such segments) and removes it. For example, if Vasya's array is [13, 13, 7, 7, 7, 2, 2, 2], then after one operation it becomes [13, 13, 2, 2, 2].
Compute the number of operations Vasya should make until the array becomes empty, i.e. Vasya removes all elements from it.
Input
The first line contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array.
The second line contains a sequence a1, a2, ..., an (1 ≤ ai ≤ 109) — Vasya's array.
Output
Print the number of operations Vasya should make to remove all elements from the array.
Examples
Input
4
2 5 5 2
Output
2
Input
5
6 3 4 1 5
Output
5
Input
8
4 4 4 2 2 100 100 100
Output
3
Input
6
10 10 50 10 50 50
Output
4
Note
In the first example, at first Vasya removes two fives at the second and third positions. The array becomes [2, 2]. In the second operation Vasya removes two twos at the first and second positions. After that the array becomes empty.
In the second example Vasya has to perform five operations to make the array empty. In each of them he removes the first element from the array.
In the third example Vasya needs three operations. In the first operation he removes all integers 4, in the second — all integers 100, in the third — all integers 2.
In the fourth example in the first operation Vasya removes the first two integers 10. After that the array becomes [50, 10, 50, 50]. Then in the second operation Vasya removes the two rightmost integers 50, so that the array becomes [50, 10]. In the third operation he removes the remaining 50, and the array becomes [10] after that. In the last, fourth operation he removes the only remaining 10. The array is empty after that.
Submitted Solution:
```
import sys
class Record:
def __init__(self, prev, number):
self.prev = prev
self.next = None
self.number = number
self.cnt = 1
def sort_record_by_cnt(r: Record):
if r is None:
return -1
return r.cnt
class Records:
def __init__(self):
self.last_record = None # type: Record
self.records = []
def add(self, number):
if self.last_record is not None and self.last_record.number == number:
self.last_record.cnt += 1
else:
record = Record(self.last_record, number)
if self.last_record is not None:
self.last_record.next = record
self.last_record = record
self.records.append(record)
self.last_record = record
def sort(self):
self.records.sort(key=sort_record_by_cnt)
def clear(self):
new_records = []
for record in self.records:
if record is not None and record.cnt > 0:
new_records.append(record)
self.records = new_records
def find_max(self):
""" :rtype: Record """
return self.records.pop()
def process_next(self):
record = self.find_max() # type: Record
prev = record.prev # type: Record
next = record.next # type: Record
if prev is None and next is None:
return True
if prev is None:
next.prev = None
record.cnt = 0
return False
if next is None:
prev.next = None
record.cnt = 0
return False
if prev.number == next.number:
next2 = next.next # type: Record
prev.cnt += next.cnt
prev.next = next.next
next.cnt = 0
record.cnt = 0
if next2 is not None:
next2.prev = prev
self.sort()
return False
prev.next = next
next.prev = prev
record.cnt = 0
return False
def process(self):
cnt = 0
while not self.process_next():
cnt += 1
if cnt % 1000 == 0:
self.clear()
return cnt
lines = []
for line in sys.stdin:
lines.append(line)
n = int(lines[0].rstrip("\r\n\t "))
numbers = lines[1].rstrip("\r\n\t ").split(" ")
records = Records()
for x in numbers:
records.add(int(x))
records.sort()
print(records.process() + 1)
``` | instruction | 0 | 61,208 | 12 | 122,416 |
No | output | 1 | 61,208 | 12 | 122,417 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has an array of integers of length n.
Vasya performs the following operations on the array: on each step he finds the longest segment of consecutive equal integers (the leftmost, if there are several such segments) and removes it. For example, if Vasya's array is [13, 13, 7, 7, 7, 2, 2, 2], then after one operation it becomes [13, 13, 2, 2, 2].
Compute the number of operations Vasya should make until the array becomes empty, i.e. Vasya removes all elements from it.
Input
The first line contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array.
The second line contains a sequence a1, a2, ..., an (1 ≤ ai ≤ 109) — Vasya's array.
Output
Print the number of operations Vasya should make to remove all elements from the array.
Examples
Input
4
2 5 5 2
Output
2
Input
5
6 3 4 1 5
Output
5
Input
8
4 4 4 2 2 100 100 100
Output
3
Input
6
10 10 50 10 50 50
Output
4
Note
In the first example, at first Vasya removes two fives at the second and third positions. The array becomes [2, 2]. In the second operation Vasya removes two twos at the first and second positions. After that the array becomes empty.
In the second example Vasya has to perform five operations to make the array empty. In each of them he removes the first element from the array.
In the third example Vasya needs three operations. In the first operation he removes all integers 4, in the second — all integers 100, in the third — all integers 2.
In the fourth example in the first operation Vasya removes the first two integers 10. After that the array becomes [50, 10, 50, 50]. Then in the second operation Vasya removes the two rightmost integers 50, so that the array becomes [50, 10]. In the third operation he removes the remaining 50, and the array becomes [10] after that. In the last, fourth operation he removes the only remaining 10. The array is empty after that.
Submitted Solution:
```
'''input
4
2 5 5 2
'''
from sys import stdin
import collections
# from random import randint
# heapdict source code
def doc(s):
if hasattr(s, '__call__'):
s = s.__doc__
def f(g):
g.__doc__ = s
return g
return f
class heapdict(collections.MutableMapping):
__marker = object()
@staticmethod
def _parent(i):
return ((i - 1) >> 1)
@staticmethod
def _left(i):
return ((i << 1) + 1)
@staticmethod
def _right(i):
return ((i+1) << 1)
def __init__(self, *args, **kw):
self.heap = []
self.d = {}
self.update(*args, **kw)
@doc(dict.clear)
def clear(self):
self.heap.clear()
self.d.clear()
@doc(dict.__setitem__)
def __setitem__(self, key, value):
if key in self.d:
self.pop(key)
wrapper = [value, key, len(self)]
self.d[key] = wrapper
self.heap.append(wrapper)
self._decrease_key(len(self.heap)-1)
def _min_heapify(self, i):
l = self._left(i)
r = self._right(i)
n = len(self.heap)
if l < n and self.heap[l][0] < self.heap[i][0]:
low = l
else:
low = i
if r < n and self.heap[r][0] < self.heap[low][0]:
low = r
if low != i:
self._swap(i, low)
self._min_heapify(low)
def _decrease_key(self, i):
while i:
parent = self._parent(i)
if self.heap[parent][0] < self.heap[i][0]: break
self._swap(i, parent)
i = parent
def _swap(self, i, j):
self.heap[i], self.heap[j] = self.heap[j], self.heap[i]
self.heap[i][2] = i
self.heap[j][2] = j
@doc(dict.__delitem__)
def __delitem__(self, key):
wrapper = self.d[key]
while wrapper[2]:
parentpos = self._parent(wrapper[2])
parent = self.heap[parentpos]
self._swap(wrapper[2], parent[2])
self.popitem()
@doc(dict.__getitem__)
def __getitem__(self, key):
return self.d[key][0]
@doc(dict.__iter__)
def __iter__(self):
return iter(self.d)
def popitem(self):
"""D.popitem() -> (k, v), remove and return the (key, value) pair with lowest\nvalue; but raise KeyError if D is empty."""
wrapper = self.heap[0]
if len(self.heap) == 1:
self.heap.pop()
else:
self.heap[0] = self.heap.pop(-1)
self.heap[0][2] = 0
self._min_heapify(0)
del self.d[wrapper[1]]
return wrapper[1], wrapper[0]
@doc(dict.__len__)
def __len__(self):
return len(self.d)
def peekitem(self):
"""D.peekitem() -> (k, v), return the (key, value) pair with lowest value;\n but raise KeyError if D is empty."""
return (self.heap[0][1], self.heap[0][0])
del doc
__all__ = ['heapdict']
def create_necessities(arr, n):
size_heap = heapdict()
link = dict()
# for unique indentification
# for last element processing and saving code
arr.append(-1)
count = 1
for i in range(n + 1):
if i == 0:
leader = arr[i]
size = 1
else:
if arr[i] == arr[i - 1]:
size += 1
else:
size_heap[count] = -size
link[count] = leader
count += 1
leader = arr[i]
size = 1
# creating neighbours
next_node = dict()
prev_node = dict()
for i in link:
if i == 1:
prev_node[i] = None
if i + 1 < count:
next_node[i] = i + 1
else:
next_node[i] = None
elif i == count:
break
else:
prev_node[i] = i - 1
if i + 1 < count:
next_node[i] = i + 1
else:
next_node[i] = None
# print(prev_node, next_node)
return link, size_heap, prev_node, next_node
# main start
n = int(stdin.readline().strip())
arr = list(map(int, stdin.readline().split()))
# arr = []
# for i in range(200000):
# arr.append(randint(1, 1))
link, size_heap, prev_node, next_node = create_necessities(arr, len(arr))
op = 0
while len(size_heap) > 0:
node, size = size_heap.popitem()
prev_node[next_node[node]] = prev_node[node]
next_node[prev_node[node]] = next_node[node]
if prev_node[node] != None and next_node[node] != None and link[prev_node[node]] == link[next_node[node]]:
if prev_node[node] in size_heap and next_node[node] in size_heap:
# adjusting the size_heap
temp1 = size_heap[prev_node[node]]
temp2 = size_heap[next_node[node]]
size_heap[prev_node[node]] = -float('inf')
size_heap.popitem()
size_heap[next_node[node]] = -float('inf')
size_heap.popitem()
size_heap[prev_node[node]] = temp1 + temp2
# adjusting neighbours
next_node[prev_node[node]] = next_node[next_node[node]]
if next_node[next_node[node]] != None:
next_node[next_node[node]] = prev_node[node]
op += 1
print(op)
``` | instruction | 0 | 61,209 | 12 | 122,418 |
No | output | 1 | 61,209 | 12 | 122,419 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has an array of integers of length n.
Vasya performs the following operations on the array: on each step he finds the longest segment of consecutive equal integers (the leftmost, if there are several such segments) and removes it. For example, if Vasya's array is [13, 13, 7, 7, 7, 2, 2, 2], then after one operation it becomes [13, 13, 2, 2, 2].
Compute the number of operations Vasya should make until the array becomes empty, i.e. Vasya removes all elements from it.
Input
The first line contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array.
The second line contains a sequence a1, a2, ..., an (1 ≤ ai ≤ 109) — Vasya's array.
Output
Print the number of operations Vasya should make to remove all elements from the array.
Examples
Input
4
2 5 5 2
Output
2
Input
5
6 3 4 1 5
Output
5
Input
8
4 4 4 2 2 100 100 100
Output
3
Input
6
10 10 50 10 50 50
Output
4
Note
In the first example, at first Vasya removes two fives at the second and third positions. The array becomes [2, 2]. In the second operation Vasya removes two twos at the first and second positions. After that the array becomes empty.
In the second example Vasya has to perform five operations to make the array empty. In each of them he removes the first element from the array.
In the third example Vasya needs three operations. In the first operation he removes all integers 4, in the second — all integers 100, in the third — all integers 2.
In the fourth example in the first operation Vasya removes the first two integers 10. After that the array becomes [50, 10, 50, 50]. Then in the second operation Vasya removes the two rightmost integers 50, so that the array becomes [50, 10]. In the third operation he removes the remaining 50, and the array becomes [10] after that. In the last, fourth operation he removes the only remaining 10. The array is empty after that.
Submitted Solution:
```
import bisect
class TreeSet(object):
"""
Binary-tree set like java Treeset.
Duplicate elements will not be added.
When added new element, TreeSet will be sorted automatically.
"""
def __init__(self, elements):
self._treeset = []
self.addAll(elements)
def addAll(self, elements):
for element in elements:
if element in self: continue
self.add(element)
def add(self, element):
if element not in self:
bisect.insort(self._treeset, element)
def ceiling(self, e):
index = bisect.bisect_right(self._treeset, e)
if self[index - 1] == e:
return e
return self._treeset[bisect.bisect_right(self._treeset, e)]
def floor(self, e):
index = bisect.bisect_left(self._treeset, e)
if self[index] == e:
return e
else:
return self._treeset[bisect.bisect_left(self._treeset, e) - 1]
def __getitem__(self, num):
return self._treeset[num]
def __len__(self):
return len(self._treeset)
def clear(self):
"""
Delete all elements in TreeSet.
"""
self._treeset = []
def clone(self):
"""
Return shallow copy of self.
"""
return TreeSet(self._treeset)
def remove(self, element):
"""
Remove element if element in TreeSet.
"""
try:
self._treeset.remove(element)
except ValueError:
return False
return True
def __iter__(self):
"""
Do ascending iteration for TreeSet
"""
for element in self._treeset:
yield element
def pop(self, index):
return self._treeset.pop(index)
def __str__(self):
return str(self._treeset)
def __eq__(self, target):
if isinstance(target, TreeSet):
return self._treeset == target.treeset
elif isinstance(target, list):
return self._treeset == target
def __contains__(self, e):
"""
Fast attribution judgment by bisect
"""
try:
return e == self._treeset[bisect.bisect_left(self._treeset, e)]
except:
return False
n = int(input())
a = list(map(int, input().split()))
class sg:
def __init__(self, val, st, pos):
self.val = val
self.st = st
self.left = None
self.right = None
self.pos = pos
def __gt__(a, b):
if a.st != b.st:
return a.st < b.st
else:
return a.pos > b.pos
pr = a[0]
st = 1
c = 0
ps = None
tst = TreeSet([])
for i in range(1, n):
if a[i] == pr:
st += 1
else:
ns = sg(pr, st, c)
pr = a[i]
st = 1
if c > 0:
ns.left = ps
ps.right = ns
ps = ns
tst.add(ns)
c += 1
ns = sg(pr, st, c)
if c > 0:
ns.left = ps
ps.right = ns
tst.add(ns)
c += 1
ans = 0
while len(tst._treeset) > 0:
#print(tst._treeset)
nd = tst.pop(0)
if nd.right is not None:
nd.right.left = None
if nd.left is not None:
nd.left.right = None
ans += 1
if nd.left is not None and nd.right is not None and nd.left.val == nd.right.val:
nd.left.st += nd.right.st
nd.left.right = nd.right.right
nd.right.left = nd.left
tst.remove(nd.right)
new = nd.left
tst.remove(nd.left)
tst.add(new)
print(ans)
``` | instruction | 0 | 61,210 | 12 | 122,420 |
No | output | 1 | 61,210 | 12 | 122,421 |
Provide a correct Python 3 solution for this coding contest problem.
Consider a sequence of n numbers using integers from 0 to 9 k1, k2, ..., kn. Read the positive integers n and s,
k1 + 2 x k2 + 3 x k3 + ... + n x kn = s
Create a program that outputs how many rows of n numbers such as. However, the same number does not appear more than once in one "n sequence of numbers".
Input
The input consists of multiple datasets. For each dataset, n (1 ≤ n ≤ 10) and s (0 ≤ s ≤ 10,000) are given on one line, separated by blanks.
The number of datasets does not exceed 100.
Output
For each dataset, print the number of combinations in which the sum of n integers is s on one line.
Example
Input
3 10
3 1
Output
8
0 | instruction | 0 | 61,383 | 12 | 122,766 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0070
"""
import sys
import time
from itertools import permutations
def solve1(pick, target):
# ????´???????????????????????????§???????????????????????????
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
temp = []
for i in range(1, pick+1):
temp.append('{} * {}'.format(i, nums[0]))
nums = nums[1:]
exp = ' + '.join(temp)
ans = eval(exp)
if ans == target:
# print(exp)
hit += 1
return hit
def solve2(pick, target):
# ????????§??????????????£???????????§?????????????????§???????????????
# 10?????\?????????????????£??????????????????????????????40.0[s]??\???????????£??????????????§?????§????????????????????????
if target > 330:
return 0
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
ans = 0
for i in range(1, pick+1):
ans += (i * nums[i-1])
if ans > target:
break
if ans == target:
hit += 1
return hit
def solve3(pick, target):
#
if target > 330:
return 0
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
temp = [x * y for x, y in zip(nums, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])]
ans = sum(temp)
if ans == target:
hit += 1
return hit
def calc_min_max(pick, numbers):
# ?????????????????°???????????¨??????pick????????°????????????????????????????°????????????§????????????
multiplier = range(1, pick+1)
min_numbers = numbers[:pick]
min_numbers.sort(reverse=True)
temp = [x*y for x, y in zip(min_numbers, multiplier)]
min = sum(temp)
numbers = numbers[-pick:]
temp = [x*y for x, y in zip(numbers, multiplier)]
max = sum(temp)
return min, max
def solve4(pick, target, numbers=[0,1,2,3,4,5,6,7,8,9]):
# 7.72 [s]
global Hit
if pick == 0:
if target == 0:
Hit += 1
return
for n in numbers:
lnumbers = numbers[:]
lnumbers.remove(n)
p_min, p_max = calc_min_max(pick-1, lnumbers)
if target-(n*pick) > p_max or target-(n*pick) < p_min:
continue
else:
solve4(pick-1, target-(n*pick), lnumbers)
def has_possibility(pick, target, numbers):
# ?????????????????°???????????¨??????pick????????°????????????????????????????°????????????§???????±???????
# ???????????°?????????????????????????????????????????????????????????
if pick == 1:
return numbers[0] <= target <= numbers[-1]
multiplier = range(1, pick+1)
max_numbers = numbers[-pick:] # ??§??????????????°??????pick????????????
max = sum(x*y for x, y in zip(max_numbers, multiplier))
if target > max:
return False
min_numbers = numbers[:pick]
#min_numbers.sort(reverse=True)
min_numbers.reverse()
min = sum(x*y for x, y in zip(min_numbers, multiplier))
if target < min:
return False
return True
Hit = 0
def solve5(pick, target, numbers=[0,1,2,3,4,5,6,7,8,9]):
# 5.07 [s]
global Hit
if pick == 1:
if target in numbers:
Hit += 1
return
for n in numbers:
lnumbers = numbers[:]
lnumbers.remove(n)
if has_possibility(pick-1, target-(n*pick), lnumbers):
solve5(pick-1, target-(n*pick), lnumbers)
else:
continue
def main(args):
global Hit
for line in sys.stdin:
pick, target = [int(x) for x in line.strip().split(' ')]
solve5(pick, target)
print(Hit)
Hit = 0
# solve5(8, 100)
# print(Hit)
# Hit = 0
# solve5(9, 150)
# print(Hit)
# Hit = 0
if __name__ == '__main__':
main(sys.argv[1:])
``` | output | 1 | 61,383 | 12 | 122,767 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of n integers a_1, a_2, …, a_n.
You will perform q operations. In the i-th operation, you have a symbol s_i which is either "<" or ">" and a number x_i.
You make a new array b such that b_j = -a_j if a_j s_i x_i and b_j = a_j otherwise (i.e. if s_i is '>', then all a_j > x_i will be flipped). After doing all these replacements, a is set to be b.
You want to know what your final array looks like after all operations.
Input
The first line contains two integers n,q (1 ≤ n,q ≤ 10^5) — the number of integers and the number of queries.
The next line contains n integers a_1, a_2, …, a_n (-10^5 ≤ a_i ≤ 10^5) — the numbers.
Each of the next q lines contains a character and an integer s_i, x_i. (s_i ∈ \{<, >\}, -10^5 ≤ x_i ≤ 10^5) – the queries.
Output
Print n integers c_1, c_2, …, c_n representing the array after all operations.
Examples
Input
11 3
-5 -4 -3 -2 -1 0 1 2 3 4 5
> 2
> -4
< 5
Output
5 4 -3 -2 -1 0 1 2 -3 4 5
Input
5 5
0 1 -2 -1 2
< -2
< -1
< 0
< 1
< 2
Output
0 -1 2 -1 2
Note
In the first example, the array goes through the following changes:
* Initial: [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
* > 2: [-5, -4, -3, -2, -1, 0, 1, 2, -3, -4, -5]
* > -4: [-5, -4, 3, 2, 1, 0, -1, -2, 3, -4, -5]
* < 5: [5, 4, -3, -2, -1, 0, 1, 2, -3, 4, 5] | instruction | 0 | 61,522 | 12 | 123,044 |
Tags: bitmasks, data structures, divide and conquer, implementation
Correct Solution:
```
import sys
N, Q = map(int, input().split())
A = list(map(int, input().split()))
Sign = [0]*(3+10**5)
SX = [tuple(sys.stdin.readline().split()) for _ in range(Q)]
mini = 3 + 10**5
Sign = [0]*(3+10**5)
keep = 1
for (s, x) in SX[::-1]:
x = int(x)
ax = abs(x) + int((s == '>') ^ (x < 0))
sin = 1 if s == '<' else -1
if mini > ax:
t = sin*keep
for i in range(mini-1, ax-1, -1):
Sign[i] = t
mini = ax
keep *= (2*(s == '>') - 1) * (2*(0 < x) - 1)
Ans = [None]*N
for i, a in enumerate(A):
s = Sign[abs(a)]
if s == 0:
s = (2*(a > 0) - 1)*keep
Ans[i] = s*abs(a)
print(*Ans)
``` | output | 1 | 61,522 | 12 | 123,045 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of n integers a_1, a_2, …, a_n.
You will perform q operations. In the i-th operation, you have a symbol s_i which is either "<" or ">" and a number x_i.
You make a new array b such that b_j = -a_j if a_j s_i x_i and b_j = a_j otherwise (i.e. if s_i is '>', then all a_j > x_i will be flipped). After doing all these replacements, a is set to be b.
You want to know what your final array looks like after all operations.
Input
The first line contains two integers n,q (1 ≤ n,q ≤ 10^5) — the number of integers and the number of queries.
The next line contains n integers a_1, a_2, …, a_n (-10^5 ≤ a_i ≤ 10^5) — the numbers.
Each of the next q lines contains a character and an integer s_i, x_i. (s_i ∈ \{<, >\}, -10^5 ≤ x_i ≤ 10^5) – the queries.
Output
Print n integers c_1, c_2, …, c_n representing the array after all operations.
Examples
Input
11 3
-5 -4 -3 -2 -1 0 1 2 3 4 5
> 2
> -4
< 5
Output
5 4 -3 -2 -1 0 1 2 -3 4 5
Input
5 5
0 1 -2 -1 2
< -2
< -1
< 0
< 1
< 2
Output
0 -1 2 -1 2
Note
In the first example, the array goes through the following changes:
* Initial: [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
* > 2: [-5, -4, -3, -2, -1, 0, 1, 2, -3, -4, -5]
* > -4: [-5, -4, 3, 2, 1, 0, -1, -2, 3, -4, -5]
* < 5: [5, 4, -3, -2, -1, 0, 1, 2, -3, 4, 5] | instruction | 0 | 61,523 | 12 | 123,046 |
Tags: bitmasks, data structures, divide and conquer, implementation
Correct Solution:
```
n,q=map(int,input().split())
a=list(map(int,input().split()))
swaps=[0]*q
for i in range(q):
b=input().split()
b[1]=int(b[1])
out=1 if (b[0]=="<" and b[1]<=0) or (b[0]==">" and b[1]>=0) else 0
split=b[1]+0.5 if b[0]==">" else b[1]-0.5
sign=1 if split>0 else -1
split=abs(split)
swaps[i]=(split,sign,out)
sml=10**5+0.5
zeros=0
for i in range(q):
sml=min(swaps[i][0],sml)
zeros+=1-swaps[i][2]
zeros%=2
arr=[0]*100001
big=100000.5
flips=1
for i in range(q):
if swaps[-1-i][0]<big:
if swaps[-1-i][2]==1:
for j in range(int(swaps[-1-i][0]+0.5),int(big+0.5)):
arr[j]=-swaps[-i-1][1]*flips
else:
for j in range(int(swaps[-1-i][0]+0.5),int(big+0.5)):
arr[j]=swaps[-i-1][1]*flips
big=swaps[-1-i][0]
if swaps[-1-i][2]==0:
flips=-flips
def func(k):
if abs(k)<sml:
return k if zeros==0 else -k
else:
return arr[abs(k)]*abs(k)
print(" ".join([str(func(guy)) for guy in a]))
``` | output | 1 | 61,523 | 12 | 123,047 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of n integers a_1, a_2, …, a_n.
You will perform q operations. In the i-th operation, you have a symbol s_i which is either "<" or ">" and a number x_i.
You make a new array b such that b_j = -a_j if a_j s_i x_i and b_j = a_j otherwise (i.e. if s_i is '>', then all a_j > x_i will be flipped). After doing all these replacements, a is set to be b.
You want to know what your final array looks like after all operations.
Input
The first line contains two integers n,q (1 ≤ n,q ≤ 10^5) — the number of integers and the number of queries.
The next line contains n integers a_1, a_2, …, a_n (-10^5 ≤ a_i ≤ 10^5) — the numbers.
Each of the next q lines contains a character and an integer s_i, x_i. (s_i ∈ \{<, >\}, -10^5 ≤ x_i ≤ 10^5) – the queries.
Output
Print n integers c_1, c_2, …, c_n representing the array after all operations.
Examples
Input
11 3
-5 -4 -3 -2 -1 0 1 2 3 4 5
> 2
> -4
< 5
Output
5 4 -3 -2 -1 0 1 2 -3 4 5
Input
5 5
0 1 -2 -1 2
< -2
< -1
< 0
< 1
< 2
Output
0 -1 2 -1 2
Note
In the first example, the array goes through the following changes:
* Initial: [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
* > 2: [-5, -4, -3, -2, -1, 0, 1, 2, -3, -4, -5]
* > -4: [-5, -4, 3, 2, 1, 0, -1, -2, 3, -4, -5]
* < 5: [5, 4, -3, -2, -1, 0, 1, 2, -3, 4, 5]
Submitted Solution:
```
import sys
N, Q = map(int, input().split())
A =list(map(int, input().split()))
Sign = [0]*(3+10**5)
SX = [tuple(input().split()) for _ in range(Q)]
mini = 10**6
D = [0]*(3+10**5)
for i, (s, x) in zip(range(Q, 0, -1), SX[::-1]):
x = int(x)
ax = abs(x) + int((s == '>') ^ (x < 0))
sin = 1 if s == '<' else -1
if mini > ax:
D[ax] = i
mini = ax
Sign[abs(ax)] = sin
print(Sign[:10])
Keep = [1]
for (s, x) in SX:
fl = Keep[-1]
if eval('0'+s+x):
Keep.append(-fl)
else:
Keep.append(fl)
Keep.append(1)
Sign = [i if i else j for i, j in zip(Sign, Sign[1:] + [Sign[0]])]
D = [i if i else j for i, j in zip(D, [D[-1]] + D[:-1])]
Ans = [None]*N
for i, a in enumerate(A):
s = 1 if a > 0 else -1
if Sign[abs(a)] == 1:
s = 1
elif Sign[abs(a)] == -1:
s = -1
s = s * Keep[D[abs(a)]] * Keep[-2]
Ans[i] = abs(a) if s == 1 else -abs(a)
print(*Ans)
``` | instruction | 0 | 61,524 | 12 | 123,048 |
No | output | 1 | 61,524 | 12 | 123,049 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of n integers a_1, a_2, …, a_n.
You will perform q operations. In the i-th operation, you have a symbol s_i which is either "<" or ">" and a number x_i.
You make a new array b such that b_j = -a_j if a_j s_i x_i and b_j = a_j otherwise (i.e. if s_i is '>', then all a_j > x_i will be flipped). After doing all these replacements, a is set to be b.
You want to know what your final array looks like after all operations.
Input
The first line contains two integers n,q (1 ≤ n,q ≤ 10^5) — the number of integers and the number of queries.
The next line contains n integers a_1, a_2, …, a_n (-10^5 ≤ a_i ≤ 10^5) — the numbers.
Each of the next q lines contains a character and an integer s_i, x_i. (s_i ∈ \{<, >\}, -10^5 ≤ x_i ≤ 10^5) – the queries.
Output
Print n integers c_1, c_2, …, c_n representing the array after all operations.
Examples
Input
11 3
-5 -4 -3 -2 -1 0 1 2 3 4 5
> 2
> -4
< 5
Output
5 4 -3 -2 -1 0 1 2 -3 4 5
Input
5 5
0 1 -2 -1 2
< -2
< -1
< 0
< 1
< 2
Output
0 -1 2 -1 2
Note
In the first example, the array goes through the following changes:
* Initial: [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
* > 2: [-5, -4, -3, -2, -1, 0, 1, 2, -3, -4, -5]
* > -4: [-5, -4, 3, 2, 1, 0, -1, -2, 3, -4, -5]
* < 5: [5, 4, -3, -2, -1, 0, 1, 2, -3, 4, 5]
Submitted Solution:
```
import sys
N, Q = map(int, input().split())
A =list(map(int, input().split()))
Sign = [0]*(3+10**5)
SX = [tuple(input().split()) for _ in range(Q)]
mini = 10**6
D = [0]*(3+10**5)
for i, (s, x) in zip(range(Q, 0, -1), SX[::-1]):
x = int(x)
ax = abs(x) + int((s == '>') ^ (x < 0))
sin = 1 if s == '<' else -1
if mini > ax:
D[ax] = i
mini = ax
Sign[abs(ax)] = sin
Keep = [1]
for (s, x) in SX:
fl = Keep[-1]
if eval('0'+s+x):
Keep.append(-fl)
else:
Keep.append(fl)
Keep.append(1)
Sign = [i if i else j for i, j in zip(Sign, Sign[1:] + [Sign[0]])]
D = [i if i else j for i, j in zip(D, [D[-1]] + D[:-1])]
Ans = [None]*N
for i, a in enumerate(A):
s = 1 if a > 0 else -1
if Sign[abs(a)] == 1:
s = 1
elif Sign[abs(a)] == -1:
s = -1
s = s * Keep[D[abs(a)]] * Keep[-2]
Ans[i] = abs(a) if s == 1 else -abs(a)
print(*Ans)
``` | instruction | 0 | 61,525 | 12 | 123,050 |
No | output | 1 | 61,525 | 12 | 123,051 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of n integers a_1, a_2, …, a_n.
You will perform q operations. In the i-th operation, you have a symbol s_i which is either "<" or ">" and a number x_i.
You make a new array b such that b_j = -a_j if a_j s_i x_i and b_j = a_j otherwise (i.e. if s_i is '>', then all a_j > x_i will be flipped). After doing all these replacements, a is set to be b.
You want to know what your final array looks like after all operations.
Input
The first line contains two integers n,q (1 ≤ n,q ≤ 10^5) — the number of integers and the number of queries.
The next line contains n integers a_1, a_2, …, a_n (-10^5 ≤ a_i ≤ 10^5) — the numbers.
Each of the next q lines contains a character and an integer s_i, x_i. (s_i ∈ \{<, >\}, -10^5 ≤ x_i ≤ 10^5) – the queries.
Output
Print n integers c_1, c_2, …, c_n representing the array after all operations.
Examples
Input
11 3
-5 -4 -3 -2 -1 0 1 2 3 4 5
> 2
> -4
< 5
Output
5 4 -3 -2 -1 0 1 2 -3 4 5
Input
5 5
0 1 -2 -1 2
< -2
< -1
< 0
< 1
< 2
Output
0 -1 2 -1 2
Note
In the first example, the array goes through the following changes:
* Initial: [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
* > 2: [-5, -4, -3, -2, -1, 0, 1, 2, -3, -4, -5]
* > -4: [-5, -4, 3, 2, 1, 0, -1, -2, 3, -4, -5]
* < 5: [5, 4, -3, -2, -1, 0, 1, 2, -3, 4, 5]
Submitted Solution:
```
n, q = map(int, input().split())
stroka = input()
a = stroka.split()
for i in range(n):
a[i] = int(a[i])
s = []
x = []
b = []
for i in range(q):
stroka = input()
s.append(stroka[0])
x.append(int(stroka[2:]))
for i in range(n):
b.append(a[i])
for i in range(q):
if ( ((s[i] == '>') and (a[i]>x[i])) or ((s[i]=='<')and(a[i]<x[i])) ):
b[i] = a[i]
else:
b[i] = -a[i]
stroka = str(b[0])
for i in range (1,len(b)):
stroka += ' ' + str(b[i])
print(stroka)
``` | instruction | 0 | 61,526 | 12 | 123,052 |
No | output | 1 | 61,526 | 12 | 123,053 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of n integers a_1, a_2, …, a_n.
You will perform q operations. In the i-th operation, you have a symbol s_i which is either "<" or ">" and a number x_i.
You make a new array b such that b_j = -a_j if a_j s_i x_i and b_j = a_j otherwise (i.e. if s_i is '>', then all a_j > x_i will be flipped). After doing all these replacements, a is set to be b.
You want to know what your final array looks like after all operations.
Input
The first line contains two integers n,q (1 ≤ n,q ≤ 10^5) — the number of integers and the number of queries.
The next line contains n integers a_1, a_2, …, a_n (-10^5 ≤ a_i ≤ 10^5) — the numbers.
Each of the next q lines contains a character and an integer s_i, x_i. (s_i ∈ \{<, >\}, -10^5 ≤ x_i ≤ 10^5) – the queries.
Output
Print n integers c_1, c_2, …, c_n representing the array after all operations.
Examples
Input
11 3
-5 -4 -3 -2 -1 0 1 2 3 4 5
> 2
> -4
< 5
Output
5 4 -3 -2 -1 0 1 2 -3 4 5
Input
5 5
0 1 -2 -1 2
< -2
< -1
< 0
< 1
< 2
Output
0 -1 2 -1 2
Note
In the first example, the array goes through the following changes:
* Initial: [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
* > 2: [-5, -4, -3, -2, -1, 0, 1, 2, -3, -4, -5]
* > -4: [-5, -4, 3, 2, 1, 0, -1, -2, 3, -4, -5]
* < 5: [5, 4, -3, -2, -1, 0, 1, 2, -3, 4, 5]
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Mon Apr 22 16:05:55 2019
@author: Aman Seth
st=input()
le=len(st)
if 'a' in st:
ins=st.rfind('a')
st1=st[0:ins+2]
re=st[ins+2:le]
ans=st1.replace('a','')
if ans==re:
print(st1)
else:
print(":(")
else:
if all(st[i]!=st[i+1] for i in range(le-1)):
print(st[0:int(le/2)])
if all(i!='a' for i in st):
if all(st[i]==st[i+1] for i in range(le-1)):
print(":(")
"""
n,q=map(int,input().split())
a=list(map(int,input().split()))
le=len(a)
#c=['0']*le
#st=''
for i in range(q):
x,y=input().split()
y=int(y)
if x=='>':
for j in range(le):
if a[j]>y:
a[j]=-a[j]
#c[j]=str(a[j])
#st=st+str(a[j])+' '
if x=='<':
for j in range(le):
if a[j]<y:
a[j]=a[j]
#c[j]=str(a[j])
#st=st+str(a[j])+' '
#for j in range(le):
# a[j]=str(a[j])
print(' '.join(map(str,a)))
#print(st)
``` | instruction | 0 | 61,527 | 12 | 123,054 |
No | output | 1 | 61,527 | 12 | 123,055 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array consisting of n integers a_1, a_2, ... , a_n and an integer x. It is guaranteed that for every i, 1 ≤ a_i ≤ x.
Let's denote a function f(l, r) which erases all values such that l ≤ a_i ≤ r from the array a and returns the resulting array. For example, if a = [4, 1, 1, 4, 5, 2, 4, 3], then f(2, 4) = [1, 1, 5].
Your task is to calculate the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ x and f(l, r) is sorted in non-descending order. Note that the empty array is also considered sorted.
Input
The first line contains two integers n and x (1 ≤ n, x ≤ 10^6) — the length of array a and the upper limit for its elements, respectively.
The second line contains n integers a_1, a_2, ... a_n (1 ≤ a_i ≤ x).
Output
Print the number of pairs 1 ≤ l ≤ r ≤ x such that f(l, r) is sorted in non-descending order.
Examples
Input
3 3
2 3 1
Output
4
Input
7 4
1 3 1 2 2 4 3
Output
6
Note
In the first test case correct pairs are (1, 1), (1, 2), (1, 3) and (2, 3).
In the second test case correct pairs are (1, 3), (1, 4), (2, 3), (2, 4), (3, 3) and (3, 4). | instruction | 0 | 61,528 | 12 | 123,056 |
Tags: binary search, combinatorics, data structures, two pointers
Correct Solution:
```
import sys; input=sys.stdin.readline
from bisect import bisect_left as bl
n, x = map(int, input().split())
a = list(map(lambda x: int(x)-1, input().split()))
# from random import randint
# n, x = randint(1, 100), randint(1, 100)
# a = [randint(0, x-1) for _ in range(n)]
# a = [0, 2, 2, 0]
# print(n, x)
# print(a)
def naive(a, x):
res = 0
for l in range(x):
for r in range(l, x):
L =list(filter(lambda x: not l <= x <= r, a))
res += L == sorted(L)
return res
if all(a[i] >= a[i-1] for i in range(1, len(a))):
res = x*(x+1)//2
else:
mn, mx = [n+1 for _ in range(x)], [-1 for _ in range(x)]
for i, e in enumerate(a):
mn[e] = min(mn[e], i)
mx[e] = max(mx[e], i)
mnc = [mn[x-1]]
for i in range(x-2, -1, -1):
mnc.append(min(mnc[-1], mn[i]))
mnc = mnc[::-1]
left = 0
M = mx[0]
while left < x-1:
if mn[left+1] > M:
M = max(M, mx[left+1])
left += 1
else:
break
right = x-1
M = mn[x-1]
while right > 0:
if mx[right-1] < M:
M = min(M, mn[right-1])
right -= 1
else:
break
# print(left, right)
res = 1 + x-right + left+1
M = mx[0]
for i in range(left+1):
ind = max(bl(mnc, M), right)
# print(i, ind, 'M', M)
res += x-ind
M = max(M, mx[i+1])
print(res)
# print(naive(a, x))
``` | output | 1 | 61,528 | 12 | 123,057 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array consisting of n integers a_1, a_2, ... , a_n and an integer x. It is guaranteed that for every i, 1 ≤ a_i ≤ x.
Let's denote a function f(l, r) which erases all values such that l ≤ a_i ≤ r from the array a and returns the resulting array. For example, if a = [4, 1, 1, 4, 5, 2, 4, 3], then f(2, 4) = [1, 1, 5].
Your task is to calculate the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ x and f(l, r) is sorted in non-descending order. Note that the empty array is also considered sorted.
Input
The first line contains two integers n and x (1 ≤ n, x ≤ 10^6) — the length of array a and the upper limit for its elements, respectively.
The second line contains n integers a_1, a_2, ... a_n (1 ≤ a_i ≤ x).
Output
Print the number of pairs 1 ≤ l ≤ r ≤ x such that f(l, r) is sorted in non-descending order.
Examples
Input
3 3
2 3 1
Output
4
Input
7 4
1 3 1 2 2 4 3
Output
6
Note
In the first test case correct pairs are (1, 1), (1, 2), (1, 3) and (2, 3).
In the second test case correct pairs are (1, 3), (1, 4), (2, 3), (2, 4), (3, 3) and (3, 4). | instruction | 0 | 61,529 | 12 | 123,058 |
Tags: binary search, combinatorics, data structures, two pointers
Correct Solution:
```
import sys
input = sys.stdin.readline
n,x=map(int,input().split())
A=list(map(int,input().split()))
MIN_R=[A[-1]]
for a in A[:-1][::-1]:
MIN_R.append(min(a,MIN_R[-1]))
MIN_R=MIN_R[::-1]
MAX=x
for i in range(n-1):
if A[i]>MIN_R[i+1]:
MAX=min(MAX,A[i])
MAX_L=[A[0]]
for a in A[1:]:
MAX_L.append(max(a,MAX_L[-1]))
MIN=0
for i in range(1,n):
if MAX_L[i-1]>A[i]:
MIN=max(MIN,A[i])
NEED=[i for i in range(x+3)]
for i in range(n-1):
if A[i]>MIN_R[i+1]:
NEED[1]=max(NEED[1],MIN_R[i+1])
NEED[MIN_R[i+1]+1]=max(NEED[MIN_R[i+1]+1],A[i])
for i in range(1,x+2):
NEED[i]=max(NEED[i],NEED[i-1])
ANS=0
for i in range(1,MAX+1):
ANS+=x-max(MIN,NEED[i])+1
#print(i,ANS)
print(ANS)
``` | output | 1 | 61,529 | 12 | 123,059 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array consisting of n integers a_1, a_2, ... , a_n and an integer x. It is guaranteed that for every i, 1 ≤ a_i ≤ x.
Let's denote a function f(l, r) which erases all values such that l ≤ a_i ≤ r from the array a and returns the resulting array. For example, if a = [4, 1, 1, 4, 5, 2, 4, 3], then f(2, 4) = [1, 1, 5].
Your task is to calculate the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ x and f(l, r) is sorted in non-descending order. Note that the empty array is also considered sorted.
Input
The first line contains two integers n and x (1 ≤ n, x ≤ 10^6) — the length of array a and the upper limit for its elements, respectively.
The second line contains n integers a_1, a_2, ... a_n (1 ≤ a_i ≤ x).
Output
Print the number of pairs 1 ≤ l ≤ r ≤ x such that f(l, r) is sorted in non-descending order.
Examples
Input
3 3
2 3 1
Output
4
Input
7 4
1 3 1 2 2 4 3
Output
6
Note
In the first test case correct pairs are (1, 1), (1, 2), (1, 3) and (2, 3).
In the second test case correct pairs are (1, 3), (1, 4), (2, 3), (2, 4), (3, 3) and (3, 4). | instruction | 0 | 61,530 | 12 | 123,060 |
Tags: binary search, combinatorics, data structures, two pointers
Correct Solution:
```
import os
from io import BytesIO, StringIO
#input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
def input_as_list():
return list(map(int, input().split()))
def array_of(f, *dim):
return [array_of(f, *dim[1:]) for _ in range(dim[0])] if dim else f()
def main():
n, x = input_as_list()
a = input_as_list()
fo = array_of(lambda:-1, x+1)
lo = array_of(lambda:-1, x+1)
ans = 0
for i, e in enumerate(a):
if fo[e] == -1:
fo[e] = i
lo[e] = i
lastidx = -1
for i in range(1, x+1):
if fo[i] != -1:
if lastidx < fo[i]:
lastidx = lo[i]
else:
i -= 1
break
L = i
firstidx = n+1
for i in range(x, 0, -1):
if fo[i] != -1:
if lo[i] < firstidx:
firstidx = fo[i]
else:
i += 1
break
R = i
ans += min(x - R + 2, x)
c = n
for i in range(x, R-1, -1):
if fo[i] == -1:
fo[i] = c
else:
c = fo[i]
r = R
l = 1
while l <= L:
if l + 1 < r and (lo[l] == -1 or x < r or lo[l] < fo[r]):
ans += x - r + 2
#print(l+1, r-1)
l += 1
else:
r += 1
#print(L, R, ans)
print(ans)
main()
``` | output | 1 | 61,530 | 12 | 123,061 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array consisting of n integers a_1, a_2, ... , a_n and an integer x. It is guaranteed that for every i, 1 ≤ a_i ≤ x.
Let's denote a function f(l, r) which erases all values such that l ≤ a_i ≤ r from the array a and returns the resulting array. For example, if a = [4, 1, 1, 4, 5, 2, 4, 3], then f(2, 4) = [1, 1, 5].
Your task is to calculate the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ x and f(l, r) is sorted in non-descending order. Note that the empty array is also considered sorted.
Input
The first line contains two integers n and x (1 ≤ n, x ≤ 10^6) — the length of array a and the upper limit for its elements, respectively.
The second line contains n integers a_1, a_2, ... a_n (1 ≤ a_i ≤ x).
Output
Print the number of pairs 1 ≤ l ≤ r ≤ x such that f(l, r) is sorted in non-descending order.
Examples
Input
3 3
2 3 1
Output
4
Input
7 4
1 3 1 2 2 4 3
Output
6
Note
In the first test case correct pairs are (1, 1), (1, 2), (1, 3) and (2, 3).
In the second test case correct pairs are (1, 3), (1, 4), (2, 3), (2, 4), (3, 3) and (3, 4). | instruction | 0 | 61,531 | 12 | 123,062 |
Tags: binary search, combinatorics, data structures, two pointers
Correct Solution:
```
N, X = map(int, input().split(' '))
class Next():
def __init__(self, arr):
# array of length X
next_ = [None for _ in arr]
for i in range(len(arr)-2, -1, -1):
next_[i] = next_[i+1]
if arr[i+1] != None:
next_[i] = i+1
self.next_ = next_
def get_next(self, value):
return self.next_[value]
def fast_solution():
pref = 0
most_right = last[0]
if most_right is None:
most_right = -1
# Find longest non-decreasing prefix
while True:
if pref == X - 1:
break
if first[pref+1] is not None and first[pref+1] < most_right:
break
pref += 1
if pref + 1 < X and last[pref] is not None:
most_right = max(most_right, last[pref])
# Find longest non-decreasing suffix
suf = X - 1
most_left = first[X-1]
if most_left is None:
most_left = N
while True:
if suf == 0:
break
if last[suf-1] is not None and last[suf-1] > most_left:
break
suf -= 1
if suf > 0 and first[suf] is not None:
most_left = min(most_left, first[suf])
count = 0
j = max(suf-1, 0)
for i in range(min(pref+2, X)):
j = max(i, j)
while i>0 and j<X-1 and last[i-1] is not None and next_first.get_next(j) is not None and last[i-1] > first[next_first.get_next(j)]:
j += 1
count += X - j
return count
def transform(x):
return int(x) - 1
A = list(map(transform, input().split(' ')))
first = [None for _ in range(X)]
last = [None for _ in range(X)]
for i in range(N):
x = A[i]
if first[x] is None:
first[x] = i
last[x] = i
next_first = Next(first)
print(fast_solution())
``` | output | 1 | 61,531 | 12 | 123,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array consisting of n integers a_1, a_2, ... , a_n and an integer x. It is guaranteed that for every i, 1 ≤ a_i ≤ x.
Let's denote a function f(l, r) which erases all values such that l ≤ a_i ≤ r from the array a and returns the resulting array. For example, if a = [4, 1, 1, 4, 5, 2, 4, 3], then f(2, 4) = [1, 1, 5].
Your task is to calculate the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ x and f(l, r) is sorted in non-descending order. Note that the empty array is also considered sorted.
Input
The first line contains two integers n and x (1 ≤ n, x ≤ 10^6) — the length of array a and the upper limit for its elements, respectively.
The second line contains n integers a_1, a_2, ... a_n (1 ≤ a_i ≤ x).
Output
Print the number of pairs 1 ≤ l ≤ r ≤ x such that f(l, r) is sorted in non-descending order.
Examples
Input
3 3
2 3 1
Output
4
Input
7 4
1 3 1 2 2 4 3
Output
6
Note
In the first test case correct pairs are (1, 1), (1, 2), (1, 3) and (2, 3).
In the second test case correct pairs are (1, 3), (1, 4), (2, 3), (2, 4), (3, 3) and (3, 4). | instruction | 0 | 61,532 | 12 | 123,064 |
Tags: binary search, combinatorics, data structures, two pointers
Correct Solution:
```
n, x = map(int, input().split())
a = list(map(int, input().split()))
fst, last, sm = [], [], []
for i in range(1000005):
fst.append(0)
last.append(0)
sm.append(0)
for i in range(n):
if fst[a[i]] == 0:
fst[a[i]] = i + 1
last[a[i]] = i + 1
for i in range(x + 2):
if fst[i] == 0:
fst[i] = n + 1
l, ans = 0, 0
for i in range(1, x + 1):
if fst[i] > l:
l = max(l, last[i])
sm[l] += 1
else:
break
for i in range(1, n + 1):
sm[i] += sm[i - 1]
l, i = n + 1, x + 1
while i > 1:
if last[i] < l:
l = min(fst[i], l)
ans += min(sm[l - 1] + 1, i - 1)
else:
break
i -= 1
print(ans)
``` | output | 1 | 61,532 | 12 | 123,065 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array consisting of n integers a_1, a_2, ... , a_n and an integer x. It is guaranteed that for every i, 1 ≤ a_i ≤ x.
Let's denote a function f(l, r) which erases all values such that l ≤ a_i ≤ r from the array a and returns the resulting array. For example, if a = [4, 1, 1, 4, 5, 2, 4, 3], then f(2, 4) = [1, 1, 5].
Your task is to calculate the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ x and f(l, r) is sorted in non-descending order. Note that the empty array is also considered sorted.
Input
The first line contains two integers n and x (1 ≤ n, x ≤ 10^6) — the length of array a and the upper limit for its elements, respectively.
The second line contains n integers a_1, a_2, ... a_n (1 ≤ a_i ≤ x).
Output
Print the number of pairs 1 ≤ l ≤ r ≤ x such that f(l, r) is sorted in non-descending order.
Examples
Input
3 3
2 3 1
Output
4
Input
7 4
1 3 1 2 2 4 3
Output
6
Note
In the first test case correct pairs are (1, 1), (1, 2), (1, 3) and (2, 3).
In the second test case correct pairs are (1, 3), (1, 4), (2, 3), (2, 4), (3, 3) and (3, 4). | instruction | 0 | 61,533 | 12 | 123,066 |
Tags: binary search, combinatorics, data structures, two pointers
Correct Solution:
```
n, x = map(int, input().split())
a = list(map(int, input().split()))
mi = [x + 1] * (x + 1)
ma = [0] * (x + 1)
trie = [0] * (1 << 23)
m = 4
trie[0] = x + 1
for i in a:
at = 0
mii = x + 1
maa = 0
for j in range(19, -1, -1):
if (i & (1 << j)):
if not trie[at + 3]:
trie[at + 3] = m
at = m
trie[m] = i
trie[m + 1] = i
m += 4
else:
at = trie[at + 3]
trie[at] = min(trie[at + 0], i)
trie[at + 1] = max(trie[at + 1], i)
else:
if trie[at + 3]:
mii = trie[trie[at + 3]]
if not maa:
maa = trie[trie[at + 3] + 1]
if not trie[at + 2]:
trie[at + 2] = m
at = m
trie[m] = i
trie[m + 1] = i
m += 4
else:
at = trie[at + 2]
trie[at] = min(trie[at + 0], i)
trie[at + 1] = max(trie[at + 1], i)
mi[i] = min(mi[i], mii)
ma[i] = max(ma[i], maa)
fi = 0
for i in range(x, 0, -1):
if mi[i] != x + 1:
fi = i
break
ans = 0
g = x + 1
for i in range(1, x + 1):
ans += x - max(i, fi) + 1
if i == g:
break
fi = max(fi, ma[i])
g = min(g, mi[i])
print(ans)
``` | output | 1 | 61,533 | 12 | 123,067 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array consisting of n integers a_1, a_2, ... , a_n and an integer x. It is guaranteed that for every i, 1 ≤ a_i ≤ x.
Let's denote a function f(l, r) which erases all values such that l ≤ a_i ≤ r from the array a and returns the resulting array. For example, if a = [4, 1, 1, 4, 5, 2, 4, 3], then f(2, 4) = [1, 1, 5].
Your task is to calculate the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ x and f(l, r) is sorted in non-descending order. Note that the empty array is also considered sorted.
Input
The first line contains two integers n and x (1 ≤ n, x ≤ 10^6) — the length of array a and the upper limit for its elements, respectively.
The second line contains n integers a_1, a_2, ... a_n (1 ≤ a_i ≤ x).
Output
Print the number of pairs 1 ≤ l ≤ r ≤ x such that f(l, r) is sorted in non-descending order.
Examples
Input
3 3
2 3 1
Output
4
Input
7 4
1 3 1 2 2 4 3
Output
6
Note
In the first test case correct pairs are (1, 1), (1, 2), (1, 3) and (2, 3).
In the second test case correct pairs are (1, 3), (1, 4), (2, 3), (2, 4), (3, 3) and (3, 4).
Submitted Solution:
```
p=[*map(int,input().split())]
x=[*map(int,input().split())]
def f(l,r,d):
e=l
b=d[:]
while e<=r:
while b.count(e):
b.remove(e)
e+=1
return b
ed=0
for i in range(1,p[0]+1):
for j in range(i,p[0]+1):
g=f(i,j,x)
r=sorted(g)
if g==r:
ed+=1
print(ed)
``` | instruction | 0 | 61,534 | 12 | 123,068 |
No | output | 1 | 61,534 | 12 | 123,069 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array consisting of n integers a_1, a_2, ... , a_n and an integer x. It is guaranteed that for every i, 1 ≤ a_i ≤ x.
Let's denote a function f(l, r) which erases all values such that l ≤ a_i ≤ r from the array a and returns the resulting array. For example, if a = [4, 1, 1, 4, 5, 2, 4, 3], then f(2, 4) = [1, 1, 5].
Your task is to calculate the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ x and f(l, r) is sorted in non-descending order. Note that the empty array is also considered sorted.
Input
The first line contains two integers n and x (1 ≤ n, x ≤ 10^6) — the length of array a and the upper limit for its elements, respectively.
The second line contains n integers a_1, a_2, ... a_n (1 ≤ a_i ≤ x).
Output
Print the number of pairs 1 ≤ l ≤ r ≤ x such that f(l, r) is sorted in non-descending order.
Examples
Input
3 3
2 3 1
Output
4
Input
7 4
1 3 1 2 2 4 3
Output
6
Note
In the first test case correct pairs are (1, 1), (1, 2), (1, 3) and (2, 3).
In the second test case correct pairs are (1, 3), (1, 4), (2, 3), (2, 4), (3, 3) and (3, 4).
Submitted Solution:
```
import sys
input = sys.stdin.readline
n,x=map(int,input().split())
A=list(map(int,input().split()))
MIN_R=[A[-1]]
for a in A[:-1][::-1]:
MIN_R.append(min(a,MIN_R[-1]))
MIN_R=MIN_R[::-1]
MAX=x
for i in range(n-1):
if A[i]>MIN_R[i+1]:
MAX=min(MAX,A[i])
MAX_L=[A[0]]
for a in A[1:]:
MAX_L.append(max(a,MAX_L[-1]))
MIN=0
for i in range(1,n):
if MAX_L[i-1]>A[i]:
MIN=max(MIN,A[i])
NEED=[i for i in range(x+3)]
for i in range(n-1):
if A[i]>MIN_R[i+1]:
NEED[1]=max(NEED[1],MIN_R[i+1])
NEED[MIN_R[i+1]+1]=max(NEED[MIN_R[i+1]+1],A[i])
ANS=0
for i in range(1,MAX+1):
ANS+=x-max(MIN,NEED[i])+1
#print(i,ANS)
print(ANS)
``` | instruction | 0 | 61,535 | 12 | 123,070 |
No | output | 1 | 61,535 | 12 | 123,071 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array consisting of n integers a_1, a_2, ... , a_n and an integer x. It is guaranteed that for every i, 1 ≤ a_i ≤ x.
Let's denote a function f(l, r) which erases all values such that l ≤ a_i ≤ r from the array a and returns the resulting array. For example, if a = [4, 1, 1, 4, 5, 2, 4, 3], then f(2, 4) = [1, 1, 5].
Your task is to calculate the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ x and f(l, r) is sorted in non-descending order. Note that the empty array is also considered sorted.
Input
The first line contains two integers n and x (1 ≤ n, x ≤ 10^6) — the length of array a and the upper limit for its elements, respectively.
The second line contains n integers a_1, a_2, ... a_n (1 ≤ a_i ≤ x).
Output
Print the number of pairs 1 ≤ l ≤ r ≤ x such that f(l, r) is sorted in non-descending order.
Examples
Input
3 3
2 3 1
Output
4
Input
7 4
1 3 1 2 2 4 3
Output
6
Note
In the first test case correct pairs are (1, 1), (1, 2), (1, 3) and (2, 3).
In the second test case correct pairs are (1, 3), (1, 4), (2, 3), (2, 4), (3, 3) and (3, 4).
Submitted Solution:
```
MAX=10**9;MIN=-10**9
n,x=map(int,input().split())
a=list(map(int,input().split()))
if sorted(a)==a:
print(x*(x+1)//2)
exit(0)
b=[(a[i],i) for i in range(n)]
d={}
for i in range(1,x+1):
d[i]=[MAX,MIN]
for i,j in b:
## if i not in d:
## d[i]=[MAX,MIN]
d[i][0]=min(d[i][0],j)
d[i][1]=max(d[i][1],j)
c=sorted(d.items());left=0;right=len(d)-1
for i in range(1,len(c)):
if c[i][1][0]>c[i-1][1][1] or c[i][1][1]==MIN:
left=i
else:
left+=1
break
for i in range(len(c)-2,-1,-1):
if c[i][1][1]<c[i+1][1][0] or c[i][1][1]==MIN:
right=i
else:
right-=1
break
ans=0
if right<left:
y=right
#print(left,right)
ans=len(c)-right
#print(ans)
for i in range(1,right+1):
while y<len(d)-1 and (c[i-1][1][1]>c[y+1][1][0] or c[i][1][1]==MIN):
y+=1
ans+=len(c)-y
ans+=1
else:
#print(left,right)
ans=len(c)-right
for i in range(1,left+1):
while right<len(d)-1 and (c[i-1][1][1]>c[right+1][1][0] or c[i][1][1]==MIN):
right+=1
ans+=len(c)-right
print(ans)
``` | instruction | 0 | 61,536 | 12 | 123,072 |
No | output | 1 | 61,536 | 12 | 123,073 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array consisting of n integers a_1, a_2, ... , a_n and an integer x. It is guaranteed that for every i, 1 ≤ a_i ≤ x.
Let's denote a function f(l, r) which erases all values such that l ≤ a_i ≤ r from the array a and returns the resulting array. For example, if a = [4, 1, 1, 4, 5, 2, 4, 3], then f(2, 4) = [1, 1, 5].
Your task is to calculate the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ x and f(l, r) is sorted in non-descending order. Note that the empty array is also considered sorted.
Input
The first line contains two integers n and x (1 ≤ n, x ≤ 10^6) — the length of array a and the upper limit for its elements, respectively.
The second line contains n integers a_1, a_2, ... a_n (1 ≤ a_i ≤ x).
Output
Print the number of pairs 1 ≤ l ≤ r ≤ x such that f(l, r) is sorted in non-descending order.
Examples
Input
3 3
2 3 1
Output
4
Input
7 4
1 3 1 2 2 4 3
Output
6
Note
In the first test case correct pairs are (1, 1), (1, 2), (1, 3) and (2, 3).
In the second test case correct pairs are (1, 3), (1, 4), (2, 3), (2, 4), (3, 3) and (3, 4).
Submitted Solution:
```
u= list(map(int,input().split()))
a= list(map(int,input().split()))
n=u[0]
x=u[1]
d=[0]*(x+1)
dd=[0]*(x+1)
g=[0]*(x+1)
dem=0
for i in range(n):
if g[a[i]] == 0 : d[a[i]]=i
if ( i > 0 and a[i] > a[i-1] ): dem+=1
dd[a[i]]=i
g[a[i]]=1
l=1
r=x
if ( g[x] == 0 ):
d[x]=x+1
dd[x]=x+1
for i in range(x-1):
if g[i+1] == 0:
d[i+1]=d[i]
dd[i+1]=dd[i]
while( l < x and dd[l] <= d[l+1] ): l+=1
for i in range(x):
if g[x-i-1] == 0:
d[x-i-1]=d[x-i]
dd[x-i-1]=dd[x-i]
while( r > 1 and dd[r-1] <= d[r] ): r-=1
if dem != n-1:
dem=0
if l < x: l+=1
k=x
dem=x-k+2
#print(dem)
while( l > 1 ):
while( r < k and d[k] >= dd[l-1] ):
k-=1
dem+=x-k+2
if ( k == x and d[k] < dd[l-1] ): dem-=1
#print(k," ",l," ",d[k]," ",dd[l-1])
l-=1
r-=1
while( r > 0 and g[r] == 0 ):
r-=1
dem+=1
else: dem=x*(x-1)/2
print(dem)
``` | instruction | 0 | 61,537 | 12 | 123,074 |
No | output | 1 | 61,537 | 12 | 123,075 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Natasha's favourite numbers are n and 1, and Sasha's favourite numbers are m and -1. One day Natasha and Sasha met and wrote down every possible array of length n+m such that some n of its elements are equal to 1 and another m elements are equal to -1. For each such array they counted its maximal prefix sum, probably an empty one which is equal to 0 (in another words, if every nonempty prefix sum is less to zero, then it is considered equal to zero). Formally, denote as f(a) the maximal prefix sum of an array a_{1, … ,l} of length l ≥ 0. Then:
$$$f(a) = max (0, \smash{\displaystylemax_{1 ≤ i ≤ l}} ∑_{j=1}^{i} a_j )$$$
Now they want to count the sum of maximal prefix sums for each such an array and they are asking you to help. As this sum can be very large, output it modulo 998\: 244\: 853.
Input
The only line contains two integers n and m (0 ≤ n,m ≤ 2 000).
Output
Output the answer to the problem modulo 998\: 244\: 853.
Examples
Input
0 2
Output
0
Input
2 0
Output
2
Input
2 2
Output
5
Input
2000 2000
Output
674532367
Note
In the first example the only possible array is [-1,-1], its maximal prefix sum is equal to 0.
In the second example the only possible array is [1,1], its maximal prefix sum is equal to 2.
There are 6 possible arrays in the third example:
[1,1,-1,-1], f([1,1,-1,-1]) = 2
[1,-1,1,-1], f([1,-1,1,-1]) = 1
[1,-1,-1,1], f([1,-1,-1,1]) = 1
[-1,1,1,-1], f([-1,1,1,-1]) = 1
[-1,1,-1,1], f([-1,1,-1,1]) = 0
[-1,-1,1,1], f([-1,-1,1,1]) = 0
So the answer for the third example is 2+1+1+1+0+0 = 5. | instruction | 0 | 61,538 | 12 | 123,076 |
Tags: combinatorics, dp, math, number theory
Correct Solution:
```
P, N = 998244853, 4000
f, fi = [0] * (N + 1), [0] * (N + 1)
f[0], fi[-1] = 1, 338887798
for i in range(N):
f[i + 1] = f[i] * (i + 1) % P
fi[N - i - 1] = fi[N - i] * (N - i) % P
C = lambda n, r: f[n] * fi[r] % P * fi[n - r] % P
n, m = map(int, input().split())
k = max(n - m - 1, 0)
print((k * C(n + m, m) + sum(C(n + m, m + i) for i in range(k + 1, n)) + 1) % P if n else 0)
``` | output | 1 | 61,538 | 12 | 123,077 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Natasha's favourite numbers are n and 1, and Sasha's favourite numbers are m and -1. One day Natasha and Sasha met and wrote down every possible array of length n+m such that some n of its elements are equal to 1 and another m elements are equal to -1. For each such array they counted its maximal prefix sum, probably an empty one which is equal to 0 (in another words, if every nonempty prefix sum is less to zero, then it is considered equal to zero). Formally, denote as f(a) the maximal prefix sum of an array a_{1, … ,l} of length l ≥ 0. Then:
$$$f(a) = max (0, \smash{\displaystylemax_{1 ≤ i ≤ l}} ∑_{j=1}^{i} a_j )$$$
Now they want to count the sum of maximal prefix sums for each such an array and they are asking you to help. As this sum can be very large, output it modulo 998\: 244\: 853.
Input
The only line contains two integers n and m (0 ≤ n,m ≤ 2 000).
Output
Output the answer to the problem modulo 998\: 244\: 853.
Examples
Input
0 2
Output
0
Input
2 0
Output
2
Input
2 2
Output
5
Input
2000 2000
Output
674532367
Note
In the first example the only possible array is [-1,-1], its maximal prefix sum is equal to 0.
In the second example the only possible array is [1,1], its maximal prefix sum is equal to 2.
There are 6 possible arrays in the third example:
[1,1,-1,-1], f([1,1,-1,-1]) = 2
[1,-1,1,-1], f([1,-1,1,-1]) = 1
[1,-1,-1,1], f([1,-1,-1,1]) = 1
[-1,1,1,-1], f([-1,1,1,-1]) = 1
[-1,1,-1,1], f([-1,1,-1,1]) = 0
[-1,-1,1,1], f([-1,-1,1,1]) = 0
So the answer for the third example is 2+1+1+1+0+0 = 5. | instruction | 0 | 61,539 | 12 | 123,078 |
Tags: combinatorics, dp, math, number theory
Correct Solution:
```
P = 998244853
N = 4000
f1, f2 = [0] * (N + 1), [0] * (N + 1)
f1[0] = 1
for i in range(N):
f1[i + 1] = f1[i] * (i + 1) % P
f2[-1] = pow(f1[-1], P - 2, P)
for i in reversed(range(N)):
f2[i] = f2[i + 1] * (i + 1) % P
def C(n, r):
c = 1
while n or r:
a, b = n % P, r % P
if a < b:
return 0
c = c * f1[a] % P * f2[b] % P * f2[a - b] % P
n //= P
r //= P
return c
n, m = map(int, input().split())
k = max(n - m - 1, 0)
print((k * C(n + m, m) + sum(C(n + m, m + i) for i in range(k + 1, n)) + 1) % P if n else 0)
``` | output | 1 | 61,539 | 12 | 123,079 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Natasha's favourite numbers are n and 1, and Sasha's favourite numbers are m and -1. One day Natasha and Sasha met and wrote down every possible array of length n+m such that some n of its elements are equal to 1 and another m elements are equal to -1. For each such array they counted its maximal prefix sum, probably an empty one which is equal to 0 (in another words, if every nonempty prefix sum is less to zero, then it is considered equal to zero). Formally, denote as f(a) the maximal prefix sum of an array a_{1, … ,l} of length l ≥ 0. Then:
$$$f(a) = max (0, \smash{\displaystylemax_{1 ≤ i ≤ l}} ∑_{j=1}^{i} a_j )$$$
Now they want to count the sum of maximal prefix sums for each such an array and they are asking you to help. As this sum can be very large, output it modulo 998\: 244\: 853.
Input
The only line contains two integers n and m (0 ≤ n,m ≤ 2 000).
Output
Output the answer to the problem modulo 998\: 244\: 853.
Examples
Input
0 2
Output
0
Input
2 0
Output
2
Input
2 2
Output
5
Input
2000 2000
Output
674532367
Note
In the first example the only possible array is [-1,-1], its maximal prefix sum is equal to 0.
In the second example the only possible array is [1,1], its maximal prefix sum is equal to 2.
There are 6 possible arrays in the third example:
[1,1,-1,-1], f([1,1,-1,-1]) = 2
[1,-1,1,-1], f([1,-1,1,-1]) = 1
[1,-1,-1,1], f([1,-1,-1,1]) = 1
[-1,1,1,-1], f([-1,1,1,-1]) = 1
[-1,1,-1,1], f([-1,1,-1,1]) = 0
[-1,-1,1,1], f([-1,-1,1,1]) = 0
So the answer for the third example is 2+1+1+1+0+0 = 5. | instruction | 0 | 61,540 | 12 | 123,080 |
Tags: combinatorics, dp, math, number theory
Correct Solution:
```
P = 998244853
N, M = map(int, input().split())
fa = [1]
for i in range(4040):
fa.append(fa[-1]*(i+1)%P)
fainv = [pow(fa[-1], P-2, P)]
for i in range(4040)[::-1]:
fainv.append(fainv[-1]*(i+1)%P)
fainv = fainv[::-1]
def C(a, b):
return fa[a]*fainv[a-b]*fainv[b]%P
def calc(i):
return C(N+M, M) if N-M > i else C(N+M, M+i)
X = [0] * N + [1]
for i in range(N):
X[i] = calc(i) - calc(i+1)
print(sum([i*X[i] for i in range(1, N+1)]) % P)
``` | output | 1 | 61,540 | 12 | 123,081 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Natasha's favourite numbers are n and 1, and Sasha's favourite numbers are m and -1. One day Natasha and Sasha met and wrote down every possible array of length n+m such that some n of its elements are equal to 1 and another m elements are equal to -1. For each such array they counted its maximal prefix sum, probably an empty one which is equal to 0 (in another words, if every nonempty prefix sum is less to zero, then it is considered equal to zero). Formally, denote as f(a) the maximal prefix sum of an array a_{1, … ,l} of length l ≥ 0. Then:
$$$f(a) = max (0, \smash{\displaystylemax_{1 ≤ i ≤ l}} ∑_{j=1}^{i} a_j )$$$
Now they want to count the sum of maximal prefix sums for each such an array and they are asking you to help. As this sum can be very large, output it modulo 998\: 244\: 853.
Input
The only line contains two integers n and m (0 ≤ n,m ≤ 2 000).
Output
Output the answer to the problem modulo 998\: 244\: 853.
Examples
Input
0 2
Output
0
Input
2 0
Output
2
Input
2 2
Output
5
Input
2000 2000
Output
674532367
Note
In the first example the only possible array is [-1,-1], its maximal prefix sum is equal to 0.
In the second example the only possible array is [1,1], its maximal prefix sum is equal to 2.
There are 6 possible arrays in the third example:
[1,1,-1,-1], f([1,1,-1,-1]) = 2
[1,-1,1,-1], f([1,-1,1,-1]) = 1
[1,-1,-1,1], f([1,-1,-1,1]) = 1
[-1,1,1,-1], f([-1,1,1,-1]) = 1
[-1,1,-1,1], f([-1,1,-1,1]) = 0
[-1,-1,1,1], f([-1,-1,1,1]) = 0
So the answer for the third example is 2+1+1+1+0+0 = 5. | instruction | 0 | 61,541 | 12 | 123,082 |
Tags: combinatorics, dp, math, number theory
Correct Solution:
```
mod = 998244853
MAX = 4000
n,m = map(int,input().split())
k = [[0 for _ in range(0,m+1)] for _ in range(0,n+1)]
c = [[0 for _ in range(0,m+1)] for _ in range(0,n+1)]
ans = [[0 for _ in range(0,m+1)] for _ in range(0,n+1)]
#Combinacion de n+m elementos en m. Expresado en forma recurrente para minimizar el
#costo computacional.
for x in range(n+1):
for y in range (m+1):
if x == 0 or y == 0:
c[x][y] = 1
else:
c[x][y] = (c[x-1][y] + c[x][y-1])%mod
#Con un dp k[x][y] se cuenta la cantidad de combinaciones de 1 y -1, tal que la suma maxima de prefijos es igual a cero.
for x in range(n+1):
for y in range (m+1):
#Si x=0 entonces k[x][y] = 1 existe una sola combinacion con los -1.
if x == 0:
k[0][y] = 1
#Si x <= y entonces si existe una disposicion de 'x' 1 y 'y-1' -1 tal que la suma de
#prefijos maximos es igual a cero entonces si se le agrega un -1 al final sigue siendo cero. Ahora
#si tenemos una disposicion de 'x-1' 1 y 'y' -1 tal que la suma de prefijos es igual a
#cero entonces si se le agrega un 1 al final, la suma maxima de prefijos sigue siendo igual a cero.
elif x <= y:
k[x][y] = (k[x-1][y] + k[x][y-1])%mod
#Con un dp ans[x][y] se cuenta la respuesta para cada x,y.
for x in range(n+1):
for y in range (m+1):
#Si la cantidad de -1 es cero entonces la suma maxima de prefijos es el total de 1.
if y == 0:
ans[x][0] = x
#Si la cantidad de 1 es cero entonces la suma maxima de prefijos debe ser cero porque la suma de pefijos es menor que cero.
elif x == 0:
ans[0][y] = 0
else:
ans[x][y] = (ans[x-1][y] + c[x-1][y] + ans[x][y-1] - (c[x][y-1] - k[x][y-1]))%mod
print(int(ans[n][m]))
``` | output | 1 | 61,541 | 12 | 123,083 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Natasha's favourite numbers are n and 1, and Sasha's favourite numbers are m and -1. One day Natasha and Sasha met and wrote down every possible array of length n+m such that some n of its elements are equal to 1 and another m elements are equal to -1. For each such array they counted its maximal prefix sum, probably an empty one which is equal to 0 (in another words, if every nonempty prefix sum is less to zero, then it is considered equal to zero). Formally, denote as f(a) the maximal prefix sum of an array a_{1, … ,l} of length l ≥ 0. Then:
$$$f(a) = max (0, \smash{\displaystylemax_{1 ≤ i ≤ l}} ∑_{j=1}^{i} a_j )$$$
Now they want to count the sum of maximal prefix sums for each such an array and they are asking you to help. As this sum can be very large, output it modulo 998\: 244\: 853.
Input
The only line contains two integers n and m (0 ≤ n,m ≤ 2 000).
Output
Output the answer to the problem modulo 998\: 244\: 853.
Examples
Input
0 2
Output
0
Input
2 0
Output
2
Input
2 2
Output
5
Input
2000 2000
Output
674532367
Note
In the first example the only possible array is [-1,-1], its maximal prefix sum is equal to 0.
In the second example the only possible array is [1,1], its maximal prefix sum is equal to 2.
There are 6 possible arrays in the third example:
[1,1,-1,-1], f([1,1,-1,-1]) = 2
[1,-1,1,-1], f([1,-1,1,-1]) = 1
[1,-1,-1,1], f([1,-1,-1,1]) = 1
[-1,1,1,-1], f([-1,1,1,-1]) = 1
[-1,1,-1,1], f([-1,1,-1,1]) = 0
[-1,-1,1,1], f([-1,-1,1,1]) = 0
So the answer for the third example is 2+1+1+1+0+0 = 5. | instruction | 0 | 61,542 | 12 | 123,084 |
Tags: combinatorics, dp, math, number theory
Correct Solution:
```
P = 998244853
N = 4000
f, fi = [0] * (N + 1), [0] * (N + 1)
f[0] = 1
for i in range(N):
f[i + 1] = f[i] * (i + 1) % P
fi[-1] = pow(f[-1], P - 2, P)
for i in reversed(range(N)):
fi[i] = fi[i + 1] * (i + 1) % P
def C(n, r):
c = 1
while n or r:
a, b = n % P, r % P
if a < b:
return 0
c = c * f[a] % P * fi[b] % P * fi[a - b] % P
n //= P
r //= P
return c
n, m = map(int, input().split())
k = max(n - m - 1, 0)
print((k * C(n + m, m) + sum(C(n + m, m + i) for i in range(k + 1, n)) + 1) % P if n else 0)
``` | output | 1 | 61,542 | 12 | 123,085 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Natasha's favourite numbers are n and 1, and Sasha's favourite numbers are m and -1. One day Natasha and Sasha met and wrote down every possible array of length n+m such that some n of its elements are equal to 1 and another m elements are equal to -1. For each such array they counted its maximal prefix sum, probably an empty one which is equal to 0 (in another words, if every nonempty prefix sum is less to zero, then it is considered equal to zero). Formally, denote as f(a) the maximal prefix sum of an array a_{1, … ,l} of length l ≥ 0. Then:
$$$f(a) = max (0, \smash{\displaystylemax_{1 ≤ i ≤ l}} ∑_{j=1}^{i} a_j )$$$
Now they want to count the sum of maximal prefix sums for each such an array and they are asking you to help. As this sum can be very large, output it modulo 998\: 244\: 853.
Input
The only line contains two integers n and m (0 ≤ n,m ≤ 2 000).
Output
Output the answer to the problem modulo 998\: 244\: 853.
Examples
Input
0 2
Output
0
Input
2 0
Output
2
Input
2 2
Output
5
Input
2000 2000
Output
674532367
Note
In the first example the only possible array is [-1,-1], its maximal prefix sum is equal to 0.
In the second example the only possible array is [1,1], its maximal prefix sum is equal to 2.
There are 6 possible arrays in the third example:
[1,1,-1,-1], f([1,1,-1,-1]) = 2
[1,-1,1,-1], f([1,-1,1,-1]) = 1
[1,-1,-1,1], f([1,-1,-1,1]) = 1
[-1,1,1,-1], f([-1,1,1,-1]) = 1
[-1,1,-1,1], f([-1,1,-1,1]) = 0
[-1,-1,1,1], f([-1,-1,1,1]) = 0
So the answer for the third example is 2+1+1+1+0+0 = 5. | instruction | 0 | 61,543 | 12 | 123,086 |
Tags: combinatorics, dp, math, number theory
Correct Solution:
```
n,m = map(int,input().split())
mod = 998244853
inv = [0] * 5000
fac = [0] * 5000
invfac = [0] * 5000
invfac[0] = invfac[1] = 1
fac[0] = fac[1] = 1
inv[0] = inv[1] = 1
for i in range(2,4500):
inv[i] = (mod - mod//i) * inv[mod%i] % mod
for i in range(2,4500):
fac[i] = i*fac[i-1]%mod
invfac[i] = inv[i]*invfac[i-1]%mod
def c(x,y):
if(x<y):
return 0
return ((fac[x]*invfac[x-y])%mod)*invfac[y]%mod
#
# dp = [[0]*2005 for _i in range(2005)]
# ans = [[0]*2005 for _i in range(2005)]
#
#
# for i in range(m+1):
# dp[0][i] = 1
#
# for i in range(1,n+1):
# for j in range(i,m+1):
# dp[i][j] = dp[i-1][j]+dp[i][j-1]
def cal(x,y):
if x>y:
return 0
return c(x+y,y) - c(x+y,y+1)
pre = [0] * 2005
now = [0] * 2005
for i in range (1,n+1):
now[0] = i
for k in range(1,m+1):
pre[k] = now[k]
for j in range(1,m+1):
now[j] = pre[j] + c(i+j-1,j) + now[j-1] - c(i+j-1,i) + cal(i,j-1)
now[j] %= mod
print(now[m])
``` | output | 1 | 61,543 | 12 | 123,087 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Natasha's favourite numbers are n and 1, and Sasha's favourite numbers are m and -1. One day Natasha and Sasha met and wrote down every possible array of length n+m such that some n of its elements are equal to 1 and another m elements are equal to -1. For each such array they counted its maximal prefix sum, probably an empty one which is equal to 0 (in another words, if every nonempty prefix sum is less to zero, then it is considered equal to zero). Formally, denote as f(a) the maximal prefix sum of an array a_{1, … ,l} of length l ≥ 0. Then:
$$$f(a) = max (0, \smash{\displaystylemax_{1 ≤ i ≤ l}} ∑_{j=1}^{i} a_j )$$$
Now they want to count the sum of maximal prefix sums for each such an array and they are asking you to help. As this sum can be very large, output it modulo 998\: 244\: 853.
Input
The only line contains two integers n and m (0 ≤ n,m ≤ 2 000).
Output
Output the answer to the problem modulo 998\: 244\: 853.
Examples
Input
0 2
Output
0
Input
2 0
Output
2
Input
2 2
Output
5
Input
2000 2000
Output
674532367
Note
In the first example the only possible array is [-1,-1], its maximal prefix sum is equal to 0.
In the second example the only possible array is [1,1], its maximal prefix sum is equal to 2.
There are 6 possible arrays in the third example:
[1,1,-1,-1], f([1,1,-1,-1]) = 2
[1,-1,1,-1], f([1,-1,1,-1]) = 1
[1,-1,-1,1], f([1,-1,-1,1]) = 1
[-1,1,1,-1], f([-1,1,1,-1]) = 1
[-1,1,-1,1], f([-1,1,-1,1]) = 0
[-1,-1,1,1], f([-1,-1,1,1]) = 0
So the answer for the third example is 2+1+1+1+0+0 = 5. | instruction | 0 | 61,544 | 12 | 123,088 |
Tags: combinatorics, dp, math, number theory
Correct Solution:
```
mod = 998244853
def frac(limit):
frac = [1]*limit
for i in range(2,limit):
frac[i] = i * frac[i-1]%mod
fraci = [None]*limit
fraci[-1] = pow(frac[-1], mod -2, mod)
for i in range(-2, -limit-1, -1):
fraci[i] = fraci[i+1] * (limit + i + 1) % mod
return frac, fraci
frac, fraci = frac(13413)
def comb(a, b):
if not a >= b >= 0:
return 0
return frac[a]*fraci[b]*fraci[a-b]%mod
N, M = map(int, input().split())
print(sum(comb(N+M, min(i, M)) for i in range(N))%mod)
``` | output | 1 | 61,544 | 12 | 123,089 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Natasha's favourite numbers are n and 1, and Sasha's favourite numbers are m and -1. One day Natasha and Sasha met and wrote down every possible array of length n+m such that some n of its elements are equal to 1 and another m elements are equal to -1. For each such array they counted its maximal prefix sum, probably an empty one which is equal to 0 (in another words, if every nonempty prefix sum is less to zero, then it is considered equal to zero). Formally, denote as f(a) the maximal prefix sum of an array a_{1, … ,l} of length l ≥ 0. Then:
$$$f(a) = max (0, \smash{\displaystylemax_{1 ≤ i ≤ l}} ∑_{j=1}^{i} a_j )$$$
Now they want to count the sum of maximal prefix sums for each such an array and they are asking you to help. As this sum can be very large, output it modulo 998\: 244\: 853.
Input
The only line contains two integers n and m (0 ≤ n,m ≤ 2 000).
Output
Output the answer to the problem modulo 998\: 244\: 853.
Examples
Input
0 2
Output
0
Input
2 0
Output
2
Input
2 2
Output
5
Input
2000 2000
Output
674532367
Note
In the first example the only possible array is [-1,-1], its maximal prefix sum is equal to 0.
In the second example the only possible array is [1,1], its maximal prefix sum is equal to 2.
There are 6 possible arrays in the third example:
[1,1,-1,-1], f([1,1,-1,-1]) = 2
[1,-1,1,-1], f([1,-1,1,-1]) = 1
[1,-1,-1,1], f([1,-1,-1,1]) = 1
[-1,1,1,-1], f([-1,1,1,-1]) = 1
[-1,1,-1,1], f([-1,1,-1,1]) = 0
[-1,-1,1,1], f([-1,-1,1,1]) = 0
So the answer for the third example is 2+1+1+1+0+0 = 5. | instruction | 0 | 61,545 | 12 | 123,090 |
Tags: combinatorics, dp, math, number theory
Correct Solution:
```
n, m = map(int, input().split())
mod = 998244853
fact = [1]
invfact = [1]
def pw(x, y):
ans = 1
while (y):
if (y & 1):
ans = (ans * x) % mod
x = x * x % mod
y >>= 1
return ans
def inv(x):
return pw(x, mod - 2)
for i in range(1, n + m + 1):
fact.append(fact[i - 1] * i % mod)
invfact.append(invfact[i - 1] * inv(i) % mod)
mn = max(0, n - m)
def ways_to(sub):
inc = (n + m + sub) // 2
return fact[n + m] * invfact[inc] * invfact[n + m - inc] % mod
ans = 0
ways = [0 for x in range(0, n + 2)]
for i in range (mn, n + 1):
ways[i] = ways_to(n - m) - ways_to(2 * i - n + m)
ways[n + 1] = ways_to(n - m)
for i in range(1, n + 1):
ans += i * (ways[i + 1] - ways[i])
ans %= mod
if (ans < 0) :
ans += mod
print(ans)
``` | output | 1 | 61,545 | 12 | 123,091 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Natasha's favourite numbers are n and 1, and Sasha's favourite numbers are m and -1. One day Natasha and Sasha met and wrote down every possible array of length n+m such that some n of its elements are equal to 1 and another m elements are equal to -1. For each such array they counted its maximal prefix sum, probably an empty one which is equal to 0 (in another words, if every nonempty prefix sum is less to zero, then it is considered equal to zero). Formally, denote as f(a) the maximal prefix sum of an array a_{1, … ,l} of length l ≥ 0. Then:
$$$f(a) = max (0, \smash{\displaystylemax_{1 ≤ i ≤ l}} ∑_{j=1}^{i} a_j )$$$
Now they want to count the sum of maximal prefix sums for each such an array and they are asking you to help. As this sum can be very large, output it modulo 998\: 244\: 853.
Input
The only line contains two integers n and m (0 ≤ n,m ≤ 2 000).
Output
Output the answer to the problem modulo 998\: 244\: 853.
Examples
Input
0 2
Output
0
Input
2 0
Output
2
Input
2 2
Output
5
Input
2000 2000
Output
674532367
Note
In the first example the only possible array is [-1,-1], its maximal prefix sum is equal to 0.
In the second example the only possible array is [1,1], its maximal prefix sum is equal to 2.
There are 6 possible arrays in the third example:
[1,1,-1,-1], f([1,1,-1,-1]) = 2
[1,-1,1,-1], f([1,-1,1,-1]) = 1
[1,-1,-1,1], f([1,-1,-1,1]) = 1
[-1,1,1,-1], f([-1,1,1,-1]) = 1
[-1,1,-1,1], f([-1,1,-1,1]) = 0
[-1,-1,1,1], f([-1,-1,1,1]) = 0
So the answer for the third example is 2+1+1+1+0+0 = 5.
Submitted Solution:
```
MOD = 998244853
MAXN = 4000
fact, inv_fact = [0] * (MAXN + 1), [0] * (MAXN + 1)
fact[0] = 1
for i in range(MAXN):
fact[i + 1] = fact[i] * (i + 1) % MOD
inv_fact[-1] = pow(fact[-1], MOD - 2, MOD)
for i in reversed(range(MAXN)):
inv_fact[i] = inv_fact[i + 1] * (i + 1) % MOD
def nCr_mod(n, r):
res = 1
while n or r:
a, b = n % MOD, r % MOD
if a < b:
return 0
res = res * fact[a] % MOD * inv_fact[b] % MOD * inv_fact[a - b] % MOD
n //= MOD
r //= MOD
return res
n, m = map(int, input().split())
k = max(n - m - 1, 0)
print((k * nCr_mod(n + m, m) +
sum(nCr_mod(n + m, m + i) for i in range(k + 1, n)) + min(1, n)) % MOD)
``` | instruction | 0 | 61,546 | 12 | 123,092 |
Yes | output | 1 | 61,546 | 12 | 123,093 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Natasha's favourite numbers are n and 1, and Sasha's favourite numbers are m and -1. One day Natasha and Sasha met and wrote down every possible array of length n+m such that some n of its elements are equal to 1 and another m elements are equal to -1. For each such array they counted its maximal prefix sum, probably an empty one which is equal to 0 (in another words, if every nonempty prefix sum is less to zero, then it is considered equal to zero). Formally, denote as f(a) the maximal prefix sum of an array a_{1, … ,l} of length l ≥ 0. Then:
$$$f(a) = max (0, \smash{\displaystylemax_{1 ≤ i ≤ l}} ∑_{j=1}^{i} a_j )$$$
Now they want to count the sum of maximal prefix sums for each such an array and they are asking you to help. As this sum can be very large, output it modulo 998\: 244\: 853.
Input
The only line contains two integers n and m (0 ≤ n,m ≤ 2 000).
Output
Output the answer to the problem modulo 998\: 244\: 853.
Examples
Input
0 2
Output
0
Input
2 0
Output
2
Input
2 2
Output
5
Input
2000 2000
Output
674532367
Note
In the first example the only possible array is [-1,-1], its maximal prefix sum is equal to 0.
In the second example the only possible array is [1,1], its maximal prefix sum is equal to 2.
There are 6 possible arrays in the third example:
[1,1,-1,-1], f([1,1,-1,-1]) = 2
[1,-1,1,-1], f([1,-1,1,-1]) = 1
[1,-1,-1,1], f([1,-1,-1,1]) = 1
[-1,1,1,-1], f([-1,1,1,-1]) = 1
[-1,1,-1,1], f([-1,1,-1,1]) = 0
[-1,-1,1,1], f([-1,-1,1,1]) = 0
So the answer for the third example is 2+1+1+1+0+0 = 5.
Submitted Solution:
```
import sys
import math
MOD = 998244853
def prepare_c(n):
result = [1]
last = [1, 1]
for i in range(2, n + 1):
new = [1]
for j in range(1, i):
new.append((last[j - 1] + last[j]) % MOD)
new.append(1)
last = new
return new
def main():
(a, b) = tuple([int(x) for x in input().split()])
if a + b == 0:
print(0)
return
c = prepare_c(a + b)
min_lv = max(0, a - b)
max_lv = a
res = 0
res += (min_lv * c[a]) % MOD
for lv in range(min_lv + 1, max_lv + 1):
t = 2 * lv - a + b
res += c[(a + b + t) // 2]
res = res % MOD
print(res)
if __name__ == '__main__':
main()
``` | instruction | 0 | 61,547 | 12 | 123,094 |
Yes | output | 1 | 61,547 | 12 | 123,095 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Natasha's favourite numbers are n and 1, and Sasha's favourite numbers are m and -1. One day Natasha and Sasha met and wrote down every possible array of length n+m such that some n of its elements are equal to 1 and another m elements are equal to -1. For each such array they counted its maximal prefix sum, probably an empty one which is equal to 0 (in another words, if every nonempty prefix sum is less to zero, then it is considered equal to zero). Formally, denote as f(a) the maximal prefix sum of an array a_{1, … ,l} of length l ≥ 0. Then:
$$$f(a) = max (0, \smash{\displaystylemax_{1 ≤ i ≤ l}} ∑_{j=1}^{i} a_j )$$$
Now they want to count the sum of maximal prefix sums for each such an array and they are asking you to help. As this sum can be very large, output it modulo 998\: 244\: 853.
Input
The only line contains two integers n and m (0 ≤ n,m ≤ 2 000).
Output
Output the answer to the problem modulo 998\: 244\: 853.
Examples
Input
0 2
Output
0
Input
2 0
Output
2
Input
2 2
Output
5
Input
2000 2000
Output
674532367
Note
In the first example the only possible array is [-1,-1], its maximal prefix sum is equal to 0.
In the second example the only possible array is [1,1], its maximal prefix sum is equal to 2.
There are 6 possible arrays in the third example:
[1,1,-1,-1], f([1,1,-1,-1]) = 2
[1,-1,1,-1], f([1,-1,1,-1]) = 1
[1,-1,-1,1], f([1,-1,-1,1]) = 1
[-1,1,1,-1], f([-1,1,1,-1]) = 1
[-1,1,-1,1], f([-1,1,-1,1]) = 0
[-1,-1,1,1], f([-1,-1,1,1]) = 0
So the answer for the third example is 2+1+1+1+0+0 = 5.
Submitted Solution:
```
import sys
"""def modinv(x, y):
z = y - 2
ans = 1
while z > 0:
if z % 2 == 0:
z = z // 2
x = (x * x) % y
else:
ans = (ans * x) % y
z = z - 1
return ans"""
n, m = list(map(int, sys.stdin.readline().strip().split()))
p = 998244853
G = [[0 for i in range (0, m+1)] for j in range (0, n+1)]
H = [[0 for i in range (0, m+1)] for j in range (0, n+1)]
B = [[0 for i in range (0, m+1)] for j in range (0, n+1)]
"""I = [0] * 2001
for i in range (1, 2001):
I[i] = modinv(i, p)"""
for i in range (0, n+1):
for j in range (0, m+1):
if i == 0 or j == 0:
B[i][j] = 1
else:
B[i][j] = (B[i-1][j] + B[i][j-1]) % p
for i in range (0, n+1):
for j in range (0, m+1):
if i == 0:
H[i][j] = 1
elif j >= i:
H[i][j] = (H[i-1][j]+H[i][j-1]) % p
for i in range (0, n+1):
for j in range (0, m+1):
if j == 0:
G[i][0] = i
elif i == 0:
G[0][j] = 0
else:
G[i][j] = (G[i-1][j] + G[i][j-1] + H[i][j-1] + B[i-1][j] - B[i][j-1]) % p
print(G[n][m])
``` | instruction | 0 | 61,548 | 12 | 123,096 |
Yes | output | 1 | 61,548 | 12 | 123,097 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Natasha's favourite numbers are n and 1, and Sasha's favourite numbers are m and -1. One day Natasha and Sasha met and wrote down every possible array of length n+m such that some n of its elements are equal to 1 and another m elements are equal to -1. For each such array they counted its maximal prefix sum, probably an empty one which is equal to 0 (in another words, if every nonempty prefix sum is less to zero, then it is considered equal to zero). Formally, denote as f(a) the maximal prefix sum of an array a_{1, … ,l} of length l ≥ 0. Then:
$$$f(a) = max (0, \smash{\displaystylemax_{1 ≤ i ≤ l}} ∑_{j=1}^{i} a_j )$$$
Now they want to count the sum of maximal prefix sums for each such an array and they are asking you to help. As this sum can be very large, output it modulo 998\: 244\: 853.
Input
The only line contains two integers n and m (0 ≤ n,m ≤ 2 000).
Output
Output the answer to the problem modulo 998\: 244\: 853.
Examples
Input
0 2
Output
0
Input
2 0
Output
2
Input
2 2
Output
5
Input
2000 2000
Output
674532367
Note
In the first example the only possible array is [-1,-1], its maximal prefix sum is equal to 0.
In the second example the only possible array is [1,1], its maximal prefix sum is equal to 2.
There are 6 possible arrays in the third example:
[1,1,-1,-1], f([1,1,-1,-1]) = 2
[1,-1,1,-1], f([1,-1,1,-1]) = 1
[1,-1,-1,1], f([1,-1,-1,1]) = 1
[-1,1,1,-1], f([-1,1,1,-1]) = 1
[-1,1,-1,1], f([-1,1,-1,1]) = 0
[-1,-1,1,1], f([-1,-1,1,1]) = 0
So the answer for the third example is 2+1+1+1+0+0 = 5.
Submitted Solution:
```
MOD = 998244853
N = 4000
fact = [1] * (N + 1)
invfact = [1] * (N + 1)
for i in range(1, N + 1):
fact[i] = (fact[i - 1] * i) % MOD
invfact[N] = pow(fact[N], MOD - 2, MOD)
for i in range(N - 1, 0, -1):
invfact[i] = (invfact[i + 1] * (i + 1)) % MOD
def C(n, k):
return (fact[n] * invfact[k] * invfact[n - k]) % MOD if n >= k else 0
def main():
n, m = [int(x) for x in input().split()]
ans = 0
for i in range(1, n + 1):
if n - i >= m:
ans += C(n + m, n)
else:
ans += C(n + m, m + i)
if ans >= MOD:
ans -= MOD
print(ans)
main()
``` | instruction | 0 | 61,549 | 12 | 123,098 |
Yes | output | 1 | 61,549 | 12 | 123,099 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Natasha's favourite numbers are n and 1, and Sasha's favourite numbers are m and -1. One day Natasha and Sasha met and wrote down every possible array of length n+m such that some n of its elements are equal to 1 and another m elements are equal to -1. For each such array they counted its maximal prefix sum, probably an empty one which is equal to 0 (in another words, if every nonempty prefix sum is less to zero, then it is considered equal to zero). Formally, denote as f(a) the maximal prefix sum of an array a_{1, … ,l} of length l ≥ 0. Then:
$$$f(a) = max (0, \smash{\displaystylemax_{1 ≤ i ≤ l}} ∑_{j=1}^{i} a_j )$$$
Now they want to count the sum of maximal prefix sums for each such an array and they are asking you to help. As this sum can be very large, output it modulo 998\: 244\: 853.
Input
The only line contains two integers n and m (0 ≤ n,m ≤ 2 000).
Output
Output the answer to the problem modulo 998\: 244\: 853.
Examples
Input
0 2
Output
0
Input
2 0
Output
2
Input
2 2
Output
5
Input
2000 2000
Output
674532367
Note
In the first example the only possible array is [-1,-1], its maximal prefix sum is equal to 0.
In the second example the only possible array is [1,1], its maximal prefix sum is equal to 2.
There are 6 possible arrays in the third example:
[1,1,-1,-1], f([1,1,-1,-1]) = 2
[1,-1,1,-1], f([1,-1,1,-1]) = 1
[1,-1,-1,1], f([1,-1,-1,1]) = 1
[-1,1,1,-1], f([-1,1,1,-1]) = 1
[-1,1,-1,1], f([-1,1,-1,1]) = 0
[-1,-1,1,1], f([-1,-1,1,1]) = 0
So the answer for the third example is 2+1+1+1+0+0 = 5.
Submitted Solution:
```
P = 998244853
N, M = map(int, input().split())
fa = [1]
for i in range(4040):
fa.append(fa[-1]*(i+1)%P)
fainv = [pow(fa[-1], P-2, P)]
for i in range(4040)[::-1]:
fainv.append(fainv[-1]*(i+1)%P)
fainv = fainv[::-1]
def C(a, b):
return fa[a]*fainv[a-b]*fainv[b]%P
X = [0] * N + [C(N+M, M)]
for i in range(N):
X[i] = C(N+M, M) - C(N+M, M-i-1) if 0<=M-i-1<=N+M and N-M<i+1 else 0
print(sum([i*(X[i]-X[i-1]) for i in range(1, N+1)]) % P)
``` | instruction | 0 | 61,550 | 12 | 123,100 |
No | output | 1 | 61,550 | 12 | 123,101 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Natasha's favourite numbers are n and 1, and Sasha's favourite numbers are m and -1. One day Natasha and Sasha met and wrote down every possible array of length n+m such that some n of its elements are equal to 1 and another m elements are equal to -1. For each such array they counted its maximal prefix sum, probably an empty one which is equal to 0 (in another words, if every nonempty prefix sum is less to zero, then it is considered equal to zero). Formally, denote as f(a) the maximal prefix sum of an array a_{1, … ,l} of length l ≥ 0. Then:
$$$f(a) = max (0, \smash{\displaystylemax_{1 ≤ i ≤ l}} ∑_{j=1}^{i} a_j )$$$
Now they want to count the sum of maximal prefix sums for each such an array and they are asking you to help. As this sum can be very large, output it modulo 998\: 244\: 853.
Input
The only line contains two integers n and m (0 ≤ n,m ≤ 2 000).
Output
Output the answer to the problem modulo 998\: 244\: 853.
Examples
Input
0 2
Output
0
Input
2 0
Output
2
Input
2 2
Output
5
Input
2000 2000
Output
674532367
Note
In the first example the only possible array is [-1,-1], its maximal prefix sum is equal to 0.
In the second example the only possible array is [1,1], its maximal prefix sum is equal to 2.
There are 6 possible arrays in the third example:
[1,1,-1,-1], f([1,1,-1,-1]) = 2
[1,-1,1,-1], f([1,-1,1,-1]) = 1
[1,-1,-1,1], f([1,-1,-1,1]) = 1
[-1,1,1,-1], f([-1,1,1,-1]) = 1
[-1,1,-1,1], f([-1,1,-1,1]) = 0
[-1,-1,1,1], f([-1,-1,1,1]) = 0
So the answer for the third example is 2+1+1+1+0+0 = 5.
Submitted Solution:
```
n, m = [int(i) for i in input().strip().split(" ")]
p = 998244853
N = n + max(n, m) + 5
M = max(n, m+1) + 5
ncr = [[0 for i in range(0, N)] for j in range(0, N)]
ncr[0][0] = 1
for i in range(1, N):
ncr[i][0] = 1
for j in range(1, i + 1):
ncr[i][j] = (ncr[i-1][j] + ncr[i-1][j-1])%p
inverses = [0, 1]
for i in range(2, M+1):
a = p // i
b = p % i
k = (-a * inverses[b]) % p
inverses.append(k)
total = 0
for k in range(1, n+1):
lol = 0
for t in range(k, n+1):
lol = (lol + ncr[2*t-k-1][t-1]*ncr[m+n+k-2*t][m+k-t]*inverses[t]*inverses[m+k+1-t]) % p
lol = (lol*k*k*(m+k+1-n)) % p
total = (total+lol) % p
print(total)
``` | instruction | 0 | 61,551 | 12 | 123,102 |
No | output | 1 | 61,551 | 12 | 123,103 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Natasha's favourite numbers are n and 1, and Sasha's favourite numbers are m and -1. One day Natasha and Sasha met and wrote down every possible array of length n+m such that some n of its elements are equal to 1 and another m elements are equal to -1. For each such array they counted its maximal prefix sum, probably an empty one which is equal to 0 (in another words, if every nonempty prefix sum is less to zero, then it is considered equal to zero). Formally, denote as f(a) the maximal prefix sum of an array a_{1, … ,l} of length l ≥ 0. Then:
$$$f(a) = max (0, \smash{\displaystylemax_{1 ≤ i ≤ l}} ∑_{j=1}^{i} a_j )$$$
Now they want to count the sum of maximal prefix sums for each such an array and they are asking you to help. As this sum can be very large, output it modulo 998\: 244\: 853.
Input
The only line contains two integers n and m (0 ≤ n,m ≤ 2 000).
Output
Output the answer to the problem modulo 998\: 244\: 853.
Examples
Input
0 2
Output
0
Input
2 0
Output
2
Input
2 2
Output
5
Input
2000 2000
Output
674532367
Note
In the first example the only possible array is [-1,-1], its maximal prefix sum is equal to 0.
In the second example the only possible array is [1,1], its maximal prefix sum is equal to 2.
There are 6 possible arrays in the third example:
[1,1,-1,-1], f([1,1,-1,-1]) = 2
[1,-1,1,-1], f([1,-1,1,-1]) = 1
[1,-1,-1,1], f([1,-1,-1,1]) = 1
[-1,1,1,-1], f([-1,1,1,-1]) = 1
[-1,1,-1,1], f([-1,1,-1,1]) = 0
[-1,-1,1,1], f([-1,-1,1,1]) = 0
So the answer for the third example is 2+1+1+1+0+0 = 5.
Submitted Solution:
```
import sys
n, m = list(map(int, sys.stdin.readline().strip().split()))
p = 998244853
G = [[0 for i in range (0, m+1)] for j in range (0, n+1)]
H = [[0 for i in range (0, m+1)] for j in range (0, n+1)]
B = [[0 for i in range (0, m+1)] for j in range (0, n+1)]
for i in range (0, n+1):
for j in range (0, m+1):
if i == 0:
H[i][j] = 1
elif j >= i:
H[i][j] = (H[i-1][j]+H[i][j-1]) % p
for i in range (0, n+1):
for j in range (0, m+1):
if j == 0:
G[i][0] = i
elif i == 0:
G[0][j] = 0
else:
G[i][j] = (G[i-1][j] + G[i][j-1] + H[i][j-1]) % p
print(G[n][m])
``` | instruction | 0 | 61,552 | 12 | 123,104 |
No | output | 1 | 61,552 | 12 | 123,105 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Natasha's favourite numbers are n and 1, and Sasha's favourite numbers are m and -1. One day Natasha and Sasha met and wrote down every possible array of length n+m such that some n of its elements are equal to 1 and another m elements are equal to -1. For each such array they counted its maximal prefix sum, probably an empty one which is equal to 0 (in another words, if every nonempty prefix sum is less to zero, then it is considered equal to zero). Formally, denote as f(a) the maximal prefix sum of an array a_{1, … ,l} of length l ≥ 0. Then:
$$$f(a) = max (0, \smash{\displaystylemax_{1 ≤ i ≤ l}} ∑_{j=1}^{i} a_j )$$$
Now they want to count the sum of maximal prefix sums for each such an array and they are asking you to help. As this sum can be very large, output it modulo 998\: 244\: 853.
Input
The only line contains two integers n and m (0 ≤ n,m ≤ 2 000).
Output
Output the answer to the problem modulo 998\: 244\: 853.
Examples
Input
0 2
Output
0
Input
2 0
Output
2
Input
2 2
Output
5
Input
2000 2000
Output
674532367
Note
In the first example the only possible array is [-1,-1], its maximal prefix sum is equal to 0.
In the second example the only possible array is [1,1], its maximal prefix sum is equal to 2.
There are 6 possible arrays in the third example:
[1,1,-1,-1], f([1,1,-1,-1]) = 2
[1,-1,1,-1], f([1,-1,1,-1]) = 1
[1,-1,-1,1], f([1,-1,-1,1]) = 1
[-1,1,1,-1], f([-1,1,1,-1]) = 1
[-1,1,-1,1], f([-1,1,-1,1]) = 0
[-1,-1,1,1], f([-1,-1,1,1]) = 0
So the answer for the third example is 2+1+1+1+0+0 = 5.
Submitted Solution:
```
def func(n, m):
if (n == 0):
return 0;
if (m == 0):
return n;
sum = n;
i = n - 1;
while (i > 0):
# print(sum);
sum += i * (n + m - 1);
if (sum > 998244853):
sum %= 998244853
i -= 1;
return sum;
n, m = map(int, input().split());
print(func(n, m));
``` | instruction | 0 | 61,553 | 12 | 123,106 |
No | output | 1 | 61,553 | 12 | 123,107 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two integers a and b. Print a+b.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
Each test case is given as a line of two integers a and b (-1000 ≤ a, b ≤ 1000).
Output
Print t integers — the required numbers a+b.
Example
Input
4
1 5
314 15
-99 99
123 987
Output
6
329
0
1110 | instruction | 0 | 61,625 | 12 | 123,250 |
Tags: implementation
Correct Solution:
```
"""
This template is made by Satwik_Tiwari.
python programmers can use this template :)) .
"""
#===============================================================================================
#importing some useful libraries.
import sys
import bisect
import heapq
from math import *
from collections import Counter as counter # Counter(list) return a dict with {key: count}
from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
from itertools import permutations as permutate
from bisect import bisect_left as bl #
from bisect import bisect_right as br
from bisect import bisect
#===============================================================================================
#some shortcuts
mod = pow(10, 9) + 7
def inp(): return sys.stdin.readline().strip() #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n") #as stdout.write always print sring.
def testcase(t):
for p in range(t):
solve()
def printlist(a) :
for p in range(0,len(a)):
out(str(a[p]) + ' ')
def lcm(a,b): return (a*b)//gcd(a,b)
#===============================================================================================
# code here ;))
def x(i):
return ((i*(i+1)) + (i*(i-1))/2)
def solve():
a,b = sep()
print(a+b)
testcase(int(inp()))
``` | output | 1 | 61,625 | 12 | 123,251 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between the easy and the hard version is the limit to the number of queries.
This is an interactive problem.
There is an array a of n different numbers. In one query you can ask the position of the second maximum element in a subsegment a[l..r]. Find the position of the maximum element in the array in no more than 20 queries.
A subsegment a[l..r] is all the elements a_l, a_{l + 1}, ..., a_r. After asking this subsegment you will be given the position of the second maximum from this subsegment in the whole array.
Input
The first line contains a single integer n (2 ≤ n ≤ 10^5) — the number of elements in the array.
Interaction
You can ask queries by printing "? l r" (1 ≤ l < r ≤ n). The answer is the index of the second maximum of all elements a_l, a_{l + 1}, ..., a_r. Array a is fixed beforehand and can't be changed in time of interaction.
You can output the answer by printing "! p", where p is the index of the maximum element in the array.
You can ask no more than 20 queries. Printing the answer doesn't count as a query.
After printing a query do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages
Hacks
To make a hack, use the following test format.
In the first line output a single integer n (2 ≤ n ≤ 10^5). In the second line output a permutation of n integers 1 to n. The position of n in the permutation is the position of the maximum
Example
Input
5
3
4
Output
? 1 5
? 4 5
! 1
Note
In the sample suppose a is [5, 1, 4, 2, 3]. So after asking the [1..5] subsegment 4 is second to max value, and it's position is 3. After asking the [4..5] subsegment 2 is second to max value and it's position in the whole array is 4.
Note that there are other arrays a that would produce the same interaction, and the answer for them might be different. Example output is given in purpose of understanding the interaction. | instruction | 0 | 61,699 | 12 | 123,398 |
Tags: binary search, interactive
Correct Solution:
```
from __future__ import print_function # for PyPy2
from collections import Counter, OrderedDict
from itertools import permutations as perm
from fractions import Fraction
from collections import deque
from sys import stdin
from bisect import *
from heapq import *
# from math import *
g = lambda : stdin.readline().strip()
gl = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
mod = int(1e9)+7
inf = float("inf")
n, = gil()
dp = {}
def query(l, r):
if r == l : return 0
if (l, r) not in dp:
print("?", l, r, flush=True)
dp[l, r] = gil()[0]
return dp[l, r]
i = query(1, n)
if query(1, i) == i:
# max element exist in left side of the second max
l, r = 1, i
ans = i-1
while l <= r:
mid = (l+r)//2
if query(mid, i) == i:
ans = mid
l = mid + 1
else:
r = mid - 1
print("!", ans, flush=True)
else:
# max element exist in right side of the second max
l, r = i, n
ans = i+1
while l <= r:
mid = (l+r)//2
if query(i, mid) == i:
ans = mid
r = mid - 1
else:
l = mid + 1
print("!", ans, flush=True)
``` | output | 1 | 61,699 | 12 | 123,399 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between the easy and the hard version is the limit to the number of queries.
This is an interactive problem.
There is an array a of n different numbers. In one query you can ask the position of the second maximum element in a subsegment a[l..r]. Find the position of the maximum element in the array in no more than 20 queries.
A subsegment a[l..r] is all the elements a_l, a_{l + 1}, ..., a_r. After asking this subsegment you will be given the position of the second maximum from this subsegment in the whole array.
Input
The first line contains a single integer n (2 ≤ n ≤ 10^5) — the number of elements in the array.
Interaction
You can ask queries by printing "? l r" (1 ≤ l < r ≤ n). The answer is the index of the second maximum of all elements a_l, a_{l + 1}, ..., a_r. Array a is fixed beforehand and can't be changed in time of interaction.
You can output the answer by printing "! p", where p is the index of the maximum element in the array.
You can ask no more than 20 queries. Printing the answer doesn't count as a query.
After printing a query do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages
Hacks
To make a hack, use the following test format.
In the first line output a single integer n (2 ≤ n ≤ 10^5). In the second line output a permutation of n integers 1 to n. The position of n in the permutation is the position of the maximum
Example
Input
5
3
4
Output
? 1 5
? 4 5
! 1
Note
In the sample suppose a is [5, 1, 4, 2, 3]. So after asking the [1..5] subsegment 4 is second to max value, and it's position is 3. After asking the [4..5] subsegment 2 is second to max value and it's position in the whole array is 4.
Note that there are other arrays a that would produce the same interaction, and the answer for them might be different. Example output is given in purpose of understanding the interaction. | instruction | 0 | 61,700 | 12 | 123,400 |
Tags: binary search, interactive
Correct Solution:
```
from sys import stdin, stdout
def ask(l, r):
stdout.write("? " + str(l) + " " + str(r) + "\n")
stdout.flush()
nd = int(stdin.readline())
return nd
try:
n = int(stdin.readline())
l = 1
r = n
nd = ask(l, r)
if (nd > 1 and ask(1, nd) == nd):
l = 1
r = nd
while(l+1 != r):
md = (l+r)//2
if (ask(md, nd) == nd):
l = md
else:
r = md
stdout.write("! "+str(l)+"\n")
else:
l = nd
r = n
while(l+1 != r):
md = (l+r)//2
if (ask(nd, md) == nd):
r = md
else:
l = md
stdout.write("! "+str(r)+"\n")
except:
pass
``` | output | 1 | 61,700 | 12 | 123,401 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between the easy and the hard version is the limit to the number of queries.
This is an interactive problem.
There is an array a of n different numbers. In one query you can ask the position of the second maximum element in a subsegment a[l..r]. Find the position of the maximum element in the array in no more than 20 queries.
A subsegment a[l..r] is all the elements a_l, a_{l + 1}, ..., a_r. After asking this subsegment you will be given the position of the second maximum from this subsegment in the whole array.
Input
The first line contains a single integer n (2 ≤ n ≤ 10^5) — the number of elements in the array.
Interaction
You can ask queries by printing "? l r" (1 ≤ l < r ≤ n). The answer is the index of the second maximum of all elements a_l, a_{l + 1}, ..., a_r. Array a is fixed beforehand and can't be changed in time of interaction.
You can output the answer by printing "! p", where p is the index of the maximum element in the array.
You can ask no more than 20 queries. Printing the answer doesn't count as a query.
After printing a query do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages
Hacks
To make a hack, use the following test format.
In the first line output a single integer n (2 ≤ n ≤ 10^5). In the second line output a permutation of n integers 1 to n. The position of n in the permutation is the position of the maximum
Example
Input
5
3
4
Output
? 1 5
? 4 5
! 1
Note
In the sample suppose a is [5, 1, 4, 2, 3]. So after asking the [1..5] subsegment 4 is second to max value, and it's position is 3. After asking the [4..5] subsegment 2 is second to max value and it's position in the whole array is 4.
Note that there are other arrays a that would produce the same interaction, and the answer for them might be different. Example output is given in purpose of understanding the interaction.
Submitted Solution:
```
def ask(l, r):
if l == r:
return -1
print('?', l, r)
return int(input())
n = int(input())
l = 1
r = n
while (l < r):
m = l + (r-l)//2
a = ask(l,r)
if (a <= m):
b = ask(l,m)
if b==a:
r = m
else:
l = m+1
else:
b = ask(m+1, r)
if b == a:
l = m+1
else:
r = m
print("! " + str(l))
``` | instruction | 0 | 61,701 | 12 | 123,402 |
No | output | 1 | 61,701 | 12 | 123,403 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between the easy and the hard version is the limit to the number of queries.
This is an interactive problem.
There is an array a of n different numbers. In one query you can ask the position of the second maximum element in a subsegment a[l..r]. Find the position of the maximum element in the array in no more than 20 queries.
A subsegment a[l..r] is all the elements a_l, a_{l + 1}, ..., a_r. After asking this subsegment you will be given the position of the second maximum from this subsegment in the whole array.
Input
The first line contains a single integer n (2 ≤ n ≤ 10^5) — the number of elements in the array.
Interaction
You can ask queries by printing "? l r" (1 ≤ l < r ≤ n). The answer is the index of the second maximum of all elements a_l, a_{l + 1}, ..., a_r. Array a is fixed beforehand and can't be changed in time of interaction.
You can output the answer by printing "! p", where p is the index of the maximum element in the array.
You can ask no more than 20 queries. Printing the answer doesn't count as a query.
After printing a query do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages
Hacks
To make a hack, use the following test format.
In the first line output a single integer n (2 ≤ n ≤ 10^5). In the second line output a permutation of n integers 1 to n. The position of n in the permutation is the position of the maximum
Example
Input
5
3
4
Output
? 1 5
? 4 5
! 1
Note
In the sample suppose a is [5, 1, 4, 2, 3]. So after asking the [1..5] subsegment 4 is second to max value, and it's position is 3. After asking the [4..5] subsegment 2 is second to max value and it's position in the whole array is 4.
Note that there are other arrays a that would produce the same interaction, and the answer for them might be different. Example output is given in purpose of understanding the interaction.
Submitted Solution:
```
'''Author- Akshit Monga'''
from sys import stdin, stdout,exit
input = stdin.readline
def ask(l,r):
if l==r:
return l
print("?",l+1,r+1,flush=True)
return int(input())-1
t = 1
for _ in range(t):
n=int(input())
l=0
r=n-1
hash={}
while 1:
if r==l:
print("!",r+1,flush=True)
exit()
if r-l+1==2:
if (l,r) not in hash:
hash[(l,r)]=ask(l,r)
if hash[(l,r)]==l:
print("!",r+1,flush=True)
else:
print("!",l+1,flush=True)
exit()
if (l,r) not in hash:
hash[(l,r)]=ask(l,r)
mid=(l+r)//2
if (l,mid) not in hash:
hash[(l,mid)]=ask(l,mid)
if (mid+1,r) not in hash:
hash[(mid+1,r)]=ask(mid+1,r)
if hash[(l,r)]==hash[(l,mid)] and l!=mid:
r=mid
continue
if hash[(l,r)]==hash[(mid+1,r)] and mid+1!=r:
l=mid+1
continue
if hash[(l,r)]<=mid:
l=mid+1
else:
r=mid
``` | instruction | 0 | 61,702 | 12 | 123,404 |
No | output | 1 | 61,702 | 12 | 123,405 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between the easy and the hard version is the limit to the number of queries.
This is an interactive problem.
There is an array a of n different numbers. In one query you can ask the position of the second maximum element in a subsegment a[l..r]. Find the position of the maximum element in the array in no more than 20 queries.
A subsegment a[l..r] is all the elements a_l, a_{l + 1}, ..., a_r. After asking this subsegment you will be given the position of the second maximum from this subsegment in the whole array.
Input
The first line contains a single integer n (2 ≤ n ≤ 10^5) — the number of elements in the array.
Interaction
You can ask queries by printing "? l r" (1 ≤ l < r ≤ n). The answer is the index of the second maximum of all elements a_l, a_{l + 1}, ..., a_r. Array a is fixed beforehand and can't be changed in time of interaction.
You can output the answer by printing "! p", where p is the index of the maximum element in the array.
You can ask no more than 20 queries. Printing the answer doesn't count as a query.
After printing a query do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages
Hacks
To make a hack, use the following test format.
In the first line output a single integer n (2 ≤ n ≤ 10^5). In the second line output a permutation of n integers 1 to n. The position of n in the permutation is the position of the maximum
Example
Input
5
3
4
Output
? 1 5
? 4 5
! 1
Note
In the sample suppose a is [5, 1, 4, 2, 3]. So after asking the [1..5] subsegment 4 is second to max value, and it's position is 3. After asking the [4..5] subsegment 2 is second to max value and it's position in the whole array is 4.
Note that there are other arrays a that would produce the same interaction, and the answer for them might be different. Example output is given in purpose of understanding the interaction.
Submitted Solution:
```
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
def getMat(n):
return [getInts() for _ in range(n)]
def isInt(s):
return '0' <= s[0] <= '9'
MOD = 10**9 + 7
from collections import defaultdict as dd
"""
"""
lookup = dd(int)
def final(X):
print("!",X,flush=True)
return
def ask(L,R):
if (L,R) in lookup: return lookup[(L,R)]
print("?",L,R,flush=True)
idx = getInt()
lookup[(L,R)] = idx
return idx
def solve():
N = getInt()
L = min_ = 1
R = max_ = N
idx2 = ask(L,R)
if N == 2:
final(3 - idx2)
return
M = (L+R)//2
if idx2 <= M:
R = M
else:
L = M+1
while min_ < max_:
#print(min_,max_)
idx = ask(L,R)
if idx == idx2:
min_ = max(min_,L)
max_ = min(max_,R)
M = (L+R)//2
if idx2 <= M: R = M
else: L = M+1
else:
if min_ < L:
max_ = min(max_,L-1)
L = (L+min_)//2
else:
min_ = max(min_,R+1)
R = (R+max_)//2
final(min_)
return
solve()
#print(time.time()-start_time)
``` | instruction | 0 | 61,703 | 12 | 123,406 |
No | output | 1 | 61,703 | 12 | 123,407 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between the easy and the hard version is the limit to the number of queries.
This is an interactive problem.
There is an array a of n different numbers. In one query you can ask the position of the second maximum element in a subsegment a[l..r]. Find the position of the maximum element in the array in no more than 20 queries.
A subsegment a[l..r] is all the elements a_l, a_{l + 1}, ..., a_r. After asking this subsegment you will be given the position of the second maximum from this subsegment in the whole array.
Input
The first line contains a single integer n (2 ≤ n ≤ 10^5) — the number of elements in the array.
Interaction
You can ask queries by printing "? l r" (1 ≤ l < r ≤ n). The answer is the index of the second maximum of all elements a_l, a_{l + 1}, ..., a_r. Array a is fixed beforehand and can't be changed in time of interaction.
You can output the answer by printing "! p", where p is the index of the maximum element in the array.
You can ask no more than 20 queries. Printing the answer doesn't count as a query.
After printing a query do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages
Hacks
To make a hack, use the following test format.
In the first line output a single integer n (2 ≤ n ≤ 10^5). In the second line output a permutation of n integers 1 to n. The position of n in the permutation is the position of the maximum
Example
Input
5
3
4
Output
? 1 5
? 4 5
! 1
Note
In the sample suppose a is [5, 1, 4, 2, 3]. So after asking the [1..5] subsegment 4 is second to max value, and it's position is 3. After asking the [4..5] subsegment 2 is second to max value and it's position in the whole array is 4.
Note that there are other arrays a that would produce the same interaction, and the answer for them might be different. Example output is given in purpose of understanding the interaction.
Submitted Solution:
```
import sys
import time
n=int(input())
s,e=1,n
while(s!=e):
mid=(s+e)//2
print("? "+str(s)+" "+str(e)+" ")
sys.stdout.flush()
a=int(input())
if s+1==e:
if s==a:
s+=1
else:
e-=1
elif mid>=a:
print("? "+str(s)+" "+str(mid)+" ")
sys.stdout.flush()
b=int(input())
if a==b:
e=mid
else:
s=mid
else:
print("? "+str(mid)+" "+str(e)+" ")
sys.stdout.flush()
b=int(input())
if a==b:
s=mid
else:
e=mid
print("! "+str(e))
sys.stdout.flush()
``` | instruction | 0 | 61,704 | 12 | 123,408 |
No | output | 1 | 61,704 | 12 | 123,409 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.