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.
You are given an array a consisting of n integers. You have to find the length of the smallest (shortest) prefix of elements you need to erase from a to make it a good array. Recall that the prefix of the array a=[a_1, a_2, ..., a_n] is a subarray consisting several first elements: the prefix of the array a of length k is the array [a_1, a_2, ..., a_k] (0 ≤ k ≤ n).
The array b of length m is called good, if you can obtain a non-decreasing array c (c_1 ≤ c_2 ≤ ... ≤ c_{m}) from it, repeating the following operation m times (initially, c is empty):
* select either the first or the last element of b, remove it from b, and append it to the end of the array c.
For example, if we do 4 operations: take b_1, then b_{m}, then b_{m-1} and at last b_2, then b becomes [b_3, b_4, ..., b_{m-3}] and c =[b_1, b_{m}, b_{m-1}, b_2].
Consider the following example: b = [1, 2, 3, 4, 4, 2, 1]. This array is good because we can obtain non-decreasing array c from it by the following sequence of operations:
1. take the first element of b, so b = [2, 3, 4, 4, 2, 1], c = [1];
2. take the last element of b, so b = [2, 3, 4, 4, 2], c = [1, 1];
3. take the last element of b, so b = [2, 3, 4, 4], c = [1, 1, 2];
4. take the first element of b, so b = [3, 4, 4], c = [1, 1, 2, 2];
5. take the first element of b, so b = [4, 4], c = [1, 1, 2, 2, 3];
6. take the last element of b, so b = [4], c = [1, 1, 2, 2, 3, 4];
7. take the only element of b, so b = [], c = [1, 1, 2, 2, 3, 4, 4] — c is non-decreasing.
Note that the array consisting of one element is good.
Print the length of the shortest prefix of a to delete (erase), to make a to be a good array. Note that the required length can be 0.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer: the length of the shortest prefix of elements you need to erase from a to make it a good array.
Example
Input
5
4
1 2 3 4
7
4 3 3 8 4 5 2
3
1 1 1
7
1 3 1 4 5 3 2
5
5 4 3 2 3
Output
0
4
0
2
3
Note
In the first test case of the example, the array a is already good, so we don't need to erase any prefix.
In the second test case of the example, the initial array a is not good. Let's erase first 4 elements of a, the result is [4, 5, 2]. The resulting array is good. You can prove that if you erase fewer number of first elements, the result will not be good.
Submitted Solution:
```
import sys
input = sys.stdin.readline
############ Input Functions ################
# Take integer input
def inp():
return(int(input()))
# Take list input
def inlt():
return(list(map(int, input().split())))
# Take string as list of characters
def insr():
s = input()
return(s[:len(s) - 1])
# Take space separated integer variable inputs
def invr():
return(map(int, input().split()))
################ Solution ##################
def solve(t):
pos = len(t) - 1
while pos>0 and t[pos]<= t[pos-1]:
pos -= 1
while pos>0 and t[pos]>=t[pos-1]:
pos -= 1
print(pos)
################ Read Input ################
T = inp()
tests = []
for _ in range(T):
# tests.append(inp())
# tests.append(insr())
inp()
tests.append(inlt())
# tests.append(invr())
for t in tests:
solve(t)
``` | instruction | 0 | 69,131 | 12 | 138,262 |
Yes | output | 1 | 69,131 | 12 | 138,263 |
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 a consisting of n integers. You have to find the length of the smallest (shortest) prefix of elements you need to erase from a to make it a good array. Recall that the prefix of the array a=[a_1, a_2, ..., a_n] is a subarray consisting several first elements: the prefix of the array a of length k is the array [a_1, a_2, ..., a_k] (0 ≤ k ≤ n).
The array b of length m is called good, if you can obtain a non-decreasing array c (c_1 ≤ c_2 ≤ ... ≤ c_{m}) from it, repeating the following operation m times (initially, c is empty):
* select either the first or the last element of b, remove it from b, and append it to the end of the array c.
For example, if we do 4 operations: take b_1, then b_{m}, then b_{m-1} and at last b_2, then b becomes [b_3, b_4, ..., b_{m-3}] and c =[b_1, b_{m}, b_{m-1}, b_2].
Consider the following example: b = [1, 2, 3, 4, 4, 2, 1]. This array is good because we can obtain non-decreasing array c from it by the following sequence of operations:
1. take the first element of b, so b = [2, 3, 4, 4, 2, 1], c = [1];
2. take the last element of b, so b = [2, 3, 4, 4, 2], c = [1, 1];
3. take the last element of b, so b = [2, 3, 4, 4], c = [1, 1, 2];
4. take the first element of b, so b = [3, 4, 4], c = [1, 1, 2, 2];
5. take the first element of b, so b = [4, 4], c = [1, 1, 2, 2, 3];
6. take the last element of b, so b = [4], c = [1, 1, 2, 2, 3, 4];
7. take the only element of b, so b = [], c = [1, 1, 2, 2, 3, 4, 4] — c is non-decreasing.
Note that the array consisting of one element is good.
Print the length of the shortest prefix of a to delete (erase), to make a to be a good array. Note that the required length can be 0.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer: the length of the shortest prefix of elements you need to erase from a to make it a good array.
Example
Input
5
4
1 2 3 4
7
4 3 3 8 4 5 2
3
1 1 1
7
1 3 1 4 5 3 2
5
5 4 3 2 3
Output
0
4
0
2
3
Note
In the first test case of the example, the array a is already good, so we don't need to erase any prefix.
In the second test case of the example, the initial array a is not good. Let's erase first 4 elements of a, the result is [4, 5, 2]. The resulting array is good. You can prove that if you erase fewer number of first elements, the result will not be good.
Submitted Solution:
```
# cook your dish here
for _ in range(int(input())):
n=int(input())
ar=list(map(int, input().split()))
mp=0
dp=0
dppos=0
i=1
li=[]
maxi=ar[0]
while i<len(ar):
#print("entry")
#print("i=", i, "ar[i]=", ar[i], "maxi=", maxi, "dppos=", dppos, "li=", li, "mp=",mp, "dp=", dp)
if ar[i]>=maxi and dp==0:
maxi=ar[i]
mp=1
elif ar[i]>=maxi and dp==1:
i=dppos+1
mp=0
dp=0
maxi=ar[dppos+1]
li=[]
li.append(dppos)
elif ar[i]<maxi:
maxi=ar[i]
dp=1
dppos=i
li.append(dppos)
#print("exit")
#print("i=", i, "ar[i]=", ar[i], "maxi=", maxi, "dppos=", dppos, "li=", li, "mp=",mp, "dp=", dp)
i+=1
#print(dppos, li)
if dppos==0:
print(0)
elif len(li)==(n-1):
print(0)
else:
print(li[0])
#04023
``` | instruction | 0 | 69,132 | 12 | 138,264 |
No | output | 1 | 69,132 | 12 | 138,265 |
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 a consisting of n integers. You have to find the length of the smallest (shortest) prefix of elements you need to erase from a to make it a good array. Recall that the prefix of the array a=[a_1, a_2, ..., a_n] is a subarray consisting several first elements: the prefix of the array a of length k is the array [a_1, a_2, ..., a_k] (0 ≤ k ≤ n).
The array b of length m is called good, if you can obtain a non-decreasing array c (c_1 ≤ c_2 ≤ ... ≤ c_{m}) from it, repeating the following operation m times (initially, c is empty):
* select either the first or the last element of b, remove it from b, and append it to the end of the array c.
For example, if we do 4 operations: take b_1, then b_{m}, then b_{m-1} and at last b_2, then b becomes [b_3, b_4, ..., b_{m-3}] and c =[b_1, b_{m}, b_{m-1}, b_2].
Consider the following example: b = [1, 2, 3, 4, 4, 2, 1]. This array is good because we can obtain non-decreasing array c from it by the following sequence of operations:
1. take the first element of b, so b = [2, 3, 4, 4, 2, 1], c = [1];
2. take the last element of b, so b = [2, 3, 4, 4, 2], c = [1, 1];
3. take the last element of b, so b = [2, 3, 4, 4], c = [1, 1, 2];
4. take the first element of b, so b = [3, 4, 4], c = [1, 1, 2, 2];
5. take the first element of b, so b = [4, 4], c = [1, 1, 2, 2, 3];
6. take the last element of b, so b = [4], c = [1, 1, 2, 2, 3, 4];
7. take the only element of b, so b = [], c = [1, 1, 2, 2, 3, 4, 4] — c is non-decreasing.
Note that the array consisting of one element is good.
Print the length of the shortest prefix of a to delete (erase), to make a to be a good array. Note that the required length can be 0.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer: the length of the shortest prefix of elements you need to erase from a to make it a good array.
Example
Input
5
4
1 2 3 4
7
4 3 3 8 4 5 2
3
1 1 1
7
1 3 1 4 5 3 2
5
5 4 3 2 3
Output
0
4
0
2
3
Note
In the first test case of the example, the array a is already good, so we don't need to erase any prefix.
In the second test case of the example, the initial array a is not good. Let's erase first 4 elements of a, the result is [4, 5, 2]. The resulting array is good. You can prove that if you erase fewer number of first elements, the result will not be good.
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
l=l[::-1]
c=0
f=0
if len(l) in [0,1,2]:
print(0)
continue
if l[0]<l[1]:
f=1
if not f:
i=1
c=1
while i<n and l[i]<=l[i-1]:
c+=1
i+=1
else:
i=1
c=1
while i<n and l[i]>=l[i-1]:
c+=1
i+=1
while i<n and l[i]<=l[i-1]:
c+=1
i+=1
print(n-c)
``` | instruction | 0 | 69,133 | 12 | 138,266 |
No | output | 1 | 69,133 | 12 | 138,267 |
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 a consisting of n integers. You have to find the length of the smallest (shortest) prefix of elements you need to erase from a to make it a good array. Recall that the prefix of the array a=[a_1, a_2, ..., a_n] is a subarray consisting several first elements: the prefix of the array a of length k is the array [a_1, a_2, ..., a_k] (0 ≤ k ≤ n).
The array b of length m is called good, if you can obtain a non-decreasing array c (c_1 ≤ c_2 ≤ ... ≤ c_{m}) from it, repeating the following operation m times (initially, c is empty):
* select either the first or the last element of b, remove it from b, and append it to the end of the array c.
For example, if we do 4 operations: take b_1, then b_{m}, then b_{m-1} and at last b_2, then b becomes [b_3, b_4, ..., b_{m-3}] and c =[b_1, b_{m}, b_{m-1}, b_2].
Consider the following example: b = [1, 2, 3, 4, 4, 2, 1]. This array is good because we can obtain non-decreasing array c from it by the following sequence of operations:
1. take the first element of b, so b = [2, 3, 4, 4, 2, 1], c = [1];
2. take the last element of b, so b = [2, 3, 4, 4, 2], c = [1, 1];
3. take the last element of b, so b = [2, 3, 4, 4], c = [1, 1, 2];
4. take the first element of b, so b = [3, 4, 4], c = [1, 1, 2, 2];
5. take the first element of b, so b = [4, 4], c = [1, 1, 2, 2, 3];
6. take the last element of b, so b = [4], c = [1, 1, 2, 2, 3, 4];
7. take the only element of b, so b = [], c = [1, 1, 2, 2, 3, 4, 4] — c is non-decreasing.
Note that the array consisting of one element is good.
Print the length of the shortest prefix of a to delete (erase), to make a to be a good array. Note that the required length can be 0.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer: the length of the shortest prefix of elements you need to erase from a to make it a good array.
Example
Input
5
4
1 2 3 4
7
4 3 3 8 4 5 2
3
1 1 1
7
1 3 1 4 5 3 2
5
5 4 3 2 3
Output
0
4
0
2
3
Note
In the first test case of the example, the array a is already good, so we don't need to erase any prefix.
In the second test case of the example, the initial array a is not good. Let's erase first 4 elements of a, the result is [4, 5, 2]. The resulting array is good. You can prove that if you erase fewer number of first elements, the result will not be good.
Submitted Solution:
```
def main():
n = int(input())
for _ in range(n):
t = int(input())
a = list(map(int,input().split()))
count=0
flag =-1
i=t-1
while (i>=0 and flag<=a[i]):
flag=a[i]
i-=1
while(i>=0 and flag>a[i]):
flag=a[i]
i-=1
print(i+1)
# print(count)
main()
``` | instruction | 0 | 69,134 | 12 | 138,268 |
No | output | 1 | 69,134 | 12 | 138,269 |
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 a consisting of n integers. You have to find the length of the smallest (shortest) prefix of elements you need to erase from a to make it a good array. Recall that the prefix of the array a=[a_1, a_2, ..., a_n] is a subarray consisting several first elements: the prefix of the array a of length k is the array [a_1, a_2, ..., a_k] (0 ≤ k ≤ n).
The array b of length m is called good, if you can obtain a non-decreasing array c (c_1 ≤ c_2 ≤ ... ≤ c_{m}) from it, repeating the following operation m times (initially, c is empty):
* select either the first or the last element of b, remove it from b, and append it to the end of the array c.
For example, if we do 4 operations: take b_1, then b_{m}, then b_{m-1} and at last b_2, then b becomes [b_3, b_4, ..., b_{m-3}] and c =[b_1, b_{m}, b_{m-1}, b_2].
Consider the following example: b = [1, 2, 3, 4, 4, 2, 1]. This array is good because we can obtain non-decreasing array c from it by the following sequence of operations:
1. take the first element of b, so b = [2, 3, 4, 4, 2, 1], c = [1];
2. take the last element of b, so b = [2, 3, 4, 4, 2], c = [1, 1];
3. take the last element of b, so b = [2, 3, 4, 4], c = [1, 1, 2];
4. take the first element of b, so b = [3, 4, 4], c = [1, 1, 2, 2];
5. take the first element of b, so b = [4, 4], c = [1, 1, 2, 2, 3];
6. take the last element of b, so b = [4], c = [1, 1, 2, 2, 3, 4];
7. take the only element of b, so b = [], c = [1, 1, 2, 2, 3, 4, 4] — c is non-decreasing.
Note that the array consisting of one element is good.
Print the length of the shortest prefix of a to delete (erase), to make a to be a good array. Note that the required length can be 0.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer: the length of the shortest prefix of elements you need to erase from a to make it a good array.
Example
Input
5
4
1 2 3 4
7
4 3 3 8 4 5 2
3
1 1 1
7
1 3 1 4 5 3 2
5
5 4 3 2 3
Output
0
4
0
2
3
Note
In the first test case of the example, the array a is already good, so we don't need to erase any prefix.
In the second test case of the example, the initial array a is not good. Let's erase first 4 elements of a, the result is [4, 5, 2]. The resulting array is good. You can prove that if you erase fewer number of first elements, the result will not be good.
Submitted Solution:
```
t=int(input())
while t:
n=int(input())
l=list(map(int,input().split()))
i=j=0
c=0
while i<n-1 and j<n-1:
c=i
while j<n-1 and l[j+1]>=l[j]:
j+=1
while j<n-1 and l[j+1]<=l[j]:
j+=1
i=j
if c>n-2 and n>=2:
print(n-2)
else:
print(c)
t-=1
``` | instruction | 0 | 69,135 | 12 | 138,270 |
No | output | 1 | 69,135 | 12 | 138,271 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alexandra has an even-length array a, consisting of 0s and 1s. The elements of the array are enumerated from 1 to n. She wants to remove at most n/2 elements (where n — length of array) in the way that alternating sum of the array will be equal 0 (i.e. a_1 - a_2 + a_3 - a_4 + ... = 0). In other words, Alexandra wants sum of all elements at the odd positions and sum of all elements at the even positions to become equal. The elements that you remove don't have to be consecutive.
For example, if she has a = [1, 0, 1, 0, 0, 0] and she removes 2nd and 4th elements, a will become equal [1, 1, 0, 0] and its alternating sum is 1 - 1 + 0 - 0 = 0.
Help her!
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^3, n is even) — length of the array.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case, firstly, print k (n/2 ≤ k ≤ n) — number of elements that will remain after removing in the order they appear in a. Then, print this k numbers. Note that you should print the numbers themselves, not their indices.
We can show that an answer always exists. If there are several answers, you can output any of them.
Example
Input
4
2
1 0
2
0 0
4
0 1 1 1
4
1 1 0 0
Output
1
0
1
0
2
1 1
4
1 1 0 0
Note
In the first and second cases, alternating sum of the array, obviously, equals 0.
In the third case, alternating sum of the array equals 1 - 1 = 0.
In the fourth case, alternating sum already equals 1 - 1 + 0 - 0 = 0, so we don't have to remove anything. | instruction | 0 | 69,136 | 12 | 138,272 |
Tags: constructive algorithms, math
Correct Solution:
```
t=int(input())
for _ in range(t):
n=int(input())
L=list(map(int, input().split()))
a=b=0
for i in L:
if i==0:
a=a+1
else:
b=b+1
if a==1 and b==1:
print(1)
print(0, end=' ')
elif a>=b:
print(a)
for i in range(a):
print(0, end=' ')
else:
print(b-b%2)
for i in range(b-b%2):
print(1, end=' ')
print()
``` | output | 1 | 69,136 | 12 | 138,273 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alexandra has an even-length array a, consisting of 0s and 1s. The elements of the array are enumerated from 1 to n. She wants to remove at most n/2 elements (where n — length of array) in the way that alternating sum of the array will be equal 0 (i.e. a_1 - a_2 + a_3 - a_4 + ... = 0). In other words, Alexandra wants sum of all elements at the odd positions and sum of all elements at the even positions to become equal. The elements that you remove don't have to be consecutive.
For example, if she has a = [1, 0, 1, 0, 0, 0] and she removes 2nd and 4th elements, a will become equal [1, 1, 0, 0] and its alternating sum is 1 - 1 + 0 - 0 = 0.
Help her!
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^3, n is even) — length of the array.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case, firstly, print k (n/2 ≤ k ≤ n) — number of elements that will remain after removing in the order they appear in a. Then, print this k numbers. Note that you should print the numbers themselves, not their indices.
We can show that an answer always exists. If there are several answers, you can output any of them.
Example
Input
4
2
1 0
2
0 0
4
0 1 1 1
4
1 1 0 0
Output
1
0
1
0
2
1 1
4
1 1 0 0
Note
In the first and second cases, alternating sum of the array, obviously, equals 0.
In the third case, alternating sum of the array equals 1 - 1 = 0.
In the fourth case, alternating sum already equals 1 - 1 + 0 - 0 = 0, so we don't have to remove anything. | instruction | 0 | 69,137 | 12 | 138,274 |
Tags: constructive algorithms, math
Correct Solution:
```
mod = 1000000007
eps = 10**-9
def main():
import sys
from collections import Counter
input = sys.stdin.buffer.readline
for _ in range(int(input())):
N = int(input())
A = list(map(int, input().split()))
if N == 2:
if A[0] == A[1] == 1:
print(2)
print(1, 1)
else:
print(1)
print(0)
continue
C = Counter(A)
if (N//2)%2 == 0:
if C[0] >= C[1]:
a = 0
else:
a = 1
print(N//2)
print(*[a] * (N//2))
else:
n = N // 2
if C[0] >= n+1:
print(n + 1)
print(*[0] * (n + 1))
elif C[1] >= n+1:
print(n + 1)
print(*[1] * (n + 1))
else:
print(n)
print(*[0] * n)
if __name__ == '__main__':
main()
``` | output | 1 | 69,137 | 12 | 138,275 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alexandra has an even-length array a, consisting of 0s and 1s. The elements of the array are enumerated from 1 to n. She wants to remove at most n/2 elements (where n — length of array) in the way that alternating sum of the array will be equal 0 (i.e. a_1 - a_2 + a_3 - a_4 + ... = 0). In other words, Alexandra wants sum of all elements at the odd positions and sum of all elements at the even positions to become equal. The elements that you remove don't have to be consecutive.
For example, if she has a = [1, 0, 1, 0, 0, 0] and she removes 2nd and 4th elements, a will become equal [1, 1, 0, 0] and its alternating sum is 1 - 1 + 0 - 0 = 0.
Help her!
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^3, n is even) — length of the array.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case, firstly, print k (n/2 ≤ k ≤ n) — number of elements that will remain after removing in the order they appear in a. Then, print this k numbers. Note that you should print the numbers themselves, not their indices.
We can show that an answer always exists. If there are several answers, you can output any of them.
Example
Input
4
2
1 0
2
0 0
4
0 1 1 1
4
1 1 0 0
Output
1
0
1
0
2
1 1
4
1 1 0 0
Note
In the first and second cases, alternating sum of the array, obviously, equals 0.
In the third case, alternating sum of the array equals 1 - 1 = 0.
In the fourth case, alternating sum already equals 1 - 1 + 0 - 0 = 0, so we don't have to remove anything. | instruction | 0 | 69,138 | 12 | 138,276 |
Tags: constructive algorithms, math
Correct Solution:
```
#Problem Link :- https://codeforces.com/contest/1407/problem/A
import sys
input = sys.stdin.readline
############ ---- Input Functions ---- ############
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
def solve(arr,n):
cnt1 = 0
cnt0 = 0
for i in range(n):
if arr[i] == 0:
cnt0 += 1
if arr[i] == 1:
cnt1 += 1
if cnt1 <= n//2:
print(n-cnt1)
for i in range(n-cnt1):
print(0,end=' ')
else:
if cnt0 < n//2 and cnt1 % 2 == 1:
print(n - cnt0 -1)
for i in range(cnt1-1):
print(1,end=' ')
if cnt0 < n//2 and cnt1 % 2 == 0:
print(n-cnt0)
for i in range(cnt1):
print(1,end=' ')
t = inp()
while t > 0:
n = inp()
arr = inlt()
solve(arr,n)
print()
t -= 1
``` | output | 1 | 69,138 | 12 | 138,277 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alexandra has an even-length array a, consisting of 0s and 1s. The elements of the array are enumerated from 1 to n. She wants to remove at most n/2 elements (where n — length of array) in the way that alternating sum of the array will be equal 0 (i.e. a_1 - a_2 + a_3 - a_4 + ... = 0). In other words, Alexandra wants sum of all elements at the odd positions and sum of all elements at the even positions to become equal. The elements that you remove don't have to be consecutive.
For example, if she has a = [1, 0, 1, 0, 0, 0] and she removes 2nd and 4th elements, a will become equal [1, 1, 0, 0] and its alternating sum is 1 - 1 + 0 - 0 = 0.
Help her!
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^3, n is even) — length of the array.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case, firstly, print k (n/2 ≤ k ≤ n) — number of elements that will remain after removing in the order they appear in a. Then, print this k numbers. Note that you should print the numbers themselves, not their indices.
We can show that an answer always exists. If there are several answers, you can output any of them.
Example
Input
4
2
1 0
2
0 0
4
0 1 1 1
4
1 1 0 0
Output
1
0
1
0
2
1 1
4
1 1 0 0
Note
In the first and second cases, alternating sum of the array, obviously, equals 0.
In the third case, alternating sum of the array equals 1 - 1 = 0.
In the fourth case, alternating sum already equals 1 - 1 + 0 - 0 = 0, so we don't have to remove anything. | instruction | 0 | 69,139 | 12 | 138,278 |
Tags: constructive algorithms, math
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
a = list(map(int,input().split()))
o = a.count(1)
z = a.count(0)
if(o > n//2):
ans = [1]*(n//2)
if((n//2)&1):
ans += [1]
else:
ans = [0]*(n//2)
print(len(ans))
print(*ans)
``` | output | 1 | 69,139 | 12 | 138,279 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alexandra has an even-length array a, consisting of 0s and 1s. The elements of the array are enumerated from 1 to n. She wants to remove at most n/2 elements (where n — length of array) in the way that alternating sum of the array will be equal 0 (i.e. a_1 - a_2 + a_3 - a_4 + ... = 0). In other words, Alexandra wants sum of all elements at the odd positions and sum of all elements at the even positions to become equal. The elements that you remove don't have to be consecutive.
For example, if she has a = [1, 0, 1, 0, 0, 0] and she removes 2nd and 4th elements, a will become equal [1, 1, 0, 0] and its alternating sum is 1 - 1 + 0 - 0 = 0.
Help her!
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^3, n is even) — length of the array.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case, firstly, print k (n/2 ≤ k ≤ n) — number of elements that will remain after removing in the order they appear in a. Then, print this k numbers. Note that you should print the numbers themselves, not their indices.
We can show that an answer always exists. If there are several answers, you can output any of them.
Example
Input
4
2
1 0
2
0 0
4
0 1 1 1
4
1 1 0 0
Output
1
0
1
0
2
1 1
4
1 1 0 0
Note
In the first and second cases, alternating sum of the array, obviously, equals 0.
In the third case, alternating sum of the array equals 1 - 1 = 0.
In the fourth case, alternating sum already equals 1 - 1 + 0 - 0 = 0, so we don't have to remove anything. | instruction | 0 | 69,140 | 12 | 138,280 |
Tags: constructive algorithms, math
Correct Solution:
```
def pos(arr,n):
evenP=[]
oddP=[]
for i in range(len(arr)):
if i%2==0 and arr[i]==1:
evenP.append(i)
if i%2!=0 and arr[i]==1:
oddP.append(i)
if n==1:
return oddP
else:
return evenP
def haha(arr):
even=arr[0::2]
odd=arr[1::2]
n=len(arr)//2
i=n
if arr.count(1)<=n:
blanck=[0]*(len(arr)-arr.count(1))
print(len(blanck))
for i in blanck:
print(i, end=" ")
return ""
if arr.count(0)<n:
c=0
if arr.count(1)%2!=0:
c=1
blanck=[1]*(len(arr)-arr.count(0)-c)
print(len(blanck))
for i in blanck:
print(i, end=" ")
return ""
print(len(arr))
for i in arr:
print(i, end=" ")
return ""
t=int(input())
for i in range(t):
a=input()
lst=list(map(int,input().strip().split()))
print(haha(lst))
``` | output | 1 | 69,140 | 12 | 138,281 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alexandra has an even-length array a, consisting of 0s and 1s. The elements of the array are enumerated from 1 to n. She wants to remove at most n/2 elements (where n — length of array) in the way that alternating sum of the array will be equal 0 (i.e. a_1 - a_2 + a_3 - a_4 + ... = 0). In other words, Alexandra wants sum of all elements at the odd positions and sum of all elements at the even positions to become equal. The elements that you remove don't have to be consecutive.
For example, if she has a = [1, 0, 1, 0, 0, 0] and she removes 2nd and 4th elements, a will become equal [1, 1, 0, 0] and its alternating sum is 1 - 1 + 0 - 0 = 0.
Help her!
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^3, n is even) — length of the array.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case, firstly, print k (n/2 ≤ k ≤ n) — number of elements that will remain after removing in the order they appear in a. Then, print this k numbers. Note that you should print the numbers themselves, not their indices.
We can show that an answer always exists. If there are several answers, you can output any of them.
Example
Input
4
2
1 0
2
0 0
4
0 1 1 1
4
1 1 0 0
Output
1
0
1
0
2
1 1
4
1 1 0 0
Note
In the first and second cases, alternating sum of the array, obviously, equals 0.
In the third case, alternating sum of the array equals 1 - 1 = 0.
In the fourth case, alternating sum already equals 1 - 1 + 0 - 0 = 0, so we don't have to remove anything. | instruction | 0 | 69,141 | 12 | 138,282 |
Tags: constructive algorithms, math
Correct Solution:
```
from sys import stdin, stdout
def find(arr,N):
a=arr.count(1)
b=arr.count(0)
K=N-N//2
if b>=K: return [0]*K
if a>K: return [1]*(K+1 if K%2 else K)
if a==K and K%2==0: return [1]*K
x=arr.count(0)
A=[1]*x+[0]+[1]*(K-x)
if x%2==0: del A[-1]
else: del A[0]
return A
def main():
for _ in range(int(stdin.readline())):
N=int(stdin.readline())
arr=list(map(int, stdin.readline().split()))
Z=find(arr,N)
print(len(Z))
print(" ".join(map(str,Z)))
main()
``` | output | 1 | 69,141 | 12 | 138,283 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alexandra has an even-length array a, consisting of 0s and 1s. The elements of the array are enumerated from 1 to n. She wants to remove at most n/2 elements (where n — length of array) in the way that alternating sum of the array will be equal 0 (i.e. a_1 - a_2 + a_3 - a_4 + ... = 0). In other words, Alexandra wants sum of all elements at the odd positions and sum of all elements at the even positions to become equal. The elements that you remove don't have to be consecutive.
For example, if she has a = [1, 0, 1, 0, 0, 0] and she removes 2nd and 4th elements, a will become equal [1, 1, 0, 0] and its alternating sum is 1 - 1 + 0 - 0 = 0.
Help her!
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^3, n is even) — length of the array.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case, firstly, print k (n/2 ≤ k ≤ n) — number of elements that will remain after removing in the order they appear in a. Then, print this k numbers. Note that you should print the numbers themselves, not their indices.
We can show that an answer always exists. If there are several answers, you can output any of them.
Example
Input
4
2
1 0
2
0 0
4
0 1 1 1
4
1 1 0 0
Output
1
0
1
0
2
1 1
4
1 1 0 0
Note
In the first and second cases, alternating sum of the array, obviously, equals 0.
In the third case, alternating sum of the array equals 1 - 1 = 0.
In the fourth case, alternating sum already equals 1 - 1 + 0 - 0 = 0, so we don't have to remove anything. | instruction | 0 | 69,142 | 12 | 138,284 |
Tags: constructive algorithms, math
Correct Solution:
```
ans=[]
for x in range(int(input())):
res=[]
waste=int(input())
l=list(map(int,input().split()))
a=l.count(1)
b=l.count(0)
if a>b:
if a%2==0:
for y in range(a):
c=1
dd=str(c)
res.append(dd)
sep=" "
de=sep.join(res)
ans.append(len(res))
ans.append(de)
else:
d=a-1
for y in range(d):
c=1
dd=str(c)
res.append(dd)
sep=" "
de=sep.join(res)
ans.append(len(res))
ans.append(de)
elif a==b:
for y in range(a):
c=0
dd=str(c)
res.append(dd)
sep=" "
de=sep.join(res)
ans.append(len(res))
ans.append(de)
elif b>a:
for y in range(b):
c=0
dd=str(c)
res.append(dd)
sep=" "
de=sep.join(res)
ans.append(len(res))
ans.append(de)
for x1 in ans:
print(x1)
``` | output | 1 | 69,142 | 12 | 138,285 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alexandra has an even-length array a, consisting of 0s and 1s. The elements of the array are enumerated from 1 to n. She wants to remove at most n/2 elements (where n — length of array) in the way that alternating sum of the array will be equal 0 (i.e. a_1 - a_2 + a_3 - a_4 + ... = 0). In other words, Alexandra wants sum of all elements at the odd positions and sum of all elements at the even positions to become equal. The elements that you remove don't have to be consecutive.
For example, if she has a = [1, 0, 1, 0, 0, 0] and she removes 2nd and 4th elements, a will become equal [1, 1, 0, 0] and its alternating sum is 1 - 1 + 0 - 0 = 0.
Help her!
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^3, n is even) — length of the array.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case, firstly, print k (n/2 ≤ k ≤ n) — number of elements that will remain after removing in the order they appear in a. Then, print this k numbers. Note that you should print the numbers themselves, not their indices.
We can show that an answer always exists. If there are several answers, you can output any of them.
Example
Input
4
2
1 0
2
0 0
4
0 1 1 1
4
1 1 0 0
Output
1
0
1
0
2
1 1
4
1 1 0 0
Note
In the first and second cases, alternating sum of the array, obviously, equals 0.
In the third case, alternating sum of the array equals 1 - 1 = 0.
In the fourth case, alternating sum already equals 1 - 1 + 0 - 0 = 0, so we don't have to remove anything. | instruction | 0 | 69,143 | 12 | 138,286 |
Tags: constructive algorithms, math
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
a = [*map(int, input().split())]
ans = []
for i in range(0, n , 2):
if a[i] + a[i+1] < 2:
ans += [0]
else:
ans += [1,1]
print(len(ans))
print(*ans)
``` | output | 1 | 69,143 | 12 | 138,287 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alexandra has an even-length array a, consisting of 0s and 1s. The elements of the array are enumerated from 1 to n. She wants to remove at most n/2 elements (where n — length of array) in the way that alternating sum of the array will be equal 0 (i.e. a_1 - a_2 + a_3 - a_4 + ... = 0). In other words, Alexandra wants sum of all elements at the odd positions and sum of all elements at the even positions to become equal. The elements that you remove don't have to be consecutive.
For example, if she has a = [1, 0, 1, 0, 0, 0] and she removes 2nd and 4th elements, a will become equal [1, 1, 0, 0] and its alternating sum is 1 - 1 + 0 - 0 = 0.
Help her!
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^3, n is even) — length of the array.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case, firstly, print k (n/2 ≤ k ≤ n) — number of elements that will remain after removing in the order they appear in a. Then, print this k numbers. Note that you should print the numbers themselves, not their indices.
We can show that an answer always exists. If there are several answers, you can output any of them.
Example
Input
4
2
1 0
2
0 0
4
0 1 1 1
4
1 1 0 0
Output
1
0
1
0
2
1 1
4
1 1 0 0
Note
In the first and second cases, alternating sum of the array, obviously, equals 0.
In the third case, alternating sum of the array equals 1 - 1 = 0.
In the fourth case, alternating sum already equals 1 - 1 + 0 - 0 = 0, so we don't have to remove anything.
Submitted Solution:
```
import sys
input = sys.stdin.readline
Q = int(input())
for _ in range(Q):
N = int(input())
K = N//2
A = list(map(int, input().split()))
ans = []
if A.count(0) >= K:
ans = [0] * K
else:
if K%2 == 0:
ans = [1] * K
else:
ans = [1] * (K+1)
print(len(ans))
print(*ans)
``` | instruction | 0 | 69,144 | 12 | 138,288 |
Yes | output | 1 | 69,144 | 12 | 138,289 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alexandra has an even-length array a, consisting of 0s and 1s. The elements of the array are enumerated from 1 to n. She wants to remove at most n/2 elements (where n — length of array) in the way that alternating sum of the array will be equal 0 (i.e. a_1 - a_2 + a_3 - a_4 + ... = 0). In other words, Alexandra wants sum of all elements at the odd positions and sum of all elements at the even positions to become equal. The elements that you remove don't have to be consecutive.
For example, if she has a = [1, 0, 1, 0, 0, 0] and she removes 2nd and 4th elements, a will become equal [1, 1, 0, 0] and its alternating sum is 1 - 1 + 0 - 0 = 0.
Help her!
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^3, n is even) — length of the array.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case, firstly, print k (n/2 ≤ k ≤ n) — number of elements that will remain after removing in the order they appear in a. Then, print this k numbers. Note that you should print the numbers themselves, not their indices.
We can show that an answer always exists. If there are several answers, you can output any of them.
Example
Input
4
2
1 0
2
0 0
4
0 1 1 1
4
1 1 0 0
Output
1
0
1
0
2
1 1
4
1 1 0 0
Note
In the first and second cases, alternating sum of the array, obviously, equals 0.
In the third case, alternating sum of the array equals 1 - 1 = 0.
In the fourth case, alternating sum already equals 1 - 1 + 0 - 0 = 0, so we don't have to remove anything.
Submitted Solution:
```
for _ in range(int(input())):
n,m=int(input()),list(map(int,input().strip().split()))
p=[]
for x in range(0,n,2):
if m[x]!=m[x+1]:
p.append(0)
else:
p.append(m[x])
p.append(m[x+1])
print(len(p))
print(*p)
``` | instruction | 0 | 69,145 | 12 | 138,290 |
Yes | output | 1 | 69,145 | 12 | 138,291 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alexandra has an even-length array a, consisting of 0s and 1s. The elements of the array are enumerated from 1 to n. She wants to remove at most n/2 elements (where n — length of array) in the way that alternating sum of the array will be equal 0 (i.e. a_1 - a_2 + a_3 - a_4 + ... = 0). In other words, Alexandra wants sum of all elements at the odd positions and sum of all elements at the even positions to become equal. The elements that you remove don't have to be consecutive.
For example, if she has a = [1, 0, 1, 0, 0, 0] and she removes 2nd and 4th elements, a will become equal [1, 1, 0, 0] and its alternating sum is 1 - 1 + 0 - 0 = 0.
Help her!
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^3, n is even) — length of the array.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case, firstly, print k (n/2 ≤ k ≤ n) — number of elements that will remain after removing in the order they appear in a. Then, print this k numbers. Note that you should print the numbers themselves, not their indices.
We can show that an answer always exists. If there are several answers, you can output any of them.
Example
Input
4
2
1 0
2
0 0
4
0 1 1 1
4
1 1 0 0
Output
1
0
1
0
2
1 1
4
1 1 0 0
Note
In the first and second cases, alternating sum of the array, obviously, equals 0.
In the third case, alternating sum of the array equals 1 - 1 = 0.
In the fourth case, alternating sum already equals 1 - 1 + 0 - 0 = 0, so we don't have to remove anything.
Submitted Solution:
```
n = int(input())
for i in range(n):
k = int(input())
L1 = [int(i) for i in input().strip('\r').split(' ')]
count_0 = 0
count_1 = 0
for i in range(len(L1)):
if L1[i] == 1:
count_1 += 1
else:
count_0 += 1
if count_1 <= k//2:
result = ['0']*count_0
if count_0 < k//2:
result = ['1']*count_1
if count_0%2 != 0:
result.pop()
print(len(result))
print(' '.join(result))
``` | instruction | 0 | 69,146 | 12 | 138,292 |
Yes | output | 1 | 69,146 | 12 | 138,293 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alexandra has an even-length array a, consisting of 0s and 1s. The elements of the array are enumerated from 1 to n. She wants to remove at most n/2 elements (where n — length of array) in the way that alternating sum of the array will be equal 0 (i.e. a_1 - a_2 + a_3 - a_4 + ... = 0). In other words, Alexandra wants sum of all elements at the odd positions and sum of all elements at the even positions to become equal. The elements that you remove don't have to be consecutive.
For example, if she has a = [1, 0, 1, 0, 0, 0] and she removes 2nd and 4th elements, a will become equal [1, 1, 0, 0] and its alternating sum is 1 - 1 + 0 - 0 = 0.
Help her!
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^3, n is even) — length of the array.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case, firstly, print k (n/2 ≤ k ≤ n) — number of elements that will remain after removing in the order they appear in a. Then, print this k numbers. Note that you should print the numbers themselves, not their indices.
We can show that an answer always exists. If there are several answers, you can output any of them.
Example
Input
4
2
1 0
2
0 0
4
0 1 1 1
4
1 1 0 0
Output
1
0
1
0
2
1 1
4
1 1 0 0
Note
In the first and second cases, alternating sum of the array, obviously, equals 0.
In the third case, alternating sum of the array equals 1 - 1 = 0.
In the fourth case, alternating sum already equals 1 - 1 + 0 - 0 = 0, so we don't have to remove anything.
Submitted Solution:
```
N = int(input())
cnt0 = 0
for i in range(N):
t = int(input())
a = list(map(int, input().split()))
cnt0 = a.count(0)
cnt1 = t - cnt0
ans = []
if cnt0 >= t // 2:
for j in range(cnt0):
ans.append(0)
print(cnt0)
print(*ans)
else:
for j in range(cnt1 - cnt1 % 2):
ans.append(1)
print(cnt1-cnt1%2)
print(*ans)
``` | instruction | 0 | 69,147 | 12 | 138,294 |
Yes | output | 1 | 69,147 | 12 | 138,295 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alexandra has an even-length array a, consisting of 0s and 1s. The elements of the array are enumerated from 1 to n. She wants to remove at most n/2 elements (where n — length of array) in the way that alternating sum of the array will be equal 0 (i.e. a_1 - a_2 + a_3 - a_4 + ... = 0). In other words, Alexandra wants sum of all elements at the odd positions and sum of all elements at the even positions to become equal. The elements that you remove don't have to be consecutive.
For example, if she has a = [1, 0, 1, 0, 0, 0] and she removes 2nd and 4th elements, a will become equal [1, 1, 0, 0] and its alternating sum is 1 - 1 + 0 - 0 = 0.
Help her!
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^3, n is even) — length of the array.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case, firstly, print k (n/2 ≤ k ≤ n) — number of elements that will remain after removing in the order they appear in a. Then, print this k numbers. Note that you should print the numbers themselves, not their indices.
We can show that an answer always exists. If there are several answers, you can output any of them.
Example
Input
4
2
1 0
2
0 0
4
0 1 1 1
4
1 1 0 0
Output
1
0
1
0
2
1 1
4
1 1 0 0
Note
In the first and second cases, alternating sum of the array, obviously, equals 0.
In the third case, alternating sum of the array equals 1 - 1 = 0.
In the fourth case, alternating sum already equals 1 - 1 + 0 - 0 = 0, so we don't have to remove anything.
Submitted Solution:
```
t=int(input())
for _ in range(t):
n=int(input())
arr=list(map(int,input().split()))
sum2=0
sum1=0
for i in range(n):
if (i+1)%2==0:
sum2=sum2+arr[i]
else:
sum1=sum1+arr[i]
#print(sum)
#print(sum1)
if sum2-sum1==0:
print(n)
elif sum1>sum2:
print(n-(sum1-sum2))
one=sum1-sum2
for i in range(n):
if (i+1)%2!=0:
if arr[i]==1:
if one>0:
arr[i]="?"
one=one-1
else:
print(n-(sum2-sum1))
one=sum2-sum1
for i in range(n):
if (i+1)%2==0:
if arr[i]==1:
if one>0:
arr[i]="?"
one=one-1
for i in arr:
if i!="?":
print(i,end=" ")
``` | instruction | 0 | 69,148 | 12 | 138,296 |
No | output | 1 | 69,148 | 12 | 138,297 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alexandra has an even-length array a, consisting of 0s and 1s. The elements of the array are enumerated from 1 to n. She wants to remove at most n/2 elements (where n — length of array) in the way that alternating sum of the array will be equal 0 (i.e. a_1 - a_2 + a_3 - a_4 + ... = 0). In other words, Alexandra wants sum of all elements at the odd positions and sum of all elements at the even positions to become equal. The elements that you remove don't have to be consecutive.
For example, if she has a = [1, 0, 1, 0, 0, 0] and she removes 2nd and 4th elements, a will become equal [1, 1, 0, 0] and its alternating sum is 1 - 1 + 0 - 0 = 0.
Help her!
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^3, n is even) — length of the array.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case, firstly, print k (n/2 ≤ k ≤ n) — number of elements that will remain after removing in the order they appear in a. Then, print this k numbers. Note that you should print the numbers themselves, not their indices.
We can show that an answer always exists. If there are several answers, you can output any of them.
Example
Input
4
2
1 0
2
0 0
4
0 1 1 1
4
1 1 0 0
Output
1
0
1
0
2
1 1
4
1 1 0 0
Note
In the first and second cases, alternating sum of the array, obviously, equals 0.
In the third case, alternating sum of the array equals 1 - 1 = 0.
In the fourth case, alternating sum already equals 1 - 1 + 0 - 0 = 0, so we don't have to remove anything.
Submitted Solution:
```
import sys
read = lambda: sys.stdin.readline().strip()
readi = lambda: map(int, read().split())
for _ in range(int(read())):
n = int(read())
nums = list(readi())
e = o = 0
for i in range(n):
if i & 1 == 0:
# eve
e += nums[i]
else:
o += nums[i]
if o == e:
print(n)
print(" ".join(map(str, nums)))
elif o > e:
diff = o - e
print(n - diff)
for i in range(n):
if i & 1 == 1 and diff > 0 and nums[i] == 1:
diff -= 1
continue
print(nums[i], end=" ")
print()
else:
diff = e - o
print(n - diff)
for i in range(n):
if i & 1 == 0 and diff > 0 and nums[i] == 1:
diff -= 1
continue
print(nums[i], end=" ")
print()
``` | instruction | 0 | 69,149 | 12 | 138,298 |
No | output | 1 | 69,149 | 12 | 138,299 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alexandra has an even-length array a, consisting of 0s and 1s. The elements of the array are enumerated from 1 to n. She wants to remove at most n/2 elements (where n — length of array) in the way that alternating sum of the array will be equal 0 (i.e. a_1 - a_2 + a_3 - a_4 + ... = 0). In other words, Alexandra wants sum of all elements at the odd positions and sum of all elements at the even positions to become equal. The elements that you remove don't have to be consecutive.
For example, if she has a = [1, 0, 1, 0, 0, 0] and she removes 2nd and 4th elements, a will become equal [1, 1, 0, 0] and its alternating sum is 1 - 1 + 0 - 0 = 0.
Help her!
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^3, n is even) — length of the array.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case, firstly, print k (n/2 ≤ k ≤ n) — number of elements that will remain after removing in the order they appear in a. Then, print this k numbers. Note that you should print the numbers themselves, not their indices.
We can show that an answer always exists. If there are several answers, you can output any of them.
Example
Input
4
2
1 0
2
0 0
4
0 1 1 1
4
1 1 0 0
Output
1
0
1
0
2
1 1
4
1 1 0 0
Note
In the first and second cases, alternating sum of the array, obviously, equals 0.
In the third case, alternating sum of the array equals 1 - 1 = 0.
In the fourth case, alternating sum already equals 1 - 1 + 0 - 0 = 0, so we don't have to remove anything.
Submitted Solution:
```
from sys import stdin, stdout
input = stdin.readline
print = lambda x:stdout.write(str(x)+'\n')
for _ in range(int(input())):
n = int(input())
a = list(map(int,input().split()))
o,z = a.count(1), a.count(0)
if o<z:
ans = [i for i in a if i==0]
else:
ans = [i for i in a if i==1]
print(len(ans))
ans = ' '.join(list(map(str, ans)))
print(ans)
``` | instruction | 0 | 69,150 | 12 | 138,300 |
No | output | 1 | 69,150 | 12 | 138,301 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alexandra has an even-length array a, consisting of 0s and 1s. The elements of the array are enumerated from 1 to n. She wants to remove at most n/2 elements (where n — length of array) in the way that alternating sum of the array will be equal 0 (i.e. a_1 - a_2 + a_3 - a_4 + ... = 0). In other words, Alexandra wants sum of all elements at the odd positions and sum of all elements at the even positions to become equal. The elements that you remove don't have to be consecutive.
For example, if she has a = [1, 0, 1, 0, 0, 0] and she removes 2nd and 4th elements, a will become equal [1, 1, 0, 0] and its alternating sum is 1 - 1 + 0 - 0 = 0.
Help her!
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^3). Description of the test cases follows.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^3, n is even) — length of the array.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^3.
Output
For each test case, firstly, print k (n/2 ≤ k ≤ n) — number of elements that will remain after removing in the order they appear in a. Then, print this k numbers. Note that you should print the numbers themselves, not their indices.
We can show that an answer always exists. If there are several answers, you can output any of them.
Example
Input
4
2
1 0
2
0 0
4
0 1 1 1
4
1 1 0 0
Output
1
0
1
0
2
1 1
4
1 1 0 0
Note
In the first and second cases, alternating sum of the array, obviously, equals 0.
In the third case, alternating sum of the array equals 1 - 1 = 0.
In the fourth case, alternating sum already equals 1 - 1 + 0 - 0 = 0, so we don't have to remove anything.
Submitted Solution:
```
for _ in range(int(input())):
am = int(input())
arr = list(map(int,input().split()))
t = am
d = []
s1 = 0
s2 = 0
for i in range(am):
if i%2:
s2+=arr[i]
else:
s1+=arr[i]
needDel = abs(s2-s1)
needDelPos = 1 if s2 > s1 else 0
c = 0
out = []
for i in range(am-1,-1,-1):
if needDel > 0 and needDel != i%2 and arr[i] == 1:
c+=1
needDel-=1
continue
else:
out.append(arr[i])
print(len(out))
out.reverse()
print(*out)
``` | instruction | 0 | 69,151 | 12 | 138,302 |
No | output | 1 | 69,151 | 12 | 138,303 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | instruction | 0 | 69,233 | 12 | 138,466 |
Tags: constructive algorithms, greedy, sortings
Correct Solution:
```
x = int(input())
if x < 3:
print("-1")
else:
for i in range(x):
print((x - i), end=" ")
``` | output | 1 | 69,233 | 12 | 138,467 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | instruction | 0 | 69,234 | 12 | 138,468 |
Tags: constructive algorithms, greedy, sortings
Correct Solution:
```
n = int(input())
if (n > 2):
for i in range(2, n+1):
print(i, end = " ")
print(1)
else:
print(-1)
``` | output | 1 | 69,234 | 12 | 138,469 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | instruction | 0 | 69,235 | 12 | 138,470 |
Tags: constructive algorithms, greedy, sortings
Correct Solution:
```
n=int(input())
if n<3:
print(-1)
else:
s=[100,2]+[1]*(n-2)
print(' '.join(map(str,s)))
``` | output | 1 | 69,235 | 12 | 138,471 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | instruction | 0 | 69,236 | 12 | 138,472 |
Tags: constructive algorithms, greedy, sortings
Correct Solution:
```
a=int(input())
if a==1 or a==2:
print(-1)
else:
print(3,5,end=' ')
for i in range(a-2):
print(1,end=' ')
``` | output | 1 | 69,236 | 12 | 138,473 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | instruction | 0 | 69,237 | 12 | 138,474 |
Tags: constructive algorithms, greedy, sortings
Correct Solution:
```
n = int(input())
if n == 1 or n == 2:
print('-1')
else:
l = ['2']
l += ['3']*(n-2)
l += ['1']
print(' '.join(l))
``` | output | 1 | 69,237 | 12 | 138,475 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | instruction | 0 | 69,238 | 12 | 138,476 |
Tags: constructive algorithms, greedy, sortings
Correct Solution:
```
a=int(input())
if a<=2:print(-1)
else:print(' '.join(list(map(str,range(1,a+1)))[::-1]))
``` | output | 1 | 69,238 | 12 | 138,477 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | instruction | 0 | 69,239 | 12 | 138,478 |
Tags: constructive algorithms, greedy, sortings
Correct Solution:
```
a = int(input())
d = 4
if a == 1 or a == 2 :
print(-1)
else:
for i in range(a -1):
print(d ,end = " ")
d += 1
print(1)
``` | output | 1 | 69,239 | 12 | 138,479 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | instruction | 0 | 69,240 | 12 | 138,480 |
Tags: constructive algorithms, greedy, sortings
Correct Solution:
```
X = int(input())
if X <= 2:
print(-1)
exit()
print(*[i for i in range(X, 0, -1)])
``` | output | 1 | 69,240 | 12 | 138,481 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1
Submitted Solution:
```
__copyright__ = ''
__author__ = 'Son-Huy TRAN'
__email__ = "sonhuytran@gmail.com"
__doc__ = ''
__version__ = '1.0'
def main() -> int:
n = int(input())
if n <= 2:
print(-1)
else:
result = [str(i) for i in range(n, 0, -1)]
print(' '.join(result))
return 0
if __name__ == '__main__':
exit(main())
``` | instruction | 0 | 69,241 | 12 | 138,482 |
Yes | output | 1 | 69,241 | 12 | 138,483 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1
Submitted Solution:
```
n = int(input())
if n == 1 or n == 2:
print(-1)
else:
arr = [x for x in range(2, n+1)]
arr.append(1)
print(*arr)
``` | instruction | 0 | 69,242 | 12 | 138,484 |
Yes | output | 1 | 69,242 | 12 | 138,485 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1
Submitted Solution:
```
n=int(input())
if n==1 or n==2:
print(-1)
else:
arr=[int(i) for i in range(n,0,-1)]
print(*arr)
``` | instruction | 0 | 69,243 | 12 | 138,486 |
Yes | output | 1 | 69,243 | 12 | 138,487 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1
Submitted Solution:
```
n=int(input())
if n<=2:
print(-1)
else:
print(*list(range(n,0,-1)))
``` | instruction | 0 | 69,244 | 12 | 138,488 |
Yes | output | 1 | 69,244 | 12 | 138,489 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1
Submitted Solution:
```
input(-1)
``` | instruction | 0 | 69,245 | 12 | 138,490 |
No | output | 1 | 69,245 | 12 | 138,491 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1
Submitted Solution:
```
import sys
n = int(input())
if n>1:
for i in range(n-1):
sys.stdout.write('2 ')
sys.stdout.write('1')
else:
print(-1)
``` | instruction | 0 | 69,246 | 12 | 138,492 |
No | output | 1 | 69,246 | 12 | 138,493 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1
Submitted Solution:
```
a=int(input())
if a==1:
print(-1)
else:
print(*[i for i in range(a,0,-1)])
``` | instruction | 0 | 69,247 | 12 | 138,494 |
No | output | 1 | 69,247 | 12 | 138,495 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1
Submitted Solution:
```
def main(n):
if n <= 1:
return "-1"
l = list(reversed(list(range(1, n + 1))))
return ' '.join(list(map(str, l)))
print(main(int(input())))
``` | instruction | 0 | 69,248 | 12 | 138,496 |
No | output | 1 | 69,248 | 12 | 138,497 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | instruction | 0 | 69,249 | 12 | 138,498 |
Tags: binary search, brute force, math, number theory
Correct Solution:
```
def rotated(array_2d):
list_of_tuples = zip(*array_2d[::-1])
return list([list(elem) for elem in list_of_tuples])
n=100100
p=[0,0]+[1]*(n)
p[0],p[1]=0,0
n1=int(n**0.5)
for i in range(2,n1):
if p[i]==1:
for j in range(i*i,n,i):
p[j]=0
for k in range(n,-1,-1):
if p[k]:
ind=k
p[k]=0
else:
p[k]=ind-k
lst=[]
x,y=map(int,input().split())
for j in range(x):
l=[]
for i in map(int,input().split()):
l.append(p[i])
lst.append(l)
st=[]
for x in lst:
st.append(sum(x))
for x in rotated(lst):
st.append(sum(x))
print(min(st))
``` | output | 1 | 69,249 | 12 | 138,499 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | instruction | 0 | 69,250 | 12 | 138,500 |
Tags: binary search, brute force, math, number theory
Correct Solution:
```
import sys
def prime(n):
v = int(n**0.5)+1
l = [True for i in range(n+1)]
l[0]=False
l[1]=False
for i in range(2,v):
if l[i]:
for j in range(i,n+1,i):
if j%i == 0 and j!=i and l[j]:
l[j] = False
return l
def c_prime(n):
if d.get(n,False):
return d[n]
elif table[n]:
d[n] = n
return d[n]
else:
if n == 0 or n == 1:
d[n] = 2
return d[n]
else:
c = 1
while True:
if table[n+c]:
d[n] = n+c
return d[n]
c+=1
table = prime(110000)
d = {}
# print(table)
n,m = [int(i) for i in input().split()]
s = sys.maxsize
matrix = []
for i in range(n):
temp = [int(j) for j in input().split()]
matrix.append(temp)
s = min(s,sum([abs(j-c_prime(j)) for j in temp]))
for i in range(m):
temp = [j[i] for j in matrix]
s = min(s,sum([abs(j-c_prime(j)) for j in temp]))
print(s)
``` | output | 1 | 69,250 | 12 | 138,501 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | instruction | 0 | 69,251 | 12 | 138,502 |
Tags: binary search, brute force, math, number theory
Correct Solution:
```
def arr_inp(n):
if n == 1:
return [int(x) for x in stdin.readline().split()]
elif n == 2:
return [float(x) for x in stdin.readline().split()]
else:
return [str(x) for x in stdin.readline().split()]
def count_prime(n):
prim = defaultdict(lambda: 1, {i: 1 for i in range(n + 1)})
prim[0] = prim[1] = 0
i = 2
while (i * i <= n):
if prim[i]:
for j in range(i * 2, n + 1, i):
prim[j] = 0
i += 1
return list(filter(lambda x: prim[x], prim.keys()))
from sys import stdin
from collections import *
from bisect import *
n, m = arr_inp(1)
mat, primes, ans, col = [arr_inp(1) for i in range(n)], count_prime(100003), float('inf'), defaultdict(int)
for i in range(n):
r = 0
for j in range(m):
ix = bisect_right(primes, mat[i][j])
if primes[ix - 1] == mat[i][j]:
ix -= 1
col[j] += primes[ix] - mat[i][j]
r += primes[ix] - mat[i][j]
if i == n - 1:
ans = min(ans, col[j])
ans = min(ans, r)
print(ans)
``` | output | 1 | 69,251 | 12 | 138,503 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | instruction | 0 | 69,252 | 12 | 138,504 |
Tags: binary search, brute force, math, number theory
Correct Solution:
```
import math,bisect
from collections import Counter,defaultdict
I =lambda:int(input())
M =lambda:map(int,input().split())
LI=lambda:list(map(int,input().split()))
n,m=M()
a=[]
for i in range(n):
b=LI()
a+=[b]
prime=[1]*((10**6)+1)
i=2
while i*i<=10**6:
if prime[i]:
for j in range(i+i,(10**6)+1,i):
prime[j]=0
i+=1
ans=[]
for i in range(2,(10**6)+1):
if prime[i]:ans+=[i]
mi=10000000
for i in range(n):
c=0
for j in range(m):
d=bisect.bisect_left(ans,a[i][j])
c+=abs(ans[d]-a[i][j])
# print(c,"f")
mi=min(mi,c)
for j in range(m):
c=0
for i in range(n):
d=bisect.bisect_left(ans,a[i][j])
c+=abs(ans[d]-a[i][j])
# print(c,"l")
mi=min(mi,c)
print(mi)
``` | output | 1 | 69,252 | 12 | 138,505 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | instruction | 0 | 69,254 | 12 | 138,508 |
Tags: binary search, brute force, math, number theory
Correct Solution:
```
from bisect import bisect_left as bl
n,m=map(int,input().split())
pn,l=[],[]
q=10**5+4
k=[True for i in range(q+2)]
for p in range(2,int(q**.5)+2):
if(k[p]==True):
for i in range(p**2,q+2,p):k[i]=False
for p in range(2,q+1):
if k[p]:pn.append(p)
for i in range(n):
l.append(list(map(int,input().split())))
def f(l,q):
for i in l:
x=0
for j in i:x+=pn[bl(pn,j)]-j
q=min(q,x)
return q
print(f(zip(*l),f(l,q)))
``` | output | 1 | 69,254 | 12 | 138,509 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | instruction | 0 | 69,255 | 12 | 138,510 |
Tags: binary search, brute force, math, number theory
Correct Solution:
```
from sys import stdin,stdout
input=stdin.readline
import math,bisect
#from itertools import permutations
#from collections import Counter
prime=[1]*102001
prime[1]=0
prime[0]=0
for i in range(2,102001):
j=i
if prime[i]==1:
while(j+i<102001):
j+=i
prime[j]=0
#print(prime)
l=[]
n,m=map(int,input().split())
for i in range(n):
t=list(map(int,input().split()))
l.append(t)
ans=5000000000
for i in range(n):
tot=0
for j in range(m):
ele=l[i][j]
for k in range(ele,102001):
if prime[k]==1:
tot+=k-ele
break
ans=min(ans,tot)
for j in range(m):
tot=0
for i in range(n):
ele=l[i][j]
for k in range(ele,102001):
if prime[k]==1:
tot+=k-ele
break
ans=min(ans,tot)
print(ans)
``` | output | 1 | 69,255 | 12 | 138,511 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2.
Submitted Solution:
```
import bisect
def sieve(n):
p = 2
prime = [True for i in range(n+1)]
while p*p<=n:
if prime[p] ==True:
for i in range(p*p,n+1,p):
prime[i] = False
p+=1
c = []
for p in range(2,n):
if prime[p]:
c.append(p)
return c
def transpose(a,n,m):
c = []
for i in range(max(n,m)):
l = []
for j in range(max(n,m)):
try:
l.append(a[j][i])
except:
pass
c.append(l)
c = c[:m]
return c
def calcost(a,c):
cost = 0
for i in range(len(a)):
p = bisect.bisect_left(c,a[i])
cost+=(c[p]-a[i])
return cost
c = sieve(1000001)
n,m = map(int,input().split())
l = []
for i in range(n):
a = list(map(int,input().split()))
l.append(a)
cost = []
for i in range(len(l)):
cost.append(calcost(l[i],c))
l = transpose(l,n,m)
for i in range(len(l)):
cost.append(calcost(l[i],c))
print(min(cost))
``` | instruction | 0 | 69,259 | 12 | 138,518 |
Yes | output | 1 | 69,259 | 12 | 138,519 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2.
Submitted Solution:
```
def sieve(num):
primes = [0] * (num + 1)
prime_flag = [True] * (num + 1)
#referencia a 0 e 1.
prime_flag[0]=prime_flag[1] = False
i = 2
while(i*i <= num):
if(prime_flag[i]):
for j in range(i*i, num + 1, i):
prime_flag[j] = False
i += 1
for i in range(num-1, -1,-1):
if not prime_flag[i]:
primes[i] = 1 + primes[i+1]
return primes
m,n = map(int, input().split())
matrix = []
max_number = 100020
prime_array = sieve(max_number)
line_sum = max_number
colum_sum=[0] * n
for i in range(m):
line = list(map(int, input().split()))
matrix.append(line)
aux_line = 0
for j in range(n):
diff_of_position = prime_array[matrix[i][j]]
aux_line += diff_of_position
colum_sum[j] += diff_of_position
if(aux_line < line_sum):
line_sum = aux_line
min_value = line_sum
for i in colum_sum:
if(i < min_value):
min_value = i
print(min_value)
``` | instruction | 0 | 69,260 | 12 | 138,520 |
Yes | output | 1 | 69,260 | 12 | 138,521 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2.
Submitted Solution:
```
import bisect
def sieve(n):
p = 2
prime = [True for i in range(n+1)]
while p*p<=n:
if prime[p] ==True:
for i in range(p*p,n+1,p):
prime[i] = False
p+=1
c = []
for p in range(2,n):
if prime[p]:
c.append(p)
return c
def transpose(a,n,m):
c = []
for i in range(max(n,m)):
l = []
for j in range(max(n,m)):
try:
l.append(a[j][i])
except:
pass
c.append(l)
return c
def calcost(a,c):
cost = 0
for i in range(len(a)):
p = bisect.bisect_left(c,a[i])
cost+=(c[p]-a[i])
return cost
c = sieve(100001)
n,m = map(int,input().split())
l = []
for i in range(n):
a = list(map(int,input().split()))
l.append(a)
cost = []
for i in range(len(l)):
cost.append(calcost(l[i],c))
l = transpose(l,n,m)
for i in range(len(l)):
cost.append(calcost(l[i],c))
print(min(cost))
``` | instruction | 0 | 69,261 | 12 | 138,522 |
No | output | 1 | 69,261 | 12 | 138,523 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2.
Submitted Solution:
```
import itertools as it
simple_nums = []
def sieve():
""" Generate an infinite sequence of prime numbers.
"""
yield 2
D = {}
for q in it.count(3, 2): # start at 3 and step by odds
p = D.pop(q, 0)
if p:
x = q + p
while x in D: x += p
D[x] = p # new composite found. Mark that
else:
yield q # q is a new prime since no composite was found
D[q * q] = 2 * q
simple_nums = list(it.islice(sieve(), 0, 10))
def resize_simple():
a = it.islice(sieve(), len(simple_nums), len(simple_nums) + 1)
a = list(a)
a = int(*a)
simple_nums.append(a)
def get_nearest_to(num):
if num <= simple_nums[0]:
return simple_nums[0]
while num > simple_nums[len(simple_nums) - 1]:
resize_simple()
high = len(simple_nums) - 1
mid = high // 2
low = 0
while low < high:
mid = (low + high) // 2
if simple_nums[mid] == num:
return simple_nums[mid]
if simple_nums[mid] > num:
high = mid -1
else:
low = mid + 1
return simple_nums[max(low, mid, high)]
def get_steps(num):
near = get_nearest_to(num)
return near - num
m, n = map(int, input().split())
matrix = [[0 for i in range(n)] for j in range(m)]
simple_steps = [
[0 for i in range(n)],
[0 for i in range(m)]
]
for i in range(m):
buf = list(map(int, input().split()))
for j in range(n):
matrix[i][j] = buf[j]
t = buf[j]
a = get_steps(buf[j])
simple_steps[0][j] += a
simple_steps[1][i] += a
print(min(min(simple_steps[0]), min(simple_steps[1])))
``` | instruction | 0 | 69,262 | 12 | 138,524 |
No | output | 1 | 69,262 | 12 | 138,525 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We'll call an array of n non-negative integers a[1], a[2], ..., a[n] interesting, if it meets m constraints. The i-th of the m constraints consists of three integers li, ri, qi (1 ≤ li ≤ ri ≤ n) meaning that value <image> should be equal to qi.
Your task is to find any interesting array of n elements or state that such array doesn't exist.
Expression x&y means the bitwise AND of numbers x and y. In programming languages C++, Java and Python this operation is represented as "&", in Pascal — as "and".
Input
The first line contains two integers n, m (1 ≤ n ≤ 105, 1 ≤ m ≤ 105) — the number of elements in the array and the number of limits.
Each of the next m lines contains three integers li, ri, qi (1 ≤ li ≤ ri ≤ n, 0 ≤ qi < 230) describing the i-th limit.
Output
If the interesting array exists, in the first line print "YES" (without the quotes) and in the second line print n integers a[1], a[2], ..., a[n] (0 ≤ a[i] < 230) decribing the interesting array. If there are multiple answers, print any of them.
If the interesting array doesn't exist, print "NO" (without the quotes) in the single line.
Examples
Input
3 1
1 3 3
Output
YES
3 3 3
Input
3 2
1 3 3
1 3 2
Output
NO | instruction | 0 | 69,361 | 12 | 138,722 |
Tags: constructive algorithms, data structures, trees
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
from io import BytesIO, IOBase
import sys
from collections import defaultdict, deque, Counter
from math import sqrt, pi, ceil, log, inf, gcd, floor
from itertools import combinations, permutations
from bisect import *
from fractions import Fraction
from heapq import *
from random import randint
def main():
po=[1]
for i in range(30):
po.append(po[-1]*2)
n,m=map(int,input().split())
q=[]
b=[[0 for _ in range(30)] for _ in range(n+2)]
for i in range(m):
l,r,x=map(int,input().split())
q.append((l,r,x))
j=0
while x:
if x&1:
b[l][j]+=1
b[r+1][j]-=1
x=x>>1
j+=1
for i in range(1,n+1):
for j in range(30):
b[i][j]+=b[i-1][j]
for i in range(1,n+1):
for j in range(30):
if b[i][j]>=2:
b[i][j]=1
b[i][j]+=b[i-1][j]
f=1
for i in q:
l,r,x=i
z=0
for j in range(30):
if b[r][j]-b[l-1][j]==(r-l+1):
z+=po[j]
if z!=x:
f=0
break
if f:
print("YES")
for i in range(1,n+1):
z=0
for j in range(30):
if b[i][j]-b[i-1][j]==1:
z+=po[j]
print(z,end=" ")
else:
print("NO")
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | output | 1 | 69,361 | 12 | 138,723 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We'll call an array of n non-negative integers a[1], a[2], ..., a[n] interesting, if it meets m constraints. The i-th of the m constraints consists of three integers li, ri, qi (1 ≤ li ≤ ri ≤ n) meaning that value <image> should be equal to qi.
Your task is to find any interesting array of n elements or state that such array doesn't exist.
Expression x&y means the bitwise AND of numbers x and y. In programming languages C++, Java and Python this operation is represented as "&", in Pascal — as "and".
Input
The first line contains two integers n, m (1 ≤ n ≤ 105, 1 ≤ m ≤ 105) — the number of elements in the array and the number of limits.
Each of the next m lines contains three integers li, ri, qi (1 ≤ li ≤ ri ≤ n, 0 ≤ qi < 230) describing the i-th limit.
Output
If the interesting array exists, in the first line print "YES" (without the quotes) and in the second line print n integers a[1], a[2], ..., a[n] (0 ≤ a[i] < 230) decribing the interesting array. If there are multiple answers, print any of them.
If the interesting array doesn't exist, print "NO" (without the quotes) in the single line.
Examples
Input
3 1
1 3 3
Output
YES
3 3 3
Input
3 2
1 3 3
1 3 2
Output
NO | instruction | 0 | 69,362 | 12 | 138,724 |
Tags: constructive algorithms, data structures, trees
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
def main():
n,m = map(int,input().split())
dp = [[0]*30 for _ in range(n+2)]
op = []
for _ in range(m):
op.append(tuple(map(int,input().split())))
l,r,q = op[-1]
mask,cou = 1,29
while mask <= q:
if mask&q:
dp[l][cou] += 1
dp[r+1][cou] -= 1
cou -= 1
mask <<= 1
ans = [[0]*30 for _ in range(n)]
for i in range(30):
a = 0
for j in range(n):
a += dp[j+1][i]
dp[j+1][i] = dp[j][i]
if a:
ans[j][i] = 1
dp[j+1][i] += 1
for i in op:
l,r,q = i
mask = 1
for cou in range(29,-1,-1):
if not mask&q and dp[r][cou]-dp[l-1][cou] == r-l+1:
print('NO')
return
mask <<= 1
for i in range(n):
ans[i] = int(''.join(map(str,ans[i])),2)
print('YES')
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 | 69,362 | 12 | 138,725 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We'll call an array of n non-negative integers a[1], a[2], ..., a[n] interesting, if it meets m constraints. The i-th of the m constraints consists of three integers li, ri, qi (1 ≤ li ≤ ri ≤ n) meaning that value <image> should be equal to qi.
Your task is to find any interesting array of n elements or state that such array doesn't exist.
Expression x&y means the bitwise AND of numbers x and y. In programming languages C++, Java and Python this operation is represented as "&", in Pascal — as "and".
Input
The first line contains two integers n, m (1 ≤ n ≤ 105, 1 ≤ m ≤ 105) — the number of elements in the array and the number of limits.
Each of the next m lines contains three integers li, ri, qi (1 ≤ li ≤ ri ≤ n, 0 ≤ qi < 230) describing the i-th limit.
Output
If the interesting array exists, in the first line print "YES" (without the quotes) and in the second line print n integers a[1], a[2], ..., a[n] (0 ≤ a[i] < 230) decribing the interesting array. If there are multiple answers, print any of them.
If the interesting array doesn't exist, print "NO" (without the quotes) in the single line.
Examples
Input
3 1
1 3 3
Output
YES
3 3 3
Input
3 2
1 3 3
1 3 2
Output
NO | instruction | 0 | 69,363 | 12 | 138,726 |
Tags: constructive algorithms, data structures, trees
Correct Solution:
```
import sys
input = sys.stdin.readline
n, m = map(int, input().split())
a = []
for _ in range(m):
l, r, q = map(int, input().split())
l -= 1
r -= 1
a.append((l, r, q))
res = [0] * n
bad = False
for i in range(30):
events = [0] * (n + 1)
for l, r, q in a:
if q & (1 << i):
events[l] += 1
events[r + 1] -= 1
c = 0
for j in range(n):
c += events[j]
if c > 0:
res[j] |= (1 << i)
s = [0] * (n + 1)
for j in range(n):
s[j + 1] = s[j] + ((res[j] >> i) & 1)
for l, r, q in a:
if q & (1 << i) == 0:
if s[r + 1] - s[l] == r - l + 1:
bad = True
break
if bad:
print("NO")
else:
print("YES")
print(*res)
``` | output | 1 | 69,363 | 12 | 138,727 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.