message stringlengths 2 433k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya is now fond of data compression algorithms. He has already studied gz, bz, zip algorithms and many others. Inspired by the new knowledge, Petya is now developing the new compression algorithm which he wants to name dis.
Petya decided to compress tables. He is given a table a consisting of n rows and m columns that is filled with positive integers. He wants to build the table a' consisting of positive integers such that the relative order of the elements in each row and each column remains the same. That is, if in some row i of the initial table ai, j < ai, k, then in the resulting table a'i, j < a'i, k, and if ai, j = ai, k then a'i, j = a'i, k. Similarly, if in some column j of the initial table ai, j < ap, j then in compressed table a'i, j < a'p, j and if ai, j = ap, j then a'i, j = a'p, j.
Because large values require more space to store them, the maximum value in a' should be as small as possible.
Petya is good in theory, however, he needs your help to implement the algorithm.
Input
The first line of the input contains two integers n and m (<image>, the number of rows and the number of columns of the table respectively.
Each of the following n rows contain m integers ai, j (1 ≤ ai, j ≤ 109) that are the values in the table.
Output
Output the compressed table in form of n lines each containing m integers.
If there exist several answers such that the maximum number in the compressed table is minimum possible, you are allowed to output any of them.
Examples
Input
2 2
1 2
3 4
Output
1 2
2 3
Input
4 3
20 10 30
50 40 30
50 60 70
90 80 70
Output
2 1 3
5 4 3
5 6 7
9 8 7
Note
In the first sample test, despite the fact a1, 2 ≠ a21, they are not located in the same row or column so they may become equal after the compression.
Submitted Solution:
```
n,m=map(int,input().split())
a=[list(map(int,input().split())) for i in range(n)]
d={}
E={}
for i in range(n):
for j in range(m): E[a[i][j]]=set()
for i in range(n):
t=sorted([a[i][j] for j in range(m)])
for j in range(m-1):
if t[j]<t[j+1]: E[t[j+1]]|={t[j]}
for j in range(m):
t=sorted([a[i][j] for i in range(n)])
for i in range(n-1):
if t[i]<t[i+1]: E[t[i+1]]|={t[i]}
def fnd(k):
t=d.get(k,0)
if t: return t
if len(E[k])==0: d[k]=1; return 1
t=max({fnd(x) for x in E[k]})+1
d[k]=t; return t
print('\n'.join([' '.join([str(fnd(a[i][j])) for j in range(m)]) for i in range(n)]))
``` | instruction | 0 | 104,896 | 12 | 209,792 |
No | output | 1 | 104,896 | 12 | 209,793 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya is now fond of data compression algorithms. He has already studied gz, bz, zip algorithms and many others. Inspired by the new knowledge, Petya is now developing the new compression algorithm which he wants to name dis.
Petya decided to compress tables. He is given a table a consisting of n rows and m columns that is filled with positive integers. He wants to build the table a' consisting of positive integers such that the relative order of the elements in each row and each column remains the same. That is, if in some row i of the initial table ai, j < ai, k, then in the resulting table a'i, j < a'i, k, and if ai, j = ai, k then a'i, j = a'i, k. Similarly, if in some column j of the initial table ai, j < ap, j then in compressed table a'i, j < a'p, j and if ai, j = ap, j then a'i, j = a'p, j.
Because large values require more space to store them, the maximum value in a' should be as small as possible.
Petya is good in theory, however, he needs your help to implement the algorithm.
Input
The first line of the input contains two integers n and m (<image>, the number of rows and the number of columns of the table respectively.
Each of the following n rows contain m integers ai, j (1 ≤ ai, j ≤ 109) that are the values in the table.
Output
Output the compressed table in form of n lines each containing m integers.
If there exist several answers such that the maximum number in the compressed table is minimum possible, you are allowed to output any of them.
Examples
Input
2 2
1 2
3 4
Output
1 2
2 3
Input
4 3
20 10 30
50 40 30
50 60 70
90 80 70
Output
2 1 3
5 4 3
5 6 7
9 8 7
Note
In the first sample test, despite the fact a1, 2 ≠ a21, they are not located in the same row or column so they may become equal after the compression.
Submitted Solution:
```
from sys import *
setrecursionlimit(1000010)
n,m=map(int,input().split())
a=[list(map(int,input().split())) for i in range(n)]
d={}
E={}
for i in range(n):
for j in range(m): E[a[i][j]]=set()
for i in range(n):
t=sorted(a[i][j] for j in range(m))
for j in range(m-1):
if t[j]<t[j+1]: E[t[j+1]]|={t[j]}
for i in range(m):
t=sorted(a[i][j] for i in range(n))
for i in range(n-1):
if t[i]<t[i+1]: E[t[i+1]]|={t[i]}
def fnd(k):
t=d.get(k,0)
if t: return t
if len(E[k])==0: d[k]=1; return 1
t=max({fnd(x) for x in E[k]})+1
d[k]=t; return t
print('\n'.join([' '.join([str(fnd(a[i][j])) for j in range(m)]) for i in range(n)]))
``` | instruction | 0 | 104,897 | 12 | 209,794 |
No | output | 1 | 104,897 | 12 | 209,795 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya is now fond of data compression algorithms. He has already studied gz, bz, zip algorithms and many others. Inspired by the new knowledge, Petya is now developing the new compression algorithm which he wants to name dis.
Petya decided to compress tables. He is given a table a consisting of n rows and m columns that is filled with positive integers. He wants to build the table a' consisting of positive integers such that the relative order of the elements in each row and each column remains the same. That is, if in some row i of the initial table ai, j < ai, k, then in the resulting table a'i, j < a'i, k, and if ai, j = ai, k then a'i, j = a'i, k. Similarly, if in some column j of the initial table ai, j < ap, j then in compressed table a'i, j < a'p, j and if ai, j = ap, j then a'i, j = a'p, j.
Because large values require more space to store them, the maximum value in a' should be as small as possible.
Petya is good in theory, however, he needs your help to implement the algorithm.
Input
The first line of the input contains two integers n and m (<image>, the number of rows and the number of columns of the table respectively.
Each of the following n rows contain m integers ai, j (1 ≤ ai, j ≤ 109) that are the values in the table.
Output
Output the compressed table in form of n lines each containing m integers.
If there exist several answers such that the maximum number in the compressed table is minimum possible, you are allowed to output any of them.
Examples
Input
2 2
1 2
3 4
Output
1 2
2 3
Input
4 3
20 10 30
50 40 30
50 60 70
90 80 70
Output
2 1 3
5 4 3
5 6 7
9 8 7
Note
In the first sample test, despite the fact a1, 2 ≠ a21, they are not located in the same row or column so they may become equal after the compression.
Submitted Solution:
```
n,m=map(int,input().split())
a=[list(map(int,input().split())) for i in range(n)]
d={}
E={}
for i in range(n):
for j in range(m): E[a[i][j]]=set()
for i in range(n):
t=sorted(a[i][j] for j in range(m))
for j in range(m-1):
if t[j]<t[j+1]: E[t[j+1]]|={t[j]}
for i in range(m):
t=sorted(a[i][j] for i in range(n))
for i in range(n-1):
if t[i]<t[i+1]: E[t[i+1]]|={t[i]}
def fnd(k):
t=d.get(k,0)
if t: return t
if len(E[k])==0: d[k]=1; return 1
t=max({fnd(x) for x in E[k]})+1
d[k]=t; return t
for l,k in sorted([(len(E[x]),x) for x in E])[::-1]: fnd(k)
print('\n'.join([' '.join([str(d[a[i][j]]) for j in range(m)]) for i in range(n)]))
``` | instruction | 0 | 104,898 | 12 | 209,796 |
No | output | 1 | 104,898 | 12 | 209,797 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nicholas has an array a that contains n distinct integers from 1 to n. In other words, Nicholas has a permutation of size n.
Nicholas want the minimum element (integer 1) and the maximum element (integer n) to be as far as possible from each other. He wants to perform exactly one swap in order to maximize the distance between the minimum and the maximum elements. The distance between two elements is considered to be equal to the absolute difference between their positions.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100) — the size of the permutation.
The second line of the input contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ n), where ai is equal to the element at the i-th position.
Output
Print a single integer — the maximum possible distance between the minimum and the maximum elements Nicholas can achieve by performing exactly one swap.
Examples
Input
5
4 5 1 3 2
Output
3
Input
7
1 6 5 3 4 7 2
Output
6
Input
6
6 5 4 3 2 1
Output
5
Note
In the first sample, one may obtain the optimal answer by swapping elements 1 and 2.
In the second sample, the minimum and the maximum elements will be located in the opposite ends of the array if we swap 7 and 2.
In the third sample, the distance between the minimum and the maximum elements is already maximum possible, so we just perform some unnecessary swap, for example, one can swap 5 and 2. | instruction | 0 | 104,899 | 12 | 209,798 |
Tags: constructive algorithms, implementation
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
m1 = 0
m2 = 0
for i, v in enumerate(a):
if v == 1:
m1 = i + 1
elif v == n:
m2 = i + 1
print(max([m1 - 1, n - m1, m2 - 1, n - m2]))
``` | output | 1 | 104,899 | 12 | 209,799 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nicholas has an array a that contains n distinct integers from 1 to n. In other words, Nicholas has a permutation of size n.
Nicholas want the minimum element (integer 1) and the maximum element (integer n) to be as far as possible from each other. He wants to perform exactly one swap in order to maximize the distance between the minimum and the maximum elements. The distance between two elements is considered to be equal to the absolute difference between their positions.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100) — the size of the permutation.
The second line of the input contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ n), where ai is equal to the element at the i-th position.
Output
Print a single integer — the maximum possible distance between the minimum and the maximum elements Nicholas can achieve by performing exactly one swap.
Examples
Input
5
4 5 1 3 2
Output
3
Input
7
1 6 5 3 4 7 2
Output
6
Input
6
6 5 4 3 2 1
Output
5
Note
In the first sample, one may obtain the optimal answer by swapping elements 1 and 2.
In the second sample, the minimum and the maximum elements will be located in the opposite ends of the array if we swap 7 and 2.
In the third sample, the distance between the minimum and the maximum elements is already maximum possible, so we just perform some unnecessary swap, for example, one can swap 5 and 2. | instruction | 0 | 104,900 | 12 | 209,800 |
Tags: constructive algorithms, implementation
Correct Solution:
```
n=int(input())
l=list(map(int,input().split()))
i,j=l.index(1),l.index(n)
print(max(i,j,n-i-1,n-j-1))
``` | output | 1 | 104,900 | 12 | 209,801 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nicholas has an array a that contains n distinct integers from 1 to n. In other words, Nicholas has a permutation of size n.
Nicholas want the minimum element (integer 1) and the maximum element (integer n) to be as far as possible from each other. He wants to perform exactly one swap in order to maximize the distance between the minimum and the maximum elements. The distance between two elements is considered to be equal to the absolute difference between their positions.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100) — the size of the permutation.
The second line of the input contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ n), where ai is equal to the element at the i-th position.
Output
Print a single integer — the maximum possible distance between the minimum and the maximum elements Nicholas can achieve by performing exactly one swap.
Examples
Input
5
4 5 1 3 2
Output
3
Input
7
1 6 5 3 4 7 2
Output
6
Input
6
6 5 4 3 2 1
Output
5
Note
In the first sample, one may obtain the optimal answer by swapping elements 1 and 2.
In the second sample, the minimum and the maximum elements will be located in the opposite ends of the array if we swap 7 and 2.
In the third sample, the distance between the minimum and the maximum elements is already maximum possible, so we just perform some unnecessary swap, for example, one can swap 5 and 2. | instruction | 0 | 104,901 | 12 | 209,802 |
Tags: constructive algorithms, implementation
Correct Solution:
```
#!/usr/bin/python
# -*- coding: UTF-8 -*-
def main():
n = input()
a = input().split(" ")*1
num_1 = a.index('1') + 1
num_max = a.index(str(n)) + 1
max_len = 0
if (max_len < num_max - 1):
max_len = num_max - 1
if (max_len < num_1 - 1):
max_len = num_1 - 1
if (max_len < len(a) - num_max):
max_len = len(a) - num_max
if (max_len < len(a) - num_1):
max_len = len(a) - num_1
print(max_len)
if __name__ == "__main__":
main()
``` | output | 1 | 104,901 | 12 | 209,803 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nicholas has an array a that contains n distinct integers from 1 to n. In other words, Nicholas has a permutation of size n.
Nicholas want the minimum element (integer 1) and the maximum element (integer n) to be as far as possible from each other. He wants to perform exactly one swap in order to maximize the distance between the minimum and the maximum elements. The distance between two elements is considered to be equal to the absolute difference between their positions.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100) — the size of the permutation.
The second line of the input contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ n), where ai is equal to the element at the i-th position.
Output
Print a single integer — the maximum possible distance between the minimum and the maximum elements Nicholas can achieve by performing exactly one swap.
Examples
Input
5
4 5 1 3 2
Output
3
Input
7
1 6 5 3 4 7 2
Output
6
Input
6
6 5 4 3 2 1
Output
5
Note
In the first sample, one may obtain the optimal answer by swapping elements 1 and 2.
In the second sample, the minimum and the maximum elements will be located in the opposite ends of the array if we swap 7 and 2.
In the third sample, the distance between the minimum and the maximum elements is already maximum possible, so we just perform some unnecessary swap, for example, one can swap 5 and 2. | instruction | 0 | 104,902 | 12 | 209,804 |
Tags: constructive algorithms, implementation
Correct Solution:
```
n = int(input())
a = [int(s) for s in input().split(' ')]
m = [a.index(1), a.index(n)]
print(max(max(m), n - min(m) - 1))
``` | output | 1 | 104,902 | 12 | 209,805 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nicholas has an array a that contains n distinct integers from 1 to n. In other words, Nicholas has a permutation of size n.
Nicholas want the minimum element (integer 1) and the maximum element (integer n) to be as far as possible from each other. He wants to perform exactly one swap in order to maximize the distance between the minimum and the maximum elements. The distance between two elements is considered to be equal to the absolute difference between their positions.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100) — the size of the permutation.
The second line of the input contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ n), where ai is equal to the element at the i-th position.
Output
Print a single integer — the maximum possible distance between the minimum and the maximum elements Nicholas can achieve by performing exactly one swap.
Examples
Input
5
4 5 1 3 2
Output
3
Input
7
1 6 5 3 4 7 2
Output
6
Input
6
6 5 4 3 2 1
Output
5
Note
In the first sample, one may obtain the optimal answer by swapping elements 1 and 2.
In the second sample, the minimum and the maximum elements will be located in the opposite ends of the array if we swap 7 and 2.
In the third sample, the distance between the minimum and the maximum elements is already maximum possible, so we just perform some unnecessary swap, for example, one can swap 5 and 2. | instruction | 0 | 104,903 | 12 | 209,806 |
Tags: constructive algorithms, implementation
Correct Solution:
```
count=int(input());
a = [int(x) for x in input().split()];
lowIndex=a.index(1);
highIndex=a.index(count);
print(max(highIndex-0, lowIndex-0, (count-1)-lowIndex, (count-1)-highIndex));
``` | output | 1 | 104,903 | 12 | 209,807 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nicholas has an array a that contains n distinct integers from 1 to n. In other words, Nicholas has a permutation of size n.
Nicholas want the minimum element (integer 1) and the maximum element (integer n) to be as far as possible from each other. He wants to perform exactly one swap in order to maximize the distance between the minimum and the maximum elements. The distance between two elements is considered to be equal to the absolute difference between their positions.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100) — the size of the permutation.
The second line of the input contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ n), where ai is equal to the element at the i-th position.
Output
Print a single integer — the maximum possible distance between the minimum and the maximum elements Nicholas can achieve by performing exactly one swap.
Examples
Input
5
4 5 1 3 2
Output
3
Input
7
1 6 5 3 4 7 2
Output
6
Input
6
6 5 4 3 2 1
Output
5
Note
In the first sample, one may obtain the optimal answer by swapping elements 1 and 2.
In the second sample, the minimum and the maximum elements will be located in the opposite ends of the array if we swap 7 and 2.
In the third sample, the distance between the minimum and the maximum elements is already maximum possible, so we just perform some unnecessary swap, for example, one can swap 5 and 2. | instruction | 0 | 104,904 | 12 | 209,808 |
Tags: constructive algorithms, implementation
Correct Solution:
```
n=int(input())
a=[int(i) for i in input().split()]
k,l=a.index(1),a.index(n)
print(max(k,l,n-k-1,n-l-1))
``` | output | 1 | 104,904 | 12 | 209,809 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nicholas has an array a that contains n distinct integers from 1 to n. In other words, Nicholas has a permutation of size n.
Nicholas want the minimum element (integer 1) and the maximum element (integer n) to be as far as possible from each other. He wants to perform exactly one swap in order to maximize the distance between the minimum and the maximum elements. The distance between two elements is considered to be equal to the absolute difference between their positions.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100) — the size of the permutation.
The second line of the input contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ n), where ai is equal to the element at the i-th position.
Output
Print a single integer — the maximum possible distance between the minimum and the maximum elements Nicholas can achieve by performing exactly one swap.
Examples
Input
5
4 5 1 3 2
Output
3
Input
7
1 6 5 3 4 7 2
Output
6
Input
6
6 5 4 3 2 1
Output
5
Note
In the first sample, one may obtain the optimal answer by swapping elements 1 and 2.
In the second sample, the minimum and the maximum elements will be located in the opposite ends of the array if we swap 7 and 2.
In the third sample, the distance between the minimum and the maximum elements is already maximum possible, so we just perform some unnecessary swap, for example, one can swap 5 and 2. | instruction | 0 | 104,905 | 12 | 209,810 |
Tags: constructive algorithms, implementation
Correct Solution:
```
n = int(input())
A = [int(x) for x in input().split()]
a, b = A.index(1), A.index(n)
print(max(a, b, n - a - 1, n - b - 1))
``` | output | 1 | 104,905 | 12 | 209,811 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nicholas has an array a that contains n distinct integers from 1 to n. In other words, Nicholas has a permutation of size n.
Nicholas want the minimum element (integer 1) and the maximum element (integer n) to be as far as possible from each other. He wants to perform exactly one swap in order to maximize the distance between the minimum and the maximum elements. The distance between two elements is considered to be equal to the absolute difference between their positions.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100) — the size of the permutation.
The second line of the input contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ n), where ai is equal to the element at the i-th position.
Output
Print a single integer — the maximum possible distance between the minimum and the maximum elements Nicholas can achieve by performing exactly one swap.
Examples
Input
5
4 5 1 3 2
Output
3
Input
7
1 6 5 3 4 7 2
Output
6
Input
6
6 5 4 3 2 1
Output
5
Note
In the first sample, one may obtain the optimal answer by swapping elements 1 and 2.
In the second sample, the minimum and the maximum elements will be located in the opposite ends of the array if we swap 7 and 2.
In the third sample, the distance between the minimum and the maximum elements is already maximum possible, so we just perform some unnecessary swap, for example, one can swap 5 and 2. | instruction | 0 | 104,906 | 12 | 209,812 |
Tags: constructive algorithms, implementation
Correct Solution:
```
n=int(input())
l=list(map(int,input().split()))
i1=l.index(min(l))
i2=l.index(max(l))
print(max((n-1-min(i1,i2)),(max(i1,i2))))
``` | output | 1 | 104,906 | 12 | 209,813 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nicholas has an array a that contains n distinct integers from 1 to n. In other words, Nicholas has a permutation of size n.
Nicholas want the minimum element (integer 1) and the maximum element (integer n) to be as far as possible from each other. He wants to perform exactly one swap in order to maximize the distance between the minimum and the maximum elements. The distance between two elements is considered to be equal to the absolute difference between their positions.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100) — the size of the permutation.
The second line of the input contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ n), where ai is equal to the element at the i-th position.
Output
Print a single integer — the maximum possible distance between the minimum and the maximum elements Nicholas can achieve by performing exactly one swap.
Examples
Input
5
4 5 1 3 2
Output
3
Input
7
1 6 5 3 4 7 2
Output
6
Input
6
6 5 4 3 2 1
Output
5
Note
In the first sample, one may obtain the optimal answer by swapping elements 1 and 2.
In the second sample, the minimum and the maximum elements will be located in the opposite ends of the array if we swap 7 and 2.
In the third sample, the distance between the minimum and the maximum elements is already maximum possible, so we just perform some unnecessary swap, for example, one can swap 5 and 2.
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
idx1 = a.index(1)
idxN = a.index(n)
if(idxN-idx1>0):
if(n-1-idxN>idx1-0):
ans = n-1-idx1
else:
ans = idxN
else:
if(n-1-idx1>idxN-0):
ans = n-1-idxN
else:
ans = idx1
print(ans)
``` | instruction | 0 | 104,907 | 12 | 209,814 |
Yes | output | 1 | 104,907 | 12 | 209,815 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nicholas has an array a that contains n distinct integers from 1 to n. In other words, Nicholas has a permutation of size n.
Nicholas want the minimum element (integer 1) and the maximum element (integer n) to be as far as possible from each other. He wants to perform exactly one swap in order to maximize the distance between the minimum and the maximum elements. The distance between two elements is considered to be equal to the absolute difference between their positions.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100) — the size of the permutation.
The second line of the input contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ n), where ai is equal to the element at the i-th position.
Output
Print a single integer — the maximum possible distance between the minimum and the maximum elements Nicholas can achieve by performing exactly one swap.
Examples
Input
5
4 5 1 3 2
Output
3
Input
7
1 6 5 3 4 7 2
Output
6
Input
6
6 5 4 3 2 1
Output
5
Note
In the first sample, one may obtain the optimal answer by swapping elements 1 and 2.
In the second sample, the minimum and the maximum elements will be located in the opposite ends of the array if we swap 7 and 2.
In the third sample, the distance between the minimum and the maximum elements is already maximum possible, so we just perform some unnecessary swap, for example, one can swap 5 and 2.
Submitted Solution:
```
n = int(input())
data = list(map(int, input().split()))
indexmax = data.index(max(data))
indexmin = data.index(min(data))
print(max(indexmax, indexmin, n - indexmax - 1, n - indexmin - 1))
``` | instruction | 0 | 104,908 | 12 | 209,816 |
Yes | output | 1 | 104,908 | 12 | 209,817 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nicholas has an array a that contains n distinct integers from 1 to n. In other words, Nicholas has a permutation of size n.
Nicholas want the minimum element (integer 1) and the maximum element (integer n) to be as far as possible from each other. He wants to perform exactly one swap in order to maximize the distance between the minimum and the maximum elements. The distance between two elements is considered to be equal to the absolute difference between their positions.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100) — the size of the permutation.
The second line of the input contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ n), where ai is equal to the element at the i-th position.
Output
Print a single integer — the maximum possible distance between the minimum and the maximum elements Nicholas can achieve by performing exactly one swap.
Examples
Input
5
4 5 1 3 2
Output
3
Input
7
1 6 5 3 4 7 2
Output
6
Input
6
6 5 4 3 2 1
Output
5
Note
In the first sample, one may obtain the optimal answer by swapping elements 1 and 2.
In the second sample, the minimum and the maximum elements will be located in the opposite ends of the array if we swap 7 and 2.
In the third sample, the distance between the minimum and the maximum elements is already maximum possible, so we just perform some unnecessary swap, for example, one can swap 5 and 2.
Submitted Solution:
```
n = int(input())
a = [int(x) for x in input().split()]
c1, c2 = -1, -1
for i in range(n):
if a[i] == 1:
c1 = i
if a[i] == n:
c2 = i
print(max(abs(c1 - c2), c1, c2, n - 1 - c1, n - 1 - c2))
``` | instruction | 0 | 104,909 | 12 | 209,818 |
Yes | output | 1 | 104,909 | 12 | 209,819 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nicholas has an array a that contains n distinct integers from 1 to n. In other words, Nicholas has a permutation of size n.
Nicholas want the minimum element (integer 1) and the maximum element (integer n) to be as far as possible from each other. He wants to perform exactly one swap in order to maximize the distance between the minimum and the maximum elements. The distance between two elements is considered to be equal to the absolute difference between their positions.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100) — the size of the permutation.
The second line of the input contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ n), where ai is equal to the element at the i-th position.
Output
Print a single integer — the maximum possible distance between the minimum and the maximum elements Nicholas can achieve by performing exactly one swap.
Examples
Input
5
4 5 1 3 2
Output
3
Input
7
1 6 5 3 4 7 2
Output
6
Input
6
6 5 4 3 2 1
Output
5
Note
In the first sample, one may obtain the optimal answer by swapping elements 1 and 2.
In the second sample, the minimum and the maximum elements will be located in the opposite ends of the array if we swap 7 and 2.
In the third sample, the distance between the minimum and the maximum elements is already maximum possible, so we just perform some unnecessary swap, for example, one can swap 5 and 2.
Submitted Solution:
```
n = int(input())
arr = list(map(int, input().split()))
l, r = arr.index(min(arr)) + 1, arr.index(max(arr)) + 1
print(max(l - 1, r - 1, n - l, n - r))
``` | instruction | 0 | 104,910 | 12 | 209,820 |
Yes | output | 1 | 104,910 | 12 | 209,821 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nicholas has an array a that contains n distinct integers from 1 to n. In other words, Nicholas has a permutation of size n.
Nicholas want the minimum element (integer 1) and the maximum element (integer n) to be as far as possible from each other. He wants to perform exactly one swap in order to maximize the distance between the minimum and the maximum elements. The distance between two elements is considered to be equal to the absolute difference between their positions.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100) — the size of the permutation.
The second line of the input contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ n), where ai is equal to the element at the i-th position.
Output
Print a single integer — the maximum possible distance between the minimum and the maximum elements Nicholas can achieve by performing exactly one swap.
Examples
Input
5
4 5 1 3 2
Output
3
Input
7
1 6 5 3 4 7 2
Output
6
Input
6
6 5 4 3 2 1
Output
5
Note
In the first sample, one may obtain the optimal answer by swapping elements 1 and 2.
In the second sample, the minimum and the maximum elements will be located in the opposite ends of the array if we swap 7 and 2.
In the third sample, the distance between the minimum and the maximum elements is already maximum possible, so we just perform some unnecessary swap, for example, one can swap 5 and 2.
Submitted Solution:
```
import math
n=int(input())
a=[int(i) for i in input().split()]
q=max(a)
w=min(a)
e=a.index(q)
d=a.index(w)
f=abs(e-d)
if(e>d):
count=f+(len(a)-1)-e
else:
count=f+(len(a)-1)-d
print(count)
``` | instruction | 0 | 104,911 | 12 | 209,822 |
No | output | 1 | 104,911 | 12 | 209,823 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nicholas has an array a that contains n distinct integers from 1 to n. In other words, Nicholas has a permutation of size n.
Nicholas want the minimum element (integer 1) and the maximum element (integer n) to be as far as possible from each other. He wants to perform exactly one swap in order to maximize the distance between the minimum and the maximum elements. The distance between two elements is considered to be equal to the absolute difference between their positions.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100) — the size of the permutation.
The second line of the input contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ n), where ai is equal to the element at the i-th position.
Output
Print a single integer — the maximum possible distance between the minimum and the maximum elements Nicholas can achieve by performing exactly one swap.
Examples
Input
5
4 5 1 3 2
Output
3
Input
7
1 6 5 3 4 7 2
Output
6
Input
6
6 5 4 3 2 1
Output
5
Note
In the first sample, one may obtain the optimal answer by swapping elements 1 and 2.
In the second sample, the minimum and the maximum elements will be located in the opposite ends of the array if we swap 7 and 2.
In the third sample, the distance between the minimum and the maximum elements is already maximum possible, so we just perform some unnecessary swap, for example, one can swap 5 and 2.
Submitted Solution:
```
n = int(input())
A = list(map(int, input().split()))
min = 0
max = n-1
for i in range(n):
if A[i] > A[max]:
max = i
if A[i] < A[min]:
min = i
if min == 0 or min == n-1 or max == 0 or max == n-1:
print(n-1)
else:
distance = 0
if n-1-min > n-1-max:
distance = n-1-min
else:
distance = n-1-max
if min-0 > max-0:
distance = min-0
else:
distance = max-0
print(distance)
``` | instruction | 0 | 104,912 | 12 | 209,824 |
No | output | 1 | 104,912 | 12 | 209,825 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nicholas has an array a that contains n distinct integers from 1 to n. In other words, Nicholas has a permutation of size n.
Nicholas want the minimum element (integer 1) and the maximum element (integer n) to be as far as possible from each other. He wants to perform exactly one swap in order to maximize the distance between the minimum and the maximum elements. The distance between two elements is considered to be equal to the absolute difference between their positions.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100) — the size of the permutation.
The second line of the input contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ n), where ai is equal to the element at the i-th position.
Output
Print a single integer — the maximum possible distance between the minimum and the maximum elements Nicholas can achieve by performing exactly one swap.
Examples
Input
5
4 5 1 3 2
Output
3
Input
7
1 6 5 3 4 7 2
Output
6
Input
6
6 5 4 3 2 1
Output
5
Note
In the first sample, one may obtain the optimal answer by swapping elements 1 and 2.
In the second sample, the minimum and the maximum elements will be located in the opposite ends of the array if we swap 7 and 2.
In the third sample, the distance between the minimum and the maximum elements is already maximum possible, so we just perform some unnecessary swap, for example, one can swap 5 and 2.
Submitted Solution:
```
n = int(input())
l = list(map(int, input().split()))
ma = l.index(max(l))
mi = l.index(min(l))
print(max(abs(ma-mi), abs(ma-mi+max(mi+1, n-ma-1))))
``` | instruction | 0 | 104,913 | 12 | 209,826 |
No | output | 1 | 104,913 | 12 | 209,827 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nicholas has an array a that contains n distinct integers from 1 to n. In other words, Nicholas has a permutation of size n.
Nicholas want the minimum element (integer 1) and the maximum element (integer n) to be as far as possible from each other. He wants to perform exactly one swap in order to maximize the distance between the minimum and the maximum elements. The distance between two elements is considered to be equal to the absolute difference between their positions.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100) — the size of the permutation.
The second line of the input contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ n), where ai is equal to the element at the i-th position.
Output
Print a single integer — the maximum possible distance between the minimum and the maximum elements Nicholas can achieve by performing exactly one swap.
Examples
Input
5
4 5 1 3 2
Output
3
Input
7
1 6 5 3 4 7 2
Output
6
Input
6
6 5 4 3 2 1
Output
5
Note
In the first sample, one may obtain the optimal answer by swapping elements 1 and 2.
In the second sample, the minimum and the maximum elements will be located in the opposite ends of the array if we swap 7 and 2.
In the third sample, the distance between the minimum and the maximum elements is already maximum possible, so we just perform some unnecessary swap, for example, one can swap 5 and 2.
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
max_distance = 0
index_max = a.index(max(a))
index_min = a.index(min(a))
if index_min < index_max:
if index_min + 1 > n - index_max + 1:
a[0], a[index_min] = a[index_min], a[0]
else:
a[-1], a[index_max] = a[index_max], a[-1]
else:
if index_max + 1 > n - index_min + 1:
a[0], a[index_max] = a[index_max], a[0]
else:
a[-1], a[index_min] = a[index_min], a[-1]
index_max = a.index(max(a))
index_min = a.index(min(a))
print(max(index_max, index_min) - min(index_max, index_min))
``` | instruction | 0 | 104,914 | 12 | 209,828 |
No | output | 1 | 104,914 | 12 | 209,829 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a sequence of N integers: A_1,A_2,...,A_N.
Find the number of permutations p_1,p_2,...,p_N of 1,2,...,N that can be changed to A_1,A_2,...,A_N by performing the following operation some number of times (possibly zero), modulo 998244353:
* For each 1\leq i\leq N, let q_i=min(p_{i-1},p_{i}), where p_0=p_N. Replace the sequence p with the sequence q.
Constraints
* 1 \leq N \leq 3 × 10^5
* 1 \leq A_i \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1
:
A_N
Output
Print the number of the sequences that satisfy the condition, modulo 998244353.
Examples
Input
3
1
2
1
Output
2
Input
5
3
1
4
1
5
Output
0
Input
8
4
4
4
1
1
1
2
2
Output
24
Input
6
1
1
6
2
2
2
Output
0 | instruction | 0 | 105,095 | 12 | 210,190 |
"Correct Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
from operator import itemgetter
MOD = 998244353
N,*A = map(int,read().split())
T = A.count(1)
if T == 0:
print(0)
exit()
if T == 1:
answer = 1 if len(set(A)) == N else 0
print(answer)
exit()
if T == N:
answer = 1
for n in range(1,N+1):
answer *= n
answer %= MOD
print(answer)
exit()
n = A.index(1)
while A[n-1] == 1:
n -= 1
A = A[n:] + A[:n]
# assert len(A) == N and A[0] == 1 and A[-1] != 1
L = [0] * (N+1)
R = [-1] * (N+1)
ctr = [0] * (N+1)
nums = []
prev = 0
for i,x in enumerate(A):
ctr[x] += 1
R[x] = i
if prev != x:
nums.append(x)
L[x] = i
prev = x
if any(y - x + 1 != z for x,y,z in zip(L,R,ctr)):
print(0)
exit()
if any(x > T for x in ctr[2:]):
print(0)
exit()
free = [0] * (N+1) # ある数値を書き込んだ時点で、死亡確定になってるマス数
answer = 1
for x,y,z in zip(nums,nums[1:],nums[2:]+[1]):
if x > y < z:
if ctr[y] != T:
answer = 0
break
elif x < y < z:
free[y] += ctr[y] - 1
elif x > y > z:
free[y] += ctr[y] - 1
else:
# x < y > z
answer *= (T + 1 - ctr[y])
answer %= MOD
free[y] += ctr[y] + T - 2
f = 0
for n in range(1,N+1):
if ctr[n] >= 1:
f += free[n]
continue
answer *= f
answer %= MOD
f -= 1
print(answer)
``` | output | 1 | 105,095 | 12 | 210,191 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence of N integers: A_1,A_2,...,A_N.
Find the number of permutations p_1,p_2,...,p_N of 1,2,...,N that can be changed to A_1,A_2,...,A_N by performing the following operation some number of times (possibly zero), modulo 998244353:
* For each 1\leq i\leq N, let q_i=min(p_{i-1},p_{i}), where p_0=p_N. Replace the sequence p with the sequence q.
Constraints
* 1 \leq N \leq 3 × 10^5
* 1 \leq A_i \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1
:
A_N
Output
Print the number of the sequences that satisfy the condition, modulo 998244353.
Examples
Input
3
1
2
1
Output
2
Input
5
3
1
4
1
5
Output
0
Input
8
4
4
4
1
1
1
2
2
Output
24
Input
6
1
1
6
2
2
2
Output
0
Submitted Solution:
```
import numpy as np
import sys
M = 998244353
N = int(input())
A = np.empty(N, dtype=np.int64)
for i in range(N):
A[i] = int(input()) - 1
# A[i]: 0,1,...,(N-1)
s=0
if A[0]==A[N-1]:
while (s <= N-1) and (A[s]==A[0]):
s = s+1
if s == N:
if A[0] == 0:
result = 1
for i in range(1,N+1):
result = (result*i) % M
print(result)
else:
print(0)
sys.exit()
lengths = np.zeros(N, dtype=np.int64)
heads = np.zeros(N, dtype=np.int64)
tails = np.zeros(N, dtype=np.int64)
if s > 0:
tail = A[0]
else:
tail = A[N-1]
l = 1
for i in range(s,N):
if (i < N-1) and (A[i+1] == A[i]):
l = l+1
else:
if i < N-1:
if lengths[A[i+1]] > 0:
print(0)
sys.exit()
else:
heads[A[i]] = A[i+1]
else:
heads[A[i]] = A[0]
lengths[A[i]] = l
l=1
tails[A[i]] = tail
tail = A[i]
if s > 0:
heads[A[0]] = A[s]
lengths[A[0]] = lengths[A[0]] + s
k = lengths[0]
if k == 0:
print(0)
sys.exit()
result = 1
killed = 0
for i in range(1,N):
if lengths[i] == 0:
result = (result * killed) % M
killed = killed - 1
elif lengths[i] > k:
print(0)
exit()
elif heads[i] > i and tails[i] > i:
if lengths[i] != k:
print(0)
exit()
elif heads[i] < i and tails[i] < i:
result = (result * (k-lengths[i]+1)) % M
killed = killed + (lengths[i]+k-2)
else:
# head < i and tail > i
# head > i and tail < i
killed = killed + (lengths[i]-1)
print(result)
``` | instruction | 0 | 105,097 | 12 | 210,194 |
No | output | 1 | 105,097 | 12 | 210,195 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya collects beautiful matrix.
A matrix of size n × n is beautiful if:
* All elements of the matrix are integers between 1 and n;
* For every row of the matrix, all elements of this row are different;
* For every pair of vertically adjacent elements, these elements are different.
Today Petya bought a beautiful matrix a of size n × n, and now he wants to determine its rarity.
The rarity of the matrix is its index in the list of beautiful matrices of size n × n, sorted in lexicographical order. Matrix comparison is done row by row. (The index of lexicographically smallest matrix is zero).
Since the number of beautiful matrices may be huge, Petya wants you to calculate the rarity of the matrix a modulo 998 244 353.
Input
The first line contains one integer n (1 ≤ n ≤ 2000) — the number of rows and columns in a.
Each of the next n lines contains n integers a_{i,j} (1 ≤ a_{i,j} ≤ n) — the elements of a.
It is guaranteed that a is a beautiful matrix.
Output
Print one integer — the rarity of matrix a, taken modulo 998 244 353.
Examples
Input
2
2 1
1 2
Output
1
Input
3
1 2 3
2 3 1
3 1 2
Output
1
Input
3
1 2 3
3 1 2
2 3 1
Output
3
Note
There are only 2 beautiful matrices of size 2 × 2:
<image>
There are the first 5 beautiful matrices of size 3 × 3 in lexicographical order:
<image>
Submitted Solution:
```
s = input()
if s == "2 2 1 1 2":
print ("1")
if s == "3 1 2 3 2 3 1 3 1 2":
print("1")
if s == "3 1 2 3 3 1 2 2 3 1":
print("3")
``` | instruction | 0 | 105,287 | 12 | 210,574 |
No | output | 1 | 105,287 | 12 | 210,575 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given two arrays a[1 ... n] and b[1 ... n], both of the same length n.
In order to perform a push operation, you have to choose three integers l, r, k satisfying 1 ≤ l ≤ r ≤ n and k > 0. Then, you will add k to elements a_l, a_{l+1}, …, a_r.
For example, if a = [3, 7, 1, 4, 1, 2] and you choose (l = 3, r = 5, k = 2), the array a will become [3, 7, \underline{3, 6, 3}, 2].
You can do this operation at most once. Can you make array a equal to array b?
(We consider that a = b if and only if, for every 1 ≤ i ≤ n, a_i = b_i)
Input
The first line contains a single integer t (1 ≤ t ≤ 20) — the number of test cases in the input.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100\ 000) — the number of elements in each array.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 1000).
The third line of each test case contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 1000).
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
For each test case, output one line containing "YES" if it's possible to make arrays a and b equal by performing at most once the described operation or "NO" if it's impossible.
You can print each letter in any case (upper or lower).
Example
Input
4
6
3 7 1 4 1 2
3 7 3 6 3 2
5
1 1 1 1 1
1 2 1 3 1
2
42 42
42 42
1
7
6
Output
YES
NO
YES
NO
Note
The first test case is described in the statement: we can perform a push operation with parameters (l=3, r=5, k=2) to make a equal to b.
In the second test case, we would need at least two operations to make a equal to b.
In the third test case, arrays a and b are already equal.
In the fourth test case, it's impossible to make a equal to b, because the integer k has to be positive. | instruction | 0 | 105,355 | 12 | 210,710 |
Tags: implementation
Correct Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = []
for a,b in zip(A,B):
C.append(b-a)
cur = C[0]
X = []
for i in range(n):
if C[i] == cur:
continue
else:
if cur != 0:
X.append(cur)
cur = C[i]
else:
if cur != 0:
X.append(cur)
#print(X)
if not X:
print('YES')
elif len(X) == 1 and X[0] > 0:
print('YES')
else:
print('NO')
``` | output | 1 | 105,355 | 12 | 210,711 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given two arrays a[1 ... n] and b[1 ... n], both of the same length n.
In order to perform a push operation, you have to choose three integers l, r, k satisfying 1 ≤ l ≤ r ≤ n and k > 0. Then, you will add k to elements a_l, a_{l+1}, …, a_r.
For example, if a = [3, 7, 1, 4, 1, 2] and you choose (l = 3, r = 5, k = 2), the array a will become [3, 7, \underline{3, 6, 3}, 2].
You can do this operation at most once. Can you make array a equal to array b?
(We consider that a = b if and only if, for every 1 ≤ i ≤ n, a_i = b_i)
Input
The first line contains a single integer t (1 ≤ t ≤ 20) — the number of test cases in the input.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100\ 000) — the number of elements in each array.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 1000).
The third line of each test case contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 1000).
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
For each test case, output one line containing "YES" if it's possible to make arrays a and b equal by performing at most once the described operation or "NO" if it's impossible.
You can print each letter in any case (upper or lower).
Example
Input
4
6
3 7 1 4 1 2
3 7 3 6 3 2
5
1 1 1 1 1
1 2 1 3 1
2
42 42
42 42
1
7
6
Output
YES
NO
YES
NO
Note
The first test case is described in the statement: we can perform a push operation with parameters (l=3, r=5, k=2) to make a equal to b.
In the second test case, we would need at least two operations to make a equal to b.
In the third test case, arrays a and b are already equal.
In the fourth test case, it's impossible to make a equal to b, because the integer k has to be positive. | instruction | 0 | 105,356 | 12 | 210,712 |
Tags: implementation
Correct Solution:
```
#for _ in range(int(input())):
#for _ in range(9): print (input().replace('2','1'))
for k in range(int(input())):
n=int(input())
arr=list(map(int,input().split()))
ls=list(map(int,input().split()))
i=0
j=n-1
flag=0
while i<j and (arr[i]==ls[i] or arr[j]==ls[j]):
if arr[i]==ls[i]:
i+=1
if arr[j]==ls[j]:
j-=1
dif=ls[i]-arr[i]
for i in range(i,j+1):
if ls[i]-arr[i]==dif and dif>=0:
pass
else:
flag=1
print("NO")
break
if flag==0:
print("YES")
``` | output | 1 | 105,356 | 12 | 210,713 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given two arrays a[1 ... n] and b[1 ... n], both of the same length n.
In order to perform a push operation, you have to choose three integers l, r, k satisfying 1 ≤ l ≤ r ≤ n and k > 0. Then, you will add k to elements a_l, a_{l+1}, …, a_r.
For example, if a = [3, 7, 1, 4, 1, 2] and you choose (l = 3, r = 5, k = 2), the array a will become [3, 7, \underline{3, 6, 3}, 2].
You can do this operation at most once. Can you make array a equal to array b?
(We consider that a = b if and only if, for every 1 ≤ i ≤ n, a_i = b_i)
Input
The first line contains a single integer t (1 ≤ t ≤ 20) — the number of test cases in the input.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100\ 000) — the number of elements in each array.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 1000).
The third line of each test case contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 1000).
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
For each test case, output one line containing "YES" if it's possible to make arrays a and b equal by performing at most once the described operation or "NO" if it's impossible.
You can print each letter in any case (upper or lower).
Example
Input
4
6
3 7 1 4 1 2
3 7 3 6 3 2
5
1 1 1 1 1
1 2 1 3 1
2
42 42
42 42
1
7
6
Output
YES
NO
YES
NO
Note
The first test case is described in the statement: we can perform a push operation with parameters (l=3, r=5, k=2) to make a equal to b.
In the second test case, we would need at least two operations to make a equal to b.
In the third test case, arrays a and b are already equal.
In the fourth test case, it's impossible to make a equal to b, because the integer k has to be positive. | instruction | 0 | 105,357 | 12 | 210,714 |
Tags: implementation
Correct Solution:
```
for _ in range(int(input())):
#a,b,n,s=map(int, input().split())
n=int(input())
a=list(map(int, input().split()))
b=list(map(int, input().split()))
diff=[]
for i in range(n):
diff.append(b[i]-a[i])
k=list(set(diff))
if min(k)<0: print("NO")
elif len(k)==1: print("YES")
elif len(k)>2: print("NO")
elif len(k)==2 and diff.count(0)==0: print("NO")
else:
for i in k:
if i!=0: x=i
if n-diff[::-1].index(x)-diff.index(x)==diff.count(x):
print("YES")
else: print("NO")
``` | output | 1 | 105,357 | 12 | 210,715 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given two arrays a[1 ... n] and b[1 ... n], both of the same length n.
In order to perform a push operation, you have to choose three integers l, r, k satisfying 1 ≤ l ≤ r ≤ n and k > 0. Then, you will add k to elements a_l, a_{l+1}, …, a_r.
For example, if a = [3, 7, 1, 4, 1, 2] and you choose (l = 3, r = 5, k = 2), the array a will become [3, 7, \underline{3, 6, 3}, 2].
You can do this operation at most once. Can you make array a equal to array b?
(We consider that a = b if and only if, for every 1 ≤ i ≤ n, a_i = b_i)
Input
The first line contains a single integer t (1 ≤ t ≤ 20) — the number of test cases in the input.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100\ 000) — the number of elements in each array.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 1000).
The third line of each test case contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 1000).
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
For each test case, output one line containing "YES" if it's possible to make arrays a and b equal by performing at most once the described operation or "NO" if it's impossible.
You can print each letter in any case (upper or lower).
Example
Input
4
6
3 7 1 4 1 2
3 7 3 6 3 2
5
1 1 1 1 1
1 2 1 3 1
2
42 42
42 42
1
7
6
Output
YES
NO
YES
NO
Note
The first test case is described in the statement: we can perform a push operation with parameters (l=3, r=5, k=2) to make a equal to b.
In the second test case, we would need at least two operations to make a equal to b.
In the third test case, arrays a and b are already equal.
In the fourth test case, it's impossible to make a equal to b, because the integer k has to be positive. | instruction | 0 | 105,358 | 12 | 210,716 |
Tags: implementation
Correct Solution:
```
import sys
tests = int(sys.stdin.readline())
for _ in range(tests):
n = int(sys.stdin.readline())
arr1 = list(map(int, sys.stdin.readline().split()))
arr2 = list(map(int, sys.stdin.readline().split()))
result = []
ok = True
for i in range(n):
if arr1[i] != arr2[i]:
result.append([arr1[i] - arr2[i], i])
if (arr1[i] > arr2[i]):
ok = False
if len(result) == 0:
print('YES')
else:
resultt = sorted(result, key=lambda el: el[0])
for i in range(1, len(resultt)):
if resultt[i][0] != resultt[i-1][0]:
ok = False
break
resultt2 = sorted(result, key=lambda el: el[1])
for i in range(1, len(resultt2)):
if resultt2[i][0] == resultt2[i-1][0] and resultt2[i][1] != resultt2[i-1][1]+1:
ok = False
break
if ok:
print('YES')
else:
print('NO')
``` | output | 1 | 105,358 | 12 | 210,717 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given two arrays a[1 ... n] and b[1 ... n], both of the same length n.
In order to perform a push operation, you have to choose three integers l, r, k satisfying 1 ≤ l ≤ r ≤ n and k > 0. Then, you will add k to elements a_l, a_{l+1}, …, a_r.
For example, if a = [3, 7, 1, 4, 1, 2] and you choose (l = 3, r = 5, k = 2), the array a will become [3, 7, \underline{3, 6, 3}, 2].
You can do this operation at most once. Can you make array a equal to array b?
(We consider that a = b if and only if, for every 1 ≤ i ≤ n, a_i = b_i)
Input
The first line contains a single integer t (1 ≤ t ≤ 20) — the number of test cases in the input.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100\ 000) — the number of elements in each array.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 1000).
The third line of each test case contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 1000).
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
For each test case, output one line containing "YES" if it's possible to make arrays a and b equal by performing at most once the described operation or "NO" if it's impossible.
You can print each letter in any case (upper or lower).
Example
Input
4
6
3 7 1 4 1 2
3 7 3 6 3 2
5
1 1 1 1 1
1 2 1 3 1
2
42 42
42 42
1
7
6
Output
YES
NO
YES
NO
Note
The first test case is described in the statement: we can perform a push operation with parameters (l=3, r=5, k=2) to make a equal to b.
In the second test case, we would need at least two operations to make a equal to b.
In the third test case, arrays a and b are already equal.
In the fourth test case, it's impossible to make a equal to b, because the integer k has to be positive. | instruction | 0 | 105,359 | 12 | 210,718 |
Tags: implementation
Correct Solution:
```
t=int(input())
while(t):
t-=1
n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
flag=0
di=0
flag2=0
flag3=0
j=0
for i in range(n):
if(a[i]==b[i]):
if(flag==1):
j=i
flag3=1
break
else:
continue
flag=1
if(di==0):
if(b[i]-a[i]<0):
flag2=1
break
di=b[i]-a[i]
else:
if(b[i]-a[i]!=di):
flag2=1
break
if(flag3==1):
for i in range(j+1,n):
if(a[i]!=b[i]):
flag2=1
break
if(flag2==1):
print("NO")
else:
print("YES")
``` | output | 1 | 105,359 | 12 | 210,719 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given two arrays a[1 ... n] and b[1 ... n], both of the same length n.
In order to perform a push operation, you have to choose three integers l, r, k satisfying 1 ≤ l ≤ r ≤ n and k > 0. Then, you will add k to elements a_l, a_{l+1}, …, a_r.
For example, if a = [3, 7, 1, 4, 1, 2] and you choose (l = 3, r = 5, k = 2), the array a will become [3, 7, \underline{3, 6, 3}, 2].
You can do this operation at most once. Can you make array a equal to array b?
(We consider that a = b if and only if, for every 1 ≤ i ≤ n, a_i = b_i)
Input
The first line contains a single integer t (1 ≤ t ≤ 20) — the number of test cases in the input.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100\ 000) — the number of elements in each array.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 1000).
The third line of each test case contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 1000).
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
For each test case, output one line containing "YES" if it's possible to make arrays a and b equal by performing at most once the described operation or "NO" if it's impossible.
You can print each letter in any case (upper or lower).
Example
Input
4
6
3 7 1 4 1 2
3 7 3 6 3 2
5
1 1 1 1 1
1 2 1 3 1
2
42 42
42 42
1
7
6
Output
YES
NO
YES
NO
Note
The first test case is described in the statement: we can perform a push operation with parameters (l=3, r=5, k=2) to make a equal to b.
In the second test case, we would need at least two operations to make a equal to b.
In the third test case, arrays a and b are already equal.
In the fourth test case, it's impossible to make a equal to b, because the integer k has to be positive. | instruction | 0 | 105,360 | 12 | 210,720 |
Tags: implementation
Correct Solution:
```
for i in range(int(input())):
N = int(input())
A = [int(x) for x in input().strip().split()]
B = [int(x) for x in input().strip().split()]
D = [B[i]-A[i] for i in range(N)]
S = False
Z = False
v = 0
for i, val in enumerate(D):
if S and val == 0: Z = True
elif (S and val != 0 and val != v) or (Z and val != 0):
print("NO")
break
elif val != 0 and not S:
v = val
if val < 0:
print("NO")
break
S = True
else: print("YES")
``` | output | 1 | 105,360 | 12 | 210,721 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given two arrays a[1 ... n] and b[1 ... n], both of the same length n.
In order to perform a push operation, you have to choose three integers l, r, k satisfying 1 ≤ l ≤ r ≤ n and k > 0. Then, you will add k to elements a_l, a_{l+1}, …, a_r.
For example, if a = [3, 7, 1, 4, 1, 2] and you choose (l = 3, r = 5, k = 2), the array a will become [3, 7, \underline{3, 6, 3}, 2].
You can do this operation at most once. Can you make array a equal to array b?
(We consider that a = b if and only if, for every 1 ≤ i ≤ n, a_i = b_i)
Input
The first line contains a single integer t (1 ≤ t ≤ 20) — the number of test cases in the input.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100\ 000) — the number of elements in each array.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 1000).
The third line of each test case contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 1000).
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
For each test case, output one line containing "YES" if it's possible to make arrays a and b equal by performing at most once the described operation or "NO" if it's impossible.
You can print each letter in any case (upper or lower).
Example
Input
4
6
3 7 1 4 1 2
3 7 3 6 3 2
5
1 1 1 1 1
1 2 1 3 1
2
42 42
42 42
1
7
6
Output
YES
NO
YES
NO
Note
The first test case is described in the statement: we can perform a push operation with parameters (l=3, r=5, k=2) to make a equal to b.
In the second test case, we would need at least two operations to make a equal to b.
In the third test case, arrays a and b are already equal.
In the fourth test case, it's impossible to make a equal to b, because the integer k has to be positive. | instruction | 0 | 105,361 | 12 | 210,722 |
Tags: implementation
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
k = list(map(int,input().split()))
l = list(map(int,input().split()))
h = [l[i]-k[i] for i in range(n)]
d = []
f = 0
for i in range(n-1):
if h[i]<0:
f=1
break
if h[i]!=h[i+1]:
d.append(h[i])
if h[-1]<0:
f=1
d.append(h[-1])
if f==1 or len(d)>3:
print("NO")
elif len(d)==3:
if d[0]==0 and d[-1]==0:
print("YES")
else:
print("NO")
elif len(d)==2:
if d[0]==0 or d[1] ==0:
print("YES")
else:
print("NO")
else:
print("YES")
``` | output | 1 | 105,361 | 12 | 210,723 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You're given two arrays a[1 ... n] and b[1 ... n], both of the same length n.
In order to perform a push operation, you have to choose three integers l, r, k satisfying 1 ≤ l ≤ r ≤ n and k > 0. Then, you will add k to elements a_l, a_{l+1}, …, a_r.
For example, if a = [3, 7, 1, 4, 1, 2] and you choose (l = 3, r = 5, k = 2), the array a will become [3, 7, \underline{3, 6, 3}, 2].
You can do this operation at most once. Can you make array a equal to array b?
(We consider that a = b if and only if, for every 1 ≤ i ≤ n, a_i = b_i)
Input
The first line contains a single integer t (1 ≤ t ≤ 20) — the number of test cases in the input.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100\ 000) — the number of elements in each array.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 1000).
The third line of each test case contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 1000).
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
For each test case, output one line containing "YES" if it's possible to make arrays a and b equal by performing at most once the described operation or "NO" if it's impossible.
You can print each letter in any case (upper or lower).
Example
Input
4
6
3 7 1 4 1 2
3 7 3 6 3 2
5
1 1 1 1 1
1 2 1 3 1
2
42 42
42 42
1
7
6
Output
YES
NO
YES
NO
Note
The first test case is described in the statement: we can perform a push operation with parameters (l=3, r=5, k=2) to make a equal to b.
In the second test case, we would need at least two operations to make a equal to b.
In the third test case, arrays a and b are already equal.
In the fourth test case, it's impossible to make a equal to b, because the integer k has to be positive. | instruction | 0 | 105,362 | 12 | 210,724 |
Tags: implementation
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
if a == b:
print('YES')
elif a!=b:
c=[]
e = 0
for i in range(n):
d = b[i]-a[i]
c.append(d)
if d<0:
e+=1
else:
e+=0
if e>0:
print('NO')
else:
g = []
f=0
for i in range(1,n):
if c[i]==c[i-1]:
f+=0
else:
f+=1
g.append(i)
if f>2:
print('NO')
elif f==2 :
if c[g[0]-1]==c[g[0]]==0 or c[g[0]-1]==c[g[1]]==0 or c[g[1]-1]==c[g[1]]==0:
print('YES')
else:
print('NO')
elif f==1 and c[g[0]-1]!=0 and c[g[0]]!=0:
print('NO')
else:
print('YES')
``` | output | 1 | 105,362 | 12 | 210,725 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given two arrays a[1 ... n] and b[1 ... n], both of the same length n.
In order to perform a push operation, you have to choose three integers l, r, k satisfying 1 ≤ l ≤ r ≤ n and k > 0. Then, you will add k to elements a_l, a_{l+1}, …, a_r.
For example, if a = [3, 7, 1, 4, 1, 2] and you choose (l = 3, r = 5, k = 2), the array a will become [3, 7, \underline{3, 6, 3}, 2].
You can do this operation at most once. Can you make array a equal to array b?
(We consider that a = b if and only if, for every 1 ≤ i ≤ n, a_i = b_i)
Input
The first line contains a single integer t (1 ≤ t ≤ 20) — the number of test cases in the input.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100\ 000) — the number of elements in each array.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 1000).
The third line of each test case contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 1000).
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
For each test case, output one line containing "YES" if it's possible to make arrays a and b equal by performing at most once the described operation or "NO" if it's impossible.
You can print each letter in any case (upper or lower).
Example
Input
4
6
3 7 1 4 1 2
3 7 3 6 3 2
5
1 1 1 1 1
1 2 1 3 1
2
42 42
42 42
1
7
6
Output
YES
NO
YES
NO
Note
The first test case is described in the statement: we can perform a push operation with parameters (l=3, r=5, k=2) to make a equal to b.
In the second test case, we would need at least two operations to make a equal to b.
In the third test case, arrays a and b are already equal.
In the fourth test case, it's impossible to make a equal to b, because the integer k has to be positive.
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
l1 = []
l2 = []
l1 = list(map(int,input().split()))
l2 = list(map(int,input().split()))
l3 = [i-j for i,j in zip(l1, l2)]
i = 0
j = len(l3) - 1
while i < len(l3) and l3[i] == 0:
i += 1
while j>=0 and l3[j]==0:
j -= 1
if j == -1 or (len(set(l3[i:j+1])) == 1 and l3[i]<0):
print("YES")
else:
print("NO")
``` | instruction | 0 | 105,363 | 12 | 210,726 |
Yes | output | 1 | 105,363 | 12 | 210,727 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given two arrays a[1 ... n] and b[1 ... n], both of the same length n.
In order to perform a push operation, you have to choose three integers l, r, k satisfying 1 ≤ l ≤ r ≤ n and k > 0. Then, you will add k to elements a_l, a_{l+1}, …, a_r.
For example, if a = [3, 7, 1, 4, 1, 2] and you choose (l = 3, r = 5, k = 2), the array a will become [3, 7, \underline{3, 6, 3}, 2].
You can do this operation at most once. Can you make array a equal to array b?
(We consider that a = b if and only if, for every 1 ≤ i ≤ n, a_i = b_i)
Input
The first line contains a single integer t (1 ≤ t ≤ 20) — the number of test cases in the input.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100\ 000) — the number of elements in each array.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 1000).
The third line of each test case contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 1000).
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
For each test case, output one line containing "YES" if it's possible to make arrays a and b equal by performing at most once the described operation or "NO" if it's impossible.
You can print each letter in any case (upper or lower).
Example
Input
4
6
3 7 1 4 1 2
3 7 3 6 3 2
5
1 1 1 1 1
1 2 1 3 1
2
42 42
42 42
1
7
6
Output
YES
NO
YES
NO
Note
The first test case is described in the statement: we can perform a push operation with parameters (l=3, r=5, k=2) to make a equal to b.
In the second test case, we would need at least two operations to make a equal to b.
In the third test case, arrays a and b are already equal.
In the fourth test case, it's impossible to make a equal to b, because the integer k has to be positive.
Submitted Solution:
```
t=int(input())
for r in range(t):
n=int(input())
l1=list(map(int,input().split()))
l2=list(map(int,input().split()))
flag=1
diff=-9999999
count=0
count0=0
for i in range(0,n):
if (l1[i]-l2[i])!=diff:
diff=l1[i]-l2[i]
count+=1
if (l1[i]-l2[i])==0:
count0+=1
if (l1[i]-l2[i])>0:
flag=0
if flag==1 and (count-count0)<=1:
print("YES")
else:
print("NO")
``` | instruction | 0 | 105,364 | 12 | 210,728 |
Yes | output | 1 | 105,364 | 12 | 210,729 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given two arrays a[1 ... n] and b[1 ... n], both of the same length n.
In order to perform a push operation, you have to choose three integers l, r, k satisfying 1 ≤ l ≤ r ≤ n and k > 0. Then, you will add k to elements a_l, a_{l+1}, …, a_r.
For example, if a = [3, 7, 1, 4, 1, 2] and you choose (l = 3, r = 5, k = 2), the array a will become [3, 7, \underline{3, 6, 3}, 2].
You can do this operation at most once. Can you make array a equal to array b?
(We consider that a = b if and only if, for every 1 ≤ i ≤ n, a_i = b_i)
Input
The first line contains a single integer t (1 ≤ t ≤ 20) — the number of test cases in the input.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100\ 000) — the number of elements in each array.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 1000).
The third line of each test case contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 1000).
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
For each test case, output one line containing "YES" if it's possible to make arrays a and b equal by performing at most once the described operation or "NO" if it's impossible.
You can print each letter in any case (upper or lower).
Example
Input
4
6
3 7 1 4 1 2
3 7 3 6 3 2
5
1 1 1 1 1
1 2 1 3 1
2
42 42
42 42
1
7
6
Output
YES
NO
YES
NO
Note
The first test case is described in the statement: we can perform a push operation with parameters (l=3, r=5, k=2) to make a equal to b.
In the second test case, we would need at least two operations to make a equal to b.
In the third test case, arrays a and b are already equal.
In the fourth test case, it's impossible to make a equal to b, because the integer k has to be positive.
Submitted Solution:
```
import sys
for _ in range(int(input())):
n = int(input())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
temp = []
for i in range(n):
temp.append(a[i]-b[i])
prev = sys.maxsize
f,cnt = 0,0
for i in temp:
if i>0:
f = 1
break
elif i<0:
if prev==sys.maxsize:
prev = i
else:
if i!=prev or cnt==1:
f=1
break
elif prev!=sys.maxsize and i==0:
cnt=1
if f==1:
print("NO")
else:
print("YES")
``` | instruction | 0 | 105,365 | 12 | 210,730 |
Yes | output | 1 | 105,365 | 12 | 210,731 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given two arrays a[1 ... n] and b[1 ... n], both of the same length n.
In order to perform a push operation, you have to choose three integers l, r, k satisfying 1 ≤ l ≤ r ≤ n and k > 0. Then, you will add k to elements a_l, a_{l+1}, …, a_r.
For example, if a = [3, 7, 1, 4, 1, 2] and you choose (l = 3, r = 5, k = 2), the array a will become [3, 7, \underline{3, 6, 3}, 2].
You can do this operation at most once. Can you make array a equal to array b?
(We consider that a = b if and only if, for every 1 ≤ i ≤ n, a_i = b_i)
Input
The first line contains a single integer t (1 ≤ t ≤ 20) — the number of test cases in the input.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100\ 000) — the number of elements in each array.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 1000).
The third line of each test case contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 1000).
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
For each test case, output one line containing "YES" if it's possible to make arrays a and b equal by performing at most once the described operation or "NO" if it's impossible.
You can print each letter in any case (upper or lower).
Example
Input
4
6
3 7 1 4 1 2
3 7 3 6 3 2
5
1 1 1 1 1
1 2 1 3 1
2
42 42
42 42
1
7
6
Output
YES
NO
YES
NO
Note
The first test case is described in the statement: we can perform a push operation with parameters (l=3, r=5, k=2) to make a equal to b.
In the second test case, we would need at least two operations to make a equal to b.
In the third test case, arrays a and b are already equal.
In the fourth test case, it's impossible to make a equal to b, because the integer k has to be positive.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
a, b = list(map(int, input().split())), list(map(int, input().split()))
bad = 0
if a == b:
print("YES")
continue
for y in range(n):
if a[y] != b[y]:
i = y
break
for y in range(n - 1, -1, -1):
if a[y] != b[y]:
j = y
break
k = b[i] - a[i]
if k < 0:
print("NO")
continue
for y in range(i + 1, j + 1):
if b[y] - k != a[y]:
bad = 1
break
if bad:
print("NO")
else:
print("YES")
``` | instruction | 0 | 105,366 | 12 | 210,732 |
Yes | output | 1 | 105,366 | 12 | 210,733 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given two arrays a[1 ... n] and b[1 ... n], both of the same length n.
In order to perform a push operation, you have to choose three integers l, r, k satisfying 1 ≤ l ≤ r ≤ n and k > 0. Then, you will add k to elements a_l, a_{l+1}, …, a_r.
For example, if a = [3, 7, 1, 4, 1, 2] and you choose (l = 3, r = 5, k = 2), the array a will become [3, 7, \underline{3, 6, 3}, 2].
You can do this operation at most once. Can you make array a equal to array b?
(We consider that a = b if and only if, for every 1 ≤ i ≤ n, a_i = b_i)
Input
The first line contains a single integer t (1 ≤ t ≤ 20) — the number of test cases in the input.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100\ 000) — the number of elements in each array.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 1000).
The third line of each test case contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 1000).
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
For each test case, output one line containing "YES" if it's possible to make arrays a and b equal by performing at most once the described operation or "NO" if it's impossible.
You can print each letter in any case (upper or lower).
Example
Input
4
6
3 7 1 4 1 2
3 7 3 6 3 2
5
1 1 1 1 1
1 2 1 3 1
2
42 42
42 42
1
7
6
Output
YES
NO
YES
NO
Note
The first test case is described in the statement: we can perform a push operation with parameters (l=3, r=5, k=2) to make a equal to b.
In the second test case, we would need at least two operations to make a equal to b.
In the third test case, arrays a and b are already equal.
In the fourth test case, it's impossible to make a equal to b, because the integer k has to be positive.
Submitted Solution:
```
n = int(input())
aa = []
bb = []
for i in range(n):
input()
aa += [list(map(int, input().split(' ')))]
bb += [list(map(int, input().split(' ')))]
for i in range(n):
a = aa[i]
b = bb[i]
k = 0
d = True
for j in range(len(a)):
if a[j] == b[j]:
continue
else:
if k == 0:
k = b[j] - a[j]
else:
if a[j] + k != b[j]:
d = False
break
if k < 0:
d = False
break
if d:
print("YES")
else:
print("NO")
``` | instruction | 0 | 105,367 | 12 | 210,734 |
No | output | 1 | 105,367 | 12 | 210,735 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given two arrays a[1 ... n] and b[1 ... n], both of the same length n.
In order to perform a push operation, you have to choose three integers l, r, k satisfying 1 ≤ l ≤ r ≤ n and k > 0. Then, you will add k to elements a_l, a_{l+1}, …, a_r.
For example, if a = [3, 7, 1, 4, 1, 2] and you choose (l = 3, r = 5, k = 2), the array a will become [3, 7, \underline{3, 6, 3}, 2].
You can do this operation at most once. Can you make array a equal to array b?
(We consider that a = b if and only if, for every 1 ≤ i ≤ n, a_i = b_i)
Input
The first line contains a single integer t (1 ≤ t ≤ 20) — the number of test cases in the input.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100\ 000) — the number of elements in each array.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 1000).
The third line of each test case contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 1000).
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
For each test case, output one line containing "YES" if it's possible to make arrays a and b equal by performing at most once the described operation or "NO" if it's impossible.
You can print each letter in any case (upper or lower).
Example
Input
4
6
3 7 1 4 1 2
3 7 3 6 3 2
5
1 1 1 1 1
1 2 1 3 1
2
42 42
42 42
1
7
6
Output
YES
NO
YES
NO
Note
The first test case is described in the statement: we can perform a push operation with parameters (l=3, r=5, k=2) to make a equal to b.
In the second test case, we would need at least two operations to make a equal to b.
In the third test case, arrays a and b are already equal.
In the fourth test case, it's impossible to make a equal to b, because the integer k has to be positive.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
li = list(map(int, input().split()))
li1 = list(map(int, input().split()))
st = True
dif = False
tmp = 0
for i in range(n):
if li[i] > li1[i]:
print("NO")
st = False
break
elif li[i] < li1[i]:
if dif == False:
tmp = li1[i] - li[i]
dif = True
else:
if li1[i] - li[i] != tmp:
print("NO")
st = False
break
if st:
print("YES")
``` | instruction | 0 | 105,368 | 12 | 210,736 |
No | output | 1 | 105,368 | 12 | 210,737 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given two arrays a[1 ... n] and b[1 ... n], both of the same length n.
In order to perform a push operation, you have to choose three integers l, r, k satisfying 1 ≤ l ≤ r ≤ n and k > 0. Then, you will add k to elements a_l, a_{l+1}, …, a_r.
For example, if a = [3, 7, 1, 4, 1, 2] and you choose (l = 3, r = 5, k = 2), the array a will become [3, 7, \underline{3, 6, 3}, 2].
You can do this operation at most once. Can you make array a equal to array b?
(We consider that a = b if and only if, for every 1 ≤ i ≤ n, a_i = b_i)
Input
The first line contains a single integer t (1 ≤ t ≤ 20) — the number of test cases in the input.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100\ 000) — the number of elements in each array.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 1000).
The third line of each test case contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 1000).
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
For each test case, output one line containing "YES" if it's possible to make arrays a and b equal by performing at most once the described operation or "NO" if it's impossible.
You can print each letter in any case (upper or lower).
Example
Input
4
6
3 7 1 4 1 2
3 7 3 6 3 2
5
1 1 1 1 1
1 2 1 3 1
2
42 42
42 42
1
7
6
Output
YES
NO
YES
NO
Note
The first test case is described in the statement: we can perform a push operation with parameters (l=3, r=5, k=2) to make a equal to b.
In the second test case, we would need at least two operations to make a equal to b.
In the third test case, arrays a and b are already equal.
In the fourth test case, it's impossible to make a equal to b, because the integer k has to be positive.
Submitted Solution:
```
t=int(input())
for i in range(t):
n=int(input())
l1=input()
l2=input()
l1=map(int,l1.split())
l2=map(int,l2.split())
l1=list(l1)
l2=list(l2)
x=l1[0]-l2[0]
c=0
if x>0:
c=4
for j in range(n):
if l1[j]-l2[j]!=x or l1[j]-l2[j]!=0:
x=l1[j]-l2[j]
if x>0:
c=4
c=c+1
if c>2:
break
if c>2:
print("NO")
else:
print("YES")
``` | instruction | 0 | 105,369 | 12 | 210,738 |
No | output | 1 | 105,369 | 12 | 210,739 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You're given two arrays a[1 ... n] and b[1 ... n], both of the same length n.
In order to perform a push operation, you have to choose three integers l, r, k satisfying 1 ≤ l ≤ r ≤ n and k > 0. Then, you will add k to elements a_l, a_{l+1}, …, a_r.
For example, if a = [3, 7, 1, 4, 1, 2] and you choose (l = 3, r = 5, k = 2), the array a will become [3, 7, \underline{3, 6, 3}, 2].
You can do this operation at most once. Can you make array a equal to array b?
(We consider that a = b if and only if, for every 1 ≤ i ≤ n, a_i = b_i)
Input
The first line contains a single integer t (1 ≤ t ≤ 20) — the number of test cases in the input.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100\ 000) — the number of elements in each array.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 1000).
The third line of each test case contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 1000).
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
For each test case, output one line containing "YES" if it's possible to make arrays a and b equal by performing at most once the described operation or "NO" if it's impossible.
You can print each letter in any case (upper or lower).
Example
Input
4
6
3 7 1 4 1 2
3 7 3 6 3 2
5
1 1 1 1 1
1 2 1 3 1
2
42 42
42 42
1
7
6
Output
YES
NO
YES
NO
Note
The first test case is described in the statement: we can perform a push operation with parameters (l=3, r=5, k=2) to make a equal to b.
In the second test case, we would need at least two operations to make a equal to b.
In the third test case, arrays a and b are already equal.
In the fourth test case, it's impossible to make a equal to b, because the integer k has to be positive.
Submitted Solution:
```
# maa chudaaye duniya
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
discont = []
diff = -10**10
f = True
for i in range(n):
if a[i] != b[i]:
discont.append(i)
if diff == -10**10:
diff = b[i] - a[i]
else:
if diff != b[i]-a[i]:
f = False
break
if f is False:
print('NO')
continue
else:
if discont == []:
print('YES')
else:
x = True
for i in range(1, len(discont)):
if discont[i] - discont[i-1] != 1:
print('NO')
x = False
break
if x and diff > 0:
print('YES')
else:
print('NO')
``` | instruction | 0 | 105,370 | 12 | 210,740 |
No | output | 1 | 105,370 | 12 | 210,741 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two sequences a_1, a_2, ..., a_n and b_1, b_2, ..., b_n. Each element of both sequences is either 0, 1 or 2. The number of elements 0, 1, 2 in the sequence a is x_1, y_1, z_1 respectively, and the number of elements 0, 1, 2 in the sequence b is x_2, y_2, z_2 respectively.
You can rearrange the elements in both sequences a and b however you like. After that, let's define a sequence c as follows:
c_i = \begin{cases} a_i b_i & \mbox{if }a_i > b_i \\\ 0 & \mbox{if }a_i = b_i \\\ -a_i b_i & \mbox{if }a_i < b_i \end{cases}
You'd like to make ∑_{i=1}^n c_i (the sum of all elements of the sequence c) as large as possible. What is the maximum possible sum?
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Each test case consists of two lines. The first line of each test case contains three integers x_1, y_1, z_1 (0 ≤ x_1, y_1, z_1 ≤ 10^8) — the number of 0-s, 1-s and 2-s in the sequence a.
The second line of each test case also contains three integers x_2, y_2, z_2 (0 ≤ x_2, y_2, z_2 ≤ 10^8; x_1 + y_1 + z_1 = x_2 + y_2 + z_2 > 0) — the number of 0-s, 1-s and 2-s in the sequence b.
Output
For each test case, print the maximum possible sum of the sequence c.
Example
Input
3
2 3 2
3 3 1
4 0 1
2 3 0
0 0 1
0 0 1
Output
4
2
0
Note
In the first sample, one of the optimal solutions is:
a = \{2, 0, 1, 1, 0, 2, 1\}
b = \{1, 0, 1, 0, 2, 1, 0\}
c = \{2, 0, 0, 0, 0, 2, 0\}
In the second sample, one of the optimal solutions is:
a = \{0, 2, 0, 0, 0\}
b = \{1, 1, 0, 1, 0\}
c = \{0, 2, 0, 0, 0\}
In the third sample, the only possible solution is:
a = \{2\}
b = \{2\}
c = \{0\} | instruction | 0 | 105,453 | 12 | 210,906 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
for t in range(int(input())):
a = list(map(int,input().split()))
b = list(map(int,input().split()))
ans = 0
while(a[0]):
if(b[2]):
d = min(b[2],a[0])
a[0] -= d
b[2] -= d
else :
if(b[0]):
dd = min(b[0],a[0])
a[0] -= dd
b[0] -= dd
else:
dd = min(b[1],a[0])
a[0] -= dd
b[1] -= dd
while(a[1]):
if(b[0]):
d = min(b[0],a[1])
a[1] -= d
b[0] -= d
else :
if(b[1]):
dd = min(b[1],a[1])
a[1] -= dd
b[1] -= dd
else:
dd = min(b[2],a[1])
ans -= 2*dd
a[1] -= dd
b[2] -= dd
d = min(b[1],a[2])
ans += 2*d
print(ans)
``` | output | 1 | 105,453 | 12 | 210,907 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two sequences a_1, a_2, ..., a_n and b_1, b_2, ..., b_n. Each element of both sequences is either 0, 1 or 2. The number of elements 0, 1, 2 in the sequence a is x_1, y_1, z_1 respectively, and the number of elements 0, 1, 2 in the sequence b is x_2, y_2, z_2 respectively.
You can rearrange the elements in both sequences a and b however you like. After that, let's define a sequence c as follows:
c_i = \begin{cases} a_i b_i & \mbox{if }a_i > b_i \\\ 0 & \mbox{if }a_i = b_i \\\ -a_i b_i & \mbox{if }a_i < b_i \end{cases}
You'd like to make ∑_{i=1}^n c_i (the sum of all elements of the sequence c) as large as possible. What is the maximum possible sum?
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Each test case consists of two lines. The first line of each test case contains three integers x_1, y_1, z_1 (0 ≤ x_1, y_1, z_1 ≤ 10^8) — the number of 0-s, 1-s and 2-s in the sequence a.
The second line of each test case also contains three integers x_2, y_2, z_2 (0 ≤ x_2, y_2, z_2 ≤ 10^8; x_1 + y_1 + z_1 = x_2 + y_2 + z_2 > 0) — the number of 0-s, 1-s and 2-s in the sequence b.
Output
For each test case, print the maximum possible sum of the sequence c.
Example
Input
3
2 3 2
3 3 1
4 0 1
2 3 0
0 0 1
0 0 1
Output
4
2
0
Note
In the first sample, one of the optimal solutions is:
a = \{2, 0, 1, 1, 0, 2, 1\}
b = \{1, 0, 1, 0, 2, 1, 0\}
c = \{2, 0, 0, 0, 0, 2, 0\}
In the second sample, one of the optimal solutions is:
a = \{0, 2, 0, 0, 0\}
b = \{1, 1, 0, 1, 0\}
c = \{0, 2, 0, 0, 0\}
In the third sample, the only possible solution is:
a = \{2\}
b = \{2\}
c = \{0\} | instruction | 0 | 105,454 | 12 | 210,908 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
t=int(input())
for test in range(t):
x0,x1,x2=map(int,input().split())
y0,y1,y2=map(int,input().split())
s=0
m = min(x0,y2)
x0-=m
y2-=m
m = min(x1,y0)
x1-=m
y0-=m
m = min(x2,y1)
x2-=m
y1-=m
s+=2*m
s-=2* min(x1,y2)
print(s)
``` | output | 1 | 105,454 | 12 | 210,909 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two sequences a_1, a_2, ..., a_n and b_1, b_2, ..., b_n. Each element of both sequences is either 0, 1 or 2. The number of elements 0, 1, 2 in the sequence a is x_1, y_1, z_1 respectively, and the number of elements 0, 1, 2 in the sequence b is x_2, y_2, z_2 respectively.
You can rearrange the elements in both sequences a and b however you like. After that, let's define a sequence c as follows:
c_i = \begin{cases} a_i b_i & \mbox{if }a_i > b_i \\\ 0 & \mbox{if }a_i = b_i \\\ -a_i b_i & \mbox{if }a_i < b_i \end{cases}
You'd like to make ∑_{i=1}^n c_i (the sum of all elements of the sequence c) as large as possible. What is the maximum possible sum?
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Each test case consists of two lines. The first line of each test case contains three integers x_1, y_1, z_1 (0 ≤ x_1, y_1, z_1 ≤ 10^8) — the number of 0-s, 1-s and 2-s in the sequence a.
The second line of each test case also contains three integers x_2, y_2, z_2 (0 ≤ x_2, y_2, z_2 ≤ 10^8; x_1 + y_1 + z_1 = x_2 + y_2 + z_2 > 0) — the number of 0-s, 1-s and 2-s in the sequence b.
Output
For each test case, print the maximum possible sum of the sequence c.
Example
Input
3
2 3 2
3 3 1
4 0 1
2 3 0
0 0 1
0 0 1
Output
4
2
0
Note
In the first sample, one of the optimal solutions is:
a = \{2, 0, 1, 1, 0, 2, 1\}
b = \{1, 0, 1, 0, 2, 1, 0\}
c = \{2, 0, 0, 0, 0, 2, 0\}
In the second sample, one of the optimal solutions is:
a = \{0, 2, 0, 0, 0\}
b = \{1, 1, 0, 1, 0\}
c = \{0, 2, 0, 0, 0\}
In the third sample, the only possible solution is:
a = \{2\}
b = \{2\}
c = \{0\} | instruction | 0 | 105,455 | 12 | 210,910 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
t=int(input())
while(t>0):
t=t-1
[x1,y1,z1]=input().split()
[x2,y2,z2]=input().split()
x1=int(x1)
y1=int(y1)
z1=int(z1)
x2=int(x2)
y2=int(y2)
z2=int(z2)
ans=0
if(z1>=y2):
ans=ans+2*y2
if(x1+z1-y2<z2):
ans=ans-2*(z2+y2-z1-x1)
else:
ans=ans+2*z1
if(x1<z2):
ans=ans-2*(z2-x1)
print(ans)
``` | output | 1 | 105,455 | 12 | 210,911 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two sequences a_1, a_2, ..., a_n and b_1, b_2, ..., b_n. Each element of both sequences is either 0, 1 or 2. The number of elements 0, 1, 2 in the sequence a is x_1, y_1, z_1 respectively, and the number of elements 0, 1, 2 in the sequence b is x_2, y_2, z_2 respectively.
You can rearrange the elements in both sequences a and b however you like. After that, let's define a sequence c as follows:
c_i = \begin{cases} a_i b_i & \mbox{if }a_i > b_i \\\ 0 & \mbox{if }a_i = b_i \\\ -a_i b_i & \mbox{if }a_i < b_i \end{cases}
You'd like to make ∑_{i=1}^n c_i (the sum of all elements of the sequence c) as large as possible. What is the maximum possible sum?
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Each test case consists of two lines. The first line of each test case contains three integers x_1, y_1, z_1 (0 ≤ x_1, y_1, z_1 ≤ 10^8) — the number of 0-s, 1-s and 2-s in the sequence a.
The second line of each test case also contains three integers x_2, y_2, z_2 (0 ≤ x_2, y_2, z_2 ≤ 10^8; x_1 + y_1 + z_1 = x_2 + y_2 + z_2 > 0) — the number of 0-s, 1-s and 2-s in the sequence b.
Output
For each test case, print the maximum possible sum of the sequence c.
Example
Input
3
2 3 2
3 3 1
4 0 1
2 3 0
0 0 1
0 0 1
Output
4
2
0
Note
In the first sample, one of the optimal solutions is:
a = \{2, 0, 1, 1, 0, 2, 1\}
b = \{1, 0, 1, 0, 2, 1, 0\}
c = \{2, 0, 0, 0, 0, 2, 0\}
In the second sample, one of the optimal solutions is:
a = \{0, 2, 0, 0, 0\}
b = \{1, 1, 0, 1, 0\}
c = \{0, 2, 0, 0, 0\}
In the third sample, the only possible solution is:
a = \{2\}
b = \{2\}
c = \{0\} | instruction | 0 | 105,456 | 12 | 210,912 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
from sys import *
input = stdin.readline
for _ in range(int(input())):
x1,y1,z1 = map(int,input().split())
x2,y2,z2 = map(int,input().split())
mx = 0
ma2 = min(z1,y2)
mx += ma2*2
z1 -= ma2
y2 -= ma2
mb2 = min(z1,z2)
z1 -= mb2
z2 -= mb2
mb2 = min(x1,z2)
z2 -= mb2
x1 -= mb2
ma1 = min(y1,z2)
z2 -= ma1
y1 -= ma1
mx -= ma1*2
stdout.write(str(mx)+'\n')
``` | output | 1 | 105,456 | 12 | 210,913 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two sequences a_1, a_2, ..., a_n and b_1, b_2, ..., b_n. Each element of both sequences is either 0, 1 or 2. The number of elements 0, 1, 2 in the sequence a is x_1, y_1, z_1 respectively, and the number of elements 0, 1, 2 in the sequence b is x_2, y_2, z_2 respectively.
You can rearrange the elements in both sequences a and b however you like. After that, let's define a sequence c as follows:
c_i = \begin{cases} a_i b_i & \mbox{if }a_i > b_i \\\ 0 & \mbox{if }a_i = b_i \\\ -a_i b_i & \mbox{if }a_i < b_i \end{cases}
You'd like to make ∑_{i=1}^n c_i (the sum of all elements of the sequence c) as large as possible. What is the maximum possible sum?
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Each test case consists of two lines. The first line of each test case contains three integers x_1, y_1, z_1 (0 ≤ x_1, y_1, z_1 ≤ 10^8) — the number of 0-s, 1-s and 2-s in the sequence a.
The second line of each test case also contains three integers x_2, y_2, z_2 (0 ≤ x_2, y_2, z_2 ≤ 10^8; x_1 + y_1 + z_1 = x_2 + y_2 + z_2 > 0) — the number of 0-s, 1-s and 2-s in the sequence b.
Output
For each test case, print the maximum possible sum of the sequence c.
Example
Input
3
2 3 2
3 3 1
4 0 1
2 3 0
0 0 1
0 0 1
Output
4
2
0
Note
In the first sample, one of the optimal solutions is:
a = \{2, 0, 1, 1, 0, 2, 1\}
b = \{1, 0, 1, 0, 2, 1, 0\}
c = \{2, 0, 0, 0, 0, 2, 0\}
In the second sample, one of the optimal solutions is:
a = \{0, 2, 0, 0, 0\}
b = \{1, 1, 0, 1, 0\}
c = \{0, 2, 0, 0, 0\}
In the third sample, the only possible solution is:
a = \{2\}
b = \{2\}
c = \{0\} | instruction | 0 | 105,457 | 12 | 210,914 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
for _ in range(int(input())):
c = 0
x1, y1, z1 = map(int, input().split())
x2, y2, z2 = map(int, input().split())
plus = min(z1, y2)
z1 -= plus
y2 -= plus
c += plus*2
minus = min(y1, z2-x1-z1)
if minus > 0:
c -= minus*2
print(c)
``` | output | 1 | 105,457 | 12 | 210,915 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two sequences a_1, a_2, ..., a_n and b_1, b_2, ..., b_n. Each element of both sequences is either 0, 1 or 2. The number of elements 0, 1, 2 in the sequence a is x_1, y_1, z_1 respectively, and the number of elements 0, 1, 2 in the sequence b is x_2, y_2, z_2 respectively.
You can rearrange the elements in both sequences a and b however you like. After that, let's define a sequence c as follows:
c_i = \begin{cases} a_i b_i & \mbox{if }a_i > b_i \\\ 0 & \mbox{if }a_i = b_i \\\ -a_i b_i & \mbox{if }a_i < b_i \end{cases}
You'd like to make ∑_{i=1}^n c_i (the sum of all elements of the sequence c) as large as possible. What is the maximum possible sum?
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Each test case consists of two lines. The first line of each test case contains three integers x_1, y_1, z_1 (0 ≤ x_1, y_1, z_1 ≤ 10^8) — the number of 0-s, 1-s and 2-s in the sequence a.
The second line of each test case also contains three integers x_2, y_2, z_2 (0 ≤ x_2, y_2, z_2 ≤ 10^8; x_1 + y_1 + z_1 = x_2 + y_2 + z_2 > 0) — the number of 0-s, 1-s and 2-s in the sequence b.
Output
For each test case, print the maximum possible sum of the sequence c.
Example
Input
3
2 3 2
3 3 1
4 0 1
2 3 0
0 0 1
0 0 1
Output
4
2
0
Note
In the first sample, one of the optimal solutions is:
a = \{2, 0, 1, 1, 0, 2, 1\}
b = \{1, 0, 1, 0, 2, 1, 0\}
c = \{2, 0, 0, 0, 0, 2, 0\}
In the second sample, one of the optimal solutions is:
a = \{0, 2, 0, 0, 0\}
b = \{1, 1, 0, 1, 0\}
c = \{0, 2, 0, 0, 0\}
In the third sample, the only possible solution is:
a = \{2\}
b = \{2\}
c = \{0\} | instruction | 0 | 105,458 | 12 | 210,916 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
ts = int(input())
for t in range(ts):
x1, y1, z1 = [int(i) for i in input().split(" ")]
x2, y2, z2 = [int(i) for i in input().split(" ")]
c = 0
if z1<=y2:
c += 2*z1
if z2>x1:
c -= 2*(z2-x1)
else:
c += 2*y2
z11 = x1+z1-y2
if z2>z11:
c -= 2*(z2-z11)
print(c)
``` | output | 1 | 105,458 | 12 | 210,917 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two sequences a_1, a_2, ..., a_n and b_1, b_2, ..., b_n. Each element of both sequences is either 0, 1 or 2. The number of elements 0, 1, 2 in the sequence a is x_1, y_1, z_1 respectively, and the number of elements 0, 1, 2 in the sequence b is x_2, y_2, z_2 respectively.
You can rearrange the elements in both sequences a and b however you like. After that, let's define a sequence c as follows:
c_i = \begin{cases} a_i b_i & \mbox{if }a_i > b_i \\\ 0 & \mbox{if }a_i = b_i \\\ -a_i b_i & \mbox{if }a_i < b_i \end{cases}
You'd like to make ∑_{i=1}^n c_i (the sum of all elements of the sequence c) as large as possible. What is the maximum possible sum?
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Each test case consists of two lines. The first line of each test case contains three integers x_1, y_1, z_1 (0 ≤ x_1, y_1, z_1 ≤ 10^8) — the number of 0-s, 1-s and 2-s in the sequence a.
The second line of each test case also contains three integers x_2, y_2, z_2 (0 ≤ x_2, y_2, z_2 ≤ 10^8; x_1 + y_1 + z_1 = x_2 + y_2 + z_2 > 0) — the number of 0-s, 1-s and 2-s in the sequence b.
Output
For each test case, print the maximum possible sum of the sequence c.
Example
Input
3
2 3 2
3 3 1
4 0 1
2 3 0
0 0 1
0 0 1
Output
4
2
0
Note
In the first sample, one of the optimal solutions is:
a = \{2, 0, 1, 1, 0, 2, 1\}
b = \{1, 0, 1, 0, 2, 1, 0\}
c = \{2, 0, 0, 0, 0, 2, 0\}
In the second sample, one of the optimal solutions is:
a = \{0, 2, 0, 0, 0\}
b = \{1, 1, 0, 1, 0\}
c = \{0, 2, 0, 0, 0\}
In the third sample, the only possible solution is:
a = \{2\}
b = \{2\}
c = \{0\} | instruction | 0 | 105,459 | 12 | 210,918 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
t = int(input())
for i in range(t):
x1,y1,z1 = map(int,input().split())
x2,y2,z2 = map(int,input().split())
if z1 <= y2:
if y2 - z1 + x2 >= y1:
print(2*(z1))
else:
print(2*(y2+ x2 - y1))
else:
if z1-y2+x1 >= z2:
print(2*(y2))
else:
print(2*(z1+x1-z2))
``` | output | 1 | 105,459 | 12 | 210,919 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two sequences a_1, a_2, ..., a_n and b_1, b_2, ..., b_n. Each element of both sequences is either 0, 1 or 2. The number of elements 0, 1, 2 in the sequence a is x_1, y_1, z_1 respectively, and the number of elements 0, 1, 2 in the sequence b is x_2, y_2, z_2 respectively.
You can rearrange the elements in both sequences a and b however you like. After that, let's define a sequence c as follows:
c_i = \begin{cases} a_i b_i & \mbox{if }a_i > b_i \\\ 0 & \mbox{if }a_i = b_i \\\ -a_i b_i & \mbox{if }a_i < b_i \end{cases}
You'd like to make ∑_{i=1}^n c_i (the sum of all elements of the sequence c) as large as possible. What is the maximum possible sum?
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Each test case consists of two lines. The first line of each test case contains three integers x_1, y_1, z_1 (0 ≤ x_1, y_1, z_1 ≤ 10^8) — the number of 0-s, 1-s and 2-s in the sequence a.
The second line of each test case also contains three integers x_2, y_2, z_2 (0 ≤ x_2, y_2, z_2 ≤ 10^8; x_1 + y_1 + z_1 = x_2 + y_2 + z_2 > 0) — the number of 0-s, 1-s and 2-s in the sequence b.
Output
For each test case, print the maximum possible sum of the sequence c.
Example
Input
3
2 3 2
3 3 1
4 0 1
2 3 0
0 0 1
0 0 1
Output
4
2
0
Note
In the first sample, one of the optimal solutions is:
a = \{2, 0, 1, 1, 0, 2, 1\}
b = \{1, 0, 1, 0, 2, 1, 0\}
c = \{2, 0, 0, 0, 0, 2, 0\}
In the second sample, one of the optimal solutions is:
a = \{0, 2, 0, 0, 0\}
b = \{1, 1, 0, 1, 0\}
c = \{0, 2, 0, 0, 0\}
In the third sample, the only possible solution is:
a = \{2\}
b = \{2\}
c = \{0\} | instruction | 0 | 105,460 | 12 | 210,920 |
Tags: constructive algorithms, greedy, math
Correct Solution:
```
t = int(input())
for _ in range(t):
x1, y1, z1 = list(map(int, input().split()))
x2, y2, z2 = list(map(int, input().split()))
p2 = min(z1, y2)
z1 -= p2
y2 -= p2
m2 = max(0, y1 - (x2 + y2))
print(2*(p2-m2))
``` | output | 1 | 105,460 | 12 | 210,921 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two sequences a_1, a_2, ..., a_n and b_1, b_2, ..., b_n. Each element of both sequences is either 0, 1 or 2. The number of elements 0, 1, 2 in the sequence a is x_1, y_1, z_1 respectively, and the number of elements 0, 1, 2 in the sequence b is x_2, y_2, z_2 respectively.
You can rearrange the elements in both sequences a and b however you like. After that, let's define a sequence c as follows:
c_i = \begin{cases} a_i b_i & \mbox{if }a_i > b_i \\\ 0 & \mbox{if }a_i = b_i \\\ -a_i b_i & \mbox{if }a_i < b_i \end{cases}
You'd like to make ∑_{i=1}^n c_i (the sum of all elements of the sequence c) as large as possible. What is the maximum possible sum?
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Each test case consists of two lines. The first line of each test case contains three integers x_1, y_1, z_1 (0 ≤ x_1, y_1, z_1 ≤ 10^8) — the number of 0-s, 1-s and 2-s in the sequence a.
The second line of each test case also contains three integers x_2, y_2, z_2 (0 ≤ x_2, y_2, z_2 ≤ 10^8; x_1 + y_1 + z_1 = x_2 + y_2 + z_2 > 0) — the number of 0-s, 1-s and 2-s in the sequence b.
Output
For each test case, print the maximum possible sum of the sequence c.
Example
Input
3
2 3 2
3 3 1
4 0 1
2 3 0
0 0 1
0 0 1
Output
4
2
0
Note
In the first sample, one of the optimal solutions is:
a = \{2, 0, 1, 1, 0, 2, 1\}
b = \{1, 0, 1, 0, 2, 1, 0\}
c = \{2, 0, 0, 0, 0, 2, 0\}
In the second sample, one of the optimal solutions is:
a = \{0, 2, 0, 0, 0\}
b = \{1, 1, 0, 1, 0\}
c = \{0, 2, 0, 0, 0\}
In the third sample, the only possible solution is:
a = \{2\}
b = \{2\}
c = \{0\}
Submitted Solution:
```
import math
def function(x1, y1, z1, x2, y2, z2):
y1-=x2
if y1<=0:
print(2*min(z1, y2))
if y1>0:
if y1<=y2:
c=y2-y1
print(2*min(c, z1))
if y1>y2:
y1-=y2
print(-2*min(y1, z2))
if __name__=="__main__":
t=int(input())
for k1 in range(t):
x1, y1, z1=map(int, input().rstrip().split())
x2, y2, z2=map(int, input().rstrip().split())
function(x1, y1, z1, x2, y2, z2)
``` | instruction | 0 | 105,461 | 12 | 210,922 |
Yes | output | 1 | 105,461 | 12 | 210,923 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two sequences a_1, a_2, ..., a_n and b_1, b_2, ..., b_n. Each element of both sequences is either 0, 1 or 2. The number of elements 0, 1, 2 in the sequence a is x_1, y_1, z_1 respectively, and the number of elements 0, 1, 2 in the sequence b is x_2, y_2, z_2 respectively.
You can rearrange the elements in both sequences a and b however you like. After that, let's define a sequence c as follows:
c_i = \begin{cases} a_i b_i & \mbox{if }a_i > b_i \\\ 0 & \mbox{if }a_i = b_i \\\ -a_i b_i & \mbox{if }a_i < b_i \end{cases}
You'd like to make ∑_{i=1}^n c_i (the sum of all elements of the sequence c) as large as possible. What is the maximum possible sum?
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Each test case consists of two lines. The first line of each test case contains three integers x_1, y_1, z_1 (0 ≤ x_1, y_1, z_1 ≤ 10^8) — the number of 0-s, 1-s and 2-s in the sequence a.
The second line of each test case also contains three integers x_2, y_2, z_2 (0 ≤ x_2, y_2, z_2 ≤ 10^8; x_1 + y_1 + z_1 = x_2 + y_2 + z_2 > 0) — the number of 0-s, 1-s and 2-s in the sequence b.
Output
For each test case, print the maximum possible sum of the sequence c.
Example
Input
3
2 3 2
3 3 1
4 0 1
2 3 0
0 0 1
0 0 1
Output
4
2
0
Note
In the first sample, one of the optimal solutions is:
a = \{2, 0, 1, 1, 0, 2, 1\}
b = \{1, 0, 1, 0, 2, 1, 0\}
c = \{2, 0, 0, 0, 0, 2, 0\}
In the second sample, one of the optimal solutions is:
a = \{0, 2, 0, 0, 0\}
b = \{1, 1, 0, 1, 0\}
c = \{0, 2, 0, 0, 0\}
In the third sample, the only possible solution is:
a = \{2\}
b = \{2\}
c = \{0\}
Submitted Solution:
```
t = int(input());
for _ in range(t):
A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = min(A[0],B[2]);
A[0] -= C;
B[2] -= C;
C = min(A[1],B[0]);
A[1] -= C;
B[0] -= C;
C = min(A[2],B[1]);
A[2] -= C;
B[1] -= C;
print(C * 2 - 2 * min(A[1],B[2]));
``` | instruction | 0 | 105,462 | 12 | 210,924 |
Yes | output | 1 | 105,462 | 12 | 210,925 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two sequences a_1, a_2, ..., a_n and b_1, b_2, ..., b_n. Each element of both sequences is either 0, 1 or 2. The number of elements 0, 1, 2 in the sequence a is x_1, y_1, z_1 respectively, and the number of elements 0, 1, 2 in the sequence b is x_2, y_2, z_2 respectively.
You can rearrange the elements in both sequences a and b however you like. After that, let's define a sequence c as follows:
c_i = \begin{cases} a_i b_i & \mbox{if }a_i > b_i \\\ 0 & \mbox{if }a_i = b_i \\\ -a_i b_i & \mbox{if }a_i < b_i \end{cases}
You'd like to make ∑_{i=1}^n c_i (the sum of all elements of the sequence c) as large as possible. What is the maximum possible sum?
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Each test case consists of two lines. The first line of each test case contains three integers x_1, y_1, z_1 (0 ≤ x_1, y_1, z_1 ≤ 10^8) — the number of 0-s, 1-s and 2-s in the sequence a.
The second line of each test case also contains three integers x_2, y_2, z_2 (0 ≤ x_2, y_2, z_2 ≤ 10^8; x_1 + y_1 + z_1 = x_2 + y_2 + z_2 > 0) — the number of 0-s, 1-s and 2-s in the sequence b.
Output
For each test case, print the maximum possible sum of the sequence c.
Example
Input
3
2 3 2
3 3 1
4 0 1
2 3 0
0 0 1
0 0 1
Output
4
2
0
Note
In the first sample, one of the optimal solutions is:
a = \{2, 0, 1, 1, 0, 2, 1\}
b = \{1, 0, 1, 0, 2, 1, 0\}
c = \{2, 0, 0, 0, 0, 2, 0\}
In the second sample, one of the optimal solutions is:
a = \{0, 2, 0, 0, 0\}
b = \{1, 1, 0, 1, 0\}
c = \{0, 2, 0, 0, 0\}
In the third sample, the only possible solution is:
a = \{2\}
b = \{2\}
c = \{0\}
Submitted Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
# import time,random,resource
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod2 = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def IF(c, t, f): return t if c else f
def main():
t = I()
rr = []
for _ in range(t):
a = LI()
b = LI()
t = min(a[0], b[2])
a[0] -= t
b[2] -= t
t = min(a[2], b[2])
a[2] -= t
b[2] -= t
t = min(a[1], b[2])
r = t * -2
t = min(a[2], b[1])
r += t * 2
rr.append(r)
return JA(rr, "\n")
print(main())
``` | instruction | 0 | 105,463 | 12 | 210,926 |
Yes | output | 1 | 105,463 | 12 | 210,927 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two sequences a_1, a_2, ..., a_n and b_1, b_2, ..., b_n. Each element of both sequences is either 0, 1 or 2. The number of elements 0, 1, 2 in the sequence a is x_1, y_1, z_1 respectively, and the number of elements 0, 1, 2 in the sequence b is x_2, y_2, z_2 respectively.
You can rearrange the elements in both sequences a and b however you like. After that, let's define a sequence c as follows:
c_i = \begin{cases} a_i b_i & \mbox{if }a_i > b_i \\\ 0 & \mbox{if }a_i = b_i \\\ -a_i b_i & \mbox{if }a_i < b_i \end{cases}
You'd like to make ∑_{i=1}^n c_i (the sum of all elements of the sequence c) as large as possible. What is the maximum possible sum?
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Each test case consists of two lines. The first line of each test case contains three integers x_1, y_1, z_1 (0 ≤ x_1, y_1, z_1 ≤ 10^8) — the number of 0-s, 1-s and 2-s in the sequence a.
The second line of each test case also contains three integers x_2, y_2, z_2 (0 ≤ x_2, y_2, z_2 ≤ 10^8; x_1 + y_1 + z_1 = x_2 + y_2 + z_2 > 0) — the number of 0-s, 1-s and 2-s in the sequence b.
Output
For each test case, print the maximum possible sum of the sequence c.
Example
Input
3
2 3 2
3 3 1
4 0 1
2 3 0
0 0 1
0 0 1
Output
4
2
0
Note
In the first sample, one of the optimal solutions is:
a = \{2, 0, 1, 1, 0, 2, 1\}
b = \{1, 0, 1, 0, 2, 1, 0\}
c = \{2, 0, 0, 0, 0, 2, 0\}
In the second sample, one of the optimal solutions is:
a = \{0, 2, 0, 0, 0\}
b = \{1, 1, 0, 1, 0\}
c = \{0, 2, 0, 0, 0\}
In the third sample, the only possible solution is:
a = \{2\}
b = \{2\}
c = \{0\}
Submitted Solution:
```
import sys
tc = int(sys.stdin.readline())
for _ in range(tc):
a0, a1, a2 = map(int, sys.stdin.readline().split())
b0, b1, b2 = map(int, sys.stdin.readline().split())
ans = 0
ans += 2 * min(a2, b1)
a2 -= min(a2, b1)
b1 -= min(a2, b1)
if b2 > a2 + a0:
b2 -= (a0 + a2)
a0 = 0
a2 = 0
ans += (-2 * min(b2, a1))
print(ans)
``` | instruction | 0 | 105,464 | 12 | 210,928 |
Yes | output | 1 | 105,464 | 12 | 210,929 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.