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.
Omkar has received a message from Anton saying "Your story for problem A is confusing. Just make a formal statement." Because of this, Omkar gives you an array a = [a_1, a_2, …, a_n] of n distinct integers. An array b = [b_1, b_2, …, b_k] is called nice if for any two distinct elements b_i, b_j of b, |b_i-b_j| appears in b at least once. In addition, all elements in b must be distinct. Can you add several (maybe, 0) integers to a to create a nice array b of size at most 300? If a is already nice, you don't have to add any elements.
For example, array [3, 6, 9] is nice, as |6-3|=|9-6| = 3, which appears in the array, and |9-3| = 6, which appears in the array, while array [4, 2, 0, 6, 9] is not nice, as |9-4| = 5 is not present in the array.
For integers x and y, |x-y| = x-y if x > y and |x-y| = y-x otherwise.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 50), the number of test cases. Description of the test cases follows.
The first line of each test case contains a single integer n (2 ≤ n ≤ 100) — the length of the array a.
The second line of each test case contains n distinct integers a_1, a_2, ⋅⋅⋅, a_n (-100 ≤ a_i ≤ 100) — the elements of the array a.
Output
For each test case, output one line containing YES if Omkar can create a nice array b by adding elements to a and NO otherwise. The case of each letter does not matter, so yEs and nO will also be accepted.
If the first line is YES, output a second line containing a single integer k (n ≤ k ≤ 300).
Then output one line containing k distinct integers b_1, b_2, ⋅⋅⋅, b_k (-10^9 ≤ b_i ≤ 10^9), the elements of the nice array b. b_1, b_2, ⋅⋅⋅, b_k can be in any order. For each a_i in a, a_i must appear at least once in b.
It can be proved that if Omkar can create such an array b, then he can also do so in a way that satisfies the above constraints.
If multiple solutions exist, you can print any.
Example
Input
4
3
3 0 9
2
3 4
5
-7 3 13 -2 8
4
4 8 12 6
Output
yes
4
6 0 3 9
yEs
5
5 3 1 2 4
NO
Yes
6
8 12 6 2 4 10
Note
For the first case, you can add integers to a to receive the array b = [6, 0, 3, 9]. Note that |6-3| = |9-6| = |3-0| = 3 and 3 is in b, |6-0| = |9-3| = 6 and 6 is in b, and |9-0| = 9 is in b, so b is nice.
For the second case, you can add integers to a to receive the array b = [5, 3, 1, 2, 4]. We have that |2-1| = |3-2| = |4-3| = |5-4| = 1 is in b, |3-1| = |4-2| = |5-3| = 2 is in b, |4-1| = |5-2| = 3 is in b, and |5-1| = 4 is in b, so b is nice.
For the fourth case, you can add integers to a to receive the array b = [8, 12, 6, 2, 4, 10]. We have that |4-2| = |6-4| = |8-6| = |10-8| = |12-10| = 2 is in b, |6-2| = |8-4| = |10-6| = |12-8| = 4 is in b, |8-2| = |10-4| = |12-6| = 6 is in b, |10-2| = |12-4| = 8 is in b, and |12-2| = 10 is in b, so b is nice.
It can be proven that for all other test cases it is impossible to create a nice array b.
Submitted Solution:
```
if __name__=='__main__':
t=int(input())
for i in range(t):
n=int(input())
l=list(map(int,input().split()))
l=sorted(l)
diff=l[1]-l[0]
max=l[-1]
if max%diff==0:
if (max//diff<300):
print("YES")
print(max//diff)
for i in range(diff,max+1,diff):
print(i,end=' ')
print()
else:
print("NO")
else:
print("NO")
``` | instruction | 0 | 51,582 | 12 | 103,164 |
No | output | 1 | 51,582 | 12 | 103,165 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Omkar has received a message from Anton saying "Your story for problem A is confusing. Just make a formal statement." Because of this, Omkar gives you an array a = [a_1, a_2, …, a_n] of n distinct integers. An array b = [b_1, b_2, …, b_k] is called nice if for any two distinct elements b_i, b_j of b, |b_i-b_j| appears in b at least once. In addition, all elements in b must be distinct. Can you add several (maybe, 0) integers to a to create a nice array b of size at most 300? If a is already nice, you don't have to add any elements.
For example, array [3, 6, 9] is nice, as |6-3|=|9-6| = 3, which appears in the array, and |9-3| = 6, which appears in the array, while array [4, 2, 0, 6, 9] is not nice, as |9-4| = 5 is not present in the array.
For integers x and y, |x-y| = x-y if x > y and |x-y| = y-x otherwise.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 50), the number of test cases. Description of the test cases follows.
The first line of each test case contains a single integer n (2 ≤ n ≤ 100) — the length of the array a.
The second line of each test case contains n distinct integers a_1, a_2, ⋅⋅⋅, a_n (-100 ≤ a_i ≤ 100) — the elements of the array a.
Output
For each test case, output one line containing YES if Omkar can create a nice array b by adding elements to a and NO otherwise. The case of each letter does not matter, so yEs and nO will also be accepted.
If the first line is YES, output a second line containing a single integer k (n ≤ k ≤ 300).
Then output one line containing k distinct integers b_1, b_2, ⋅⋅⋅, b_k (-10^9 ≤ b_i ≤ 10^9), the elements of the nice array b. b_1, b_2, ⋅⋅⋅, b_k can be in any order. For each a_i in a, a_i must appear at least once in b.
It can be proved that if Omkar can create such an array b, then he can also do so in a way that satisfies the above constraints.
If multiple solutions exist, you can print any.
Example
Input
4
3
3 0 9
2
3 4
5
-7 3 13 -2 8
4
4 8 12 6
Output
yes
4
6 0 3 9
yEs
5
5 3 1 2 4
NO
Yes
6
8 12 6 2 4 10
Note
For the first case, you can add integers to a to receive the array b = [6, 0, 3, 9]. Note that |6-3| = |9-6| = |3-0| = 3 and 3 is in b, |6-0| = |9-3| = 6 and 6 is in b, and |9-0| = 9 is in b, so b is nice.
For the second case, you can add integers to a to receive the array b = [5, 3, 1, 2, 4]. We have that |2-1| = |3-2| = |4-3| = |5-4| = 1 is in b, |3-1| = |4-2| = |5-3| = 2 is in b, |4-1| = |5-2| = 3 is in b, and |5-1| = 4 is in b, so b is nice.
For the fourth case, you can add integers to a to receive the array b = [8, 12, 6, 2, 4, 10]. We have that |4-2| = |6-4| = |8-6| = |10-8| = |12-10| = 2 is in b, |6-2| = |8-4| = |10-6| = |12-8| = 4 is in b, |8-2| = |10-4| = |12-6| = 6 is in b, |10-2| = |12-4| = 8 is in b, and |12-2| = 10 is in b, so b is nice.
It can be proven that for all other test cases it is impossible to create a nice array b.
Submitted Solution:
```
# import math
# from itertools import permutations
# from itertools import combinations
# import sys
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
'''def is_prime(n):
j=2
while j*j<=n:
if n%j==0:
return 0
j+=1
return 1'''
'''def gcd(x, y):
while(y):
x, y = y, x % y
return x'''
def prob():
n=int(input())
l=[int(x) for x in input().split()]
for i in l:
if i<0:
print("NO")
return
diff=[]
l.sort()
for i in range(n-1):
diff.append(abs(l[i]-l[i+1]))
diff.sort()
k=diff[0]
for i in range(len(diff)):
if diff[i]%k!=0:
print("NO")
return
p=l[-1]
num=l[0]
ans=[]
# if num==0:
# ans.append(num)
ans.append(p)
# j=1
while(p>0):
p = p - k
ans.append(p)
# j+=1
print("YES")
print(len(ans))
print(*ans)
t=1
t=int(input())
for _ in range(0,t):
prob()
``` | instruction | 0 | 51,583 | 12 | 103,166 |
No | output | 1 | 51,583 | 12 | 103,167 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Omkar has received a message from Anton saying "Your story for problem A is confusing. Just make a formal statement." Because of this, Omkar gives you an array a = [a_1, a_2, …, a_n] of n distinct integers. An array b = [b_1, b_2, …, b_k] is called nice if for any two distinct elements b_i, b_j of b, |b_i-b_j| appears in b at least once. In addition, all elements in b must be distinct. Can you add several (maybe, 0) integers to a to create a nice array b of size at most 300? If a is already nice, you don't have to add any elements.
For example, array [3, 6, 9] is nice, as |6-3|=|9-6| = 3, which appears in the array, and |9-3| = 6, which appears in the array, while array [4, 2, 0, 6, 9] is not nice, as |9-4| = 5 is not present in the array.
For integers x and y, |x-y| = x-y if x > y and |x-y| = y-x otherwise.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 50), the number of test cases. Description of the test cases follows.
The first line of each test case contains a single integer n (2 ≤ n ≤ 100) — the length of the array a.
The second line of each test case contains n distinct integers a_1, a_2, ⋅⋅⋅, a_n (-100 ≤ a_i ≤ 100) — the elements of the array a.
Output
For each test case, output one line containing YES if Omkar can create a nice array b by adding elements to a and NO otherwise. The case of each letter does not matter, so yEs and nO will also be accepted.
If the first line is YES, output a second line containing a single integer k (n ≤ k ≤ 300).
Then output one line containing k distinct integers b_1, b_2, ⋅⋅⋅, b_k (-10^9 ≤ b_i ≤ 10^9), the elements of the nice array b. b_1, b_2, ⋅⋅⋅, b_k can be in any order. For each a_i in a, a_i must appear at least once in b.
It can be proved that if Omkar can create such an array b, then he can also do so in a way that satisfies the above constraints.
If multiple solutions exist, you can print any.
Example
Input
4
3
3 0 9
2
3 4
5
-7 3 13 -2 8
4
4 8 12 6
Output
yes
4
6 0 3 9
yEs
5
5 3 1 2 4
NO
Yes
6
8 12 6 2 4 10
Note
For the first case, you can add integers to a to receive the array b = [6, 0, 3, 9]. Note that |6-3| = |9-6| = |3-0| = 3 and 3 is in b, |6-0| = |9-3| = 6 and 6 is in b, and |9-0| = 9 is in b, so b is nice.
For the second case, you can add integers to a to receive the array b = [5, 3, 1, 2, 4]. We have that |2-1| = |3-2| = |4-3| = |5-4| = 1 is in b, |3-1| = |4-2| = |5-3| = 2 is in b, |4-1| = |5-2| = 3 is in b, and |5-1| = 4 is in b, so b is nice.
For the fourth case, you can add integers to a to receive the array b = [8, 12, 6, 2, 4, 10]. We have that |4-2| = |6-4| = |8-6| = |10-8| = |12-10| = 2 is in b, |6-2| = |8-4| = |10-6| = |12-8| = 4 is in b, |8-2| = |10-4| = |12-6| = 6 is in b, |10-2| = |12-4| = 8 is in b, and |12-2| = 10 is in b, so b is nice.
It can be proven that for all other test cases it is impossible to create a nice array b.
Submitted Solution:
```
import sys
import math
from bisect import bisect_left
from collections import Counter,defaultdict
L=lambda:list(map(int,input().split()))
I=lambda:int(input())
S=lambda:input()
mod=10**9+7
def solve():
n = I()
a = L()
print("YES")
b = [i for i in range(-100,201)]
b.remove(0)
print(len(b))
print(*b)
for _ in range(I()):
solve()
``` | instruction | 0 | 51,584 | 12 | 103,168 |
No | output | 1 | 51,584 | 12 | 103,169 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10. | instruction | 0 | 51,606 | 12 | 103,212 |
Tags: brute force, dp
Correct Solution:
```
def get_len(a, b):
if a[0]>=b[0]:
c = a
a = b
b = c
i = 0
j = 0
res = 2
while i<len(a) and j<len(b):
while a[i]<=b[j]:
i+=1
if i==len(a):
break
if i==len(a):
break
res+=1
while a[i]>=b[j]:
j+=1
if j==len(b):
break
if j==len(b):
break
res+=1
return res
n = int(input())
a = [int(e) for e in input().split()]
d = dict()
keys = []
for i in range(len(a)):
x = a[i]
if x in d:
d[x].append(i)
else:
d[x] = [i]
keys.append(x)
ans = 0
for i in range(len(keys)):
x = keys[i]
for j in range(i+1, len(keys)):
y = keys[j]
if x==y:
continue
i1 = 0
j1 = 0
#print("___")
#print(d[x], d[y])
xi = get_len(d[x], d[y])
#print(xi)
ans = max(ans, xi)
ans1 = [len(d[e]) for e in d]
ans = max(ans, max(ans1))
print(ans)
# 3 1 3 1 3
``` | output | 1 | 51,606 | 12 | 103,213 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10. | instruction | 0 | 51,607 | 12 | 103,214 |
Tags: brute force, dp
Correct Solution:
```
n = int(input())
ls = list(map(int, input().split()))
dp = [[1 for i in range(n)] for j in range(n)]
laspos = [None] * (max(ls) + 1)
for i in range(n):
for j in range(i):
if laspos[ls[i]] is not None:
dp[i][j] = 1 + dp[j][laspos[ls[i]]]
else:
dp[i][j] += 1
laspos[ls[j]] = j
mx = -100000
for i in range(n):
for j in range(n):
mx = max(dp[i][j], mx)
print(mx)
``` | output | 1 | 51,607 | 12 | 103,215 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10. | instruction | 0 | 51,608 | 12 | 103,216 |
Tags: brute force, dp
Correct Solution:
```
R = lambda: map(int, input().split())
n = int(input())
arr = list(R())
dp = [[0] * (n + 1) for i in range(n + 1)]
for i in range(n):
p = -1
for j in range(i):
dp[i][j] = max(dp[i][j], dp[j][p] + 1)
p = j if arr[j] == arr[i] else p
print(max(max(dp[i]) for i in range(n)) + 1)
``` | output | 1 | 51,608 | 12 | 103,217 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10. | instruction | 0 | 51,609 | 12 | 103,218 |
Tags: brute force, dp
Correct Solution:
```
#!/usr/bin/env python3
import io
import os
import sys
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def printd(*args, **kwargs):
# print(*args, **kwargs, file=sys.stderr)
print(*args, **kwargs)
pass
def get_str():
return input().decode().strip()
def rint():
return map(int, input().split())
def oint():
return int(input())
def find_next(l, li, i):
while l[li] < i:
li += 1
if li == len(l):
return -1
return li
n = oint()
b = list(rint())
index_dict = dict()
for i in range(n):
if b[i] in index_dict:
index_dict[b[i]].append(i)
else:
index_dict[b[i]] = [i]
index = []
for i in index_dict:
index.append(index_dict[i])
max_cnt = 0
for i in range(len(index)):
ii = index[i]
for j in range(len(index)):
jj = index[j]
if i == j:
max_cnt = max(max_cnt, len(index[i]))
continue
pi = 0
pj = 0
ij = 0
cnt = 1
while True:
if ij == 0:
tmp = find_next(jj, pj, ii[pi])
if tmp == -1:
break
pj = tmp
cnt += 1
ij = 1
else:
tmp = find_next(ii, pi, jj[pj])
if tmp == -1:
break
pi = tmp
cnt += 1
ij = 0
max_cnt = max(max_cnt, cnt)
print(max_cnt)
``` | output | 1 | 51,609 | 12 | 103,219 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10. | instruction | 0 | 51,610 | 12 | 103,220 |
Tags: brute force, dp
Correct Solution:
```
# WHY IS RUBY SO SLOW????
input()
a=[*map(int,input().split())]
r={}
for i, x in enumerate(list(set(a))):
r[x] = i
n = len(r)
m = 0
a = [r[x] for x in a]
for i,x in enumerate(a):
h=[0 for _ in range(n)]
l=[-2 for _ in range(n)]
lx = -1
for j,y in enumerate(a[i+1:]):
if y == x:
lx = j
if l[y] < lx:
h[y] += 1
l[y] = j
for k in range(n):
if k == x:
h[k] = h[k] + 1
elif l[k] < lx:
h[k] = 2*h[k] + 1
else:
h[k] = 2*h[k]
m = max(m, max(h+[1]))
print(m)
``` | output | 1 | 51,610 | 12 | 103,221 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10. | instruction | 0 | 51,611 | 12 | 103,222 |
Tags: brute force, dp
Correct Solution:
```
def function(n , array):
grid = [ {} for i in range(n)]
if(n <= 2):
print(n)
return
global_max = -10
for i in range(n - 2, -1, -1):
for j in range(i + 1, n):
diff = array[i] - array[j]
max_val = 1
if((-diff) in grid[j].keys()):
max_val = max(grid[j][(-diff)] + 1, max_val)
if(diff in grid[i].keys()):
max_val = max(max_val, grid[i][diff])
grid[i][diff] = max_val
else:
grid[i][diff] = max_val
global_max = max(global_max, max_val)
print(global_max + 1)
n = int(input())
array = [ int(x) for x in input().split() ]
function(n, array)
``` | output | 1 | 51,611 | 12 | 103,223 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10. | instruction | 0 | 51,612 | 12 | 103,224 |
Tags: brute force, dp
Correct Solution:
```
import sys
input = sys.stdin.readline
#for _ in range(int(input())):
n=int(input())
ans=1
arr=[int(x) for x in input().split()]
for i in range(n):
temp=set()
d={}
#ans=0
for j in range(i+1,n):
if arr[j]==arr[i]:
temp=set()
else:
if arr[j] not in temp:
if arr[j] in d:
d[arr[j]]+=1
else:
d[arr[j]]=1
temp.add(arr[j])
number=-1
maxi=-1
#print(d,temp)
for i in d:
if maxi<d[i]:
number=i
maxi=d[i]
#print(number,maxi)
if number in temp:
ans=max(ans,2*maxi)
else:
ans=max(ans,2*maxi+1)
d={}
for i in arr:
if i in d:
d[i]+=1
else:
d[i]=1
for i in d:
ans=max(ans,d[i])
print(ans)
``` | output | 1 | 51,612 | 12 | 103,225 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10. | instruction | 0 | 51,613 | 12 | 103,226 |
Tags: brute force, dp
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
# from decimal import Decimal
# import heapq
# from functools import lru_cache
# import sys
# import threading
# sys.setrecursionlimit(10**6)
# threading.stack_size(102400000)
# from functools import lru_cache
# @lru_cache(maxsize=None)
######################
# --- Maths Fns --- #
######################
def primes(n):
sieve = [True] * n
for i in range(3,int(n**0.5)+1,2):
if sieve[i]:
sieve[i*i::2*i]=[False]*((n-i*i-1)//(2*i)+1)
return [2] + [i for i in range(3,n,2) if sieve[i]]
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 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
# @lru_cache(maxsize=None)
def digitsSum(n):
if n == 0:
return 0
r = 0
while n > 0:
r += n % 10
n //= 10
return r
######################
# ---- GRID Fns ---- #
######################
def isValid(i, j, n, m):
return i >= 0 and i < n and j >= 0 and j < m
def print_grid(grid):
for line in grid:
print(" ".join(map(str,line)))
######################
# ---- MISC Fns ---- #
######################
def kadane(a,size):
max_so_far = 0
max_ending_here = 0
for i in range(0, size):
max_ending_here = max_ending_here + a[i]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if max_ending_here < 0:
max_ending_here = 0
return max_so_far
def prefixSum(arr):
for i in range(1, len(arr)):
arr[i] = arr[i] + arr[i-1]
return arr
def ceil(n, d):
if n % d == 0:
return n // d
else:
return (n // d) + 1
# INPUTS --------------------------
# s = input().decode('utf-8').strip()
# n = int(input())
# l = list(map(int, input().split()))
# t = int(input())
# for _ in range(t):
# for _ in range(t):
def solve(arr1, arr2, p, t):
if not len(arr1) or not len(arr2):
return 1
i, j = 0, 0
cnt = 1
# p = arr1[0]
# t = True
while i < len(arr1) and j < len(arr2):
if t:
while j < len(arr2) and arr2[j] <= p:
j += 1
if j < len(arr2):
p = arr2[j]
t = not t
cnt += 1
else:
while i < len(arr1) and arr1[i] <= p:
i += 1
if i < len(arr1):
p = arr1[i]
t = not t
cnt += 1
if t and j < len(arr2):
while j < len(arr2) and arr2[j] <= p:
j += 1
if j < len(arr2):
p = arr2[j]
t = not t
cnt += 1
elif not t and i < len(arr1):
while i < len(arr1) and arr1[i] <= p:
i += 1
if i < len(arr1):
p = arr1[i]
t = not t
cnt += 1
return cnt
n = int(input())
l = list(map(int, input().split()))
if n <= 2:
print(n)
exit()
best = 0
m = collections.defaultdict(list)
for i, v in enumerate(l):
m[v].append(i)
keys = list(m.keys())
for i in range(len(keys)):
for j in range(i+1, len(keys)):
arr1 = m[keys[i]]
arr2 = m[keys[j]]
if len(arr1) + len(arr2) <= best:
continue
r = solve(arr1, arr2, arr1[0], True)
best = max(r, best)
r2 = solve(arr1, arr2, arr2[0], False)
best = max(r2, best)
best = max(best, len(arr1))
best = max(best, len(arr2))
print(best)
``` | output | 1 | 51,613 | 12 | 103,227 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10.
Submitted Solution:
```
n = int(input())
t = list(map(int, input().split()))
p = {a: 0 for a in set(t)}
d = 0
for i in range(n):
a = t[i]
if not a in p:
continue
p.pop(a)
s = t.count(a) - 1
if 2 * s < d:
continue
if s > d:
d = s
k = i + 1
for j in range(k, n):
if t[j] == a:
for b in set(t[k: j]):
if b in p:
p[b] += 2
k = j + 1
for b in set(t[k: n]):
if b in p:
p[b] += 1
for b in p:
if p[b] > d:
d = p[b]
p[b] = 0
print(d + 1)
``` | instruction | 0 | 51,614 | 12 | 103,228 |
Yes | output | 1 | 51,614 | 12 | 103,229 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10.
Submitted Solution:
```
n=int(input())
b=list(map(int,input().split()))
dp=[[1]*n for i in range(n)]
d,k={},0
for i in range(n):
if b[i] not in d:
d[b[i]]=k
k+=1
b[i]=d[b[i]]
d.clear()
for i in range(n):
for j in range(i):
dp[i][b[j]]=max(1+dp[j][b[i]],dp[i][b[j]])
ans=0
for l in dp:
ans=max(ans,max(l))
print(ans)
``` | instruction | 0 | 51,615 | 12 | 103,230 |
Yes | output | 1 | 51,615 | 12 | 103,231 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10.
Submitted Solution:
```
d, n, t = 0, int(input()), list(map(int, input().split()))
p = {a: 0 for a in set(t)}
for i in range(n):
a = t[i]
if not a in p: continue
p.pop(a)
s = t.count(a) - 1
if 2 * s < d: continue
if s > d: d = s
k = i + 1
for j in range(k, n):
if t[j] == a:
for b in set(t[k: j]):
if b in p: p[b] += 2
k = j + 1
for b in set(t[k: n]):
if b in p: p[b] += 1
for b in p:
if p[b] > d: d = p[b]
p[b] = 0
print(d + 1)
``` | instruction | 0 | 51,616 | 12 | 103,232 |
Yes | output | 1 | 51,616 | 12 | 103,233 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10.
Submitted Solution:
```
import sys
from math import log2,floor,ceil,sqrt
# import bisect
# from collections import deque
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 10**9+7
n = int(ri())
arr = Ri()
a = sorted(arr)
dic = {}
ite = 1
for i in range(n):
if a[i] not in dic:
dic[a[i]] = ite
ite+=1
for i in range(n):
arr[i] = dic[arr[i]]
dp = list2d(n,n+1,0)
for i in range(n):
for j in range(n+1):
dp[i][j] = 1
maxx = 1
for i in range(1,n):
for j in range(i-1,-1,-1):
dp[i][arr[j]] = max(dp[i][arr[j]], dp[j][arr[i]]+1)
maxx = max(maxx,dp[i][arr[j]])
print(maxx)
``` | instruction | 0 | 51,617 | 12 | 103,234 |
Yes | output | 1 | 51,617 | 12 | 103,235 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10.
Submitted Solution:
```
n = int(input())
b = list(map(int,input().split()))
if n <= 2:
print(n)
else:
k= 2
maxk = k
for i in range(n-2):
if b[i] == b[i+2]:
k+=1
else:
k=2
if maxk <k :
maxk = k
print(maxk)
``` | instruction | 0 | 51,618 | 12 | 103,236 |
No | output | 1 | 51,618 | 12 | 103,237 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10.
Submitted Solution:
```
n=int(input())
ar=list(map(int,input().split()))
from collections import defaultdict
import bisect
di=defaultdict(list)
for i in range(n):
di[ar[i]].append(i)
#print(di)
if(n<=2):
print(n)
else:
s=set(ar)
cnt=0
for i in s:
for j in s:
br=[]
if(i!=j):
l1=1
l2=0
n1=di[i]
n2=di[j]
br.append(n1[0])
F=True
while(True):
if(F==True):
x=br[-1]
k=bisect.bisect(n2,x)
if(k==len(n2)):
break
br.append(n2[k])
F=False
l2+=1
else:
x=br[-1]
k=bisect.bisect(n1,x)
if(k==len(n1)):
break
br.append(n1[k])
F=True
l1+=1
cnt=max(cnt,len(br))
print(cnt)
``` | instruction | 0 | 51,619 | 12 | 103,238 |
No | output | 1 | 51,619 | 12 | 103,239 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10.
Submitted Solution:
```
class Data:
def __init__(self, num, ind):
self.num = num
self.count = 1
self.occurrence = []
self.occurrence.append(ind)
def data_comp(x):
return x.count
def compute_len(a, b, list):
ab = 0
next_number = -1
for i in range(len(list)):
if next_number == -1 and list[i] == a.num:
ab += 1
next_number = 2
if next_number == -1 and list[i] == b.num:
ab += 1
next_number = 1
if next_number == 1 and list[i] == a.num:
ab += 1
next_number = 2
if next_number == 2 and list[i] == b.num:
ab += 1
next_number = 1
return ab
# get inputs
n = int(input())
input_list = []
input_numbers = []
raw_input = input().split(sep=" ")
last_number = -1
for index in range(n):
temp = int(raw_input[index])
if last_number == temp:
continue
else:
last_number = temp
input_numbers.append(temp)
for ind in range(len(input_list)):
if input_list[ind].num == temp:
input_list[ind].count += 1
input_list[ind].occurrence.append(index)
break
else:
tempData = Data(temp, index)
input_list.append(tempData)
# sorting
input_list.sort(key=data_comp, reverse=True)
# finding max len
max_len = 1
for i in range(len(input_list)-1):
for j in range(i+1, len(input_list)):
if max_len >= input_list[i].count + input_list[j].count:
break
this_len = compute_len(input_list[i], input_list[j], input_numbers)
if this_len > max_len:
max_len = this_len
print(max_len)
``` | instruction | 0 | 51,620 | 12 | 103,240 |
No | output | 1 | 51,620 | 12 | 103,241 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10.
Submitted Solution:
```
def main():
s1 = input() # String.
s1 = dict.fromkeys(s1) # Convert it to dictionary to remove duplicates.
if len(s1) % 2 == 0:
print("CHAT WITH HER!")
else:
print("IGNORE HIM!")
if __name__ == "__main__":
main()
``` | instruction | 0 | 51,621 | 12 | 103,242 |
No | output | 1 | 51,621 | 12 | 103,243 |
Provide tags and a correct Python 3 solution for this coding contest problem.
«Polygon» is a system which allows to create programming tasks in a simple and professional way. When you add a test to the problem, the corresponding form asks you for the test index. As in most cases it is clear which index the next test will have, the system suggests the default value of the index. It is calculated as the smallest positive integer which is not used as an index for some previously added test.
You are to implement this feature. Create a program which determines the default index of the next test, given the indexes of the previously added tests.
Input
The first line contains one integer n (1 ≤ n ≤ 3000) — the amount of previously added tests. The second line contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ 3000) — indexes of these tests.
Output
Output the required default value for the next test index.
Examples
Input
3
1 7 2
Output
3 | instruction | 0 | 51,628 | 12 | 103,256 |
Tags: implementation, sortings
Correct Solution:
```
n = int(input())
arr = list(map(int, input().split()))
print(sorted(set(range(1, max(arr)+2)) - set(arr))[0])
``` | output | 1 | 51,628 | 12 | 103,257 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Yaroslav calls an array of r integers a1, a2, ..., ar good, if it meets the following conditions: |a1 - a2| = 1, |a2 - a3| = 1, ..., |ar - 1 - ar| = 1, |ar - a1| = 1, at that <image>.
An array of integers b1, b2, ..., br is called great, if it meets the following conditions:
1. The elements in it do not decrease (bi ≤ bi + 1).
2. If the inequalities 1 ≤ r ≤ n and 1 ≤ bi ≤ m hold.
3. If we can rearrange its elements and get at least one and at most k distinct good arrays.
Yaroslav has three integers n, m, k. He needs to count the number of distinct great arrays. Help Yaroslav! As the answer may be rather large, print the remainder after dividing it by 1000000007 (109 + 7).
Two arrays are considered distinct if there is a position in which they have distinct numbers.
Input
The single line contains three integers n, m, k (1 ≤ n, m, k ≤ 100).
Output
In a single line print the remainder after dividing the answer to the problem by number 1000000007 (109 + 7).
Examples
Input
1 1 1
Output
0
Input
3 3 3
Output
2
Submitted Solution:
```
mod=1000000007
dp=[[[[0 for i in range(110)] for i in range(110) ] for i in range(110)] for i in range(2)]
c=[[0 for i in range(110)] for i in range(110)]
c[0][0]=1
for i in range(1,110):
for j in range(0,110):
if j==0:
c[i][0]=1
else:
c[i][j]=(c[i-1][j]+c[i-1][j-1])%mod
n,m,p=map(int,input().split())
n=n+1
dp[0][0][1][1]=1
ret=0
for i in range(1,m+1):
for j in range(0,n+1):
for k in range(0,n-j+1):
for t in range(1,p+1):
if j>1 and k==0:
ret=(ret+dp[~i&1][j][k][t]*(m-i+2)%mod)%mod
continue
for w in range(k,n-j+1):
if t*c[w-1][k-1]<=p:
dp[i&1][j+w][w-k][t*c[w-1][k-1]]=(dp[i&1][j+w][w-k][t*c[w-1][k-1]]+dp[~i&1][j][k][t])%mod
dp[~i&1][j][k][t]=0
print(ret)
``` | instruction | 0 | 51,638 | 12 | 103,276 |
No | output | 1 | 51,638 | 12 | 103,277 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers, and additionally an integer m. You have to choose some sequence of indices b1, b2, ..., bk (1 ≤ b1 < b2 < ... < bk ≤ n) in such a way that the value of <image> is maximized. Chosen sequence can be empty.
Print the maximum possible value of <image>.
Input
The first line contains two integers n and m (1 ≤ n ≤ 35, 1 ≤ m ≤ 109).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
Print the maximum possible value of <image>.
Examples
Input
4 4
5 2 4 1
Output
3
Input
3 20
199 41 299
Output
19
Note
In the first example you can choose a sequence b = {1, 2}, so the sum <image> is equal to 7 (and that's 3 after taking it modulo 4).
In the second example you can choose a sequence b = {3}. | instruction | 0 | 51,842 | 12 | 103,684 |
Tags: bitmasks, divide and conquer, meet-in-the-middle
Correct Solution:
```
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
import bisect
a1,a2=[],[]
n1=n//2
def sums1(i,sum=0):
if i==n1:
a1.append(sum)
else:
sums1(i+1,(sum+a[i])%m)
sums1(i+1,sum)
def sums2(i,sum=0):
if i==n:
a2.append(sum)
else:
sums2(i+1,(sum+a[i])%m)
sums2(i+1,sum)
sums1(0)
sums2(n1)
ans=0
end=len(a2)-1
a1=sorted(set(a1))
for i in a2:
j=bisect.bisect_left(a1,m-i)
ans=max(ans,a1[j-1]+i)
k=a1[j-1]+i
if ans<k:
ans=k
print(ans)
``` | output | 1 | 51,842 | 12 | 103,685 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers, and additionally an integer m. You have to choose some sequence of indices b1, b2, ..., bk (1 ≤ b1 < b2 < ... < bk ≤ n) in such a way that the value of <image> is maximized. Chosen sequence can be empty.
Print the maximum possible value of <image>.
Input
The first line contains two integers n and m (1 ≤ n ≤ 35, 1 ≤ m ≤ 109).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
Print the maximum possible value of <image>.
Examples
Input
4 4
5 2 4 1
Output
3
Input
3 20
199 41 299
Output
19
Note
In the first example you can choose a sequence b = {1, 2}, so the sum <image> is equal to 7 (and that's 3 after taking it modulo 4).
In the second example you can choose a sequence b = {3}. | instruction | 0 | 51,843 | 12 | 103,686 |
Tags: bitmasks, divide and conquer, meet-in-the-middle
Correct Solution:
```
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
import bisect
a1,a2=[],[]
n1=n//2
app1=a1.append
app2=a2.append
def sums1(i,sum=0):
if i==n1:
app1(sum)
else:
sums1(i+1,(sum+a[i])%m)
sums1(i+1,sum)
def sums2(i,sum=0):
if i==n:
app2(sum)
else:
sums2(i+1,(sum+a[i])%m)
sums2(i+1,sum)
sums1(0)
sums2(n1)
ans=0
end=len(a2)-1
a1=sorted(set(a1))
bis=bisect.bisect_left
def solve(i):
global ans
j=bis(a1,m-i)
if ans<a1[j-1]+i:
ans=a1[j-1]+i
return ans
l=list(map(solve,a2))
print(l[-1])
``` | output | 1 | 51,843 | 12 | 103,687 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers, and additionally an integer m. You have to choose some sequence of indices b1, b2, ..., bk (1 ≤ b1 < b2 < ... < bk ≤ n) in such a way that the value of <image> is maximized. Chosen sequence can be empty.
Print the maximum possible value of <image>.
Input
The first line contains two integers n and m (1 ≤ n ≤ 35, 1 ≤ m ≤ 109).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
Print the maximum possible value of <image>.
Examples
Input
4 4
5 2 4 1
Output
3
Input
3 20
199 41 299
Output
19
Note
In the first example you can choose a sequence b = {1, 2}, so the sum <image> is equal to 7 (and that's 3 after taking it modulo 4).
In the second example you can choose a sequence b = {3}. | instruction | 0 | 51,844 | 12 | 103,688 |
Tags: bitmasks, divide and conquer, meet-in-the-middle
Correct Solution:
```
n,m=map(int,input().split())
a=[int(i)%m for i in input().split()]
x,y=set(),set()
def f(x,n,i,s=0):
if i==n:
if s == m - 1: exit(print(s))
x.add(s)
else:
f(x,n,i+1,(s+a[i])%m)
f(x,n,i+1,s)
h=n//2
f(x,h,0)
f(y,n,h)
y=sorted(y)
import bisect
k=0
print(max(i+y[bisect.bisect_left(y,m-i)-1]for i in x))
``` | output | 1 | 51,844 | 12 | 103,689 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers, and additionally an integer m. You have to choose some sequence of indices b1, b2, ..., bk (1 ≤ b1 < b2 < ... < bk ≤ n) in such a way that the value of <image> is maximized. Chosen sequence can be empty.
Print the maximum possible value of <image>.
Input
The first line contains two integers n and m (1 ≤ n ≤ 35, 1 ≤ m ≤ 109).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
Print the maximum possible value of <image>.
Examples
Input
4 4
5 2 4 1
Output
3
Input
3 20
199 41 299
Output
19
Note
In the first example you can choose a sequence b = {1, 2}, so the sum <image> is equal to 7 (and that's 3 after taking it modulo 4).
In the second example you can choose a sequence b = {3}. | instruction | 0 | 51,845 | 12 | 103,690 |
Tags: bitmasks, divide and conquer, meet-in-the-middle
Correct Solution:
```
from bisect import bisect_right, bisect_left
import sys
def input():
return sys.stdin.buffer.readline().rstrip()
n, m = map(int, input().split())
a = list(map(int, input().split()))
la = a[:n//2]
ra = a[n//2:]
La = [0]
Ra = [0]
len_la = len(la)
for i in range(1 << len_la):
v = 0
V = i
for bit in range(len_la):
if V & 1:
v += la[bit]
V >>= 1
La.append(v % m)
len_ra = len(ra)
for i in range(1 << len_ra):
v = 0
V = i
for bit in range(len_ra):
if V & 1:
v += ra[bit]
V >>= 1
Ra.append(v % m)
ans = 0
La.sort()
Ra.sort()
for v in La:
ans = max(ans, v + Ra[bisect_right(Ra, m - 1 - v) - 1])
print(ans)
``` | output | 1 | 51,845 | 12 | 103,691 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers, and additionally an integer m. You have to choose some sequence of indices b1, b2, ..., bk (1 ≤ b1 < b2 < ... < bk ≤ n) in such a way that the value of <image> is maximized. Chosen sequence can be empty.
Print the maximum possible value of <image>.
Input
The first line contains two integers n and m (1 ≤ n ≤ 35, 1 ≤ m ≤ 109).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
Print the maximum possible value of <image>.
Examples
Input
4 4
5 2 4 1
Output
3
Input
3 20
199 41 299
Output
19
Note
In the first example you can choose a sequence b = {1, 2}, so the sum <image> is equal to 7 (and that's 3 after taking it modulo 4).
In the second example you can choose a sequence b = {3}. | instruction | 0 | 51,846 | 12 | 103,692 |
Tags: bitmasks, divide and conquer, meet-in-the-middle
Correct Solution:
```
n,m=map(int,input().split())
a=[int(i) for i in input().split()]
x,y=set(),set()
def f(x,n,i,s=0):
if i==n:
if s == m - 1: exit(print(s))
x.add(s)
else:
f(x,n,i+1,(s+a[i])%m)
f(x,n,i+1,s)
h=n//2
f(x,h,0)
f(y,n,h)
y=sorted(y)
import bisect
k=0
print(max(i+y[bisect.bisect_left(y,m-i)-1]for i in x))
``` | output | 1 | 51,846 | 12 | 103,693 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers, and additionally an integer m. You have to choose some sequence of indices b1, b2, ..., bk (1 ≤ b1 < b2 < ... < bk ≤ n) in such a way that the value of <image> is maximized. Chosen sequence can be empty.
Print the maximum possible value of <image>.
Input
The first line contains two integers n and m (1 ≤ n ≤ 35, 1 ≤ m ≤ 109).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
Print the maximum possible value of <image>.
Examples
Input
4 4
5 2 4 1
Output
3
Input
3 20
199 41 299
Output
19
Note
In the first example you can choose a sequence b = {1, 2}, so the sum <image> is equal to 7 (and that's 3 after taking it modulo 4).
In the second example you can choose a sequence b = {3}. | instruction | 0 | 51,847 | 12 | 103,694 |
Tags: bitmasks, divide and conquer, meet-in-the-middle
Correct Solution:
```
n, m = map(int, input().split())
A = list(map(int, input().split()))
p = n//2
q = n-p
B = A[0:p]
C = A[p:n]
S = []
for i in range(2**p):
s = 0
for j in range(p):
if (i >> j) & 1:
s += B[j]
s %= m
S.append(s)
T = []
for i in range(2**q):
t = 0
for j in range(q):
if (i >> j) & 1:
t += C[j]
t %= m
T.append(t)
T.sort()
ans = -1
import bisect
for s in S:
idx = bisect.bisect_right(T, m-1-s)
if idx != 0:
ans = max(ans, max((s+T[idx-1])%m, (s+T[-1])%m))
else:
ans = max(ans, (s+T[-1])%m)
print(ans)
``` | output | 1 | 51,847 | 12 | 103,695 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers, and additionally an integer m. You have to choose some sequence of indices b1, b2, ..., bk (1 ≤ b1 < b2 < ... < bk ≤ n) in such a way that the value of <image> is maximized. Chosen sequence can be empty.
Print the maximum possible value of <image>.
Input
The first line contains two integers n and m (1 ≤ n ≤ 35, 1 ≤ m ≤ 109).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
Print the maximum possible value of <image>.
Examples
Input
4 4
5 2 4 1
Output
3
Input
3 20
199 41 299
Output
19
Note
In the first example you can choose a sequence b = {1, 2}, so the sum <image> is equal to 7 (and that's 3 after taking it modulo 4).
In the second example you can choose a sequence b = {3}. | instruction | 0 | 51,848 | 12 | 103,696 |
Tags: bitmasks, divide and conquer, meet-in-the-middle
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
def gen(x,m):
bt = []
for i in range(len(x)):
for xx in range(len(bt)):
bt.append((bt[xx]+x[i])%m)
bt.append(x[i]%m)
return sorted(set(bt))
def main():
n,m = map(int,input().split())
arr = list(map(int,input().split()))
if n == 1:
print(arr[0]%m)
exit()
a = gen(arr[n//2:],m)
b = gen(arr[:n//2],m)
ans = max((a[-1]+b[-1])%m,a[-1]%m,b[-1]%m)
j = len(b)-1
for i in range(len(a)):
ans = max(ans,(a[i]+b[j])%m)
while j != -1 and a[i]+b[j] >= m:
j -= 1
ans = max(ans,(a[i]+b[j])%m)
if j == -1:
break
print(ans)
#Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == '__main__':
main()
``` | output | 1 | 51,848 | 12 | 103,697 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers, and additionally an integer m. You have to choose some sequence of indices b1, b2, ..., bk (1 ≤ b1 < b2 < ... < bk ≤ n) in such a way that the value of <image> is maximized. Chosen sequence can be empty.
Print the maximum possible value of <image>.
Input
The first line contains two integers n and m (1 ≤ n ≤ 35, 1 ≤ m ≤ 109).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
Print the maximum possible value of <image>.
Examples
Input
4 4
5 2 4 1
Output
3
Input
3 20
199 41 299
Output
19
Note
In the first example you can choose a sequence b = {1, 2}, so the sum <image> is equal to 7 (and that's 3 after taking it modulo 4).
In the second example you can choose a sequence b = {3}. | instruction | 0 | 51,849 | 12 | 103,698 |
Tags: bitmasks, divide and conquer, meet-in-the-middle
Correct Solution:
```
def Anal(A, i, r, m, S):
if i == len(A):
S.add(r)
else:
Anal(A, i+1, (r+A[i])%m, m, S)
Anal(A, i+1, r, m, S)
n, m = map(int, input().split())
A = list(map(int, input().split()))
x = set()
y = set()
Anal(A[:n//2], 0, 0, m, x)
Anal(A[n//2:], 0, 0, m, y)
x = sorted(x)
y = sorted(y)
import bisect
print(max(i+y[bisect.bisect_left(y,m-i)-1] for i in x))
``` | output | 1 | 51,849 | 12 | 103,699 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array d_1, d_2, ..., d_n consisting of n integer numbers.
Your task is to split this array into three parts (some of which may be empty) in such a way that each element of the array belongs to exactly one of the three parts, and each of the parts forms a consecutive contiguous subsegment (possibly, empty) of the original array.
Let the sum of elements of the first part be sum_1, the sum of elements of the second part be sum_2 and the sum of elements of the third part be sum_3. Among all possible ways to split the array you have to choose a way such that sum_1 = sum_3 and sum_1 is maximum possible.
More formally, if the first part of the array contains a elements, the second part of the array contains b elements and the third part contains c elements, then:
$$$sum_1 = ∑_{1 ≤ i ≤ a}d_i, sum_2 = ∑_{a + 1 ≤ i ≤ a + b}d_i, sum_3 = ∑_{a + b + 1 ≤ i ≤ a + b + c}d_i.$$$
The sum of an empty array is 0.
Your task is to find a way to split the array such that sum_1 = sum_3 and sum_1 is maximum possible.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array d.
The second line of the input contains n integers d_1, d_2, ..., d_n (1 ≤ d_i ≤ 10^9) — the elements of the array d.
Output
Print a single integer — the maximum possible value of sum_1, considering that the condition sum_1 = sum_3 must be met.
Obviously, at least one valid way to split the array exists (use a=c=0 and b=n).
Examples
Input
5
1 3 1 1 4
Output
5
Input
5
1 3 2 1 4
Output
4
Input
3
4 1 2
Output
0
Note
In the first example there is only one possible splitting which maximizes sum_1: [1, 3, 1], [~], [1, 4].
In the second example the only way to have sum_1=4 is: [1, 3], [2, 1], [4].
In the third example there is only one way to split the array: [~], [4, 1, 2], [~]. | instruction | 0 | 52,170 | 12 | 104,340 |
Tags: binary search, data structures, two pointers
Correct Solution:
```
n = int(input())
List = [int(x) for x in input().split()]
left = 0
right = n-1
Max = 0
SumLeft = List[0]
SumRight = List[n-1]
while(left<right):
if(SumLeft<SumRight):
left+=1
SumLeft+=List[left]
elif(SumLeft==SumRight):
Max = SumLeft
left+=1
right-=1
SumLeft+=List[left]
SumRight+=List[right]
else:
right-=1
SumRight+=List[right]
print(Max)
``` | output | 1 | 52,170 | 12 | 104,341 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array d_1, d_2, ..., d_n consisting of n integer numbers.
Your task is to split this array into three parts (some of which may be empty) in such a way that each element of the array belongs to exactly one of the three parts, and each of the parts forms a consecutive contiguous subsegment (possibly, empty) of the original array.
Let the sum of elements of the first part be sum_1, the sum of elements of the second part be sum_2 and the sum of elements of the third part be sum_3. Among all possible ways to split the array you have to choose a way such that sum_1 = sum_3 and sum_1 is maximum possible.
More formally, if the first part of the array contains a elements, the second part of the array contains b elements and the third part contains c elements, then:
$$$sum_1 = ∑_{1 ≤ i ≤ a}d_i, sum_2 = ∑_{a + 1 ≤ i ≤ a + b}d_i, sum_3 = ∑_{a + b + 1 ≤ i ≤ a + b + c}d_i.$$$
The sum of an empty array is 0.
Your task is to find a way to split the array such that sum_1 = sum_3 and sum_1 is maximum possible.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array d.
The second line of the input contains n integers d_1, d_2, ..., d_n (1 ≤ d_i ≤ 10^9) — the elements of the array d.
Output
Print a single integer — the maximum possible value of sum_1, considering that the condition sum_1 = sum_3 must be met.
Obviously, at least one valid way to split the array exists (use a=c=0 and b=n).
Examples
Input
5
1 3 1 1 4
Output
5
Input
5
1 3 2 1 4
Output
4
Input
3
4 1 2
Output
0
Note
In the first example there is only one possible splitting which maximizes sum_1: [1, 3, 1], [~], [1, 4].
In the second example the only way to have sum_1=4 is: [1, 3], [2, 1], [4].
In the third example there is only one way to split the array: [~], [4, 1, 2], [~]. | instruction | 0 | 52,171 | 12 | 104,342 |
Tags: binary search, data structures, two pointers
Correct Solution:
```
def mi():
return map(int, input().split())
n = int(input())
a = list(mi())
i1 = 0
i2 = n-1
cand = []
s1 = s2 = 0
s1 += a[i1]
s2 += a[i2]
while i1<i2:
if s1==s2:
cand.append(s1)
i1+=1
i2-=1
if i1==n or i2==-1:
break
s1 += a[i1]
s2 += a[i2]
elif s1<s2:
i1+=1
if i1==n or i2==-1:
break
s1 += a[i1]
else:
i2-=1
if i1==n or i2==-1:
break
s2 += a[i2]
if len(cand):
print (cand[-1])
else:
print (0)
``` | output | 1 | 52,171 | 12 | 104,343 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array d_1, d_2, ..., d_n consisting of n integer numbers.
Your task is to split this array into three parts (some of which may be empty) in such a way that each element of the array belongs to exactly one of the three parts, and each of the parts forms a consecutive contiguous subsegment (possibly, empty) of the original array.
Let the sum of elements of the first part be sum_1, the sum of elements of the second part be sum_2 and the sum of elements of the third part be sum_3. Among all possible ways to split the array you have to choose a way such that sum_1 = sum_3 and sum_1 is maximum possible.
More formally, if the first part of the array contains a elements, the second part of the array contains b elements and the third part contains c elements, then:
$$$sum_1 = ∑_{1 ≤ i ≤ a}d_i, sum_2 = ∑_{a + 1 ≤ i ≤ a + b}d_i, sum_3 = ∑_{a + b + 1 ≤ i ≤ a + b + c}d_i.$$$
The sum of an empty array is 0.
Your task is to find a way to split the array such that sum_1 = sum_3 and sum_1 is maximum possible.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array d.
The second line of the input contains n integers d_1, d_2, ..., d_n (1 ≤ d_i ≤ 10^9) — the elements of the array d.
Output
Print a single integer — the maximum possible value of sum_1, considering that the condition sum_1 = sum_3 must be met.
Obviously, at least one valid way to split the array exists (use a=c=0 and b=n).
Examples
Input
5
1 3 1 1 4
Output
5
Input
5
1 3 2 1 4
Output
4
Input
3
4 1 2
Output
0
Note
In the first example there is only one possible splitting which maximizes sum_1: [1, 3, 1], [~], [1, 4].
In the second example the only way to have sum_1=4 is: [1, 3], [2, 1], [4].
In the third example there is only one way to split the array: [~], [4, 1, 2], [~]. | instruction | 0 | 52,172 | 12 | 104,344 |
Tags: binary search, data structures, two pointers
Correct Solution:
```
n = int(input())
d = [int(x) for x in input().split()]
if n==1:
print("0")
else:
i = 1
j = n-2
sl = d[0]
sr = d[n-1]
while(i<=j):
if sl>sr:
sr += d[j]
j -= 1
else:
sl += d[i]
i += 1
temp = i
i = j
j = temp
if sl == sr:
print(sl)
else:
while(sl!=sr and i>-1 and j<n):
if sl>sr:
sl -= d[i]
i -= 1
else:
sr -= d[j]
j += 1
if (i>-1 and j<n):
print(sl)
else:
print("0")
``` | output | 1 | 52,172 | 12 | 104,345 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array d_1, d_2, ..., d_n consisting of n integer numbers.
Your task is to split this array into three parts (some of which may be empty) in such a way that each element of the array belongs to exactly one of the three parts, and each of the parts forms a consecutive contiguous subsegment (possibly, empty) of the original array.
Let the sum of elements of the first part be sum_1, the sum of elements of the second part be sum_2 and the sum of elements of the third part be sum_3. Among all possible ways to split the array you have to choose a way such that sum_1 = sum_3 and sum_1 is maximum possible.
More formally, if the first part of the array contains a elements, the second part of the array contains b elements and the third part contains c elements, then:
$$$sum_1 = ∑_{1 ≤ i ≤ a}d_i, sum_2 = ∑_{a + 1 ≤ i ≤ a + b}d_i, sum_3 = ∑_{a + b + 1 ≤ i ≤ a + b + c}d_i.$$$
The sum of an empty array is 0.
Your task is to find a way to split the array such that sum_1 = sum_3 and sum_1 is maximum possible.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array d.
The second line of the input contains n integers d_1, d_2, ..., d_n (1 ≤ d_i ≤ 10^9) — the elements of the array d.
Output
Print a single integer — the maximum possible value of sum_1, considering that the condition sum_1 = sum_3 must be met.
Obviously, at least one valid way to split the array exists (use a=c=0 and b=n).
Examples
Input
5
1 3 1 1 4
Output
5
Input
5
1 3 2 1 4
Output
4
Input
3
4 1 2
Output
0
Note
In the first example there is only one possible splitting which maximizes sum_1: [1, 3, 1], [~], [1, 4].
In the second example the only way to have sum_1=4 is: [1, 3], [2, 1], [4].
In the third example there is only one way to split the array: [~], [4, 1, 2], [~]. | instruction | 0 | 52,173 | 12 | 104,346 |
Tags: binary search, data structures, two pointers
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
s1 = 0; s2 = 0; r = n; res = 0
for l in range(n):
s1 += a[l]
while s2 < s1 and r > 0:
r -= 1
s2 += a[r]
if s1 == s2 and l < r:
res = max(res, s1)
print(res)
``` | output | 1 | 52,173 | 12 | 104,347 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array d_1, d_2, ..., d_n consisting of n integer numbers.
Your task is to split this array into three parts (some of which may be empty) in such a way that each element of the array belongs to exactly one of the three parts, and each of the parts forms a consecutive contiguous subsegment (possibly, empty) of the original array.
Let the sum of elements of the first part be sum_1, the sum of elements of the second part be sum_2 and the sum of elements of the third part be sum_3. Among all possible ways to split the array you have to choose a way such that sum_1 = sum_3 and sum_1 is maximum possible.
More formally, if the first part of the array contains a elements, the second part of the array contains b elements and the third part contains c elements, then:
$$$sum_1 = ∑_{1 ≤ i ≤ a}d_i, sum_2 = ∑_{a + 1 ≤ i ≤ a + b}d_i, sum_3 = ∑_{a + b + 1 ≤ i ≤ a + b + c}d_i.$$$
The sum of an empty array is 0.
Your task is to find a way to split the array such that sum_1 = sum_3 and sum_1 is maximum possible.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array d.
The second line of the input contains n integers d_1, d_2, ..., d_n (1 ≤ d_i ≤ 10^9) — the elements of the array d.
Output
Print a single integer — the maximum possible value of sum_1, considering that the condition sum_1 = sum_3 must be met.
Obviously, at least one valid way to split the array exists (use a=c=0 and b=n).
Examples
Input
5
1 3 1 1 4
Output
5
Input
5
1 3 2 1 4
Output
4
Input
3
4 1 2
Output
0
Note
In the first example there is only one possible splitting which maximizes sum_1: [1, 3, 1], [~], [1, 4].
In the second example the only way to have sum_1=4 is: [1, 3], [2, 1], [4].
In the third example there is only one way to split the array: [~], [4, 1, 2], [~]. | instruction | 0 | 52,174 | 12 | 104,348 |
Tags: binary search, data structures, two pointers
Correct Solution:
```
length = int(input())
numbers = list(map(int, input().split(' ')))
lastResult = 0
sum1, sum3 = 0, 0
i1, i3 = 0, length-1
while True:
if i1 > i3:
break
if sum1 < sum3:
sum1 += numbers[i1]
i1 += 1
elif sum1 > sum3:
sum3 += numbers[i3]
i3 -= 1
else:
lastResult = sum1
sum1 += numbers[i1]
i1 += 1
print(sum1 if sum1 == sum3 else lastResult)
``` | output | 1 | 52,174 | 12 | 104,349 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array d_1, d_2, ..., d_n consisting of n integer numbers.
Your task is to split this array into three parts (some of which may be empty) in such a way that each element of the array belongs to exactly one of the three parts, and each of the parts forms a consecutive contiguous subsegment (possibly, empty) of the original array.
Let the sum of elements of the first part be sum_1, the sum of elements of the second part be sum_2 and the sum of elements of the third part be sum_3. Among all possible ways to split the array you have to choose a way such that sum_1 = sum_3 and sum_1 is maximum possible.
More formally, if the first part of the array contains a elements, the second part of the array contains b elements and the third part contains c elements, then:
$$$sum_1 = ∑_{1 ≤ i ≤ a}d_i, sum_2 = ∑_{a + 1 ≤ i ≤ a + b}d_i, sum_3 = ∑_{a + b + 1 ≤ i ≤ a + b + c}d_i.$$$
The sum of an empty array is 0.
Your task is to find a way to split the array such that sum_1 = sum_3 and sum_1 is maximum possible.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array d.
The second line of the input contains n integers d_1, d_2, ..., d_n (1 ≤ d_i ≤ 10^9) — the elements of the array d.
Output
Print a single integer — the maximum possible value of sum_1, considering that the condition sum_1 = sum_3 must be met.
Obviously, at least one valid way to split the array exists (use a=c=0 and b=n).
Examples
Input
5
1 3 1 1 4
Output
5
Input
5
1 3 2 1 4
Output
4
Input
3
4 1 2
Output
0
Note
In the first example there is only one possible splitting which maximizes sum_1: [1, 3, 1], [~], [1, 4].
In the second example the only way to have sum_1=4 is: [1, 3], [2, 1], [4].
In the third example there is only one way to split the array: [~], [4, 1, 2], [~]. | instruction | 0 | 52,175 | 12 | 104,350 |
Tags: binary search, data structures, two pointers
Correct Solution:
```
x=int(input())
a=list(map(int,input().split()))
#a.sort()
k=0
i=0
j=x-1
lol=a[i]
yo=a[j]
while i<j:
#print(yo,lol,i,j)
if lol==yo:
k=max(k,yo)
i+=1
j-=1
yo+=a[j]
lol+=a[i]
elif lol>yo:
j-=1
yo+=a[j]
else:
i+=1
lol+=a[i]
print(k)
``` | output | 1 | 52,175 | 12 | 104,351 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array d_1, d_2, ..., d_n consisting of n integer numbers.
Your task is to split this array into three parts (some of which may be empty) in such a way that each element of the array belongs to exactly one of the three parts, and each of the parts forms a consecutive contiguous subsegment (possibly, empty) of the original array.
Let the sum of elements of the first part be sum_1, the sum of elements of the second part be sum_2 and the sum of elements of the third part be sum_3. Among all possible ways to split the array you have to choose a way such that sum_1 = sum_3 and sum_1 is maximum possible.
More formally, if the first part of the array contains a elements, the second part of the array contains b elements and the third part contains c elements, then:
$$$sum_1 = ∑_{1 ≤ i ≤ a}d_i, sum_2 = ∑_{a + 1 ≤ i ≤ a + b}d_i, sum_3 = ∑_{a + b + 1 ≤ i ≤ a + b + c}d_i.$$$
The sum of an empty array is 0.
Your task is to find a way to split the array such that sum_1 = sum_3 and sum_1 is maximum possible.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array d.
The second line of the input contains n integers d_1, d_2, ..., d_n (1 ≤ d_i ≤ 10^9) — the elements of the array d.
Output
Print a single integer — the maximum possible value of sum_1, considering that the condition sum_1 = sum_3 must be met.
Obviously, at least one valid way to split the array exists (use a=c=0 and b=n).
Examples
Input
5
1 3 1 1 4
Output
5
Input
5
1 3 2 1 4
Output
4
Input
3
4 1 2
Output
0
Note
In the first example there is only one possible splitting which maximizes sum_1: [1, 3, 1], [~], [1, 4].
In the second example the only way to have sum_1=4 is: [1, 3], [2, 1], [4].
In the third example there is only one way to split the array: [~], [4, 1, 2], [~]. | instruction | 0 | 52,176 | 12 | 104,352 |
Tags: binary search, data structures, two pointers
Correct Solution:
```
n=int(input())
l=[int (x) for x in input().split()]
ki=0
b=0
j=1
s1=0
s2=0
while b+j<=n:
if s1<s2:
s1+=l[b]
b+=1
else:
s2+=l[-j]
j+=1
if s1==s2:
ki=s1
print(ki)
``` | output | 1 | 52,176 | 12 | 104,353 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array d_1, d_2, ..., d_n consisting of n integer numbers.
Your task is to split this array into three parts (some of which may be empty) in such a way that each element of the array belongs to exactly one of the three parts, and each of the parts forms a consecutive contiguous subsegment (possibly, empty) of the original array.
Let the sum of elements of the first part be sum_1, the sum of elements of the second part be sum_2 and the sum of elements of the third part be sum_3. Among all possible ways to split the array you have to choose a way such that sum_1 = sum_3 and sum_1 is maximum possible.
More formally, if the first part of the array contains a elements, the second part of the array contains b elements and the third part contains c elements, then:
$$$sum_1 = ∑_{1 ≤ i ≤ a}d_i, sum_2 = ∑_{a + 1 ≤ i ≤ a + b}d_i, sum_3 = ∑_{a + b + 1 ≤ i ≤ a + b + c}d_i.$$$
The sum of an empty array is 0.
Your task is to find a way to split the array such that sum_1 = sum_3 and sum_1 is maximum possible.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array d.
The second line of the input contains n integers d_1, d_2, ..., d_n (1 ≤ d_i ≤ 10^9) — the elements of the array d.
Output
Print a single integer — the maximum possible value of sum_1, considering that the condition sum_1 = sum_3 must be met.
Obviously, at least one valid way to split the array exists (use a=c=0 and b=n).
Examples
Input
5
1 3 1 1 4
Output
5
Input
5
1 3 2 1 4
Output
4
Input
3
4 1 2
Output
0
Note
In the first example there is only one possible splitting which maximizes sum_1: [1, 3, 1], [~], [1, 4].
In the second example the only way to have sum_1=4 is: [1, 3], [2, 1], [4].
In the third example there is only one way to split the array: [~], [4, 1, 2], [~]. | instruction | 0 | 52,177 | 12 | 104,354 |
Tags: binary search, data structures, two pointers
Correct Solution:
```
n=int(input())
a=[int(x) for x in input().split()]
s=0
a1=[]
for i in range(n):
s+=a[i]
a1.append(s)
a=a[::-1]
s=0
a2=[]
for i in range(n):
s+=a[i]
a2.append(s)
a2=a2[::-1]
#print(a1,a2)
d={}
for i in a2:
d[i]=[]
for i in range(n):
d[a2[i]].append(i)
ss=set(a2)
ans=0
for i in range(n):
if(a1[i] in ss):
if(d[a1[i]][-1]>i):
ans=a1[i]
print(ans)
``` | output | 1 | 52,177 | 12 | 104,355 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array d_1, d_2, ..., d_n consisting of n integer numbers.
Your task is to split this array into three parts (some of which may be empty) in such a way that each element of the array belongs to exactly one of the three parts, and each of the parts forms a consecutive contiguous subsegment (possibly, empty) of the original array.
Let the sum of elements of the first part be sum_1, the sum of elements of the second part be sum_2 and the sum of elements of the third part be sum_3. Among all possible ways to split the array you have to choose a way such that sum_1 = sum_3 and sum_1 is maximum possible.
More formally, if the first part of the array contains a elements, the second part of the array contains b elements and the third part contains c elements, then:
$$$sum_1 = ∑_{1 ≤ i ≤ a}d_i, sum_2 = ∑_{a + 1 ≤ i ≤ a + b}d_i, sum_3 = ∑_{a + b + 1 ≤ i ≤ a + b + c}d_i.$$$
The sum of an empty array is 0.
Your task is to find a way to split the array such that sum_1 = sum_3 and sum_1 is maximum possible.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array d.
The second line of the input contains n integers d_1, d_2, ..., d_n (1 ≤ d_i ≤ 10^9) — the elements of the array d.
Output
Print a single integer — the maximum possible value of sum_1, considering that the condition sum_1 = sum_3 must be met.
Obviously, at least one valid way to split the array exists (use a=c=0 and b=n).
Examples
Input
5
1 3 1 1 4
Output
5
Input
5
1 3 2 1 4
Output
4
Input
3
4 1 2
Output
0
Note
In the first example there is only one possible splitting which maximizes sum_1: [1, 3, 1], [~], [1, 4].
In the second example the only way to have sum_1=4 is: [1, 3], [2, 1], [4].
In the third example there is only one way to split the array: [~], [4, 1, 2], [~].
Submitted Solution:
```
n = int(input())
nums = list(map(int, input().split()))
l, r = -1, n
suma, sumb = 0, 0
res = 0
while l < r:
if suma < sumb:
l += 1
suma += nums[l]
elif suma > sumb:
r -= 1
sumb += nums[r]
else:
l += 1
r -= 1
res = suma
suma += nums[l]
sumb += nums[r]
print(res)
``` | instruction | 0 | 52,178 | 12 | 104,356 |
Yes | output | 1 | 52,178 | 12 | 104,357 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array d_1, d_2, ..., d_n consisting of n integer numbers.
Your task is to split this array into three parts (some of which may be empty) in such a way that each element of the array belongs to exactly one of the three parts, and each of the parts forms a consecutive contiguous subsegment (possibly, empty) of the original array.
Let the sum of elements of the first part be sum_1, the sum of elements of the second part be sum_2 and the sum of elements of the third part be sum_3. Among all possible ways to split the array you have to choose a way such that sum_1 = sum_3 and sum_1 is maximum possible.
More formally, if the first part of the array contains a elements, the second part of the array contains b elements and the third part contains c elements, then:
$$$sum_1 = ∑_{1 ≤ i ≤ a}d_i, sum_2 = ∑_{a + 1 ≤ i ≤ a + b}d_i, sum_3 = ∑_{a + b + 1 ≤ i ≤ a + b + c}d_i.$$$
The sum of an empty array is 0.
Your task is to find a way to split the array such that sum_1 = sum_3 and sum_1 is maximum possible.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array d.
The second line of the input contains n integers d_1, d_2, ..., d_n (1 ≤ d_i ≤ 10^9) — the elements of the array d.
Output
Print a single integer — the maximum possible value of sum_1, considering that the condition sum_1 = sum_3 must be met.
Obviously, at least one valid way to split the array exists (use a=c=0 and b=n).
Examples
Input
5
1 3 1 1 4
Output
5
Input
5
1 3 2 1 4
Output
4
Input
3
4 1 2
Output
0
Note
In the first example there is only one possible splitting which maximizes sum_1: [1, 3, 1], [~], [1, 4].
In the second example the only way to have sum_1=4 is: [1, 3], [2, 1], [4].
In the third example there is only one way to split the array: [~], [4, 1, 2], [~].
Submitted Solution:
```
n = int(input())
A = list(map(int,input().split()))
t = -1
p = len(A)
x = len(A)
S = 0
S1 = 0
for i in range(len(A)-1):
S += A[i]
while S1 < S and x > i:
S1 += A[x-1]
x -= 1
if S1 > S:
S1 -= A[x]
x += 1
elif S1 == S:
if i < x:
t = i
z = 0
for i in range(t+1):
z += A[i]
print(z)
``` | instruction | 0 | 52,179 | 12 | 104,358 |
Yes | output | 1 | 52,179 | 12 | 104,359 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array d_1, d_2, ..., d_n consisting of n integer numbers.
Your task is to split this array into three parts (some of which may be empty) in such a way that each element of the array belongs to exactly one of the three parts, and each of the parts forms a consecutive contiguous subsegment (possibly, empty) of the original array.
Let the sum of elements of the first part be sum_1, the sum of elements of the second part be sum_2 and the sum of elements of the third part be sum_3. Among all possible ways to split the array you have to choose a way such that sum_1 = sum_3 and sum_1 is maximum possible.
More formally, if the first part of the array contains a elements, the second part of the array contains b elements and the third part contains c elements, then:
$$$sum_1 = ∑_{1 ≤ i ≤ a}d_i, sum_2 = ∑_{a + 1 ≤ i ≤ a + b}d_i, sum_3 = ∑_{a + b + 1 ≤ i ≤ a + b + c}d_i.$$$
The sum of an empty array is 0.
Your task is to find a way to split the array such that sum_1 = sum_3 and sum_1 is maximum possible.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array d.
The second line of the input contains n integers d_1, d_2, ..., d_n (1 ≤ d_i ≤ 10^9) — the elements of the array d.
Output
Print a single integer — the maximum possible value of sum_1, considering that the condition sum_1 = sum_3 must be met.
Obviously, at least one valid way to split the array exists (use a=c=0 and b=n).
Examples
Input
5
1 3 1 1 4
Output
5
Input
5
1 3 2 1 4
Output
4
Input
3
4 1 2
Output
0
Note
In the first example there is only one possible splitting which maximizes sum_1: [1, 3, 1], [~], [1, 4].
In the second example the only way to have sum_1=4 is: [1, 3], [2, 1], [4].
In the third example there is only one way to split the array: [~], [4, 1, 2], [~].
Submitted Solution:
```
n = int(input().strip())
a = [int(x) for x in input().strip().split(' ')]
i = 0
j = n-1
s1 = a[i]
s2 = a[j]
ans = 0
while (i+n-j)<(n):
if (s1==s2):
ans=s1
i+=1
s1+=a[i]
elif s1<s2:
i+=1
s1+=a[i]
else:
j-=1
s2+=a[j]
print(ans)
``` | instruction | 0 | 52,180 | 12 | 104,360 |
Yes | output | 1 | 52,180 | 12 | 104,361 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array d_1, d_2, ..., d_n consisting of n integer numbers.
Your task is to split this array into three parts (some of which may be empty) in such a way that each element of the array belongs to exactly one of the three parts, and each of the parts forms a consecutive contiguous subsegment (possibly, empty) of the original array.
Let the sum of elements of the first part be sum_1, the sum of elements of the second part be sum_2 and the sum of elements of the third part be sum_3. Among all possible ways to split the array you have to choose a way such that sum_1 = sum_3 and sum_1 is maximum possible.
More formally, if the first part of the array contains a elements, the second part of the array contains b elements and the third part contains c elements, then:
$$$sum_1 = ∑_{1 ≤ i ≤ a}d_i, sum_2 = ∑_{a + 1 ≤ i ≤ a + b}d_i, sum_3 = ∑_{a + b + 1 ≤ i ≤ a + b + c}d_i.$$$
The sum of an empty array is 0.
Your task is to find a way to split the array such that sum_1 = sum_3 and sum_1 is maximum possible.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array d.
The second line of the input contains n integers d_1, d_2, ..., d_n (1 ≤ d_i ≤ 10^9) — the elements of the array d.
Output
Print a single integer — the maximum possible value of sum_1, considering that the condition sum_1 = sum_3 must be met.
Obviously, at least one valid way to split the array exists (use a=c=0 and b=n).
Examples
Input
5
1 3 1 1 4
Output
5
Input
5
1 3 2 1 4
Output
4
Input
3
4 1 2
Output
0
Note
In the first example there is only one possible splitting which maximizes sum_1: [1, 3, 1], [~], [1, 4].
In the second example the only way to have sum_1=4 is: [1, 3], [2, 1], [4].
In the third example there is only one way to split the array: [~], [4, 1, 2], [~].
Submitted Solution:
```
tam = int(input())
inteiros = [*map(int, input().split())]
p1 = 0
p2 = tam - 1
maximoAcumulado = 0
acc1 = inteiros[p1]
acc3 = inteiros[p2]
while (p1 < p2):
if (acc1 < acc3):
p1 += 1
acc1 += inteiros[p1]
elif (acc1 > acc3):
p2 -= 1
acc3 += inteiros[p2]
else:
if (acc1 > maximoAcumulado):
maximoAcumulado = acc1
p1 += 1
p2 -= 1
acc1 += inteiros[p1]
acc3 += inteiros[p2]
print(maximoAcumulado)
'''
Input
5
1 3 1 1 4
Output
5
Input
5
1 3 2 1 4
Output
4
Input
3
4 1 2
Output
0
'''
``` | instruction | 0 | 52,181 | 12 | 104,362 |
Yes | output | 1 | 52,181 | 12 | 104,363 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array d_1, d_2, ..., d_n consisting of n integer numbers.
Your task is to split this array into three parts (some of which may be empty) in such a way that each element of the array belongs to exactly one of the three parts, and each of the parts forms a consecutive contiguous subsegment (possibly, empty) of the original array.
Let the sum of elements of the first part be sum_1, the sum of elements of the second part be sum_2 and the sum of elements of the third part be sum_3. Among all possible ways to split the array you have to choose a way such that sum_1 = sum_3 and sum_1 is maximum possible.
More formally, if the first part of the array contains a elements, the second part of the array contains b elements and the third part contains c elements, then:
$$$sum_1 = ∑_{1 ≤ i ≤ a}d_i, sum_2 = ∑_{a + 1 ≤ i ≤ a + b}d_i, sum_3 = ∑_{a + b + 1 ≤ i ≤ a + b + c}d_i.$$$
The sum of an empty array is 0.
Your task is to find a way to split the array such that sum_1 = sum_3 and sum_1 is maximum possible.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array d.
The second line of the input contains n integers d_1, d_2, ..., d_n (1 ≤ d_i ≤ 10^9) — the elements of the array d.
Output
Print a single integer — the maximum possible value of sum_1, considering that the condition sum_1 = sum_3 must be met.
Obviously, at least one valid way to split the array exists (use a=c=0 and b=n).
Examples
Input
5
1 3 1 1 4
Output
5
Input
5
1 3 2 1 4
Output
4
Input
3
4 1 2
Output
0
Note
In the first example there is only one possible splitting which maximizes sum_1: [1, 3, 1], [~], [1, 4].
In the second example the only way to have sum_1=4 is: [1, 3], [2, 1], [4].
In the third example there is only one way to split the array: [~], [4, 1, 2], [~].
Submitted Solution:
```
n = int(input())
arr = list(map(int, input().split()))
s1, s2 = 0, 0
i, j = 0, n - 1
while i < n and i <= j:
s1 += arr[i]
while s2 < s1 and j > i:
s2 += arr[j]
j -= 1
i += 1
print(s1)
``` | instruction | 0 | 52,182 | 12 | 104,364 |
No | output | 1 | 52,182 | 12 | 104,365 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array d_1, d_2, ..., d_n consisting of n integer numbers.
Your task is to split this array into three parts (some of which may be empty) in such a way that each element of the array belongs to exactly one of the three parts, and each of the parts forms a consecutive contiguous subsegment (possibly, empty) of the original array.
Let the sum of elements of the first part be sum_1, the sum of elements of the second part be sum_2 and the sum of elements of the third part be sum_3. Among all possible ways to split the array you have to choose a way such that sum_1 = sum_3 and sum_1 is maximum possible.
More formally, if the first part of the array contains a elements, the second part of the array contains b elements and the third part contains c elements, then:
$$$sum_1 = ∑_{1 ≤ i ≤ a}d_i, sum_2 = ∑_{a + 1 ≤ i ≤ a + b}d_i, sum_3 = ∑_{a + b + 1 ≤ i ≤ a + b + c}d_i.$$$
The sum of an empty array is 0.
Your task is to find a way to split the array such that sum_1 = sum_3 and sum_1 is maximum possible.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array d.
The second line of the input contains n integers d_1, d_2, ..., d_n (1 ≤ d_i ≤ 10^9) — the elements of the array d.
Output
Print a single integer — the maximum possible value of sum_1, considering that the condition sum_1 = sum_3 must be met.
Obviously, at least one valid way to split the array exists (use a=c=0 and b=n).
Examples
Input
5
1 3 1 1 4
Output
5
Input
5
1 3 2 1 4
Output
4
Input
3
4 1 2
Output
0
Note
In the first example there is only one possible splitting which maximizes sum_1: [1, 3, 1], [~], [1, 4].
In the second example the only way to have sum_1=4 is: [1, 3], [2, 1], [4].
In the third example there is only one way to split the array: [~], [4, 1, 2], [~].
Submitted Solution:
```
#####################################
import atexit, io, sys, collections, math, heapq, fractions,copy, os, functools
import sys
import random
import collections
from io import BytesIO, IOBase
##################################### python 3 START
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")
##################################### python 3 END
n = int(input())
ais = list(map(int, input().split()))
inf = - 10 ** 9
inf *= 10
h = {}
suf = 0
for j in range(len(ais)-1,-1,-1):
suf += ais[j]
if j not in h:
h[suf] = j
ans = 0
pre = 0
for i in range(len(ais)):
pre += ais[i]
if pre in h and h[pre] > i:
ans = max(ans, pre)
print(ans)
``` | instruction | 0 | 52,183 | 12 | 104,366 |
No | output | 1 | 52,183 | 12 | 104,367 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array d_1, d_2, ..., d_n consisting of n integer numbers.
Your task is to split this array into three parts (some of which may be empty) in such a way that each element of the array belongs to exactly one of the three parts, and each of the parts forms a consecutive contiguous subsegment (possibly, empty) of the original array.
Let the sum of elements of the first part be sum_1, the sum of elements of the second part be sum_2 and the sum of elements of the third part be sum_3. Among all possible ways to split the array you have to choose a way such that sum_1 = sum_3 and sum_1 is maximum possible.
More formally, if the first part of the array contains a elements, the second part of the array contains b elements and the third part contains c elements, then:
$$$sum_1 = ∑_{1 ≤ i ≤ a}d_i, sum_2 = ∑_{a + 1 ≤ i ≤ a + b}d_i, sum_3 = ∑_{a + b + 1 ≤ i ≤ a + b + c}d_i.$$$
The sum of an empty array is 0.
Your task is to find a way to split the array such that sum_1 = sum_3 and sum_1 is maximum possible.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array d.
The second line of the input contains n integers d_1, d_2, ..., d_n (1 ≤ d_i ≤ 10^9) — the elements of the array d.
Output
Print a single integer — the maximum possible value of sum_1, considering that the condition sum_1 = sum_3 must be met.
Obviously, at least one valid way to split the array exists (use a=c=0 and b=n).
Examples
Input
5
1 3 1 1 4
Output
5
Input
5
1 3 2 1 4
Output
4
Input
3
4 1 2
Output
0
Note
In the first example there is only one possible splitting which maximizes sum_1: [1, 3, 1], [~], [1, 4].
In the second example the only way to have sum_1=4 is: [1, 3], [2, 1], [4].
In the third example there is only one way to split the array: [~], [4, 1, 2], [~].
Submitted Solution:
```
#DaRk DeveLopeR
import sys
#taking input as string
input = lambda: sys.stdin.readline().rstrip("\r\n")
inp = lambda: list(map(int,sys.stdin.readline().rstrip("\r\n").split()))
mod = 10**9+7; Mod = 998244353; INF = float('inf')
#______________________________________________________________________________________________________
import math
from bisect import *
from heapq import *
from collections import defaultdict as dd
from collections import OrderedDict as odict
from collections import Counter as cc
from collections import deque
from itertools import groupby
sys.setrecursionlimit(20*20*20*20+10) #this is must for dfs
#question link:-
def solve():
n=takein()
arr=takeiar()
i=sum1=sum2=0
j=n-1
index=0
while i<j:
# print(j)
if sum1>sum2:
sum2+=arr[j]
j-=1
elif sum1<sum2:
sum1+=arr[i]
i+=1
else:
index=i
sum1+=arr[i]
sum2+=arr[j]
i+=1
j-=1
# print(index,i,j)
print(sum(arr[:index]))
def main():
global tt
if not ONLINE_JUDGE:
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
t = 1
# t = takein()
#t = 1
for tt in range(1,t + 1):
solve()
if not ONLINE_JUDGE:
print("Time Elapsed :",time.time() - start_time,"seconds")
sys.stdout.close()
#---------------------- USER DEFINED INPUT FUNCTIONS ----------------------#
def takein():
return (int(sys.stdin.readline().rstrip("\r\n")))
# input the string
def takesr():
return (sys.stdin.readline().rstrip("\r\n"))
# input int array
def takeiar():
return (list(map(int, sys.stdin.readline().rstrip("\r\n").split())))
# input string array
def takesar():
return (list(map(str, sys.stdin.readline().rstrip("\r\n").split())))
# innut values for the diffrent variables
def takeivr():
return (map(int, sys.stdin.readline().rstrip("\r\n").split()))
def takesvr():
return (map(str, sys.stdin.readline().rstrip("\r\n").split()))
#------------------ USER DEFINED PROGRAMMING FUNCTIONS ------------------#
def ispalindrome(s):
return s==s[::-1]
def invert(bit_s):
# convert binary string
# into integer
temp = int(bit_s, 2)
# applying Ex-or operator
# b/w 10 and 31
inverse_s = temp ^ (2 ** (len(bit_s) + 1) - 1)
# convert the integer result
# into binary result and then
# slicing of the '0b1'
# binary indicator
rslt = bin(inverse_s)[3 : ]
return str(rslt)
def counter(a):
q = [0] * max(a)
for i in range(len(a)):
q[a[i] - 1] = q[a[i] - 1] + 1
return(q)
def counter_elements(a):
q = dict()
for i in range(len(a)):
if a[i] not in q:
q[a[i]] = 0
q[a[i]] = q[a[i]] + 1
return(q)
def string_counter(a):
q = [0] * 26
for i in range(len(a)):
q[ord(a[i]) - 97] = q[ord(a[i]) - 97] + 1
return(q)
def factorial(n,m = 1000000007):
q = 1
for i in range(n):
q = (q * (i + 1)) % m
return(q)
def factors(n):
q = []
for i in range(1,int(n ** 0.5) + 1):
if n % i == 0: q.append(i); q.append(n // i)
return(list(sorted(list(set(q)))))
def prime_factors(n):
q = []
while n % 2 == 0: q.append(2); n = n // 2
for i in range(3,int(n ** 0.5) + 1,2):
while n % i == 0: q.append(i); n = n // i
if n > 2: q.append(n)
return(list(sorted(q)))
def transpose(a):
n,m = len(a),len(a[0])
b = [[0] * n for i in range(m)]
for i in range(m):
for j in range(n):
b[i][j] = a[j][i]
return(b)
def power_two(x):
return (x and (not(x & (x - 1))))
def ceil(a, b):
return -(-a // b)
def seive(n):
a = [1]
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p ** 2,n + 1, p):
prime[i] = False
p = p + 1
for p in range(2,n + 1):
if prime[p]:
a.append(p)
return(a)
#-----------------------------------------------------------------------#
ONLINE_JUDGE = __debug__
if ONLINE_JUDGE:
input = sys.stdin.readline
main()
``` | instruction | 0 | 52,184 | 12 | 104,368 |
No | output | 1 | 52,184 | 12 | 104,369 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array d_1, d_2, ..., d_n consisting of n integer numbers.
Your task is to split this array into three parts (some of which may be empty) in such a way that each element of the array belongs to exactly one of the three parts, and each of the parts forms a consecutive contiguous subsegment (possibly, empty) of the original array.
Let the sum of elements of the first part be sum_1, the sum of elements of the second part be sum_2 and the sum of elements of the third part be sum_3. Among all possible ways to split the array you have to choose a way such that sum_1 = sum_3 and sum_1 is maximum possible.
More formally, if the first part of the array contains a elements, the second part of the array contains b elements and the third part contains c elements, then:
$$$sum_1 = ∑_{1 ≤ i ≤ a}d_i, sum_2 = ∑_{a + 1 ≤ i ≤ a + b}d_i, sum_3 = ∑_{a + b + 1 ≤ i ≤ a + b + c}d_i.$$$
The sum of an empty array is 0.
Your task is to find a way to split the array such that sum_1 = sum_3 and sum_1 is maximum possible.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array d.
The second line of the input contains n integers d_1, d_2, ..., d_n (1 ≤ d_i ≤ 10^9) — the elements of the array d.
Output
Print a single integer — the maximum possible value of sum_1, considering that the condition sum_1 = sum_3 must be met.
Obviously, at least one valid way to split the array exists (use a=c=0 and b=n).
Examples
Input
5
1 3 1 1 4
Output
5
Input
5
1 3 2 1 4
Output
4
Input
3
4 1 2
Output
0
Note
In the first example there is only one possible splitting which maximizes sum_1: [1, 3, 1], [~], [1, 4].
In the second example the only way to have sum_1=4 is: [1, 3], [2, 1], [4].
In the third example there is only one way to split the array: [~], [4, 1, 2], [~].
Submitted Solution:
```
ll=lambda:map(int,input().split())
t=lambda:int(input())
ss=lambda:input()
lx=lambda x:map(int,input().split(x))
yy=lambda:print("YES")
nn=lambda:print("NO")
from math import log10 ,log2,ceil,factorial as fac,gcd,inf
#from itertools import combinations_with_replacement as cs
#from functools import reduce
#from bisect import bisect_right as br,bisect_left as bl
#from collections import Counter
#from math import inf
#for _ in range(t()):
def f():
n=t()
a=list(ll())
i=0
j=n-1
s1,s2=0,0
ans=0
s1=a[0]
s2=a[-1]
while i<j:
if s1==s2:
ans=max(ans,s1,s2)
s1+=a[i]
s2+=a[j]
i+=1
j-=1
elif s1>s2:
s2+=a[j]
j-=1
else:
s1+=a[i]
i+=1
if s1==s2:
ans=max(ans,s2)
print(ans)
f()
'''
'''
``` | instruction | 0 | 52,185 | 12 | 104,370 |
No | output | 1 | 52,185 | 12 | 104,371 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer array a_1, a_2, ..., a_n, where a_i represents the number of blocks at the i-th position. It is guaranteed that 1 ≤ a_i ≤ n.
In one operation you can choose a subset of indices of the given array and remove one block in each of these indices. You can't remove a block from a position without blocks.
All subsets that you choose should be different (unique).
You need to remove all blocks in the array using at most n+1 operations. It can be proved that the answer always exists.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^3) — length of the given array.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — numbers of blocks at positions 1, 2, ..., n.
Output
In the first line print an integer op (0 ≤ op ≤ n+1).
In each of the following op lines, print a binary string s of length n. If s_i='0', it means that the position i is not in the chosen subset. Otherwise, s_i should be equal to '1' and the position i is in the chosen subset.
All binary strings should be distinct (unique) and a_i should be equal to the sum of s_i among all chosen binary strings.
If there are multiple possible answers, you can print any.
It can be proved that an answer always exists.
Examples
Input
5
5 5 5 5 5
Output
6
11111
01111
10111
11011
11101
11110
Input
5
5 1 1 1 1
Output
5
11000
10000
10100
10010
10001
Input
5
4 1 5 3 4
Output
5
11111
10111
10101
00111
10100
Note
In the first example, the number of blocks decrease like that:
{ 5,5,5,5,5 } → { 4,4,4,4,4 } → { 4,3,3,3,3 } → { 3,3,2,2,2 } → { 2,2,2,1,1 } → { 1,1,1,1,0 } → { 0,0,0,0,0 }. And we can note that each operation differs from others. | instruction | 0 | 52,330 | 12 | 104,660 |
Tags: constructive algorithms
Correct Solution:
```
n = int(input())
v, c = list([[0, 0]]), list()
z = ['0' for i in range(n)]
for i, x in enumerate(input().split()) : v.append([int(x), i])
v.sort(reverse=True)
def S_N_U_F_F(z, v, c) :
y, k, x, count = -1, 0, len(v)-1, len(v)-1
while v[0][0] != 0 :
if k > 0 and k < len(v)-1 : z[v[y+k][1]] = '0'
elif v[y+k][0] > 1 or v[y+k+1][0] == 0 :
v[y+k][0], z[v[y+k][1]], x = v[y+k][0]-1, '1', i
else : z[v[y+k][1]] = '0'
for i in range(0, y+k) : v[i][0], z[v[i][1]] = v[i][0]-1, '1'
for i in range(y+k+1, len(v)-1) :
if v[i][0] > 1 or (v[i][0] != 0 and v[i+1][0] == 0) :
v[i][0], z[v[i][1]], x = v[i][0]-1, '1', i
else : z[v[i][1]] = '0'
while v[y+1][0] == count and count != 0 : y, k = y+1, k-1
if v[x-1][0] == 1 or v[x][0] == 0 : k = -1
k += 1
count -= 1
c.append(''.join(z))
return len(c)
print(S_N_U_F_F(z, v, c))
print('\n'.join(c))
``` | output | 1 | 52,330 | 12 | 104,661 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer array a_1, a_2, ..., a_n, where a_i represents the number of blocks at the i-th position. It is guaranteed that 1 ≤ a_i ≤ n.
In one operation you can choose a subset of indices of the given array and remove one block in each of these indices. You can't remove a block from a position without blocks.
All subsets that you choose should be different (unique).
You need to remove all blocks in the array using at most n+1 operations. It can be proved that the answer always exists.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^3) — length of the given array.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — numbers of blocks at positions 1, 2, ..., n.
Output
In the first line print an integer op (0 ≤ op ≤ n+1).
In each of the following op lines, print a binary string s of length n. If s_i='0', it means that the position i is not in the chosen subset. Otherwise, s_i should be equal to '1' and the position i is in the chosen subset.
All binary strings should be distinct (unique) and a_i should be equal to the sum of s_i among all chosen binary strings.
If there are multiple possible answers, you can print any.
It can be proved that an answer always exists.
Examples
Input
5
5 5 5 5 5
Output
6
11111
01111
10111
11011
11101
11110
Input
5
5 1 1 1 1
Output
5
11000
10000
10100
10010
10001
Input
5
4 1 5 3 4
Output
5
11111
10111
10101
00111
10100
Note
In the first example, the number of blocks decrease like that:
{ 5,5,5,5,5 } → { 4,4,4,4,4 } → { 4,3,3,3,3 } → { 3,3,2,2,2 } → { 2,2,2,1,1 } → { 1,1,1,1,0 } → { 0,0,0,0,0 }. And we can note that each operation differs from others. | instruction | 0 | 52,331 | 12 | 104,662 |
Tags: constructive algorithms
Correct Solution:
```
import sys
n = int(input())
v, c = list(), list()
z = ['0' for i in range(n)]
for i, x in enumerate(input().split()) : v.append([int(x), i])
v.sort(reverse=True)
def predictor(v, z, index_off, index_on, n) :
global c
if n == 0 :
for i in range(len(v)) :
if v[i][0] > 0 :
v[i][0] -= 1
z[v[i][1]] = '1'
else : z[v[i][1]] = '0'
c.append(''.join(z))
return
for i in range(len(v)) :
if (index_off != i and (v[i][0] > 1 or (i == index_on and v[i][0] == 1))) :
v[i][0] -= 1
z[v[i][1]] = '1'
else : z[v[i][1]] = '0'
c.append(''.join(z))
def generator(v, z, n) :
y, x, q = -1, n-1, 0
while v[0][0] != 0 :
if v[x-1][0] == 1 or v[x][0] == 0 : y = -2
if v[x][0] == 0 : x -= 1#
if y >= 0 :
while v[y][0]-1 == n :
y += 1
q += 1
predictor(v, z, y, x, n)
if y == -2 : y = q
else : y += 1
n -= 1
return len(c)
print(generator(v, z, n))
#print('\n'.join(c))
sys.stdout.write('\n'.join(c))
``` | output | 1 | 52,331 | 12 | 104,663 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer array a_1, a_2, ..., a_n, where a_i represents the number of blocks at the i-th position. It is guaranteed that 1 ≤ a_i ≤ n.
In one operation you can choose a subset of indices of the given array and remove one block in each of these indices. You can't remove a block from a position without blocks.
All subsets that you choose should be different (unique).
You need to remove all blocks in the array using at most n+1 operations. It can be proved that the answer always exists.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^3) — length of the given array.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — numbers of blocks at positions 1, 2, ..., n.
Output
In the first line print an integer op (0 ≤ op ≤ n+1).
In each of the following op lines, print a binary string s of length n. If s_i='0', it means that the position i is not in the chosen subset. Otherwise, s_i should be equal to '1' and the position i is in the chosen subset.
All binary strings should be distinct (unique) and a_i should be equal to the sum of s_i among all chosen binary strings.
If there are multiple possible answers, you can print any.
It can be proved that an answer always exists.
Examples
Input
5
5 5 5 5 5
Output
6
11111
01111
10111
11011
11101
11110
Input
5
5 1 1 1 1
Output
5
11000
10000
10100
10010
10001
Input
5
4 1 5 3 4
Output
5
11111
10111
10101
00111
10100
Note
In the first example, the number of blocks decrease like that:
{ 5,5,5,5,5 } → { 4,4,4,4,4 } → { 4,3,3,3,3 } → { 3,3,2,2,2 } → { 2,2,2,1,1 } → { 1,1,1,1,0 } → { 0,0,0,0,0 }. And we can note that each operation differs from others. | instruction | 0 | 52,332 | 12 | 104,664 |
Tags: constructive algorithms
Correct Solution:
```
n = int(input())
v = []
q = 0
z = ['0' for i in range(n)]
for i in input().split() :
v.append([int(i), q])
q += 1
v.sort(reverse=True, key=lambda x : [x[0], -x[1]])
print(n+1)
def predictor(v, z, index_off, index_on, n) :
#print(v)
if n == 0 :
for i in range(len(v)) :
if v[i][0] > 0 :
v[i][0] -= 1
z[v[i][1]] = '1'
else : z[v[i][1]] = '0'
print(''.join(z))
return v
for i in range(len(v)) :
#print(index_off, i, n, index_on)
if (index_off != i and (v[i][0] > 1 or (i == index_on and v[i][0] == 1))) :
v[i][0] -= 1
z[v[i][1]] = '1'
else : z[v[i][1]] = '0'
#print(101-n, ''.join(z), index_off, index_on)
print(''.join(z))
#if index_on < 13 : print(v)
return v
def generator(v, z, n) :
y, x = -1, n-1
q = 0
while v[0][0] != 0 :
if v[x-1][0] == 1 or v[x][0] == 0 : y = -2
while v[x][0] == 0 : x -= 1
if y >= 0 :
while v[y][0]-1 == n :
y += 1
q += 1
predictor(v, z, y, x, n)
if y == -2 : y = q
else : y += 1
n -= 1
return n
q = generator(v, z, n)
c = '0'*n
for i in range(q+1) : print(c)
``` | output | 1 | 52,332 | 12 | 104,665 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer array a_1, a_2, ..., a_n, where a_i represents the number of blocks at the i-th position. It is guaranteed that 1 ≤ a_i ≤ n.
In one operation you can choose a subset of indices of the given array and remove one block in each of these indices. You can't remove a block from a position without blocks.
All subsets that you choose should be different (unique).
You need to remove all blocks in the array using at most n+1 operations. It can be proved that the answer always exists.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^3) — length of the given array.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — numbers of blocks at positions 1, 2, ..., n.
Output
In the first line print an integer op (0 ≤ op ≤ n+1).
In each of the following op lines, print a binary string s of length n. If s_i='0', it means that the position i is not in the chosen subset. Otherwise, s_i should be equal to '1' and the position i is in the chosen subset.
All binary strings should be distinct (unique) and a_i should be equal to the sum of s_i among all chosen binary strings.
If there are multiple possible answers, you can print any.
It can be proved that an answer always exists.
Examples
Input
5
5 5 5 5 5
Output
6
11111
01111
10111
11011
11101
11110
Input
5
5 1 1 1 1
Output
5
11000
10000
10100
10010
10001
Input
5
4 1 5 3 4
Output
5
11111
10111
10101
00111
10100
Note
In the first example, the number of blocks decrease like that:
{ 5,5,5,5,5 } → { 4,4,4,4,4 } → { 4,3,3,3,3 } → { 3,3,2,2,2 } → { 2,2,2,1,1 } → { 1,1,1,1,0 } → { 0,0,0,0,0 }. And we can note that each operation differs from others. | instruction | 0 | 52,333 | 12 | 104,666 |
Tags: constructive algorithms
Correct Solution:
```
n = int(input())
v = []
q = 0
z = ['0' for i in range(n)]
for i in input().split() :
v.append([int(i), q])
q += 1
v.sort(reverse=True)
c = []
def predictor(v, z, index_off, index_on, n) :
global c
if n == 0 :
for i in range(len(v)) :
if v[i][0] > 0 :
v[i][0] -= 1
z[v[i][1]] = '1'
else : z[v[i][1]] = '0'
#print(''.join(z))
c.append(''.join(z))
return v
for i in range(len(v)) :
if (index_off != i and (v[i][0] > 1 or (i == index_on and v[i][0] == 1))) :
v[i][0] -= 1
z[v[i][1]] = '1'
else : z[v[i][1]] = '0'
c.append(''.join(z))
return v
def generator(v, z, n) :
y, x = -1, n-1
q = 0
while v[0][0] != 0 :
if v[x-1][0] == 1 or v[x][0] == 0 : y = -2
while v[x][0] == 0 : x -= 1
if y >= 0 :
while v[y][0]-1 == n :
y += 1
q += 1
predictor(v, z, y, x, n)
if y == -2 : y = q
else : y += 1
n -= 1
return n
generator(v, z, n)
print(len(c))
print('\n'.join(c))
``` | output | 1 | 52,333 | 12 | 104,667 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer array a_1, a_2, ..., a_n, where a_i represents the number of blocks at the i-th position. It is guaranteed that 1 ≤ a_i ≤ n.
In one operation you can choose a subset of indices of the given array and remove one block in each of these indices. You can't remove a block from a position without blocks.
All subsets that you choose should be different (unique).
You need to remove all blocks in the array using at most n+1 operations. It can be proved that the answer always exists.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^3) — length of the given array.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — numbers of blocks at positions 1, 2, ..., n.
Output
In the first line print an integer op (0 ≤ op ≤ n+1).
In each of the following op lines, print a binary string s of length n. If s_i='0', it means that the position i is not in the chosen subset. Otherwise, s_i should be equal to '1' and the position i is in the chosen subset.
All binary strings should be distinct (unique) and a_i should be equal to the sum of s_i among all chosen binary strings.
If there are multiple possible answers, you can print any.
It can be proved that an answer always exists.
Examples
Input
5
5 5 5 5 5
Output
6
11111
01111
10111
11011
11101
11110
Input
5
5 1 1 1 1
Output
5
11000
10000
10100
10010
10001
Input
5
4 1 5 3 4
Output
5
11111
10111
10101
00111
10100
Note
In the first example, the number of blocks decrease like that:
{ 5,5,5,5,5 } → { 4,4,4,4,4 } → { 4,3,3,3,3 } → { 3,3,2,2,2 } → { 2,2,2,1,1 } → { 1,1,1,1,0 } → { 0,0,0,0,0 }. And we can note that each operation differs from others. | instruction | 0 | 52,334 | 12 | 104,668 |
Tags: constructive algorithms
Correct Solution:
```
import os, sys, math
import collections
#res = solve('(R' + ('(R)R' * 2) + ')')
if os.path.exists('testing'):
name = os.path.basename(__file__)
if name.endswith('.py'):
name = name[:-3]
src = open(name + '.in.txt', encoding='utf8')
input = src.readline
n = int(input().strip())
counts = [ int(q) for q in (input().strip().split()) ]
sorted_counts_map = list(sorted(((int(q), e) for e, q in enumerate(counts)), reverse=True))
sorted_counts = [ q for q, _ in sorted_counts_map ]
def solve():
res = [
[ 0 ] * n for _ in range(n + 1)
]
for e in range(n):
c = sorted_counts[e]
for r in range(c):
index = (r + e) % (n + 1)
res[index][e] = 1
res2 = [ 0 ] * n
for r in res:
for e, (_, pos) in enumerate(sorted_counts_map):
res2[pos] = r[e]
r[:] = res2[:]
for x in range(len(res)):
res[x] = ''.join(str(q) for q in res[x])
zeroes = '0' * n
while res[-1] == zeroes:
res.pop()
return res
res = solve()
print(len(res))
for r in res:
print(''.join(map(str, r)))
``` | output | 1 | 52,334 | 12 | 104,669 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.