text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers.
Your task is to determine if a has some subsequence of length at least 3 that is a palindrome.
Recall that an array b is called a subsequence of the array a if b can be obtained by removing some (possibly, zero) elements from a (not necessarily consecutive) without changing the order of remaining elements. For example, [2], [1, 2, 1, 3] and [2, 3] are subsequences of [1, 2, 1, 3], but [1, 1, 2] and [4] are not.
Also, recall that a palindrome is an array that reads the same backward as forward. In other words, the array a of length n is the palindrome if a_i = a_{n - i - 1} for all i from 1 to n. For example, arrays [1234], [1, 2, 1], [1, 3, 2, 2, 3, 1] and [10, 100, 10] are palindromes, but arrays [1, 2] and [1, 2, 3, 1] are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Next 2t lines describe test cases. The first line of the test case contains one integer n (3 ≤ n ≤ 5000) — the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all test cases does not exceed 5000 (∑ n ≤ 5000).
Output
For each test case, print the answer — "YES" (without quotes) if a has some subsequence of length at least 3 that is a palindrome and "NO" otherwise.
Example
Input
5
3
1 2 1
5
1 2 2 3 2
3
1 1 2
4
1 2 2 1
10
1 1 2 2 3 3 4 4 5 5
Output
YES
YES
NO
YES
NO
Note
In the first test case of the example, the array a has a subsequence [1, 2, 1] which is a palindrome.
In the second test case of the example, the array a has two subsequences of length 3 which are palindromes: [2, 3, 2] and [2, 2, 2].
In the third test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
In the fourth test case of the example, the array a has one subsequence of length 4 which is a palindrome: [1, 2, 2, 1] (and has two subsequences of length 3 which are palindromes: both are [1, 2, 1]).
In the fifth test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
Tags: brute force, strings
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
li = list(map(int, input().split()))
arr = [0] * (max(li))
for i in range(len(li) - 1):
if li[i] != li[i + 1]:
arr[li[i] - 1] += 1
arr[li[-1] - 1] += 1
count = 0
abc = False
xyz = False
for i in range(len(li) - 2):
if li[i] == li[i + 2]:
abc = True
xyz = True
break
for i in range(len(arr)):
if arr[i] > 1:
abc = True
xyz = True
break
if not xyz:
if len(set(li)) == 1:
print("YES")
abc = True
continue
elif not abc:
print("NO")
else:
print("YES")
```
| 14,300 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers.
Your task is to determine if a has some subsequence of length at least 3 that is a palindrome.
Recall that an array b is called a subsequence of the array a if b can be obtained by removing some (possibly, zero) elements from a (not necessarily consecutive) without changing the order of remaining elements. For example, [2], [1, 2, 1, 3] and [2, 3] are subsequences of [1, 2, 1, 3], but [1, 1, 2] and [4] are not.
Also, recall that a palindrome is an array that reads the same backward as forward. In other words, the array a of length n is the palindrome if a_i = a_{n - i - 1} for all i from 1 to n. For example, arrays [1234], [1, 2, 1], [1, 3, 2, 2, 3, 1] and [10, 100, 10] are palindromes, but arrays [1, 2] and [1, 2, 3, 1] are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Next 2t lines describe test cases. The first line of the test case contains one integer n (3 ≤ n ≤ 5000) — the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all test cases does not exceed 5000 (∑ n ≤ 5000).
Output
For each test case, print the answer — "YES" (without quotes) if a has some subsequence of length at least 3 that is a palindrome and "NO" otherwise.
Example
Input
5
3
1 2 1
5
1 2 2 3 2
3
1 1 2
4
1 2 2 1
10
1 1 2 2 3 3 4 4 5 5
Output
YES
YES
NO
YES
NO
Note
In the first test case of the example, the array a has a subsequence [1, 2, 1] which is a palindrome.
In the second test case of the example, the array a has two subsequences of length 3 which are palindromes: [2, 3, 2] and [2, 2, 2].
In the third test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
In the fourth test case of the example, the array a has one subsequence of length 4 which is a palindrome: [1, 2, 2, 1] (and has two subsequences of length 3 which are palindromes: both are [1, 2, 1]).
In the fifth test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
Tags: brute force, strings
Correct Solution:
```
import sys
from array import array
input = sys.stdin.readline
t = int(input())
for _ in range(t):
n = int(input())
s = [int(i) for i in input().split()]
prev = [array('l', (0 for i in range(n))) for i in range(200)]
pos = [[] for i in range(200)]
for i in range(n):
for j in range(200):
if i == 0: continue
prev[j][i] = prev[j][i-1]
prev[s[i]][i] += 1
pos[s[i]].append(i)
ans = 0
for i in range(200):
# if x == 0
for k in range(200):
if len(pos[i]):
ans = max(ans, prev[k][pos[i][-1]] - prev[k][pos[i][0]] + 1)
# if x != 0
for j in range(1, (len(pos[i]) // 2) + 1):
m = 0
for k in range(200):
m = max(m, prev[k][pos[i][-j]-1] - prev[k][pos[i][j-1]])
ans = max(ans, m + 2 * j)
print(ans)
```
| 14,301 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers.
Your task is to determine if a has some subsequence of length at least 3 that is a palindrome.
Recall that an array b is called a subsequence of the array a if b can be obtained by removing some (possibly, zero) elements from a (not necessarily consecutive) without changing the order of remaining elements. For example, [2], [1, 2, 1, 3] and [2, 3] are subsequences of [1, 2, 1, 3], but [1, 1, 2] and [4] are not.
Also, recall that a palindrome is an array that reads the same backward as forward. In other words, the array a of length n is the palindrome if a_i = a_{n - i - 1} for all i from 1 to n. For example, arrays [1234], [1, 2, 1], [1, 3, 2, 2, 3, 1] and [10, 100, 10] are palindromes, but arrays [1, 2] and [1, 2, 3, 1] are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Next 2t lines describe test cases. The first line of the test case contains one integer n (3 ≤ n ≤ 5000) — the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all test cases does not exceed 5000 (∑ n ≤ 5000).
Output
For each test case, print the answer — "YES" (without quotes) if a has some subsequence of length at least 3 that is a palindrome and "NO" otherwise.
Example
Input
5
3
1 2 1
5
1 2 2 3 2
3
1 1 2
4
1 2 2 1
10
1 1 2 2 3 3 4 4 5 5
Output
YES
YES
NO
YES
NO
Note
In the first test case of the example, the array a has a subsequence [1, 2, 1] which is a palindrome.
In the second test case of the example, the array a has two subsequences of length 3 which are palindromes: [2, 3, 2] and [2, 2, 2].
In the third test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
In the fourth test case of the example, the array a has one subsequence of length 4 which is a palindrome: [1, 2, 2, 1] (and has two subsequences of length 3 which are palindromes: both are [1, 2, 1]).
In the fifth test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
Tags: brute force, strings
Correct Solution:
```
import sys
import math
import itertools
import functools
import collections
import operator
import fileinput
import copy
ORDA = 97 # a
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return [int(i) for i in input().split()]
def lcm(a, b): return abs(a * b) // math.gcd(a, b)
def revn(n): return str(n)[::-1]
def dd(): return collections.defaultdict(int)
def ddl(): return collections.defaultdict(list)
def sieve(n):
if n < 2: return list()
prime = [True for _ in range(n + 1)]
p = 3
while p * p <= n:
if prime[p]:
for i in range(p * 2, n + 1, p):
prime[i] = False
p += 2
r = [2]
for p in range(3, n + 1, 2):
if prime[p]:
r.append(p)
return r
def divs(n, start=2):
r = []
for i in range(start, int(math.sqrt(n) + 1)):
if (n % i == 0):
if (n / i == i):
r.append(i)
else:
r.extend([i, n // i])
return r
def divn(n, primes):
divs_number = 1
for i in primes:
if n == 1:
return divs_number
t = 1
while n % i == 0:
t += 1
n //= i
divs_number *= t
def prime(n):
if n == 2: return True
if n % 2 == 0 or n <= 1: return False
sqr = int(math.sqrt(n)) + 1
for d in range(3, sqr, 2):
if n % d == 0: return False
return True
def convn(number, base):
new_number = 0
while number > 0:
new_number += number % base
number //= base
return new_number
def cdiv(n, k): return n // k + (n % k != 0)
def ispal(s): # Palindrome
for i in range(len(s) // 2 + 1):
if s[i] != s[-i - 1]:
return False
return True
# a = [1,2,3,4,5] -----> print(*a) ----> list print krne ka new way
#rr = sieve(int(1000**0.5))
def main():
for i in range(ii()):
d = collections.defaultdict(int)
n = ii()
arr = li()
for ele in arr:
d[ele] += 1
for key in list(d.keys()):
if d[key] == 2:
j = arr.index(key)
if j+1 <= n-1 and arr[j] != arr[j+1]:
break
elif d[key] > 2:
break
else:
print('NO')
continue
print('YES')
main()
```
| 14,302 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers.
Your task is to determine if a has some subsequence of length at least 3 that is a palindrome.
Recall that an array b is called a subsequence of the array a if b can be obtained by removing some (possibly, zero) elements from a (not necessarily consecutive) without changing the order of remaining elements. For example, [2], [1, 2, 1, 3] and [2, 3] are subsequences of [1, 2, 1, 3], but [1, 1, 2] and [4] are not.
Also, recall that a palindrome is an array that reads the same backward as forward. In other words, the array a of length n is the palindrome if a_i = a_{n - i - 1} for all i from 1 to n. For example, arrays [1234], [1, 2, 1], [1, 3, 2, 2, 3, 1] and [10, 100, 10] are palindromes, but arrays [1, 2] and [1, 2, 3, 1] are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Next 2t lines describe test cases. The first line of the test case contains one integer n (3 ≤ n ≤ 5000) — the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all test cases does not exceed 5000 (∑ n ≤ 5000).
Output
For each test case, print the answer — "YES" (without quotes) if a has some subsequence of length at least 3 that is a palindrome and "NO" otherwise.
Example
Input
5
3
1 2 1
5
1 2 2 3 2
3
1 1 2
4
1 2 2 1
10
1 1 2 2 3 3 4 4 5 5
Output
YES
YES
NO
YES
NO
Note
In the first test case of the example, the array a has a subsequence [1, 2, 1] which is a palindrome.
In the second test case of the example, the array a has two subsequences of length 3 which are palindromes: [2, 3, 2] and [2, 2, 2].
In the third test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
In the fourth test case of the example, the array a has one subsequence of length 4 which is a palindrome: [1, 2, 2, 1] (and has two subsequences of length 3 which are palindromes: both are [1, 2, 1]).
In the fifth test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
Tags: brute force, strings
Correct Solution:
```
from collections import Counter
from collections import defaultdict
import math
import random
import heapq as hq
from math import sqrt
import sys
from functools import reduce
def input():
return sys.stdin.readline().strip()
def iinput():
return int(input())
def tinput():
return input().split()
def rinput():
return map(int, tinput())
def rlinput():
return list(rinput())
mod = int(1e9)+7
def factors(n):
return set(reduce(list.__add__,
([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))
# ----------------------------------------------------
if __name__ == "__main__":
for _ in range(iinput()):
n=iinput()
a=rlinput()
d=defaultdict(list)
j=0
for i in a:
d[i].append(j)
j+=1
flag=False
for i in d:
if len(d[i])>=2 and d[i][-1]-d[i][0]>1:
flag=True
break
print('YES' if flag else 'NO')
```
| 14,303 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers.
Your task is to determine if a has some subsequence of length at least 3 that is a palindrome.
Recall that an array b is called a subsequence of the array a if b can be obtained by removing some (possibly, zero) elements from a (not necessarily consecutive) without changing the order of remaining elements. For example, [2], [1, 2, 1, 3] and [2, 3] are subsequences of [1, 2, 1, 3], but [1, 1, 2] and [4] are not.
Also, recall that a palindrome is an array that reads the same backward as forward. In other words, the array a of length n is the palindrome if a_i = a_{n - i - 1} for all i from 1 to n. For example, arrays [1234], [1, 2, 1], [1, 3, 2, 2, 3, 1] and [10, 100, 10] are palindromes, but arrays [1, 2] and [1, 2, 3, 1] are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Next 2t lines describe test cases. The first line of the test case contains one integer n (3 ≤ n ≤ 5000) — the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all test cases does not exceed 5000 (∑ n ≤ 5000).
Output
For each test case, print the answer — "YES" (without quotes) if a has some subsequence of length at least 3 that is a palindrome and "NO" otherwise.
Example
Input
5
3
1 2 1
5
1 2 2 3 2
3
1 1 2
4
1 2 2 1
10
1 1 2 2 3 3 4 4 5 5
Output
YES
YES
NO
YES
NO
Note
In the first test case of the example, the array a has a subsequence [1, 2, 1] which is a palindrome.
In the second test case of the example, the array a has two subsequences of length 3 which are palindromes: [2, 3, 2] and [2, 2, 2].
In the third test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
In the fourth test case of the example, the array a has one subsequence of length 4 which is a palindrome: [1, 2, 2, 1] (and has two subsequences of length 3 which are palindromes: both are [1, 2, 1]).
In the fifth test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
Tags: brute force, strings
Correct Solution:
```
for u in range(int(input())):
n = int(input())
x = list(map(int, input().split()))
ind = [[] for i in range(n+1)]
flag = 1
for i in range(n):
ind[x[i]] += [i]
if len(ind[x[i]]) == 2 and ind[x[i]][-1] - ind[x[i]][-2] > 1 or len(ind[x[i]]) >= 3:
print('YES')
flag = 0
break
if flag:
print('NO')
```
| 14,304 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers.
Your task is to determine if a has some subsequence of length at least 3 that is a palindrome.
Recall that an array b is called a subsequence of the array a if b can be obtained by removing some (possibly, zero) elements from a (not necessarily consecutive) without changing the order of remaining elements. For example, [2], [1, 2, 1, 3] and [2, 3] are subsequences of [1, 2, 1, 3], but [1, 1, 2] and [4] are not.
Also, recall that a palindrome is an array that reads the same backward as forward. In other words, the array a of length n is the palindrome if a_i = a_{n - i - 1} for all i from 1 to n. For example, arrays [1234], [1, 2, 1], [1, 3, 2, 2, 3, 1] and [10, 100, 10] are palindromes, but arrays [1, 2] and [1, 2, 3, 1] are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Next 2t lines describe test cases. The first line of the test case contains one integer n (3 ≤ n ≤ 5000) — the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all test cases does not exceed 5000 (∑ n ≤ 5000).
Output
For each test case, print the answer — "YES" (without quotes) if a has some subsequence of length at least 3 that is a palindrome and "NO" otherwise.
Example
Input
5
3
1 2 1
5
1 2 2 3 2
3
1 1 2
4
1 2 2 1
10
1 1 2 2 3 3 4 4 5 5
Output
YES
YES
NO
YES
NO
Note
In the first test case of the example, the array a has a subsequence [1, 2, 1] which is a palindrome.
In the second test case of the example, the array a has two subsequences of length 3 which are palindromes: [2, 3, 2] and [2, 2, 2].
In the third test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
In the fourth test case of the example, the array a has one subsequence of length 4 which is a palindrome: [1, 2, 2, 1] (and has two subsequences of length 3 which are palindromes: both are [1, 2, 1]).
In the fifth test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
Submitted Solution:
```
n = int(input())
for _ in range(n):
m = int(input())
s = set()
mat = list(map(int, input().split()))
for i in range(1,m):
if mat[i] in s:
print("YES")
break
s.add(mat[i-1])
else:
print("NO")
```
Yes
| 14,305 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers.
Your task is to determine if a has some subsequence of length at least 3 that is a palindrome.
Recall that an array b is called a subsequence of the array a if b can be obtained by removing some (possibly, zero) elements from a (not necessarily consecutive) without changing the order of remaining elements. For example, [2], [1, 2, 1, 3] and [2, 3] are subsequences of [1, 2, 1, 3], but [1, 1, 2] and [4] are not.
Also, recall that a palindrome is an array that reads the same backward as forward. In other words, the array a of length n is the palindrome if a_i = a_{n - i - 1} for all i from 1 to n. For example, arrays [1234], [1, 2, 1], [1, 3, 2, 2, 3, 1] and [10, 100, 10] are palindromes, but arrays [1, 2] and [1, 2, 3, 1] are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Next 2t lines describe test cases. The first line of the test case contains one integer n (3 ≤ n ≤ 5000) — the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all test cases does not exceed 5000 (∑ n ≤ 5000).
Output
For each test case, print the answer — "YES" (without quotes) if a has some subsequence of length at least 3 that is a palindrome and "NO" otherwise.
Example
Input
5
3
1 2 1
5
1 2 2 3 2
3
1 1 2
4
1 2 2 1
10
1 1 2 2 3 3 4 4 5 5
Output
YES
YES
NO
YES
NO
Note
In the first test case of the example, the array a has a subsequence [1, 2, 1] which is a palindrome.
In the second test case of the example, the array a has two subsequences of length 3 which are palindromes: [2, 3, 2] and [2, 2, 2].
In the third test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
In the fourth test case of the example, the array a has one subsequence of length 4 which is a palindrome: [1, 2, 2, 1] (and has two subsequences of length 3 which are palindromes: both are [1, 2, 1]).
In the fifth test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
def main():
pass
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
def test():
n = int(input())
a = list(map(int, input().split()))
for i in range(n):
for j in range(i, n - 2):
if a[j + 2] == a[i]:
return 'YES'
return 'NO'
t = int(input())
for _ in range(t):
print(test())
```
Yes
| 14,306 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers.
Your task is to determine if a has some subsequence of length at least 3 that is a palindrome.
Recall that an array b is called a subsequence of the array a if b can be obtained by removing some (possibly, zero) elements from a (not necessarily consecutive) without changing the order of remaining elements. For example, [2], [1, 2, 1, 3] and [2, 3] are subsequences of [1, 2, 1, 3], but [1, 1, 2] and [4] are not.
Also, recall that a palindrome is an array that reads the same backward as forward. In other words, the array a of length n is the palindrome if a_i = a_{n - i - 1} for all i from 1 to n. For example, arrays [1234], [1, 2, 1], [1, 3, 2, 2, 3, 1] and [10, 100, 10] are palindromes, but arrays [1, 2] and [1, 2, 3, 1] are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Next 2t lines describe test cases. The first line of the test case contains one integer n (3 ≤ n ≤ 5000) — the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all test cases does not exceed 5000 (∑ n ≤ 5000).
Output
For each test case, print the answer — "YES" (without quotes) if a has some subsequence of length at least 3 that is a palindrome and "NO" otherwise.
Example
Input
5
3
1 2 1
5
1 2 2 3 2
3
1 1 2
4
1 2 2 1
10
1 1 2 2 3 3 4 4 5 5
Output
YES
YES
NO
YES
NO
Note
In the first test case of the example, the array a has a subsequence [1, 2, 1] which is a palindrome.
In the second test case of the example, the array a has two subsequences of length 3 which are palindromes: [2, 3, 2] and [2, 2, 2].
In the third test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
In the fourth test case of the example, the array a has one subsequence of length 4 which is a palindrome: [1, 2, 2, 1] (and has two subsequences of length 3 which are palindromes: both are [1, 2, 1]).
In the fifth test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
Submitted Solution:
```
# cook your dish here
t = int(input())
out = []
for i in range(t):
n = int(input())
# NOTE: If same number gte 3, pass
# NOTE: same number gte 2 with space pass
nums = {}
flag = False
for i, num in enumerate(input().split()):
if not num in nums:
nums[num] = [i]
else:
if len(nums[num]) >= 2:
flag = True
break
elif nums[num][-1] + 1 == i:
# consecutive
nums[num].append(i)
else:
flag = True
break
if flag:
out.append("YES")
else:
out.append("NO")
print("\n".join(out))
```
Yes
| 14,307 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers.
Your task is to determine if a has some subsequence of length at least 3 that is a palindrome.
Recall that an array b is called a subsequence of the array a if b can be obtained by removing some (possibly, zero) elements from a (not necessarily consecutive) without changing the order of remaining elements. For example, [2], [1, 2, 1, 3] and [2, 3] are subsequences of [1, 2, 1, 3], but [1, 1, 2] and [4] are not.
Also, recall that a palindrome is an array that reads the same backward as forward. In other words, the array a of length n is the palindrome if a_i = a_{n - i - 1} for all i from 1 to n. For example, arrays [1234], [1, 2, 1], [1, 3, 2, 2, 3, 1] and [10, 100, 10] are palindromes, but arrays [1, 2] and [1, 2, 3, 1] are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Next 2t lines describe test cases. The first line of the test case contains one integer n (3 ≤ n ≤ 5000) — the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all test cases does not exceed 5000 (∑ n ≤ 5000).
Output
For each test case, print the answer — "YES" (without quotes) if a has some subsequence of length at least 3 that is a palindrome and "NO" otherwise.
Example
Input
5
3
1 2 1
5
1 2 2 3 2
3
1 1 2
4
1 2 2 1
10
1 1 2 2 3 3 4 4 5 5
Output
YES
YES
NO
YES
NO
Note
In the first test case of the example, the array a has a subsequence [1, 2, 1] which is a palindrome.
In the second test case of the example, the array a has two subsequences of length 3 which are palindromes: [2, 3, 2] and [2, 2, 2].
In the third test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
In the fourth test case of the example, the array a has one subsequence of length 4 which is a palindrome: [1, 2, 2, 1] (and has two subsequences of length 3 which are palindromes: both are [1, 2, 1]).
In the fifth test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
Submitted Solution:
```
t = int(input())
for k in range(t):
n = int(input())
arr = list(input().split())
check = False
for i in range(n):
for j in range(n):
if arr[i] == arr[j] and abs(i - j) > 1:
check = True
break
if check:
break
print('YES' if check else 'NO')
```
Yes
| 14,308 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers.
Your task is to determine if a has some subsequence of length at least 3 that is a palindrome.
Recall that an array b is called a subsequence of the array a if b can be obtained by removing some (possibly, zero) elements from a (not necessarily consecutive) without changing the order of remaining elements. For example, [2], [1, 2, 1, 3] and [2, 3] are subsequences of [1, 2, 1, 3], but [1, 1, 2] and [4] are not.
Also, recall that a palindrome is an array that reads the same backward as forward. In other words, the array a of length n is the palindrome if a_i = a_{n - i - 1} for all i from 1 to n. For example, arrays [1234], [1, 2, 1], [1, 3, 2, 2, 3, 1] and [10, 100, 10] are palindromes, but arrays [1, 2] and [1, 2, 3, 1] are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Next 2t lines describe test cases. The first line of the test case contains one integer n (3 ≤ n ≤ 5000) — the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all test cases does not exceed 5000 (∑ n ≤ 5000).
Output
For each test case, print the answer — "YES" (without quotes) if a has some subsequence of length at least 3 that is a palindrome and "NO" otherwise.
Example
Input
5
3
1 2 1
5
1 2 2 3 2
3
1 1 2
4
1 2 2 1
10
1 1 2 2 3 3 4 4 5 5
Output
YES
YES
NO
YES
NO
Note
In the first test case of the example, the array a has a subsequence [1, 2, 1] which is a palindrome.
In the second test case of the example, the array a has two subsequences of length 3 which are palindromes: [2, 3, 2] and [2, 2, 2].
In the third test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
In the fourth test case of the example, the array a has one subsequence of length 4 which is a palindrome: [1, 2, 2, 1] (and has two subsequences of length 3 which are palindromes: both are [1, 2, 1]).
In the fifth test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
Submitted Solution:
```
n=int(input())
c=[]
for i in range(n):
b=int(input())
a=list(map(int,input().split()))
a.reverse()
c=a
if a==c:
print("YES")
else:
print("NO")
```
No
| 14,309 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers.
Your task is to determine if a has some subsequence of length at least 3 that is a palindrome.
Recall that an array b is called a subsequence of the array a if b can be obtained by removing some (possibly, zero) elements from a (not necessarily consecutive) without changing the order of remaining elements. For example, [2], [1, 2, 1, 3] and [2, 3] are subsequences of [1, 2, 1, 3], but [1, 1, 2] and [4] are not.
Also, recall that a palindrome is an array that reads the same backward as forward. In other words, the array a of length n is the palindrome if a_i = a_{n - i - 1} for all i from 1 to n. For example, arrays [1234], [1, 2, 1], [1, 3, 2, 2, 3, 1] and [10, 100, 10] are palindromes, but arrays [1, 2] and [1, 2, 3, 1] are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Next 2t lines describe test cases. The first line of the test case contains one integer n (3 ≤ n ≤ 5000) — the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all test cases does not exceed 5000 (∑ n ≤ 5000).
Output
For each test case, print the answer — "YES" (without quotes) if a has some subsequence of length at least 3 that is a palindrome and "NO" otherwise.
Example
Input
5
3
1 2 1
5
1 2 2 3 2
3
1 1 2
4
1 2 2 1
10
1 1 2 2 3 3 4 4 5 5
Output
YES
YES
NO
YES
NO
Note
In the first test case of the example, the array a has a subsequence [1, 2, 1] which is a palindrome.
In the second test case of the example, the array a has two subsequences of length 3 which are palindromes: [2, 3, 2] and [2, 2, 2].
In the third test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
In the fourth test case of the example, the array a has one subsequence of length 4 which is a palindrome: [1, 2, 2, 1] (and has two subsequences of length 3 which are palindromes: both are [1, 2, 1]).
In the fifth test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
Submitted Solution:
```
t=int(input())
l1=[]
for i in range(t):
l=[]
n=int(input())
s=list(map(int,input().split()))
for j in range(n):
l.append([s[j],j])
l1.append(l)
for k in l1:
k.sort()
for m in range(1,len(k)):
if k[m-1][0]==k[m][0] and k[m][1]-k[m-1][1]>1:
print("YES")
break
else:
if m==len(k)-1:
print("NO")
```
No
| 14,310 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers.
Your task is to determine if a has some subsequence of length at least 3 that is a palindrome.
Recall that an array b is called a subsequence of the array a if b can be obtained by removing some (possibly, zero) elements from a (not necessarily consecutive) without changing the order of remaining elements. For example, [2], [1, 2, 1, 3] and [2, 3] are subsequences of [1, 2, 1, 3], but [1, 1, 2] and [4] are not.
Also, recall that a palindrome is an array that reads the same backward as forward. In other words, the array a of length n is the palindrome if a_i = a_{n - i - 1} for all i from 1 to n. For example, arrays [1234], [1, 2, 1], [1, 3, 2, 2, 3, 1] and [10, 100, 10] are palindromes, but arrays [1, 2] and [1, 2, 3, 1] are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Next 2t lines describe test cases. The first line of the test case contains one integer n (3 ≤ n ≤ 5000) — the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all test cases does not exceed 5000 (∑ n ≤ 5000).
Output
For each test case, print the answer — "YES" (without quotes) if a has some subsequence of length at least 3 that is a palindrome and "NO" otherwise.
Example
Input
5
3
1 2 1
5
1 2 2 3 2
3
1 1 2
4
1 2 2 1
10
1 1 2 2 3 3 4 4 5 5
Output
YES
YES
NO
YES
NO
Note
In the first test case of the example, the array a has a subsequence [1, 2, 1] which is a palindrome.
In the second test case of the example, the array a has two subsequences of length 3 which are palindromes: [2, 3, 2] and [2, 2, 2].
In the third test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
In the fourth test case of the example, the array a has one subsequence of length 4 which is a palindrome: [1, 2, 2, 1] (and has two subsequences of length 3 which are palindromes: both are [1, 2, 1]).
In the fifth test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
Submitted Solution:
```
from itertools import combinations as comb
def check():
for n in range(N):
for m in range(n+2, N):
if number[n] == number[m]:
l = number[n:m+1]
rl = l[::-1]
if l == rl: return 'YES'
return 'NO'
for case in range(int(input())):
N = int(input())
number = list(map(int, input().split()))
print(check())
```
No
| 14,311 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers.
Your task is to determine if a has some subsequence of length at least 3 that is a palindrome.
Recall that an array b is called a subsequence of the array a if b can be obtained by removing some (possibly, zero) elements from a (not necessarily consecutive) without changing the order of remaining elements. For example, [2], [1, 2, 1, 3] and [2, 3] are subsequences of [1, 2, 1, 3], but [1, 1, 2] and [4] are not.
Also, recall that a palindrome is an array that reads the same backward as forward. In other words, the array a of length n is the palindrome if a_i = a_{n - i - 1} for all i from 1 to n. For example, arrays [1234], [1, 2, 1], [1, 3, 2, 2, 3, 1] and [10, 100, 10] are palindromes, but arrays [1, 2] and [1, 2, 3, 1] are not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
Next 2t lines describe test cases. The first line of the test case contains one integer n (3 ≤ n ≤ 5000) — the length of a. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all test cases does not exceed 5000 (∑ n ≤ 5000).
Output
For each test case, print the answer — "YES" (without quotes) if a has some subsequence of length at least 3 that is a palindrome and "NO" otherwise.
Example
Input
5
3
1 2 1
5
1 2 2 3 2
3
1 1 2
4
1 2 2 1
10
1 1 2 2 3 3 4 4 5 5
Output
YES
YES
NO
YES
NO
Note
In the first test case of the example, the array a has a subsequence [1, 2, 1] which is a palindrome.
In the second test case of the example, the array a has two subsequences of length 3 which are palindromes: [2, 3, 2] and [2, 2, 2].
In the third test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
In the fourth test case of the example, the array a has one subsequence of length 4 which is a palindrome: [1, 2, 2, 1] (and has two subsequences of length 3 which are palindromes: both are [1, 2, 1]).
In the fifth test case of the example, the array a has no subsequences of length at least 3 which are palindromes.
Submitted Solution:
```
a=int(input())
letters=['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
for i in range (a) :
leng=int(input())
arr=list(input().split())
flag=0
for k in range (int(int(leng+1)/2)) :
if arr.count(arr[k])>2 :
flag=1
elif arr.count(arr[k])>1 :
flag2=0
for j in range (leng-1) :
if arr[j]==arr[j+1] and arr[j]==arr[k] :
flag2=1
if flag2==0 :
flag=1
if flag==1 :
print ("YES")
else :
print ("NO")
```
No
| 14,312 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Vova found n candy wrappers. He remembers that he bought x candies during the first day, 2x candies during the second day, 4x candies during the third day, ..., 2^{k-1} x candies during the k-th day. But there is an issue: Vova remembers neither x nor k but he is sure that x and k are positive integers and k > 1.
Vova will be satisfied if you tell him any positive integer x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n. It is guaranteed that at least one solution exists. Note that k > 1.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (3 ≤ n ≤ 10^9) — the number of candy wrappers Vova found. It is guaranteed that there is some positive integer x and integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Output
Print one integer — any positive integer value of x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Example
Input
7
3
6
7
21
28
999999999
999999984
Output
1
2
1
7
4
333333333
333333328
Note
In the first test case of the example, one of the possible answers is x=1, k=2. Then 1 ⋅ 1 + 2 ⋅ 1 equals n=3.
In the second test case of the example, one of the possible answers is x=2, k=2. Then 1 ⋅ 2 + 2 ⋅ 2 equals n=6.
In the third test case of the example, one of the possible answers is x=1, k=3. Then 1 ⋅ 1 + 2 ⋅ 1 + 4 ⋅ 1 equals n=7.
In the fourth test case of the example, one of the possible answers is x=7, k=2. Then 1 ⋅ 7 + 2 ⋅ 7 equals n=21.
In the fifth test case of the example, one of the possible answers is x=4, k=3. Then 1 ⋅ 4 + 2 ⋅ 4 + 4 ⋅ 4 equals n=28.
Tags: brute force, math
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
k=2
while True:
if n%(pow(2,k)-1)==0:
print(n//(pow(2,k)-1))
break
k+=1
```
| 14,313 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Vova found n candy wrappers. He remembers that he bought x candies during the first day, 2x candies during the second day, 4x candies during the third day, ..., 2^{k-1} x candies during the k-th day. But there is an issue: Vova remembers neither x nor k but he is sure that x and k are positive integers and k > 1.
Vova will be satisfied if you tell him any positive integer x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n. It is guaranteed that at least one solution exists. Note that k > 1.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (3 ≤ n ≤ 10^9) — the number of candy wrappers Vova found. It is guaranteed that there is some positive integer x and integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Output
Print one integer — any positive integer value of x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Example
Input
7
3
6
7
21
28
999999999
999999984
Output
1
2
1
7
4
333333333
333333328
Note
In the first test case of the example, one of the possible answers is x=1, k=2. Then 1 ⋅ 1 + 2 ⋅ 1 equals n=3.
In the second test case of the example, one of the possible answers is x=2, k=2. Then 1 ⋅ 2 + 2 ⋅ 2 equals n=6.
In the third test case of the example, one of the possible answers is x=1, k=3. Then 1 ⋅ 1 + 2 ⋅ 1 + 4 ⋅ 1 equals n=7.
In the fourth test case of the example, one of the possible answers is x=7, k=2. Then 1 ⋅ 7 + 2 ⋅ 7 equals n=21.
In the fifth test case of the example, one of the possible answers is x=4, k=3. Then 1 ⋅ 4 + 2 ⋅ 4 + 4 ⋅ 4 equals n=28.
Tags: brute force, math
Correct Solution:
```
t=int(input())
for i in range(0,t):
n=int(input())
c=0
m=2
while c==0:
x=n/((2**m)-1)
y=int(x)
if y==x:
print(y)
c=1
else:
m=m+1
```
| 14,314 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Vova found n candy wrappers. He remembers that he bought x candies during the first day, 2x candies during the second day, 4x candies during the third day, ..., 2^{k-1} x candies during the k-th day. But there is an issue: Vova remembers neither x nor k but he is sure that x and k are positive integers and k > 1.
Vova will be satisfied if you tell him any positive integer x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n. It is guaranteed that at least one solution exists. Note that k > 1.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (3 ≤ n ≤ 10^9) — the number of candy wrappers Vova found. It is guaranteed that there is some positive integer x and integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Output
Print one integer — any positive integer value of x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Example
Input
7
3
6
7
21
28
999999999
999999984
Output
1
2
1
7
4
333333333
333333328
Note
In the first test case of the example, one of the possible answers is x=1, k=2. Then 1 ⋅ 1 + 2 ⋅ 1 equals n=3.
In the second test case of the example, one of the possible answers is x=2, k=2. Then 1 ⋅ 2 + 2 ⋅ 2 equals n=6.
In the third test case of the example, one of the possible answers is x=1, k=3. Then 1 ⋅ 1 + 2 ⋅ 1 + 4 ⋅ 1 equals n=7.
In the fourth test case of the example, one of the possible answers is x=7, k=2. Then 1 ⋅ 7 + 2 ⋅ 7 equals n=21.
In the fifth test case of the example, one of the possible answers is x=4, k=3. Then 1 ⋅ 4 + 2 ⋅ 4 + 4 ⋅ 4 equals n=28.
Tags: brute force, math
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
fg=1
k=2
while fg:
if(n%((2**k)-1)==0):
break
k+=1
x=n//((2**k)-1)
print(x)
```
| 14,315 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Vova found n candy wrappers. He remembers that he bought x candies during the first day, 2x candies during the second day, 4x candies during the third day, ..., 2^{k-1} x candies during the k-th day. But there is an issue: Vova remembers neither x nor k but he is sure that x and k are positive integers and k > 1.
Vova will be satisfied if you tell him any positive integer x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n. It is guaranteed that at least one solution exists. Note that k > 1.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (3 ≤ n ≤ 10^9) — the number of candy wrappers Vova found. It is guaranteed that there is some positive integer x and integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Output
Print one integer — any positive integer value of x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Example
Input
7
3
6
7
21
28
999999999
999999984
Output
1
2
1
7
4
333333333
333333328
Note
In the first test case of the example, one of the possible answers is x=1, k=2. Then 1 ⋅ 1 + 2 ⋅ 1 equals n=3.
In the second test case of the example, one of the possible answers is x=2, k=2. Then 1 ⋅ 2 + 2 ⋅ 2 equals n=6.
In the third test case of the example, one of the possible answers is x=1, k=3. Then 1 ⋅ 1 + 2 ⋅ 1 + 4 ⋅ 1 equals n=7.
In the fourth test case of the example, one of the possible answers is x=7, k=2. Then 1 ⋅ 7 + 2 ⋅ 7 equals n=21.
In the fifth test case of the example, one of the possible answers is x=4, k=3. Then 1 ⋅ 4 + 2 ⋅ 4 + 4 ⋅ 4 equals n=28.
Tags: brute force, math
Correct Solution:
```
x=int(input())
for a in range(x):
y=int(input())
n=4
k=3
while y%k!=0:
k+=n
n=int(n*2)
#print(k)
print(y//k)
```
| 14,316 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Vova found n candy wrappers. He remembers that he bought x candies during the first day, 2x candies during the second day, 4x candies during the third day, ..., 2^{k-1} x candies during the k-th day. But there is an issue: Vova remembers neither x nor k but he is sure that x and k are positive integers and k > 1.
Vova will be satisfied if you tell him any positive integer x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n. It is guaranteed that at least one solution exists. Note that k > 1.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (3 ≤ n ≤ 10^9) — the number of candy wrappers Vova found. It is guaranteed that there is some positive integer x and integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Output
Print one integer — any positive integer value of x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Example
Input
7
3
6
7
21
28
999999999
999999984
Output
1
2
1
7
4
333333333
333333328
Note
In the first test case of the example, one of the possible answers is x=1, k=2. Then 1 ⋅ 1 + 2 ⋅ 1 equals n=3.
In the second test case of the example, one of the possible answers is x=2, k=2. Then 1 ⋅ 2 + 2 ⋅ 2 equals n=6.
In the third test case of the example, one of the possible answers is x=1, k=3. Then 1 ⋅ 1 + 2 ⋅ 1 + 4 ⋅ 1 equals n=7.
In the fourth test case of the example, one of the possible answers is x=7, k=2. Then 1 ⋅ 7 + 2 ⋅ 7 equals n=21.
In the fifth test case of the example, one of the possible answers is x=4, k=3. Then 1 ⋅ 4 + 2 ⋅ 4 + 4 ⋅ 4 equals n=28.
Tags: brute force, math
Correct Solution:
```
if __name__=='__main__':
T = int(input())
for t in range(1,T+1):
n = int(input())
for k in range(2,31):
if n%(2**k -1)==0:
## print(2**k -1)
print(n//(2**k - 1))
break
```
| 14,317 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Vova found n candy wrappers. He remembers that he bought x candies during the first day, 2x candies during the second day, 4x candies during the third day, ..., 2^{k-1} x candies during the k-th day. But there is an issue: Vova remembers neither x nor k but he is sure that x and k are positive integers and k > 1.
Vova will be satisfied if you tell him any positive integer x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n. It is guaranteed that at least one solution exists. Note that k > 1.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (3 ≤ n ≤ 10^9) — the number of candy wrappers Vova found. It is guaranteed that there is some positive integer x and integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Output
Print one integer — any positive integer value of x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Example
Input
7
3
6
7
21
28
999999999
999999984
Output
1
2
1
7
4
333333333
333333328
Note
In the first test case of the example, one of the possible answers is x=1, k=2. Then 1 ⋅ 1 + 2 ⋅ 1 equals n=3.
In the second test case of the example, one of the possible answers is x=2, k=2. Then 1 ⋅ 2 + 2 ⋅ 2 equals n=6.
In the third test case of the example, one of the possible answers is x=1, k=3. Then 1 ⋅ 1 + 2 ⋅ 1 + 4 ⋅ 1 equals n=7.
In the fourth test case of the example, one of the possible answers is x=7, k=2. Then 1 ⋅ 7 + 2 ⋅ 7 equals n=21.
In the fifth test case of the example, one of the possible answers is x=4, k=3. Then 1 ⋅ 4 + 2 ⋅ 4 + 4 ⋅ 4 equals n=28.
Tags: brute force, math
Correct Solution:
```
# n=int(input())
# if(n%2==0):
# print("YES")
# else:
# print("NO")
# for _ in range(int(input())):
# n=(input())
# if(len(n)<=10):
# print(n)
# else:
# print(n[0]+str(len(n)-2)+n[len(n)-1])
# a=0
# for _ in range(int(input())):
# n=list(map(int,input().split()))
# count=0
# for i in range(len(n)):
# if(n[i]==1):
# count+=1
# else:
# count-=1
# if(count>0):
# a+=1
# print(a)
# n,m=map(int,input().split())
# a=list(map(int,input().split()))
# count=0
# for i in range(len(a)):
# if(a[i]>=a[m-1] and a[i]>0):
# count+=1
# print(count)
# n,m=map(int,input().split())
# # if((n*m)%2!=0):
# print((n*m)//2)
# # else:
# # print((n*m)//2)\
# x=0
# for _ in range(int(input())):
# n=input()
# if(n=="X++" or n=="++X"):
# x=x+1
# else:
# x=x-1
# print(x)
# n = input()
# m = input()
# n = n.lower()
# m = m.lower()
# if n == m:
# print("0")
# elif n > m:
# print('1')
# elif n <m:
# print('-1')
# matrix=[]
# min=[]
# one_line=0
# one_column=0
# for l in range(0,5):
# m=input().split()
# for col,ele in enumerate()
# a = list(map(int,input().split('+')))
# a.sort()
# print('+'.join([str(c) for c in a]))
# n=list(input())
# # if(n[0].islower()):
# n[0]=n[0].upper()
# else:
# pass
# print("".join(str(x)for x in n))
# n=list(input())
# s=input()
# count=0
# for i in range(1,len(s)):
# if(s[i]==s[i-1]):
# count+=1
# print(count)
# v=["A","O","Y","E","U","I","a","i","e","o","u","y"]
# n=list(input())
# x=[]
# for i in range(len(n)):
# if n[i] not in v:
# x.append(n[i])
# print("."+".".join(str(y.lower())for y in x))
# a=[]
# b=[]
# c=[]
# for _ in range(int(input())):
# x,y,z=map(int,input().split())
# a.append(x)
# b.append(y)
# c.append(z)
# print("YES" if sum(a)==sum(b)==sum(c)== 0 else "NO")
# m = "hello"
# n=input()
# j=0
# flag=0
# for i in range(len(n)):
# if(n[i]==m[j]):
# j=j+1
# if(j==5):
# flag=1
# break
# if(flag==1):
# print("YES")
# else:
# print("NO")
# a=set(list(input()))
# print("CHAT WITH HER!" if len(set(list(input())))%2==0 else "IGNORE HIM!")
# k,n,w=map(int,input().split())
# sum=0
# a=[]
# for i in range(w+1):
# sum+=k*i
# print((sum-n) if sum>n else 0)
# m,n = 0,0
# for i in range(5):
# a = map(int,input().split())
# for j in range(5):
# if a[j]!=0:
# m = i
# n = j
# break
# print(abs(m-2)+abs(n-2))
# l,b=map(int,input().split())
# c=0
# while(l<=b):
# l=l*3
# b=b*2
# c=c+1
# print(c)
# from math import ceil
# n,m,a=map(int,input().split())
# # print(ceil(n/a),ceil(m/a))
# c=ceil(n/a)*ceil(m/a)
# print(c)
# n=int(input())
# if(n%4==0 or n%7==0 or n%44==0 or n%47==0 or n%74==0 or n%444==0 or n%447==0 or n%474==0 or n%477==0):
# print("YES")
# else:
# print("NO")
# def tramCapacity():
# n = int(input().strip())
# pout, pin = map(int, input().strip().split())
# sm = pin
# mx = pin
# for i in range(n-1):
# pout, pin = map(int, input().strip().split())
# sm = sm - pout + pin
# if sm > mx:
# mx = sm
# return mx
# print(tramCapacity())
# n,k=map(int,input().split())
# for i in range(k):
# if(str(n)[-1]=="0"):
# n=n//10
# else:
# n=n-1
# print(n)
# n=int(input())
# n=int(input())
# if(n%5==0):
# print(n//5)
# else:
# print((n//5)+1)
# n=int(input())
# if(n%2==0):
# print(n//2)
# else:
# print("-"+str(n-((n-1)//2)))
# n=int(input())
# arr=list(map(int,input().split()))
# sum=sum(arr)
# deno=len(arr)*100
# print(format(((sum/deno)*100),'.12f'))
# k=int(input())
# l=int(input())
# m=int(input())
# n=int(input())
# d=int(input())
# count=0
# # if(d%k==0):
# # print(d)
# # elif(d%l==0):
# # print(d//l)
# # elif(d%m==0):
# # print(d//m)
# # elif(d%n==0):
# # print(d//n)
# # else:
# for i in range(1,d+1):
# if(i%k==0 or i%l==0 or i%m==0 or i%n==0):
# count+=1
# print(count)
# a,b=map(int,input().split())
# # if(n%m==0):
# # print(0)
# # else:
# # for i in range(m):
# # n=n+i
# # if(n%m==0):
# # print(i-1)
# # break
# # else:
# # continue
# x=((a+b)-1)/b
# print((b*x)-1)
# for _ in range(int(input())):
# a, b = map(int,input().split(" "))
# x=(a + b - 1) // b
# # print(x)
# print((b * x) - a)
# for _ in range(int(input())):
# n=int(input())
# print((n-1)//2)
# n=int(input())
# # n = int(input())
# if n%2 == 0:
# print(8, n-8)
# else:
# print(9, n-9)
# n=int(input())
# a=[]
# for i in range(len(n)):
# x=int(n)-int(n)%(10**i)
# a.append(x)
# print(a)
# # b=max(a)
# print(a[-1])
# for i in range(len(a)):
# a[i]=a[i]-a[-1]
# print(a)
# for _ in range(int(input())):
# n=int(input())
# p=1
# rl=[]
# x=[]
# while(n>0):
# dig=n%10
# r=dig*p
# rl.append(r)
# p*=10
# n=n//10
# for i in rl:
# if i !=0:
# x.append(i)
# print(len(x))
# print(" ".join(str(x)for x in x))
# n,m=map(int,input().split())
# print(str(min(n,m))+" "+str((max(n,m)-min(n,m))//2))
# arr=sorted(list(map(int,input().split())))
# s=max(arr)
# ac=arr[0]
# ab=arr[1]
# bc=arr[2]
# a=s-bc
# b=ab-a
# c=bc-b
# print(a,b,c)
# x=0
# q,t=map(int,input().split())
# for i in range(1,q+1):
# x=x+5*i
# if(x>240-t):
# print(i-1)
# break
# if(x<=240-t):
# print(q)
# # print(q)
# print(z)
# print(x)
# l=(240-t)-x
# print(l)
# if(((240-t)-x)>=0):
# print(q)
# else:
# print(q-1)
# n, L = map(int, input().split())
# arr = [int(x) for x in input().split()]
# arr.sort()
# x = arr[0] - 0
# y = L - arr[-1]
# r = max(x, y) * 2
# for i in range(1, n):
# r = max(r, arr[i] - arr[i-1])
# print(format(r/2,'.12f'))
# n,m=map(int,input().split())
# print(((m-n)*2)-1)
# for _ in range(int(input())):
# n=int(input())
# x=360/(180-n)
# # print(x)
# if(n==60 or n==90 or n==120 or n==108 or n==128.57 or n==135 or n==140 or n==144 or n==162 or n==180):
# print("YES")
# elif(x==round(x)):
# print("YES")
# else:
# print("NO")
# n,m=map(int,input().split())
# if(n<2 and m==10):
# print(-1)
# else:
# x=10**(n-1)
# print(x+(m-(x%m)))
# for _ in range(int(input())):
# n,k=map(int,input().split())
# a=list(map(int,input().split()))
# a.sort()
# c=0
# for i in range(1,n):
# c = (k-a[i])//a[0]
# # print(c)
# for _ in range(int(input())):
# x,y=map(int,input().split())
# a,b=map(int,input().split())
# q=a*(x+y)
# p=b*(min(x,y))+a*(abs(x-y))
# print(min(p,q))
# n,k=map(int,input().split())
# a=n//2+n%2
# print(a)
# if(k<=a):
# print(2*k-1)
# else:
# print(2*(k-a))
# a,b=map(int,input().split())
# count=0
# if(a>=b):
# print(a-b)
# else:
# while(b>a):
# if(b%2==0):
# b=int(b/2)
# count+=1
# else:
# b+=1
# count+=1
# print(count+(a-b))
# n=int(input())
# while n>5:
# n = n - 4
# n=(n-((n-4)%2))/2
# # print(n)
# if n==1:
# print('Sheldon')
# if n==2:
# print('Leonard')
# if n==3:
# print('Penny')
# if n==4:
# print('Rajesh')
# if n==5:
# print('Howard')
# n, m = (int(x) for x in input().split())
# if(n<m):
# print(-1)
# else:
# print((int((n-0.5)/(2*m))+1)*m)
# for _ in range(int(input())):
# n,k=map(int,input().split())
# print(k//n)
# print(k%n)
# if((k+(k//n))%n==0):
# print(k+(k//n)+1)
# else:
# print(k+(k//n))
# for i in range(int(input())):
# n,k=map(int,input().split())
# print((k-1)//(n-1) +k)
# for _ in range(int(input())):
# n,k = map(int,input().split())
# if (n >= k*k and n % 2 == k % 2):
# print("YES")
# else:
# print("NO")
# for _ in range(int(input())):
# n,x=map(int,input().split())
# a=list(map(int,input().split()))
# arr=[]
# # s=sum([i%2 for i in a])
# for i in a:
# j=i%2
# arr.append(j)
# s=sum(arr)
# # print(s)
# if s==0 or (n==x and s%2==0) or (s==n and x%2==0):
# print("No")
# else:
# print("Yes")
# a=int(input())
# print(a*(a*a+5)//6)
# n,m=map(int,input().split())
# a=[]
# k='YES'
# for i in range(m):
# a.append(list(map(int,input().split())))
# a.sort()
# for i in a:
# if i[0]<n:
# n=n+i[1]
# else:
# k='NO'
# break
# print(k)
# a=input()
# if('1'*7 in a or '0'*7 in a):
# print("YES")
# else:
# print("NO")
# s=int(input())
# for i in range(s):
# n=int(input())
# if (n//2)%2==1:
# print('NO')
# else:
# print('YES')
# for j in range(n//2):
# print(2*(j+1))
# for j in range(n//2-1):
# print(2*(j+1)-1)
# print(n-1+n//2)
# k,r=map(int,input().split())
# i=1
# while((k*i)%10)!=0 and ((k*i)%10)!=r:
# i=i+1
# print(i)
# for _ in range(int(input())):
# n,m=map(int,input().split())
# if(abs(n-m)==0):
# print(0)
# else:
# if(abs(n-m)%10==0):
# print((abs(n-m)//10))
# else:
# print((abs(n-m)//10)+1)
# a,b,c=map(int,input().split())
# print(max(a,b,c)-min(a,b,c))
# a=int(input())
# arr=list(map(int,input().split()))
# print(a*max(arr)-sum(arr))
# for _ in range(int(input())):
# a, b = map(int, input().split())
# if a==b:
# print((a+b)**2)
# elif max(a,b)%min(a,b)==0:
# print(max(a,b)**2)
# else:
# ans=max(max(a,b),2*min(a,b))
# print(ans**2)
# import math
# # for _ in range(int(input())):
# x=int(input())
# a=list(map(int,input().split()))
# for j in range(len(a)):
# n=math.sqrt(a[j])
# flag=0
# if(a[j]==1):
# print("NO")
# elif(n==math.floor(n)):
# for i in range(int(n)):
# if((6*i)-1==n or ((6*i)+1==n) or n==2 or n==3 or n!=1):
# # print("YES")
# flag=1
# break
# else:
# flag=0
# print("YES" if flag==1 else "NO")
# else:
# print("NO")
# print(12339-12345)
# for _ in range(int(input())):
# x,y,n=map(int,input().split())
# # for i in range((n-x),n):
# # # if(i%x==y):
# # print(i)
# print(n-(n-y)%x)
# n=int(input())
# for _ in range(int(input())):
# n= int(input())
# print(int(2**(n//2+1)-2))
# for _ in range(int(input())):
# n=int(input())
# arr=list(map(int,input().split()))
# countod=0
# countev=0
# for i in range(n):
# if i%2==0 and arr[i]%2!=0:
# countev+=1
# elif i%2!=0 and arr[i]%2==0:
# countod+=1
# if countod!=countev:
# print(-1)
# else:
# print(countev)
# n,m=map(int,input().split())
# x=m/(n//2)
# print(x)
# print(int(x*(n-1)))
# for _ in range(int(input())):
# n,m = map(int,input().split())
# print(m*min(2,n-1))
# n=int(input())
# if(n%2==0):
# print(n//2)
# print('2 '*(n//2))
# else:
# print(((n-2)//2)+1)
# print('2 '*(((n-2)//2)) + "3")
for _ in range(int(input())):
n=int(input())
for i in range(2,30):
if(n%(2**i - 1)==0):
print(n//(2**i - 1))
break
```
| 14,318 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Vova found n candy wrappers. He remembers that he bought x candies during the first day, 2x candies during the second day, 4x candies during the third day, ..., 2^{k-1} x candies during the k-th day. But there is an issue: Vova remembers neither x nor k but he is sure that x and k are positive integers and k > 1.
Vova will be satisfied if you tell him any positive integer x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n. It is guaranteed that at least one solution exists. Note that k > 1.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (3 ≤ n ≤ 10^9) — the number of candy wrappers Vova found. It is guaranteed that there is some positive integer x and integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Output
Print one integer — any positive integer value of x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Example
Input
7
3
6
7
21
28
999999999
999999984
Output
1
2
1
7
4
333333333
333333328
Note
In the first test case of the example, one of the possible answers is x=1, k=2. Then 1 ⋅ 1 + 2 ⋅ 1 equals n=3.
In the second test case of the example, one of the possible answers is x=2, k=2. Then 1 ⋅ 2 + 2 ⋅ 2 equals n=6.
In the third test case of the example, one of the possible answers is x=1, k=3. Then 1 ⋅ 1 + 2 ⋅ 1 + 4 ⋅ 1 equals n=7.
In the fourth test case of the example, one of the possible answers is x=7, k=2. Then 1 ⋅ 7 + 2 ⋅ 7 equals n=21.
In the fifth test case of the example, one of the possible answers is x=4, k=3. Then 1 ⋅ 4 + 2 ⋅ 4 + 4 ⋅ 4 equals n=28.
Tags: brute force, math
Correct Solution:
```
for i in range(int(input())):
n=int(input())
k=2
while True:
arr_sum=n/(pow(2,k)-1)
if arr_sum==n//(pow(2,k)-1) and arr_sum>0:
print(int(arr_sum))
break
k+=1
```
| 14,319 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Vova found n candy wrappers. He remembers that he bought x candies during the first day, 2x candies during the second day, 4x candies during the third day, ..., 2^{k-1} x candies during the k-th day. But there is an issue: Vova remembers neither x nor k but he is sure that x and k are positive integers and k > 1.
Vova will be satisfied if you tell him any positive integer x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n. It is guaranteed that at least one solution exists. Note that k > 1.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (3 ≤ n ≤ 10^9) — the number of candy wrappers Vova found. It is guaranteed that there is some positive integer x and integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Output
Print one integer — any positive integer value of x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Example
Input
7
3
6
7
21
28
999999999
999999984
Output
1
2
1
7
4
333333333
333333328
Note
In the first test case of the example, one of the possible answers is x=1, k=2. Then 1 ⋅ 1 + 2 ⋅ 1 equals n=3.
In the second test case of the example, one of the possible answers is x=2, k=2. Then 1 ⋅ 2 + 2 ⋅ 2 equals n=6.
In the third test case of the example, one of the possible answers is x=1, k=3. Then 1 ⋅ 1 + 2 ⋅ 1 + 4 ⋅ 1 equals n=7.
In the fourth test case of the example, one of the possible answers is x=7, k=2. Then 1 ⋅ 7 + 2 ⋅ 7 equals n=21.
In the fifth test case of the example, one of the possible answers is x=4, k=3. Then 1 ⋅ 4 + 2 ⋅ 4 + 4 ⋅ 4 equals n=28.
Tags: brute force, math
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
p = 2
while n % (2 ** p - 1) != 0:
p += 1
print(n // (2 ** p - 1))
```
| 14,320 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Vova found n candy wrappers. He remembers that he bought x candies during the first day, 2x candies during the second day, 4x candies during the third day, ..., 2^{k-1} x candies during the k-th day. But there is an issue: Vova remembers neither x nor k but he is sure that x and k are positive integers and k > 1.
Vova will be satisfied if you tell him any positive integer x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n. It is guaranteed that at least one solution exists. Note that k > 1.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (3 ≤ n ≤ 10^9) — the number of candy wrappers Vova found. It is guaranteed that there is some positive integer x and integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Output
Print one integer — any positive integer value of x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Example
Input
7
3
6
7
21
28
999999999
999999984
Output
1
2
1
7
4
333333333
333333328
Note
In the first test case of the example, one of the possible answers is x=1, k=2. Then 1 ⋅ 1 + 2 ⋅ 1 equals n=3.
In the second test case of the example, one of the possible answers is x=2, k=2. Then 1 ⋅ 2 + 2 ⋅ 2 equals n=6.
In the third test case of the example, one of the possible answers is x=1, k=3. Then 1 ⋅ 1 + 2 ⋅ 1 + 4 ⋅ 1 equals n=7.
In the fourth test case of the example, one of the possible answers is x=7, k=2. Then 1 ⋅ 7 + 2 ⋅ 7 equals n=21.
In the fifth test case of the example, one of the possible answers is x=4, k=3. Then 1 ⋅ 4 + 2 ⋅ 4 + 4 ⋅ 4 equals n=28.
Submitted Solution:
```
from collections import defaultdict as dc
from heapq import *
import math
import bisect
import sys
from collections import deque as dq
from heapq import heapify,heappush,heappop
mod=10**12
def inp():
p=int(input())
return p
def line():
p=list(map(int,input().split()))
return p
def read_mat():
n=inp()
a=[]
for i in range(n):
a.append(line())
return a
def digit(n):
s=str(n)
p=0
for i in s:
p+=(int(i))**2
return p
def check(a,b):
for i in range(26):
for j in range(len(a)+1):
q=a[:j]+chr(97+i)+a[j:]
if q==b:
return 1
return 0
def solve(a):
for k in range(2,40):
z=pow(2,k)-1
if a%z==0:
return a//z
for _ in range(inp()):
a=inp()
l=solve(a)
print(l)
# print("Case #"+str(_+1)+":",l)
```
Yes
| 14,321 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Vova found n candy wrappers. He remembers that he bought x candies during the first day, 2x candies during the second day, 4x candies during the third day, ..., 2^{k-1} x candies during the k-th day. But there is an issue: Vova remembers neither x nor k but he is sure that x and k are positive integers and k > 1.
Vova will be satisfied if you tell him any positive integer x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n. It is guaranteed that at least one solution exists. Note that k > 1.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (3 ≤ n ≤ 10^9) — the number of candy wrappers Vova found. It is guaranteed that there is some positive integer x and integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Output
Print one integer — any positive integer value of x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Example
Input
7
3
6
7
21
28
999999999
999999984
Output
1
2
1
7
4
333333333
333333328
Note
In the first test case of the example, one of the possible answers is x=1, k=2. Then 1 ⋅ 1 + 2 ⋅ 1 equals n=3.
In the second test case of the example, one of the possible answers is x=2, k=2. Then 1 ⋅ 2 + 2 ⋅ 2 equals n=6.
In the third test case of the example, one of the possible answers is x=1, k=3. Then 1 ⋅ 1 + 2 ⋅ 1 + 4 ⋅ 1 equals n=7.
In the fourth test case of the example, one of the possible answers is x=7, k=2. Then 1 ⋅ 7 + 2 ⋅ 7 equals n=21.
In the fifth test case of the example, one of the possible answers is x=4, k=3. Then 1 ⋅ 4 + 2 ⋅ 4 + 4 ⋅ 4 equals n=28.
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
k=4
ans=0
while(k<n):
if(n%(k-1)==0):
ans=(n//(k-1))
break
k*=2
if(ans==0):
print(1)
else:
print(ans)
```
Yes
| 14,322 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Vova found n candy wrappers. He remembers that he bought x candies during the first day, 2x candies during the second day, 4x candies during the third day, ..., 2^{k-1} x candies during the k-th day. But there is an issue: Vova remembers neither x nor k but he is sure that x and k are positive integers and k > 1.
Vova will be satisfied if you tell him any positive integer x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n. It is guaranteed that at least one solution exists. Note that k > 1.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (3 ≤ n ≤ 10^9) — the number of candy wrappers Vova found. It is guaranteed that there is some positive integer x and integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Output
Print one integer — any positive integer value of x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Example
Input
7
3
6
7
21
28
999999999
999999984
Output
1
2
1
7
4
333333333
333333328
Note
In the first test case of the example, one of the possible answers is x=1, k=2. Then 1 ⋅ 1 + 2 ⋅ 1 equals n=3.
In the second test case of the example, one of the possible answers is x=2, k=2. Then 1 ⋅ 2 + 2 ⋅ 2 equals n=6.
In the third test case of the example, one of the possible answers is x=1, k=3. Then 1 ⋅ 1 + 2 ⋅ 1 + 4 ⋅ 1 equals n=7.
In the fourth test case of the example, one of the possible answers is x=7, k=2. Then 1 ⋅ 7 + 2 ⋅ 7 equals n=21.
In the fifth test case of the example, one of the possible answers is x=4, k=3. Then 1 ⋅ 4 + 2 ⋅ 4 + 4 ⋅ 4 equals n=28.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
for k in range(2, 30):
if n % (2 ** k - 1) == 0:
print(n // (2 ** k - 1))
break
```
Yes
| 14,323 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Vova found n candy wrappers. He remembers that he bought x candies during the first day, 2x candies during the second day, 4x candies during the third day, ..., 2^{k-1} x candies during the k-th day. But there is an issue: Vova remembers neither x nor k but he is sure that x and k are positive integers and k > 1.
Vova will be satisfied if you tell him any positive integer x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n. It is guaranteed that at least one solution exists. Note that k > 1.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (3 ≤ n ≤ 10^9) — the number of candy wrappers Vova found. It is guaranteed that there is some positive integer x and integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Output
Print one integer — any positive integer value of x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Example
Input
7
3
6
7
21
28
999999999
999999984
Output
1
2
1
7
4
333333333
333333328
Note
In the first test case of the example, one of the possible answers is x=1, k=2. Then 1 ⋅ 1 + 2 ⋅ 1 equals n=3.
In the second test case of the example, one of the possible answers is x=2, k=2. Then 1 ⋅ 2 + 2 ⋅ 2 equals n=6.
In the third test case of the example, one of the possible answers is x=1, k=3. Then 1 ⋅ 1 + 2 ⋅ 1 + 4 ⋅ 1 equals n=7.
In the fourth test case of the example, one of the possible answers is x=7, k=2. Then 1 ⋅ 7 + 2 ⋅ 7 equals n=21.
In the fifth test case of the example, one of the possible answers is x=4, k=3. Then 1 ⋅ 4 + 2 ⋅ 4 + 4 ⋅ 4 equals n=28.
Submitted Solution:
```
def test_a(n):
k = 2
k_pow_two = 2**k-1
while k_pow_two <= n:
if n / k_pow_two == n // k_pow_two:
# print(n, k_pow_two, n // k_pow_two)
return n // k_pow_two
k +=1
k_pow_two = 2**k-1
t = int(input())
for i in range(t):
n = int(input())
x = test_a(n)
print(x)
```
Yes
| 14,324 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Vova found n candy wrappers. He remembers that he bought x candies during the first day, 2x candies during the second day, 4x candies during the third day, ..., 2^{k-1} x candies during the k-th day. But there is an issue: Vova remembers neither x nor k but he is sure that x and k are positive integers and k > 1.
Vova will be satisfied if you tell him any positive integer x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n. It is guaranteed that at least one solution exists. Note that k > 1.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (3 ≤ n ≤ 10^9) — the number of candy wrappers Vova found. It is guaranteed that there is some positive integer x and integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Output
Print one integer — any positive integer value of x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Example
Input
7
3
6
7
21
28
999999999
999999984
Output
1
2
1
7
4
333333333
333333328
Note
In the first test case of the example, one of the possible answers is x=1, k=2. Then 1 ⋅ 1 + 2 ⋅ 1 equals n=3.
In the second test case of the example, one of the possible answers is x=2, k=2. Then 1 ⋅ 2 + 2 ⋅ 2 equals n=6.
In the third test case of the example, one of the possible answers is x=1, k=3. Then 1 ⋅ 1 + 2 ⋅ 1 + 4 ⋅ 1 equals n=7.
In the fourth test case of the example, one of the possible answers is x=7, k=2. Then 1 ⋅ 7 + 2 ⋅ 7 equals n=21.
In the fifth test case of the example, one of the possible answers is x=4, k=3. Then 1 ⋅ 4 + 2 ⋅ 4 + 4 ⋅ 4 equals n=28.
Submitted Solution:
```
for i in range(int(input())):
n = int(input())
k = 2
x = 0
# Geometric Progression Sum x = n / (2 ** k - 1)
while k < 29:
if not (n % (2**k - 1)):
x = n // (2**k - 1)
break
k += 1
print(x)
```
No
| 14,325 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Vova found n candy wrappers. He remembers that he bought x candies during the first day, 2x candies during the second day, 4x candies during the third day, ..., 2^{k-1} x candies during the k-th day. But there is an issue: Vova remembers neither x nor k but he is sure that x and k are positive integers and k > 1.
Vova will be satisfied if you tell him any positive integer x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n. It is guaranteed that at least one solution exists. Note that k > 1.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (3 ≤ n ≤ 10^9) — the number of candy wrappers Vova found. It is guaranteed that there is some positive integer x and integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Output
Print one integer — any positive integer value of x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Example
Input
7
3
6
7
21
28
999999999
999999984
Output
1
2
1
7
4
333333333
333333328
Note
In the first test case of the example, one of the possible answers is x=1, k=2. Then 1 ⋅ 1 + 2 ⋅ 1 equals n=3.
In the second test case of the example, one of the possible answers is x=2, k=2. Then 1 ⋅ 2 + 2 ⋅ 2 equals n=6.
In the third test case of the example, one of the possible answers is x=1, k=3. Then 1 ⋅ 1 + 2 ⋅ 1 + 4 ⋅ 1 equals n=7.
In the fourth test case of the example, one of the possible answers is x=7, k=2. Then 1 ⋅ 7 + 2 ⋅ 7 equals n=21.
In the fifth test case of the example, one of the possible answers is x=4, k=3. Then 1 ⋅ 4 + 2 ⋅ 4 + 4 ⋅ 4 equals n=28.
Submitted Solution:
```
t=int(input())
ans=[]
for i in range(t):
n=int(input())
k=2
while(True):
s=(2**k)-1
if n%s==0:
ans.append(n//s)
break
k+=1
print(ans)
```
No
| 14,326 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Vova found n candy wrappers. He remembers that he bought x candies during the first day, 2x candies during the second day, 4x candies during the third day, ..., 2^{k-1} x candies during the k-th day. But there is an issue: Vova remembers neither x nor k but he is sure that x and k are positive integers and k > 1.
Vova will be satisfied if you tell him any positive integer x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n. It is guaranteed that at least one solution exists. Note that k > 1.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (3 ≤ n ≤ 10^9) — the number of candy wrappers Vova found. It is guaranteed that there is some positive integer x and integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Output
Print one integer — any positive integer value of x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Example
Input
7
3
6
7
21
28
999999999
999999984
Output
1
2
1
7
4
333333333
333333328
Note
In the first test case of the example, one of the possible answers is x=1, k=2. Then 1 ⋅ 1 + 2 ⋅ 1 equals n=3.
In the second test case of the example, one of the possible answers is x=2, k=2. Then 1 ⋅ 2 + 2 ⋅ 2 equals n=6.
In the third test case of the example, one of the possible answers is x=1, k=3. Then 1 ⋅ 1 + 2 ⋅ 1 + 4 ⋅ 1 equals n=7.
In the fourth test case of the example, one of the possible answers is x=7, k=2. Then 1 ⋅ 7 + 2 ⋅ 7 equals n=21.
In the fifth test case of the example, one of the possible answers is x=4, k=3. Then 1 ⋅ 4 + 2 ⋅ 4 + 4 ⋅ 4 equals n=28.
Submitted Solution:
```
n = int(input())
for i in range(n):
a = int(input())
print(a)
```
No
| 14,327 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Vova found n candy wrappers. He remembers that he bought x candies during the first day, 2x candies during the second day, 4x candies during the third day, ..., 2^{k-1} x candies during the k-th day. But there is an issue: Vova remembers neither x nor k but he is sure that x and k are positive integers and k > 1.
Vova will be satisfied if you tell him any positive integer x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n. It is guaranteed that at least one solution exists. Note that k > 1.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (3 ≤ n ≤ 10^9) — the number of candy wrappers Vova found. It is guaranteed that there is some positive integer x and integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Output
Print one integer — any positive integer value of x so there is an integer k>1 that x + 2x + 4x + ... + 2^{k-1} x = n.
Example
Input
7
3
6
7
21
28
999999999
999999984
Output
1
2
1
7
4
333333333
333333328
Note
In the first test case of the example, one of the possible answers is x=1, k=2. Then 1 ⋅ 1 + 2 ⋅ 1 equals n=3.
In the second test case of the example, one of the possible answers is x=2, k=2. Then 1 ⋅ 2 + 2 ⋅ 2 equals n=6.
In the third test case of the example, one of the possible answers is x=1, k=3. Then 1 ⋅ 1 + 2 ⋅ 1 + 4 ⋅ 1 equals n=7.
In the fourth test case of the example, one of the possible answers is x=7, k=2. Then 1 ⋅ 7 + 2 ⋅ 7 equals n=21.
In the fifth test case of the example, one of the possible answers is x=4, k=3. Then 1 ⋅ 4 + 2 ⋅ 4 + 4 ⋅ 4 equals n=28.
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
if(n%3==0):
print(n//3)
elif(n%7==0):
print(n//7)
else:
print(n)
```
No
| 14,328 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish has n elements arranged in a line.
These elements are represented by two integers a_i — the value of the element and b_i — the type of the element (there are only two possible types: 0 and 1). He wants to sort the elements in non-decreasing values of a_i.
He can perform the following operation any number of times:
* Select any two elements i and j such that b_i ≠ b_j and swap them. That is, he can only swap two elements of different types in one move.
Tell him if he can sort the elements in non-decreasing values of a_i after performing any number of operations.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (1 ≤ n ≤ 500) — the size of the arrays.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^5) — the value of the i-th element.
The third line containts n integers b_i (b_i ∈ \{0, 1\}) — the type of the i-th element.
Output
For each test case, print "Yes" or "No" (without quotes) depending on whether it is possible to sort elements in non-decreasing order of their value.
You may print each letter in any case (upper or lower).
Example
Input
5
4
10 20 20 30
0 1 0 1
3
3 1 2
0 1 1
4
2 2 4 8
1 1 1 1
3
5 15 4
0 0 0
4
20 10 100 50
1 0 0 1
Output
Yes
Yes
Yes
No
Yes
Note
For the first case: The elements are already in sorted order.
For the second case: Ashish may first swap elements at positions 1 and 2, then swap elements at positions 2 and 3.
For the third case: The elements are already in sorted order.
For the fourth case: No swap operations may be performed as there is no pair of elements i and j such that b_i ≠ b_j. The elements cannot be sorted.
For the fifth case: Ashish may swap elements at positions 3 and 4, then elements at positions 1 and 2.
Tags: constructive algorithms, implementation
Correct Solution:
```
from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import heappush,heappop
import math
from collections import *
from functools import reduce,cmp_to_key,lru_cache
from itertools import *
import io, os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
# import sys
# input = sys.stdin.readline
M = mod = 10**9 + 7
def factors(n):return sorted(set(reduce(list.__add__, ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0))))
def inv_mod(n):return pow(n, mod - 2, mod)
def li():return [int(i) for i in input().rstrip().split()]
def st():return str(input().rstrip())[2:-1]
def val():return int(input().rstrip())
def li2():return [str(i)[2:-1] for i in input().rstrip().split()]
def li3():return [int(i) for i in st()]
for _ in range(val()):
n = val()
l1 = li()
l2 = li()
l3 = sorted(l1)
ans = 'NO'
if l3 == l1 or max(l2) != min(l2):
ans = 'YES'
print(ans)
```
| 14,329 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish has n elements arranged in a line.
These elements are represented by two integers a_i — the value of the element and b_i — the type of the element (there are only two possible types: 0 and 1). He wants to sort the elements in non-decreasing values of a_i.
He can perform the following operation any number of times:
* Select any two elements i and j such that b_i ≠ b_j and swap them. That is, he can only swap two elements of different types in one move.
Tell him if he can sort the elements in non-decreasing values of a_i after performing any number of operations.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (1 ≤ n ≤ 500) — the size of the arrays.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^5) — the value of the i-th element.
The third line containts n integers b_i (b_i ∈ \{0, 1\}) — the type of the i-th element.
Output
For each test case, print "Yes" or "No" (without quotes) depending on whether it is possible to sort elements in non-decreasing order of their value.
You may print each letter in any case (upper or lower).
Example
Input
5
4
10 20 20 30
0 1 0 1
3
3 1 2
0 1 1
4
2 2 4 8
1 1 1 1
3
5 15 4
0 0 0
4
20 10 100 50
1 0 0 1
Output
Yes
Yes
Yes
No
Yes
Note
For the first case: The elements are already in sorted order.
For the second case: Ashish may first swap elements at positions 1 and 2, then swap elements at positions 2 and 3.
For the third case: The elements are already in sorted order.
For the fourth case: No swap operations may be performed as there is no pair of elements i and j such that b_i ≠ b_j. The elements cannot be sorted.
For the fifth case: Ashish may swap elements at positions 3 and 4, then elements at positions 1 and 2.
Tags: constructive algorithms, implementation
Correct Solution:
```
def main():
for t in range(int(input())):
n = int(input())
a = list(zip(list(map(int, input().split())), list(map(int, input().split()))))
cnt = [0, 0]
for i in range(n):
cnt[a[i][1]] += 1
is_sorted = True
for i in range(1, n):
if a[i - 1][0] > a[i][0]:
is_sorted = False
break
ans = 'Yes' if is_sorted or (not is_sorted and cnt[0] != 0 and cnt[1] != 0) else 'No'
print(ans)
if __name__ == "__main__":
main()
```
| 14,330 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish has n elements arranged in a line.
These elements are represented by two integers a_i — the value of the element and b_i — the type of the element (there are only two possible types: 0 and 1). He wants to sort the elements in non-decreasing values of a_i.
He can perform the following operation any number of times:
* Select any two elements i and j such that b_i ≠ b_j and swap them. That is, he can only swap two elements of different types in one move.
Tell him if he can sort the elements in non-decreasing values of a_i after performing any number of operations.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (1 ≤ n ≤ 500) — the size of the arrays.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^5) — the value of the i-th element.
The third line containts n integers b_i (b_i ∈ \{0, 1\}) — the type of the i-th element.
Output
For each test case, print "Yes" or "No" (without quotes) depending on whether it is possible to sort elements in non-decreasing order of their value.
You may print each letter in any case (upper or lower).
Example
Input
5
4
10 20 20 30
0 1 0 1
3
3 1 2
0 1 1
4
2 2 4 8
1 1 1 1
3
5 15 4
0 0 0
4
20 10 100 50
1 0 0 1
Output
Yes
Yes
Yes
No
Yes
Note
For the first case: The elements are already in sorted order.
For the second case: Ashish may first swap elements at positions 1 and 2, then swap elements at positions 2 and 3.
For the third case: The elements are already in sorted order.
For the fourth case: No swap operations may be performed as there is no pair of elements i and j such that b_i ≠ b_j. The elements cannot be sorted.
For the fifth case: Ashish may swap elements at positions 3 and 4, then elements at positions 1 and 2.
Tags: constructive algorithms, implementation
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
l1=list(map(int,input().split()))
zeros,ones=0,0
for i in l1:
if i==0:
zeros+=1
else:
ones+=1
if zeros==0 or ones==0:
l2=[]
for i in l:
l2.append(i)
#print(l2)
l2.sort()
#print(l2)
#print(l)
if l==l2:
print("Yes")
else:
print("No")
else:
print("Yes")
```
| 14,331 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish has n elements arranged in a line.
These elements are represented by two integers a_i — the value of the element and b_i — the type of the element (there are only two possible types: 0 and 1). He wants to sort the elements in non-decreasing values of a_i.
He can perform the following operation any number of times:
* Select any two elements i and j such that b_i ≠ b_j and swap them. That is, he can only swap two elements of different types in one move.
Tell him if he can sort the elements in non-decreasing values of a_i after performing any number of operations.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (1 ≤ n ≤ 500) — the size of the arrays.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^5) — the value of the i-th element.
The third line containts n integers b_i (b_i ∈ \{0, 1\}) — the type of the i-th element.
Output
For each test case, print "Yes" or "No" (without quotes) depending on whether it is possible to sort elements in non-decreasing order of their value.
You may print each letter in any case (upper or lower).
Example
Input
5
4
10 20 20 30
0 1 0 1
3
3 1 2
0 1 1
4
2 2 4 8
1 1 1 1
3
5 15 4
0 0 0
4
20 10 100 50
1 0 0 1
Output
Yes
Yes
Yes
No
Yes
Note
For the first case: The elements are already in sorted order.
For the second case: Ashish may first swap elements at positions 1 and 2, then swap elements at positions 2 and 3.
For the third case: The elements are already in sorted order.
For the fourth case: No swap operations may be performed as there is no pair of elements i and j such that b_i ≠ b_j. The elements cannot be sorted.
For the fifth case: Ashish may swap elements at positions 3 and 4, then elements at positions 1 and 2.
Tags: constructive algorithms, implementation
Correct Solution:
```
import sys
from sys import stdin
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
def neo(): return map(int,input().split())
def Neo(): return list(map(int,input().split()))
for _ in range(int(input())):
n=int(input());A=Neo();B=Neo();mark={};C=A.copy();C.sort()
if C==A:print('Yes')
else:
if B.count(0)==0 or B.count(1)==0:print('No')
else:print('Yes')
```
| 14,332 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish has n elements arranged in a line.
These elements are represented by two integers a_i — the value of the element and b_i — the type of the element (there are only two possible types: 0 and 1). He wants to sort the elements in non-decreasing values of a_i.
He can perform the following operation any number of times:
* Select any two elements i and j such that b_i ≠ b_j and swap them. That is, he can only swap two elements of different types in one move.
Tell him if he can sort the elements in non-decreasing values of a_i after performing any number of operations.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (1 ≤ n ≤ 500) — the size of the arrays.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^5) — the value of the i-th element.
The third line containts n integers b_i (b_i ∈ \{0, 1\}) — the type of the i-th element.
Output
For each test case, print "Yes" or "No" (without quotes) depending on whether it is possible to sort elements in non-decreasing order of their value.
You may print each letter in any case (upper or lower).
Example
Input
5
4
10 20 20 30
0 1 0 1
3
3 1 2
0 1 1
4
2 2 4 8
1 1 1 1
3
5 15 4
0 0 0
4
20 10 100 50
1 0 0 1
Output
Yes
Yes
Yes
No
Yes
Note
For the first case: The elements are already in sorted order.
For the second case: Ashish may first swap elements at positions 1 and 2, then swap elements at positions 2 and 3.
For the third case: The elements are already in sorted order.
For the fourth case: No swap operations may be performed as there is no pair of elements i and j such that b_i ≠ b_j. The elements cannot be sorted.
For the fifth case: Ashish may swap elements at positions 3 and 4, then elements at positions 1 and 2.
Tags: constructive algorithms, implementation
Correct Solution:
```
t = int(input())
for i in range(t):
n = int(input())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
if a == sorted(a):
print("Yes")
elif b.count(0)==len(b) or b.count(1)==len(b):
print("No")
else:
l = []
for i in range(len(a)):
l.append([a[i],b[i]])
l.sort()
temp = []
for j in range(len(l)):
temp.append(l[i][1])
if temp!=b:
print("Yes")
else:
print("No")
```
| 14,333 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish has n elements arranged in a line.
These elements are represented by two integers a_i — the value of the element and b_i — the type of the element (there are only two possible types: 0 and 1). He wants to sort the elements in non-decreasing values of a_i.
He can perform the following operation any number of times:
* Select any two elements i and j such that b_i ≠ b_j and swap them. That is, he can only swap two elements of different types in one move.
Tell him if he can sort the elements in non-decreasing values of a_i after performing any number of operations.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (1 ≤ n ≤ 500) — the size of the arrays.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^5) — the value of the i-th element.
The third line containts n integers b_i (b_i ∈ \{0, 1\}) — the type of the i-th element.
Output
For each test case, print "Yes" or "No" (without quotes) depending on whether it is possible to sort elements in non-decreasing order of their value.
You may print each letter in any case (upper or lower).
Example
Input
5
4
10 20 20 30
0 1 0 1
3
3 1 2
0 1 1
4
2 2 4 8
1 1 1 1
3
5 15 4
0 0 0
4
20 10 100 50
1 0 0 1
Output
Yes
Yes
Yes
No
Yes
Note
For the first case: The elements are already in sorted order.
For the second case: Ashish may first swap elements at positions 1 and 2, then swap elements at positions 2 and 3.
For the third case: The elements are already in sorted order.
For the fourth case: No swap operations may be performed as there is no pair of elements i and j such that b_i ≠ b_j. The elements cannot be sorted.
For the fifth case: Ashish may swap elements at positions 3 and 4, then elements at positions 1 and 2.
Tags: constructive algorithms, implementation
Correct Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
a = [int(i) for i in input().split(' ')]
b = [int(i) for i in input().split(' ')]
prev = a[0]
sorted = True
for cur in a:
if prev > cur:
sorted = False
prev = b[0]
one_type = True
for cur in b:
if prev != cur:
one_type = False
if sorted or not one_type:
print('Yes')
else:
print('No')
```
| 14,334 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish has n elements arranged in a line.
These elements are represented by two integers a_i — the value of the element and b_i — the type of the element (there are only two possible types: 0 and 1). He wants to sort the elements in non-decreasing values of a_i.
He can perform the following operation any number of times:
* Select any two elements i and j such that b_i ≠ b_j and swap them. That is, he can only swap two elements of different types in one move.
Tell him if he can sort the elements in non-decreasing values of a_i after performing any number of operations.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (1 ≤ n ≤ 500) — the size of the arrays.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^5) — the value of the i-th element.
The third line containts n integers b_i (b_i ∈ \{0, 1\}) — the type of the i-th element.
Output
For each test case, print "Yes" or "No" (without quotes) depending on whether it is possible to sort elements in non-decreasing order of their value.
You may print each letter in any case (upper or lower).
Example
Input
5
4
10 20 20 30
0 1 0 1
3
3 1 2
0 1 1
4
2 2 4 8
1 1 1 1
3
5 15 4
0 0 0
4
20 10 100 50
1 0 0 1
Output
Yes
Yes
Yes
No
Yes
Note
For the first case: The elements are already in sorted order.
For the second case: Ashish may first swap elements at positions 1 and 2, then swap elements at positions 2 and 3.
For the third case: The elements are already in sorted order.
For the fourth case: No swap operations may be performed as there is no pair of elements i and j such that b_i ≠ b_j. The elements cannot be sorted.
For the fifth case: Ashish may swap elements at positions 3 and 4, then elements at positions 1 and 2.
Tags: constructive algorithms, 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 == sorted(a):
print('Yes')
else:
ch0 = 0
ch1 = 0
for i in b:
if i == 0:
ch0 += 1
else:
ch1 += 1
if ch1 == 0 or ch0 == 0:
print('No')
else:
print('Yes')
```
| 14,335 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish has n elements arranged in a line.
These elements are represented by two integers a_i — the value of the element and b_i — the type of the element (there are only two possible types: 0 and 1). He wants to sort the elements in non-decreasing values of a_i.
He can perform the following operation any number of times:
* Select any two elements i and j such that b_i ≠ b_j and swap them. That is, he can only swap two elements of different types in one move.
Tell him if he can sort the elements in non-decreasing values of a_i after performing any number of operations.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (1 ≤ n ≤ 500) — the size of the arrays.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^5) — the value of the i-th element.
The third line containts n integers b_i (b_i ∈ \{0, 1\}) — the type of the i-th element.
Output
For each test case, print "Yes" or "No" (without quotes) depending on whether it is possible to sort elements in non-decreasing order of their value.
You may print each letter in any case (upper or lower).
Example
Input
5
4
10 20 20 30
0 1 0 1
3
3 1 2
0 1 1
4
2 2 4 8
1 1 1 1
3
5 15 4
0 0 0
4
20 10 100 50
1 0 0 1
Output
Yes
Yes
Yes
No
Yes
Note
For the first case: The elements are already in sorted order.
For the second case: Ashish may first swap elements at positions 1 and 2, then swap elements at positions 2 and 3.
For the third case: The elements are already in sorted order.
For the fourth case: No swap operations may be performed as there is no pair of elements i and j such that b_i ≠ b_j. The elements cannot be sorted.
For the fifth case: Ashish may swap elements at positions 3 and 4, then elements at positions 1 and 2.
Tags: constructive algorithms, implementation
Correct Solution:
```
t = int(input())
for i in range(t):
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
o = b.count(1)
z = b.count(0)
ans = "Yes"
for i in range(n-1):
if (o==0 or z==0) and a[i] > a[i+1]:
ans="No"
break
print(ans)
```
| 14,336 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish has n elements arranged in a line.
These elements are represented by two integers a_i — the value of the element and b_i — the type of the element (there are only two possible types: 0 and 1). He wants to sort the elements in non-decreasing values of a_i.
He can perform the following operation any number of times:
* Select any two elements i and j such that b_i ≠ b_j and swap them. That is, he can only swap two elements of different types in one move.
Tell him if he can sort the elements in non-decreasing values of a_i after performing any number of operations.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (1 ≤ n ≤ 500) — the size of the arrays.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^5) — the value of the i-th element.
The third line containts n integers b_i (b_i ∈ \{0, 1\}) — the type of the i-th element.
Output
For each test case, print "Yes" or "No" (without quotes) depending on whether it is possible to sort elements in non-decreasing order of their value.
You may print each letter in any case (upper or lower).
Example
Input
5
4
10 20 20 30
0 1 0 1
3
3 1 2
0 1 1
4
2 2 4 8
1 1 1 1
3
5 15 4
0 0 0
4
20 10 100 50
1 0 0 1
Output
Yes
Yes
Yes
No
Yes
Note
For the first case: The elements are already in sorted order.
For the second case: Ashish may first swap elements at positions 1 and 2, then swap elements at positions 2 and 3.
For the third case: The elements are already in sorted order.
For the fourth case: No swap operations may be performed as there is no pair of elements i and j such that b_i ≠ b_j. The elements cannot be sorted.
For the fifth case: Ashish may swap elements at positions 3 and 4, then elements at positions 1 and 2.
Submitted Solution:
```
t = int(input())
results = []
for case in range(t):
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = 'Yes'
if (1 in b and 0 not in b):
ans = 'No'
elif (0 in b and 1 not in b):
ans = 'No'
if (a == sorted(a)):
ans = 'Yes'
results.append(ans)
for result in results:
print (result)
```
Yes
| 14,337 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish has n elements arranged in a line.
These elements are represented by two integers a_i — the value of the element and b_i — the type of the element (there are only two possible types: 0 and 1). He wants to sort the elements in non-decreasing values of a_i.
He can perform the following operation any number of times:
* Select any two elements i and j such that b_i ≠ b_j and swap them. That is, he can only swap two elements of different types in one move.
Tell him if he can sort the elements in non-decreasing values of a_i after performing any number of operations.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (1 ≤ n ≤ 500) — the size of the arrays.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^5) — the value of the i-th element.
The third line containts n integers b_i (b_i ∈ \{0, 1\}) — the type of the i-th element.
Output
For each test case, print "Yes" or "No" (without quotes) depending on whether it is possible to sort elements in non-decreasing order of their value.
You may print each letter in any case (upper or lower).
Example
Input
5
4
10 20 20 30
0 1 0 1
3
3 1 2
0 1 1
4
2 2 4 8
1 1 1 1
3
5 15 4
0 0 0
4
20 10 100 50
1 0 0 1
Output
Yes
Yes
Yes
No
Yes
Note
For the first case: The elements are already in sorted order.
For the second case: Ashish may first swap elements at positions 1 and 2, then swap elements at positions 2 and 3.
For the third case: The elements are already in sorted order.
For the fourth case: No swap operations may be performed as there is no pair of elements i and j such that b_i ≠ b_j. The elements cannot be sorted.
For the fifth case: Ashish may swap elements at positions 3 and 4, then elements at positions 1 and 2.
Submitted Solution:
```
t = int(input())
for i in range(t):
n = int(input())
arr = list(map(int,input().split()))
brr = list(map(int,input().split()))
cnt0=0
for i in brr:
if(i==0):
cnt0+=1
if(arr== sorted(arr)):
print("Yes")
else:
if(cnt0==n or cnt0==0):
print("No")
else:
print("Yes")
```
Yes
| 14,338 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish has n elements arranged in a line.
These elements are represented by two integers a_i — the value of the element and b_i — the type of the element (there are only two possible types: 0 and 1). He wants to sort the elements in non-decreasing values of a_i.
He can perform the following operation any number of times:
* Select any two elements i and j such that b_i ≠ b_j and swap them. That is, he can only swap two elements of different types in one move.
Tell him if he can sort the elements in non-decreasing values of a_i after performing any number of operations.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (1 ≤ n ≤ 500) — the size of the arrays.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^5) — the value of the i-th element.
The third line containts n integers b_i (b_i ∈ \{0, 1\}) — the type of the i-th element.
Output
For each test case, print "Yes" or "No" (without quotes) depending on whether it is possible to sort elements in non-decreasing order of their value.
You may print each letter in any case (upper or lower).
Example
Input
5
4
10 20 20 30
0 1 0 1
3
3 1 2
0 1 1
4
2 2 4 8
1 1 1 1
3
5 15 4
0 0 0
4
20 10 100 50
1 0 0 1
Output
Yes
Yes
Yes
No
Yes
Note
For the first case: The elements are already in sorted order.
For the second case: Ashish may first swap elements at positions 1 and 2, then swap elements at positions 2 and 3.
For the third case: The elements are already in sorted order.
For the fourth case: No swap operations may be performed as there is no pair of elements i and j such that b_i ≠ b_j. The elements cannot be sorted.
For the fifth case: Ashish may swap elements at positions 3 and 4, then elements at positions 1 and 2.
Submitted Solution:
```
import sys
input = sys.stdin.readline
for _ in range(int(input())):
n = int(input())
A = list(map(int, input().split()))
T = list(map(int, input().split()))
ordered = True
last = 0
for i in range(n):
if A[i] < last:
ordered = False
last = A[i]
if ordered:
print('Yes')
continue
print('Yes' if len(set(T)) == 2 else 'No')
```
Yes
| 14,339 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish has n elements arranged in a line.
These elements are represented by two integers a_i — the value of the element and b_i — the type of the element (there are only two possible types: 0 and 1). He wants to sort the elements in non-decreasing values of a_i.
He can perform the following operation any number of times:
* Select any two elements i and j such that b_i ≠ b_j and swap them. That is, he can only swap two elements of different types in one move.
Tell him if he can sort the elements in non-decreasing values of a_i after performing any number of operations.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (1 ≤ n ≤ 500) — the size of the arrays.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^5) — the value of the i-th element.
The third line containts n integers b_i (b_i ∈ \{0, 1\}) — the type of the i-th element.
Output
For each test case, print "Yes" or "No" (without quotes) depending on whether it is possible to sort elements in non-decreasing order of their value.
You may print each letter in any case (upper or lower).
Example
Input
5
4
10 20 20 30
0 1 0 1
3
3 1 2
0 1 1
4
2 2 4 8
1 1 1 1
3
5 15 4
0 0 0
4
20 10 100 50
1 0 0 1
Output
Yes
Yes
Yes
No
Yes
Note
For the first case: The elements are already in sorted order.
For the second case: Ashish may first swap elements at positions 1 and 2, then swap elements at positions 2 and 3.
For the third case: The elements are already in sorted order.
For the fourth case: No swap operations may be performed as there is no pair of elements i and j such that b_i ≠ b_j. The elements cannot be sorted.
For the fifth case: Ashish may swap elements at positions 3 and 4, then elements at positions 1 and 2.
Submitted Solution:
```
import sys
input = lambda: sys.stdin.readline().strip("\r\n")
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
if (len(set(b)) == 1 and sorted(a) == a) or len(set(b)) == 2:
print("YES")
else:
print("NO")
```
Yes
| 14,340 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish has n elements arranged in a line.
These elements are represented by two integers a_i — the value of the element and b_i — the type of the element (there are only two possible types: 0 and 1). He wants to sort the elements in non-decreasing values of a_i.
He can perform the following operation any number of times:
* Select any two elements i and j such that b_i ≠ b_j and swap them. That is, he can only swap two elements of different types in one move.
Tell him if he can sort the elements in non-decreasing values of a_i after performing any number of operations.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (1 ≤ n ≤ 500) — the size of the arrays.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^5) — the value of the i-th element.
The third line containts n integers b_i (b_i ∈ \{0, 1\}) — the type of the i-th element.
Output
For each test case, print "Yes" or "No" (without quotes) depending on whether it is possible to sort elements in non-decreasing order of their value.
You may print each letter in any case (upper or lower).
Example
Input
5
4
10 20 20 30
0 1 0 1
3
3 1 2
0 1 1
4
2 2 4 8
1 1 1 1
3
5 15 4
0 0 0
4
20 10 100 50
1 0 0 1
Output
Yes
Yes
Yes
No
Yes
Note
For the first case: The elements are already in sorted order.
For the second case: Ashish may first swap elements at positions 1 and 2, then swap elements at positions 2 and 3.
For the third case: The elements are already in sorted order.
For the fourth case: No swap operations may be performed as there is no pair of elements i and j such that b_i ≠ b_j. The elements cannot be sorted.
For the fifth case: Ashish may swap elements at positions 3 and 4, then elements at positions 1 and 2.
Submitted Solution:
```
t=int(input())
while t:
t-=1
n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
li=[]
mi=[]
for i in a:
li.append(i)
li.sort()
if li==a:
print('YES')
else:
for i in range(len(li)):
if a.index(li[i])==i:
pass
else:
if b[i]!=b[a.index(li[i])]:
mi.append(a[a.index(li[i])])
print('YES')
break
else:
print('NO')
```
No
| 14,341 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish has n elements arranged in a line.
These elements are represented by two integers a_i — the value of the element and b_i — the type of the element (there are only two possible types: 0 and 1). He wants to sort the elements in non-decreasing values of a_i.
He can perform the following operation any number of times:
* Select any two elements i and j such that b_i ≠ b_j and swap them. That is, he can only swap two elements of different types in one move.
Tell him if he can sort the elements in non-decreasing values of a_i after performing any number of operations.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (1 ≤ n ≤ 500) — the size of the arrays.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^5) — the value of the i-th element.
The third line containts n integers b_i (b_i ∈ \{0, 1\}) — the type of the i-th element.
Output
For each test case, print "Yes" or "No" (without quotes) depending on whether it is possible to sort elements in non-decreasing order of their value.
You may print each letter in any case (upper or lower).
Example
Input
5
4
10 20 20 30
0 1 0 1
3
3 1 2
0 1 1
4
2 2 4 8
1 1 1 1
3
5 15 4
0 0 0
4
20 10 100 50
1 0 0 1
Output
Yes
Yes
Yes
No
Yes
Note
For the first case: The elements are already in sorted order.
For the second case: Ashish may first swap elements at positions 1 and 2, then swap elements at positions 2 and 3.
For the third case: The elements are already in sorted order.
For the fourth case: No swap operations may be performed as there is no pair of elements i and j such that b_i ≠ b_j. The elements cannot be sorted.
For the fifth case: Ashish may swap elements at positions 3 and 4, then elements at positions 1 and 2.
Submitted Solution:
```
t = int(input())
while(t > 0):
n = int(input())
a = [0]*510
b = [0]*510
x = 0
y = 0
a = list(map(int,input().split()))
b = list(map(int,input().split()))
for i in range(n):
if i != 0:
if a[i] < a[i-1]:
x = x + 1
for i in range(n):
if b[i] != b[0]:
y = y + 1
if y > 1 and x == 0:
print("yes")
else:
print("no")
t = t - 1
```
No
| 14,342 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish has n elements arranged in a line.
These elements are represented by two integers a_i — the value of the element and b_i — the type of the element (there are only two possible types: 0 and 1). He wants to sort the elements in non-decreasing values of a_i.
He can perform the following operation any number of times:
* Select any two elements i and j such that b_i ≠ b_j and swap them. That is, he can only swap two elements of different types in one move.
Tell him if he can sort the elements in non-decreasing values of a_i after performing any number of operations.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (1 ≤ n ≤ 500) — the size of the arrays.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^5) — the value of the i-th element.
The third line containts n integers b_i (b_i ∈ \{0, 1\}) — the type of the i-th element.
Output
For each test case, print "Yes" or "No" (without quotes) depending on whether it is possible to sort elements in non-decreasing order of their value.
You may print each letter in any case (upper or lower).
Example
Input
5
4
10 20 20 30
0 1 0 1
3
3 1 2
0 1 1
4
2 2 4 8
1 1 1 1
3
5 15 4
0 0 0
4
20 10 100 50
1 0 0 1
Output
Yes
Yes
Yes
No
Yes
Note
For the first case: The elements are already in sorted order.
For the second case: Ashish may first swap elements at positions 1 and 2, then swap elements at positions 2 and 3.
For the third case: The elements are already in sorted order.
For the fourth case: No swap operations may be performed as there is no pair of elements i and j such that b_i ≠ b_j. The elements cannot be sorted.
For the fifth case: Ashish may swap elements at positions 3 and 4, then elements at positions 1 and 2.
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
if b.count(1) > 0 and b.count(0) > 0:
print('YES')
else:
print('NO')
```
No
| 14,343 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish has n elements arranged in a line.
These elements are represented by two integers a_i — the value of the element and b_i — the type of the element (there are only two possible types: 0 and 1). He wants to sort the elements in non-decreasing values of a_i.
He can perform the following operation any number of times:
* Select any two elements i and j such that b_i ≠ b_j and swap them. That is, he can only swap two elements of different types in one move.
Tell him if he can sort the elements in non-decreasing values of a_i after performing any number of operations.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains one integer n (1 ≤ n ≤ 500) — the size of the arrays.
The second line contains n integers a_i (1 ≤ a_i ≤ 10^5) — the value of the i-th element.
The third line containts n integers b_i (b_i ∈ \{0, 1\}) — the type of the i-th element.
Output
For each test case, print "Yes" or "No" (without quotes) depending on whether it is possible to sort elements in non-decreasing order of their value.
You may print each letter in any case (upper or lower).
Example
Input
5
4
10 20 20 30
0 1 0 1
3
3 1 2
0 1 1
4
2 2 4 8
1 1 1 1
3
5 15 4
0 0 0
4
20 10 100 50
1 0 0 1
Output
Yes
Yes
Yes
No
Yes
Note
For the first case: The elements are already in sorted order.
For the second case: Ashish may first swap elements at positions 1 and 2, then swap elements at positions 2 and 3.
For the third case: The elements are already in sorted order.
For the fourth case: No swap operations may be performed as there is no pair of elements i and j such that b_i ≠ b_j. The elements cannot be sorted.
For the fifth case: Ashish may swap elements at positions 3 and 4, then elements at positions 1 and 2.
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
l1 = list(map(int,input().split()))
l2 = list(map(int,input().split()))
r1 = []
r0 = []
for i in range(n):
if l2[i] == 1:
r1.append(l1[i])
else:
r0.append(l1[i])
c = 1
for i in range(1,len(r1)):
if r1[i] < r1[i-1]:
print("No")
c = 0
break
if c == 0:
continue
for i in range(1,len(r0)):
if r0[i] < r0[i-1]:
print("No")
c = 0
break
if c == 0:
continue
print("Yes")
```
No
| 14,344 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation of length n is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] are permutations, and [1, 1], [0, 1], [2, 2, 1, 4] are not.
There was a permutation p[1 ... n]. It was merged with itself. In other words, let's take two instances of p and insert elements of the second p into the first maintaining relative order of elements. The result is a sequence of the length 2n.
For example, if p=[3, 1, 2] some possible results are: [3, 1, 2, 3, 1, 2], [3, 3, 1, 1, 2, 2], [3, 1, 3, 1, 2, 2]. The following sequences are not possible results of a merging: [1, 3, 2, 1, 2, 3], [3, 1, 2, 3, 2, 1], [3, 3, 1, 2, 2, 1].
For example, if p=[2, 1] the possible results are: [2, 2, 1, 1], [2, 1, 2, 1]. The following sequences are not possible results of a merging: [1, 1, 2, 2], [2, 1, 1, 2], [1, 2, 2, 1].
Your task is to restore the permutation p by the given resulting sequence a. It is guaranteed that the answer exists and is unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 400) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 50) — the length of permutation. The second line of the test case contains 2n integers a_1, a_2, ..., a_{2n} (1 ≤ a_i ≤ n), where a_i is the i-th element of a. It is guaranteed that the array a represents the result of merging of some permutation p with the same permutation p.
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n), representing the initial permutation. It is guaranteed that the answer exists and is unique.
Example
Input
5
2
1 1 2 2
4
1 3 1 4 3 4 2 2
5
1 2 1 2 3 4 3 5 4 5
3
1 2 3 1 2 3
4
2 3 2 4 1 3 4 1
Output
1 2
1 3 4 2
1 2 3 4 5
1 2 3
2 3 4 1
Tags: greedy
Correct Solution:
```
t = int(input())
while t:
n = int(input())
l = [int(x) for x in input().split()]
assert len(l) == 2*n
c = [0]*2*n
o = []
for i in range(2*n):
if c[i]==1:
o.append(str(l[i]))
continue
for j in range(i+1, 2*n):
if l[i]==l[j]:
c[j]=1
print(" ".join(o))
t-=1
```
| 14,345 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation of length n is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] are permutations, and [1, 1], [0, 1], [2, 2, 1, 4] are not.
There was a permutation p[1 ... n]. It was merged with itself. In other words, let's take two instances of p and insert elements of the second p into the first maintaining relative order of elements. The result is a sequence of the length 2n.
For example, if p=[3, 1, 2] some possible results are: [3, 1, 2, 3, 1, 2], [3, 3, 1, 1, 2, 2], [3, 1, 3, 1, 2, 2]. The following sequences are not possible results of a merging: [1, 3, 2, 1, 2, 3], [3, 1, 2, 3, 2, 1], [3, 3, 1, 2, 2, 1].
For example, if p=[2, 1] the possible results are: [2, 2, 1, 1], [2, 1, 2, 1]. The following sequences are not possible results of a merging: [1, 1, 2, 2], [2, 1, 1, 2], [1, 2, 2, 1].
Your task is to restore the permutation p by the given resulting sequence a. It is guaranteed that the answer exists and is unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 400) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 50) — the length of permutation. The second line of the test case contains 2n integers a_1, a_2, ..., a_{2n} (1 ≤ a_i ≤ n), where a_i is the i-th element of a. It is guaranteed that the array a represents the result of merging of some permutation p with the same permutation p.
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n), representing the initial permutation. It is guaranteed that the answer exists and is unique.
Example
Input
5
2
1 1 2 2
4
1 3 1 4 3 4 2 2
5
1 2 1 2 3 4 3 5 4 5
3
1 2 3 1 2 3
4
2 3 2 4 1 3 4 1
Output
1 2
1 3 4 2
1 2 3 4 5
1 2 3
2 3 4 1
Tags: greedy
Correct Solution:
```
import sys
def input():
return sys.stdin.readline().rstrip()
def input_split():
return [int(i) for i in input().split()]
testCases = int(input())
answers = []
for _ in range(testCases):
#take input
n = int(input())
arr = input_split()
found = [False for i in range(n+1)]
ans = []
for a in arr:
if not found[a]:
ans.append(a)
found[a] = True
answers.append(ans)
for ans in answers:
print(*ans, sep = ' ')
```
| 14,346 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation of length n is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] are permutations, and [1, 1], [0, 1], [2, 2, 1, 4] are not.
There was a permutation p[1 ... n]. It was merged with itself. In other words, let's take two instances of p and insert elements of the second p into the first maintaining relative order of elements. The result is a sequence of the length 2n.
For example, if p=[3, 1, 2] some possible results are: [3, 1, 2, 3, 1, 2], [3, 3, 1, 1, 2, 2], [3, 1, 3, 1, 2, 2]. The following sequences are not possible results of a merging: [1, 3, 2, 1, 2, 3], [3, 1, 2, 3, 2, 1], [3, 3, 1, 2, 2, 1].
For example, if p=[2, 1] the possible results are: [2, 2, 1, 1], [2, 1, 2, 1]. The following sequences are not possible results of a merging: [1, 1, 2, 2], [2, 1, 1, 2], [1, 2, 2, 1].
Your task is to restore the permutation p by the given resulting sequence a. It is guaranteed that the answer exists and is unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 400) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 50) — the length of permutation. The second line of the test case contains 2n integers a_1, a_2, ..., a_{2n} (1 ≤ a_i ≤ n), where a_i is the i-th element of a. It is guaranteed that the array a represents the result of merging of some permutation p with the same permutation p.
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n), representing the initial permutation. It is guaranteed that the answer exists and is unique.
Example
Input
5
2
1 1 2 2
4
1 3 1 4 3 4 2 2
5
1 2 1 2 3 4 3 5 4 5
3
1 2 3 1 2 3
4
2 3 2 4 1 3 4 1
Output
1 2
1 3 4 2
1 2 3 4 5
1 2 3
2 3 4 1
Tags: greedy
Correct Solution:
```
n=int(input())
for _ in range(n):
m=int(input())
ar=list(map(int,input().split()))
x=[]
for i in ar:
if i not in x:
x.append(i)
p=len(x)
for i in range(p):
print(x[i],end=' ')
```
| 14,347 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation of length n is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] are permutations, and [1, 1], [0, 1], [2, 2, 1, 4] are not.
There was a permutation p[1 ... n]. It was merged with itself. In other words, let's take two instances of p and insert elements of the second p into the first maintaining relative order of elements. The result is a sequence of the length 2n.
For example, if p=[3, 1, 2] some possible results are: [3, 1, 2, 3, 1, 2], [3, 3, 1, 1, 2, 2], [3, 1, 3, 1, 2, 2]. The following sequences are not possible results of a merging: [1, 3, 2, 1, 2, 3], [3, 1, 2, 3, 2, 1], [3, 3, 1, 2, 2, 1].
For example, if p=[2, 1] the possible results are: [2, 2, 1, 1], [2, 1, 2, 1]. The following sequences are not possible results of a merging: [1, 1, 2, 2], [2, 1, 1, 2], [1, 2, 2, 1].
Your task is to restore the permutation p by the given resulting sequence a. It is guaranteed that the answer exists and is unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 400) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 50) — the length of permutation. The second line of the test case contains 2n integers a_1, a_2, ..., a_{2n} (1 ≤ a_i ≤ n), where a_i is the i-th element of a. It is guaranteed that the array a represents the result of merging of some permutation p with the same permutation p.
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n), representing the initial permutation. It is guaranteed that the answer exists and is unique.
Example
Input
5
2
1 1 2 2
4
1 3 1 4 3 4 2 2
5
1 2 1 2 3 4 3 5 4 5
3
1 2 3 1 2 3
4
2 3 2 4 1 3 4 1
Output
1 2
1 3 4 2
1 2 3 4 5
1 2 3
2 3 4 1
Tags: greedy
Correct Solution:
```
t = int(input())
for i in range(t):
length = input()
inp = input()
inp_split = inp.split(" ")
numbers = [int(num) for num in inp_split]
check = []
for i in numbers:
if i not in check:
check.append(i)
final1 = [str(i) for i in check]
final = " ".join(final1)
print(final)
```
| 14,348 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation of length n is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] are permutations, and [1, 1], [0, 1], [2, 2, 1, 4] are not.
There was a permutation p[1 ... n]. It was merged with itself. In other words, let's take two instances of p and insert elements of the second p into the first maintaining relative order of elements. The result is a sequence of the length 2n.
For example, if p=[3, 1, 2] some possible results are: [3, 1, 2, 3, 1, 2], [3, 3, 1, 1, 2, 2], [3, 1, 3, 1, 2, 2]. The following sequences are not possible results of a merging: [1, 3, 2, 1, 2, 3], [3, 1, 2, 3, 2, 1], [3, 3, 1, 2, 2, 1].
For example, if p=[2, 1] the possible results are: [2, 2, 1, 1], [2, 1, 2, 1]. The following sequences are not possible results of a merging: [1, 1, 2, 2], [2, 1, 1, 2], [1, 2, 2, 1].
Your task is to restore the permutation p by the given resulting sequence a. It is guaranteed that the answer exists and is unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 400) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 50) — the length of permutation. The second line of the test case contains 2n integers a_1, a_2, ..., a_{2n} (1 ≤ a_i ≤ n), where a_i is the i-th element of a. It is guaranteed that the array a represents the result of merging of some permutation p with the same permutation p.
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n), representing the initial permutation. It is guaranteed that the answer exists and is unique.
Example
Input
5
2
1 1 2 2
4
1 3 1 4 3 4 2 2
5
1 2 1 2 3 4 3 5 4 5
3
1 2 3 1 2 3
4
2 3 2 4 1 3 4 1
Output
1 2
1 3 4 2
1 2 3 4 5
1 2 3
2 3 4 1
Tags: greedy
Correct Solution:
```
t = int(input())
for _ in range(t):
s = set()
n = int(input())
a = list(map(int,input().split()))
for i in a:
if i not in s:
s.add(i)
print(i,end = ' ')
print()
```
| 14,349 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation of length n is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] are permutations, and [1, 1], [0, 1], [2, 2, 1, 4] are not.
There was a permutation p[1 ... n]. It was merged with itself. In other words, let's take two instances of p and insert elements of the second p into the first maintaining relative order of elements. The result is a sequence of the length 2n.
For example, if p=[3, 1, 2] some possible results are: [3, 1, 2, 3, 1, 2], [3, 3, 1, 1, 2, 2], [3, 1, 3, 1, 2, 2]. The following sequences are not possible results of a merging: [1, 3, 2, 1, 2, 3], [3, 1, 2, 3, 2, 1], [3, 3, 1, 2, 2, 1].
For example, if p=[2, 1] the possible results are: [2, 2, 1, 1], [2, 1, 2, 1]. The following sequences are not possible results of a merging: [1, 1, 2, 2], [2, 1, 1, 2], [1, 2, 2, 1].
Your task is to restore the permutation p by the given resulting sequence a. It is guaranteed that the answer exists and is unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 400) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 50) — the length of permutation. The second line of the test case contains 2n integers a_1, a_2, ..., a_{2n} (1 ≤ a_i ≤ n), where a_i is the i-th element of a. It is guaranteed that the array a represents the result of merging of some permutation p with the same permutation p.
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n), representing the initial permutation. It is guaranteed that the answer exists and is unique.
Example
Input
5
2
1 1 2 2
4
1 3 1 4 3 4 2 2
5
1 2 1 2 3 4 3 5 4 5
3
1 2 3 1 2 3
4
2 3 2 4 1 3 4 1
Output
1 2
1 3 4 2
1 2 3 4 5
1 2 3
2 3 4 1
Tags: greedy
Correct Solution:
```
c=int(input())
for j in range(c):
n=int(input())
l=list(map(int,input().split()))
d=list(dict.fromkeys(l))
for i in d:
if i in l:
print(i,end=" ")
print()
```
| 14,350 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation of length n is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] are permutations, and [1, 1], [0, 1], [2, 2, 1, 4] are not.
There was a permutation p[1 ... n]. It was merged with itself. In other words, let's take two instances of p and insert elements of the second p into the first maintaining relative order of elements. The result is a sequence of the length 2n.
For example, if p=[3, 1, 2] some possible results are: [3, 1, 2, 3, 1, 2], [3, 3, 1, 1, 2, 2], [3, 1, 3, 1, 2, 2]. The following sequences are not possible results of a merging: [1, 3, 2, 1, 2, 3], [3, 1, 2, 3, 2, 1], [3, 3, 1, 2, 2, 1].
For example, if p=[2, 1] the possible results are: [2, 2, 1, 1], [2, 1, 2, 1]. The following sequences are not possible results of a merging: [1, 1, 2, 2], [2, 1, 1, 2], [1, 2, 2, 1].
Your task is to restore the permutation p by the given resulting sequence a. It is guaranteed that the answer exists and is unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 400) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 50) — the length of permutation. The second line of the test case contains 2n integers a_1, a_2, ..., a_{2n} (1 ≤ a_i ≤ n), where a_i is the i-th element of a. It is guaranteed that the array a represents the result of merging of some permutation p with the same permutation p.
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n), representing the initial permutation. It is guaranteed that the answer exists and is unique.
Example
Input
5
2
1 1 2 2
4
1 3 1 4 3 4 2 2
5
1 2 1 2 3 4 3 5 4 5
3
1 2 3 1 2 3
4
2 3 2 4 1 3 4 1
Output
1 2
1 3 4 2
1 2 3 4 5
1 2 3
2 3 4 1
Tags: greedy
Correct Solution:
```
t = int(input())
#the number of test cases
for k in range(t):
n = int(input())
#the length of permutation
a = list(map(int, input().split()))
p = []
#the oiginal permuaion
for i in range(n * 2):
if a[i] not in p:
p.append(a[i])
for i in range(n):
print(p[i], end=" ")
print()
```
| 14,351 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation of length n is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] are permutations, and [1, 1], [0, 1], [2, 2, 1, 4] are not.
There was a permutation p[1 ... n]. It was merged with itself. In other words, let's take two instances of p and insert elements of the second p into the first maintaining relative order of elements. The result is a sequence of the length 2n.
For example, if p=[3, 1, 2] some possible results are: [3, 1, 2, 3, 1, 2], [3, 3, 1, 1, 2, 2], [3, 1, 3, 1, 2, 2]. The following sequences are not possible results of a merging: [1, 3, 2, 1, 2, 3], [3, 1, 2, 3, 2, 1], [3, 3, 1, 2, 2, 1].
For example, if p=[2, 1] the possible results are: [2, 2, 1, 1], [2, 1, 2, 1]. The following sequences are not possible results of a merging: [1, 1, 2, 2], [2, 1, 1, 2], [1, 2, 2, 1].
Your task is to restore the permutation p by the given resulting sequence a. It is guaranteed that the answer exists and is unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 400) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 50) — the length of permutation. The second line of the test case contains 2n integers a_1, a_2, ..., a_{2n} (1 ≤ a_i ≤ n), where a_i is the i-th element of a. It is guaranteed that the array a represents the result of merging of some permutation p with the same permutation p.
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n), representing the initial permutation. It is guaranteed that the answer exists and is unique.
Example
Input
5
2
1 1 2 2
4
1 3 1 4 3 4 2 2
5
1 2 1 2 3 4 3 5 4 5
3
1 2 3 1 2 3
4
2 3 2 4 1 3 4 1
Output
1 2
1 3 4 2
1 2 3 4 5
1 2 3
2 3 4 1
Tags: greedy
Correct Solution:
```
for T in range(int(input())):
n=int(input())
arr=[int(i) for i in input().split()]
c=[0 for i in range(n+1)]
ans=[]
for i in arr:
if c[i]==0:
ans.append(str(i))
c[i]=1
print(' '.join(ans))
```
| 14,352 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation of length n is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] are permutations, and [1, 1], [0, 1], [2, 2, 1, 4] are not.
There was a permutation p[1 ... n]. It was merged with itself. In other words, let's take two instances of p and insert elements of the second p into the first maintaining relative order of elements. The result is a sequence of the length 2n.
For example, if p=[3, 1, 2] some possible results are: [3, 1, 2, 3, 1, 2], [3, 3, 1, 1, 2, 2], [3, 1, 3, 1, 2, 2]. The following sequences are not possible results of a merging: [1, 3, 2, 1, 2, 3], [3, 1, 2, 3, 2, 1], [3, 3, 1, 2, 2, 1].
For example, if p=[2, 1] the possible results are: [2, 2, 1, 1], [2, 1, 2, 1]. The following sequences are not possible results of a merging: [1, 1, 2, 2], [2, 1, 1, 2], [1, 2, 2, 1].
Your task is to restore the permutation p by the given resulting sequence a. It is guaranteed that the answer exists and is unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 400) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 50) — the length of permutation. The second line of the test case contains 2n integers a_1, a_2, ..., a_{2n} (1 ≤ a_i ≤ n), where a_i is the i-th element of a. It is guaranteed that the array a represents the result of merging of some permutation p with the same permutation p.
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n), representing the initial permutation. It is guaranteed that the answer exists and is unique.
Example
Input
5
2
1 1 2 2
4
1 3 1 4 3 4 2 2
5
1 2 1 2 3 4 3 5 4 5
3
1 2 3 1 2 3
4
2 3 2 4 1 3 4 1
Output
1 2
1 3 4 2
1 2 3 4 5
1 2 3
2 3 4 1
Submitted Solution:
```
count = int(input())
for i in range(count):
n = int(input())
test = [int(j) for j in input().split()]
answer = []
for j in test:
if j not in answer:
answer.append(j)
for j in answer:
print(j, end = " ")
print()
```
Yes
| 14,353 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation of length n is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] are permutations, and [1, 1], [0, 1], [2, 2, 1, 4] are not.
There was a permutation p[1 ... n]. It was merged with itself. In other words, let's take two instances of p and insert elements of the second p into the first maintaining relative order of elements. The result is a sequence of the length 2n.
For example, if p=[3, 1, 2] some possible results are: [3, 1, 2, 3, 1, 2], [3, 3, 1, 1, 2, 2], [3, 1, 3, 1, 2, 2]. The following sequences are not possible results of a merging: [1, 3, 2, 1, 2, 3], [3, 1, 2, 3, 2, 1], [3, 3, 1, 2, 2, 1].
For example, if p=[2, 1] the possible results are: [2, 2, 1, 1], [2, 1, 2, 1]. The following sequences are not possible results of a merging: [1, 1, 2, 2], [2, 1, 1, 2], [1, 2, 2, 1].
Your task is to restore the permutation p by the given resulting sequence a. It is guaranteed that the answer exists and is unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 400) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 50) — the length of permutation. The second line of the test case contains 2n integers a_1, a_2, ..., a_{2n} (1 ≤ a_i ≤ n), where a_i is the i-th element of a. It is guaranteed that the array a represents the result of merging of some permutation p with the same permutation p.
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n), representing the initial permutation. It is guaranteed that the answer exists and is unique.
Example
Input
5
2
1 1 2 2
4
1 3 1 4 3 4 2 2
5
1 2 1 2 3 4 3 5 4 5
3
1 2 3 1 2 3
4
2 3 2 4 1 3 4 1
Output
1 2
1 3 4 2
1 2 3 4 5
1 2 3
2 3 4 1
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
lst = list(map(int, input().split()))
myset = set()
sol = []
for item in lst:
if item not in myset:
myset.add(item)
sol.append(item)
for item in sol:
print(item, end=' ')
print()
```
Yes
| 14,354 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation of length n is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] are permutations, and [1, 1], [0, 1], [2, 2, 1, 4] are not.
There was a permutation p[1 ... n]. It was merged with itself. In other words, let's take two instances of p and insert elements of the second p into the first maintaining relative order of elements. The result is a sequence of the length 2n.
For example, if p=[3, 1, 2] some possible results are: [3, 1, 2, 3, 1, 2], [3, 3, 1, 1, 2, 2], [3, 1, 3, 1, 2, 2]. The following sequences are not possible results of a merging: [1, 3, 2, 1, 2, 3], [3, 1, 2, 3, 2, 1], [3, 3, 1, 2, 2, 1].
For example, if p=[2, 1] the possible results are: [2, 2, 1, 1], [2, 1, 2, 1]. The following sequences are not possible results of a merging: [1, 1, 2, 2], [2, 1, 1, 2], [1, 2, 2, 1].
Your task is to restore the permutation p by the given resulting sequence a. It is guaranteed that the answer exists and is unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 400) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 50) — the length of permutation. The second line of the test case contains 2n integers a_1, a_2, ..., a_{2n} (1 ≤ a_i ≤ n), where a_i is the i-th element of a. It is guaranteed that the array a represents the result of merging of some permutation p with the same permutation p.
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n), representing the initial permutation. It is guaranteed that the answer exists and is unique.
Example
Input
5
2
1 1 2 2
4
1 3 1 4 3 4 2 2
5
1 2 1 2 3 4 3 5 4 5
3
1 2 3 1 2 3
4
2 3 2 4 1 3 4 1
Output
1 2
1 3 4 2
1 2 3 4 5
1 2 3
2 3 4 1
Submitted Solution:
```
#!/usr/bin/env python3
import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
n = int(input())
a = [int(item) for item in input().split()]
visited = [0] * (n + 1)
ans = []
for item in a:
if visited[item] == 1:
ans.append(item)
else:
visited[item] += 1
print(*ans)
```
Yes
| 14,355 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation of length n is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] are permutations, and [1, 1], [0, 1], [2, 2, 1, 4] are not.
There was a permutation p[1 ... n]. It was merged with itself. In other words, let's take two instances of p and insert elements of the second p into the first maintaining relative order of elements. The result is a sequence of the length 2n.
For example, if p=[3, 1, 2] some possible results are: [3, 1, 2, 3, 1, 2], [3, 3, 1, 1, 2, 2], [3, 1, 3, 1, 2, 2]. The following sequences are not possible results of a merging: [1, 3, 2, 1, 2, 3], [3, 1, 2, 3, 2, 1], [3, 3, 1, 2, 2, 1].
For example, if p=[2, 1] the possible results are: [2, 2, 1, 1], [2, 1, 2, 1]. The following sequences are not possible results of a merging: [1, 1, 2, 2], [2, 1, 1, 2], [1, 2, 2, 1].
Your task is to restore the permutation p by the given resulting sequence a. It is guaranteed that the answer exists and is unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 400) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 50) — the length of permutation. The second line of the test case contains 2n integers a_1, a_2, ..., a_{2n} (1 ≤ a_i ≤ n), where a_i is the i-th element of a. It is guaranteed that the array a represents the result of merging of some permutation p with the same permutation p.
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n), representing the initial permutation. It is guaranteed that the answer exists and is unique.
Example
Input
5
2
1 1 2 2
4
1 3 1 4 3 4 2 2
5
1 2 1 2 3 4 3 5 4 5
3
1 2 3 1 2 3
4
2 3 2 4 1 3 4 1
Output
1 2
1 3 4 2
1 2 3 4 5
1 2 3
2 3 4 1
Submitted Solution:
```
def permut(n,a):
l=[]
for i in range(2*n):
if len(l)==n:
break
if a[i] not in l:
l.append(a[i])
for i in l:
print(i,end=" ")
t=int(input())
for i in range(t):
n=int(input())
a=[int(j) for j in input().split()]
permut(n,a)
print()
```
Yes
| 14,356 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation of length n is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] are permutations, and [1, 1], [0, 1], [2, 2, 1, 4] are not.
There was a permutation p[1 ... n]. It was merged with itself. In other words, let's take two instances of p and insert elements of the second p into the first maintaining relative order of elements. The result is a sequence of the length 2n.
For example, if p=[3, 1, 2] some possible results are: [3, 1, 2, 3, 1, 2], [3, 3, 1, 1, 2, 2], [3, 1, 3, 1, 2, 2]. The following sequences are not possible results of a merging: [1, 3, 2, 1, 2, 3], [3, 1, 2, 3, 2, 1], [3, 3, 1, 2, 2, 1].
For example, if p=[2, 1] the possible results are: [2, 2, 1, 1], [2, 1, 2, 1]. The following sequences are not possible results of a merging: [1, 1, 2, 2], [2, 1, 1, 2], [1, 2, 2, 1].
Your task is to restore the permutation p by the given resulting sequence a. It is guaranteed that the answer exists and is unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 400) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 50) — the length of permutation. The second line of the test case contains 2n integers a_1, a_2, ..., a_{2n} (1 ≤ a_i ≤ n), where a_i is the i-th element of a. It is guaranteed that the array a represents the result of merging of some permutation p with the same permutation p.
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n), representing the initial permutation. It is guaranteed that the answer exists and is unique.
Example
Input
5
2
1 1 2 2
4
1 3 1 4 3 4 2 2
5
1 2 1 2 3 4 3 5 4 5
3
1 2 3 1 2 3
4
2 3 2 4 1 3 4 1
Output
1 2
1 3 4 2
1 2 3 4 5
1 2 3
2 3 4 1
Submitted Solution:
```
t=int(input())
for o in range(t):
n=int(input())
a=list(map(int,input().split()))
b=[]
for i in range(n):
if a[i] not in b:
b.append(a[i])
print(*b)
```
No
| 14,357 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation of length n is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] are permutations, and [1, 1], [0, 1], [2, 2, 1, 4] are not.
There was a permutation p[1 ... n]. It was merged with itself. In other words, let's take two instances of p and insert elements of the second p into the first maintaining relative order of elements. The result is a sequence of the length 2n.
For example, if p=[3, 1, 2] some possible results are: [3, 1, 2, 3, 1, 2], [3, 3, 1, 1, 2, 2], [3, 1, 3, 1, 2, 2]. The following sequences are not possible results of a merging: [1, 3, 2, 1, 2, 3], [3, 1, 2, 3, 2, 1], [3, 3, 1, 2, 2, 1].
For example, if p=[2, 1] the possible results are: [2, 2, 1, 1], [2, 1, 2, 1]. The following sequences are not possible results of a merging: [1, 1, 2, 2], [2, 1, 1, 2], [1, 2, 2, 1].
Your task is to restore the permutation p by the given resulting sequence a. It is guaranteed that the answer exists and is unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 400) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 50) — the length of permutation. The second line of the test case contains 2n integers a_1, a_2, ..., a_{2n} (1 ≤ a_i ≤ n), where a_i is the i-th element of a. It is guaranteed that the array a represents the result of merging of some permutation p with the same permutation p.
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n), representing the initial permutation. It is guaranteed that the answer exists and is unique.
Example
Input
5
2
1 1 2 2
4
1 3 1 4 3 4 2 2
5
1 2 1 2 3 4 3 5 4 5
3
1 2 3 1 2 3
4
2 3 2 4 1 3 4 1
Output
1 2
1 3 4 2
1 2 3 4 5
1 2 3
2 3 4 1
Submitted Solution:
```
t=int(input())
print('**********')
while t>0:
t-=1
n=int(input())
arr=list(map(str,input().split()))
num=set()
ans=''
for i in arr:
if i not in num:
num.add(i)
ans+=i
print(ans)
```
No
| 14,358 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation of length n is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] are permutations, and [1, 1], [0, 1], [2, 2, 1, 4] are not.
There was a permutation p[1 ... n]. It was merged with itself. In other words, let's take two instances of p and insert elements of the second p into the first maintaining relative order of elements. The result is a sequence of the length 2n.
For example, if p=[3, 1, 2] some possible results are: [3, 1, 2, 3, 1, 2], [3, 3, 1, 1, 2, 2], [3, 1, 3, 1, 2, 2]. The following sequences are not possible results of a merging: [1, 3, 2, 1, 2, 3], [3, 1, 2, 3, 2, 1], [3, 3, 1, 2, 2, 1].
For example, if p=[2, 1] the possible results are: [2, 2, 1, 1], [2, 1, 2, 1]. The following sequences are not possible results of a merging: [1, 1, 2, 2], [2, 1, 1, 2], [1, 2, 2, 1].
Your task is to restore the permutation p by the given resulting sequence a. It is guaranteed that the answer exists and is unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 400) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 50) — the length of permutation. The second line of the test case contains 2n integers a_1, a_2, ..., a_{2n} (1 ≤ a_i ≤ n), where a_i is the i-th element of a. It is guaranteed that the array a represents the result of merging of some permutation p with the same permutation p.
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n), representing the initial permutation. It is guaranteed that the answer exists and is unique.
Example
Input
5
2
1 1 2 2
4
1 3 1 4 3 4 2 2
5
1 2 1 2 3 4 3 5 4 5
3
1 2 3 1 2 3
4
2 3 2 4 1 3 4 1
Output
1 2
1 3 4 2
1 2 3 4 5
1 2 3
2 3 4 1
Submitted Solution:
```
t=int(input())
for i in range(t):
n=int(input())
lst=list(map(int,input().strip().split()))[:n]
res=[]
for ele in lst:
if ele not in res:
res.append(ele)
print(*res)
```
No
| 14,359 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation of length n is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] are permutations, and [1, 1], [0, 1], [2, 2, 1, 4] are not.
There was a permutation p[1 ... n]. It was merged with itself. In other words, let's take two instances of p and insert elements of the second p into the first maintaining relative order of elements. The result is a sequence of the length 2n.
For example, if p=[3, 1, 2] some possible results are: [3, 1, 2, 3, 1, 2], [3, 3, 1, 1, 2, 2], [3, 1, 3, 1, 2, 2]. The following sequences are not possible results of a merging: [1, 3, 2, 1, 2, 3], [3, 1, 2, 3, 2, 1], [3, 3, 1, 2, 2, 1].
For example, if p=[2, 1] the possible results are: [2, 2, 1, 1], [2, 1, 2, 1]. The following sequences are not possible results of a merging: [1, 1, 2, 2], [2, 1, 1, 2], [1, 2, 2, 1].
Your task is to restore the permutation p by the given resulting sequence a. It is guaranteed that the answer exists and is unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 400) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 50) — the length of permutation. The second line of the test case contains 2n integers a_1, a_2, ..., a_{2n} (1 ≤ a_i ≤ n), where a_i is the i-th element of a. It is guaranteed that the array a represents the result of merging of some permutation p with the same permutation p.
Output
For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n), representing the initial permutation. It is guaranteed that the answer exists and is unique.
Example
Input
5
2
1 1 2 2
4
1 3 1 4 3 4 2 2
5
1 2 1 2 3 4 3 5 4 5
3
1 2 3 1 2 3
4
2 3 2 4 1 3 4 1
Output
1 2
1 3 4 2
1 2 3 4 5
1 2 3
2 3 4 1
Submitted Solution:
```
t = int(input())
li = []
for k in range(t):
n = int(input())
permutation = map(int, input().split())
for j in permutation:
if j not in li:
li.append(j)
for l in li:
print(l, end=' ')
```
No
| 14,360 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem.
There is an unknown integer x (1≤ x≤ n). You want to find x.
At first, you have a set of integers \{1, 2, …, n\}. You can perform the following operations no more than 10000 times:
* A a: find how many numbers are multiples of a in the current set.
* B a: find how many numbers are multiples of a in this set, and then delete all multiples of a, but x will never be deleted (even if it is a multiple of a). In this operation, a must be greater than 1.
* C a: it means that you know that x=a. This operation can be only performed once.
Remember that in the operation of type B a>1 must hold.
Write a program, that will find the value of x.
Input
The first line contains one integer n (1≤ n≤ 10^5). The remaining parts of the input will be given throughout the interaction process.
Interaction
In each round, your program needs to print a line containing one uppercase letter A, B or C and an integer a (1≤ a≤ n for operations A and C, 2≤ a≤ n for operation B). This line desribes operation you make.
If your operation has type C your program should terminate immediately.
Else your program should read one line containing a single integer, which is the answer to your operation.
After outputting each line, don't forget to flush the output. To do it use:
* fflush(stdout) in C/C++;
* System.out.flush() in Java;
* sys.stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
It is guaranteed, that the number x is fixed and won't change during the interaction process.
Hacks:
To make a hack, use such input format:
The only line should contain two integers n, x (1 ≤ x ≤ n ≤ 10^5).
Example
Input
10
2
4
0
Output
B 4
A 2
A 8
C 4
Note
Note that to make the sample more clear, we added extra empty lines. You shouldn't print any extra empty lines during the interaction process.
In the first test n=10 and x=4.
Initially the set is: \{1,2,3,4,5,6,7,8,9,10\}.
In the first operation, you ask how many numbers are multiples of 4 and delete them. The answer is 2 because there are two numbers divisible by 4: \{4,8\}. 8 will be deleted but 4 won't, because the number x will never be deleted. Now the set is \{1,2,3,4,5,6,7,9,10\}.
In the second operation, you ask how many numbers are multiples of 2. The answer is 4 because there are four numbers divisible by 2: \{2,4,6,10\}.
In the third operation, you ask how many numbers are multiples of 8. The answer is 0 because there isn't any number divisible by 8 in the current set.
In the fourth operation, you know that x=4, which is the right answer.
Submitted Solution:
```
import sys
n = int(input())
q = 0
if n > 5:
for i in range(2, n // 2):
print('B', i)
sys.stdout.flush()
ans1 = int(input())
print('A', i)
sys.stdout.flush()
ans2 = int(input())
if ans2 == 1:
p = i
q = 1
break
if q == 0:
print('C', 1)
else:
j = 2
myans = p
while p * j <= n:
print('A', p * j)
sys.stdout.flush()
ans = int(input())
if ans == 1:
myans = p * j
j += 1
print('C', myans)
else:
for i in range(2, n + 1):
print('B', i)
sys.stdout.flush()
ans1 = int(input())
print('A', i)
sys.stdout.flush()
ans2 = int(input())
if ans2 == 1:
p = i
q = 1
break
if q == 0:
print('C', 1)
else:
j = 2
myans = p
while p * j <= n:
print('A', p * j)
sys.stdout.flush()
ans = int(input())
if ans == 1:
myans = p * j
j += 1
print('C', myans)
```
No
| 14,361 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem.
There is an unknown integer x (1≤ x≤ n). You want to find x.
At first, you have a set of integers \{1, 2, …, n\}. You can perform the following operations no more than 10000 times:
* A a: find how many numbers are multiples of a in the current set.
* B a: find how many numbers are multiples of a in this set, and then delete all multiples of a, but x will never be deleted (even if it is a multiple of a). In this operation, a must be greater than 1.
* C a: it means that you know that x=a. This operation can be only performed once.
Remember that in the operation of type B a>1 must hold.
Write a program, that will find the value of x.
Input
The first line contains one integer n (1≤ n≤ 10^5). The remaining parts of the input will be given throughout the interaction process.
Interaction
In each round, your program needs to print a line containing one uppercase letter A, B or C and an integer a (1≤ a≤ n for operations A and C, 2≤ a≤ n for operation B). This line desribes operation you make.
If your operation has type C your program should terminate immediately.
Else your program should read one line containing a single integer, which is the answer to your operation.
After outputting each line, don't forget to flush the output. To do it use:
* fflush(stdout) in C/C++;
* System.out.flush() in Java;
* sys.stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
It is guaranteed, that the number x is fixed and won't change during the interaction process.
Hacks:
To make a hack, use such input format:
The only line should contain two integers n, x (1 ≤ x ≤ n ≤ 10^5).
Example
Input
10
2
4
0
Output
B 4
A 2
A 8
C 4
Note
Note that to make the sample more clear, we added extra empty lines. You shouldn't print any extra empty lines during the interaction process.
In the first test n=10 and x=4.
Initially the set is: \{1,2,3,4,5,6,7,8,9,10\}.
In the first operation, you ask how many numbers are multiples of 4 and delete them. The answer is 2 because there are two numbers divisible by 4: \{4,8\}. 8 will be deleted but 4 won't, because the number x will never be deleted. Now the set is \{1,2,3,4,5,6,7,9,10\}.
In the second operation, you ask how many numbers are multiples of 2. The answer is 4 because there are four numbers divisible by 2: \{2,4,6,10\}.
In the third operation, you ask how many numbers are multiples of 8. The answer is 0 because there isn't any number divisible by 8 in the current set.
In the fourth operation, you know that x=4, which is the right answer.
Submitted Solution:
```
import sys
N = int(input())
sieve = [-1] * (N + 1)
sieve[0] = sieve[1] = 0
for i in range(N + 1):
if sieve[i] != -1:
continue
else:
index = i * i
while True:
if index > N:
break
sieve[index] = i
index += i
Primes = []
for i in range(N + 1):
if sieve[i] == -1:
Primes.append(i)
CheckConst = 100
currentCheck = 0 # when I have to check
lastCheck = 0 # number of primes checked
isDeleted = [False] * N
deleteCount = 0
maxNumber = N
currentNumber = 1
onePrimeFactor = 0
for indexOut in range(len(Primes)):
elem = Primes[indexOut]
if maxNumber < elem:
break
print("B " + str(elem))
sys.stdout.flush()
curDeleteCount = 0
for i in range(elem - 1,N,elem):
if not isDeleted[i]:
isDeleted[i] = True
curDeleteCount += 1
cnt = int(input())
if cnt != curDeleteCount:
onePrimeFactor = elem
break
currentCheck += 1
deleteCount += curDeleteCount
if currentCheck > CheckConst or indexOut == len(Primes) - 1:
print("A 1")
sys.stdout.flush()
cntNonDeleted = int(input())
if cntNonDeleted + deleteCount != N:
onePrimeFactor = -1
break
lastCheck = indexOut + 1
if onePrimeFactor == 0:
print("C " + str(currentNumber))
else:
for index in range(lastCheck, len(Primes)):
prime = Primes[index]
if prime > maxNumber:
break
print("B " + str(prime))
elem = prime
sys.stdout.flush()
cnt = int(input())
curAliveCount = 0
for i in range(elem - 1,N,elem):
if not isDeleted[i]:
isDeleted[i] = True
curAliveCount += 1
if cnt != curAliveCount:
maxIndex = 1
for i in range(2,100):
if prime ** i > maxNumber:
break
print("A " + str(prime ** i))
sys.stdout.flush()
if(int(input()) != 0):
maxIndex += 1
else:
break
currentNumber *= prime ** maxIndex
maxNumber //= prime ** maxIndex
print("C " + str(currentNumber))
```
No
| 14,362 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem.
There is an unknown integer x (1≤ x≤ n). You want to find x.
At first, you have a set of integers \{1, 2, …, n\}. You can perform the following operations no more than 10000 times:
* A a: find how many numbers are multiples of a in the current set.
* B a: find how many numbers are multiples of a in this set, and then delete all multiples of a, but x will never be deleted (even if it is a multiple of a). In this operation, a must be greater than 1.
* C a: it means that you know that x=a. This operation can be only performed once.
Remember that in the operation of type B a>1 must hold.
Write a program, that will find the value of x.
Input
The first line contains one integer n (1≤ n≤ 10^5). The remaining parts of the input will be given throughout the interaction process.
Interaction
In each round, your program needs to print a line containing one uppercase letter A, B or C and an integer a (1≤ a≤ n for operations A and C, 2≤ a≤ n for operation B). This line desribes operation you make.
If your operation has type C your program should terminate immediately.
Else your program should read one line containing a single integer, which is the answer to your operation.
After outputting each line, don't forget to flush the output. To do it use:
* fflush(stdout) in C/C++;
* System.out.flush() in Java;
* sys.stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
It is guaranteed, that the number x is fixed and won't change during the interaction process.
Hacks:
To make a hack, use such input format:
The only line should contain two integers n, x (1 ≤ x ≤ n ≤ 10^5).
Example
Input
10
2
4
0
Output
B 4
A 2
A 8
C 4
Note
Note that to make the sample more clear, we added extra empty lines. You shouldn't print any extra empty lines during the interaction process.
In the first test n=10 and x=4.
Initially the set is: \{1,2,3,4,5,6,7,8,9,10\}.
In the first operation, you ask how many numbers are multiples of 4 and delete them. The answer is 2 because there are two numbers divisible by 4: \{4,8\}. 8 will be deleted but 4 won't, because the number x will never be deleted. Now the set is \{1,2,3,4,5,6,7,9,10\}.
In the second operation, you ask how many numbers are multiples of 2. The answer is 4 because there are four numbers divisible by 2: \{2,4,6,10\}.
In the third operation, you ask how many numbers are multiples of 8. The answer is 0 because there isn't any number divisible by 8 in the current set.
In the fourth operation, you know that x=4, which is the right answer.
Submitted Solution:
```
from math import sqrt
MAX_SIZE = 10**5+1
isprime = [True] * MAX_SIZE
p = []
SPF = [None] * (MAX_SIZE)
def manipulated_seive(N):
isprime[0] = isprime[1] = False
for i in range(2, N):
if isprime[i] == True:
p.append(i)
SPF[i] = i
j = 0
while (j < len(p) and
i * p[j] < N and
p[j] <= SPF[i]):
isprime[i * p[j]] = False
SPF[i * p[j]] = p[j]
j += 1
def ask(b,x):
print("{} {}".format(b,x))
n = int(input())
manipulated_seive(10**5+1)
num = 0
ind = 0
while(p[ind]<316):
if (p[ind] > n):
break
ask("B",p[ind])
k = int(input())
ind+=1
num+=1
x = 1
i = 0
ask("A",1)
last_k = int(input())
if(last_k==len(p)-num+1):
m = p.index(317)
i = 0
while(m+i<len(p) and p[m+i]<n):
ask("B",p[m+i])
k = int(input())
i+=1
if(i==100):
ask("A", 1)
k = int(input())
if (last_k != k):
for j in range(100):
ask("B", p[m + j])
k = int(input())
if (k == 1):
x = p[m + j]
ask("C", x)
exit(0)
last_k = k
m += 100
i = 0
ask("A", 1)
k = int(input())
if (last_k != k):
for j in range(i):
ask("B", p[m + j])
k = int(input())
if (k == 1):
x = p[m + j]
ask("C", x)
exit(0)
ask("C",1)
exit(0)
while(p[i]<317):
if(p[i]>n):
break
ask("A",p[i])
k = int(input())
if(k==0):
i+=1
continue
pow = 2
while(k!=0 and p[i]<316):
if(p[i]**pow>n):
pow -= 1
break
ask("A",p[i]**pow)
k = int(input())
if(k==0):
pow -=1
break
pow+=1
x *= p[i]**(pow)
i+=1
m = p.index(317)
i = 0
while(m+i<len(p) and p[m+i]<n):
ask("B",p[m+i])
k = int(input())
i+=1
if(i==100):
ask("A", 1)
k = int(input())
if (last_k != k):
for j in range(100):
ask("B", p[m + j])
k = int(input())
if (k == 1):
x *= p[m + j]
ask("C", x)
exit(0)
last_k = k
m += 100
i = 0
ask("A", 1)
k = int(input())
if (last_k != k):
for j in range(i):
ask("B", p[m + j])
k = int(input())
if (k == 1):
x *= p[m + j]
ask("C", x)
exit(0)
ask("C",x)
```
No
| 14,363 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem.
There is an unknown integer x (1≤ x≤ n). You want to find x.
At first, you have a set of integers \{1, 2, …, n\}. You can perform the following operations no more than 10000 times:
* A a: find how many numbers are multiples of a in the current set.
* B a: find how many numbers are multiples of a in this set, and then delete all multiples of a, but x will never be deleted (even if it is a multiple of a). In this operation, a must be greater than 1.
* C a: it means that you know that x=a. This operation can be only performed once.
Remember that in the operation of type B a>1 must hold.
Write a program, that will find the value of x.
Input
The first line contains one integer n (1≤ n≤ 10^5). The remaining parts of the input will be given throughout the interaction process.
Interaction
In each round, your program needs to print a line containing one uppercase letter A, B or C and an integer a (1≤ a≤ n for operations A and C, 2≤ a≤ n for operation B). This line desribes operation you make.
If your operation has type C your program should terminate immediately.
Else your program should read one line containing a single integer, which is the answer to your operation.
After outputting each line, don't forget to flush the output. To do it use:
* fflush(stdout) in C/C++;
* System.out.flush() in Java;
* sys.stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
It is guaranteed, that the number x is fixed and won't change during the interaction process.
Hacks:
To make a hack, use such input format:
The only line should contain two integers n, x (1 ≤ x ≤ n ≤ 10^5).
Example
Input
10
2
4
0
Output
B 4
A 2
A 8
C 4
Note
Note that to make the sample more clear, we added extra empty lines. You shouldn't print any extra empty lines during the interaction process.
In the first test n=10 and x=4.
Initially the set is: \{1,2,3,4,5,6,7,8,9,10\}.
In the first operation, you ask how many numbers are multiples of 4 and delete them. The answer is 2 because there are two numbers divisible by 4: \{4,8\}. 8 will be deleted but 4 won't, because the number x will never be deleted. Now the set is \{1,2,3,4,5,6,7,9,10\}.
In the second operation, you ask how many numbers are multiples of 2. The answer is 4 because there are four numbers divisible by 2: \{2,4,6,10\}.
In the third operation, you ask how many numbers are multiples of 8. The answer is 0 because there isn't any number divisible by 8 in the current set.
In the fourth operation, you know that x=4, which is the right answer.
Submitted Solution:
```
MAX_SIZE = 10**5+1
isprime = [True] * MAX_SIZE
p = []
SPF = [None] * (MAX_SIZE)
def manipulated_seive(N):
isprime[0] = isprime[1] = False
for i in range(2, N):
if isprime[i] == True:
p.append(i)
SPF[i] = i
j = 0
while (j < len(p) and
i * p[j] < N and
p[j] <= SPF[i]):
isprime[i * p[j]] = False
SPF[i * p[j]] = p[j]
j += 1
def ask(b,x):
print("{} {}".format(b,x))
n = int(input())
manipulated_seive(10**5+1)
num = 0
ind = 0
while(p[ind]<316):
if (p[ind] > n):
break
ask("B",p[ind])
k = int(input())
ind+=1
num+=1
x = 1
i = 0
ask("A",1)
last_k = int(input())
if(last_k==len(p)-num+1):
m = p.index(317)
i = 0
while(m+i<len(p) and p[m+i]<n):
ask("B",p[m+i])
k = int(input())
i+=1
if(i==100):
ask("A", 1)
k = int(input())
if (last_k-99 == k):
for j in range(100):
ask("A", p[m + j])
k = int(input())
if (k == 1):
x = p[m + j]
ask("C", x)
exit(0)
last_k = k
m += 100
i = 0
ask("A", 1)
k = int(input())
if (last_k-i+1== k):
for j in range(i):
ask("B", p[m + j])
k = int(input())
if (k == 1):
x = p[m + j]
ask("C", x)
exit(0)
ask("C",1)
exit(0)
while(p[i]<317):
if(p[i]>n):
break
ask("A",p[i])
k = int(input())
if(k==0):
i+=1
continue
pow = 2
while(k!=0 and p[i]<316):
if(p[i]**pow>n):
pow -= 1
break
ask("A",p[i]**pow)
k = int(input())
if(k==0):
pow -=1
break
pow+=1
x *= p[i]**(pow)
i+=1
m = p.index(317)
i = 0
if(x>315):
ask("C",x)
exit(0)
while(m+i<len(p) and p[m+i]<n):
ask("B",p[m+i])
k = int(input())
i+=1
if(i==100):
ask("A", 1)
k = int(input())
if (last_k-100 == k):
for j in range(100):
ask("A", p[m + j])
k = int(input())
if (k == 1):
x *= p[m + j]
ask("C", x)
exit(0)
last_k = k
m += 100
i = 0
ask("A",1)
k = int(input())
if(last_k-i==k):
for j in range(i):
ask("A", p[m + j])
k = int(input())
if (k == 1):
x *= p[m + j]
ask("C", x)
exit(0)
ask("C",x)
```
No
| 14,364 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When they are bored, Federico and Giada often play the following card game with a deck containing 6n cards.
Each card contains one number between 1 and 6n and each number appears on exactly one card. Initially the deck is sorted, so the first card contains the number 1, the second card contains the number 2, ..., and the last one contains the number 6n.
Federico and Giada take turns, alternating; Federico starts.
In his turn, the player takes 3 contiguous cards from the deck and puts them in his pocket. The order of the cards remaining in the deck is not changed. They play until the deck is empty (after exactly 2n turns). At the end of the game both Federico and Giada have 3n cards in their pockets.
You are given the cards in Federico's pocket at the end of the game. Describe a sequence of moves that produces that set of cards in Federico's pocket.
Input
The first line of the input contains one integer n (1≤ n ≤ 200).
The second line of the input contains 3n numbers x_1, x_2,…, x_{3n} (1 ≤ x_1 < x_2 <… < x_{3n} ≤ 6n) – the cards in Federico's pocket at the end of the game.
It is guaranteed that for each test there is at least one sequence of moves that produces such set of cards in Federico's pocket.
Output
Print 2n lines, each containing 3 integers.
The i-th line should contain, in increasing order, the integers a_i<b_i<c_i written on the three cards taken by the player during the i-th turn (so taken by Federico if i is odd and by Giada if i is even).
If there is more than one possible sequence of moves, you can print any.
Examples
Input
2
2 3 4 9 10 11
Output
9 10 11
6 7 8
2 3 4
1 5 12
Input
5
1 2 3 4 5 9 11 12 13 18 19 20 21 22 23
Output
19 20 21
24 25 26
11 12 13
27 28 29
1 2 3
14 15 16
18 22 23
6 7 8
4 5 9
10 17 30
Note
Explanation of the first testcase: Initially the deck has 12 = 2⋅ 6 sorted cards, so the deck is [1\ 2\ 3\ 4\ 5\ 6\ 7\ 8\ 9\ 10\ 11\ 12].
* During turn 1, Federico takes the three cards [9\ 10\ 11]. After his move, the deck is [1\ 2\ 3\ 4\ 5\ 6\ 7\ 8\ 12].
* During turn 2, Giada takes the three cards [6\ 7\ 8]. After her move, the deck is [1\ 2\ 3\ 4\ 5\ 12].
* During turn 3, Federico takes the three cards [2\ 3\ 4]. After his move, the deck is [1\ 5\ 12].
* During turn 4, Giada takes the three cards [1\ 5\ 12]. After her move, the deck is empty.
At the end of the game, the cards in Federico's pocket are [2\ 3\ 4\ 9\ 10\ 11] and the cards in Giada's pocket are [1\ 5\ 6\ 7\ 8\ 12].
Submitted Solution:
```
n = int(input())
x = list(map(int, input().strip().split()))
y = [i for i in range(1, 6*n+1) if i not in x]
deck = dict()
rdeck = dict()
rdeck[1] = 0
for i in range(1, 6*n+1):
deck[i] = i+1
rdeck[i+1] = i
def dist(a, b):
d = 0
c = deck[a]
while c != b:
d += 1
c = deck[c]
return d
x_dists = [dist(a, b) for a, b in zip(x, x[1:])]
y_dists = [dist(a, b) for a, b in zip(y, y[1:])]
def remove(x, x_dists, y, y_dists, moves, i):
a, b, c = x[i], x[i+1], x[i+2]
moves.append((a, b, c))
xn = x[:i] + x[i+3:]
xn_dists = x_dists[:i] + x_dists[i+3:]
u = rdeck[a]
v = deck[c]
rdeck[v] = u
deck[u] = v
if solve(y, y_dists, xn, xn_dists, moves):
return True
deck[u] = a
rdeck[v] = c
return False
def solve(x, x_dists, y, y_dists, moves):
if len(x) == 0:
for (a, b, c) in moves:
print(a, b, c)
return True
scores = dict()
for i, d in enumerate(y_dists[:-1]):
d2 = y_dists[i+1]
if d == 0 and d2 == 0:
continue
if d % 3 != 0 or d2 % 3 != 0:
continue
a = y[i]
b = y[i+1]
u = deck[a]
v = deck[b]
if d != 0:
scores[u] = min(d+d2, scores.get(u, 3*n))
if d2 != 0:
scores[v] = min(d+d2, scores.get(v, 3*n))
if len(scores) > 0:
su = sorted(scores.keys(), key=scores.get)
for min_x in su:
for i, u in enumerate(x):
if u == min_x:
break
if i+1 == len(x_dists):
continue
if x_dists[i] != 0 or x_dists[i+1] != 0:
continue
U = rdeck[min_x]
for j, u in enumerate(y):
if u == U:
break
y_dists[j] -= 3
if remove(x, x_dists, y, y_dists, moves, i):
return True
y_dists[j] += 3
for i, d in enumerate(x_dists[:-1]):
d2 = x_dists[i+1]
if d == 0 and d2 == 0:
if remove(x, x_dists, y, y_dists, moves, i):
return True
return False
solve(x, x_dists, y, y_dists, [])
```
No
| 14,365 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When they are bored, Federico and Giada often play the following card game with a deck containing 6n cards.
Each card contains one number between 1 and 6n and each number appears on exactly one card. Initially the deck is sorted, so the first card contains the number 1, the second card contains the number 2, ..., and the last one contains the number 6n.
Federico and Giada take turns, alternating; Federico starts.
In his turn, the player takes 3 contiguous cards from the deck and puts them in his pocket. The order of the cards remaining in the deck is not changed. They play until the deck is empty (after exactly 2n turns). At the end of the game both Federico and Giada have 3n cards in their pockets.
You are given the cards in Federico's pocket at the end of the game. Describe a sequence of moves that produces that set of cards in Federico's pocket.
Input
The first line of the input contains one integer n (1≤ n ≤ 200).
The second line of the input contains 3n numbers x_1, x_2,…, x_{3n} (1 ≤ x_1 < x_2 <… < x_{3n} ≤ 6n) – the cards in Federico's pocket at the end of the game.
It is guaranteed that for each test there is at least one sequence of moves that produces such set of cards in Federico's pocket.
Output
Print 2n lines, each containing 3 integers.
The i-th line should contain, in increasing order, the integers a_i<b_i<c_i written on the three cards taken by the player during the i-th turn (so taken by Federico if i is odd and by Giada if i is even).
If there is more than one possible sequence of moves, you can print any.
Examples
Input
2
2 3 4 9 10 11
Output
9 10 11
6 7 8
2 3 4
1 5 12
Input
5
1 2 3 4 5 9 11 12 13 18 19 20 21 22 23
Output
19 20 21
24 25 26
11 12 13
27 28 29
1 2 3
14 15 16
18 22 23
6 7 8
4 5 9
10 17 30
Note
Explanation of the first testcase: Initially the deck has 12 = 2⋅ 6 sorted cards, so the deck is [1\ 2\ 3\ 4\ 5\ 6\ 7\ 8\ 9\ 10\ 11\ 12].
* During turn 1, Federico takes the three cards [9\ 10\ 11]. After his move, the deck is [1\ 2\ 3\ 4\ 5\ 6\ 7\ 8\ 12].
* During turn 2, Giada takes the three cards [6\ 7\ 8]. After her move, the deck is [1\ 2\ 3\ 4\ 5\ 12].
* During turn 3, Federico takes the three cards [2\ 3\ 4]. After his move, the deck is [1\ 5\ 12].
* During turn 4, Giada takes the three cards [1\ 5\ 12]. After her move, the deck is empty.
At the end of the game, the cards in Federico's pocket are [2\ 3\ 4\ 9\ 10\ 11] and the cards in Giada's pocket are [1\ 5\ 6\ 7\ 8\ 12].
Submitted Solution:
```
from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import heappush,heappop,heapify
import math
from collections import *
from functools import reduce,cmp_to_key
import sys
input = sys.stdin.readline
from itertools import accumulate, permutations
from functools import lru_cache
M = mod = 998244353
def factors(n):return sorted(set(reduce(list.__add__, ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0))))
def inv_mod(n):return pow(n, mod - 2, mod)
def li():return [int(i) for i in input().rstrip('\n').split()]
def st():return input().rstrip('\n')
def val():return int(input().rstrip('\n'))
def li2():return [i for i in input().rstrip('\n')]
def li3():return [int(i) for i in input().rstrip('\n')]
n = val()
l = set(li())
turn = 1
currset = list(range(1, 6 * n + 1))
def printit(a, b, c):
print(currset[a], currset[b], currset[c])
for _ in range(2 * n):
# print(currset)
if _ == 2 * n - 1:
print(*currset)
break
if turn:
for i in range(2, len(currset)):
if currset[i - 2] in l and currset[i - 1] in l and currset[i] in l:
printit(i - 2, i - 1, i)
currset = currset[:i - 2] + currset[i + 1:]
break
else:
done = 0
for i in range(2, len(currset)):
if currset[i - 2] in l or currset[i - 1] in l or currset[i] in l:continue
if i > 3 and i < len(currset) - 1 and currset[i - 4] in l and currset[i - 3] in l and currset[i + 1] in l:
printit(i - 2, i - 1, i)
currset = currset[:i - 2] + currset[i + 1:]
done = 1
break
elif i > 2 and i < len(currset) - 2 and currset[i - 3] in l and currset[i + 1] in l and currset[i + 2] in l:
printit(i - 2, i - 1, i)
currset = currset[:i - 2] + currset[i + 1:]
done = 1
break
if not done:
for i in range(2, len(currset)):
if currset[i - 2] in l or currset[i - 1] in l or currset[i] in l:continue
if i > 4 and currset[i - 5] in l and currset[i - 4] in l and currset[i - 3] in l:
printit(i - 2, i - 1, i)
currset = currset[:i - 2] + currset[i + 1:]
break
elif i < len(currset) - 3 and currset[i + 1] in l and currset[i + 2] in l and currset[i + 3] in l:
printit(i - 2, i - 1, i)
currset = currset[:i - 2] + currset[i + 1:]
break
turn = 1 - turn
```
No
| 14,366 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When they are bored, Federico and Giada often play the following card game with a deck containing 6n cards.
Each card contains one number between 1 and 6n and each number appears on exactly one card. Initially the deck is sorted, so the first card contains the number 1, the second card contains the number 2, ..., and the last one contains the number 6n.
Federico and Giada take turns, alternating; Federico starts.
In his turn, the player takes 3 contiguous cards from the deck and puts them in his pocket. The order of the cards remaining in the deck is not changed. They play until the deck is empty (after exactly 2n turns). At the end of the game both Federico and Giada have 3n cards in their pockets.
You are given the cards in Federico's pocket at the end of the game. Describe a sequence of moves that produces that set of cards in Federico's pocket.
Input
The first line of the input contains one integer n (1≤ n ≤ 200).
The second line of the input contains 3n numbers x_1, x_2,…, x_{3n} (1 ≤ x_1 < x_2 <… < x_{3n} ≤ 6n) – the cards in Federico's pocket at the end of the game.
It is guaranteed that for each test there is at least one sequence of moves that produces such set of cards in Federico's pocket.
Output
Print 2n lines, each containing 3 integers.
The i-th line should contain, in increasing order, the integers a_i<b_i<c_i written on the three cards taken by the player during the i-th turn (so taken by Federico if i is odd and by Giada if i is even).
If there is more than one possible sequence of moves, you can print any.
Examples
Input
2
2 3 4 9 10 11
Output
9 10 11
6 7 8
2 3 4
1 5 12
Input
5
1 2 3 4 5 9 11 12 13 18 19 20 21 22 23
Output
19 20 21
24 25 26
11 12 13
27 28 29
1 2 3
14 15 16
18 22 23
6 7 8
4 5 9
10 17 30
Note
Explanation of the first testcase: Initially the deck has 12 = 2⋅ 6 sorted cards, so the deck is [1\ 2\ 3\ 4\ 5\ 6\ 7\ 8\ 9\ 10\ 11\ 12].
* During turn 1, Federico takes the three cards [9\ 10\ 11]. After his move, the deck is [1\ 2\ 3\ 4\ 5\ 6\ 7\ 8\ 12].
* During turn 2, Giada takes the three cards [6\ 7\ 8]. After her move, the deck is [1\ 2\ 3\ 4\ 5\ 12].
* During turn 3, Federico takes the three cards [2\ 3\ 4]. After his move, the deck is [1\ 5\ 12].
* During turn 4, Giada takes the three cards [1\ 5\ 12]. After her move, the deck is empty.
At the end of the game, the cards in Federico's pocket are [2\ 3\ 4\ 9\ 10\ 11] and the cards in Giada's pocket are [1\ 5\ 6\ 7\ 8\ 12].
Submitted Solution:
```
n = int(input())
x = list(map(int, input().strip().split()))
y = [i for i in range(1, 6*n+1) if i not in x]
deck = dict()
rdeck = dict()
rdeck[1] = 0
for i in range(1, 6*n+1):
deck[i] = i+1
rdeck[i+1] = i
def dist(a, b):
d = 0
c = deck[a]
while c != b:
d += 1
c = deck[c]
return d
x_dists = [dist(a, b) for a, b in zip(x, x[1:])]
y_dists = [dist(a, b) for a, b in zip(y, y[1:])]
def remove(x, x_dists, y, y_dists, moves, i):
a, b, c = x[i], x[i+1], x[i+2]
moves.append((a, b, c))
x = x[:i] + x[i+3:]
x_dists = x_dists[:i] + x_dists[i+3:]
u = rdeck[a]
v = deck[c]
rdeck[v] = u
deck[u] = v
solve(y, y_dists, x, x_dists, moves)
def solve(x, x_dists, y, y_dists, moves):
if len(x) == 0:
for (a, b, c) in moves:
print(a, b, c)
return
scores = dict()
for i, d in enumerate(y_dists[:-2]):
d2 = y_dists[i+1]
if d == 0 and d2 == 0:
continue
a = y[i]
b = y[i+1]
u = deck[a]
v = deck[b]
if d != 0:
scores[u] = min(d+d2, scores.get(u, 3*n))
if d2 != 0:
scores[v] = min(d+d2, scores.get(v, 3*n))
if len(scores) > 0:
su = sorted(scores.keys(), key=scores.get)
for min_x in su:
for i, u in enumerate(x):
if u == min_x:
break
if i+1 == len(x_dists):
continue
if x_dists[i] != 0 or x_dists[i+1] != 0:
continue
U = rdeck[min_x]
for j, u in enumerate(y):
if u == U:
break
y_dists[j] -= 3
remove(x, x_dists, y, y_dists, moves, i)
return
for i, d in enumerate(x_dists[:-1]):
d2 = x_dists[i+1]
if d == 0 and d2 == 0:
remove(x, x_dists, y, y_dists, moves, i)
return
solve(x, x_dists, y, y_dists, [])
```
No
| 14,367 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When they are bored, Federico and Giada often play the following card game with a deck containing 6n cards.
Each card contains one number between 1 and 6n and each number appears on exactly one card. Initially the deck is sorted, so the first card contains the number 1, the second card contains the number 2, ..., and the last one contains the number 6n.
Federico and Giada take turns, alternating; Federico starts.
In his turn, the player takes 3 contiguous cards from the deck and puts them in his pocket. The order of the cards remaining in the deck is not changed. They play until the deck is empty (after exactly 2n turns). At the end of the game both Federico and Giada have 3n cards in their pockets.
You are given the cards in Federico's pocket at the end of the game. Describe a sequence of moves that produces that set of cards in Federico's pocket.
Input
The first line of the input contains one integer n (1≤ n ≤ 200).
The second line of the input contains 3n numbers x_1, x_2,…, x_{3n} (1 ≤ x_1 < x_2 <… < x_{3n} ≤ 6n) – the cards in Federico's pocket at the end of the game.
It is guaranteed that for each test there is at least one sequence of moves that produces such set of cards in Federico's pocket.
Output
Print 2n lines, each containing 3 integers.
The i-th line should contain, in increasing order, the integers a_i<b_i<c_i written on the three cards taken by the player during the i-th turn (so taken by Federico if i is odd and by Giada if i is even).
If there is more than one possible sequence of moves, you can print any.
Examples
Input
2
2 3 4 9 10 11
Output
9 10 11
6 7 8
2 3 4
1 5 12
Input
5
1 2 3 4 5 9 11 12 13 18 19 20 21 22 23
Output
19 20 21
24 25 26
11 12 13
27 28 29
1 2 3
14 15 16
18 22 23
6 7 8
4 5 9
10 17 30
Note
Explanation of the first testcase: Initially the deck has 12 = 2⋅ 6 sorted cards, so the deck is [1\ 2\ 3\ 4\ 5\ 6\ 7\ 8\ 9\ 10\ 11\ 12].
* During turn 1, Federico takes the three cards [9\ 10\ 11]. After his move, the deck is [1\ 2\ 3\ 4\ 5\ 6\ 7\ 8\ 12].
* During turn 2, Giada takes the three cards [6\ 7\ 8]. After her move, the deck is [1\ 2\ 3\ 4\ 5\ 12].
* During turn 3, Federico takes the three cards [2\ 3\ 4]. After his move, the deck is [1\ 5\ 12].
* During turn 4, Giada takes the three cards [1\ 5\ 12]. After her move, the deck is empty.
At the end of the game, the cards in Federico's pocket are [2\ 3\ 4\ 9\ 10\ 11] and the cards in Giada's pocket are [1\ 5\ 6\ 7\ 8\ 12].
Submitted Solution:
```
from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import heappush,heappop,heapify
import math
from collections import *
from functools import reduce,cmp_to_key
import sys
input = sys.stdin.readline
from itertools import accumulate, permutations
from functools import lru_cache
M = mod = 998244353
def factors(n):return sorted(set(reduce(list.__add__, ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0))))
def inv_mod(n):return pow(n, mod - 2, mod)
def li():return [int(i) for i in input().rstrip('\n').split()]
def st():return input().rstrip('\n')
def val():return int(input().rstrip('\n'))
def li2():return [i for i in input().rstrip('\n')]
def li3():return [int(i) for i in input().rstrip('\n')]
n = val()
l = set(li())
turn = 1
currset = list(range(1, 6 * n + 1))
def printit(a, b, c):
print(currset[a], currset[b], currset[c])
for _ in range(2 * n):
# print(currset)
if _ == 2 * n - 1:
print(*currset)
break
if turn:
for i in range(2, len(currset)):
if currset[i - 2] in l and currset[i - 1] in l and currset[i] in l:
printit(i - 2, i - 1, i)
currset = currset[:i - 2] + currset[i + 1:]
break
else:
for i in range(2, len(currset)):
if currset[i - 2] in l or currset[i - 1] in l or currset[i] in l:continue
if i > 4 and currset[i - 5] in l and currset[i - 4] in l and currset[i - 3] in l:
printit(i - 2, i - 1, i)
currset = currset[:i - 2] + currset[i + 1:]
break
elif i > 3 and i < len(currset) - 1 and currset[i - 4] in l and currset[i - 3] in l and currset[i + 1] in l:
printit(i - 2, i - 1, i)
currset = currset[:i - 2] + currset[i + 1:]
break
elif i > 2 and i < len(currset) - 2 and currset[i - 3] in l and currset[i + 1] in l and currset[i + 2] in l:
printit(i - 2, i - 1, i)
currset = currset[:i - 2] + currset[i + 1:]
break
elif i < len(currset) - 3 and currset[i + 1] in l and currset[i + 2] in l and currset[i + 3] in l:
printit(i - 2, i - 1, i)
currset = currset[:i - 2] + currset[i + 1:]
break
turn = 1 - turn
```
No
| 14,368 |
Provide tags and a correct Python 3 solution for this coding contest problem.
To help those contestants who struggle a lot in contests, the headquarters of Codeforces are planning to introduce Division 5. In this new division, the tags of all problems will be announced prior to the round to help the contestants.
The contest consists of n problems, where the tag of the i-th problem is denoted by an integer a_i.
You want to AK (solve all problems). To do that, you must solve the problems in some order. To make the contest funnier, you created extra limitations on yourself. You do not want to solve two problems consecutively with the same tag since it is boring. Also, you are afraid of big jumps in difficulties while solving them, so you want to minimize the number of times that you solve two problems consecutively that are not adjacent in the contest order.
Formally, your solve order can be described by a permutation p of length n. The cost of a permutation is defined as the number of indices i (1≤ i<n) where |p_{i+1}-p_i|>1. You have the requirement that a_{p_i}≠ a_{p_{i+1}} for all 1≤ i< n.
You want to know the minimum possible cost of permutation that satisfies the requirement. If no permutations meet this requirement, you should report about it.
Input
The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases.
The first line of the description of each test case contains a single integer n (1 ≤ n ≤ 10^5) — the number of problems in the contest.
The next line contains n integers a_1,a_2,… a_n (1 ≤ a_i ≤ n) — the tags of the problems.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, if there are no permutations that satisfy the required condition, print -1. Otherwise, print the minimum possible cost of a permutation that satisfies the required condition.
Example
Input
4
6
2 1 2 3 1 1
5
1 1 1 2 2
8
7 7 2 7 7 1 8 7
10
1 2 3 4 1 1 2 3 4 1
Output
1
3
-1
2
Note
In the first test case, let p=[5, 4, 3, 2, 1, 6]. The cost is 1 because we jump from p_5=1 to p_6=6, and |6-1|>1. This permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 1.
In the second test case, let p=[1,5,2,4,3]. The cost is 3 because |p_2-p_1|>1, |p_3-p_2|>1, and |p_4-p_3|>1. The permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 3.
In the third test case, for any order of solving the problems, we will solve two problems with the same tag consecutively, so the answer is -1.
Tags: constructive algorithms, greedy
Correct Solution:
```
import sys
input = sys.stdin.readline
def main():
n = int(input())
alst = list(map(int, input().split()))
cnt = [0 for _ in range(n + 1)]
for a in alst:
cnt[a] += 1
if max(cnt) > (n + 1) / 2:
print(-1)
return
ans = 0
end = [0 for _ in range(n + 1)]
for i in range(n - 1):
if alst[i] == alst[i + 1]:
end[alst[i]] += 1
end[alst[i + 1]] += 1
ans += 1
end[alst[0]] += 1
end[alst[-1]] += 1
print(ans + max(0, max(end) - ans - 2))
for _ in range(int(input())):
main()
```
| 14,369 |
Provide tags and a correct Python 3 solution for this coding contest problem.
To help those contestants who struggle a lot in contests, the headquarters of Codeforces are planning to introduce Division 5. In this new division, the tags of all problems will be announced prior to the round to help the contestants.
The contest consists of n problems, where the tag of the i-th problem is denoted by an integer a_i.
You want to AK (solve all problems). To do that, you must solve the problems in some order. To make the contest funnier, you created extra limitations on yourself. You do not want to solve two problems consecutively with the same tag since it is boring. Also, you are afraid of big jumps in difficulties while solving them, so you want to minimize the number of times that you solve two problems consecutively that are not adjacent in the contest order.
Formally, your solve order can be described by a permutation p of length n. The cost of a permutation is defined as the number of indices i (1≤ i<n) where |p_{i+1}-p_i|>1. You have the requirement that a_{p_i}≠ a_{p_{i+1}} for all 1≤ i< n.
You want to know the minimum possible cost of permutation that satisfies the requirement. If no permutations meet this requirement, you should report about it.
Input
The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases.
The first line of the description of each test case contains a single integer n (1 ≤ n ≤ 10^5) — the number of problems in the contest.
The next line contains n integers a_1,a_2,… a_n (1 ≤ a_i ≤ n) — the tags of the problems.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, if there are no permutations that satisfy the required condition, print -1. Otherwise, print the minimum possible cost of a permutation that satisfies the required condition.
Example
Input
4
6
2 1 2 3 1 1
5
1 1 1 2 2
8
7 7 2 7 7 1 8 7
10
1 2 3 4 1 1 2 3 4 1
Output
1
3
-1
2
Note
In the first test case, let p=[5, 4, 3, 2, 1, 6]. The cost is 1 because we jump from p_5=1 to p_6=6, and |6-1|>1. This permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 1.
In the second test case, let p=[1,5,2,4,3]. The cost is 3 because |p_2-p_1|>1, |p_3-p_2|>1, and |p_4-p_3|>1. The permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 3.
In the third test case, for any order of solving the problems, we will solve two problems with the same tag consecutively, so the answer is -1.
Tags: constructive algorithms, greedy
Correct Solution:
```
def calc(A):
N = len(A)
if N == 1:return 0
X = [0] * N
for a in A:X[a] += 1
if max(X) > (N + 1) // 2:return -1
Y = [0] * N;Y[A[0]] += 1;Y[A[-1]] += 1
for a, b in zip(A, A[1:]):
if a == b:Y[a] += 2
su, ma = sum(Y), max(Y);cc = su - ma
return su // 2 - 1 + max(ma - cc - 2, 0) // 2
for _ in range(int(input())):N = int(input());print(calc([int(a) - 1 for a in input().split()]))
```
| 14,370 |
Provide tags and a correct Python 3 solution for this coding contest problem.
To help those contestants who struggle a lot in contests, the headquarters of Codeforces are planning to introduce Division 5. In this new division, the tags of all problems will be announced prior to the round to help the contestants.
The contest consists of n problems, where the tag of the i-th problem is denoted by an integer a_i.
You want to AK (solve all problems). To do that, you must solve the problems in some order. To make the contest funnier, you created extra limitations on yourself. You do not want to solve two problems consecutively with the same tag since it is boring. Also, you are afraid of big jumps in difficulties while solving them, so you want to minimize the number of times that you solve two problems consecutively that are not adjacent in the contest order.
Formally, your solve order can be described by a permutation p of length n. The cost of a permutation is defined as the number of indices i (1≤ i<n) where |p_{i+1}-p_i|>1. You have the requirement that a_{p_i}≠ a_{p_{i+1}} for all 1≤ i< n.
You want to know the minimum possible cost of permutation that satisfies the requirement. If no permutations meet this requirement, you should report about it.
Input
The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases.
The first line of the description of each test case contains a single integer n (1 ≤ n ≤ 10^5) — the number of problems in the contest.
The next line contains n integers a_1,a_2,… a_n (1 ≤ a_i ≤ n) — the tags of the problems.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, if there are no permutations that satisfy the required condition, print -1. Otherwise, print the minimum possible cost of a permutation that satisfies the required condition.
Example
Input
4
6
2 1 2 3 1 1
5
1 1 1 2 2
8
7 7 2 7 7 1 8 7
10
1 2 3 4 1 1 2 3 4 1
Output
1
3
-1
2
Note
In the first test case, let p=[5, 4, 3, 2, 1, 6]. The cost is 1 because we jump from p_5=1 to p_6=6, and |6-1|>1. This permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 1.
In the second test case, let p=[1,5,2,4,3]. The cost is 3 because |p_2-p_1|>1, |p_3-p_2|>1, and |p_4-p_3|>1. The permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 3.
In the third test case, for any order of solving the problems, we will solve two problems with the same tag consecutively, so the answer is -1.
Tags: constructive algorithms, greedy
Correct Solution:
```
import sys
input = sys.stdin.readline
t=int(input())
for tests in range(t):
n=int(input())
A=list(map(int,input().split()))
C=[0]*(n+1)
for a in A:
C[a]+=1
MAX=-1
MAXI=-1
for i in range(n+1):
if C[i]>MAX:
MAX=C[i]
MAXI=i
if MAX>(n+1)//2:
print(-1)
continue
NOW=A[0]
T=[]
for i in range(n-1):
if A[i]==A[i+1]:
T.append((NOW,A[i]))
NOW=A[i+1]
T.append((NOW,A[-1]))
#print(T)
D=[0]*(n+1)
OTHER=[0]*(n+1)
for x,y in T:
if x==y:
D[x]+=1
OTHER[x]+=1
else:
OTHER[x]+=1
OTHER[y]+=1
TUIKA=0
LEN=len(T)
for i in range(n+1):
if D[i]>LEN-OTHER[i]+1:
TUIKA+=D[i]-(LEN-OTHER[i]+1)
print(LEN-1+TUIKA)
```
| 14,371 |
Provide tags and a correct Python 3 solution for this coding contest problem.
To help those contestants who struggle a lot in contests, the headquarters of Codeforces are planning to introduce Division 5. In this new division, the tags of all problems will be announced prior to the round to help the contestants.
The contest consists of n problems, where the tag of the i-th problem is denoted by an integer a_i.
You want to AK (solve all problems). To do that, you must solve the problems in some order. To make the contest funnier, you created extra limitations on yourself. You do not want to solve two problems consecutively with the same tag since it is boring. Also, you are afraid of big jumps in difficulties while solving them, so you want to minimize the number of times that you solve two problems consecutively that are not adjacent in the contest order.
Formally, your solve order can be described by a permutation p of length n. The cost of a permutation is defined as the number of indices i (1≤ i<n) where |p_{i+1}-p_i|>1. You have the requirement that a_{p_i}≠ a_{p_{i+1}} for all 1≤ i< n.
You want to know the minimum possible cost of permutation that satisfies the requirement. If no permutations meet this requirement, you should report about it.
Input
The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases.
The first line of the description of each test case contains a single integer n (1 ≤ n ≤ 10^5) — the number of problems in the contest.
The next line contains n integers a_1,a_2,… a_n (1 ≤ a_i ≤ n) — the tags of the problems.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, if there are no permutations that satisfy the required condition, print -1. Otherwise, print the minimum possible cost of a permutation that satisfies the required condition.
Example
Input
4
6
2 1 2 3 1 1
5
1 1 1 2 2
8
7 7 2 7 7 1 8 7
10
1 2 3 4 1 1 2 3 4 1
Output
1
3
-1
2
Note
In the first test case, let p=[5, 4, 3, 2, 1, 6]. The cost is 1 because we jump from p_5=1 to p_6=6, and |6-1|>1. This permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 1.
In the second test case, let p=[1,5,2,4,3]. The cost is 3 because |p_2-p_1|>1, |p_3-p_2|>1, and |p_4-p_3|>1. The permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 3.
In the third test case, for any order of solving the problems, we will solve two problems with the same tag consecutively, so the answer is -1.
Tags: constructive algorithms, greedy
Correct Solution:
```
from collections import Counter
for _ in range(int(input())):
n = int(input())
A = list(map(int, input().split()))
if max(Counter(A).values()) > (n + 1) // 2: print(-1)
else:
k = 0
cnt = Counter()
cnt[A[0]] += 1
cnt[A[-1]] += 1
for i in range(n - 1):
if A[i] == A[i + 1]:
cnt[A[i]] += 2
k += 1
print(k + max(0, max(cnt.values()) - (k + 2)))
```
| 14,372 |
Provide tags and a correct Python 3 solution for this coding contest problem.
To help those contestants who struggle a lot in contests, the headquarters of Codeforces are planning to introduce Division 5. In this new division, the tags of all problems will be announced prior to the round to help the contestants.
The contest consists of n problems, where the tag of the i-th problem is denoted by an integer a_i.
You want to AK (solve all problems). To do that, you must solve the problems in some order. To make the contest funnier, you created extra limitations on yourself. You do not want to solve two problems consecutively with the same tag since it is boring. Also, you are afraid of big jumps in difficulties while solving them, so you want to minimize the number of times that you solve two problems consecutively that are not adjacent in the contest order.
Formally, your solve order can be described by a permutation p of length n. The cost of a permutation is defined as the number of indices i (1≤ i<n) where |p_{i+1}-p_i|>1. You have the requirement that a_{p_i}≠ a_{p_{i+1}} for all 1≤ i< n.
You want to know the minimum possible cost of permutation that satisfies the requirement. If no permutations meet this requirement, you should report about it.
Input
The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases.
The first line of the description of each test case contains a single integer n (1 ≤ n ≤ 10^5) — the number of problems in the contest.
The next line contains n integers a_1,a_2,… a_n (1 ≤ a_i ≤ n) — the tags of the problems.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, if there are no permutations that satisfy the required condition, print -1. Otherwise, print the minimum possible cost of a permutation that satisfies the required condition.
Example
Input
4
6
2 1 2 3 1 1
5
1 1 1 2 2
8
7 7 2 7 7 1 8 7
10
1 2 3 4 1 1 2 3 4 1
Output
1
3
-1
2
Note
In the first test case, let p=[5, 4, 3, 2, 1, 6]. The cost is 1 because we jump from p_5=1 to p_6=6, and |6-1|>1. This permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 1.
In the second test case, let p=[1,5,2,4,3]. The cost is 3 because |p_2-p_1|>1, |p_3-p_2|>1, and |p_4-p_3|>1. The permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 3.
In the third test case, for any order of solving the problems, we will solve two problems with the same tag consecutively, so the answer is -1.
Tags: constructive algorithms, greedy
Correct Solution:
```
T, = map(int, input().split())
for _ in range(T):
N, = map(int, input().split())
X = list(map(int, input().split()))
d = [0] * (N+1)
for x in X:
d[x] += 1
if max(d) > (N+1)//2:
print(-1)
continue
L = []
stack = []
for i in range(N):
if len(stack) == 0 or stack[-1] != X[i]:
stack.append(X[i])
else:
L.append(stack)
stack = [X[i]]
if stack:
L.append(stack)
cnt = [0]*(N+1)
for st in L:
if st[0] == st[-1]:
cnt[st[0]] += 1
mx, mxi = 0, 0
for i in range(N+1):
if cnt[i] > mx:
mx, mxi = cnt[i], i
tmp = 0
for st in L:
if st[0] != mxi and st[-1] != mxi:
tmp += 1
# print(len(L)-1, mx, tmp)
print(len(L)-1 + max(0, mx - tmp - 1))
```
| 14,373 |
Provide tags and a correct Python 3 solution for this coding contest problem.
To help those contestants who struggle a lot in contests, the headquarters of Codeforces are planning to introduce Division 5. In this new division, the tags of all problems will be announced prior to the round to help the contestants.
The contest consists of n problems, where the tag of the i-th problem is denoted by an integer a_i.
You want to AK (solve all problems). To do that, you must solve the problems in some order. To make the contest funnier, you created extra limitations on yourself. You do not want to solve two problems consecutively with the same tag since it is boring. Also, you are afraid of big jumps in difficulties while solving them, so you want to minimize the number of times that you solve two problems consecutively that are not adjacent in the contest order.
Formally, your solve order can be described by a permutation p of length n. The cost of a permutation is defined as the number of indices i (1≤ i<n) where |p_{i+1}-p_i|>1. You have the requirement that a_{p_i}≠ a_{p_{i+1}} for all 1≤ i< n.
You want to know the minimum possible cost of permutation that satisfies the requirement. If no permutations meet this requirement, you should report about it.
Input
The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases.
The first line of the description of each test case contains a single integer n (1 ≤ n ≤ 10^5) — the number of problems in the contest.
The next line contains n integers a_1,a_2,… a_n (1 ≤ a_i ≤ n) — the tags of the problems.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, if there are no permutations that satisfy the required condition, print -1. Otherwise, print the minimum possible cost of a permutation that satisfies the required condition.
Example
Input
4
6
2 1 2 3 1 1
5
1 1 1 2 2
8
7 7 2 7 7 1 8 7
10
1 2 3 4 1 1 2 3 4 1
Output
1
3
-1
2
Note
In the first test case, let p=[5, 4, 3, 2, 1, 6]. The cost is 1 because we jump from p_5=1 to p_6=6, and |6-1|>1. This permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 1.
In the second test case, let p=[1,5,2,4,3]. The cost is 3 because |p_2-p_1|>1, |p_3-p_2|>1, and |p_4-p_3|>1. The permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 3.
In the third test case, for any order of solving the problems, we will solve two problems with the same tag consecutively, so the answer is -1.
Tags: constructive algorithms, greedy
Correct Solution:
```
import sys
input = sys.stdin.readline
for _ in range(int(input())):
n = int(input())
N = n
a = list(map(int,input().split()))
a = [a[i]-1 for i in range(n)]
E = []
cnt = [0 for i in range(n)]
L = 0
for i in range(1,n):
if a[i]==a[i-1]:
cnt[a[i-1]] += 1
cnt[a[L]] += 1
E.append((L,i-1))
L = i
cnt[a[n-1]] += 1
cnt[a[L]] += 1
E.append((L,n-1))
idx = -1
M = max(cnt)
for i in range(n):
if cnt[i]==M:
idx = i
break
k = len(E)
cut = 0
for L,R in E:
for i in range(L,R):
if a[i]!=idx and a[i+1]!=idx:
cut += 1
#print(k,M,cut)
ans = -1
if k+1>=M:
ans = k-1
else:
need = M-(k+1)
if need<=cut:
ans = M - 2
#print("ANS")
print(ans)
```
| 14,374 |
Provide tags and a correct Python 3 solution for this coding contest problem.
To help those contestants who struggle a lot in contests, the headquarters of Codeforces are planning to introduce Division 5. In this new division, the tags of all problems will be announced prior to the round to help the contestants.
The contest consists of n problems, where the tag of the i-th problem is denoted by an integer a_i.
You want to AK (solve all problems). To do that, you must solve the problems in some order. To make the contest funnier, you created extra limitations on yourself. You do not want to solve two problems consecutively with the same tag since it is boring. Also, you are afraid of big jumps in difficulties while solving them, so you want to minimize the number of times that you solve two problems consecutively that are not adjacent in the contest order.
Formally, your solve order can be described by a permutation p of length n. The cost of a permutation is defined as the number of indices i (1≤ i<n) where |p_{i+1}-p_i|>1. You have the requirement that a_{p_i}≠ a_{p_{i+1}} for all 1≤ i< n.
You want to know the minimum possible cost of permutation that satisfies the requirement. If no permutations meet this requirement, you should report about it.
Input
The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases.
The first line of the description of each test case contains a single integer n (1 ≤ n ≤ 10^5) — the number of problems in the contest.
The next line contains n integers a_1,a_2,… a_n (1 ≤ a_i ≤ n) — the tags of the problems.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, if there are no permutations that satisfy the required condition, print -1. Otherwise, print the minimum possible cost of a permutation that satisfies the required condition.
Example
Input
4
6
2 1 2 3 1 1
5
1 1 1 2 2
8
7 7 2 7 7 1 8 7
10
1 2 3 4 1 1 2 3 4 1
Output
1
3
-1
2
Note
In the first test case, let p=[5, 4, 3, 2, 1, 6]. The cost is 1 because we jump from p_5=1 to p_6=6, and |6-1|>1. This permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 1.
In the second test case, let p=[1,5,2,4,3]. The cost is 3 because |p_2-p_1|>1, |p_3-p_2|>1, and |p_4-p_3|>1. The permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 3.
In the third test case, for any order of solving the problems, we will solve two problems with the same tag consecutively, so the answer is -1.
Tags: constructive algorithms, greedy
Correct Solution:
```
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
def main():
for _ in range(int(input())):
n = int(input())
a = list(map(int,input().split()))
cnt = 0
aCnt = [0] * n
for i in range(n):
aCnt[a[i] - 1] += 1
flag = True
for elem in aCnt:
if elem > n - (n // 2):
flag = False
if not flag:
print(-1)
continue
endCountDouble = [0] * (n + 1)
endCountSingle = [0] * (n + 1)
last = a[0]
lastInd = 0
for i in range(n-1):
if a[i] == a[i + 1]:
cnt += 1
if last == a[i]:
endCountDouble[last] += 1
else:
endCountSingle[last] += 1
endCountSingle[a[i]] += 1
last = a[i]
lastInd = i
if last == a[n-1]:
endCountDouble[last] += 1
else:
endCountSingle[last] += 1
endCountSingle[a[n-1]] += 1
last = a[n-1]
segCount = cnt + 1
adjCount = 0
whattoAdj = 0
for i in range(n + 1):
if endCountDouble[i] > (segCount - endCountSingle[i]) - (segCount - endCountSingle[i]) // 2:
adjCount = endCountDouble[i] - ((segCount - endCountSingle[i]) - (segCount - endCountSingle[i]) // 2)
whattoAdj = i
if adjCount != 0:
badPair = endCountDouble[whattoAdj]
goodPair = segCount - endCountSingle[whattoAdj] - endCountDouble[whattoAdj]
adjAble = 0
for i in range(n - 1):
if a[i] != i and a[i + 1] != i:
adjAble += 1
if adjAble >= badPair - goodPair - 1:
print(cnt + badPair - goodPair - 1)
else:
print(-1)
else:
print(cnt)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
```
| 14,375 |
Provide tags and a correct Python 3 solution for this coding contest problem.
To help those contestants who struggle a lot in contests, the headquarters of Codeforces are planning to introduce Division 5. In this new division, the tags of all problems will be announced prior to the round to help the contestants.
The contest consists of n problems, where the tag of the i-th problem is denoted by an integer a_i.
You want to AK (solve all problems). To do that, you must solve the problems in some order. To make the contest funnier, you created extra limitations on yourself. You do not want to solve two problems consecutively with the same tag since it is boring. Also, you are afraid of big jumps in difficulties while solving them, so you want to minimize the number of times that you solve two problems consecutively that are not adjacent in the contest order.
Formally, your solve order can be described by a permutation p of length n. The cost of a permutation is defined as the number of indices i (1≤ i<n) where |p_{i+1}-p_i|>1. You have the requirement that a_{p_i}≠ a_{p_{i+1}} for all 1≤ i< n.
You want to know the minimum possible cost of permutation that satisfies the requirement. If no permutations meet this requirement, you should report about it.
Input
The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases.
The first line of the description of each test case contains a single integer n (1 ≤ n ≤ 10^5) — the number of problems in the contest.
The next line contains n integers a_1,a_2,… a_n (1 ≤ a_i ≤ n) — the tags of the problems.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, if there are no permutations that satisfy the required condition, print -1. Otherwise, print the minimum possible cost of a permutation that satisfies the required condition.
Example
Input
4
6
2 1 2 3 1 1
5
1 1 1 2 2
8
7 7 2 7 7 1 8 7
10
1 2 3 4 1 1 2 3 4 1
Output
1
3
-1
2
Note
In the first test case, let p=[5, 4, 3, 2, 1, 6]. The cost is 1 because we jump from p_5=1 to p_6=6, and |6-1|>1. This permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 1.
In the second test case, let p=[1,5,2,4,3]. The cost is 3 because |p_2-p_1|>1, |p_3-p_2|>1, and |p_4-p_3|>1. The permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 3.
In the third test case, for any order of solving the problems, we will solve two problems with the same tag consecutively, so the answer is -1.
Tags: constructive algorithms, greedy
Correct Solution:
```
# region fastio # from https://codeforces.com/contest/1333/submission/75948789
import sys, io, os
BUFSIZE = 8192
class FastIO(io.IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = io.BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(io.IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#endregion
T = int(input())
for _ in range(T):
N = int(input())
A = list(map(int, input().split()))
Counts = [0] * (N+1)
for a in A:
Counts[a] += 1
ma = max(Counts)
if ma * 2 - 1 > N:
print(-1)
continue
Cons = [0] * (N+1)
for a1, a2 in zip(A, A[1:]):
if a1 == a2:
Cons[a1] += 1
ans1 = sum(Cons)
ma = -1
ama = -101010101
for i, cons in enumerate(Cons):
if ma < cons:
ama = i
ma = cons
a_old = A[0]
left = A[0]
C = [0, 0, 0]
for a in A[1:]+[A[-1]]:
if a == a_old:
right = a
C[(left==ama)+(right==ama)] += 1
left = a
a_old = a
C[2] -= C[0]
if C[2] <= 1:
ans = ans1
else:
ans = ans1 + C[2] - 1
print(ans)
```
| 14,376 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To help those contestants who struggle a lot in contests, the headquarters of Codeforces are planning to introduce Division 5. In this new division, the tags of all problems will be announced prior to the round to help the contestants.
The contest consists of n problems, where the tag of the i-th problem is denoted by an integer a_i.
You want to AK (solve all problems). To do that, you must solve the problems in some order. To make the contest funnier, you created extra limitations on yourself. You do not want to solve two problems consecutively with the same tag since it is boring. Also, you are afraid of big jumps in difficulties while solving them, so you want to minimize the number of times that you solve two problems consecutively that are not adjacent in the contest order.
Formally, your solve order can be described by a permutation p of length n. The cost of a permutation is defined as the number of indices i (1≤ i<n) where |p_{i+1}-p_i|>1. You have the requirement that a_{p_i}≠ a_{p_{i+1}} for all 1≤ i< n.
You want to know the minimum possible cost of permutation that satisfies the requirement. If no permutations meet this requirement, you should report about it.
Input
The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases.
The first line of the description of each test case contains a single integer n (1 ≤ n ≤ 10^5) — the number of problems in the contest.
The next line contains n integers a_1,a_2,… a_n (1 ≤ a_i ≤ n) — the tags of the problems.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, if there are no permutations that satisfy the required condition, print -1. Otherwise, print the minimum possible cost of a permutation that satisfies the required condition.
Example
Input
4
6
2 1 2 3 1 1
5
1 1 1 2 2
8
7 7 2 7 7 1 8 7
10
1 2 3 4 1 1 2 3 4 1
Output
1
3
-1
2
Note
In the first test case, let p=[5, 4, 3, 2, 1, 6]. The cost is 1 because we jump from p_5=1 to p_6=6, and |6-1|>1. This permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 1.
In the second test case, let p=[1,5,2,4,3]. The cost is 3 because |p_2-p_1|>1, |p_3-p_2|>1, and |p_4-p_3|>1. The permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 3.
In the third test case, for any order of solving the problems, we will solve two problems with the same tag consecutively, so the answer is -1.
Submitted Solution:
```
import sys
input = lambda: sys.stdin.readline().rstrip()
def calc(A):
N = len(A)
if N == 1:
return 0
X = [0] * N
for a in A:
X[a] += 1
if max(X) > (N + 1) // 2:
return -1
Y = [0] * N
Y[A[0]] += 1
Y[A[-1]] += 1
for a, b in zip(A, A[1:]):
if a == b:
Y[a] += 2
su, ma = sum(Y), max(Y)
cc = su - ma
return su // 2 - 1 + max(ma - cc - 2, 0) // 2
T = int(input())
for _ in range(T):
N = int(input())
A = [int(a) - 1 for a in input().split()]
print(calc(A))
```
Yes
| 14,377 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To help those contestants who struggle a lot in contests, the headquarters of Codeforces are planning to introduce Division 5. In this new division, the tags of all problems will be announced prior to the round to help the contestants.
The contest consists of n problems, where the tag of the i-th problem is denoted by an integer a_i.
You want to AK (solve all problems). To do that, you must solve the problems in some order. To make the contest funnier, you created extra limitations on yourself. You do not want to solve two problems consecutively with the same tag since it is boring. Also, you are afraid of big jumps in difficulties while solving them, so you want to minimize the number of times that you solve two problems consecutively that are not adjacent in the contest order.
Formally, your solve order can be described by a permutation p of length n. The cost of a permutation is defined as the number of indices i (1≤ i<n) where |p_{i+1}-p_i|>1. You have the requirement that a_{p_i}≠ a_{p_{i+1}} for all 1≤ i< n.
You want to know the minimum possible cost of permutation that satisfies the requirement. If no permutations meet this requirement, you should report about it.
Input
The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases.
The first line of the description of each test case contains a single integer n (1 ≤ n ≤ 10^5) — the number of problems in the contest.
The next line contains n integers a_1,a_2,… a_n (1 ≤ a_i ≤ n) — the tags of the problems.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, if there are no permutations that satisfy the required condition, print -1. Otherwise, print the minimum possible cost of a permutation that satisfies the required condition.
Example
Input
4
6
2 1 2 3 1 1
5
1 1 1 2 2
8
7 7 2 7 7 1 8 7
10
1 2 3 4 1 1 2 3 4 1
Output
1
3
-1
2
Note
In the first test case, let p=[5, 4, 3, 2, 1, 6]. The cost is 1 because we jump from p_5=1 to p_6=6, and |6-1|>1. This permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 1.
In the second test case, let p=[1,5,2,4,3]. The cost is 3 because |p_2-p_1|>1, |p_3-p_2|>1, and |p_4-p_3|>1. The permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 3.
In the third test case, for any order of solving the problems, we will solve two problems with the same tag consecutively, so the answer is -1.
Submitted Solution:
```
def calc(A):
N = len(A)
if N == 1:
return 0
X = [0] * N
for a in A:
X[a] += 1
if max(X) > (N + 1) // 2:
return -1
Y = [0] * N
Y[A[0]] += 1
Y[A[-1]] += 1
for a, b in zip(A, A[1:]):
if a == b:
Y[a] += 2
su, ma = sum(Y), max(Y)
cc = su - ma
return su // 2 - 1 + max(ma - cc - 2, 0) // 2
T = int(input())
for _ in range(T):
N = int(input())
A = [int(a) - 1 for a in input().split()]
print(calc(A))
```
Yes
| 14,378 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To help those contestants who struggle a lot in contests, the headquarters of Codeforces are planning to introduce Division 5. In this new division, the tags of all problems will be announced prior to the round to help the contestants.
The contest consists of n problems, where the tag of the i-th problem is denoted by an integer a_i.
You want to AK (solve all problems). To do that, you must solve the problems in some order. To make the contest funnier, you created extra limitations on yourself. You do not want to solve two problems consecutively with the same tag since it is boring. Also, you are afraid of big jumps in difficulties while solving them, so you want to minimize the number of times that you solve two problems consecutively that are not adjacent in the contest order.
Formally, your solve order can be described by a permutation p of length n. The cost of a permutation is defined as the number of indices i (1≤ i<n) where |p_{i+1}-p_i|>1. You have the requirement that a_{p_i}≠ a_{p_{i+1}} for all 1≤ i< n.
You want to know the minimum possible cost of permutation that satisfies the requirement. If no permutations meet this requirement, you should report about it.
Input
The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases.
The first line of the description of each test case contains a single integer n (1 ≤ n ≤ 10^5) — the number of problems in the contest.
The next line contains n integers a_1,a_2,… a_n (1 ≤ a_i ≤ n) — the tags of the problems.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, if there are no permutations that satisfy the required condition, print -1. Otherwise, print the minimum possible cost of a permutation that satisfies the required condition.
Example
Input
4
6
2 1 2 3 1 1
5
1 1 1 2 2
8
7 7 2 7 7 1 8 7
10
1 2 3 4 1 1 2 3 4 1
Output
1
3
-1
2
Note
In the first test case, let p=[5, 4, 3, 2, 1, 6]. The cost is 1 because we jump from p_5=1 to p_6=6, and |6-1|>1. This permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 1.
In the second test case, let p=[1,5,2,4,3]. The cost is 3 because |p_2-p_1|>1, |p_3-p_2|>1, and |p_4-p_3|>1. The permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 3.
In the third test case, for any order of solving the problems, we will solve two problems with the same tag consecutively, so the answer is -1.
Submitted Solution:
```
import sys
input = sys.stdin.readline
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
c = [0]*(n+1)
for e in a:
c[e]+=1
if max(c) >= (n+1)//2 +1:
print(-1)
continue
count = 1
s=0
c = [0]*(n+1)
for i in range(n-1):
if a[i]==a[i+1]:
count +=1
c[a[s]]+=1
c[a[i]]+=1
s = i+1
c[a[s]]+=1
c[a[n-1]]+=1
mx = max(c)
ss = sum(c)
if mx-2 <= ss-mx :
print(count-1)
else:
count += (mx-2-(ss-mx))//2
print(count-1)
```
Yes
| 14,379 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To help those contestants who struggle a lot in contests, the headquarters of Codeforces are planning to introduce Division 5. In this new division, the tags of all problems will be announced prior to the round to help the contestants.
The contest consists of n problems, where the tag of the i-th problem is denoted by an integer a_i.
You want to AK (solve all problems). To do that, you must solve the problems in some order. To make the contest funnier, you created extra limitations on yourself. You do not want to solve two problems consecutively with the same tag since it is boring. Also, you are afraid of big jumps in difficulties while solving them, so you want to minimize the number of times that you solve two problems consecutively that are not adjacent in the contest order.
Formally, your solve order can be described by a permutation p of length n. The cost of a permutation is defined as the number of indices i (1≤ i<n) where |p_{i+1}-p_i|>1. You have the requirement that a_{p_i}≠ a_{p_{i+1}} for all 1≤ i< n.
You want to know the minimum possible cost of permutation that satisfies the requirement. If no permutations meet this requirement, you should report about it.
Input
The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases.
The first line of the description of each test case contains a single integer n (1 ≤ n ≤ 10^5) — the number of problems in the contest.
The next line contains n integers a_1,a_2,… a_n (1 ≤ a_i ≤ n) — the tags of the problems.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, if there are no permutations that satisfy the required condition, print -1. Otherwise, print the minimum possible cost of a permutation that satisfies the required condition.
Example
Input
4
6
2 1 2 3 1 1
5
1 1 1 2 2
8
7 7 2 7 7 1 8 7
10
1 2 3 4 1 1 2 3 4 1
Output
1
3
-1
2
Note
In the first test case, let p=[5, 4, 3, 2, 1, 6]. The cost is 1 because we jump from p_5=1 to p_6=6, and |6-1|>1. This permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 1.
In the second test case, let p=[1,5,2,4,3]. The cost is 3 because |p_2-p_1|>1, |p_3-p_2|>1, and |p_4-p_3|>1. The permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 3.
In the third test case, for any order of solving the problems, we will solve two problems with the same tag consecutively, so the answer is -1.
Submitted Solution:
```
import sys,io,os;Z=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
o=[]
for _ in range(int(Z())):
n=int(Z());a=[*map(int,Z().split())]
cn=p=a[0];pn=d=0;e=[0]*n;b=[0]*n;c=[0]*n
for i in range(n):
if a[i]==p:
if pn:
if pn!=p:b[pn-1]+=1
else:e[p-1]+=1
b[p-1]+=1;d+=1
pn=p
p=a[i];c[p-1]+=1
if pn!=p:b[pn-1]+=1
else:e[p-1]+=1
b[p-1]+=1
if 2*max(c)-1>n:o.append('-1');continue
m=0;s=sum(b)
for i in range(n):
dl=max(0,e[i]-2-d+b[i]);m=max(dl,m)
o.append(str(d+m))
print('\n'.join(o))
```
Yes
| 14,380 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To help those contestants who struggle a lot in contests, the headquarters of Codeforces are planning to introduce Division 5. In this new division, the tags of all problems will be announced prior to the round to help the contestants.
The contest consists of n problems, where the tag of the i-th problem is denoted by an integer a_i.
You want to AK (solve all problems). To do that, you must solve the problems in some order. To make the contest funnier, you created extra limitations on yourself. You do not want to solve two problems consecutively with the same tag since it is boring. Also, you are afraid of big jumps in difficulties while solving them, so you want to minimize the number of times that you solve two problems consecutively that are not adjacent in the contest order.
Formally, your solve order can be described by a permutation p of length n. The cost of a permutation is defined as the number of indices i (1≤ i<n) where |p_{i+1}-p_i|>1. You have the requirement that a_{p_i}≠ a_{p_{i+1}} for all 1≤ i< n.
You want to know the minimum possible cost of permutation that satisfies the requirement. If no permutations meet this requirement, you should report about it.
Input
The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases.
The first line of the description of each test case contains a single integer n (1 ≤ n ≤ 10^5) — the number of problems in the contest.
The next line contains n integers a_1,a_2,… a_n (1 ≤ a_i ≤ n) — the tags of the problems.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, if there are no permutations that satisfy the required condition, print -1. Otherwise, print the minimum possible cost of a permutation that satisfies the required condition.
Example
Input
4
6
2 1 2 3 1 1
5
1 1 1 2 2
8
7 7 2 7 7 1 8 7
10
1 2 3 4 1 1 2 3 4 1
Output
1
3
-1
2
Note
In the first test case, let p=[5, 4, 3, 2, 1, 6]. The cost is 1 because we jump from p_5=1 to p_6=6, and |6-1|>1. This permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 1.
In the second test case, let p=[1,5,2,4,3]. The cost is 3 because |p_2-p_1|>1, |p_3-p_2|>1, and |p_4-p_3|>1. The permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 3.
In the third test case, for any order of solving the problems, we will solve two problems with the same tag consecutively, so the answer is -1.
Submitted Solution:
```
import sys
input = sys.stdin.readline
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
c = [0]*(n+1)
for e in a:
c[e]+=1
if max(c) >= (n+1)//2 +1:
print(-1)
continue
count = 1
s=0
c = [0]*(n+1)
for i in range(n-1):
if a[i]==a[i+1]:
count +=1
if a[s]!=a[i]:
c[a[s]]+=1
c[a[i]]+=1
else:
c[a[i]]+=1
s = i+1
if a[s]!=a[n-1]:
c[a[s]]+=1
c[a[n-1]]+=1
else:
c[a[s]]+=1
mx = max(c)
ss = sum(c)
if mx < (ss+1)//2 +1:
print(count-1)
else:
while mx >= (ss+1)//2 +1:
count +=1
ss += 2
print(count-1)
```
No
| 14,381 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To help those contestants who struggle a lot in contests, the headquarters of Codeforces are planning to introduce Division 5. In this new division, the tags of all problems will be announced prior to the round to help the contestants.
The contest consists of n problems, where the tag of the i-th problem is denoted by an integer a_i.
You want to AK (solve all problems). To do that, you must solve the problems in some order. To make the contest funnier, you created extra limitations on yourself. You do not want to solve two problems consecutively with the same tag since it is boring. Also, you are afraid of big jumps in difficulties while solving them, so you want to minimize the number of times that you solve two problems consecutively that are not adjacent in the contest order.
Formally, your solve order can be described by a permutation p of length n. The cost of a permutation is defined as the number of indices i (1≤ i<n) where |p_{i+1}-p_i|>1. You have the requirement that a_{p_i}≠ a_{p_{i+1}} for all 1≤ i< n.
You want to know the minimum possible cost of permutation that satisfies the requirement. If no permutations meet this requirement, you should report about it.
Input
The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases.
The first line of the description of each test case contains a single integer n (1 ≤ n ≤ 10^5) — the number of problems in the contest.
The next line contains n integers a_1,a_2,… a_n (1 ≤ a_i ≤ n) — the tags of the problems.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, if there are no permutations that satisfy the required condition, print -1. Otherwise, print the minimum possible cost of a permutation that satisfies the required condition.
Example
Input
4
6
2 1 2 3 1 1
5
1 1 1 2 2
8
7 7 2 7 7 1 8 7
10
1 2 3 4 1 1 2 3 4 1
Output
1
3
-1
2
Note
In the first test case, let p=[5, 4, 3, 2, 1, 6]. The cost is 1 because we jump from p_5=1 to p_6=6, and |6-1|>1. This permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 1.
In the second test case, let p=[1,5,2,4,3]. The cost is 3 because |p_2-p_1|>1, |p_3-p_2|>1, and |p_4-p_3|>1. The permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 3.
In the third test case, for any order of solving the problems, we will solve two problems with the same tag consecutively, so the answer is -1.
Submitted Solution:
```
from sys import stdin
input = stdin.readline
q = int(input())
for _ in range(q):
n = int(input())
l = list(map(int,input().split()))
ile = [0] * (n+1)
for i in l:
ile[i] += 1
if max(ile) >= (n+1)//2 + 1:
print(-1)
else:
if n == 1:
print(0)
else:
cyk = []
count = 0
cur = l[0]
for i in range(n):
if l[i] != cur:
cyk.append([cur,count])
count = 1
cur = l[i]
else:
count += 1
if count != 1:
cyk.append([cur, count])
if l[-1] != l[-2]:
cyk.append([cur,count])
wyn = 0
for i in cyk:
wyn += max(0, i[1]-1)
if cyk[0][1] == 1 and cyk[-1][1] == 1 and cyk[0][0] == cyk[-1][0]:
for j in range(1, len(cyk)-1):
if cyk[j][0] == cyk[0][0] and cyk[j][1] > 1:
wyn += 1
break
print(wyn)
```
No
| 14,382 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To help those contestants who struggle a lot in contests, the headquarters of Codeforces are planning to introduce Division 5. In this new division, the tags of all problems will be announced prior to the round to help the contestants.
The contest consists of n problems, where the tag of the i-th problem is denoted by an integer a_i.
You want to AK (solve all problems). To do that, you must solve the problems in some order. To make the contest funnier, you created extra limitations on yourself. You do not want to solve two problems consecutively with the same tag since it is boring. Also, you are afraid of big jumps in difficulties while solving them, so you want to minimize the number of times that you solve two problems consecutively that are not adjacent in the contest order.
Formally, your solve order can be described by a permutation p of length n. The cost of a permutation is defined as the number of indices i (1≤ i<n) where |p_{i+1}-p_i|>1. You have the requirement that a_{p_i}≠ a_{p_{i+1}} for all 1≤ i< n.
You want to know the minimum possible cost of permutation that satisfies the requirement. If no permutations meet this requirement, you should report about it.
Input
The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases.
The first line of the description of each test case contains a single integer n (1 ≤ n ≤ 10^5) — the number of problems in the contest.
The next line contains n integers a_1,a_2,… a_n (1 ≤ a_i ≤ n) — the tags of the problems.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, if there are no permutations that satisfy the required condition, print -1. Otherwise, print the minimum possible cost of a permutation that satisfies the required condition.
Example
Input
4
6
2 1 2 3 1 1
5
1 1 1 2 2
8
7 7 2 7 7 1 8 7
10
1 2 3 4 1 1 2 3 4 1
Output
1
3
-1
2
Note
In the first test case, let p=[5, 4, 3, 2, 1, 6]. The cost is 1 because we jump from p_5=1 to p_6=6, and |6-1|>1. This permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 1.
In the second test case, let p=[1,5,2,4,3]. The cost is 3 because |p_2-p_1|>1, |p_3-p_2|>1, and |p_4-p_3|>1. The permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 3.
In the third test case, for any order of solving the problems, we will solve two problems with the same tag consecutively, so the answer is -1.
Submitted Solution:
```
from sys import stdin
input = stdin.readline
q = int(input())
for _ in range(q):
n = int(input())
l = list(map(int,input().split()))
ile = [0] * (n+1)
for i in l:
ile[i] += 1
if max(ile) >= (n+1)//2 + 1:
print(-1)
else:
if n == 1:
print(0)
else:
frag = []
now = [l[0]]
for i in range(1,n):
if l[i] == l[i-1]:
frag.append(now)
now = [l[i]]
else:
now.append(l[i])
frag.append(now)
konce = []
for i in frag:
if i[0] == i[-1]:
konce.append(i[0])
k = len(frag)
d = {}
for i in konce:
d[i] = 0
for i in konce:
d[i] += 1
m = 0
for i in d:
m = max(m, d[i])
dif = max(0, 2*m-k-1)
print(k + dif-1)
```
No
| 14,383 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To help those contestants who struggle a lot in contests, the headquarters of Codeforces are planning to introduce Division 5. In this new division, the tags of all problems will be announced prior to the round to help the contestants.
The contest consists of n problems, where the tag of the i-th problem is denoted by an integer a_i.
You want to AK (solve all problems). To do that, you must solve the problems in some order. To make the contest funnier, you created extra limitations on yourself. You do not want to solve two problems consecutively with the same tag since it is boring. Also, you are afraid of big jumps in difficulties while solving them, so you want to minimize the number of times that you solve two problems consecutively that are not adjacent in the contest order.
Formally, your solve order can be described by a permutation p of length n. The cost of a permutation is defined as the number of indices i (1≤ i<n) where |p_{i+1}-p_i|>1. You have the requirement that a_{p_i}≠ a_{p_{i+1}} for all 1≤ i< n.
You want to know the minimum possible cost of permutation that satisfies the requirement. If no permutations meet this requirement, you should report about it.
Input
The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases.
The first line of the description of each test case contains a single integer n (1 ≤ n ≤ 10^5) — the number of problems in the contest.
The next line contains n integers a_1,a_2,… a_n (1 ≤ a_i ≤ n) — the tags of the problems.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, if there are no permutations that satisfy the required condition, print -1. Otherwise, print the minimum possible cost of a permutation that satisfies the required condition.
Example
Input
4
6
2 1 2 3 1 1
5
1 1 1 2 2
8
7 7 2 7 7 1 8 7
10
1 2 3 4 1 1 2 3 4 1
Output
1
3
-1
2
Note
In the first test case, let p=[5, 4, 3, 2, 1, 6]. The cost is 1 because we jump from p_5=1 to p_6=6, and |6-1|>1. This permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 1.
In the second test case, let p=[1,5,2,4,3]. The cost is 3 because |p_2-p_1|>1, |p_3-p_2|>1, and |p_4-p_3|>1. The permutation is valid because we don't solve problems with the same tag twice in a row. We cannot find a permutation with a cost smaller than 3.
In the third test case, for any order of solving the problems, we will solve two problems with the same tag consecutively, so the answer is -1.
Submitted Solution:
```
import sys
input = sys.stdin.readline
outL = []
t = int(input())
for _ in range(t):
n = int(input())
l = list(map(lambda x: int(x) - 1, input().split()))
intervals = []
start = 0
for i in range(1,n):
if l[i] == l[i-1]:
intervals.append((start, i-1))
start = i
intervals.append((start,n-1))
count = [0] * n
for le,ri in intervals:
count[l[le]] += 1
count[l[ri]] += 1
want = len(intervals)-1
if max(count) <= want+2:
outL.append(want)
continue
count2 = [0] * n
for v in l:
count2[v] += 1
for issue in range(n):
if count2[issue] == max(count2):
break
num_issue = max(count2)
rest = n - issue
best = max(count) - 2
if num_issue > rest + 1:
outL.append(-1)
else:
outL.append(best)
print('\n'.join(map(str,outL)))
```
No
| 14,384 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During cleaning the coast, Alice found n piles of stones. The i-th pile has a_i stones.
Piles i and i + 1 are neighbouring for all 1 ≤ i ≤ n - 1. If pile i becomes empty, piles i - 1 and i + 1 doesn't become neighbouring.
Alice is too lazy to remove these stones, so she asked you to take this duty. She allowed you to do only the following operation:
* Select two neighboring piles and, if both of them are not empty, remove one stone from each of them.
Alice understands that sometimes it's impossible to remove all stones with the given operation, so she allowed you to use the following superability:
* Before the start of cleaning, you can select two neighboring piles and swap them.
Determine, if it is possible to remove all stones using the superability not more than once.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of piles.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the number of stones in each pile.
It is guaranteed that the total sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print YES or NO — is it possible to remove all stones using the superability not more than once or not.
Example
Input
5
3
1 2 1
3
1 1 2
5
2 2 2 1 3
5
2100 1900 1600 3000 1600
2
2443 2445
Output
YES
YES
YES
YES
NO
Note
In the first test case, you can remove all stones without using a superability: [1, 2, 1] → [1, 1, 0] → [0, 0, 0].
In the second test case, you can apply superability to the second and the third piles and then act like in the first testcase.
In the third test case, you can apply superability to the fourth and the fifth piles, thus getting a = [2, 2, 2, 3, 1].
In the fourth test case, you can apply superability to the first and the second piles, thus getting a = [1900, 2100, 1600, 3000, 1600].
Tags: data structures, dp, greedy, math
Correct Solution:
```
# 452c532939484f489758bb6a1e71a6aafee40ae6f991e8cd80298b6258223d75
#adding bot
"""
Author - Satwik Tiwari .
19th Jan , 2021 - Tuesday
"""
#===============================================================================================
#importing some useful libraries.
from __future__ import division, print_function
# from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
# from itertools import *
from heapq import *
from math import gcd, factorial,floor,ceil,sqrt,log2
from copy import deepcopy
from collections import deque
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
#==============================================================================================
#fast I/O region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
#===============================================================================================
#some shortcuts
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def testcase(t):
for pp in range(t):
solve(pp)
def google(p):
print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(x, y, p) :
y%=(p-1) #not so sure about this. used when y>p-1. if p is prime.
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) : # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def ncr(n,r): return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
inf = pow(10,20)
mod = 10**9+7
#===============================================================================================
# code here ;))
def do(b,n):
ans = True
for i in range(n-1):
if(i == n-2):
if(b[i] != b[i+1]):
ans = False
else:
if(b[i] <= b[i+1]):
b[i+1]-=b[i]
else:
ans = False
return ans
def chck(a):
ans = False
b = deepcopy(a)
n = len(a)
ans = ans | do(b,n)
b = deepcopy(a)
b[0],b[1] = b[1],b[0]
ans = ans | do(b,n)
b = deepcopy(a)
b[n-1],b[n-2] = b[n-2],b[n-1]
ans = ans | do(b,n)
return ans
def solve(case):
n = int(inp())
b = lis()
if(n == 2):
if(b[0] == b[1]):
print('YES')
else:
print('NO')
return
if(chck(b)):
print('YES')
return
l = deepcopy(b)
left = [0]*n
left[0] = 1
for i in range(1,n-1):
if(l[i] >= l[i-1]):
l[i]-=l[i-1]
# a[i] = 0
left[i] = 1 and left[i-1]
else:
left[i] = 0
r = deepcopy(b)
right = [0]*n
right[n-1] = 1
for i in range(n-2,0,-1):
if(r[i] >= r[i+1]):
r[i]-=r[i+1]
right[i] = 1 and right[i+1]
else:
right[i] = 0
# print(l,left)
# print(r,right)
ans = False
for i in range(n-3):
if(left[i] and right[i+3] and b[i+2] >= l[i] and b[i+1] >= r[i+3] and b[i+2]-l[i] == b[i+1]-r[i+3]):
ans = True
# print(i)
print('YES' if ans else 'NO')
# testcase(1)
testcase(int(inp()))
```
| 14,385 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During cleaning the coast, Alice found n piles of stones. The i-th pile has a_i stones.
Piles i and i + 1 are neighbouring for all 1 ≤ i ≤ n - 1. If pile i becomes empty, piles i - 1 and i + 1 doesn't become neighbouring.
Alice is too lazy to remove these stones, so she asked you to take this duty. She allowed you to do only the following operation:
* Select two neighboring piles and, if both of them are not empty, remove one stone from each of them.
Alice understands that sometimes it's impossible to remove all stones with the given operation, so she allowed you to use the following superability:
* Before the start of cleaning, you can select two neighboring piles and swap them.
Determine, if it is possible to remove all stones using the superability not more than once.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of piles.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the number of stones in each pile.
It is guaranteed that the total sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print YES or NO — is it possible to remove all stones using the superability not more than once or not.
Example
Input
5
3
1 2 1
3
1 1 2
5
2 2 2 1 3
5
2100 1900 1600 3000 1600
2
2443 2445
Output
YES
YES
YES
YES
NO
Note
In the first test case, you can remove all stones without using a superability: [1, 2, 1] → [1, 1, 0] → [0, 0, 0].
In the second test case, you can apply superability to the second and the third piles and then act like in the first testcase.
In the third test case, you can apply superability to the fourth and the fifth piles, thus getting a = [2, 2, 2, 3, 1].
In the fourth test case, you can apply superability to the first and the second piles, thus getting a = [1900, 2100, 1600, 3000, 1600].
Tags: data structures, dp, greedy, math
Correct Solution:
```
from bisect import *
from collections import *
from math import gcd,ceil,sqrt,floor,inf
from heapq import *
from itertools import *
#from operator import add,mul,sub,xor,truediv,floordiv
from functools import *
#------------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#------------------------------------------------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
#------------------------------------------------------------------------
from types import GeneratorType
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
mod=10**9+7
farr=[1]
ifa=[]
def fact(x,mod=0):
if mod:
while x>=len(farr):
farr.append(farr[-1]*len(farr)%mod)
else:
while x>=len(farr):
farr.append(farr[-1]*len(farr))
return farr[x]
def ifact(x,mod):
global ifa
fact(x,mod)
ifa.append(pow(farr[-1],mod-2,mod))
for i in range(x,0,-1):
ifa.append(ifa[-1]*i%mod)
ifa.reverse()
def per(i,j,mod=0):
if i<j: return 0
if not mod:
return fact(i)//fact(i-j)
return farr[i]*ifa[i-j]%mod
def com(i,j,mod=0):
if i<j: return 0
if not mod:
return per(i,j)//fact(j)
return per(i,j,mod)*ifa[j]%mod
def catalan(n):
return com(2*n,n)//(n+1)
def isprime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True
def floorsum(a,b,c,n):#sum((a*i+b)//c for i in range(n+1))
if a==0:return b//c*(n+1)
if a>=c or b>=c: return floorsum(a%c,b%c,c,n)+b//c*(n+1)+a//c*n*(n+1)//2
m=(a*n+b)//c
return n*m-floorsum(c,c-b-1,a,m-1)
def lowbit(n):
return n&-n
def inverse(a,m):
a%=m
if a<=1: return a
return ((1-inverse(m,a)*m)//a)%m
class BIT:
def __init__(self,arr):
self.arr=arr
self.n=len(arr)-1
def update(self,x,v):
while x<=self.n:
self.arr[x]+=v
x+=x&-x
def query(self,x):
ans=0
while x:
ans+=self.arr[x]
x&=x-1
return ans
'''
class SMT:
def __init__(self,arr):
self.n=len(arr)-1
self.arr=[0]*(self.n<<2)
self.lazy=[0]*(self.n<<2)
def Build(l,r,rt):
if l==r:
self.arr[rt]=arr[l]
return
m=(l+r)>>1
Build(l,m,rt<<1)
Build(m+1,r,rt<<1|1)
self.pushup(rt)
Build(1,self.n,1)
def pushup(self,rt):
self.arr[rt]=self.arr[rt<<1]+self.arr[rt<<1|1]
def pushdown(self,rt,ln,rn):#lr,rn表区间数字数
if self.lazy[rt]:
self.lazy[rt<<1]+=self.lazy[rt]
self.lazy[rt<<1|1]+=self.lazy[rt]
self.arr[rt<<1]+=self.lazy[rt]*ln
self.arr[rt<<1|1]+=self.lazy[rt]*rn
self.lazy[rt]=0
def update(self,L,R,c,l=1,r=None,rt=1):#L,R表示操作区间
if r==None: r=self.n
if L<=l and r<=R:
self.arr[rt]+=c*(r-l+1)
self.lazy[rt]+=c
return
m=(l+r)>>1
self.pushdown(rt,m-l+1,r-m)
if L<=m: self.update(L,R,c,l,m,rt<<1)
if R>m: self.update(L,R,c,m+1,r,rt<<1|1)
self.pushup(rt)
def query(self,L,R,l=1,r=None,rt=1):
if r==None: r=self.n
#print(L,R,l,r,rt)
if L<=l and R>=r:
return self.arr[rt]
m=(l+r)>>1
self.pushdown(rt,m-l+1,r-m)
ans=0
if L<=m: ans+=self.query(L,R,l,m,rt<<1)
if R>m: ans+=self.query(L,R,m+1,r,rt<<1|1)
return ans
'''
class DSU:#容量+路径压缩
def __init__(self,n):
self.c=[-1]*n
def same(self,x,y):
return self.find(x)==self.find(y)
def find(self,x):
if self.c[x]<0:
return x
self.c[x]=self.find(self.c[x])
return self.c[x]
def union(self,u,v):
u,v=self.find(u),self.find(v)
if u==v:
return False
if self.c[u]>self.c[v]:
u,v=v,u
self.c[u]+=self.c[v]
self.c[v]=u
return True
def size(self,x): return -self.c[self.find(x)]
class UFS:#秩+路径
def __init__(self,n):
self.parent=[i for i in range(n)]
self.ranks=[0]*n
def find(self,x):
if x!=self.parent[x]:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def union(self,u,v):
pu,pv=self.find(u),self.find(v)
if pu==pv:
return False
if self.ranks[pu]>=self.ranks[pv]:
self.parent[pv]=pu
if self.ranks[pv]==self.ranks[pu]:
self.ranks[pu]+=1
else:
self.parent[pu]=pv
def Prime(n):
c=0
prime=[]
flag=[0]*(n+1)
for i in range(2,n+1):
if not flag[i]:
prime.append(i)
c+=1
for j in range(c):
if i*prime[j]>n: break
flag[i*prime[j]]=prime[j]
if i%prime[j]==0: break
return prime
def dij(s,graph):
d={}
d[s]=0
heap=[(0,s)]
seen=set()
while heap:
dis,u=heappop(heap)
if u in seen:
continue
seen.add(u)
for v,w in graph[u]:
if v not in d or d[v]>d[u]+w:
d[v]=d[u]+w
heappush(heap,(d[v],v))
return d
def GP(it): return [[ch,len(list(g))] for ch,g in groupby(it)]
def lcm(a,b): return a*b//gcd(a,b)
def lis(nums):
res=[]
for k in nums:
i=bisect.bisect_left(res,k)
if i==len(res):
res.append(k)
else:
res[i]=k
return len(res)
class DLN:
def __init__(self,val):
self.val=val
self.pre=None
self.next=None
def nb(i,j):
for ni,nj in [[i+1,j],[i-1,j],[i,j-1],[i,j+1]]:
if 0<=ni<n and 0<=nj<m:
yield ni,nj
def topo(n):
q=deque()
res=[]
for i in range(1,n+1):
if ind[i]==0:
q.append(i)
res.append(i)
while q:
u=q.popleft()
for v in g[u]:
ind[v]-=1
if ind[v]==0:
q.append(v)
res.append(v)
return res
@bootstrap
def gdfs(r,p):
if len(g[r])==1 and p!=-1:
yield None
for ch in g[r]:
if ch!=p:
yield gdfs(ch,r)
yield None
def judge(a):
res=[0]
n=len(a)
f=True
for x in a:
res.append(x-res[-1])
#print(res)
if res[-1]<0:
f=False
break
if f:
#print(a,res)
return 1
for i in range(n-1):
a[i],a[i+1]=a[i+1],a[i]
res=[0]
f=True
for x in a:
res.append(x-res[-1])
if res[-1]<0:
f=False
break
if f:
print(a,res)
a[i],a[i+1]=a[i+1],a[i]
return 1
a[i],a[i+1]=a[i+1],a[i]
return 0
from random import randint
def build(n):
f=False
while not f:
a=[]
for i in range(n-1):
a.append(randint(1,10))
x=0
for i in range(n-1):
x=a[i]-x
a.append(x)
if a[-1]>0:
f=True
return a
t=N()
for i in range(t):
n=N()
a=RLL()
#a.sort()
s=0
res=[]
pre=[0]
for i in range(n):
if i&1:
res.append(-a[i])
else:
res.append(a[i])
pre.append(a[i]-pre[-1])
s=pre[-1]
ans=False
#print(res,s)
mi=[0]*n
for i in range(n-1,-1,-1):
if i==n-1:
mi[i]=pre[-1]
elif i==n-2:
mi[i]=pre[-2]
else:
mi[i]=min(mi[i+2],pre[i+1])
if s==0:
if all(x>=0 for x in pre):
ans=True
else:
for i in range(n-1):
cur=a[i]-a[i+1] if not (n-1-i)&1 else a[i+1]-a[i]
if s-2*cur==0:
if a[i+1]-pre[i]>=0 and a[i]-a[i+1]+pre[i]>=0:
if (i>=n-2 or mi[i+2]>=2*(a[i]-a[i+1])) and (i>=n-3 or mi[i+3]>=2*(a[i+1]-a[i])):
ans=True
break
if pre[i+1]<0:
break
ans='YES' if ans else "NO"
print(ans)
'''
sys.setrecursionlimit(200000)
import threading
threading.stack_size(10**8)
t=threading.Thread(target=main)
t.start()
t.join()
'''
'''
sys.setrecursionlimit(200000)
import threading
threading.stack_size(10**8)
t=threading.Thread(target=main)
t.start()
t.join()
'''
```
| 14,386 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During cleaning the coast, Alice found n piles of stones. The i-th pile has a_i stones.
Piles i and i + 1 are neighbouring for all 1 ≤ i ≤ n - 1. If pile i becomes empty, piles i - 1 and i + 1 doesn't become neighbouring.
Alice is too lazy to remove these stones, so she asked you to take this duty. She allowed you to do only the following operation:
* Select two neighboring piles and, if both of them are not empty, remove one stone from each of them.
Alice understands that sometimes it's impossible to remove all stones with the given operation, so she allowed you to use the following superability:
* Before the start of cleaning, you can select two neighboring piles and swap them.
Determine, if it is possible to remove all stones using the superability not more than once.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of piles.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the number of stones in each pile.
It is guaranteed that the total sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print YES or NO — is it possible to remove all stones using the superability not more than once or not.
Example
Input
5
3
1 2 1
3
1 1 2
5
2 2 2 1 3
5
2100 1900 1600 3000 1600
2
2443 2445
Output
YES
YES
YES
YES
NO
Note
In the first test case, you can remove all stones without using a superability: [1, 2, 1] → [1, 1, 0] → [0, 0, 0].
In the second test case, you can apply superability to the second and the third piles and then act like in the first testcase.
In the third test case, you can apply superability to the fourth and the fifth piles, thus getting a = [2, 2, 2, 3, 1].
In the fourth test case, you can apply superability to the first and the second piles, thus getting a = [1900, 2100, 1600, 3000, 1600].
Tags: data structures, dp, greedy, math
Correct Solution:
```
import sys;input=sys.stdin.readline
T, = map(int, input().split())
for _ in range(T):
N, = map(int, input().split())
X = list(map(int, input().split()))
l = [-1] * N
b = 0
f = 1
for i in range(N):
x = X[i]
if b > x:
f = 0
break
b = x-b
l[i] = b
if f and b == 0:
print("YES")
continue
l2 = [-1]*N
b = 0
for i in range(N-1, -1, -1):
x = X[i]
if b > x:
break
b = x-b
l2[i] = b
f = 0
for i in range(N-1):
c, b = X[i], X[i+1]
if i==0:
a = 0
else:
a = l[i-1]
if i==N-2:
d=0
else:
d = l2[i+2]
if a==-1 or d==-1:
continue
if b-a==c-d and b>=a:
print("YES")
f=1
break
if not f:
print("NO")
```
| 14,387 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During cleaning the coast, Alice found n piles of stones. The i-th pile has a_i stones.
Piles i and i + 1 are neighbouring for all 1 ≤ i ≤ n - 1. If pile i becomes empty, piles i - 1 and i + 1 doesn't become neighbouring.
Alice is too lazy to remove these stones, so she asked you to take this duty. She allowed you to do only the following operation:
* Select two neighboring piles and, if both of them are not empty, remove one stone from each of them.
Alice understands that sometimes it's impossible to remove all stones with the given operation, so she allowed you to use the following superability:
* Before the start of cleaning, you can select two neighboring piles and swap them.
Determine, if it is possible to remove all stones using the superability not more than once.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of piles.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the number of stones in each pile.
It is guaranteed that the total sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print YES or NO — is it possible to remove all stones using the superability not more than once or not.
Example
Input
5
3
1 2 1
3
1 1 2
5
2 2 2 1 3
5
2100 1900 1600 3000 1600
2
2443 2445
Output
YES
YES
YES
YES
NO
Note
In the first test case, you can remove all stones without using a superability: [1, 2, 1] → [1, 1, 0] → [0, 0, 0].
In the second test case, you can apply superability to the second and the third piles and then act like in the first testcase.
In the third test case, you can apply superability to the fourth and the fifth piles, thus getting a = [2, 2, 2, 3, 1].
In the fourth test case, you can apply superability to the first and the second piles, thus getting a = [1900, 2100, 1600, 3000, 1600].
Tags: data structures, dp, greedy, math
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
a = [int(x) for x in input().split()]
suok = [True]
sulft = [0]
for i in range(n - 1, -1, -1):
if not suok[-1] or a[i] < sulft[-1]:
suok.append(False)
sulft.append(0)
else:
suok.append(True)
sulft.append(a[i] - sulft[-1])
a.append(0)
suok = suok[::-1]
sulft = sulft[::-1]
if suok[0] and sulft[0] == 0:
print("YES")
continue
prlft = 0
win = False
for i in range(n - 1):
a[i], a[i + 1] = a[i + 1], a[i]
if suok[i + 2] and a[i] >= prlft and a[i + 1] >= (a[i] - prlft) and a[i + 1] - (a[i] - prlft) == sulft[i + 2]:
win = True
break
a[i], a[i + 1] = a[i + 1], a[i]
if a[i] < prlft:
break
prlft = a[i] - prlft
print("YES" if win else "NO")
```
| 14,388 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During cleaning the coast, Alice found n piles of stones. The i-th pile has a_i stones.
Piles i and i + 1 are neighbouring for all 1 ≤ i ≤ n - 1. If pile i becomes empty, piles i - 1 and i + 1 doesn't become neighbouring.
Alice is too lazy to remove these stones, so she asked you to take this duty. She allowed you to do only the following operation:
* Select two neighboring piles and, if both of them are not empty, remove one stone from each of them.
Alice understands that sometimes it's impossible to remove all stones with the given operation, so she allowed you to use the following superability:
* Before the start of cleaning, you can select two neighboring piles and swap them.
Determine, if it is possible to remove all stones using the superability not more than once.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of piles.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the number of stones in each pile.
It is guaranteed that the total sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print YES or NO — is it possible to remove all stones using the superability not more than once or not.
Example
Input
5
3
1 2 1
3
1 1 2
5
2 2 2 1 3
5
2100 1900 1600 3000 1600
2
2443 2445
Output
YES
YES
YES
YES
NO
Note
In the first test case, you can remove all stones without using a superability: [1, 2, 1] → [1, 1, 0] → [0, 0, 0].
In the second test case, you can apply superability to the second and the third piles and then act like in the first testcase.
In the third test case, you can apply superability to the fourth and the fifth piles, thus getting a = [2, 2, 2, 3, 1].
In the fourth test case, you can apply superability to the first and the second piles, thus getting a = [1900, 2100, 1600, 3000, 1600].
Tags: data structures, dp, greedy, math
Correct Solution:
```
#!/usr/bin/env python3
import sys, getpass
import math, random
import functools, itertools, collections, heapq, bisect
from collections import Counter, defaultdict, deque
input = sys.stdin.readline # to read input quickly
# available on Google, AtCoder Python3, not available on Codeforces
# import numpy as np
# import scipy
M9 = 10**9 + 7 # 998244353
# d4 = [(1,0),(0,1),(-1,0),(0,-1)]
# d8 = [(1,0),(1,1),(0,1),(-1,1),(-1,0),(-1,-1),(0,-1),(1,-1)]
# d6 = [(2,0),(1,1),(-1,1),(-2,0),(-1,-1),(1,-1)] # hexagonal layout
MAXINT = sys.maxsize
# if testing locally, print to terminal with a different color
OFFLINE_TEST = getpass.getuser() == "hkmac"
# OFFLINE_TEST = False # codechef does not allow getpass
def log(*args):
if OFFLINE_TEST:
print('\033[36m', *args, '\033[0m', file=sys.stderr)
def solve(*args):
# screen input
if OFFLINE_TEST:
log("----- solving ------")
log(*args)
log("----- ------- ------")
return solve_(*args)
def read_matrix(rows):
return [list(map(int,input().split())) for _ in range(rows)]
def read_strings(rows):
return [input().strip() for _ in range(rows)]
# ---------------------------- template ends here ----------------------------
def check(lst):
remainder = lst[0]
for x in lst[1:]:
remainder = x - remainder
if remainder < 0:
return False
else: # ok without swap
if remainder == 0:
return True
return False
def remainder_arr(lst):
remainder = lst[0]
remainders = [0,lst[0]]
faulty = False
for x in lst[1:]:
remainder = x - remainder
if faulty:
remainder = -1
remainders.append(remainder)
if remainder < 0:
faulty = True
return remainders
def solve_(arr, reverse=False):
# sweep, if cannot, replace
if check(arr):
log("no swap")
return "YES"
remainder = arr[0]
for i,x in enumerate(arr[1:], start=1):
remainder = x - remainder
if remainder < 0:
# swap with either before or after
arr[i], arr[i-1] = arr[i-1], arr[i]
if check(arr):
log("left swap")
return "YES"
arr[i], arr[i-1] = arr[i-1], arr[i]
break
arr[-2], arr[-1] = arr[-1], arr[-2]
if check(arr):
log("end swap")
return "YES"
arr[-2], arr[-1] = arr[-1], arr[-2]
xrr = remainder_arr(arr)
yrr = remainder_arr(arr[::-1])[::-1]
log(xrr)
log(yrr)
remainder = 0
# if I swap, what is the remainder
for i,(x,y) in enumerate(zip(arr, arr[1:])):
if x-remainder > y: # must swap, would have swapped
break
new_remainder = x-(y-remainder)
log(x,y,new_remainder,yrr[i+2])
if new_remainder >= 0 and yrr[i+2] == new_remainder:
arr[i], arr[i+1] = arr[i+1], arr[i]
if check(arr):
log("advanced swap")
return "YES"
arr[i], arr[i+1] = arr[i+1], arr[i]
remainder = x-remainder
# log(remainder, "r")
if not reverse:
log("reversing")
return solve_(arr[::-1], reverse=True)
return "NO"
# for case_num in [0]: # no loop over test case
# for case_num in range(100): # if the number of test cases is specified
for case_num in range(int(input())):
# read line as an integer
k = int(input())
# read line as a string
# srr = input().strip()
# read one line and parse each word as a string
# lst = input().split()
# read one line and parse each word as an integer
# a,b,c = list(map(int,input().split()))
lst = list(map(int,input().split()))
# read multiple rows
# mrr = read_matrix(k) # and return as a list of list of int
# arr = read_strings(k) # and return as a list of str
res = solve(lst) # include input here
# print result
# Google and Facebook - case number required
# print("Case #{}: {}".format(case_num+1, res))
# Other platforms - no case number required
print(res)
# print(len(res))
# print(*res) # print a list with elements
# for r in res: # print each list in a different line
# print(res)
# print(*res)
```
| 14,389 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During cleaning the coast, Alice found n piles of stones. The i-th pile has a_i stones.
Piles i and i + 1 are neighbouring for all 1 ≤ i ≤ n - 1. If pile i becomes empty, piles i - 1 and i + 1 doesn't become neighbouring.
Alice is too lazy to remove these stones, so she asked you to take this duty. She allowed you to do only the following operation:
* Select two neighboring piles and, if both of them are not empty, remove one stone from each of them.
Alice understands that sometimes it's impossible to remove all stones with the given operation, so she allowed you to use the following superability:
* Before the start of cleaning, you can select two neighboring piles and swap them.
Determine, if it is possible to remove all stones using the superability not more than once.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of piles.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the number of stones in each pile.
It is guaranteed that the total sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print YES or NO — is it possible to remove all stones using the superability not more than once or not.
Example
Input
5
3
1 2 1
3
1 1 2
5
2 2 2 1 3
5
2100 1900 1600 3000 1600
2
2443 2445
Output
YES
YES
YES
YES
NO
Note
In the first test case, you can remove all stones without using a superability: [1, 2, 1] → [1, 1, 0] → [0, 0, 0].
In the second test case, you can apply superability to the second and the third piles and then act like in the first testcase.
In the third test case, you can apply superability to the fourth and the fifth piles, thus getting a = [2, 2, 2, 3, 1].
In the fourth test case, you can apply superability to the first and the second piles, thus getting a = [1900, 2100, 1600, 3000, 1600].
Tags: data structures, dp, greedy, math
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO,IOBase
from math import inf
def solve(n,a):
x = a[:]
for i in range(1,n):
a[i] -= a[i-1]
val = a[-1]
if not val:
return 'NO' if min(a)<0 else 'YES'
if abs(a[-1])&1:
return 'NO'
mini = [a[-1],a[-2]]
for i in range(-3,-n-1,-1):
mini.append(min(mini[-2],a[i]))
mini.reverse()
mini.append(inf)
for i in range(n-1):
if (n-1-i)&1:
if (x[i] == x[i+1]-val//2 and mini[i+2] >= -val
and mini[i+1] >= val and a[i] >= -val//2):
return 'YES'
else:
if (x[i] == x[i+1]+val//2 and mini[i+2] >= val
and mini[i+1] >= -val and a[i] >= val//2):
return 'YES'
if a[i] < 0:
break
return 'NO'
def main():
for _ in range(int(input())):
n = int(input())
a = list(map(int,input().split()))
print(solve(n,a))
#Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == '__main__':
main()
```
| 14,390 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During cleaning the coast, Alice found n piles of stones. The i-th pile has a_i stones.
Piles i and i + 1 are neighbouring for all 1 ≤ i ≤ n - 1. If pile i becomes empty, piles i - 1 and i + 1 doesn't become neighbouring.
Alice is too lazy to remove these stones, so she asked you to take this duty. She allowed you to do only the following operation:
* Select two neighboring piles and, if both of them are not empty, remove one stone from each of them.
Alice understands that sometimes it's impossible to remove all stones with the given operation, so she allowed you to use the following superability:
* Before the start of cleaning, you can select two neighboring piles and swap them.
Determine, if it is possible to remove all stones using the superability not more than once.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of piles.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the number of stones in each pile.
It is guaranteed that the total sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print YES or NO — is it possible to remove all stones using the superability not more than once or not.
Example
Input
5
3
1 2 1
3
1 1 2
5
2 2 2 1 3
5
2100 1900 1600 3000 1600
2
2443 2445
Output
YES
YES
YES
YES
NO
Note
In the first test case, you can remove all stones without using a superability: [1, 2, 1] → [1, 1, 0] → [0, 0, 0].
In the second test case, you can apply superability to the second and the third piles and then act like in the first testcase.
In the third test case, you can apply superability to the fourth and the fifth piles, thus getting a = [2, 2, 2, 3, 1].
In the fourth test case, you can apply superability to the first and the second piles, thus getting a = [1900, 2100, 1600, 3000, 1600].
Tags: data structures, dp, greedy, math
Correct Solution:
```
from sys import stdin, stdout
from collections import defaultdict
import math
def main():
t = int(stdin.readline())
for tt in range(1, t+1):
n = int(stdin.readline())
arr = list(map(int, stdin.readline().split()))
dp_l = [-1 for _ in range(n)]
dp_l[0] = arr[0]
for i in range(1, n):
dp_l[i] = arr[i] - dp_l[i - 1]
if dp_l[i] < 0:
break
dp_r = [-1 for _ in range(n)]
dp_r[n-1] = arr[n-1]
for i in range(n-2, -1, -1):
dp_r[i] = arr[i] - dp_r[i + 1]
if dp_r[i] < 0:
break
if dp_l[n-1] == 0:
stdout.write("YES\n")
continue
is_found = False
for i in range(n-1):
p = []
if i > 0:
if dp_l[i-1] < 0:
continue
p.append(dp_l[i-1])
p.append(arr[i+1])
p.append(arr[i])
if i < n-2:
if dp_r[i+2] < 0:
continue
p.append(dp_r[i+2])
sm = p[0]
for j in range(1, len(p)):
sm = p[j] - sm
if sm < 0:
break
if sm == 0:
is_found = True
break
if is_found:
stdout.write("YES\n")
else:
stdout.write("NO\n")
main()
```
| 14,391 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During cleaning the coast, Alice found n piles of stones. The i-th pile has a_i stones.
Piles i and i + 1 are neighbouring for all 1 ≤ i ≤ n - 1. If pile i becomes empty, piles i - 1 and i + 1 doesn't become neighbouring.
Alice is too lazy to remove these stones, so she asked you to take this duty. She allowed you to do only the following operation:
* Select two neighboring piles and, if both of them are not empty, remove one stone from each of them.
Alice understands that sometimes it's impossible to remove all stones with the given operation, so she allowed you to use the following superability:
* Before the start of cleaning, you can select two neighboring piles and swap them.
Determine, if it is possible to remove all stones using the superability not more than once.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of piles.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the number of stones in each pile.
It is guaranteed that the total sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print YES or NO — is it possible to remove all stones using the superability not more than once or not.
Example
Input
5
3
1 2 1
3
1 1 2
5
2 2 2 1 3
5
2100 1900 1600 3000 1600
2
2443 2445
Output
YES
YES
YES
YES
NO
Note
In the first test case, you can remove all stones without using a superability: [1, 2, 1] → [1, 1, 0] → [0, 0, 0].
In the second test case, you can apply superability to the second and the third piles and then act like in the first testcase.
In the third test case, you can apply superability to the fourth and the fifth piles, thus getting a = [2, 2, 2, 3, 1].
In the fourth test case, you can apply superability to the first and the second piles, thus getting a = [1900, 2100, 1600, 3000, 1600].
Tags: data structures, dp, greedy, math
Correct Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
s = [a[0]]
for i in range(1, n):
s.append(a[i] - s[-1])
mi0 = mi1 = 10**16
# Suffix min of s
# Based on parity of index
mia0 = []
mia1 = []
for i in range(n - 1, -1, -1):
v = s[i]
if i % 2 == 0:
mi0 = min(mi0, v)
else:
mi1 = min(mi1, v)
mia0.append(mi0)
mia1.append(mi1)
mia0.reverse()
mia1.reverse()
mia0.append(10**16)
mia1.append(10**16)
if min(mi0, mi1) >= 0 and s[-1] == 0:
# No superability
print("YES")
else:
poss = False
# Try all superabilities (O(n))
for i in range(n - 1):
# Difference from swapping the elements
# Alternating positive and negative
dv = -2 * (a[i] - a[i + 1])
# New value of the end
if (i % 2 == 0) == (n % 2 == 0):
ne = s[-1] - dv
else:
ne = s[-1] + dv
# If the end would become 0
if ne == 0:
# choose which min to subtract from / add to
if i % 2 == 1:
if mia0[i] - dv >= 0 and min(mia1[i + 1] + dv, s[i] + dv // 2) >= 0:
poss = True
break
else:
if mia1[i] - dv >= 0 and min(mia0[i + 1] + dv, s[i] + dv // 2) >= 0:
poss = True
break
if s[i] < 0:
break
print("YES" if poss else "NO")
```
| 14,392 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
During cleaning the coast, Alice found n piles of stones. The i-th pile has a_i stones.
Piles i and i + 1 are neighbouring for all 1 ≤ i ≤ n - 1. If pile i becomes empty, piles i - 1 and i + 1 doesn't become neighbouring.
Alice is too lazy to remove these stones, so she asked you to take this duty. She allowed you to do only the following operation:
* Select two neighboring piles and, if both of them are not empty, remove one stone from each of them.
Alice understands that sometimes it's impossible to remove all stones with the given operation, so she allowed you to use the following superability:
* Before the start of cleaning, you can select two neighboring piles and swap them.
Determine, if it is possible to remove all stones using the superability not more than once.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of piles.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the number of stones in each pile.
It is guaranteed that the total sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print YES or NO — is it possible to remove all stones using the superability not more than once or not.
Example
Input
5
3
1 2 1
3
1 1 2
5
2 2 2 1 3
5
2100 1900 1600 3000 1600
2
2443 2445
Output
YES
YES
YES
YES
NO
Note
In the first test case, you can remove all stones without using a superability: [1, 2, 1] → [1, 1, 0] → [0, 0, 0].
In the second test case, you can apply superability to the second and the third piles and then act like in the first testcase.
In the third test case, you can apply superability to the fourth and the fifth piles, thus getting a = [2, 2, 2, 3, 1].
In the fourth test case, you can apply superability to the first and the second piles, thus getting a = [1900, 2100, 1600, 3000, 1600].
Submitted Solution:
```
import sys
input = sys.stdin.readline
for _ in range(int(input())):
N = int(input())
a = list(map(int, input().split()))
l = [-1] * N
l[0] = a[0]
for i in range(N - 1):
if l[i] >= 0: l[i + 1] = a[i + 1] - l[i]
r = [-1] * N
r[-1] = a[-1]
for i in range(N - 1, 0, -1):
if r[i] >= 0:r[i - 1] = a[i - 1] - r[i]
if l[-1] == r[0] == 0:
print("YES")
continue
for i in range(N - 1):
x, y, z, w = 0, a[i + 1], a[i], 0
if i - 1 >= 0: x = l[i - 1]
if i + 2 < N: w = r[i + 2]
if y - x == z - w and x >= 0 and w >= 0 and x <= y and w <= z:
print("YES")
break
else: print("NO")
```
Yes
| 14,393 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
During cleaning the coast, Alice found n piles of stones. The i-th pile has a_i stones.
Piles i and i + 1 are neighbouring for all 1 ≤ i ≤ n - 1. If pile i becomes empty, piles i - 1 and i + 1 doesn't become neighbouring.
Alice is too lazy to remove these stones, so she asked you to take this duty. She allowed you to do only the following operation:
* Select two neighboring piles and, if both of them are not empty, remove one stone from each of them.
Alice understands that sometimes it's impossible to remove all stones with the given operation, so she allowed you to use the following superability:
* Before the start of cleaning, you can select two neighboring piles and swap them.
Determine, if it is possible to remove all stones using the superability not more than once.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of piles.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the number of stones in each pile.
It is guaranteed that the total sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print YES or NO — is it possible to remove all stones using the superability not more than once or not.
Example
Input
5
3
1 2 1
3
1 1 2
5
2 2 2 1 3
5
2100 1900 1600 3000 1600
2
2443 2445
Output
YES
YES
YES
YES
NO
Note
In the first test case, you can remove all stones without using a superability: [1, 2, 1] → [1, 1, 0] → [0, 0, 0].
In the second test case, you can apply superability to the second and the third piles and then act like in the first testcase.
In the third test case, you can apply superability to the fourth and the fifth piles, thus getting a = [2, 2, 2, 3, 1].
In the fourth test case, you can apply superability to the first and the second piles, thus getting a = [1900, 2100, 1600, 3000, 1600].
Submitted Solution:
```
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
import threading
from bisect import bisect_left
from math import gcd,log
from collections import Counter
from pprint import pprint
MX=10**5
p=[i for i in range(MX)]
for i in range(2,MX):
if p[i]==i:
for j in range(i*i,MX,i):
p[j]=i
pm=[i for i in range(2,MX) if p[i]==i]
# print(pm[-1])
def main():
n=int(input())
arr=list(map(int,input().split()))
pref=[-1]*n
pref[0]=arr[0]
suf=[-1]*n
suf[-1]=arr[-1]
for i in range(1,n):
if pref[i-1]!=-1 and arr[i]>=pref[i-1]:
pref[i]=arr[i]-pref[i-1]
for i in range(n-2,-1,-1):
if suf[i+1]!=-1 and arr[i]>=suf[i+1]:
suf[i]=arr[i]-suf[i+1]
pref=[0]+pref
suf.append(0)
# print(pref)
# print(suf)
for i in range(n-1):
# print(pref[i],arr[i+1],arr[i],suf[i+2])
if pref[i]!=-1 and suf[i+2]!=-1:
if arr[i+1]>=pref[i] and arr[i]>=suf[i+2] and arr[i+1]-pref[i]==arr[i]-suf[i+2]:
print('YES')
return
if pref[i]==suf[i]==0:
print('YES')
return
print('NO')
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
for _ in range(int(input())):
main()
```
Yes
| 14,394 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
During cleaning the coast, Alice found n piles of stones. The i-th pile has a_i stones.
Piles i and i + 1 are neighbouring for all 1 ≤ i ≤ n - 1. If pile i becomes empty, piles i - 1 and i + 1 doesn't become neighbouring.
Alice is too lazy to remove these stones, so she asked you to take this duty. She allowed you to do only the following operation:
* Select two neighboring piles and, if both of them are not empty, remove one stone from each of them.
Alice understands that sometimes it's impossible to remove all stones with the given operation, so she allowed you to use the following superability:
* Before the start of cleaning, you can select two neighboring piles and swap them.
Determine, if it is possible to remove all stones using the superability not more than once.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of piles.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the number of stones in each pile.
It is guaranteed that the total sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print YES or NO — is it possible to remove all stones using the superability not more than once or not.
Example
Input
5
3
1 2 1
3
1 1 2
5
2 2 2 1 3
5
2100 1900 1600 3000 1600
2
2443 2445
Output
YES
YES
YES
YES
NO
Note
In the first test case, you can remove all stones without using a superability: [1, 2, 1] → [1, 1, 0] → [0, 0, 0].
In the second test case, you can apply superability to the second and the third piles and then act like in the first testcase.
In the third test case, you can apply superability to the fourth and the fifth piles, thus getting a = [2, 2, 2, 3, 1].
In the fourth test case, you can apply superability to the first and the second piles, thus getting a = [1900, 2100, 1600, 3000, 1600].
Submitted Solution:
```
def ke(x: list):
y = x.copy()
for i in range(0, len(y) - 1):
if y[i] > y[i + 1]:
return False
else:
y[i + 1] -= y[i]
y[i] = 0
if y[len(y) - 1] == 0:
return True
return False
t = int(input())
for cas in range(0, t):
n = int(input())
v = list(map(int, input().split()))
if ke(v):
print("YES")
continue
if n == 1:
print("NO")
continue
z = v.copy()
z[0], z[1] = z[1], z[0]
if ke(z):
print("YES")
continue
z = v.copy()
z[n - 2], z[n - 1] = z[n - 1], z[n - 2]
if ke(z):
print("YES")
continue
zuo = [0] * n
you = [0] * n
z = v.copy()
zuo[0] = v[0]
for i in range(0, n - 1):
if z[i] > z[i + 1]:
for j in range(i + 1, n):
zuo[j] = -1
break
else:
z[i + 1] -= z[i]
zuo[i + 1] = z[i + 1]
z[i] = 0
z = v.copy()
you[n - 1] = v[n - 1]
for i in range(n - 1, 0, -1):
if z[i] > z[i - 1]:
for j in range(i - 1, -1, -1):
you[j] = -1
break
else:
z[i - 1] -= z[i]
you[i - 1] = z[i - 1]
z[i] = 0
z = v.copy()
xing = 0
for i in range(1, n - 2):
if zuo[i - 1] != -1 and you[i + 2] != -1 and ke([zuo[i - 1], z[i + 1], z[i], you[i + 2]]):
xing = 1
print("YES")
break
if xing == 0:
print("NO")
```
Yes
| 14,395 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
During cleaning the coast, Alice found n piles of stones. The i-th pile has a_i stones.
Piles i and i + 1 are neighbouring for all 1 ≤ i ≤ n - 1. If pile i becomes empty, piles i - 1 and i + 1 doesn't become neighbouring.
Alice is too lazy to remove these stones, so she asked you to take this duty. She allowed you to do only the following operation:
* Select two neighboring piles and, if both of them are not empty, remove one stone from each of them.
Alice understands that sometimes it's impossible to remove all stones with the given operation, so she allowed you to use the following superability:
* Before the start of cleaning, you can select two neighboring piles and swap them.
Determine, if it is possible to remove all stones using the superability not more than once.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of piles.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the number of stones in each pile.
It is guaranteed that the total sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print YES or NO — is it possible to remove all stones using the superability not more than once or not.
Example
Input
5
3
1 2 1
3
1 1 2
5
2 2 2 1 3
5
2100 1900 1600 3000 1600
2
2443 2445
Output
YES
YES
YES
YES
NO
Note
In the first test case, you can remove all stones without using a superability: [1, 2, 1] → [1, 1, 0] → [0, 0, 0].
In the second test case, you can apply superability to the second and the third piles and then act like in the first testcase.
In the third test case, you can apply superability to the fourth and the fifth piles, thus getting a = [2, 2, 2, 3, 1].
In the fourth test case, you can apply superability to the first and the second piles, thus getting a = [1900, 2100, 1600, 3000, 1600].
Submitted Solution:
```
t=int(input())
for _ in range(t):
n=int(input())
b=list(map(int,input().split()))
fow=[0]
back=[0]
ind1=[]
ind2=[]
for j in range(n):
fow.append(b[j]-fow[-1])
if fow[-1]<0:
ind1.append(j)
back.append(b[n-1-j]-back[-1])
if back[-1]<0:
ind2.append(n-j-1)
fow.pop(0)
back.reverse()
back.pop()
pre=[j for j in back]
suf=[j for j in fow]
for j in range(n):
if j-2>=0:
pre[j]=min(pre[j],pre[j-2])
if n-j+1<n:
suf[n-j-1]=min(suf[n-j-1],suf[n-j+1])
poss=0
for j in range(n):
if j==0:
if fow[-1]==0 and ind1==[]:
poss=1
break
if back[0]==0 and ind2==[]:
poss=1
break
else:
pr=b[j]-b[j-1]
q=j%2
r=(n-1)%2
if q==r:
res1=fow[-1]-2*pr
else:
res1 = fow[-1] + 2*pr
if res1==0 and fow[j-1]+pr>=0 and suf[j]>=2*pr and (1 if ((j+1<n and suf[j+1]>=-2*pr)or(j+1>=n)) else 0):
if ind1==[]:
poss=1
break
else:
if ind1[0]>=j-1:
poss=1
break
r = 0
if q == r:
res1 = back[0] - 2 * pr
else:
res1 = back[0] + 2 * pr
if res1 == 0 and pre[j-1] >= -2 * pr and (back[j]-pr)>=0 and (1 if ((j-2>=0 and pre[j-2]>=2*pr)or(j-2<0)) else 0) :
if ind2 == []:
poss = 1
break
else:
if ind2[0] < j+1:
poss = 1
break
if poss:
print('YES')
else:
print("NO")
```
Yes
| 14,396 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
During cleaning the coast, Alice found n piles of stones. The i-th pile has a_i stones.
Piles i and i + 1 are neighbouring for all 1 ≤ i ≤ n - 1. If pile i becomes empty, piles i - 1 and i + 1 doesn't become neighbouring.
Alice is too lazy to remove these stones, so she asked you to take this duty. She allowed you to do only the following operation:
* Select two neighboring piles and, if both of them are not empty, remove one stone from each of them.
Alice understands that sometimes it's impossible to remove all stones with the given operation, so she allowed you to use the following superability:
* Before the start of cleaning, you can select two neighboring piles and swap them.
Determine, if it is possible to remove all stones using the superability not more than once.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of piles.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the number of stones in each pile.
It is guaranteed that the total sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print YES or NO — is it possible to remove all stones using the superability not more than once or not.
Example
Input
5
3
1 2 1
3
1 1 2
5
2 2 2 1 3
5
2100 1900 1600 3000 1600
2
2443 2445
Output
YES
YES
YES
YES
NO
Note
In the first test case, you can remove all stones without using a superability: [1, 2, 1] → [1, 1, 0] → [0, 0, 0].
In the second test case, you can apply superability to the second and the third piles and then act like in the first testcase.
In the third test case, you can apply superability to the fourth and the fifth piles, thus getting a = [2, 2, 2, 3, 1].
In the fourth test case, you can apply superability to the first and the second piles, thus getting a = [1900, 2100, 1600, 3000, 1600].
Submitted Solution:
```
test_count = int(input(""))
def check_sequence(piles_list, piles_in_test):
ability_used = False
r = 0
d = 0
possible = True
for i in range(piles_in_test):
x = piles_list[i]
# This does backwards swap
if ability_used == False:
if r > x:
ability_used = True
c = r + d
r = x - d
x = c
if r < 0:
possible = False
break
else:
x1 = 0 # get value if there is one
if i + 1 < piles_in_test:
x1 = piles_list[i+1]
x2 = 0 # get value if there is one
if i + 2 < piles_in_test:
x1 = piles_list[i+2]
x0 = r + d
r0 = x - d
if x - r + x2 < x1 and x0 - r0 + x2 >= x1:
ability_used = True
r = r0
x = x0
d = r
r = x - r
if r < 0:
possible = False
break
if r > 0:
possible = False
return possible
answer = "";
for test in range(0,test_count):
piles_in_test = int(input(""))
piles_list = list(map(int ,input("").split(" ")))
# check case of failure
if test == 147:
print(piles_list)
if piles_in_test < 2:
answer += "NO\n"
elif piles_in_test == 2:
if piles_list[0] != piles_list[1]:
answer += "NO\n"
else:
answer += "YES\n"
else:
possible = check_sequence(piles_list, piles_in_test)
#reverse check
if possible == False :
piles_list.reverse()
possible = check_sequence(piles_list, piles_in_test)
if possible == True:
answer += "YES\n"
else:
answer += "NO\n"
print(answer)
```
No
| 14,397 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
During cleaning the coast, Alice found n piles of stones. The i-th pile has a_i stones.
Piles i and i + 1 are neighbouring for all 1 ≤ i ≤ n - 1. If pile i becomes empty, piles i - 1 and i + 1 doesn't become neighbouring.
Alice is too lazy to remove these stones, so she asked you to take this duty. She allowed you to do only the following operation:
* Select two neighboring piles and, if both of them are not empty, remove one stone from each of them.
Alice understands that sometimes it's impossible to remove all stones with the given operation, so she allowed you to use the following superability:
* Before the start of cleaning, you can select two neighboring piles and swap them.
Determine, if it is possible to remove all stones using the superability not more than once.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of piles.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the number of stones in each pile.
It is guaranteed that the total sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print YES or NO — is it possible to remove all stones using the superability not more than once or not.
Example
Input
5
3
1 2 1
3
1 1 2
5
2 2 2 1 3
5
2100 1900 1600 3000 1600
2
2443 2445
Output
YES
YES
YES
YES
NO
Note
In the first test case, you can remove all stones without using a superability: [1, 2, 1] → [1, 1, 0] → [0, 0, 0].
In the second test case, you can apply superability to the second and the third piles and then act like in the first testcase.
In the third test case, you can apply superability to the fourth and the fifth piles, thus getting a = [2, 2, 2, 3, 1].
In the fourth test case, you can apply superability to the first and the second piles, thus getting a = [1900, 2100, 1600, 3000, 1600].
Submitted Solution:
```
from sys import stdin
def check(a, n):
for i in range(1, n):
if a[i] >= a[i - 1]:
a[i] -= a[i - 1]
a[i - 1] = 0
else: return i
if a[n - 1] != 0: return n - 1
return 0
for _ in range(int(input())):
n = int(input())
a = list(map(int, stdin.readline().strip().split()))
a1 = a.copy()
a2 = a.copy()
c = check(a, n)
if c:
if c == n - 1:
a1[c], a1[c - 1] = a1[c - 1], a1[c]
c1 = check(a1, n)
if c1: print("NO")
else: print("YES")
else:
a1[c], a1[c - 1] = a1[c - 1], a1[c]
a2[c], a2[c + 1] = a2[c + 1], a2[c]
c1 = check(a1, n)
c2 = check(a2, n)
if c1 and c2: print("NO")
else: print("YES")
else: print("YES")
```
No
| 14,398 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
During cleaning the coast, Alice found n piles of stones. The i-th pile has a_i stones.
Piles i and i + 1 are neighbouring for all 1 ≤ i ≤ n - 1. If pile i becomes empty, piles i - 1 and i + 1 doesn't become neighbouring.
Alice is too lazy to remove these stones, so she asked you to take this duty. She allowed you to do only the following operation:
* Select two neighboring piles and, if both of them are not empty, remove one stone from each of them.
Alice understands that sometimes it's impossible to remove all stones with the given operation, so she allowed you to use the following superability:
* Before the start of cleaning, you can select two neighboring piles and swap them.
Determine, if it is possible to remove all stones using the superability not more than once.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains the single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of piles.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the number of stones in each pile.
It is guaranteed that the total sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print YES or NO — is it possible to remove all stones using the superability not more than once or not.
Example
Input
5
3
1 2 1
3
1 1 2
5
2 2 2 1 3
5
2100 1900 1600 3000 1600
2
2443 2445
Output
YES
YES
YES
YES
NO
Note
In the first test case, you can remove all stones without using a superability: [1, 2, 1] → [1, 1, 0] → [0, 0, 0].
In the second test case, you can apply superability to the second and the third piles and then act like in the first testcase.
In the third test case, you can apply superability to the fourth and the fifth piles, thus getting a = [2, 2, 2, 3, 1].
In the fourth test case, you can apply superability to the first and the second piles, thus getting a = [1900, 2100, 1600, 3000, 1600].
Submitted Solution:
```
import io
import os
from collections import Counter, defaultdict, deque
from math import inf
# https://raw.githubusercontent.com/cheran-senthil/PyRival/master/pyrival/data_structures/SegmentTree.py
class SegmentTree:
def __init__(self, data, default=0, func=max):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size : _size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
"""func of data[start, stop)"""
start += self._size
stop += self._size
res_left = res_right = self._default
while start < stop:
if start & 1:
res_left = self._func(res_left, self.data[start])
start += 1
if stop & 1:
stop -= 1
res_right = self._func(self.data[stop], res_right)
start >>= 1
stop >>= 1
return self._func(res_left, res_right)
def __repr__(self):
return "SegmentTree({0})".format(self.data)
class Node:
def __init__(self, minEven, maxEven, minOdd, maxOdd, total, count):
self.minEven = minEven
self.maxEven = maxEven
self.minOdd = minOdd
self.maxOdd = maxOdd
self.total = total
self.count = count
def __repr__(self):
return str(
(
self.minEven,
self.maxEven,
self.minOdd,
self.maxOdd,
self.total,
self.count,
)
)
segDefault = Node(inf, -inf, inf, -inf, 0, 0)
def segMap(x, i):
if i % 2 == 1:
x *= -1
return Node(x, x, inf, -inf, x, 1)
def segCombine(l, r):
if l.count == 0:
return r
if r.count == 0:
return l
if l.count % 2 == 0:
minEven = min(l.minEven, l.total + r.minEven)
maxEven = max(l.maxEven, l.total + r.maxEven)
minOdd = min(l.minOdd, l.total + r.minOdd)
maxOdd = max(l.maxOdd, l.total + r.maxOdd)
else:
minEven = min(l.minEven, l.total + r.minOdd)
maxEven = max(l.maxEven, l.total + r.maxOdd)
minOdd = min(l.minOdd, l.total + r.minEven)
maxOdd = max(l.maxOdd, l.total + r.maxEven)
total = l.total + r.total
count = l.count + r.count
return Node(minEven, maxEven, minOdd, maxOdd, total, count)
def solve(N, A):
def makeOps(A):
needed = []
extra = 0
for x in A:
extra = x - extra
needed.append(extra)
return needed
needed = makeOps(A)
if needed[-1] == 0 and min(needed) >= 0:
return "YES"
segTree = SegmentTree(
[segMap(x, i) for i, x in enumerate(A)], segDefault, segCombine,
)
for i in range(N - 1):
if A[i] == A[i + 1]:
continue
segTree[i] = segMap(A[i + 1], i)
segTree[i + 1] = segMap(A[i], i + 1)
res = segTree.query(0, N)
if False:
A[i], A[i + 1] = A[i + 1], A[i]
pref = [0]
for j, x in enumerate(A):
if j % 2 == 0:
pref.append(pref[-1] + x)
else:
pref.append(pref[-1] - x)
for j in range(N + 1):
check = segmentTree.query(0, j)
evens = pref[1 : j + 1 : 2]
odds = pref[2 : j + 1 : 2]
assert check.total == pref[j]
assert check.minEven == min(evens, default=inf)
assert check.maxEven == max(evens, default=-inf)
assert check.minOdd == min(odds, default=inf)
assert check.maxOdd == max(odds, default=-inf)
A[i], A[i + 1] = A[i + 1], A[i]
if (N - 1) % 2 == 0:
if res.total == 0 and res.minEven >= 0 and -res.maxOdd >= 0:
return "YES"
else:
if res.total == 0 and res.minOdd >= 0 and -res.maxEven >= 0:
return "YES"
segTree[i] = segMap(A[i], i)
segTree[i + 1] = segMap(A[i + 1], i + 1)
return "NO"
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
TC = int(input())
for tc in range(1, TC + 1):
(N,) = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
ans = solve(N, A)
print(ans)
```
No
| 14,399 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.