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.
Kefa decided to make some money doing business on the Internet for exactly n days. He knows that on the i-th day (1 ≤ i ≤ n) he makes ai money. Kefa loves progress, that's why he wants to know the length of the maximum non-decreasing subsegment in sequence ai. Let us remind you that the subsegment of the sequence is its continuous fragment. A subsegment of numbers is called non-decreasing if all numbers in it follow in the non-decreasing order.
Help Kefa cope with this task!
Input
The first line contains integer n (1 ≤ n ≤ 105).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
Print a single integer — the length of the maximum non-decreasing subsegment of sequence a.
Examples
Input
6
2 2 1 3 4 1
Output
3
Input
3
2 2 9
Output
3
Note
In the first test the maximum non-decreasing subsegment is the numbers from the third to the fifth one.
In the second test the maximum non-decreasing subsegment is the numbers from the first to the third one.
Submitted Solution:
```
n = input()
max1,dem = 0,0
a =list(map(int, input().split()))
a.append(0)
for i in range(len(a)-1):
dem+=1
if a[i+1]<a[i]:
max1 = max(dem,max1)
dem=0
print(max1)
``` | instruction | 0 | 93,110 | 12 | 186,220 |
Yes | output | 1 | 93,110 | 12 | 186,221 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kefa decided to make some money doing business on the Internet for exactly n days. He knows that on the i-th day (1 ≤ i ≤ n) he makes ai money. Kefa loves progress, that's why he wants to know the length of the maximum non-decreasing subsegment in sequence ai. Let us remind you that the subsegment of the sequence is its continuous fragment. A subsegment of numbers is called non-decreasing if all numbers in it follow in the non-decreasing order.
Help Kefa cope with this task!
Input
The first line contains integer n (1 ≤ n ≤ 105).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
Print a single integer — the length of the maximum non-decreasing subsegment of sequence a.
Examples
Input
6
2 2 1 3 4 1
Output
3
Input
3
2 2 9
Output
3
Note
In the first test the maximum non-decreasing subsegment is the numbers from the third to the fifth one.
In the second test the maximum non-decreasing subsegment is the numbers from the first to the third one.
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
c=1
min=1
for i in range (n-1):
if l[i]>l[i+1]:
if c>=min:
min=c
c=1
else:
c+=1
if c>min:
min=c
print(min)
``` | instruction | 0 | 93,111 | 12 | 186,222 |
No | output | 1 | 93,111 | 12 | 186,223 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kefa decided to make some money doing business on the Internet for exactly n days. He knows that on the i-th day (1 ≤ i ≤ n) he makes ai money. Kefa loves progress, that's why he wants to know the length of the maximum non-decreasing subsegment in sequence ai. Let us remind you that the subsegment of the sequence is its continuous fragment. A subsegment of numbers is called non-decreasing if all numbers in it follow in the non-decreasing order.
Help Kefa cope with this task!
Input
The first line contains integer n (1 ≤ n ≤ 105).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
Print a single integer — the length of the maximum non-decreasing subsegment of sequence a.
Examples
Input
6
2 2 1 3 4 1
Output
3
Input
3
2 2 9
Output
3
Note
In the first test the maximum non-decreasing subsegment is the numbers from the third to the fifth one.
In the second test the maximum non-decreasing subsegment is the numbers from the first to the third one.
Submitted Solution:
```
N = int(input())
arr = list(map(int,input().split()))
arr1 = [0]*N
temp = temp1 = 1
for i in range(N-1):
if arr[i] <= arr[i+1]:
temp = temp + 1
else:
print("hj")
if temp1 < temp:
print(temp1,temp)
temp1 = temp
temp = 1
if temp1 < temp:
temp1 = temp
print(temp1)
``` | instruction | 0 | 93,112 | 12 | 186,224 |
No | output | 1 | 93,112 | 12 | 186,225 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kefa decided to make some money doing business on the Internet for exactly n days. He knows that on the i-th day (1 ≤ i ≤ n) he makes ai money. Kefa loves progress, that's why he wants to know the length of the maximum non-decreasing subsegment in sequence ai. Let us remind you that the subsegment of the sequence is its continuous fragment. A subsegment of numbers is called non-decreasing if all numbers in it follow in the non-decreasing order.
Help Kefa cope with this task!
Input
The first line contains integer n (1 ≤ n ≤ 105).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
Print a single integer — the length of the maximum non-decreasing subsegment of sequence a.
Examples
Input
6
2 2 1 3 4 1
Output
3
Input
3
2 2 9
Output
3
Note
In the first test the maximum non-decreasing subsegment is the numbers from the third to the fifth one.
In the second test the maximum non-decreasing subsegment is the numbers from the first to the third one.
Submitted Solution:
```
a = int(input())
b = list(map(int, input().split()))
c, m = 1, 1
for i in range(1, a):
if(b[i] > b[i-1]):
c = 1
else:
c = c+1
m = max(m, c)
print(m)
``` | instruction | 0 | 93,113 | 12 | 186,226 |
No | output | 1 | 93,113 | 12 | 186,227 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kefa decided to make some money doing business on the Internet for exactly n days. He knows that on the i-th day (1 ≤ i ≤ n) he makes ai money. Kefa loves progress, that's why he wants to know the length of the maximum non-decreasing subsegment in sequence ai. Let us remind you that the subsegment of the sequence is its continuous fragment. A subsegment of numbers is called non-decreasing if all numbers in it follow in the non-decreasing order.
Help Kefa cope with this task!
Input
The first line contains integer n (1 ≤ n ≤ 105).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
Print a single integer — the length of the maximum non-decreasing subsegment of sequence a.
Examples
Input
6
2 2 1 3 4 1
Output
3
Input
3
2 2 9
Output
3
Note
In the first test the maximum non-decreasing subsegment is the numbers from the third to the fifth one.
In the second test the maximum non-decreasing subsegment is the numbers from the first to the third one.
Submitted Solution:
```
n=int(input())
list=[int(x) for x in input().split()]
long=0
templ=1
if len(list)==1:
print(1)
else:
for i in range(n-1):
if list[i]<=list[i+1]:
templ +=1
long=max(long,templ)
else:
templ=1
print(long)
'''ANS1
n = int(input())
line = [int(x) for x in input().split()]
num = line[0]
length = [1]*n
for i in range(1,n):
if line[i]>=num:
length[i] = length[i-1]+1
num = line[i]
length.sort()
print(length[-1])
'''
'''ANS2
i=input;i()
c=m=s=0
for i in i().split():
i=int(i)
c=c+1 if i>=s else 1
m=max(m,c)
s=i
print(m)'''
``` | instruction | 0 | 93,114 | 12 | 186,228 |
No | output | 1 | 93,114 | 12 | 186,229 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has an array a consisting of positive integer numbers. Vasya wants to divide this array into two non-empty consecutive parts (the prefix and the suffix) so that the sum of all elements in the first part equals to the sum of elements in the second part. It is not always possible, so Vasya will move some element before dividing the array (Vasya will erase some element and insert it into an arbitrary position).
Inserting an element in the same position he was erased from is also considered moving.
Can Vasya divide the array after choosing the right element to move and its new position?
Input
The first line contains single integer n (1 ≤ n ≤ 100000) — the size of the array.
The second line contains n integers a1, a2... an (1 ≤ ai ≤ 109) — the elements of the array.
Output
Print YES if Vasya can divide the array after moving one element. Otherwise print NO.
Examples
Input
3
1 3 2
Output
YES
Input
5
1 2 3 4 5
Output
NO
Input
5
2 2 3 4 5
Output
YES
Note
In the first example Vasya can move the second element to the end of the array.
In the second example no move can make the division possible.
In the third example Vasya can move the fourth element by one position to the left. | instruction | 0 | 93,177 | 12 | 186,354 |
Tags: binary search, data structures, implementation
Correct Solution:
```
def find(ar: list) -> bool:
p = [0]
s = sum(ar)
if s % 2 != 0:
return False
for elm in ar:
p.append(p[-1] + elm)
if p[-1] == (s >> 1):
return True
lk = set()
n = len(ar)
for i in range(1, n):
lk.add(ar[i - 1])
elm = -(s >> 1) + (p[i] + ar[i])
if elm in lk:
return True
return False
if __name__ == '__main__':
n = int(input())
ar = list(map(int, input().split()))
rar = ar[::-1]
if find(ar) or find(rar):
print("YES")
else:
print("NO")
``` | output | 1 | 93,177 | 12 | 186,355 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has an array a consisting of positive integer numbers. Vasya wants to divide this array into two non-empty consecutive parts (the prefix and the suffix) so that the sum of all elements in the first part equals to the sum of elements in the second part. It is not always possible, so Vasya will move some element before dividing the array (Vasya will erase some element and insert it into an arbitrary position).
Inserting an element in the same position he was erased from is also considered moving.
Can Vasya divide the array after choosing the right element to move and its new position?
Input
The first line contains single integer n (1 ≤ n ≤ 100000) — the size of the array.
The second line contains n integers a1, a2... an (1 ≤ ai ≤ 109) — the elements of the array.
Output
Print YES if Vasya can divide the array after moving one element. Otherwise print NO.
Examples
Input
3
1 3 2
Output
YES
Input
5
1 2 3 4 5
Output
NO
Input
5
2 2 3 4 5
Output
YES
Note
In the first example Vasya can move the second element to the end of the array.
In the second example no move can make the division possible.
In the third example Vasya can move the fourth element by one position to the left. | instruction | 0 | 93,178 | 12 | 186,356 |
Tags: binary search, data structures, implementation
Correct Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
#threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
#sys.setrecursionlimit(300000)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=300006, func=lambda a, b: min(a , b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b:a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] <=key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
class TrieNode:
def __init__(self):
self.children = [None] * 26
self.isEndOfWord = False
class Trie:
def __init__(self):
self.root = self.getNode()
def getNode(self):
return TrieNode()
def _charToIndex(self, ch):
return ord(ch) - ord('a')
def insert(self, key):
pCrawl = self.root
length = len(key)
for level in range(length):
index = self._charToIndex(key[level])
if not pCrawl.children[index]:
pCrawl.children[index] = self.getNode()
pCrawl = pCrawl.children[index]
pCrawl.isEndOfWord = True
def search(self, key):
pCrawl = self.root
length = len(key)
for level in range(length):
index = self._charToIndex(key[level])
if not pCrawl.children[index]:
return False
pCrawl = pCrawl.children[index]
return pCrawl != None and pCrawl.isEndOfWord
#-----------------------------------------trie---------------------------------
class Node:
def __init__(self, data):
self.data = data
self.count=0
self.left = None # left node for 0
self.right = None # right node for 1
class BinaryTrie:
def __init__(self):
self.root = Node(0)
def insert(self, pre_xor):
self.temp = self.root
for i in range(31, -1, -1):
val = pre_xor & (1 << i)
if val:
if not self.temp.right:
self.temp.right = Node(0)
self.temp = self.temp.right
self.temp.count+=1
if not val:
if not self.temp.left:
self.temp.left = Node(0)
self.temp = self.temp.left
self.temp.count += 1
self.temp.data = pre_xor
def query(self, xor):
self.temp = self.root
for i in range(31, -1, -1):
val = xor & (1 << i)
if not val:
if self.temp.left and self.temp.left.count>0:
self.temp = self.temp.left
elif self.temp.right:
self.temp = self.temp.right
else:
if self.temp.right and self.temp.right.count>0:
self.temp = self.temp.right
elif self.temp.left:
self.temp = self.temp.left
self.temp.count-=1
return xor ^ self.temp.data
#-------------------------bin trie-------------------------------------------
n=int(input())
l=list(map(int,input().split()))
su=sum(l)
if su%2!=0:
print("NO")
sys.exit(0)
su//=2
tr=0
done=set()
for i in range(n):
done.add(l[i])
tr+=l[i]
if tr-su in done:
print("YES")
sys.exit(0)
tr=0
done=set()
for i in range(n-1,-1,-1):
done.add(l[i])
tr+=l[i]
if tr-su in done:
print("YES")
sys.exit(0)
print("NO")
``` | output | 1 | 93,178 | 12 | 186,357 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has an array a consisting of positive integer numbers. Vasya wants to divide this array into two non-empty consecutive parts (the prefix and the suffix) so that the sum of all elements in the first part equals to the sum of elements in the second part. It is not always possible, so Vasya will move some element before dividing the array (Vasya will erase some element and insert it into an arbitrary position).
Inserting an element in the same position he was erased from is also considered moving.
Can Vasya divide the array after choosing the right element to move and its new position?
Input
The first line contains single integer n (1 ≤ n ≤ 100000) — the size of the array.
The second line contains n integers a1, a2... an (1 ≤ ai ≤ 109) — the elements of the array.
Output
Print YES if Vasya can divide the array after moving one element. Otherwise print NO.
Examples
Input
3
1 3 2
Output
YES
Input
5
1 2 3 4 5
Output
NO
Input
5
2 2 3 4 5
Output
YES
Note
In the first example Vasya can move the second element to the end of the array.
In the second example no move can make the division possible.
In the third example Vasya can move the fourth element by one position to the left. | instruction | 0 | 93,179 | 12 | 186,358 |
Tags: binary search, data structures, implementation
Correct Solution:
```
n=int(input())
l=[int(i) for i in input().split()]
tot=sum(l)
if tot&1:
print('NO')
exit()
#dont remove
sm=0
mid=tot//2
for i in l:
sm+=i
if sm==tot-sm:
print("YES")
exit()
#simulaate pref
from collections import defaultdict
def check(l):
d=defaultdict(int)
sm=0
for i in range(n-1):
d[l[i]]+=1
sm+=l[i]
add=l[i+1]
curr=sm+add
rem=tot-curr
#print(curr,rem)
if d[mid-rem]:
print('YES')
exit()
#d[l[i]]+=1
if check(l):
pass
l=l[::-1]
if check(l):
pass
print("NO")
``` | output | 1 | 93,179 | 12 | 186,359 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has an array a consisting of positive integer numbers. Vasya wants to divide this array into two non-empty consecutive parts (the prefix and the suffix) so that the sum of all elements in the first part equals to the sum of elements in the second part. It is not always possible, so Vasya will move some element before dividing the array (Vasya will erase some element and insert it into an arbitrary position).
Inserting an element in the same position he was erased from is also considered moving.
Can Vasya divide the array after choosing the right element to move and its new position?
Input
The first line contains single integer n (1 ≤ n ≤ 100000) — the size of the array.
The second line contains n integers a1, a2... an (1 ≤ ai ≤ 109) — the elements of the array.
Output
Print YES if Vasya can divide the array after moving one element. Otherwise print NO.
Examples
Input
3
1 3 2
Output
YES
Input
5
1 2 3 4 5
Output
NO
Input
5
2 2 3 4 5
Output
YES
Note
In the first example Vasya can move the second element to the end of the array.
In the second example no move can make the division possible.
In the third example Vasya can move the fourth element by one position to the left. | instruction | 0 | 93,180 | 12 | 186,360 |
Tags: binary search, data structures, implementation
Correct Solution:
```
import os,io
from sys import stdout
import collections
import random
import math
from operator import itemgetter
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
from collections import Counter
# import sys
# sys.setrecursionlimit(10**6)
def binomial_coefficient(n, k):
if 0 <= k <= n:
ntok = 1
ktok = 1
for t in range(1, min(k, n - k) + 1):
ntok *= n
ktok *= t
n -= 1
return ntok // ktok
else:
return 0
def powerOfK(k, max):
if k == 1:
return [1]
if k == -1:
return [-1, 1]
result = []
n = 1
while n <= max:
result.append(n)
n *= k
return result
def prefixSum(arr):
for i in range(1, len(arr)):
arr[i] = arr[i] + arr[i-1]
return arr
def divisors(n):
i = 1
result = []
while i*i <= n:
if n%i == 0:
if n/i == i:
result.append(i)
else:
result.append(i)
result.append(n/i)
i+=1
return result
# from functools import lru_cache
# @lru_cache(maxsize=None)
n = int(input())
l = list(map(int, input().split()))
rs = Counter(l)
ls = collections.defaultdict(int)
left = prefixSum(l[:])
right = prefixSum(l[::-1])[::-1]
found = False
for i in range(0, n):
#print(rs, ls, l[i])
rs[l[i]] -= 1
ls[l[i]] += 1
#print(left[i], right[i]-l[i])
if left[i] == right[i] - l[i]:
found = True
print("YES")
break
if left[i] > right[i] - l[i]:
diff = left[i] - (right[i] - l[i])
if diff % 2 != 0:
continue
if diff // 2 in ls and ls[diff//2] > 0:
found = True
print("YES")
break
else:
diff = (right[i] - l[i]) - left[i]
if diff % 2 != 0:
continue
if diff // 2 in rs and rs[diff//2] > 0:
found = True
print("YES")
break
if not found:
print("NO")
``` | output | 1 | 93,180 | 12 | 186,361 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has an array a consisting of positive integer numbers. Vasya wants to divide this array into two non-empty consecutive parts (the prefix and the suffix) so that the sum of all elements in the first part equals to the sum of elements in the second part. It is not always possible, so Vasya will move some element before dividing the array (Vasya will erase some element and insert it into an arbitrary position).
Inserting an element in the same position he was erased from is also considered moving.
Can Vasya divide the array after choosing the right element to move and its new position?
Input
The first line contains single integer n (1 ≤ n ≤ 100000) — the size of the array.
The second line contains n integers a1, a2... an (1 ≤ ai ≤ 109) — the elements of the array.
Output
Print YES if Vasya can divide the array after moving one element. Otherwise print NO.
Examples
Input
3
1 3 2
Output
YES
Input
5
1 2 3 4 5
Output
NO
Input
5
2 2 3 4 5
Output
YES
Note
In the first example Vasya can move the second element to the end of the array.
In the second example no move can make the division possible.
In the third example Vasya can move the fourth element by one position to the left. | instruction | 0 | 93,181 | 12 | 186,362 |
Tags: binary search, data structures, implementation
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
sum=[0]*n
sum[0]=a[0]
for i in range(1,n):
sum[i]=sum[i-1]+a[i]
s=sum[n-1]
found=0
if(s%2==0):
half=s//2
u=0
l=n-1
while(u<=l):
mid=(u+l)//2
if(sum[mid]==half):
print("YES")
exit()
elif(sum[mid]>half):
l=mid-1
else:
u=mid+1
for i in range(0,n):
u=i
l=n-1
if((2*a[i]+s)%2==0):
check=(s+2*a[i])//2
while(u<=l):
mid=(u+l)//2
if(sum[mid]==check):
found=1
break
elif(sum[mid]>check):
l=mid-1
else:
u=mid+1
if(found==1):
break
if(found==0 and n<10000):
for i in range(n-1,-1,-1):
u=0
l=i-1
if((s-2*a[i])%2==0 and (s-2*a[i])>0):
check=(s-2*a[i])//2
while(u<=l):
mid=(u+l)//2
if(sum[mid]==check):
found=1
break
elif(sum[mid]>check):
l=mid-1
else:
u=mid+1
if(found==1):
break
if(found==1):
print("YES")
else:
print("NO")
``` | output | 1 | 93,181 | 12 | 186,363 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has an array a consisting of positive integer numbers. Vasya wants to divide this array into two non-empty consecutive parts (the prefix and the suffix) so that the sum of all elements in the first part equals to the sum of elements in the second part. It is not always possible, so Vasya will move some element before dividing the array (Vasya will erase some element and insert it into an arbitrary position).
Inserting an element in the same position he was erased from is also considered moving.
Can Vasya divide the array after choosing the right element to move and its new position?
Input
The first line contains single integer n (1 ≤ n ≤ 100000) — the size of the array.
The second line contains n integers a1, a2... an (1 ≤ ai ≤ 109) — the elements of the array.
Output
Print YES if Vasya can divide the array after moving one element. Otherwise print NO.
Examples
Input
3
1 3 2
Output
YES
Input
5
1 2 3 4 5
Output
NO
Input
5
2 2 3 4 5
Output
YES
Note
In the first example Vasya can move the second element to the end of the array.
In the second example no move can make the division possible.
In the third example Vasya can move the fourth element by one position to the left. | instruction | 0 | 93,182 | 12 | 186,364 |
Tags: binary search, data structures, implementation
Correct Solution:
```
n = int(input())
arr = [int(x) for x in input().split()]
if n==1:
print("NO")
exit(0)
s = sum(arr)
sp = 0
ss = s
setq = {}
setp = {}
for i in arr:
setq[i] = setq.get(i,0)+1
setp[i] = 0
for i in range(n):
sp += arr[i]
ss -= arr[i]
setp[arr[i]] += 1
setq[arr[i]] -= 1
val = ss-sp
if val>0 and not val&1:
val //= 2
ans = setq.get(val,0)
if ans>0:
print("YES")
exit(0)
elif val<0 and not (-val)&1:
val = -val
val //= 2
ans = setp.get(val,0)
if ans>0:
print("YES")
exit(0)
elif val==0:
print("YES")
exit(0)
print("NO")
``` | output | 1 | 93,182 | 12 | 186,365 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has an array a consisting of positive integer numbers. Vasya wants to divide this array into two non-empty consecutive parts (the prefix and the suffix) so that the sum of all elements in the first part equals to the sum of elements in the second part. It is not always possible, so Vasya will move some element before dividing the array (Vasya will erase some element and insert it into an arbitrary position).
Inserting an element in the same position he was erased from is also considered moving.
Can Vasya divide the array after choosing the right element to move and its new position?
Input
The first line contains single integer n (1 ≤ n ≤ 100000) — the size of the array.
The second line contains n integers a1, a2... an (1 ≤ ai ≤ 109) — the elements of the array.
Output
Print YES if Vasya can divide the array after moving one element. Otherwise print NO.
Examples
Input
3
1 3 2
Output
YES
Input
5
1 2 3 4 5
Output
NO
Input
5
2 2 3 4 5
Output
YES
Note
In the first example Vasya can move the second element to the end of the array.
In the second example no move can make the division possible.
In the third example Vasya can move the fourth element by one position to the left. | instruction | 0 | 93,183 | 12 | 186,366 |
Tags: binary search, data structures, implementation
Correct Solution:
```
# |
# _` | __ \ _` | __| _ \ __ \ _` | _` |
# ( | | | ( | ( ( | | | ( | ( |
# \__,_| _| _| \__,_| \___| \___/ _| _| \__,_| \__,_|
import sys
def read_line():
return sys.stdin.readline()[:-1]
def read_int():
return int(sys.stdin.readline())
def read_int_line():
return [int(v) for v in sys.stdin.readline().split()]
n = read_int()
a = read_int_line()
d = {}
d[0] = -1
pref = [0]*(n+1)
for i in range(1,n+1):
pref[i]=pref[i-1]+a[i-1]
if a[i-1] not in d:
d[a[i-1]] = i-1
tot = pref[n]
req = tot//2
f = False
for i in range(1,n+1):
if pref[i]>=req:
if pref[i]-req in d:
if d[pref[i]-req] < i:
f = True
break
a = a[::-1]
d = {}
d[0] = -1
pref = [0]*(n+1)
for i in range(1,n+1):
pref[i]=pref[i-1]+a[i-1]
if a[i-1] not in d:
d[a[i-1]] = i-1
tot = pref[n]
req = tot//2
f1 = False
for i in range(1,n+1):
if pref[i]>=req:
if pref[i]-req in d:
if d[pref[i]-req] < i:
f1 = True
break
if (f or f1) and tot%2==0:
print("YES")
else:
print("NO")
``` | output | 1 | 93,183 | 12 | 186,367 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has an array a consisting of positive integer numbers. Vasya wants to divide this array into two non-empty consecutive parts (the prefix and the suffix) so that the sum of all elements in the first part equals to the sum of elements in the second part. It is not always possible, so Vasya will move some element before dividing the array (Vasya will erase some element and insert it into an arbitrary position).
Inserting an element in the same position he was erased from is also considered moving.
Can Vasya divide the array after choosing the right element to move and its new position?
Input
The first line contains single integer n (1 ≤ n ≤ 100000) — the size of the array.
The second line contains n integers a1, a2... an (1 ≤ ai ≤ 109) — the elements of the array.
Output
Print YES if Vasya can divide the array after moving one element. Otherwise print NO.
Examples
Input
3
1 3 2
Output
YES
Input
5
1 2 3 4 5
Output
NO
Input
5
2 2 3 4 5
Output
YES
Note
In the first example Vasya can move the second element to the end of the array.
In the second example no move can make the division possible.
In the third example Vasya can move the fourth element by one position to the left. | instruction | 0 | 93,184 | 12 | 186,368 |
Tags: binary search, data structures, implementation
Correct Solution:
```
n = int(input())
A = list(map(int,input().split()))
d = dict()
acc = 0
for i,j in enumerate(A):
acc += j
d[acc] = i
if acc % 2 == 1:
print("NO")
exit()
for i,j in enumerate(A):
v = acc // 2 - j
if v in d and d[v] < i:
print("YES")
exit()
v = acc / 2 + j
if v in d and d[v] >= i:
print("YES")
exit()
print("NO")
``` | output | 1 | 93,184 | 12 | 186,369 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has an array a consisting of positive integer numbers. Vasya wants to divide this array into two non-empty consecutive parts (the prefix and the suffix) so that the sum of all elements in the first part equals to the sum of elements in the second part. It is not always possible, so Vasya will move some element before dividing the array (Vasya will erase some element and insert it into an arbitrary position).
Inserting an element in the same position he was erased from is also considered moving.
Can Vasya divide the array after choosing the right element to move and its new position?
Input
The first line contains single integer n (1 ≤ n ≤ 100000) — the size of the array.
The second line contains n integers a1, a2... an (1 ≤ ai ≤ 109) — the elements of the array.
Output
Print YES if Vasya can divide the array after moving one element. Otherwise print NO.
Examples
Input
3
1 3 2
Output
YES
Input
5
1 2 3 4 5
Output
NO
Input
5
2 2 3 4 5
Output
YES
Note
In the first example Vasya can move the second element to the end of the array.
In the second example no move can make the division possible.
In the third example Vasya can move the fourth element by one position to the left.
Submitted Solution:
```
a = int(input())
nums = [int(i) for i in input().split()]
tot = sum(nums)
def runner(lpr):
total = 0
used = {}
for i in range(*lpr):
used[nums[i]] = 1
total += nums[i]
distance = 2 * total - tot
if distance % 2 == 0 and used.get(distance // 2, -1) != -1:
print("YES")
exit(0)
runner((0, a))
runner((a - 1, -1, -1))
print("NO")
``` | instruction | 0 | 93,185 | 12 | 186,370 |
Yes | output | 1 | 93,185 | 12 | 186,371 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has an array a consisting of positive integer numbers. Vasya wants to divide this array into two non-empty consecutive parts (the prefix and the suffix) so that the sum of all elements in the first part equals to the sum of elements in the second part. It is not always possible, so Vasya will move some element before dividing the array (Vasya will erase some element and insert it into an arbitrary position).
Inserting an element in the same position he was erased from is also considered moving.
Can Vasya divide the array after choosing the right element to move and its new position?
Input
The first line contains single integer n (1 ≤ n ≤ 100000) — the size of the array.
The second line contains n integers a1, a2... an (1 ≤ ai ≤ 109) — the elements of the array.
Output
Print YES if Vasya can divide the array after moving one element. Otherwise print NO.
Examples
Input
3
1 3 2
Output
YES
Input
5
1 2 3 4 5
Output
NO
Input
5
2 2 3 4 5
Output
YES
Note
In the first example Vasya can move the second element to the end of the array.
In the second example no move can make the division possible.
In the third example Vasya can move the fourth element by one position to the left.
Submitted Solution:
```
from itertools import *
n = int(input())
l = list(map(int, input().split()))
for j in range(0, 2):
m = {}
l = [0] + list(reversed(l))
for i in range(len(l)):
m[l[i]] = i
ac = list(accumulate(l))
s = ac[-1]
for i in range(0, len(ac)-1):
if ac[i] == s/2 or (s/2-ac[i] in m.keys() and m[s/2-ac[i]] > i):
print('YES')
quit()
print('NO')
``` | instruction | 0 | 93,186 | 12 | 186,372 |
Yes | output | 1 | 93,186 | 12 | 186,373 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has an array a consisting of positive integer numbers. Vasya wants to divide this array into two non-empty consecutive parts (the prefix and the suffix) so that the sum of all elements in the first part equals to the sum of elements in the second part. It is not always possible, so Vasya will move some element before dividing the array (Vasya will erase some element and insert it into an arbitrary position).
Inserting an element in the same position he was erased from is also considered moving.
Can Vasya divide the array after choosing the right element to move and its new position?
Input
The first line contains single integer n (1 ≤ n ≤ 100000) — the size of the array.
The second line contains n integers a1, a2... an (1 ≤ ai ≤ 109) — the elements of the array.
Output
Print YES if Vasya can divide the array after moving one element. Otherwise print NO.
Examples
Input
3
1 3 2
Output
YES
Input
5
1 2 3 4 5
Output
NO
Input
5
2 2 3 4 5
Output
YES
Note
In the first example Vasya can move the second element to the end of the array.
In the second example no move can make the division possible.
In the third example Vasya can move the fourth element by one position to the left.
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
e = set([0])
p = 0
s = sum(a)
if s % 2:
st = False
else:
st = True
if st:
st = False
for j in range(2):
for i in a:
p += i
e.add(i)
if p - s // 2 in e:
st = True
break
e = set([0])
p = 0
a.reverse()
print('YES' if st else 'NO')
``` | instruction | 0 | 93,187 | 12 | 186,374 |
Yes | output | 1 | 93,187 | 12 | 186,375 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has an array a consisting of positive integer numbers. Vasya wants to divide this array into two non-empty consecutive parts (the prefix and the suffix) so that the sum of all elements in the first part equals to the sum of elements in the second part. It is not always possible, so Vasya will move some element before dividing the array (Vasya will erase some element and insert it into an arbitrary position).
Inserting an element in the same position he was erased from is also considered moving.
Can Vasya divide the array after choosing the right element to move and its new position?
Input
The first line contains single integer n (1 ≤ n ≤ 100000) — the size of the array.
The second line contains n integers a1, a2... an (1 ≤ ai ≤ 109) — the elements of the array.
Output
Print YES if Vasya can divide the array after moving one element. Otherwise print NO.
Examples
Input
3
1 3 2
Output
YES
Input
5
1 2 3 4 5
Output
NO
Input
5
2 2 3 4 5
Output
YES
Note
In the first example Vasya can move the second element to the end of the array.
In the second example no move can make the division possible.
In the third example Vasya can move the fourth element by one position to the left.
Submitted Solution:
```
def func():
n = int(input())
array = []
sum = 0
for index,number in enumerate(input().split()):
num = int(number)
array.append(num)
sum += num
if sum%1 ==1:
print("NO")
return
setn = set()
sumSub = 0
indexdict = {}
for indexm,number in enumerate(array):
sumSub += number
sum2 = sumSub * 2 - sum
if sum2%2 == 1:
continue
sum2 /= 2
setn.add(sum2)
indexdict[sum2] = indexm
i = 0
if 0 in setn:
print("YES")
return
while i < n:
num = array[i]
if num in setn and num in indexdict and i < indexdict[num]:
print("YES")
return
if -num in setn and -num in indexdict and i > indexdict[-num]:
print("YES")
return
i+=1
print("NO")
func()
``` | instruction | 0 | 93,188 | 12 | 186,376 |
Yes | output | 1 | 93,188 | 12 | 186,377 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has an array a consisting of positive integer numbers. Vasya wants to divide this array into two non-empty consecutive parts (the prefix and the suffix) so that the sum of all elements in the first part equals to the sum of elements in the second part. It is not always possible, so Vasya will move some element before dividing the array (Vasya will erase some element and insert it into an arbitrary position).
Inserting an element in the same position he was erased from is also considered moving.
Can Vasya divide the array after choosing the right element to move and its new position?
Input
The first line contains single integer n (1 ≤ n ≤ 100000) — the size of the array.
The second line contains n integers a1, a2... an (1 ≤ ai ≤ 109) — the elements of the array.
Output
Print YES if Vasya can divide the array after moving one element. Otherwise print NO.
Examples
Input
3
1 3 2
Output
YES
Input
5
1 2 3 4 5
Output
NO
Input
5
2 2 3 4 5
Output
YES
Note
In the first example Vasya can move the second element to the end of the array.
In the second example no move can make the division possible.
In the third example Vasya can move the fourth element by one position to the left.
Submitted Solution:
```
def process(A):
d = {}
S = 0
for x in A:
if x not in d:
d[x] = 0
d[x]+=1
S+=x
if S % 2==1:
return 'NO'
S1 = 0
for x in A:
S1+=x
d[x]-=1
y = S//2-S1
if y==0:
return 'YES'
if y in d and d[y] > 0:
return 'YES'
return 'NO'
n = int(input())
A = [int(x) for x in input().split()]
print(process(A))
``` | instruction | 0 | 93,189 | 12 | 186,378 |
No | output | 1 | 93,189 | 12 | 186,379 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has an array a consisting of positive integer numbers. Vasya wants to divide this array into two non-empty consecutive parts (the prefix and the suffix) so that the sum of all elements in the first part equals to the sum of elements in the second part. It is not always possible, so Vasya will move some element before dividing the array (Vasya will erase some element and insert it into an arbitrary position).
Inserting an element in the same position he was erased from is also considered moving.
Can Vasya divide the array after choosing the right element to move and its new position?
Input
The first line contains single integer n (1 ≤ n ≤ 100000) — the size of the array.
The second line contains n integers a1, a2... an (1 ≤ ai ≤ 109) — the elements of the array.
Output
Print YES if Vasya can divide the array after moving one element. Otherwise print NO.
Examples
Input
3
1 3 2
Output
YES
Input
5
1 2 3 4 5
Output
NO
Input
5
2 2 3 4 5
Output
YES
Note
In the first example Vasya can move the second element to the end of the array.
In the second example no move can make the division possible.
In the third example Vasya can move the fourth element by one position to the left.
Submitted Solution:
```
def solve(a):
s = sum(a)
if s % 2 == 1:
return False
s //= 2
elements = set()
cs = 0
n = len(a)
for i in range(n):
cs += a[i]
if cs == s:
return True
elements.add(a[i])
if i > 0 and cs > s and cs - s in elements:
return True
return False
def main():
n = int(input())
a = list(map(int, input().split()))
if solve(a):
print("YES")
else:
print("NO")
if __name__ == '__main__':
main()
``` | instruction | 0 | 93,190 | 12 | 186,380 |
No | output | 1 | 93,190 | 12 | 186,381 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has an array a consisting of positive integer numbers. Vasya wants to divide this array into two non-empty consecutive parts (the prefix and the suffix) so that the sum of all elements in the first part equals to the sum of elements in the second part. It is not always possible, so Vasya will move some element before dividing the array (Vasya will erase some element and insert it into an arbitrary position).
Inserting an element in the same position he was erased from is also considered moving.
Can Vasya divide the array after choosing the right element to move and its new position?
Input
The first line contains single integer n (1 ≤ n ≤ 100000) — the size of the array.
The second line contains n integers a1, a2... an (1 ≤ ai ≤ 109) — the elements of the array.
Output
Print YES if Vasya can divide the array after moving one element. Otherwise print NO.
Examples
Input
3
1 3 2
Output
YES
Input
5
1 2 3 4 5
Output
NO
Input
5
2 2 3 4 5
Output
YES
Note
In the first example Vasya can move the second element to the end of the array.
In the second example no move can make the division possible.
In the third example Vasya can move the fourth element by one position to the left.
Submitted Solution:
```
def isthat(list1):
flag=False
for i in range(1,len(list1)):
if sum(list1[0:i])==sum(list1[i:]):
flag=True
return flag
n=int(input())
list1=list(map(int,input().strip().split(' ')))
flag=False
for i in range(n):
for j in range(n):
list2=list1[:]
t=list2[i]
list2[i]=list2[j]
list2[j]=t
if isthat(list2):
flag=True
break
if flag:
break
if flag:
print("YES")
else:
print("NO")
``` | instruction | 0 | 93,191 | 12 | 186,382 |
No | output | 1 | 93,191 | 12 | 186,383 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has an array a consisting of positive integer numbers. Vasya wants to divide this array into two non-empty consecutive parts (the prefix and the suffix) so that the sum of all elements in the first part equals to the sum of elements in the second part. It is not always possible, so Vasya will move some element before dividing the array (Vasya will erase some element and insert it into an arbitrary position).
Inserting an element in the same position he was erased from is also considered moving.
Can Vasya divide the array after choosing the right element to move and its new position?
Input
The first line contains single integer n (1 ≤ n ≤ 100000) — the size of the array.
The second line contains n integers a1, a2... an (1 ≤ ai ≤ 109) — the elements of the array.
Output
Print YES if Vasya can divide the array after moving one element. Otherwise print NO.
Examples
Input
3
1 3 2
Output
YES
Input
5
1 2 3 4 5
Output
NO
Input
5
2 2 3 4 5
Output
YES
Note
In the first example Vasya can move the second element to the end of the array.
In the second example no move can make the division possible.
In the third example Vasya can move the fourth element by one position to the left.
Submitted Solution:
```
n = int(input())
ls = input().split()
ls = list(map(int, ls))
psum = []
psum.append(ls[0])
ch = 0
for i in range(1, n):
psum.append(psum[i-1] + ls[i])
#print(len(psum), psum)
half = psum[n-1]//2
#print(half)
if psum[n-1] % 2 != 0:
print("No")
else:
for i in range(n-1):
temp = psum[i]
#print(temp)
if temp < half:
diff = half - temp
#print("inner %d" % ls[j])
if diff == ls[i+1]:
print(ls[i], diff)
print("Yes")
ch = 1
break
elif temp == half:
ch = 1
print("Yes")
break
if ch == 1:
break
if ch == 0:
print("No")
``` | instruction | 0 | 93,192 | 12 | 186,384 |
No | output | 1 | 93,192 | 12 | 186,385 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alicia has an array, a_1, a_2, …, a_n, of non-negative integers. For each 1 ≤ i ≤ n, she has found a non-negative integer x_i = max(0, a_1, …, a_{i-1}). Note that for i=1, x_i = 0.
For example, if Alicia had the array a = \{0, 1, 2, 0, 3\}, then x = \{0, 0, 1, 2, 2\}.
Then, she calculated an array, b_1, b_2, …, b_n: b_i = a_i - x_i.
For example, if Alicia had the array a = \{0, 1, 2, 0, 3\}, b = \{0-0, 1-0, 2-1, 0-2, 3-2\} = \{0, 1, 1, -2, 1\}.
Alicia gives you the values b_1, b_2, …, b_n and asks you to restore the values a_1, a_2, …, a_n. Can you help her solve the problem?
Input
The first line contains one integer n (3 ≤ n ≤ 200 000) – the number of elements in Alicia's array.
The next line contains n integers, b_1, b_2, …, b_n (-10^9 ≤ b_i ≤ 10^9).
It is guaranteed that for the given array b there is a solution a_1, a_2, …, a_n, for all elements of which the following is true: 0 ≤ a_i ≤ 10^9.
Output
Print n integers, a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9), such that if you calculate x according to the statement, b_1 will be equal to a_1 - x_1, b_2 will be equal to a_2 - x_2, ..., and b_n will be equal to a_n - x_n.
It is guaranteed that there exists at least one solution for the given tests. It can be shown that the solution is unique.
Examples
Input
5
0 1 1 -2 1
Output
0 1 2 0 3
Input
3
1000 999999000 -1000000000
Output
1000 1000000000 0
Input
5
2 1 2 2 3
Output
2 3 5 7 10
Note
The first test was described in the problem statement.
In the second test, if Alicia had an array a = \{1000, 1000000000, 0\}, then x = \{0, 1000, 1000000000\} and b = \{1000-0, 1000000000-1000, 0-1000000000\} = \{1000, 999999000, -1000000000\}. | instruction | 0 | 93,644 | 12 | 187,288 |
Tags: implementation, math
Correct Solution:
```
a = int(input())
a = list(map(int, input().split()))
x = max(a[0], 0 )
print(a[0], end=" ")
for i in range(1, len(a)):
print(x+a[i], end=" ")
x = max(x,x+a[i])
``` | output | 1 | 93,644 | 12 | 187,289 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alicia has an array, a_1, a_2, …, a_n, of non-negative integers. For each 1 ≤ i ≤ n, she has found a non-negative integer x_i = max(0, a_1, …, a_{i-1}). Note that for i=1, x_i = 0.
For example, if Alicia had the array a = \{0, 1, 2, 0, 3\}, then x = \{0, 0, 1, 2, 2\}.
Then, she calculated an array, b_1, b_2, …, b_n: b_i = a_i - x_i.
For example, if Alicia had the array a = \{0, 1, 2, 0, 3\}, b = \{0-0, 1-0, 2-1, 0-2, 3-2\} = \{0, 1, 1, -2, 1\}.
Alicia gives you the values b_1, b_2, …, b_n and asks you to restore the values a_1, a_2, …, a_n. Can you help her solve the problem?
Input
The first line contains one integer n (3 ≤ n ≤ 200 000) – the number of elements in Alicia's array.
The next line contains n integers, b_1, b_2, …, b_n (-10^9 ≤ b_i ≤ 10^9).
It is guaranteed that for the given array b there is a solution a_1, a_2, …, a_n, for all elements of which the following is true: 0 ≤ a_i ≤ 10^9.
Output
Print n integers, a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9), such that if you calculate x according to the statement, b_1 will be equal to a_1 - x_1, b_2 will be equal to a_2 - x_2, ..., and b_n will be equal to a_n - x_n.
It is guaranteed that there exists at least one solution for the given tests. It can be shown that the solution is unique.
Examples
Input
5
0 1 1 -2 1
Output
0 1 2 0 3
Input
3
1000 999999000 -1000000000
Output
1000 1000000000 0
Input
5
2 1 2 2 3
Output
2 3 5 7 10
Note
The first test was described in the problem statement.
In the second test, if Alicia had an array a = \{1000, 1000000000, 0\}, then x = \{0, 1000, 1000000000\} and b = \{1000-0, 1000000000-1000, 0-1000000000\} = \{1000, 999999000, -1000000000\}. | instruction | 0 | 93,645 | 12 | 187,290 |
Tags: implementation, math
Correct Solution:
```
import sys
from math import sqrt
inp = sys.stdin.readline
# arr = list(map(int, inp().split()))
def is_prime(n):
for i in range(2, int(sqrt(n))+1):
if n % i == 0:
return(False)
return(True)
def a():
ans = ""
for _ in range(int(inp())):
n = int(inp())
s = ""
if n == 1:
s = "-1"
else:
s = ("2"*(n-1) + "3")
ans += (s+"\n")
print(ans)
def b():
n = int(inp())
arr = list(map(int, inp().split()))
arr2 = [arr[0]]
maxi = arr[0]
for i in range(1, n):
arr2.append(maxi + arr[i])
maxi = max(maxi, arr2[i])
print(*arr2)
if __name__ == "__main__":
# a()
b()
# c()
``` | output | 1 | 93,645 | 12 | 187,291 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alicia has an array, a_1, a_2, …, a_n, of non-negative integers. For each 1 ≤ i ≤ n, she has found a non-negative integer x_i = max(0, a_1, …, a_{i-1}). Note that for i=1, x_i = 0.
For example, if Alicia had the array a = \{0, 1, 2, 0, 3\}, then x = \{0, 0, 1, 2, 2\}.
Then, she calculated an array, b_1, b_2, …, b_n: b_i = a_i - x_i.
For example, if Alicia had the array a = \{0, 1, 2, 0, 3\}, b = \{0-0, 1-0, 2-1, 0-2, 3-2\} = \{0, 1, 1, -2, 1\}.
Alicia gives you the values b_1, b_2, …, b_n and asks you to restore the values a_1, a_2, …, a_n. Can you help her solve the problem?
Input
The first line contains one integer n (3 ≤ n ≤ 200 000) – the number of elements in Alicia's array.
The next line contains n integers, b_1, b_2, …, b_n (-10^9 ≤ b_i ≤ 10^9).
It is guaranteed that for the given array b there is a solution a_1, a_2, …, a_n, for all elements of which the following is true: 0 ≤ a_i ≤ 10^9.
Output
Print n integers, a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9), such that if you calculate x according to the statement, b_1 will be equal to a_1 - x_1, b_2 will be equal to a_2 - x_2, ..., and b_n will be equal to a_n - x_n.
It is guaranteed that there exists at least one solution for the given tests. It can be shown that the solution is unique.
Examples
Input
5
0 1 1 -2 1
Output
0 1 2 0 3
Input
3
1000 999999000 -1000000000
Output
1000 1000000000 0
Input
5
2 1 2 2 3
Output
2 3 5 7 10
Note
The first test was described in the problem statement.
In the second test, if Alicia had an array a = \{1000, 1000000000, 0\}, then x = \{0, 1000, 1000000000\} and b = \{1000-0, 1000000000-1000, 0-1000000000\} = \{1000, 999999000, -1000000000\}. | instruction | 0 | 93,646 | 12 | 187,292 |
Tags: implementation, math
Correct Solution:
```
n=int(input())
l=[int(i) for i in input().split()]
m=0
for i in range(0,n):
k=l[i]+m
print(k,end=' ')
if m<k:
m=k
``` | output | 1 | 93,646 | 12 | 187,293 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alicia has an array, a_1, a_2, …, a_n, of non-negative integers. For each 1 ≤ i ≤ n, she has found a non-negative integer x_i = max(0, a_1, …, a_{i-1}). Note that for i=1, x_i = 0.
For example, if Alicia had the array a = \{0, 1, 2, 0, 3\}, then x = \{0, 0, 1, 2, 2\}.
Then, she calculated an array, b_1, b_2, …, b_n: b_i = a_i - x_i.
For example, if Alicia had the array a = \{0, 1, 2, 0, 3\}, b = \{0-0, 1-0, 2-1, 0-2, 3-2\} = \{0, 1, 1, -2, 1\}.
Alicia gives you the values b_1, b_2, …, b_n and asks you to restore the values a_1, a_2, …, a_n. Can you help her solve the problem?
Input
The first line contains one integer n (3 ≤ n ≤ 200 000) – the number of elements in Alicia's array.
The next line contains n integers, b_1, b_2, …, b_n (-10^9 ≤ b_i ≤ 10^9).
It is guaranteed that for the given array b there is a solution a_1, a_2, …, a_n, for all elements of which the following is true: 0 ≤ a_i ≤ 10^9.
Output
Print n integers, a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9), such that if you calculate x according to the statement, b_1 will be equal to a_1 - x_1, b_2 will be equal to a_2 - x_2, ..., and b_n will be equal to a_n - x_n.
It is guaranteed that there exists at least one solution for the given tests. It can be shown that the solution is unique.
Examples
Input
5
0 1 1 -2 1
Output
0 1 2 0 3
Input
3
1000 999999000 -1000000000
Output
1000 1000000000 0
Input
5
2 1 2 2 3
Output
2 3 5 7 10
Note
The first test was described in the problem statement.
In the second test, if Alicia had an array a = \{1000, 1000000000, 0\}, then x = \{0, 1000, 1000000000\} and b = \{1000-0, 1000000000-1000, 0-1000000000\} = \{1000, 999999000, -1000000000\}. | instruction | 0 | 93,647 | 12 | 187,294 |
Tags: implementation, math
Correct Solution:
```
n=int(input())
l1=[int(x) for x in input().split()]
l=[]
l.append(l1[0])
m=l[0]
for j in range(1,n):
if l1[j]>0:
m=m+l1[j]
l.append(m)
else:
l.append(m+l1[j])
print(*l)
``` | output | 1 | 93,647 | 12 | 187,295 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alicia has an array, a_1, a_2, …, a_n, of non-negative integers. For each 1 ≤ i ≤ n, she has found a non-negative integer x_i = max(0, a_1, …, a_{i-1}). Note that for i=1, x_i = 0.
For example, if Alicia had the array a = \{0, 1, 2, 0, 3\}, then x = \{0, 0, 1, 2, 2\}.
Then, she calculated an array, b_1, b_2, …, b_n: b_i = a_i - x_i.
For example, if Alicia had the array a = \{0, 1, 2, 0, 3\}, b = \{0-0, 1-0, 2-1, 0-2, 3-2\} = \{0, 1, 1, -2, 1\}.
Alicia gives you the values b_1, b_2, …, b_n and asks you to restore the values a_1, a_2, …, a_n. Can you help her solve the problem?
Input
The first line contains one integer n (3 ≤ n ≤ 200 000) – the number of elements in Alicia's array.
The next line contains n integers, b_1, b_2, …, b_n (-10^9 ≤ b_i ≤ 10^9).
It is guaranteed that for the given array b there is a solution a_1, a_2, …, a_n, for all elements of which the following is true: 0 ≤ a_i ≤ 10^9.
Output
Print n integers, a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9), such that if you calculate x according to the statement, b_1 will be equal to a_1 - x_1, b_2 will be equal to a_2 - x_2, ..., and b_n will be equal to a_n - x_n.
It is guaranteed that there exists at least one solution for the given tests. It can be shown that the solution is unique.
Examples
Input
5
0 1 1 -2 1
Output
0 1 2 0 3
Input
3
1000 999999000 -1000000000
Output
1000 1000000000 0
Input
5
2 1 2 2 3
Output
2 3 5 7 10
Note
The first test was described in the problem statement.
In the second test, if Alicia had an array a = \{1000, 1000000000, 0\}, then x = \{0, 1000, 1000000000\} and b = \{1000-0, 1000000000-1000, 0-1000000000\} = \{1000, 999999000, -1000000000\}. | instruction | 0 | 93,648 | 12 | 187,296 |
Tags: implementation, math
Correct Solution:
```
# your code goes here
n=int(input())
lst=list(map(int,input().split()))
sum1=0
a=[]
x=0
a.append(lst[0])
for i in range(1,n):
x=max(x,a[i-1])
a.append(lst[i]+x)
print(*a)
``` | output | 1 | 93,648 | 12 | 187,297 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alicia has an array, a_1, a_2, …, a_n, of non-negative integers. For each 1 ≤ i ≤ n, she has found a non-negative integer x_i = max(0, a_1, …, a_{i-1}). Note that for i=1, x_i = 0.
For example, if Alicia had the array a = \{0, 1, 2, 0, 3\}, then x = \{0, 0, 1, 2, 2\}.
Then, she calculated an array, b_1, b_2, …, b_n: b_i = a_i - x_i.
For example, if Alicia had the array a = \{0, 1, 2, 0, 3\}, b = \{0-0, 1-0, 2-1, 0-2, 3-2\} = \{0, 1, 1, -2, 1\}.
Alicia gives you the values b_1, b_2, …, b_n and asks you to restore the values a_1, a_2, …, a_n. Can you help her solve the problem?
Input
The first line contains one integer n (3 ≤ n ≤ 200 000) – the number of elements in Alicia's array.
The next line contains n integers, b_1, b_2, …, b_n (-10^9 ≤ b_i ≤ 10^9).
It is guaranteed that for the given array b there is a solution a_1, a_2, …, a_n, for all elements of which the following is true: 0 ≤ a_i ≤ 10^9.
Output
Print n integers, a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9), such that if you calculate x according to the statement, b_1 will be equal to a_1 - x_1, b_2 will be equal to a_2 - x_2, ..., and b_n will be equal to a_n - x_n.
It is guaranteed that there exists at least one solution for the given tests. It can be shown that the solution is unique.
Examples
Input
5
0 1 1 -2 1
Output
0 1 2 0 3
Input
3
1000 999999000 -1000000000
Output
1000 1000000000 0
Input
5
2 1 2 2 3
Output
2 3 5 7 10
Note
The first test was described in the problem statement.
In the second test, if Alicia had an array a = \{1000, 1000000000, 0\}, then x = \{0, 1000, 1000000000\} and b = \{1000-0, 1000000000-1000, 0-1000000000\} = \{1000, 999999000, -1000000000\}. | instruction | 0 | 93,649 | 12 | 187,298 |
Tags: implementation, math
Correct Solution:
```
n=int(input())
b=list(map(int,input().split()))
ans=[b[0]]
m=b[0]
for i in range(1,n):
ans.append(m+b[i])
m=max(m,ans[-1])
print (*ans)
``` | output | 1 | 93,649 | 12 | 187,299 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alicia has an array, a_1, a_2, …, a_n, of non-negative integers. For each 1 ≤ i ≤ n, she has found a non-negative integer x_i = max(0, a_1, …, a_{i-1}). Note that for i=1, x_i = 0.
For example, if Alicia had the array a = \{0, 1, 2, 0, 3\}, then x = \{0, 0, 1, 2, 2\}.
Then, she calculated an array, b_1, b_2, …, b_n: b_i = a_i - x_i.
For example, if Alicia had the array a = \{0, 1, 2, 0, 3\}, b = \{0-0, 1-0, 2-1, 0-2, 3-2\} = \{0, 1, 1, -2, 1\}.
Alicia gives you the values b_1, b_2, …, b_n and asks you to restore the values a_1, a_2, …, a_n. Can you help her solve the problem?
Input
The first line contains one integer n (3 ≤ n ≤ 200 000) – the number of elements in Alicia's array.
The next line contains n integers, b_1, b_2, …, b_n (-10^9 ≤ b_i ≤ 10^9).
It is guaranteed that for the given array b there is a solution a_1, a_2, …, a_n, for all elements of which the following is true: 0 ≤ a_i ≤ 10^9.
Output
Print n integers, a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9), such that if you calculate x according to the statement, b_1 will be equal to a_1 - x_1, b_2 will be equal to a_2 - x_2, ..., and b_n will be equal to a_n - x_n.
It is guaranteed that there exists at least one solution for the given tests. It can be shown that the solution is unique.
Examples
Input
5
0 1 1 -2 1
Output
0 1 2 0 3
Input
3
1000 999999000 -1000000000
Output
1000 1000000000 0
Input
5
2 1 2 2 3
Output
2 3 5 7 10
Note
The first test was described in the problem statement.
In the second test, if Alicia had an array a = \{1000, 1000000000, 0\}, then x = \{0, 1000, 1000000000\} and b = \{1000-0, 1000000000-1000, 0-1000000000\} = \{1000, 999999000, -1000000000\}. | instruction | 0 | 93,650 | 12 | 187,300 |
Tags: implementation, math
Correct Solution:
```
def solve():
n=input()
l=list(map(int,input().split()))
sum=0
sum2=l[0]
print(l[0],end=" ")
for i in range(1,len(l)):
sum=abs(sum2)+l[i]
print(sum,end=" ")
if(abs(sum)>sum2):
sum2=sum
print("")
solve()
``` | output | 1 | 93,650 | 12 | 187,301 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alicia has an array, a_1, a_2, …, a_n, of non-negative integers. For each 1 ≤ i ≤ n, she has found a non-negative integer x_i = max(0, a_1, …, a_{i-1}). Note that for i=1, x_i = 0.
For example, if Alicia had the array a = \{0, 1, 2, 0, 3\}, then x = \{0, 0, 1, 2, 2\}.
Then, she calculated an array, b_1, b_2, …, b_n: b_i = a_i - x_i.
For example, if Alicia had the array a = \{0, 1, 2, 0, 3\}, b = \{0-0, 1-0, 2-1, 0-2, 3-2\} = \{0, 1, 1, -2, 1\}.
Alicia gives you the values b_1, b_2, …, b_n and asks you to restore the values a_1, a_2, …, a_n. Can you help her solve the problem?
Input
The first line contains one integer n (3 ≤ n ≤ 200 000) – the number of elements in Alicia's array.
The next line contains n integers, b_1, b_2, …, b_n (-10^9 ≤ b_i ≤ 10^9).
It is guaranteed that for the given array b there is a solution a_1, a_2, …, a_n, for all elements of which the following is true: 0 ≤ a_i ≤ 10^9.
Output
Print n integers, a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9), such that if you calculate x according to the statement, b_1 will be equal to a_1 - x_1, b_2 will be equal to a_2 - x_2, ..., and b_n will be equal to a_n - x_n.
It is guaranteed that there exists at least one solution for the given tests. It can be shown that the solution is unique.
Examples
Input
5
0 1 1 -2 1
Output
0 1 2 0 3
Input
3
1000 999999000 -1000000000
Output
1000 1000000000 0
Input
5
2 1 2 2 3
Output
2 3 5 7 10
Note
The first test was described in the problem statement.
In the second test, if Alicia had an array a = \{1000, 1000000000, 0\}, then x = \{0, 1000, 1000000000\} and b = \{1000-0, 1000000000-1000, 0-1000000000\} = \{1000, 999999000, -1000000000\}. | instruction | 0 | 93,651 | 12 | 187,302 |
Tags: implementation, math
Correct Solution:
```
n = int(input())
b = list(map(int, input().split()))
x = [0]
a = []
a.append(x[0] + b[0])
x.append(max(x[0], a[0]))
a.append(x[1] + b[1])
for i in range(2, n):
x.append(max(x[i-1], a[i-1]))
a.append(x[i] + b[i])
print(*a)
``` | output | 1 | 93,651 | 12 | 187,303 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Victor adores the sets theory. Let us remind you that a set is a group of numbers where all numbers are pairwise distinct. Today Victor wants to find a set of integers S that has the following properties:
* for all x <image> the following inequality holds l ≤ x ≤ r;
* 1 ≤ |S| ≤ k;
* lets denote the i-th element of the set S as si; value <image> must be as small as possible.
Help Victor find the described set.
Input
The first line contains three space-separated integers l, r, k (1 ≤ l ≤ r ≤ 1012; 1 ≤ k ≤ min(106, r - l + 1)).
Output
Print the minimum possible value of f(S). Then print the cardinality of set |S|. Then print the elements of the set in any order.
If there are multiple optimal sets, you can print any of them.
Examples
Input
8 15 3
Output
1
2
10 11
Input
8 30 7
Output
0
5
14 9 28 11 16
Note
Operation <image> represents the operation of bitwise exclusive OR. In other words, it is the XOR operation. | instruction | 0 | 93,883 | 12 | 187,766 |
Tags: brute force, constructive algorithms, math
Correct Solution:
```
from itertools import combinations
from functools import reduce
def get_res(l, r, k):
if k == 1:
return [l]
if r == l:
return [l]
if r - l == 1:
if r ^ l < l:
return [r, l]
else:
return [l]
if k == 2:
return [l + (l % 2), l + 1 + (l % 2)]
moi = 2 ** (len(bin(l)) - 2)
if moi + moi // 2 <= r:
return [l, moi + moi // 2, l ^ (moi + moi // 2)]
if k == 3:
return [l + (l % 2), l + 1 + (l % 2)]
next4 = l + (4 - (l % 4)) % 4
if next4 + 3 <= r:
return [next4, next4 + 1, next4 + 2, next4 + 3]
tempres = l
tempans = [l]
for ll in range(2, k + 1):
for s in combinations(range(l, r + 1), ll):
rs = reduce(lambda x, y: x ^ y, s, 0)
if rs < tempres:
tempans = s
tempres = rs
return tempans
l, r, k = map(int, input().split())
res = get_res(l, r, k)
s = 0
for i in res:
s ^= i
print(s)
print(len(res))
print(*res)
``` | output | 1 | 93,883 | 12 | 187,767 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Victor adores the sets theory. Let us remind you that a set is a group of numbers where all numbers are pairwise distinct. Today Victor wants to find a set of integers S that has the following properties:
* for all x <image> the following inequality holds l ≤ x ≤ r;
* 1 ≤ |S| ≤ k;
* lets denote the i-th element of the set S as si; value <image> must be as small as possible.
Help Victor find the described set.
Input
The first line contains three space-separated integers l, r, k (1 ≤ l ≤ r ≤ 1012; 1 ≤ k ≤ min(106, r - l + 1)).
Output
Print the minimum possible value of f(S). Then print the cardinality of set |S|. Then print the elements of the set in any order.
If there are multiple optimal sets, you can print any of them.
Examples
Input
8 15 3
Output
1
2
10 11
Input
8 30 7
Output
0
5
14 9 28 11 16
Note
Operation <image> represents the operation of bitwise exclusive OR. In other words, it is the XOR operation. | instruction | 0 | 93,884 | 12 | 187,768 |
Tags: brute force, constructive algorithms, math
Correct Solution:
```
from itertools import combinations
from functools import reduce
from operator import xor
l, r, k = map(int, input().split())
def bruteforce(l, r, k):
rc = []
rv = float('inf')
for i in range(1, min(k, r - l + 1) + 1):
for c in combinations(range(l, r + 1), i):
v = reduce(xor, c)
if v < rv:
rc = c[:]
rv = v
return rv, rc
def large(l, r, k):
if l % 2 != 0:
l += 1
return 0, list(range(l, l + 4))
def one(l, r, k):
return l, [l]
def two(l, r, k):
if l % 2 != 0:
l += 1
return 1, list(range(l, l + 2))
def three(l, r, k):
#
# 10000101010111 == r
#
# x 01000000000000
# x 11000101010111 >= r
#
# o 00000111111111
# o 10000010101000 < r
#
lgr = 0
while (1 << lgr) <= r:
lgr += 1
lgr -= 1
if lgr < 0:
return two(l, r, k)
t = r ^ (1 << lgr)
lgr -= 1
while lgr >= 0 and not (t & (1 << lgr)):
lgr -= 1
if lgr < 0:
return two(l, r, k)
lgr += 1
if (1 << lgr) - 1 >= l:
x1 = r
x2 = (1 << lgr) - 1
x3 = x1 ^ x2
return 0, [x1, x2, x3]
else:
return two(l, r, k)
if r - l + 1 <= 4:
rv, rc = bruteforce(l, r, k)
elif k >= 4:
rv, rc = large(l, r, k)
elif k == 1:
rv, rc = one(l, r, k)
elif k == 2:
rv, rc = two(l, r, k)
elif k == 3:
rv, rc = three(l, r, k)
else:
assert False
print(rv)
print(len(rc))
print(*rc)
``` | output | 1 | 93,884 | 12 | 187,769 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Victor adores the sets theory. Let us remind you that a set is a group of numbers where all numbers are pairwise distinct. Today Victor wants to find a set of integers S that has the following properties:
* for all x <image> the following inequality holds l ≤ x ≤ r;
* 1 ≤ |S| ≤ k;
* lets denote the i-th element of the set S as si; value <image> must be as small as possible.
Help Victor find the described set.
Input
The first line contains three space-separated integers l, r, k (1 ≤ l ≤ r ≤ 1012; 1 ≤ k ≤ min(106, r - l + 1)).
Output
Print the minimum possible value of f(S). Then print the cardinality of set |S|. Then print the elements of the set in any order.
If there are multiple optimal sets, you can print any of them.
Examples
Input
8 15 3
Output
1
2
10 11
Input
8 30 7
Output
0
5
14 9 28 11 16
Note
Operation <image> represents the operation of bitwise exclusive OR. In other words, it is the XOR operation. | instruction | 0 | 93,887 | 12 | 187,774 |
Tags: brute force, constructive algorithms, math
Correct Solution:
```
from functools import reduce
xor = lambda x, y: x ^ y
l, r, k = map(int, input().split())
result = []
if r - l < 5:
result = [l]
l1 = [([], list(range(l, r + 1)))]
l2 = []
for i in range(1, k + 1):
for test, trash in l1:
for j, el in enumerate(trash):
l2.append((test + [el], trash[:j] + trash[j + 1:]))
for test, trash in l2:
if reduce(xor, test) < reduce(xor, result):
result = test
l1 = l2
l2 = []
else:
if k == 1:
result = [l]
elif k == 2:
x = l + l % 2
result = [x, x + 1]
elif k == 3:
i = 1
while 3 * 2 ** (i - 1) <= r:
if (2 ** i - 1 >= l):
result = [2 ** i - 1, 3 * 2 ** (i - 1) - 1, 3 * 2 ** (i - 1)]
break
i += 1
if not result:
x = l + l % 2
result = [x, x + 1]
else:
x = l + l % 2
result = [x, x + 1, x + 2, x + 3]
print(reduce(xor, result))
print(len(result))
print(" ".join(map(str, result)))
``` | output | 1 | 93,887 | 12 | 187,775 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Victor adores the sets theory. Let us remind you that a set is a group of numbers where all numbers are pairwise distinct. Today Victor wants to find a set of integers S that has the following properties:
* for all x <image> the following inequality holds l ≤ x ≤ r;
* 1 ≤ |S| ≤ k;
* lets denote the i-th element of the set S as si; value <image> must be as small as possible.
Help Victor find the described set.
Input
The first line contains three space-separated integers l, r, k (1 ≤ l ≤ r ≤ 1012; 1 ≤ k ≤ min(106, r - l + 1)).
Output
Print the minimum possible value of f(S). Then print the cardinality of set |S|. Then print the elements of the set in any order.
If there are multiple optimal sets, you can print any of them.
Examples
Input
8 15 3
Output
1
2
10 11
Input
8 30 7
Output
0
5
14 9 28 11 16
Note
Operation <image> represents the operation of bitwise exclusive OR. In other words, it is the XOR operation. | instruction | 0 | 93,888 | 12 | 187,776 |
Tags: brute force, constructive algorithms, math
Correct Solution:
```
#!/usr/bin/python3
import sys
import itertools
import functools
def brute_force(l, r, k):
best_set = None
best = None
for i in range(1, k+1):
for s in itertools.combinations(range(l, r+1), i):
p = functools.reduce(lambda x, y: x^y, s)
if (best is None) or p < best:
best = p
best_set = s
print(best)
print(len(best_set))
print(' '.join(str(x) for x in best_set))
if __name__ == '__main__':
l, r, k = map(int, sys.stdin.readline().split())
n = r - l + 1
if k > 4:
k = 4
# 1 <= k <= 4
if n < 7:
brute_force(l, r, k)
sys.exit(0)
if k == 1:
print(l)
print(1)
print(l)
sys.exit(0)
if k == 3:
w = len(bin(r)) - 2
# print(w)
for i in range(0, w-2+1):
a = int('1' + '0' * i + '1' + '0' * (w-2-i), 2)
b = int('1' + '0' * i + '0' + '1' * (w-2-i), 2)
c = int('0' + '0' * i + '1' + '1' * (w-2-i), 2)
# print('*', c, b, a)
if l <= c and a <= r:
print(0)
print(3)
print(c, b, a)
sys.exit(0)
if 2 <= k <= 3:
while l % 4 != 0:
l += 1
print(1)
print(2)
print(l, l+1)
sys.exit(0)
# k == 4
while l % 4 != 0:
l += 1
print(0)
print(4)
print(l, l+1, l+2, l+3)
``` | output | 1 | 93,888 | 12 | 187,777 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Victor adores the sets theory. Let us remind you that a set is a group of numbers where all numbers are pairwise distinct. Today Victor wants to find a set of integers S that has the following properties:
* for all x <image> the following inequality holds l ≤ x ≤ r;
* 1 ≤ |S| ≤ k;
* lets denote the i-th element of the set S as si; value <image> must be as small as possible.
Help Victor find the described set.
Input
The first line contains three space-separated integers l, r, k (1 ≤ l ≤ r ≤ 1012; 1 ≤ k ≤ min(106, r - l + 1)).
Output
Print the minimum possible value of f(S). Then print the cardinality of set |S|. Then print the elements of the set in any order.
If there are multiple optimal sets, you can print any of them.
Examples
Input
8 15 3
Output
1
2
10 11
Input
8 30 7
Output
0
5
14 9 28 11 16
Note
Operation <image> represents the operation of bitwise exclusive OR. In other words, it is the XOR operation. | instruction | 0 | 93,889 | 12 | 187,778 |
Tags: brute force, constructive algorithms, math
Correct Solution:
```
"""
Codeforces Contest 262 Div 2 Problem D
Author : chaotic_iak
Language: Python 3.3.4
"""
import functools, itertools
def main():
l,r,k = read()
tl = l + l%2
if tl+3 <= r and k >= 4:
print(0)
print(4)
print(tl, tl+1, tl+2, tl+3)
return
if k >= 3:
# 0111111 = 2^i * 2 - 1
# 1011111 = 2^i * 3 - 1
# 1100000 = 2^i * 3
# -> xored is 0
for i in range(0, 50): # log2(10**12) < 50
if l <= 2**i * 2 - 1 and 2**i * 3 <= r:
print(0)
print(3)
print(2**i * 2 - 1, 2**i * 3 - 1, 2**i * 3)
return
if tl+1 <= r and k >= 2:
print(1)
print(2)
print(tl, tl+1)
return
# now there are either at most 2 numbers, or k = 1
if k == 1 or l == r:
print(l)
print(1)
print(l)
return
# there are at most 2 numbers, bruteforce
if l^r < l:
print(l^r)
print(2)
print(l,r)
else:
print(l)
print(1)
print(l)
################################### NON-SOLUTION STUFF BELOW
def read(mode=2):
# 0: String
# 1: List of strings
# 2: List of integers
inputs = input().strip()
if mode == 0: return inputs
if mode == 1: return inputs.split()
if mode == 2: return list(map(int, inputs.split()))
def write(s="\n"):
if s is None: s = ""
if isinstance(s, list): s = " ".join(map(str, s))
s = str(s)
print(s, end="")
write(main())
``` | output | 1 | 93,889 | 12 | 187,779 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Victor adores the sets theory. Let us remind you that a set is a group of numbers where all numbers are pairwise distinct. Today Victor wants to find a set of integers S that has the following properties:
* for all x <image> the following inequality holds l ≤ x ≤ r;
* 1 ≤ |S| ≤ k;
* lets denote the i-th element of the set S as si; value <image> must be as small as possible.
Help Victor find the described set.
Input
The first line contains three space-separated integers l, r, k (1 ≤ l ≤ r ≤ 1012; 1 ≤ k ≤ min(106, r - l + 1)).
Output
Print the minimum possible value of f(S). Then print the cardinality of set |S|. Then print the elements of the set in any order.
If there are multiple optimal sets, you can print any of them.
Examples
Input
8 15 3
Output
1
2
10 11
Input
8 30 7
Output
0
5
14 9 28 11 16
Note
Operation <image> represents the operation of bitwise exclusive OR. In other words, it is the XOR operation. | instruction | 0 | 93,890 | 12 | 187,780 |
Tags: brute force, constructive algorithms, math
Correct Solution:
```
def main():
from itertools import combinations
from functools import reduce
from random import randrange
l, r, k = [int(i) for i in input().split()]
if r - l < 4:
f = float("inf")
result = None
numbers = list(range(l, r + 1))
for mask in range(1, 1 << (r - l + 1)):
tmp = [numbers[i] for i in range(r - l + 1) if mask & (1 << i)]
if len(tmp) <= k and reduce(lambda x, y: x ^ y, tmp) < f:
f = reduce(lambda x, y: x ^ y, tmp)
result = tmp
elif k >= 4:
a = l + l % 2
f = 0
result = [a, a + 1, a + 2, a + 3]
elif k == 1:
f = l
result = [l]
elif k == 2:
a = l + l % 2
f = 1
result = [a, a + 1]
elif k == 3:
a = l + l % 2
f = 1
result = [a, a + 1]
for a in range(l, min(r + 1, l + 400)):
for b in range(max(l, r - 400), r + 1):
if l <= a ^ b <= r:
f = 0
result = [a, b, a ^ b]
break
for i in range(100000):
a = randrange(l, r + 1)
b = randrange(l, r + 1)
if l <= a ^ b <= r:
f = 0
result = [a, b, a ^ b]
break
print(f)
print(len(result))
print(' '.join(str(i) for i in sorted(result)))
main()
``` | output | 1 | 93,890 | 12 | 187,781 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of positive integers a1, a2, ..., an.
While possible, you perform the following operation: find a pair of equal consecutive elements. If there are more than one such pair, find the leftmost (with the smallest indices of elements). If the two integers are equal to x, delete both and insert a single integer x + 1 on their place. This way the number of elements in the sequence is decreased by 1 on each step.
You stop performing the operation when there is no pair of equal consecutive elements.
For example, if the initial sequence is [5, 2, 1, 1, 2, 2], then after the first operation you get [5, 2, 2, 2, 2], after the second — [5, 3, 2, 2], after the third — [5, 3, 3], and finally after the fourth you get [5, 4]. After that there are no equal consecutive elements left in the sequence, so you stop the process.
Determine the final sequence after you stop performing the operation.
Input
The first line contains a single integer n (2 ≤ n ≤ 2·105) — the number of elements in the sequence.
The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
In the first line print a single integer k — the number of elements in the sequence after you stop performing the operation.
In the second line print k integers — the sequence after you stop performing the operation.
Examples
Input
6
5 2 1 1 2 2
Output
2
5 4
Input
4
1000000000 1000000000 1000000000 1000000000
Output
1
1000000002
Input
7
4 10 22 11 12 5 6
Output
7
4 10 22 11 12 5 6
Note
The first example is described in the statements.
In the second example the initial sequence is [1000000000, 1000000000, 1000000000, 1000000000]. After the first operation the sequence is equal to [1000000001, 1000000000, 1000000000]. After the second operation the sequence is [1000000001, 1000000001]. After the third operation the sequence is [1000000002].
In the third example there are no two equal consecutive elements initially, so the sequence does not change. | instruction | 0 | 94,107 | 12 | 188,214 |
Tags: constructive algorithms, data structures
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
i=0
b=[]
while i+1<n:
if a[i]==a[i+1]:
a[i+1]=a[i]+1
if len(b)>0:
a[i]=b.pop()
else:
i=i+1
else:
b.append(a[i])
i=i+1
b.append(a[-1])
print(len(b))
print(*b)
``` | output | 1 | 94,107 | 12 | 188,215 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of positive integers a1, a2, ..., an.
While possible, you perform the following operation: find a pair of equal consecutive elements. If there are more than one such pair, find the leftmost (with the smallest indices of elements). If the two integers are equal to x, delete both and insert a single integer x + 1 on their place. This way the number of elements in the sequence is decreased by 1 on each step.
You stop performing the operation when there is no pair of equal consecutive elements.
For example, if the initial sequence is [5, 2, 1, 1, 2, 2], then after the first operation you get [5, 2, 2, 2, 2], after the second — [5, 3, 2, 2], after the third — [5, 3, 3], and finally after the fourth you get [5, 4]. After that there are no equal consecutive elements left in the sequence, so you stop the process.
Determine the final sequence after you stop performing the operation.
Input
The first line contains a single integer n (2 ≤ n ≤ 2·105) — the number of elements in the sequence.
The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
In the first line print a single integer k — the number of elements in the sequence after you stop performing the operation.
In the second line print k integers — the sequence after you stop performing the operation.
Examples
Input
6
5 2 1 1 2 2
Output
2
5 4
Input
4
1000000000 1000000000 1000000000 1000000000
Output
1
1000000002
Input
7
4 10 22 11 12 5 6
Output
7
4 10 22 11 12 5 6
Note
The first example is described in the statements.
In the second example the initial sequence is [1000000000, 1000000000, 1000000000, 1000000000]. After the first operation the sequence is equal to [1000000001, 1000000000, 1000000000]. After the second operation the sequence is [1000000001, 1000000001]. After the third operation the sequence is [1000000002].
In the third example there are no two equal consecutive elements initially, so the sequence does not change. | instruction | 0 | 94,108 | 12 | 188,216 |
Tags: constructive algorithms, data structures
Correct Solution:
```
stk = []
n = input()
n = int(n)
lst = input()
lst = lst.split()
for a in lst:
stk.append(int(a))
while len(stk) > 1:
if stk[-1] == stk[-2]:
b = stk[-1]
stk.pop()
stk.pop()
stk.append(b + 1)
else:
break
print(len(stk))
for a in stk:
print(a , end=" ")
``` | output | 1 | 94,108 | 12 | 188,217 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of positive integers a1, a2, ..., an.
While possible, you perform the following operation: find a pair of equal consecutive elements. If there are more than one such pair, find the leftmost (with the smallest indices of elements). If the two integers are equal to x, delete both and insert a single integer x + 1 on their place. This way the number of elements in the sequence is decreased by 1 on each step.
You stop performing the operation when there is no pair of equal consecutive elements.
For example, if the initial sequence is [5, 2, 1, 1, 2, 2], then after the first operation you get [5, 2, 2, 2, 2], after the second — [5, 3, 2, 2], after the third — [5, 3, 3], and finally after the fourth you get [5, 4]. After that there are no equal consecutive elements left in the sequence, so you stop the process.
Determine the final sequence after you stop performing the operation.
Input
The first line contains a single integer n (2 ≤ n ≤ 2·105) — the number of elements in the sequence.
The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
In the first line print a single integer k — the number of elements in the sequence after you stop performing the operation.
In the second line print k integers — the sequence after you stop performing the operation.
Examples
Input
6
5 2 1 1 2 2
Output
2
5 4
Input
4
1000000000 1000000000 1000000000 1000000000
Output
1
1000000002
Input
7
4 10 22 11 12 5 6
Output
7
4 10 22 11 12 5 6
Note
The first example is described in the statements.
In the second example the initial sequence is [1000000000, 1000000000, 1000000000, 1000000000]. After the first operation the sequence is equal to [1000000001, 1000000000, 1000000000]. After the second operation the sequence is [1000000001, 1000000001]. After the third operation the sequence is [1000000002].
In the third example there are no two equal consecutive elements initially, so the sequence does not change. | instruction | 0 | 94,109 | 12 | 188,218 |
Tags: constructive algorithms, data structures
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
arr = [0 for i in range(n)]
m = 0
for i in range(n):
x = a[i]
while m > 0 and arr[m - 1] == x:
arr[m - 1] = 0
x += 1
m -= 1
arr[m] = x
m += 1
print(m)
print(*arr[:m])
``` | output | 1 | 94,109 | 12 | 188,219 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of positive integers a1, a2, ..., an.
While possible, you perform the following operation: find a pair of equal consecutive elements. If there are more than one such pair, find the leftmost (with the smallest indices of elements). If the two integers are equal to x, delete both and insert a single integer x + 1 on their place. This way the number of elements in the sequence is decreased by 1 on each step.
You stop performing the operation when there is no pair of equal consecutive elements.
For example, if the initial sequence is [5, 2, 1, 1, 2, 2], then after the first operation you get [5, 2, 2, 2, 2], after the second — [5, 3, 2, 2], after the third — [5, 3, 3], and finally after the fourth you get [5, 4]. After that there are no equal consecutive elements left in the sequence, so you stop the process.
Determine the final sequence after you stop performing the operation.
Input
The first line contains a single integer n (2 ≤ n ≤ 2·105) — the number of elements in the sequence.
The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
In the first line print a single integer k — the number of elements in the sequence after you stop performing the operation.
In the second line print k integers — the sequence after you stop performing the operation.
Examples
Input
6
5 2 1 1 2 2
Output
2
5 4
Input
4
1000000000 1000000000 1000000000 1000000000
Output
1
1000000002
Input
7
4 10 22 11 12 5 6
Output
7
4 10 22 11 12 5 6
Note
The first example is described in the statements.
In the second example the initial sequence is [1000000000, 1000000000, 1000000000, 1000000000]. After the first operation the sequence is equal to [1000000001, 1000000000, 1000000000]. After the second operation the sequence is [1000000001, 1000000001]. After the third operation the sequence is [1000000002].
In the third example there are no two equal consecutive elements initially, so the sequence does not change. | instruction | 0 | 94,110 | 12 | 188,220 |
Tags: constructive algorithms, data structures
Correct Solution:
```
import sys
from math import *
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return map(int, minp().split())
n = mint()
a = []
for i in mints():
if len(a) > 0 and a[-1] == i:
a[-1] += 1
while len(a) > 1 and a[-2] == a[-1]:
a.pop()
a[-1] += 1
else:
a.append(i)
print(len(a))
print(*a)
``` | output | 1 | 94,110 | 12 | 188,221 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of positive integers a1, a2, ..., an.
While possible, you perform the following operation: find a pair of equal consecutive elements. If there are more than one such pair, find the leftmost (with the smallest indices of elements). If the two integers are equal to x, delete both and insert a single integer x + 1 on their place. This way the number of elements in the sequence is decreased by 1 on each step.
You stop performing the operation when there is no pair of equal consecutive elements.
For example, if the initial sequence is [5, 2, 1, 1, 2, 2], then after the first operation you get [5, 2, 2, 2, 2], after the second — [5, 3, 2, 2], after the third — [5, 3, 3], and finally after the fourth you get [5, 4]. After that there are no equal consecutive elements left in the sequence, so you stop the process.
Determine the final sequence after you stop performing the operation.
Input
The first line contains a single integer n (2 ≤ n ≤ 2·105) — the number of elements in the sequence.
The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
In the first line print a single integer k — the number of elements in the sequence after you stop performing the operation.
In the second line print k integers — the sequence after you stop performing the operation.
Examples
Input
6
5 2 1 1 2 2
Output
2
5 4
Input
4
1000000000 1000000000 1000000000 1000000000
Output
1
1000000002
Input
7
4 10 22 11 12 5 6
Output
7
4 10 22 11 12 5 6
Note
The first example is described in the statements.
In the second example the initial sequence is [1000000000, 1000000000, 1000000000, 1000000000]. After the first operation the sequence is equal to [1000000001, 1000000000, 1000000000]. After the second operation the sequence is [1000000001, 1000000001]. After the third operation the sequence is [1000000002].
In the third example there are no two equal consecutive elements initially, so the sequence does not change. | instruction | 0 | 94,111 | 12 | 188,222 |
Tags: constructive algorithms, data structures
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
b = [0] * n
b[0] = a[0]
j = 1
for i in range(1, n):
b[j] = a[i]
while j > 0 and b[j] == b[j - 1]:
j -= 1
b[j] += 1
j += 1
print(j)
for i in range(j):
print(b[i], end=' ')
``` | output | 1 | 94,111 | 12 | 188,223 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of positive integers a1, a2, ..., an.
While possible, you perform the following operation: find a pair of equal consecutive elements. If there are more than one such pair, find the leftmost (with the smallest indices of elements). If the two integers are equal to x, delete both and insert a single integer x + 1 on their place. This way the number of elements in the sequence is decreased by 1 on each step.
You stop performing the operation when there is no pair of equal consecutive elements.
For example, if the initial sequence is [5, 2, 1, 1, 2, 2], then after the first operation you get [5, 2, 2, 2, 2], after the second — [5, 3, 2, 2], after the third — [5, 3, 3], and finally after the fourth you get [5, 4]. After that there are no equal consecutive elements left in the sequence, so you stop the process.
Determine the final sequence after you stop performing the operation.
Input
The first line contains a single integer n (2 ≤ n ≤ 2·105) — the number of elements in the sequence.
The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
In the first line print a single integer k — the number of elements in the sequence after you stop performing the operation.
In the second line print k integers — the sequence after you stop performing the operation.
Examples
Input
6
5 2 1 1 2 2
Output
2
5 4
Input
4
1000000000 1000000000 1000000000 1000000000
Output
1
1000000002
Input
7
4 10 22 11 12 5 6
Output
7
4 10 22 11 12 5 6
Note
The first example is described in the statements.
In the second example the initial sequence is [1000000000, 1000000000, 1000000000, 1000000000]. After the first operation the sequence is equal to [1000000001, 1000000000, 1000000000]. After the second operation the sequence is [1000000001, 1000000001]. After the third operation the sequence is [1000000002].
In the third example there are no two equal consecutive elements initially, so the sequence does not change. | instruction | 0 | 94,112 | 12 | 188,224 |
Tags: constructive algorithms, data structures
Correct Solution:
```
n = int(input())
ls = input().split()
st = []
for i in range(n):
x = int(ls[i])
while len(st) > 0 and x == st[-1]:
x += 1
st.pop()
st.append(x)
print(len(st))
for x in st:
print("{} ".format(x), end="")
``` | output | 1 | 94,112 | 12 | 188,225 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of positive integers a1, a2, ..., an.
While possible, you perform the following operation: find a pair of equal consecutive elements. If there are more than one such pair, find the leftmost (with the smallest indices of elements). If the two integers are equal to x, delete both and insert a single integer x + 1 on their place. This way the number of elements in the sequence is decreased by 1 on each step.
You stop performing the operation when there is no pair of equal consecutive elements.
For example, if the initial sequence is [5, 2, 1, 1, 2, 2], then after the first operation you get [5, 2, 2, 2, 2], after the second — [5, 3, 2, 2], after the third — [5, 3, 3], and finally after the fourth you get [5, 4]. After that there are no equal consecutive elements left in the sequence, so you stop the process.
Determine the final sequence after you stop performing the operation.
Input
The first line contains a single integer n (2 ≤ n ≤ 2·105) — the number of elements in the sequence.
The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
In the first line print a single integer k — the number of elements in the sequence after you stop performing the operation.
In the second line print k integers — the sequence after you stop performing the operation.
Examples
Input
6
5 2 1 1 2 2
Output
2
5 4
Input
4
1000000000 1000000000 1000000000 1000000000
Output
1
1000000002
Input
7
4 10 22 11 12 5 6
Output
7
4 10 22 11 12 5 6
Note
The first example is described in the statements.
In the second example the initial sequence is [1000000000, 1000000000, 1000000000, 1000000000]. After the first operation the sequence is equal to [1000000001, 1000000000, 1000000000]. After the second operation the sequence is [1000000001, 1000000001]. After the third operation the sequence is [1000000002].
In the third example there are no two equal consecutive elements initially, so the sequence does not change. | instruction | 0 | 94,113 | 12 | 188,226 |
Tags: constructive algorithms, data structures
Correct Solution:
```
n, m = int(input()), 0
b = [int(t) for t in input().split()]
a = []
for i in range(n):
a.append(b[i])
while len(a) > 1 and a[-2] == a[-1]:
del a[-1]
a[-1] += 1
print(len(a))
print(" ".join([str(t) for t in a]))
``` | output | 1 | 94,113 | 12 | 188,227 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of positive integers a1, a2, ..., an.
While possible, you perform the following operation: find a pair of equal consecutive elements. If there are more than one such pair, find the leftmost (with the smallest indices of elements). If the two integers are equal to x, delete both and insert a single integer x + 1 on their place. This way the number of elements in the sequence is decreased by 1 on each step.
You stop performing the operation when there is no pair of equal consecutive elements.
For example, if the initial sequence is [5, 2, 1, 1, 2, 2], then after the first operation you get [5, 2, 2, 2, 2], after the second — [5, 3, 2, 2], after the third — [5, 3, 3], and finally after the fourth you get [5, 4]. After that there are no equal consecutive elements left in the sequence, so you stop the process.
Determine the final sequence after you stop performing the operation.
Input
The first line contains a single integer n (2 ≤ n ≤ 2·105) — the number of elements in the sequence.
The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
In the first line print a single integer k — the number of elements in the sequence after you stop performing the operation.
In the second line print k integers — the sequence after you stop performing the operation.
Examples
Input
6
5 2 1 1 2 2
Output
2
5 4
Input
4
1000000000 1000000000 1000000000 1000000000
Output
1
1000000002
Input
7
4 10 22 11 12 5 6
Output
7
4 10 22 11 12 5 6
Note
The first example is described in the statements.
In the second example the initial sequence is [1000000000, 1000000000, 1000000000, 1000000000]. After the first operation the sequence is equal to [1000000001, 1000000000, 1000000000]. After the second operation the sequence is [1000000001, 1000000001]. After the third operation the sequence is [1000000002].
In the third example there are no two equal consecutive elements initially, so the sequence does not change. | instruction | 0 | 94,114 | 12 | 188,228 |
Tags: constructive algorithms, data structures
Correct Solution:
```
# https://codeforces.com/problemset/problem/926/E
input()
stack1 = [int(i) for i in input().split()]
stack1.reverse()
stack2 = []
while stack1:
transfer = stack1.pop()
while stack2 and stack2[-1] == transfer:
stack2.pop()
transfer += 1
stack2.append(transfer)
print(len(stack2))
print(" ".join([str(i) for i in stack2]))
``` | output | 1 | 94,114 | 12 | 188,229 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence of positive integers a1, a2, ..., an.
While possible, you perform the following operation: find a pair of equal consecutive elements. If there are more than one such pair, find the leftmost (with the smallest indices of elements). If the two integers are equal to x, delete both and insert a single integer x + 1 on their place. This way the number of elements in the sequence is decreased by 1 on each step.
You stop performing the operation when there is no pair of equal consecutive elements.
For example, if the initial sequence is [5, 2, 1, 1, 2, 2], then after the first operation you get [5, 2, 2, 2, 2], after the second — [5, 3, 2, 2], after the third — [5, 3, 3], and finally after the fourth you get [5, 4]. After that there are no equal consecutive elements left in the sequence, so you stop the process.
Determine the final sequence after you stop performing the operation.
Input
The first line contains a single integer n (2 ≤ n ≤ 2·105) — the number of elements in the sequence.
The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
In the first line print a single integer k — the number of elements in the sequence after you stop performing the operation.
In the second line print k integers — the sequence after you stop performing the operation.
Examples
Input
6
5 2 1 1 2 2
Output
2
5 4
Input
4
1000000000 1000000000 1000000000 1000000000
Output
1
1000000002
Input
7
4 10 22 11 12 5 6
Output
7
4 10 22 11 12 5 6
Note
The first example is described in the statements.
In the second example the initial sequence is [1000000000, 1000000000, 1000000000, 1000000000]. After the first operation the sequence is equal to [1000000001, 1000000000, 1000000000]. After the second operation the sequence is [1000000001, 1000000001]. After the third operation the sequence is [1000000002].
In the third example there are no two equal consecutive elements initially, so the sequence does not change.
Submitted Solution:
```
n = int(input())
a = [int(x) for x in input().split()]
stack = []
i = 0
x = a[i]
while True:
if len(stack) == 0:
stack.append(x)
i += 1
if i == n:
break
x = a[i]
else:
if x == stack[-1]:
del stack[-1]
x += 1
else:
stack.append(x)
i += 1
if i == n:
break
x = a[i]
print(len(stack))
print(" ".join([str(x) for x in stack]))
``` | instruction | 0 | 94,115 | 12 | 188,230 |
Yes | output | 1 | 94,115 | 12 | 188,231 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence of positive integers a1, a2, ..., an.
While possible, you perform the following operation: find a pair of equal consecutive elements. If there are more than one such pair, find the leftmost (with the smallest indices of elements). If the two integers are equal to x, delete both and insert a single integer x + 1 on their place. This way the number of elements in the sequence is decreased by 1 on each step.
You stop performing the operation when there is no pair of equal consecutive elements.
For example, if the initial sequence is [5, 2, 1, 1, 2, 2], then after the first operation you get [5, 2, 2, 2, 2], after the second — [5, 3, 2, 2], after the third — [5, 3, 3], and finally after the fourth you get [5, 4]. After that there are no equal consecutive elements left in the sequence, so you stop the process.
Determine the final sequence after you stop performing the operation.
Input
The first line contains a single integer n (2 ≤ n ≤ 2·105) — the number of elements in the sequence.
The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
In the first line print a single integer k — the number of elements in the sequence after you stop performing the operation.
In the second line print k integers — the sequence after you stop performing the operation.
Examples
Input
6
5 2 1 1 2 2
Output
2
5 4
Input
4
1000000000 1000000000 1000000000 1000000000
Output
1
1000000002
Input
7
4 10 22 11 12 5 6
Output
7
4 10 22 11 12 5 6
Note
The first example is described in the statements.
In the second example the initial sequence is [1000000000, 1000000000, 1000000000, 1000000000]. After the first operation the sequence is equal to [1000000001, 1000000000, 1000000000]. After the second operation the sequence is [1000000001, 1000000001]. After the third operation the sequence is [1000000002].
In the third example there are no two equal consecutive elements initially, so the sequence does not change.
Submitted Solution:
```
n=int(input())
x=[int(i) for i in input().split()]
otv=[]
i=0
while i<n:
if len(otv)<2:
otv.append(x[i])
i+=1
continue
if otv[len(otv)-1]==otv[len(otv)-2]:
otv.pop()
otv[len(otv)-1]+=1
else:
otv.append(x[i])
i+=1
while len(otv)>=2 and otv[len(otv)-1]==otv[len(otv)-2]:
otv.pop()
otv[len(otv)-1]+=1
print(len(otv))
for i in otv:
print(i,end=" ")
``` | instruction | 0 | 94,116 | 12 | 188,232 |
Yes | output | 1 | 94,116 | 12 | 188,233 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence of positive integers a1, a2, ..., an.
While possible, you perform the following operation: find a pair of equal consecutive elements. If there are more than one such pair, find the leftmost (with the smallest indices of elements). If the two integers are equal to x, delete both and insert a single integer x + 1 on their place. This way the number of elements in the sequence is decreased by 1 on each step.
You stop performing the operation when there is no pair of equal consecutive elements.
For example, if the initial sequence is [5, 2, 1, 1, 2, 2], then after the first operation you get [5, 2, 2, 2, 2], after the second — [5, 3, 2, 2], after the third — [5, 3, 3], and finally after the fourth you get [5, 4]. After that there are no equal consecutive elements left in the sequence, so you stop the process.
Determine the final sequence after you stop performing the operation.
Input
The first line contains a single integer n (2 ≤ n ≤ 2·105) — the number of elements in the sequence.
The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
In the first line print a single integer k — the number of elements in the sequence after you stop performing the operation.
In the second line print k integers — the sequence after you stop performing the operation.
Examples
Input
6
5 2 1 1 2 2
Output
2
5 4
Input
4
1000000000 1000000000 1000000000 1000000000
Output
1
1000000002
Input
7
4 10 22 11 12 5 6
Output
7
4 10 22 11 12 5 6
Note
The first example is described in the statements.
In the second example the initial sequence is [1000000000, 1000000000, 1000000000, 1000000000]. After the first operation the sequence is equal to [1000000001, 1000000000, 1000000000]. After the second operation the sequence is [1000000001, 1000000001]. After the third operation the sequence is [1000000002].
In the third example there are no two equal consecutive elements initially, so the sequence does not change.
Submitted Solution:
```
n, m = int(input()), 0
b = [int(t) for t in input().split()]
a = []
for i in range(n):
a.append(b[i])
while len(a) > 1 and a[-2] == a[-1]:
del a[-1]
a[-1] *= 2
print(len(a))
print(" ".join([str(t) for t in a]))
``` | instruction | 0 | 94,117 | 12 | 188,234 |
No | output | 1 | 94,117 | 12 | 188,235 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence of positive integers a1, a2, ..., an.
While possible, you perform the following operation: find a pair of equal consecutive elements. If there are more than one such pair, find the leftmost (with the smallest indices of elements). If the two integers are equal to x, delete both and insert a single integer x + 1 on their place. This way the number of elements in the sequence is decreased by 1 on each step.
You stop performing the operation when there is no pair of equal consecutive elements.
For example, if the initial sequence is [5, 2, 1, 1, 2, 2], then after the first operation you get [5, 2, 2, 2, 2], after the second — [5, 3, 2, 2], after the third — [5, 3, 3], and finally after the fourth you get [5, 4]. After that there are no equal consecutive elements left in the sequence, so you stop the process.
Determine the final sequence after you stop performing the operation.
Input
The first line contains a single integer n (2 ≤ n ≤ 2·105) — the number of elements in the sequence.
The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
In the first line print a single integer k — the number of elements in the sequence after you stop performing the operation.
In the second line print k integers — the sequence after you stop performing the operation.
Examples
Input
6
5 2 1 1 2 2
Output
2
5 4
Input
4
1000000000 1000000000 1000000000 1000000000
Output
1
1000000002
Input
7
4 10 22 11 12 5 6
Output
7
4 10 22 11 12 5 6
Note
The first example is described in the statements.
In the second example the initial sequence is [1000000000, 1000000000, 1000000000, 1000000000]. After the first operation the sequence is equal to [1000000001, 1000000000, 1000000000]. After the second operation the sequence is [1000000001, 1000000001]. After the third operation the sequence is [1000000002].
In the third example there are no two equal consecutive elements initially, so the sequence does not change.
Submitted Solution:
```
n=int(input())
a=list(map(int,input().split()))
b,s,l=[],0,len(a)+1
while s<l:
for i in range(0,len(a)-1):
if a[i]==a[i+1]:
a[i]=a[i]+1
del a[i+1]
s=s+1
break
s=s+1
print(a)
print(len(a))
for i in a:
print(i,end=' ')
``` | instruction | 0 | 94,118 | 12 | 188,236 |
No | output | 1 | 94,118 | 12 | 188,237 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence of positive integers a1, a2, ..., an.
While possible, you perform the following operation: find a pair of equal consecutive elements. If there are more than one such pair, find the leftmost (with the smallest indices of elements). If the two integers are equal to x, delete both and insert a single integer x + 1 on their place. This way the number of elements in the sequence is decreased by 1 on each step.
You stop performing the operation when there is no pair of equal consecutive elements.
For example, if the initial sequence is [5, 2, 1, 1, 2, 2], then after the first operation you get [5, 2, 2, 2, 2], after the second — [5, 3, 2, 2], after the third — [5, 3, 3], and finally after the fourth you get [5, 4]. After that there are no equal consecutive elements left in the sequence, so you stop the process.
Determine the final sequence after you stop performing the operation.
Input
The first line contains a single integer n (2 ≤ n ≤ 2·105) — the number of elements in the sequence.
The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
In the first line print a single integer k — the number of elements in the sequence after you stop performing the operation.
In the second line print k integers — the sequence after you stop performing the operation.
Examples
Input
6
5 2 1 1 2 2
Output
2
5 4
Input
4
1000000000 1000000000 1000000000 1000000000
Output
1
1000000002
Input
7
4 10 22 11 12 5 6
Output
7
4 10 22 11 12 5 6
Note
The first example is described in the statements.
In the second example the initial sequence is [1000000000, 1000000000, 1000000000, 1000000000]. After the first operation the sequence is equal to [1000000001, 1000000000, 1000000000]. After the second operation the sequence is [1000000001, 1000000001]. After the third operation the sequence is [1000000002].
In the third example there are no two equal consecutive elements initially, so the sequence does not change.
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
arr = [0 for i in range(n)]
m = 0
for i in range(n):
x = a[i]
while m > 0 and arr[m - 1] == x:
arr[m - 1] = 0
x += 1
m -= 1
arr[m] = x
m += 1
print(arr)
``` | instruction | 0 | 94,119 | 12 | 188,238 |
No | output | 1 | 94,119 | 12 | 188,239 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Grisha come to a contest and faced the following problem.
You are given an array of size n, initially consisting of zeros. The elements of the array are enumerated from 1 to n. You perform q operations on the array. The i-th operation is described with three integers l_i, r_i and x_i (1 ≤ l_i ≤ r_i ≤ n, 1 ≤ x_i ≤ n) and means that you should add x_i to each of the elements with indices l_i, l_i + 1, …, r_i. After all operations you should find the maximum in the array.
Grisha is clever, so he solved the problem quickly.
However something went wrong inside his head and now he thinks of the following question: "consider we applied some subset of the operations to the array. What are the possible values of the maximum in the array?"
Help Grisha, find all integers y between 1 and n such that if you apply some subset (possibly empty) of the operations, then the maximum in the array becomes equal to y.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 10^{4}) — the length of the array and the number of queries in the initial problem.
The following q lines contain queries, one per line. The i-th of these lines contains three integers l_i, r_i and x_i (1 ≤ l_i ≤ r_i ≤ n, 1 ≤ x_i ≤ n), denoting a query of adding x_i to the segment from l_i-th to r_i-th elements of the array, inclusive.
Output
In the first line print the only integer k, denoting the number of integers from 1 to n, inclusive, that can be equal to the maximum in the array after applying some subset (possibly empty) of the given operations.
In the next line print these k integers from 1 to n — the possible values of the maximum. Print these integers in increasing order.
Examples
Input
4 3
1 3 1
2 4 2
3 4 4
Output
4
1 2 3 4
Input
7 2
1 5 1
3 7 2
Output
3
1 2 3
Input
10 3
1 1 2
1 1 3
1 1 6
Output
6
2 3 5 6 8 9
Note
Consider the first example. If you consider the subset only of the first query, the maximum is equal to 1. If you take only the second query, the maximum equals to 2. If you take the first two queries, the maximum becomes 3. If you take only the fourth query, the maximum becomes 4. If you take the fourth query and something more, the maximum becomes greater that n, so you shouldn't print it.
In the second example you can take the first query to obtain 1. You can take only the second query to obtain 2. You can take all queries to obtain 3.
In the third example you can obtain the following maximums:
* You can achieve the maximim of 2 by using queries: (1).
* You can achieve the maximim of 3 by using queries: (2).
* You can achieve the maximim of 5 by using queries: (1, 2).
* You can achieve the maximim of 6 by using queries: (3).
* You can achieve the maximim of 8 by using queries: (1, 3).
* You can achieve the maximim of 9 by using queries: (2, 3).
Submitted Solution:
```
from itertools import permutations
n, q = list(map(int, input().split()))
s = [int(0) for i in range(n)]
maxC = 0
maxValues = []
qList = []
for i in range(q):
l, r, x = list(map(lambda x: int(x) - 1, input().split()))
x += 1
qList.append((l, r, x))
lst = list(permutations(range(q)))[:10]
while lst:
posl = lst.pop(0)
sCopy = s.copy()
for ind in posl:
l, r, x = qList[int(ind)]
for j in range(l, r + 1):
sCopy[j] += x
currentMax = max(sCopy)
if currentMax not in maxValues and currentMax <= n:
maxValues.append(currentMax)
maxC += 1
print(maxC)
print(*sorted(maxValues))
``` | instruction | 0 | 94,127 | 12 | 188,254 |
No | output | 1 | 94,127 | 12 | 188,255 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Grisha come to a contest and faced the following problem.
You are given an array of size n, initially consisting of zeros. The elements of the array are enumerated from 1 to n. You perform q operations on the array. The i-th operation is described with three integers l_i, r_i and x_i (1 ≤ l_i ≤ r_i ≤ n, 1 ≤ x_i ≤ n) and means that you should add x_i to each of the elements with indices l_i, l_i + 1, …, r_i. After all operations you should find the maximum in the array.
Grisha is clever, so he solved the problem quickly.
However something went wrong inside his head and now he thinks of the following question: "consider we applied some subset of the operations to the array. What are the possible values of the maximum in the array?"
Help Grisha, find all integers y between 1 and n such that if you apply some subset (possibly empty) of the operations, then the maximum in the array becomes equal to y.
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 10^{4}) — the length of the array and the number of queries in the initial problem.
The following q lines contain queries, one per line. The i-th of these lines contains three integers l_i, r_i and x_i (1 ≤ l_i ≤ r_i ≤ n, 1 ≤ x_i ≤ n), denoting a query of adding x_i to the segment from l_i-th to r_i-th elements of the array, inclusive.
Output
In the first line print the only integer k, denoting the number of integers from 1 to n, inclusive, that can be equal to the maximum in the array after applying some subset (possibly empty) of the given operations.
In the next line print these k integers from 1 to n — the possible values of the maximum. Print these integers in increasing order.
Examples
Input
4 3
1 3 1
2 4 2
3 4 4
Output
4
1 2 3 4
Input
7 2
1 5 1
3 7 2
Output
3
1 2 3
Input
10 3
1 1 2
1 1 3
1 1 6
Output
6
2 3 5 6 8 9
Note
Consider the first example. If you consider the subset only of the first query, the maximum is equal to 1. If you take only the second query, the maximum equals to 2. If you take the first two queries, the maximum becomes 3. If you take only the fourth query, the maximum becomes 4. If you take the fourth query and something more, the maximum becomes greater that n, so you shouldn't print it.
In the second example you can take the first query to obtain 1. You can take only the second query to obtain 2. You can take all queries to obtain 3.
In the third example you can obtain the following maximums:
* You can achieve the maximim of 2 by using queries: (1).
* You can achieve the maximim of 3 by using queries: (2).
* You can achieve the maximim of 5 by using queries: (1, 2).
* You can achieve the maximim of 6 by using queries: (3).
* You can achieve the maximim of 8 by using queries: (1, 3).
* You can achieve the maximim of 9 by using queries: (2, 3).
Submitted Solution:
```
def getMax(n_max, values):
for vs in values:
if len(vs) > 0:
asd = dynamic[tuple(vs)]
if len(asd) == 0:
getMaxes(n_max, 0, vs, asd)
def getMaxes(n_max, current, values, asd):
if len(values) == 0 and n_max >= current and current > 0:
asd.add(current)
for v in values:
if current + values[0] < n_max:
getMaxes(n_max, current + values[0], values[1:], asd)
if current < n_max:
getMaxes(n_max, current, values[1:], asd)
n, q = map(int, input().split())
values = [[] for _ in range(n)]
total = set()
dynamic = {}
for _ in range(q):
l, r, value = map(int, input().split())
if value < n:
for i in range(l - 1, r):
values[i].append(value)
elif value == n:
total.add(value)
for p in values:
if len(p) > 0:
dynamic[tuple(p)] = set()
getMax(n, values)
total = []
for a in dynamic.values():
total.extend(a)
print(len(total))
if len(total) > 0:
print(' '.join([str(v) for v in sorted(total)]))
``` | instruction | 0 | 94,128 | 12 | 188,256 |
No | output | 1 | 94,128 | 12 | 188,257 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.