text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Submitted Solution:
```
# *-* coding=utf-8 *-*
input()
s = input()
ans = 0
l = list(s)
for i in range(len(l)//2):
if l[2*i-1] == l[2*i]:
ans += 1
if l[2*i] == 'a': l[2*i] = 'b'
else: l[2*i] = 'a'
print(ans, ''.join(l), sep='\n')
```
No
| 86,700 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Submitted Solution:
```
import sys
n = int(sys.stdin.readline())
string1 = list(sys.stdin.readline().strip())
string2 = string1[:]
cnt_1 = 0
cnt_2 = 0
for i in range(n):
if i % 2 != 0 and string1[i] == 'a': # ab
# print("call1")
cnt_1 += 1
string1[i] = 'b'
elif i % 2 == 0 and string1[i] == 'b':
# print("call2")
cnt_1 += 1
string1[i] = 'a'
for j in range(n): # ba
if j % 2 != 0 and string2[j] == 'b':
# print("call3")
cnt_2 += 1
string2[j] = 'a'
elif j % 2 == 0 and string2[j] == 'a':
# print("call4")
cnt_2 += 1
string2[j] = 'b'
if cnt_1 >= cnt_2:
print(cnt_2)
for i in string2:
print(i, end='')
else:
print(cnt_1)
for j in string1:
print(j, end='')
```
No
| 86,701 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Submitted Solution:
```
if __name__ == '__main__':
n = int(input())
txt = list(input())
print(2)
print('abab')
```
No
| 86,702 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikolay got a string s of even length n, which consists only of lowercase Latin letters 'a' and 'b'. Its positions are numbered from 1 to n.
He wants to modify his string so that every its prefix of even length has an equal amount of letters 'a' and 'b'. To achieve that, Nikolay can perform the following operation arbitrary number of times (possibly, zero): choose some position in his string and replace the letter on this position with the other letter (i.e. replace 'a' with 'b' or replace 'b' with 'a'). Nikolay can use no letters except 'a' and 'b'.
The prefix of string s of length l (1 ≤ l ≤ n) is a string s[1..l].
For example, for the string s="abba" there are two prefixes of the even length. The first is s[1...2]="ab" and the second s[1...4]="abba". Both of them have the same number of 'a' and 'b'.
Your task is to calculate the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
Input
The first line of the input contains one even integer n (2 ≤ n ≤ 2⋅10^{5}) — the length of string s.
The second line of the input contains the string s of length n, which consists only of lowercase Latin letters 'a' and 'b'.
Output
In the first line print the minimum number of operations Nikolay has to perform with the string s to modify it so that every its prefix of even length has an equal amount of letters 'a' and 'b'.
In the second line print the string Nikolay obtains after applying all the operations. If there are multiple answers, you can print any of them.
Examples
Input
4
bbbb
Output
2
abba
Input
6
ababab
Output
0
ababab
Input
2
aa
Output
1
ba
Note
In the first example Nikolay has to perform two operations. For example, he can replace the first 'b' with 'a' and the last 'b' with 'a'.
In the second example Nikolay doesn't need to do anything because each prefix of an even length of the initial string already contains an equal amount of letters 'a' and 'b'.
Submitted Solution:
```
n = int(input())
s = input()
a = [x for x in s]
res = 0
if a[0] == 'a':
for i in range(1, n):
if i % 2 == 1:
if a[i] == 'a':
res += 1
a[i] = 'b'
else:
if a[i] == 'b':
res += 1
a[i] = 'a'
else:
for i in range(1, n):
if i % 2 == 1:
if a[i] == 'b':
res += 1
a[i] = 'a'
else:
if a[i] == 'a':
res += 1
a[i] = 'b'
print(res)
for x in a:
print(x, end="")
```
No
| 86,703 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is a harder version of the problem. In this version, n ≤ 300 000.
Vasya is an experienced developer of programming competitions' problems. As all great minds at some time, Vasya faced a creative crisis. To improve the situation, Petya gifted him a string consisting of opening and closing brackets only. Petya believes, that the beauty of the bracket string is a number of its cyclical shifts, which form a correct bracket sequence.
To digress from his problems, Vasya decided to select two positions of the string (not necessarily distinct) and swap characters located at this positions with each other. Vasya will apply this operation exactly once. He is curious what is the maximum possible beauty he can achieve this way. Please help him.
We remind that bracket sequence s is called correct if:
* s is empty;
* s is equal to "(t)", where t is correct bracket sequence;
* s is equal to t_1 t_2, i.e. concatenation of t_1 and t_2, where t_1 and t_2 are correct bracket sequences.
For example, "(()())", "()" are correct, while ")(" and "())" are not.
The cyclical shift of the string s of length n by k (0 ≤ k < n) is a string formed by a concatenation of the last k symbols of the string s with the first n - k symbols of string s. For example, the cyclical shift of string "(())()" by 2 equals "()(())".
Cyclical shifts i and j are considered different, if i ≠ j.
Input
The first line contains an integer n (1 ≤ n ≤ 300 000), the length of the string.
The second line contains a string, consisting of exactly n characters, where each of the characters is either "(" or ")".
Output
The first line should contain a single integer — the largest beauty of the string, which can be achieved by swapping some two characters.
The second line should contain integers l and r (1 ≤ l, r ≤ n) — the indices of two characters, which should be swapped in order to maximize the string's beauty.
In case there are several possible swaps, print any of them.
Examples
Input
10
()()())(()
Output
5
8 7
Input
12
)(()(()())()
Output
4
5 10
Input
6
)))(()
Output
0
1 1
Note
In the first example, we can swap 7-th and 8-th character, obtaining a string "()()()()()". The cyclical shifts by 0, 2, 4, 6, 8 of this string form a correct bracket sequence.
In the second example, after swapping 5-th and 10-th character, we obtain a string ")(())()()(()". The cyclical shifts by 11, 7, 5, 3 of this string form a correct bracket sequence.
In the third example, swap of any two brackets results in 0 cyclical shifts being correct bracket sequences.
Tags: implementation
Correct Solution:
```
n = int(input())
seq = list(input())
def get_comps(seq):
depth = 0
components = 0
lookingfor = 0
for i in range(n):
if seq[i] == "(":
depth += 1
else:
depth -= 1
if depth < lookingfor:
lookingfor = depth
components = 1
elif depth == lookingfor:
components += 1
return components
def other(x):
if x == "(":
return ")"
return "("
if n%2 == 1 or seq.count("(") != seq.count(")"):
print(0)
print(1,1)
else:
best1 = 1
best2 = 1
bestVal = get_comps(seq)
for i in range(n):
for j in range(i+1,n):
if seq[i] != seq[j]:
seq[i] = other(seq[i])
seq[j] = other(seq[j])
val = get_comps(seq)
if val > bestVal:
best1 = i
best2 = j
bestVal = val
seq[i] = other(seq[i])
seq[j] = other(seq[j])
print(bestVal)
print(best1+1,best2+1)
```
| 86,704 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is a harder version of the problem. In this version, n ≤ 300 000.
Vasya is an experienced developer of programming competitions' problems. As all great minds at some time, Vasya faced a creative crisis. To improve the situation, Petya gifted him a string consisting of opening and closing brackets only. Petya believes, that the beauty of the bracket string is a number of its cyclical shifts, which form a correct bracket sequence.
To digress from his problems, Vasya decided to select two positions of the string (not necessarily distinct) and swap characters located at this positions with each other. Vasya will apply this operation exactly once. He is curious what is the maximum possible beauty he can achieve this way. Please help him.
We remind that bracket sequence s is called correct if:
* s is empty;
* s is equal to "(t)", where t is correct bracket sequence;
* s is equal to t_1 t_2, i.e. concatenation of t_1 and t_2, where t_1 and t_2 are correct bracket sequences.
For example, "(()())", "()" are correct, while ")(" and "())" are not.
The cyclical shift of the string s of length n by k (0 ≤ k < n) is a string formed by a concatenation of the last k symbols of the string s with the first n - k symbols of string s. For example, the cyclical shift of string "(())()" by 2 equals "()(())".
Cyclical shifts i and j are considered different, if i ≠ j.
Input
The first line contains an integer n (1 ≤ n ≤ 300 000), the length of the string.
The second line contains a string, consisting of exactly n characters, where each of the characters is either "(" or ")".
Output
The first line should contain a single integer — the largest beauty of the string, which can be achieved by swapping some two characters.
The second line should contain integers l and r (1 ≤ l, r ≤ n) — the indices of two characters, which should be swapped in order to maximize the string's beauty.
In case there are several possible swaps, print any of them.
Examples
Input
10
()()())(()
Output
5
8 7
Input
12
)(()(()())()
Output
4
5 10
Input
6
)))(()
Output
0
1 1
Note
In the first example, we can swap 7-th and 8-th character, obtaining a string "()()()()()". The cyclical shifts by 0, 2, 4, 6, 8 of this string form a correct bracket sequence.
In the second example, after swapping 5-th and 10-th character, we obtain a string ")(())()()(()". The cyclical shifts by 11, 7, 5, 3 of this string form a correct bracket sequence.
In the third example, swap of any two brackets results in 0 cyclical shifts being correct bracket sequences.
Tags: implementation
Correct Solution:
```
n = int(input())
S = list(input())
def count_all(s):
cnt=0
l_cnt=1
for c in s[1:]:
if c==')':
l_cnt-=1
else:
l_cnt+=1
if l_cnt==0:
cnt+=1
return cnt
if S==list('()'*(n//2)) or S==list(')'+'()'*(n//2-1)+'('):
print(n // 2)
print(1, 1)
else:
res=0
l,r =1,1
lc=rc=0
for c in S:
if c=="(":
lc+=1
else:
rc+=1
if lc==rc:
for i in range(n):
for j in range(i,n):
ss=S[:]
if ss[i]==ss[j]:
continue
ss[i],ss[j]=ss[j],ss[i]
t=0
t_min=n
m=0
for k in range(n):
if ss[k]==")":
t-=1
else:
t+=1
if t<t_min:
t_min,m=t,k
sss=ss[m+1:]+ss[:m+1]
temp = count_all(sss)
if temp>=res:
# print(sss)
res=temp
l,r=i+1,j+1
print(res)
print(l,r)
```
| 86,705 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is a harder version of the problem. In this version, n ≤ 300 000.
Vasya is an experienced developer of programming competitions' problems. As all great minds at some time, Vasya faced a creative crisis. To improve the situation, Petya gifted him a string consisting of opening and closing brackets only. Petya believes, that the beauty of the bracket string is a number of its cyclical shifts, which form a correct bracket sequence.
To digress from his problems, Vasya decided to select two positions of the string (not necessarily distinct) and swap characters located at this positions with each other. Vasya will apply this operation exactly once. He is curious what is the maximum possible beauty he can achieve this way. Please help him.
We remind that bracket sequence s is called correct if:
* s is empty;
* s is equal to "(t)", where t is correct bracket sequence;
* s is equal to t_1 t_2, i.e. concatenation of t_1 and t_2, where t_1 and t_2 are correct bracket sequences.
For example, "(()())", "()" are correct, while ")(" and "())" are not.
The cyclical shift of the string s of length n by k (0 ≤ k < n) is a string formed by a concatenation of the last k symbols of the string s with the first n - k symbols of string s. For example, the cyclical shift of string "(())()" by 2 equals "()(())".
Cyclical shifts i and j are considered different, if i ≠ j.
Input
The first line contains an integer n (1 ≤ n ≤ 300 000), the length of the string.
The second line contains a string, consisting of exactly n characters, where each of the characters is either "(" or ")".
Output
The first line should contain a single integer — the largest beauty of the string, which can be achieved by swapping some two characters.
The second line should contain integers l and r (1 ≤ l, r ≤ n) — the indices of two characters, which should be swapped in order to maximize the string's beauty.
In case there are several possible swaps, print any of them.
Examples
Input
10
()()())(()
Output
5
8 7
Input
12
)(()(()())()
Output
4
5 10
Input
6
)))(()
Output
0
1 1
Note
In the first example, we can swap 7-th and 8-th character, obtaining a string "()()()()()". The cyclical shifts by 0, 2, 4, 6, 8 of this string form a correct bracket sequence.
In the second example, after swapping 5-th and 10-th character, we obtain a string ")(())()()(()". The cyclical shifts by 11, 7, 5, 3 of this string form a correct bracket sequence.
In the third example, swap of any two brackets results in 0 cyclical shifts being correct bracket sequences.
Tags: implementation
Correct Solution:
```
n = int(input())
s = [1 if c == '(' else -1 for c in input()]
if s.count(1) != s.count(-1):
print(0)
print(1, 1)
exit()
ans = 0
pair = 1, 1
for i in range(n-1):
for j in range(i, n):
s[i], s[j] = s[j], s[i]
min_p, cnt = 10**9, 0
nest = 0
for k in range(n):
nest += s[k]
if min_p > nest:
min_p = nest
cnt = 1
elif min_p == nest:
cnt += 1
if ans < cnt:
ans = cnt
pair = i+1, j+1
s[i], s[j] = s[j], s[i]
print(ans)
print(*pair)
```
| 86,706 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is a harder version of the problem. In this version, n ≤ 300 000.
Vasya is an experienced developer of programming competitions' problems. As all great minds at some time, Vasya faced a creative crisis. To improve the situation, Petya gifted him a string consisting of opening and closing brackets only. Petya believes, that the beauty of the bracket string is a number of its cyclical shifts, which form a correct bracket sequence.
To digress from his problems, Vasya decided to select two positions of the string (not necessarily distinct) and swap characters located at this positions with each other. Vasya will apply this operation exactly once. He is curious what is the maximum possible beauty he can achieve this way. Please help him.
We remind that bracket sequence s is called correct if:
* s is empty;
* s is equal to "(t)", where t is correct bracket sequence;
* s is equal to t_1 t_2, i.e. concatenation of t_1 and t_2, where t_1 and t_2 are correct bracket sequences.
For example, "(()())", "()" are correct, while ")(" and "())" are not.
The cyclical shift of the string s of length n by k (0 ≤ k < n) is a string formed by a concatenation of the last k symbols of the string s with the first n - k symbols of string s. For example, the cyclical shift of string "(())()" by 2 equals "()(())".
Cyclical shifts i and j are considered different, if i ≠ j.
Input
The first line contains an integer n (1 ≤ n ≤ 300 000), the length of the string.
The second line contains a string, consisting of exactly n characters, where each of the characters is either "(" or ")".
Output
The first line should contain a single integer — the largest beauty of the string, which can be achieved by swapping some two characters.
The second line should contain integers l and r (1 ≤ l, r ≤ n) — the indices of two characters, which should be swapped in order to maximize the string's beauty.
In case there are several possible swaps, print any of them.
Examples
Input
10
()()())(()
Output
5
8 7
Input
12
)(()(()())()
Output
4
5 10
Input
6
)))(()
Output
0
1 1
Note
In the first example, we can swap 7-th and 8-th character, obtaining a string "()()()()()". The cyclical shifts by 0, 2, 4, 6, 8 of this string form a correct bracket sequence.
In the second example, after swapping 5-th and 10-th character, we obtain a string ")(())()()(()". The cyclical shifts by 11, 7, 5, 3 of this string form a correct bracket sequence.
In the third example, swap of any two brackets results in 0 cyclical shifts being correct bracket sequences.
Tags: implementation
Correct Solution:
```
n = int(input())
s = list(input())
best = 0
L = 1
R = 1
def check():
calc = 0
min = 0
cntmin = 0
for ch in s:
if ch == '(':
calc += 1
else:
calc -= 1
if min > calc:
min = calc
cntmin = 1
elif min == calc:
cntmin += 1
return cntmin if calc == 0 else 0
if len(s) % 2:
print(best)
print(L, R)
quit()
best = check()
for i, ch in enumerate(s, 0):
for j in range(i + 1, n, 1):
s[i], s[j] = s[j], s[i]
new = check()
s[j], s[i] = s[i], s[j]
if (new > best):
best = new; L = 1+i; R = 1+j
print(best)
print(L, R)
```
| 86,707 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is a harder version of the problem. In this version, n ≤ 300 000.
Vasya is an experienced developer of programming competitions' problems. As all great minds at some time, Vasya faced a creative crisis. To improve the situation, Petya gifted him a string consisting of opening and closing brackets only. Petya believes, that the beauty of the bracket string is a number of its cyclical shifts, which form a correct bracket sequence.
To digress from his problems, Vasya decided to select two positions of the string (not necessarily distinct) and swap characters located at this positions with each other. Vasya will apply this operation exactly once. He is curious what is the maximum possible beauty he can achieve this way. Please help him.
We remind that bracket sequence s is called correct if:
* s is empty;
* s is equal to "(t)", where t is correct bracket sequence;
* s is equal to t_1 t_2, i.e. concatenation of t_1 and t_2, where t_1 and t_2 are correct bracket sequences.
For example, "(()())", "()" are correct, while ")(" and "())" are not.
The cyclical shift of the string s of length n by k (0 ≤ k < n) is a string formed by a concatenation of the last k symbols of the string s with the first n - k symbols of string s. For example, the cyclical shift of string "(())()" by 2 equals "()(())".
Cyclical shifts i and j are considered different, if i ≠ j.
Input
The first line contains an integer n (1 ≤ n ≤ 300 000), the length of the string.
The second line contains a string, consisting of exactly n characters, where each of the characters is either "(" or ")".
Output
The first line should contain a single integer — the largest beauty of the string, which can be achieved by swapping some two characters.
The second line should contain integers l and r (1 ≤ l, r ≤ n) — the indices of two characters, which should be swapped in order to maximize the string's beauty.
In case there are several possible swaps, print any of them.
Examples
Input
10
()()())(()
Output
5
8 7
Input
12
)(()(()())()
Output
4
5 10
Input
6
)))(()
Output
0
1 1
Note
In the first example, we can swap 7-th and 8-th character, obtaining a string "()()()()()". The cyclical shifts by 0, 2, 4, 6, 8 of this string form a correct bracket sequence.
In the second example, after swapping 5-th and 10-th character, we obtain a string ")(())()()(()". The cyclical shifts by 11, 7, 5, 3 of this string form a correct bracket sequence.
In the third example, swap of any two brackets results in 0 cyclical shifts being correct bracket sequences.
Tags: implementation
Correct Solution:
```
n = int(input())
ddd = input()
d = [0]
for dd in ddd:
if dd == '(':
d.append(d[-1] + 1)
else:
d.append(d[-1] - 1)
if d[-1] != 0:
print("0\n1 1")
exit(0)
d.pop()
mn = min(d)
ind = d.index(mn)
d = d[ind:] + d[:ind]
d = [i - mn for i in d]
fi = -1
crfi = -1
li = -1
mx = 0
cr = 0
cnt0 = 0
for i in range(n):
dd = d[i]
if dd == 0:
cnt0 += 1
if dd == 2:
if cr == 0:
crfi = i
cr += 1
if cr > mx:
fi = crfi
li = i
mx = cr
elif dd < 2:
cr = 0
# print('=========')
# print(d)
# print(cnt0)
# print(fi, li)
# print(mx)
# print("=========")
# if fi == -1:
# print(cnt0)
# print(1, 1)
# else:
# print(cnt0 + mx)
# print(fi, li + 2)
if fi == -1:
ans1 = [cnt0, 0, 0]
else:
ans1 = [cnt0 + mx, fi-1, li]
fi = -1
crfi = -1
li = -1
mx = 0
cr = 0
for i in range(n):
dd = d[i]
if dd == 1:
if cr == 0:
crfi = i
cr += 1
if cr > mx:
fi = crfi
li = i
mx = cr
elif dd < 1:
cr = 0
ans2 = [mx, fi-1, li]
if ans1[0] > ans2[0]:
print(ans1[0])
print(((ans1[1] + ind)%n) + 1, ((ans1[2] + ind)%n) + 1)
else:
print(ans2[0])
print(((ans2[1] + ind)%n) + 1, ((ans2[2] + ind)%n) + 1)
```
| 86,708 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is a harder version of the problem. In this version, n ≤ 300 000.
Vasya is an experienced developer of programming competitions' problems. As all great minds at some time, Vasya faced a creative crisis. To improve the situation, Petya gifted him a string consisting of opening and closing brackets only. Petya believes, that the beauty of the bracket string is a number of its cyclical shifts, which form a correct bracket sequence.
To digress from his problems, Vasya decided to select two positions of the string (not necessarily distinct) and swap characters located at this positions with each other. Vasya will apply this operation exactly once. He is curious what is the maximum possible beauty he can achieve this way. Please help him.
We remind that bracket sequence s is called correct if:
* s is empty;
* s is equal to "(t)", where t is correct bracket sequence;
* s is equal to t_1 t_2, i.e. concatenation of t_1 and t_2, where t_1 and t_2 are correct bracket sequences.
For example, "(()())", "()" are correct, while ")(" and "())" are not.
The cyclical shift of the string s of length n by k (0 ≤ k < n) is a string formed by a concatenation of the last k symbols of the string s with the first n - k symbols of string s. For example, the cyclical shift of string "(())()" by 2 equals "()(())".
Cyclical shifts i and j are considered different, if i ≠ j.
Input
The first line contains an integer n (1 ≤ n ≤ 300 000), the length of the string.
The second line contains a string, consisting of exactly n characters, where each of the characters is either "(" or ")".
Output
The first line should contain a single integer — the largest beauty of the string, which can be achieved by swapping some two characters.
The second line should contain integers l and r (1 ≤ l, r ≤ n) — the indices of two characters, which should be swapped in order to maximize the string's beauty.
In case there are several possible swaps, print any of them.
Examples
Input
10
()()())(()
Output
5
8 7
Input
12
)(()(()())()
Output
4
5 10
Input
6
)))(()
Output
0
1 1
Note
In the first example, we can swap 7-th and 8-th character, obtaining a string "()()()()()". The cyclical shifts by 0, 2, 4, 6, 8 of this string form a correct bracket sequence.
In the second example, after swapping 5-th and 10-th character, we obtain a string ")(())()()(()". The cyclical shifts by 11, 7, 5, 3 of this string form a correct bracket sequence.
In the third example, swap of any two brackets results in 0 cyclical shifts being correct bracket sequences.
Tags: implementation
Correct Solution:
```
n = int(input().strip())
s= input().strip()
ss= 0
mina = 0
ti = 0
for k in range(len(s)):
if(s[k] == "("):
ss+=1
else:
ss-=1
if(ss<0):
ti = k+1
ss = 0
s=s[ti:]+s[:ti]
#print(s)
ss= 0
for k in range(len(s)):
if(s[k] == "("):
ss+=1
else:
ss-=1
if(ss<0):
print(0)
print(1,1)
break
else:
if(ss == 0):
pre=[0 for k in range(len(s))]
ss=0
for k in range(len(s)):
if (s[k] == "("):
ss += 1
else:
ss -= 1
pre[k] = ss
tt = 0
a =(1,1)
for k in range(0,len(s)):
if(pre[k] == 0):
tt+=1
maxi= tt
#print(pre)
g =0
gg =0
while(gg<len(s)):
if(pre[gg] == 0):
#print(gg,g,"g")
if(gg != g+1):
yy = g+1
y = g+1
q = 0
while(yy<gg):
if(pre[yy] == 1):
# print(yy,y,"y")
if(yy !=y+1):
rr = y+1
r = y+1
h = 0
while(rr<yy):
if(pre[rr] == 2):
h+=1
rr+=1
if(tt+h+1>maxi):
maxi = tt + h + 1
a=(y,yy)
else:
if(tt+1>maxi):
maxi =tt+1
a=(y,yy)
#print(a, a)
q+=1
y = yy+1
yy = y
else:
yy+=1
if (q + 1 > maxi):
maxi = q+1
a = (g, gg)
g= gg+1
gg= g
else:
gg+=1
print(maxi)
# print(a)
print((a[0]+ti)%len(s)+1,(a[1]+ti)%len(s)+1)
else:
print(0)
print(1,1)
```
| 86,709 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is a harder version of the problem. In this version, n ≤ 300 000.
Vasya is an experienced developer of programming competitions' problems. As all great minds at some time, Vasya faced a creative crisis. To improve the situation, Petya gifted him a string consisting of opening and closing brackets only. Petya believes, that the beauty of the bracket string is a number of its cyclical shifts, which form a correct bracket sequence.
To digress from his problems, Vasya decided to select two positions of the string (not necessarily distinct) and swap characters located at this positions with each other. Vasya will apply this operation exactly once. He is curious what is the maximum possible beauty he can achieve this way. Please help him.
We remind that bracket sequence s is called correct if:
* s is empty;
* s is equal to "(t)", where t is correct bracket sequence;
* s is equal to t_1 t_2, i.e. concatenation of t_1 and t_2, where t_1 and t_2 are correct bracket sequences.
For example, "(()())", "()" are correct, while ")(" and "())" are not.
The cyclical shift of the string s of length n by k (0 ≤ k < n) is a string formed by a concatenation of the last k symbols of the string s with the first n - k symbols of string s. For example, the cyclical shift of string "(())()" by 2 equals "()(())".
Cyclical shifts i and j are considered different, if i ≠ j.
Input
The first line contains an integer n (1 ≤ n ≤ 300 000), the length of the string.
The second line contains a string, consisting of exactly n characters, where each of the characters is either "(" or ")".
Output
The first line should contain a single integer — the largest beauty of the string, which can be achieved by swapping some two characters.
The second line should contain integers l and r (1 ≤ l, r ≤ n) — the indices of two characters, which should be swapped in order to maximize the string's beauty.
In case there are several possible swaps, print any of them.
Examples
Input
10
()()())(()
Output
5
8 7
Input
12
)(()(()())()
Output
4
5 10
Input
6
)))(()
Output
0
1 1
Note
In the first example, we can swap 7-th and 8-th character, obtaining a string "()()()()()". The cyclical shifts by 0, 2, 4, 6, 8 of this string form a correct bracket sequence.
In the second example, after swapping 5-th and 10-th character, we obtain a string ")(())()()(()". The cyclical shifts by 11, 7, 5, 3 of this string form a correct bracket sequence.
In the third example, swap of any two brackets results in 0 cyclical shifts being correct bracket sequences.
Tags: implementation
Correct Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
from collections import deque
import threading
#sys.setrecursionlimit(300000)
#threading.stack_size(10**8)
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")
#-------------------------------------------------------------------------
#mod = 9223372036854775807
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: max(a,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
class SegmentTree1:
def __init__(self, data, default=10**6, func=lambda a, b: min(a,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
MOD=10**9+7
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
mod=10**9+7
omod=998244353
#-------------------------------------------------------------------------
prime = [True for i in range(10)]
pp=[0]*10
def SieveOfEratosthenes(n=10):
p = 2
c=0
while (p * p <= n):
if (prime[p] == True):
c+=1
for i in range(p, n+1, p):
pp[i]+=1
prime[i] = False
p += 1
#---------------------------------Binary Search------------------------------------------
def binarySearch(arr, n, key):
left = 0
right = n-1
mid = 0
res=0
while (left <= right):
mid = (right + left)//2
if (arr[mid][0] > key):
right = mid-1
else:
res=mid
left = mid + 1
return res
#---------------------------------running code------------------------------------------
n = int(input())
s = list(input())
L = 1
R = 1
def check():
calc = 0
min = 0
cntmin = 0
for ch in s:
if ch == '(': calc += 1
else: calc -= 1
if min > calc:
min = calc
cntmin = 1
elif min == calc:
cntmin += 1
return cntmin if calc == 0 else 0
best = check()
for i in range(n):
for j in range(i + 1, n, 1):
s[i], s[j] = s[j], s[i]
new = check()
s[j], s[i] = s[i], s[j]
if (new > best):
best = new; L = 1+i; R = 1+j
print(best)
print(L, R)
```
| 86,710 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is a harder version of the problem. In this version, n ≤ 300 000.
Vasya is an experienced developer of programming competitions' problems. As all great minds at some time, Vasya faced a creative crisis. To improve the situation, Petya gifted him a string consisting of opening and closing brackets only. Petya believes, that the beauty of the bracket string is a number of its cyclical shifts, which form a correct bracket sequence.
To digress from his problems, Vasya decided to select two positions of the string (not necessarily distinct) and swap characters located at this positions with each other. Vasya will apply this operation exactly once. He is curious what is the maximum possible beauty he can achieve this way. Please help him.
We remind that bracket sequence s is called correct if:
* s is empty;
* s is equal to "(t)", where t is correct bracket sequence;
* s is equal to t_1 t_2, i.e. concatenation of t_1 and t_2, where t_1 and t_2 are correct bracket sequences.
For example, "(()())", "()" are correct, while ")(" and "())" are not.
The cyclical shift of the string s of length n by k (0 ≤ k < n) is a string formed by a concatenation of the last k symbols of the string s with the first n - k symbols of string s. For example, the cyclical shift of string "(())()" by 2 equals "()(())".
Cyclical shifts i and j are considered different, if i ≠ j.
Input
The first line contains an integer n (1 ≤ n ≤ 300 000), the length of the string.
The second line contains a string, consisting of exactly n characters, where each of the characters is either "(" or ")".
Output
The first line should contain a single integer — the largest beauty of the string, which can be achieved by swapping some two characters.
The second line should contain integers l and r (1 ≤ l, r ≤ n) — the indices of two characters, which should be swapped in order to maximize the string's beauty.
In case there are several possible swaps, print any of them.
Examples
Input
10
()()())(()
Output
5
8 7
Input
12
)(()(()())()
Output
4
5 10
Input
6
)))(()
Output
0
1 1
Note
In the first example, we can swap 7-th and 8-th character, obtaining a string "()()()()()". The cyclical shifts by 0, 2, 4, 6, 8 of this string form a correct bracket sequence.
In the second example, after swapping 5-th and 10-th character, we obtain a string ")(())()()(()". The cyclical shifts by 11, 7, 5, 3 of this string form a correct bracket sequence.
In the third example, swap of any two brackets results in 0 cyclical shifts being correct bracket sequences.
Tags: implementation
Correct Solution:
```
# import cProfile
def prefix(s):
count = 0
cur = 0
m = 0
for c in s:
if c == '(':
cur += 1
else:
cur -= 1
if cur < m:
m = cur
count = 0
if cur == m:
count += 1
return count
from collections import Counter
n = int(input())
s = list(input())
C = Counter(s)
if C['('] == C[')']:
a, b, c = -1, -1, -1
for l in range(n):
for r in range(l, n):
s[l], s[r] = s[r], s[l]
abc = prefix(s)
if abc > a:
a = abc
b = l
c = r
s[l], s[r] = s[r], s[l]
print (a)
print (b + 1, c + 1)
else:
print (0)
print (1, 1)
```
| 86,711 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is a harder version of the problem. In this version, n ≤ 300 000.
Vasya is an experienced developer of programming competitions' problems. As all great minds at some time, Vasya faced a creative crisis. To improve the situation, Petya gifted him a string consisting of opening and closing brackets only. Petya believes, that the beauty of the bracket string is a number of its cyclical shifts, which form a correct bracket sequence.
To digress from his problems, Vasya decided to select two positions of the string (not necessarily distinct) and swap characters located at this positions with each other. Vasya will apply this operation exactly once. He is curious what is the maximum possible beauty he can achieve this way. Please help him.
We remind that bracket sequence s is called correct if:
* s is empty;
* s is equal to "(t)", where t is correct bracket sequence;
* s is equal to t_1 t_2, i.e. concatenation of t_1 and t_2, where t_1 and t_2 are correct bracket sequences.
For example, "(()())", "()" are correct, while ")(" and "())" are not.
The cyclical shift of the string s of length n by k (0 ≤ k < n) is a string formed by a concatenation of the last k symbols of the string s with the first n - k symbols of string s. For example, the cyclical shift of string "(())()" by 2 equals "()(())".
Cyclical shifts i and j are considered different, if i ≠ j.
Input
The first line contains an integer n (1 ≤ n ≤ 300 000), the length of the string.
The second line contains a string, consisting of exactly n characters, where each of the characters is either "(" or ")".
Output
The first line should contain a single integer — the largest beauty of the string, which can be achieved by swapping some two characters.
The second line should contain integers l and r (1 ≤ l, r ≤ n) — the indices of two characters, which should be swapped in order to maximize the string's beauty.
In case there are several possible swaps, print any of them.
Examples
Input
10
()()())(()
Output
5
8 7
Input
12
)(()(()())()
Output
4
5 10
Input
6
)))(()
Output
0
1 1
Note
In the first example, we can swap 7-th and 8-th character, obtaining a string "()()()()()". The cyclical shifts by 0, 2, 4, 6, 8 of this string form a correct bracket sequence.
In the second example, after swapping 5-th and 10-th character, we obtain a string ")(())()()(()". The cyclical shifts by 11, 7, 5, 3 of this string form a correct bracket sequence.
In the third example, swap of any two brackets results in 0 cyclical shifts being correct bracket sequences.
Submitted Solution:
```
#!/usr/bin/env python3
import sys
#lines = stdin.readlines()
def rint():
return map(int, sys.stdin.readline().split())
def input():
return sys.stdin.readline().rstrip('\n')
def oint():
return int(input())
n = oint()
stemp = input()
s = []
for i in range(n):
if stemp[i] == '(':
s.append(1)
else:
s.append(-1)
maxcnt = 0
candi = [0, 0]
for l in range(n):
for r in range(l, n):
cnt = 0
s[l], s[r] = s[r], s[l]
ssum = [0]*n
ssum[0] = s[0]
for i in range(1, n):
ssum[i] = ssum[i-1] + s[i]
minssum = min(ssum)
if ssum[n-1] != 0:
continue
for i in range(0, n):
if ssum[i] == minssum:
cnt += 1
if maxcnt < cnt:
candi = [r, l]
maxcnt = cnt
s[l], s[r] = s[r], s[l]
print(maxcnt)
print(candi[0]+1, candi[1]+1)
```
Yes
| 86,712 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is a harder version of the problem. In this version, n ≤ 300 000.
Vasya is an experienced developer of programming competitions' problems. As all great minds at some time, Vasya faced a creative crisis. To improve the situation, Petya gifted him a string consisting of opening and closing brackets only. Petya believes, that the beauty of the bracket string is a number of its cyclical shifts, which form a correct bracket sequence.
To digress from his problems, Vasya decided to select two positions of the string (not necessarily distinct) and swap characters located at this positions with each other. Vasya will apply this operation exactly once. He is curious what is the maximum possible beauty he can achieve this way. Please help him.
We remind that bracket sequence s is called correct if:
* s is empty;
* s is equal to "(t)", where t is correct bracket sequence;
* s is equal to t_1 t_2, i.e. concatenation of t_1 and t_2, where t_1 and t_2 are correct bracket sequences.
For example, "(()())", "()" are correct, while ")(" and "())" are not.
The cyclical shift of the string s of length n by k (0 ≤ k < n) is a string formed by a concatenation of the last k symbols of the string s with the first n - k symbols of string s. For example, the cyclical shift of string "(())()" by 2 equals "()(())".
Cyclical shifts i and j are considered different, if i ≠ j.
Input
The first line contains an integer n (1 ≤ n ≤ 300 000), the length of the string.
The second line contains a string, consisting of exactly n characters, where each of the characters is either "(" or ")".
Output
The first line should contain a single integer — the largest beauty of the string, which can be achieved by swapping some two characters.
The second line should contain integers l and r (1 ≤ l, r ≤ n) — the indices of two characters, which should be swapped in order to maximize the string's beauty.
In case there are several possible swaps, print any of them.
Examples
Input
10
()()())(()
Output
5
8 7
Input
12
)(()(()())()
Output
4
5 10
Input
6
)))(()
Output
0
1 1
Note
In the first example, we can swap 7-th and 8-th character, obtaining a string "()()()()()". The cyclical shifts by 0, 2, 4, 6, 8 of this string form a correct bracket sequence.
In the second example, after swapping 5-th and 10-th character, we obtain a string ")(())()()(()". The cyclical shifts by 11, 7, 5, 3 of this string form a correct bracket sequence.
In the third example, swap of any two brackets results in 0 cyclical shifts being correct bracket sequences.
Submitted Solution:
```
n = int(input())
s = list(input())
if n % 2 == 1 or s.count('(') != s.count(')'):
print('0\n1 1')
exit()
def solve():
cnt_open, res, need = 0, 0, 0
for i in s:
if i == '(':
cnt_open += 1
else:
cnt_open -= 1
if cnt_open < need:
need = cnt_open
res = 1
elif cnt_open == need:
res += 1
return res
res, res_i, res_j = solve(), 0, 0
for i in range(n):
for j in range(i+1, n):
if s[i] != s[j]:
s[i], s[j] = s[j], s[i]
curr = solve()
s[i], s[j] = s[j], s[i]
if curr > res:
res = curr
res_i = i
res_j = j
print(res)
print(res_i+1, res_j+1)
```
Yes
| 86,713 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is a harder version of the problem. In this version, n ≤ 300 000.
Vasya is an experienced developer of programming competitions' problems. As all great minds at some time, Vasya faced a creative crisis. To improve the situation, Petya gifted him a string consisting of opening and closing brackets only. Petya believes, that the beauty of the bracket string is a number of its cyclical shifts, which form a correct bracket sequence.
To digress from his problems, Vasya decided to select two positions of the string (not necessarily distinct) and swap characters located at this positions with each other. Vasya will apply this operation exactly once. He is curious what is the maximum possible beauty he can achieve this way. Please help him.
We remind that bracket sequence s is called correct if:
* s is empty;
* s is equal to "(t)", where t is correct bracket sequence;
* s is equal to t_1 t_2, i.e. concatenation of t_1 and t_2, where t_1 and t_2 are correct bracket sequences.
For example, "(()())", "()" are correct, while ")(" and "())" are not.
The cyclical shift of the string s of length n by k (0 ≤ k < n) is a string formed by a concatenation of the last k symbols of the string s with the first n - k symbols of string s. For example, the cyclical shift of string "(())()" by 2 equals "()(())".
Cyclical shifts i and j are considered different, if i ≠ j.
Input
The first line contains an integer n (1 ≤ n ≤ 300 000), the length of the string.
The second line contains a string, consisting of exactly n characters, where each of the characters is either "(" or ")".
Output
The first line should contain a single integer — the largest beauty of the string, which can be achieved by swapping some two characters.
The second line should contain integers l and r (1 ≤ l, r ≤ n) — the indices of two characters, which should be swapped in order to maximize the string's beauty.
In case there are several possible swaps, print any of them.
Examples
Input
10
()()())(()
Output
5
8 7
Input
12
)(()(()())()
Output
4
5 10
Input
6
)))(()
Output
0
1 1
Note
In the first example, we can swap 7-th and 8-th character, obtaining a string "()()()()()". The cyclical shifts by 0, 2, 4, 6, 8 of this string form a correct bracket sequence.
In the second example, after swapping 5-th and 10-th character, we obtain a string ")(())()()(()". The cyclical shifts by 11, 7, 5, 3 of this string form a correct bracket sequence.
In the third example, swap of any two brackets results in 0 cyclical shifts being correct bracket sequences.
Submitted Solution:
```
def beauty(tt):
depth = 0
min_depth = 0
dd = []
for i, t in enumerate(tt):
if t == '(':
depth += 1
else:
depth -= 1
dd.append(depth)
if depth < min_depth:
min_depth = depth
if depth != 0:
return(0)
result = 0
for d in dd:
if d == min_depth:
result+=1
return(result)
def main():
n = int(input())
if n%2 == 1:
print(0)
print(1,1)
return
tt = input()
best = beauty(tt)
l = 1
r = 1
for i in range(n-1):
for j in range(i+1, n):
if tt[i] != tt[j]:
ttt = list(tt)
ttt[i] = tt[j]
ttt[j] = tt[i]
b = beauty(ttt)
if b > best:
best = b
l = i+1
r = j+1
print(best)
print(l, r)
if __name__ == "__main__":
main()
```
Yes
| 86,714 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is a harder version of the problem. In this version, n ≤ 300 000.
Vasya is an experienced developer of programming competitions' problems. As all great minds at some time, Vasya faced a creative crisis. To improve the situation, Petya gifted him a string consisting of opening and closing brackets only. Petya believes, that the beauty of the bracket string is a number of its cyclical shifts, which form a correct bracket sequence.
To digress from his problems, Vasya decided to select two positions of the string (not necessarily distinct) and swap characters located at this positions with each other. Vasya will apply this operation exactly once. He is curious what is the maximum possible beauty he can achieve this way. Please help him.
We remind that bracket sequence s is called correct if:
* s is empty;
* s is equal to "(t)", where t is correct bracket sequence;
* s is equal to t_1 t_2, i.e. concatenation of t_1 and t_2, where t_1 and t_2 are correct bracket sequences.
For example, "(()())", "()" are correct, while ")(" and "())" are not.
The cyclical shift of the string s of length n by k (0 ≤ k < n) is a string formed by a concatenation of the last k symbols of the string s with the first n - k symbols of string s. For example, the cyclical shift of string "(())()" by 2 equals "()(())".
Cyclical shifts i and j are considered different, if i ≠ j.
Input
The first line contains an integer n (1 ≤ n ≤ 300 000), the length of the string.
The second line contains a string, consisting of exactly n characters, where each of the characters is either "(" or ")".
Output
The first line should contain a single integer — the largest beauty of the string, which can be achieved by swapping some two characters.
The second line should contain integers l and r (1 ≤ l, r ≤ n) — the indices of two characters, which should be swapped in order to maximize the string's beauty.
In case there are several possible swaps, print any of them.
Examples
Input
10
()()())(()
Output
5
8 7
Input
12
)(()(()())()
Output
4
5 10
Input
6
)))(()
Output
0
1 1
Note
In the first example, we can swap 7-th and 8-th character, obtaining a string "()()()()()". The cyclical shifts by 0, 2, 4, 6, 8 of this string form a correct bracket sequence.
In the second example, after swapping 5-th and 10-th character, we obtain a string ")(())()()(()". The cyclical shifts by 11, 7, 5, 3 of this string form a correct bracket sequence.
In the third example, swap of any two brackets results in 0 cyclical shifts being correct bracket sequences.
Submitted Solution:
```
n = int(input())
s = list(input())
cnt_r = 0
cnt_l = 0
for i in range(n):
if s[i] == ")":
cnt_r += 1
else:
cnt_l += 1
if cnt_l != cnt_r:
print(0)
print(1, 1)
exit()
pos_r = []
pos_l = []
for i in range(n):
if s[i] == ")":
pos_r.append(i)
else:
pos_l.append(i)
# no change
ans = 0
for i in [0]:
for j in [0]:
tmp_ans = 0
tmp = s[0:]
tmp[i], tmp[j] = tmp[j], tmp[i]
cnt = 0
offset = 0
min_cnt = 0
for num, k in enumerate(tmp):
if k == ")":
cnt -= 1
else:
cnt += 1
if cnt < min_cnt:
min_cnt = cnt
offset = num+1
cnt = 0
for num, k in enumerate(tmp[offset:]+tmp[0:offset]):
if k == ")":
cnt += 1
else:
cnt -= 1
if cnt == 0:
tmp_ans += 1
if ans < tmp_ans:
ans = tmp_ans
ind1 = i
ind2 = j
for i in pos_r:
for j in pos_l:
tmp_ans = 0
tmp = s[0:]
tmp[i], tmp[j] = tmp[j], tmp[i]
cnt = 0
offset = 0
min_cnt = 0
for num, k in enumerate(tmp):
if k == ")":
cnt -= 1
else:
cnt += 1
if cnt < min_cnt:
min_cnt = cnt
offset = num+1
#print("".join(tmp), offset)
#print("".join(tmp[offset:]+tmp[0:offset]))
cnt = 0
for num, k in enumerate(tmp[offset:]+tmp[0:offset]):
if k == ")":
cnt += 1
else:
cnt -= 1
if cnt == 0:
tmp_ans += 1
if ans < tmp_ans:
ans = tmp_ans
ind1 = i
ind2 = j
print(ans)
print(ind1+1, ind2+1)
```
Yes
| 86,715 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is a harder version of the problem. In this version, n ≤ 300 000.
Vasya is an experienced developer of programming competitions' problems. As all great minds at some time, Vasya faced a creative crisis. To improve the situation, Petya gifted him a string consisting of opening and closing brackets only. Petya believes, that the beauty of the bracket string is a number of its cyclical shifts, which form a correct bracket sequence.
To digress from his problems, Vasya decided to select two positions of the string (not necessarily distinct) and swap characters located at this positions with each other. Vasya will apply this operation exactly once. He is curious what is the maximum possible beauty he can achieve this way. Please help him.
We remind that bracket sequence s is called correct if:
* s is empty;
* s is equal to "(t)", where t is correct bracket sequence;
* s is equal to t_1 t_2, i.e. concatenation of t_1 and t_2, where t_1 and t_2 are correct bracket sequences.
For example, "(()())", "()" are correct, while ")(" and "())" are not.
The cyclical shift of the string s of length n by k (0 ≤ k < n) is a string formed by a concatenation of the last k symbols of the string s with the first n - k symbols of string s. For example, the cyclical shift of string "(())()" by 2 equals "()(())".
Cyclical shifts i and j are considered different, if i ≠ j.
Input
The first line contains an integer n (1 ≤ n ≤ 300 000), the length of the string.
The second line contains a string, consisting of exactly n characters, where each of the characters is either "(" or ")".
Output
The first line should contain a single integer — the largest beauty of the string, which can be achieved by swapping some two characters.
The second line should contain integers l and r (1 ≤ l, r ≤ n) — the indices of two characters, which should be swapped in order to maximize the string's beauty.
In case there are several possible swaps, print any of them.
Examples
Input
10
()()())(()
Output
5
8 7
Input
12
)(()(()())()
Output
4
5 10
Input
6
)))(()
Output
0
1 1
Note
In the first example, we can swap 7-th and 8-th character, obtaining a string "()()()()()". The cyclical shifts by 0, 2, 4, 6, 8 of this string form a correct bracket sequence.
In the second example, after swapping 5-th and 10-th character, we obtain a string ")(())()()(()". The cyclical shifts by 11, 7, 5, 3 of this string form a correct bracket sequence.
In the third example, swap of any two brackets results in 0 cyclical shifts being correct bracket sequences.
Submitted Solution:
```
n = int(input())
s = input()
r = 0
l = n-1
root = []
buf = []
to_the_right = True
for count in range(n):
if to_the_right:
i = r
r += 1
else:
i = l
l -= 1
b = s[i]
if b == '(':
if len(buf) == 0 or buf[-1][0] != -1:
buf.append([-1,-1,[]])
buf[-1][0] = i
else:
if len(buf) == 0 or buf[-1][1] != -1:
buf.append([-1,-1,root])
root = []
to_the_right = False
buf[-1][1] = i
if buf[-1][0] != -1 and buf[-1][1] != -1:
tmp = buf.pop()
if len(buf):
buf[-1][2].append(tmp)
else:
root.append(tmp)
to_the_right = True
sol = [[0,1,1]]
if len(buf) == 0:
sol.append([len(root), 1, 1])
for child in root:
sol.append([len(child[2])+1, child[0]+1, child[1]+1])
for gr_child in child[2]:
if len(gr_child[2]):
sol.append([len(root)+len(gr_child[2])+1, gr_child[0]+1, gr_child[1]+1])
print('%d\n%d %d'%tuple(max(sol)))
```
No
| 86,716 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is a harder version of the problem. In this version, n ≤ 300 000.
Vasya is an experienced developer of programming competitions' problems. As all great minds at some time, Vasya faced a creative crisis. To improve the situation, Petya gifted him a string consisting of opening and closing brackets only. Petya believes, that the beauty of the bracket string is a number of its cyclical shifts, which form a correct bracket sequence.
To digress from his problems, Vasya decided to select two positions of the string (not necessarily distinct) and swap characters located at this positions with each other. Vasya will apply this operation exactly once. He is curious what is the maximum possible beauty he can achieve this way. Please help him.
We remind that bracket sequence s is called correct if:
* s is empty;
* s is equal to "(t)", where t is correct bracket sequence;
* s is equal to t_1 t_2, i.e. concatenation of t_1 and t_2, where t_1 and t_2 are correct bracket sequences.
For example, "(()())", "()" are correct, while ")(" and "())" are not.
The cyclical shift of the string s of length n by k (0 ≤ k < n) is a string formed by a concatenation of the last k symbols of the string s with the first n - k symbols of string s. For example, the cyclical shift of string "(())()" by 2 equals "()(())".
Cyclical shifts i and j are considered different, if i ≠ j.
Input
The first line contains an integer n (1 ≤ n ≤ 300 000), the length of the string.
The second line contains a string, consisting of exactly n characters, where each of the characters is either "(" or ")".
Output
The first line should contain a single integer — the largest beauty of the string, which can be achieved by swapping some two characters.
The second line should contain integers l and r (1 ≤ l, r ≤ n) — the indices of two characters, which should be swapped in order to maximize the string's beauty.
In case there are several possible swaps, print any of them.
Examples
Input
10
()()())(()
Output
5
8 7
Input
12
)(()(()())()
Output
4
5 10
Input
6
)))(()
Output
0
1 1
Note
In the first example, we can swap 7-th and 8-th character, obtaining a string "()()()()()". The cyclical shifts by 0, 2, 4, 6, 8 of this string form a correct bracket sequence.
In the second example, after swapping 5-th and 10-th character, we obtain a string ")(())()()(()". The cyclical shifts by 11, 7, 5, 3 of this string form a correct bracket sequence.
In the third example, swap of any two brackets results in 0 cyclical shifts being correct bracket sequences.
Submitted Solution:
```
n = int(input())
seq = list(input())
def rectify(seq):
depth = 0
best = bestVal = -1
for i in range(n):
if seq[i] == "(":
depth += 1
else:
depth -= 1
if best == -1 or depth < bestVal:
best = i
bestVal = depth
return seq[best+1:]+seq[:best+1]
if n%2 == 1 or seq.count("(") != seq.count(")"):
print(0)
print(1,1)
else:
best = -1
bestVal = -1
for i in range(n):
for j in range(n):
if seq[i] != seq[j]:
swapseq = list(seq)
swapseq[i] = seq[j]
swapseq[j] = seq[i]
swapseq = rectify(swapseq)
depth = components = 0
for x in range(n):
if swapseq[x] == "(":
depth += 1
else:
depth -= 1
if depth == 0:
components += 1
if bestVal == -1 or components > bestVal:
best = (i,j)
bestVal = components
print(bestVal)
print(best[0],best[1])
```
No
| 86,717 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is a harder version of the problem. In this version, n ≤ 300 000.
Vasya is an experienced developer of programming competitions' problems. As all great minds at some time, Vasya faced a creative crisis. To improve the situation, Petya gifted him a string consisting of opening and closing brackets only. Petya believes, that the beauty of the bracket string is a number of its cyclical shifts, which form a correct bracket sequence.
To digress from his problems, Vasya decided to select two positions of the string (not necessarily distinct) and swap characters located at this positions with each other. Vasya will apply this operation exactly once. He is curious what is the maximum possible beauty he can achieve this way. Please help him.
We remind that bracket sequence s is called correct if:
* s is empty;
* s is equal to "(t)", where t is correct bracket sequence;
* s is equal to t_1 t_2, i.e. concatenation of t_1 and t_2, where t_1 and t_2 are correct bracket sequences.
For example, "(()())", "()" are correct, while ")(" and "())" are not.
The cyclical shift of the string s of length n by k (0 ≤ k < n) is a string formed by a concatenation of the last k symbols of the string s with the first n - k symbols of string s. For example, the cyclical shift of string "(())()" by 2 equals "()(())".
Cyclical shifts i and j are considered different, if i ≠ j.
Input
The first line contains an integer n (1 ≤ n ≤ 300 000), the length of the string.
The second line contains a string, consisting of exactly n characters, where each of the characters is either "(" or ")".
Output
The first line should contain a single integer — the largest beauty of the string, which can be achieved by swapping some two characters.
The second line should contain integers l and r (1 ≤ l, r ≤ n) — the indices of two characters, which should be swapped in order to maximize the string's beauty.
In case there are several possible swaps, print any of them.
Examples
Input
10
()()())(()
Output
5
8 7
Input
12
)(()(()())()
Output
4
5 10
Input
6
)))(()
Output
0
1 1
Note
In the first example, we can swap 7-th and 8-th character, obtaining a string "()()()()()". The cyclical shifts by 0, 2, 4, 6, 8 of this string form a correct bracket sequence.
In the second example, after swapping 5-th and 10-th character, we obtain a string ")(())()()(()". The cyclical shifts by 11, 7, 5, 3 of this string form a correct bracket sequence.
In the third example, swap of any two brackets results in 0 cyclical shifts being correct bracket sequences.
Submitted Solution:
```
# cook your dish here
def check(expression, l, r, k):
if l+k < len(expression):
l = l+k
else:
l = len(expression)-l-1
if r+k < len(expression):
r += k
else:
r = len(expression)-r-1
expression[l], expression[r] = expression[r], expression[l]
open_tup = tuple('({[')
close_tup = tuple(')}]')
map = dict(zip(open_tup, close_tup))
queue = []
for i in expression:
if i in open_tup:
queue.append(map[i])
elif i in close_tup:
if not queue or i != queue.pop():
return False
return True
n = int(input())
array = list(input())
# duplicate = array[:]
cnt = 0
ans = 0
l, r = 1, 1
d = dict()
for i in range(n):
d[i] = array[n-i:]+array[:n-i]
for i in range(n):
for j in range(n):
# duplicate[i], duplicate[j] = duplicate[j], duplicate[i]
for k in range(n):
if check(d[k], i, j, k):
cnt += 1
if cnt > ans:
ans = cnt
l, r = i+1, j+1
# duplicate[i], duplicate[j] = duplicate[j], duplicate[i]
print(ans)
print(l, r)
```
No
| 86,718 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is a harder version of the problem. In this version, n ≤ 300 000.
Vasya is an experienced developer of programming competitions' problems. As all great minds at some time, Vasya faced a creative crisis. To improve the situation, Petya gifted him a string consisting of opening and closing brackets only. Petya believes, that the beauty of the bracket string is a number of its cyclical shifts, which form a correct bracket sequence.
To digress from his problems, Vasya decided to select two positions of the string (not necessarily distinct) and swap characters located at this positions with each other. Vasya will apply this operation exactly once. He is curious what is the maximum possible beauty he can achieve this way. Please help him.
We remind that bracket sequence s is called correct if:
* s is empty;
* s is equal to "(t)", where t is correct bracket sequence;
* s is equal to t_1 t_2, i.e. concatenation of t_1 and t_2, where t_1 and t_2 are correct bracket sequences.
For example, "(()())", "()" are correct, while ")(" and "())" are not.
The cyclical shift of the string s of length n by k (0 ≤ k < n) is a string formed by a concatenation of the last k symbols of the string s with the first n - k symbols of string s. For example, the cyclical shift of string "(())()" by 2 equals "()(())".
Cyclical shifts i and j are considered different, if i ≠ j.
Input
The first line contains an integer n (1 ≤ n ≤ 300 000), the length of the string.
The second line contains a string, consisting of exactly n characters, where each of the characters is either "(" or ")".
Output
The first line should contain a single integer — the largest beauty of the string, which can be achieved by swapping some two characters.
The second line should contain integers l and r (1 ≤ l, r ≤ n) — the indices of two characters, which should be swapped in order to maximize the string's beauty.
In case there are several possible swaps, print any of them.
Examples
Input
10
()()())(()
Output
5
8 7
Input
12
)(()(()())()
Output
4
5 10
Input
6
)))(()
Output
0
1 1
Note
In the first example, we can swap 7-th and 8-th character, obtaining a string "()()()()()". The cyclical shifts by 0, 2, 4, 6, 8 of this string form a correct bracket sequence.
In the second example, after swapping 5-th and 10-th character, we obtain a string ")(())()()(()". The cyclical shifts by 11, 7, 5, 3 of this string form a correct bracket sequence.
In the third example, swap of any two brackets results in 0 cyclical shifts being correct bracket sequences.
Submitted Solution:
```
n = int(input())
s = input()
sl = list(s)
ans = 0
ai = [1,1]
for i in range(n):
for j in range(i, n):
sl = list(s)
sl[i], sl[j] = sl[j], sl[i]
b = 0
p = 0
k = 0
while k < n and sl[k] == ")":
k += 1
for kk in range(n):
if sl[k] == "(":
p += 1
else:
if p == 1:
b += 1
elif p == 0:
b = 0
break
p -= 1
k = (k+1) % n
# print(sl,b,i,j)
if b > ans:
ans = b
ai = [i+1, j+1]
print(ans)
print(ai[0], ai[1])
```
No
| 86,719 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You play a computer game. In this game, you lead a party of m heroes, and you have to clear a dungeon with n monsters. Each monster is characterized by its power a_i. Each hero is characterized by his power p_i and endurance s_i.
The heroes clear the dungeon day by day. In the beginning of each day, you choose a hero (exactly one) who is going to enter the dungeon this day.
When the hero enters the dungeon, he is challenged by the first monster which was not defeated during the previous days (so, if the heroes have already defeated k monsters, the hero fights with the monster k + 1). When the hero fights the monster, there are two possible outcomes:
* if the monster's power is strictly greater than the hero's power, the hero retreats from the dungeon. The current day ends;
* otherwise, the monster is defeated.
After defeating a monster, the hero either continues fighting with the next monster or leaves the dungeon. He leaves the dungeon either if he has already defeated the number of monsters equal to his endurance during this day (so, the i-th hero cannot defeat more than s_i monsters during each day), or if all monsters are defeated — otherwise, he fights with the next monster. When the hero leaves the dungeon, the current day ends.
Your goal is to defeat the last monster. What is the minimum number of days that you need to achieve your goal? Each day you have to use exactly one hero; it is possible that some heroes don't fight the monsters at all. Each hero can be used arbitrary number of times.
Input
The first line contains one integer t (1 ≤ t ≤ 10^5) — the number of test cases. Then the test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of monsters in the dungeon.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the power of the i-th monster.
The third line contains one integer m (1 ≤ m ≤ 2 ⋅ 10^5) — the number of heroes in your party.
Then m lines follow, each describing a hero. Each line contains two integers p_i and s_i (1 ≤ p_i ≤ 10^9, 1 ≤ s_i ≤ n) — the power and the endurance of the i-th hero.
It is guaranteed that the sum of n + m over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print one integer — the minimum number of days you have to spend to defeat all of the monsters (or -1 if it is impossible).
Example
Input
2
6
2 3 11 14 1 8
2
3 2
100 1
5
3 5 100 2 3
2
30 5
90 1
Output
5
-1
Tags: binary search, data structures, dp, greedy, sortings, two pointers
Correct Solution:
```
def main():
t=int(input())
allans=[]
for _ in range(t):
n=int(input()) # monsters
a=readIntArr()
m=int(input()) # heroes
ps=[] # [p,s]
for __ in range(m):
ps.append(readIntArr())
maxMonsterPower=max(a)
maxHeroPower=0
for p,s in ps:
maxHeroPower=max(maxHeroPower,p)
if maxMonsterPower>maxHeroPower:
allans.append(-1)
continue
maxPower=[-1 for _ in range(n+1)] # maxPower[endurance] is the max power of all heroes with s>=endurance
for p,s in ps:
maxPower[s]=max(maxPower[s],p)
# print(maxPower)
for i in range(n-1,-1,-1):
maxPower[i]=max(maxPower[i],maxPower[i+1])
# print('maxPower:{}'.format(maxPower))
currMonst=0
nDays=0
while currMonst<n:
nDays+=1
nextMonst=currMonst
monstMax=a[nextMonst]
for nMonst in range(1,n+1):
# print('maxP:{} nMonst:{} a:{} nextMonst:{}'.format(maxPower,nMonst,a,nextMonst))
if maxPower[nMonst]<monstMax:
assert nMonst!=1 # should be larger than 1
break
nextMonst+=1
if nextMonst==n:
break
monstMax=max(monstMax,a[nextMonst])
# print('currMonst:{} nDays:{} nMonst:{} nextMonst:{}'.format(currMonst,nDays,nMonst,nextMonst))
assert nextMonst>currMonst
currMonst=nextMonst
allans.append(nDays)
multiLineArrayPrint(allans)
return
import sys
input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
# input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.
def oneLineArrayPrint(arr):
print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))
def readIntArr():
return [int(x) for x in input().split()]
# def readFloatArr():
# return [float(x) for x in input().split()]
def makeArr(defaultVal,dimensionArr): # eg. makeArr(0,[n,m])
dv=defaultVal;da=dimensionArr
if len(da)==1:return [dv for _ in range(da[0])]
else:return [makeArr(dv,da[1:]) for _ in range(da[0])]
def queryInteractive(x,y):
print('? {} {}'.format(x,y))
sys.stdout.flush()
return int(input())
def answerInteractive(ans):
print('! {}'.format(ans))
sys.stdout.flush()
inf=float('inf')
MOD=10**9+7
for _abc in range(1):
main()
```
| 86,720 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You play a computer game. In this game, you lead a party of m heroes, and you have to clear a dungeon with n monsters. Each monster is characterized by its power a_i. Each hero is characterized by his power p_i and endurance s_i.
The heroes clear the dungeon day by day. In the beginning of each day, you choose a hero (exactly one) who is going to enter the dungeon this day.
When the hero enters the dungeon, he is challenged by the first monster which was not defeated during the previous days (so, if the heroes have already defeated k monsters, the hero fights with the monster k + 1). When the hero fights the monster, there are two possible outcomes:
* if the monster's power is strictly greater than the hero's power, the hero retreats from the dungeon. The current day ends;
* otherwise, the monster is defeated.
After defeating a monster, the hero either continues fighting with the next monster or leaves the dungeon. He leaves the dungeon either if he has already defeated the number of monsters equal to his endurance during this day (so, the i-th hero cannot defeat more than s_i monsters during each day), or if all monsters are defeated — otherwise, he fights with the next monster. When the hero leaves the dungeon, the current day ends.
Your goal is to defeat the last monster. What is the minimum number of days that you need to achieve your goal? Each day you have to use exactly one hero; it is possible that some heroes don't fight the monsters at all. Each hero can be used arbitrary number of times.
Input
The first line contains one integer t (1 ≤ t ≤ 10^5) — the number of test cases. Then the test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of monsters in the dungeon.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the power of the i-th monster.
The third line contains one integer m (1 ≤ m ≤ 2 ⋅ 10^5) — the number of heroes in your party.
Then m lines follow, each describing a hero. Each line contains two integers p_i and s_i (1 ≤ p_i ≤ 10^9, 1 ≤ s_i ≤ n) — the power and the endurance of the i-th hero.
It is guaranteed that the sum of n + m over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print one integer — the minimum number of days you have to spend to defeat all of the monsters (or -1 if it is impossible).
Example
Input
2
6
2 3 11 14 1 8
2
3 2
100 1
5
3 5 100 2 3
2
30 5
90 1
Output
5
-1
Tags: binary search, data structures, dp, greedy, sortings, two pointers
Correct Solution:
```
import math
from collections import Counter
import math
for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
m = int(input())
d=[0]*(n+1)
for i in range(m):
u,v=map(int,input().split())
d[v]=max(d[v],u)
for i in range(n-1,-1,-1):
d[i]=max(d[i],d[i+1])
#print(d)
ans=1
cnt=1
ma=0
if d[1]<max(arr):
ans=-1
else:
for i in arr:
ma = max(ma, i)
if d[cnt] < ma:
cnt = 1
ans += 1
ma=i
cnt += 1
print(ans)
```
| 86,721 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You play a computer game. In this game, you lead a party of m heroes, and you have to clear a dungeon with n monsters. Each monster is characterized by its power a_i. Each hero is characterized by his power p_i and endurance s_i.
The heroes clear the dungeon day by day. In the beginning of each day, you choose a hero (exactly one) who is going to enter the dungeon this day.
When the hero enters the dungeon, he is challenged by the first monster which was not defeated during the previous days (so, if the heroes have already defeated k monsters, the hero fights with the monster k + 1). When the hero fights the monster, there are two possible outcomes:
* if the monster's power is strictly greater than the hero's power, the hero retreats from the dungeon. The current day ends;
* otherwise, the monster is defeated.
After defeating a monster, the hero either continues fighting with the next monster or leaves the dungeon. He leaves the dungeon either if he has already defeated the number of monsters equal to his endurance during this day (so, the i-th hero cannot defeat more than s_i monsters during each day), or if all monsters are defeated — otherwise, he fights with the next monster. When the hero leaves the dungeon, the current day ends.
Your goal is to defeat the last monster. What is the minimum number of days that you need to achieve your goal? Each day you have to use exactly one hero; it is possible that some heroes don't fight the monsters at all. Each hero can be used arbitrary number of times.
Input
The first line contains one integer t (1 ≤ t ≤ 10^5) — the number of test cases. Then the test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of monsters in the dungeon.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the power of the i-th monster.
The third line contains one integer m (1 ≤ m ≤ 2 ⋅ 10^5) — the number of heroes in your party.
Then m lines follow, each describing a hero. Each line contains two integers p_i and s_i (1 ≤ p_i ≤ 10^9, 1 ≤ s_i ≤ n) — the power and the endurance of the i-th hero.
It is guaranteed that the sum of n + m over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print one integer — the minimum number of days you have to spend to defeat all of the monsters (or -1 if it is impossible).
Example
Input
2
6
2 3 11 14 1 8
2
3 2
100 1
5
3 5 100 2 3
2
30 5
90 1
Output
5
-1
Tags: binary search, data structures, dp, greedy, sortings, two pointers
Correct Solution:
```
mod=10**9+7
import sys
sys.setrecursionlimit(10**6)
from sys import stdin, stdout
import bisect
from bisect import bisect_left as bl #c++ lowerbound bl(array,element)
from bisect import bisect_right as br #c++ upperbound
import itertools
import collections
import math
import heapq
import random
def modinv(n,p):
return pow(n,p-2,p)
def ncr(n,r,p): #for using this uncomment the lines calculating fact and ifact
t=((fact[n])*((ifact[r]*ifact[n-r])%p))%p
return t
def cin():
return map(int,sin().split())
def ain(): #takes array as input
return list(map(int,sin().split()))
def sin():
return input()
def inin():
return int(input())
def GCD(x,y):
while(y):
x, y = y, x % y
return x
"""*******************************************************"""
def main():
t=inin()
for _ in range(t):
n=inin()
a=ain()
m=inin()
p=[]
e=[]
d={}
for i in range(m):
j,k=cin()
p.append((j,k))
p.sort(reverse=True)
x=0
for i in p:
if(i[1]>x):
e.append(i)
x=max(x,i[1])
y=n-1
p=[]
for i in e:
p.append(i[0])
d[i[0]]=i[1]
p.sort()
nn=len(p)
ans=0
# print(a,p,d,ans)
b=[]
m=0
j=0
for i in a:
m=max(i,m)
j+=1
x=bisect.bisect_right(p,m-1,0,nn-1)
if(m>p[x]):
ans=-2
break
if(j>d[p[x]]):
ans+=1
j=1
m=i
# print(i)
print(ans+1)
######## Python 2 and 3 footer by Pajenegod and c1729
py2 = round(0.5)
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192
class FastIO(BytesIO):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.writable = "x" in file.mode or "w" in file.mode
self.write = super(FastIO, self).write if self.writable else None
def _fill(self):
s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
return s
def read(self):
while self._fill(): pass
return super(FastIO,self).read()
def readline(self):
while self.newlines == 0:
s = self._fill(); self.newlines = s.count(b"\n") + (not s)
self.newlines -= 1
return super(FastIO, self).readline()
def flush(self):
if self.writable:
os.write(self._fd, self.getvalue())
self.truncate(0), self.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
if py2:
self.write = self.buffer.write
self.read = self.buffer.read
self.readline = self.buffer.readline
else:
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')
# Cout implemented in Python
import sys
class ostream:
def __lshift__(self,a):
sys.stdout.write(str(a))
return self
cout = ostream()
endl = '\n'
# Read all remaining integers in stdin, type is given by optional argument, this is fast
def readnumbers(zero = 0):
conv = ord if py2 else lambda x:x
A = []; numb = zero; sign = 1; i = 0; s = sys.stdin.buffer.read()
try:
while True:
if s[i] >= b'0' [0]:
numb = 10 * numb + conv(s[i]) - 48
elif s[i] == b'-' [0]: sign = -1
elif s[i] != b'\r' [0]:
A.append(sign*numb)
numb = zero; sign = 1
i += 1
except:pass
if s and s[-1] >= b'0' [0]:
A.append(sign*numb)
return A
if __name__== "__main__":
main()
```
| 86,722 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You play a computer game. In this game, you lead a party of m heroes, and you have to clear a dungeon with n monsters. Each monster is characterized by its power a_i. Each hero is characterized by his power p_i and endurance s_i.
The heroes clear the dungeon day by day. In the beginning of each day, you choose a hero (exactly one) who is going to enter the dungeon this day.
When the hero enters the dungeon, he is challenged by the first monster which was not defeated during the previous days (so, if the heroes have already defeated k monsters, the hero fights with the monster k + 1). When the hero fights the monster, there are two possible outcomes:
* if the monster's power is strictly greater than the hero's power, the hero retreats from the dungeon. The current day ends;
* otherwise, the monster is defeated.
After defeating a monster, the hero either continues fighting with the next monster or leaves the dungeon. He leaves the dungeon either if he has already defeated the number of monsters equal to his endurance during this day (so, the i-th hero cannot defeat more than s_i monsters during each day), or if all monsters are defeated — otherwise, he fights with the next monster. When the hero leaves the dungeon, the current day ends.
Your goal is to defeat the last monster. What is the minimum number of days that you need to achieve your goal? Each day you have to use exactly one hero; it is possible that some heroes don't fight the monsters at all. Each hero can be used arbitrary number of times.
Input
The first line contains one integer t (1 ≤ t ≤ 10^5) — the number of test cases. Then the test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of monsters in the dungeon.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the power of the i-th monster.
The third line contains one integer m (1 ≤ m ≤ 2 ⋅ 10^5) — the number of heroes in your party.
Then m lines follow, each describing a hero. Each line contains two integers p_i and s_i (1 ≤ p_i ≤ 10^9, 1 ≤ s_i ≤ n) — the power and the endurance of the i-th hero.
It is guaranteed that the sum of n + m over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print one integer — the minimum number of days you have to spend to defeat all of the monsters (or -1 if it is impossible).
Example
Input
2
6
2 3 11 14 1 8
2
3 2
100 1
5
3 5 100 2 3
2
30 5
90 1
Output
5
-1
Tags: binary search, data structures, dp, greedy, sortings, two pointers
Correct Solution:
```
import bisect
import sys
input=sys.stdin.readline
for _ in range(int(input())):
n=int(input())
ar=list(map(int,input().split()))
m=int(input())
po=[]
for i in range(m):
po.append(list(map(int,input().split())))
po.sort(key=lambda x:x[0])
en=[0]*m
powd=[]
ma=0
for i in range(1,m+1):
powd.append(po[i-1][0])
ma=max(ma,po[-i][1])
en[-i]=ma
if(max(ar)>max(powd)):
print(-1)
else:
ans=1
count=0
prev=bisect.bisect_left(powd,ar[0])
for i in range(n):
xx=bisect.bisect_left(powd,ar[i])
if(xx>=prev):
prev=xx
if(en[prev]>=count+1):
count+=1
else:
if(xx<prev):
prev=xx
count=1
ans+=1
print(ans)
```
| 86,723 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You play a computer game. In this game, you lead a party of m heroes, and you have to clear a dungeon with n monsters. Each monster is characterized by its power a_i. Each hero is characterized by his power p_i and endurance s_i.
The heroes clear the dungeon day by day. In the beginning of each day, you choose a hero (exactly one) who is going to enter the dungeon this day.
When the hero enters the dungeon, he is challenged by the first monster which was not defeated during the previous days (so, if the heroes have already defeated k monsters, the hero fights with the monster k + 1). When the hero fights the monster, there are two possible outcomes:
* if the monster's power is strictly greater than the hero's power, the hero retreats from the dungeon. The current day ends;
* otherwise, the monster is defeated.
After defeating a monster, the hero either continues fighting with the next monster or leaves the dungeon. He leaves the dungeon either if he has already defeated the number of monsters equal to his endurance during this day (so, the i-th hero cannot defeat more than s_i monsters during each day), or if all monsters are defeated — otherwise, he fights with the next monster. When the hero leaves the dungeon, the current day ends.
Your goal is to defeat the last monster. What is the minimum number of days that you need to achieve your goal? Each day you have to use exactly one hero; it is possible that some heroes don't fight the monsters at all. Each hero can be used arbitrary number of times.
Input
The first line contains one integer t (1 ≤ t ≤ 10^5) — the number of test cases. Then the test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of monsters in the dungeon.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the power of the i-th monster.
The third line contains one integer m (1 ≤ m ≤ 2 ⋅ 10^5) — the number of heroes in your party.
Then m lines follow, each describing a hero. Each line contains two integers p_i and s_i (1 ≤ p_i ≤ 10^9, 1 ≤ s_i ≤ n) — the power and the endurance of the i-th hero.
It is guaranteed that the sum of n + m over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print one integer — the minimum number of days you have to spend to defeat all of the monsters (or -1 if it is impossible).
Example
Input
2
6
2 3 11 14 1 8
2
3 2
100 1
5
3 5 100 2 3
2
30 5
90 1
Output
5
-1
Tags: binary search, data structures, dp, greedy, sortings, two pointers
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO,IOBase
def cons(n,x):
xx = n.bit_length()
dp = [[0]*n for _ in range(xx)]
dp[0] = x
for i in range(1,xx):
for j in range(n-(1<<i)+1):
dp[i][j] = max(dp[i-1][j],dp[i-1][j+(1<<(i-1))])
return dp
def ask(l,r,dp):
""" l and r inclusive 0 based"""
xx1 = (r-l+1).bit_length()-1
return max(dp[xx1][l],dp[xx1][r-(1<<xx1)+1])
def solve(n,a):
day = [0]*(n+1)
for _ in range(int(input())):
p,s = map(int,input().split())
day[s] = max(day[s],p)
for i in range(n-1,-1,-1):
day[i] = max(day[i],day[i+1])
if max(a) > day[0]:
return -1
dp = cons(n,a)
val,i = 0,0
while i != n:
hi,lo,ans = n-1,i,i
while hi >= lo:
mid = (hi+lo)//2
maxi = ask(i,mid,dp)
if day[mid-i+1] >= maxi:
lo = mid+1
ans = mid
else:
hi = mid-1
i = ans+1
val += 1
return val
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()
```
| 86,724 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You play a computer game. In this game, you lead a party of m heroes, and you have to clear a dungeon with n monsters. Each monster is characterized by its power a_i. Each hero is characterized by his power p_i and endurance s_i.
The heroes clear the dungeon day by day. In the beginning of each day, you choose a hero (exactly one) who is going to enter the dungeon this day.
When the hero enters the dungeon, he is challenged by the first monster which was not defeated during the previous days (so, if the heroes have already defeated k monsters, the hero fights with the monster k + 1). When the hero fights the monster, there are two possible outcomes:
* if the monster's power is strictly greater than the hero's power, the hero retreats from the dungeon. The current day ends;
* otherwise, the monster is defeated.
After defeating a monster, the hero either continues fighting with the next monster or leaves the dungeon. He leaves the dungeon either if he has already defeated the number of monsters equal to his endurance during this day (so, the i-th hero cannot defeat more than s_i monsters during each day), or if all monsters are defeated — otherwise, he fights with the next monster. When the hero leaves the dungeon, the current day ends.
Your goal is to defeat the last monster. What is the minimum number of days that you need to achieve your goal? Each day you have to use exactly one hero; it is possible that some heroes don't fight the monsters at all. Each hero can be used arbitrary number of times.
Input
The first line contains one integer t (1 ≤ t ≤ 10^5) — the number of test cases. Then the test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of monsters in the dungeon.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the power of the i-th monster.
The third line contains one integer m (1 ≤ m ≤ 2 ⋅ 10^5) — the number of heroes in your party.
Then m lines follow, each describing a hero. Each line contains two integers p_i and s_i (1 ≤ p_i ≤ 10^9, 1 ≤ s_i ≤ n) — the power and the endurance of the i-th hero.
It is guaranteed that the sum of n + m over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print one integer — the minimum number of days you have to spend to defeat all of the monsters (or -1 if it is impossible).
Example
Input
2
6
2 3 11 14 1 8
2
3 2
100 1
5
3 5 100 2 3
2
30 5
90 1
Output
5
-1
Tags: binary search, data structures, dp, greedy, sortings, two pointers
Correct Solution:
```
import os, sys, bisect, copy
from collections import defaultdict, Counter, deque
from functools import lru_cache #use @lru_cache(None)
if os.path.exists('in.txt'): sys.stdin=open('in.txt','r')
if os.path.exists('out.txt'): sys.stdout=open('out.txt', 'w')
#
def input(): return sys.stdin.readline()
def mapi(arg=0): return map(int if arg==0 else str,input().split())
#------------------------------------------------------------------
for _ in range(int(input())):
n = int(input())
a = list(mapi())
m = int(input())
heroes = []
mxp = defaultdict(int)
for i in range(m):
p,s =mapi()
heroes.append([p,s])
mxp[s] = max(mxp[s],p)
for i in range(n-1,-1,-1):
mxp[i] = max(mxp[i+1],mxp[i])
#print(*mxp)
if mxp[0]<max(a):
print(-1)
continue
res = 0
cnt = 0
mx = 0
for x in a:
cnt+=1
mx = max(mx,x)
if mxp[cnt]<mx:
res+=1
mx = x
cnt = 1
if cnt>0:
res+=1
print(res)
```
| 86,725 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You play a computer game. In this game, you lead a party of m heroes, and you have to clear a dungeon with n monsters. Each monster is characterized by its power a_i. Each hero is characterized by his power p_i and endurance s_i.
The heroes clear the dungeon day by day. In the beginning of each day, you choose a hero (exactly one) who is going to enter the dungeon this day.
When the hero enters the dungeon, he is challenged by the first monster which was not defeated during the previous days (so, if the heroes have already defeated k monsters, the hero fights with the monster k + 1). When the hero fights the monster, there are two possible outcomes:
* if the monster's power is strictly greater than the hero's power, the hero retreats from the dungeon. The current day ends;
* otherwise, the monster is defeated.
After defeating a monster, the hero either continues fighting with the next monster or leaves the dungeon. He leaves the dungeon either if he has already defeated the number of monsters equal to his endurance during this day (so, the i-th hero cannot defeat more than s_i monsters during each day), or if all monsters are defeated — otherwise, he fights with the next monster. When the hero leaves the dungeon, the current day ends.
Your goal is to defeat the last monster. What is the minimum number of days that you need to achieve your goal? Each day you have to use exactly one hero; it is possible that some heroes don't fight the monsters at all. Each hero can be used arbitrary number of times.
Input
The first line contains one integer t (1 ≤ t ≤ 10^5) — the number of test cases. Then the test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of monsters in the dungeon.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the power of the i-th monster.
The third line contains one integer m (1 ≤ m ≤ 2 ⋅ 10^5) — the number of heroes in your party.
Then m lines follow, each describing a hero. Each line contains two integers p_i and s_i (1 ≤ p_i ≤ 10^9, 1 ≤ s_i ≤ n) — the power and the endurance of the i-th hero.
It is guaranteed that the sum of n + m over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print one integer — the minimum number of days you have to spend to defeat all of the monsters (or -1 if it is impossible).
Example
Input
2
6
2 3 11 14 1 8
2
3 2
100 1
5
3 5 100 2 3
2
30 5
90 1
Output
5
-1
Tags: binary search, data structures, dp, greedy, sortings, two pointers
Correct Solution:
```
import sys
input = sys.stdin.readline
t = int(input())
ANS = []
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
m = int(input())
ps = [list(map(int, input().split())) for _ in range(m)]
p = [0] * (n + 1)
for i in range(m):
p[ps[i][1]] = max(p[ps[i][1]], ps[i][0])
for i in range(n)[::-1]:
p[i] = max(p[i], p[i + 1])
if p[1] < max(a):
print(-1)
continue
ans = 0
mx = 0
cnt = 0
i = 0
for x in a:
cnt += 1
mx = max(mx, x)
if p[cnt] < mx:
ans += 1
mx = x
cnt = 1
if cnt:
ans += 1
print(ans)
```
| 86,726 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You play a computer game. In this game, you lead a party of m heroes, and you have to clear a dungeon with n monsters. Each monster is characterized by its power a_i. Each hero is characterized by his power p_i and endurance s_i.
The heroes clear the dungeon day by day. In the beginning of each day, you choose a hero (exactly one) who is going to enter the dungeon this day.
When the hero enters the dungeon, he is challenged by the first monster which was not defeated during the previous days (so, if the heroes have already defeated k monsters, the hero fights with the monster k + 1). When the hero fights the monster, there are two possible outcomes:
* if the monster's power is strictly greater than the hero's power, the hero retreats from the dungeon. The current day ends;
* otherwise, the monster is defeated.
After defeating a monster, the hero either continues fighting with the next monster or leaves the dungeon. He leaves the dungeon either if he has already defeated the number of monsters equal to his endurance during this day (so, the i-th hero cannot defeat more than s_i monsters during each day), or if all monsters are defeated — otherwise, he fights with the next monster. When the hero leaves the dungeon, the current day ends.
Your goal is to defeat the last monster. What is the minimum number of days that you need to achieve your goal? Each day you have to use exactly one hero; it is possible that some heroes don't fight the monsters at all. Each hero can be used arbitrary number of times.
Input
The first line contains one integer t (1 ≤ t ≤ 10^5) — the number of test cases. Then the test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of monsters in the dungeon.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the power of the i-th monster.
The third line contains one integer m (1 ≤ m ≤ 2 ⋅ 10^5) — the number of heroes in your party.
Then m lines follow, each describing a hero. Each line contains two integers p_i and s_i (1 ≤ p_i ≤ 10^9, 1 ≤ s_i ≤ n) — the power and the endurance of the i-th hero.
It is guaranteed that the sum of n + m over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print one integer — the minimum number of days you have to spend to defeat all of the monsters (or -1 if it is impossible).
Example
Input
2
6
2 3 11 14 1 8
2
3 2
100 1
5
3 5 100 2 3
2
30 5
90 1
Output
5
-1
Tags: binary search, data structures, dp, greedy, sortings, two pointers
Correct Solution:
```
import sys
input = sys.stdin.readline
class RangeMinimumQuery:
def __init__(self, n, func=min, inf=float("inf")):
self.n0 = 2**(n-1).bit_length()
self.op = func
self.inf = inf
self.data = [self.inf]*(2*self.n0-1)
def query(self, l,r):
l += self.n0
r += self.n0
res = self.inf
while l < r:
if r&1:
r -= 1
res = self.op(res, self.data[r-1])
if l&1:
res = self.op(res, self.data[l-1])
l += 1
l >>=1
r >>=1
return res
def update(self, i, x):
i += self.n0-1
self.data[i] = x
while i+1:
i = ~-i//2
self.data[i] = self.op(self.data[2*i+1], self.data[2*i+2])
def solve():
n = int(input())
a = list(map(int, input().split()))
RMQ = RangeMinimumQuery(n, func=max, inf=0)
for i, ai in enumerate(a):
RMQ.update(i, ai)
m = int(input())
ps = [list(map(int, input().split())) for i in range(m)]
bst = [0]*(n+1)
for p,s in ps:
bst[s] = max(bst[s], p)
for i in reversed(range(1,n+1)):
bst[i-1] = max(bst[i-1], bst[i])
cur = -1
ans = 0
while cur != n-1:
left = cur
right = n
while right-left>1:
mid = (right+left)//2
x = mid-cur
if RMQ.query(cur+1, mid+1) > bst[x]:
right=mid
else:
left=mid
if left == cur:
print(-1)
return
cur = left
ans += 1
print(ans)
t = int(input())
for i in range(t):
solve()
```
| 86,727 |
Provide tags and a correct Python 2 solution for this coding contest problem.
You play a computer game. In this game, you lead a party of m heroes, and you have to clear a dungeon with n monsters. Each monster is characterized by its power a_i. Each hero is characterized by his power p_i and endurance s_i.
The heroes clear the dungeon day by day. In the beginning of each day, you choose a hero (exactly one) who is going to enter the dungeon this day.
When the hero enters the dungeon, he is challenged by the first monster which was not defeated during the previous days (so, if the heroes have already defeated k monsters, the hero fights with the monster k + 1). When the hero fights the monster, there are two possible outcomes:
* if the monster's power is strictly greater than the hero's power, the hero retreats from the dungeon. The current day ends;
* otherwise, the monster is defeated.
After defeating a monster, the hero either continues fighting with the next monster or leaves the dungeon. He leaves the dungeon either if he has already defeated the number of monsters equal to his endurance during this day (so, the i-th hero cannot defeat more than s_i monsters during each day), or if all monsters are defeated — otherwise, he fights with the next monster. When the hero leaves the dungeon, the current day ends.
Your goal is to defeat the last monster. What is the minimum number of days that you need to achieve your goal? Each day you have to use exactly one hero; it is possible that some heroes don't fight the monsters at all. Each hero can be used arbitrary number of times.
Input
The first line contains one integer t (1 ≤ t ≤ 10^5) — the number of test cases. Then the test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of monsters in the dungeon.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the power of the i-th monster.
The third line contains one integer m (1 ≤ m ≤ 2 ⋅ 10^5) — the number of heroes in your party.
Then m lines follow, each describing a hero. Each line contains two integers p_i and s_i (1 ≤ p_i ≤ 10^9, 1 ≤ s_i ≤ n) — the power and the endurance of the i-th hero.
It is guaranteed that the sum of n + m over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print one integer — the minimum number of days you have to spend to defeat all of the monsters (or -1 if it is impossible).
Example
Input
2
6
2 3 11 14 1 8
2
3 2
100 1
5
3 5 100 2 3
2
30 5
90 1
Output
5
-1
Tags: binary search, data structures, dp, greedy, sortings, two pointers
Correct Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
pr=stdout.write
raw_input = stdin.readline
def ni():
return int(raw_input())
def li():
return list(map(int,raw_input().split()))
def pn(n):
stdout.write(str(n)+'\n')
def pa(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return (map(int,stdin.read().split()))
range = xrange # not for python 3.0+
# main code
for t in range(ni()):
n=ni()
l=li()
m=ni()
dp=[0]*(n+1)
i=0
for i in range(m):
x,y=li()
dp[y]=max(dp[y],x)
f=0
ans=0
for i in range(n-1,0,-1):
dp[i]=max(dp[i+1],dp[i])
i=0
while i<n:
if l[i]>dp[1]:
f=1
break
ln=1
mx=l[i]
while i<n-1 and dp[ln+1]>=max(mx,l[i+1]):
i+=1
ln+=1
mx=max(mx,l[i])
ans+=1
i+=1
if f:
pn(-1)
else:
pn(ans)
```
| 86,728 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You play a computer game. In this game, you lead a party of m heroes, and you have to clear a dungeon with n monsters. Each monster is characterized by its power a_i. Each hero is characterized by his power p_i and endurance s_i.
The heroes clear the dungeon day by day. In the beginning of each day, you choose a hero (exactly one) who is going to enter the dungeon this day.
When the hero enters the dungeon, he is challenged by the first monster which was not defeated during the previous days (so, if the heroes have already defeated k monsters, the hero fights with the monster k + 1). When the hero fights the monster, there are two possible outcomes:
* if the monster's power is strictly greater than the hero's power, the hero retreats from the dungeon. The current day ends;
* otherwise, the monster is defeated.
After defeating a monster, the hero either continues fighting with the next monster or leaves the dungeon. He leaves the dungeon either if he has already defeated the number of monsters equal to his endurance during this day (so, the i-th hero cannot defeat more than s_i monsters during each day), or if all monsters are defeated — otherwise, he fights with the next monster. When the hero leaves the dungeon, the current day ends.
Your goal is to defeat the last monster. What is the minimum number of days that you need to achieve your goal? Each day you have to use exactly one hero; it is possible that some heroes don't fight the monsters at all. Each hero can be used arbitrary number of times.
Input
The first line contains one integer t (1 ≤ t ≤ 10^5) — the number of test cases. Then the test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of monsters in the dungeon.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the power of the i-th monster.
The third line contains one integer m (1 ≤ m ≤ 2 ⋅ 10^5) — the number of heroes in your party.
Then m lines follow, each describing a hero. Each line contains two integers p_i and s_i (1 ≤ p_i ≤ 10^9, 1 ≤ s_i ≤ n) — the power and the endurance of the i-th hero.
It is guaranteed that the sum of n + m over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print one integer — the minimum number of days you have to spend to defeat all of the monsters (or -1 if it is impossible).
Example
Input
2
6
2 3 11 14 1 8
2
3 2
100 1
5
3 5 100 2 3
2
30 5
90 1
Output
5
-1
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
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")
##########################################################
import math
#n,m=map(int,input().split())
from collections import Counter
#for i in range(n):
import math
for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
m = int(input())
d=[0]*(n+1)
for i in range(m):
u,v=map(int,input().split())
d[v]=max(d[v],u)
for i in range(n-1,-1,-1):
d[i]=max(d[i],d[i+1])
ans=1
cnt=1
ma=0
if d[1]<max(arr):
ans=-1
else:
for i in arr:
ma = max(ma, i)
if d[cnt] < ma:
cnt = 1
ans += 1
ma=i
cnt += 1
print(ans)
```
Yes
| 86,729 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You play a computer game. In this game, you lead a party of m heroes, and you have to clear a dungeon with n monsters. Each monster is characterized by its power a_i. Each hero is characterized by his power p_i and endurance s_i.
The heroes clear the dungeon day by day. In the beginning of each day, you choose a hero (exactly one) who is going to enter the dungeon this day.
When the hero enters the dungeon, he is challenged by the first monster which was not defeated during the previous days (so, if the heroes have already defeated k monsters, the hero fights with the monster k + 1). When the hero fights the monster, there are two possible outcomes:
* if the monster's power is strictly greater than the hero's power, the hero retreats from the dungeon. The current day ends;
* otherwise, the monster is defeated.
After defeating a monster, the hero either continues fighting with the next monster or leaves the dungeon. He leaves the dungeon either if he has already defeated the number of monsters equal to his endurance during this day (so, the i-th hero cannot defeat more than s_i monsters during each day), or if all monsters are defeated — otherwise, he fights with the next monster. When the hero leaves the dungeon, the current day ends.
Your goal is to defeat the last monster. What is the minimum number of days that you need to achieve your goal? Each day you have to use exactly one hero; it is possible that some heroes don't fight the monsters at all. Each hero can be used arbitrary number of times.
Input
The first line contains one integer t (1 ≤ t ≤ 10^5) — the number of test cases. Then the test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of monsters in the dungeon.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the power of the i-th monster.
The third line contains one integer m (1 ≤ m ≤ 2 ⋅ 10^5) — the number of heroes in your party.
Then m lines follow, each describing a hero. Each line contains two integers p_i and s_i (1 ≤ p_i ≤ 10^9, 1 ≤ s_i ≤ n) — the power and the endurance of the i-th hero.
It is guaranteed that the sum of n + m over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print one integer — the minimum number of days you have to spend to defeat all of the monsters (or -1 if it is impossible).
Example
Input
2
6
2 3 11 14 1 8
2
3 2
100 1
5
3 5 100 2 3
2
30 5
90 1
Output
5
-1
Submitted Solution:
```
import sys
input = sys.stdin.readline
t = int(input())
ANS = []
for _ in range(t):
n = int(input())
a = list(map(int,input().split()))
m = int(input())
ps = [list(map(int, input().split())) for _ in range(m)]
p = [0] * (n+1)
for i in range(m):
p[ps[i][1]] = max(p[ps[i][1]], ps[i][0])
for i in range(n)[::-1]:
p[i] = max(p[i], p[i + 1])
if p[1] < max(a):
ANS.append(-1)
continue
ans = 0
mx = 0
cnt = 0
i = 0
for x in a:
cnt += 1
mx = max(mx, x)
if p[cnt] < mx:
ans += 1
mx = x
cnt = 1
if cnt:
ans += 1
ANS.append(ans)
print('\n'.join(map(str, ANS)))
```
Yes
| 86,730 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You play a computer game. In this game, you lead a party of m heroes, and you have to clear a dungeon with n monsters. Each monster is characterized by its power a_i. Each hero is characterized by his power p_i and endurance s_i.
The heroes clear the dungeon day by day. In the beginning of each day, you choose a hero (exactly one) who is going to enter the dungeon this day.
When the hero enters the dungeon, he is challenged by the first monster which was not defeated during the previous days (so, if the heroes have already defeated k monsters, the hero fights with the monster k + 1). When the hero fights the monster, there are two possible outcomes:
* if the monster's power is strictly greater than the hero's power, the hero retreats from the dungeon. The current day ends;
* otherwise, the monster is defeated.
After defeating a monster, the hero either continues fighting with the next monster or leaves the dungeon. He leaves the dungeon either if he has already defeated the number of monsters equal to his endurance during this day (so, the i-th hero cannot defeat more than s_i monsters during each day), or if all monsters are defeated — otherwise, he fights with the next monster. When the hero leaves the dungeon, the current day ends.
Your goal is to defeat the last monster. What is the minimum number of days that you need to achieve your goal? Each day you have to use exactly one hero; it is possible that some heroes don't fight the monsters at all. Each hero can be used arbitrary number of times.
Input
The first line contains one integer t (1 ≤ t ≤ 10^5) — the number of test cases. Then the test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of monsters in the dungeon.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the power of the i-th monster.
The third line contains one integer m (1 ≤ m ≤ 2 ⋅ 10^5) — the number of heroes in your party.
Then m lines follow, each describing a hero. Each line contains two integers p_i and s_i (1 ≤ p_i ≤ 10^9, 1 ≤ s_i ≤ n) — the power and the endurance of the i-th hero.
It is guaranteed that the sum of n + m over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print one integer — the minimum number of days you have to spend to defeat all of the monsters (or -1 if it is impossible).
Example
Input
2
6
2 3 11 14 1 8
2
3 2
100 1
5
3 5 100 2 3
2
30 5
90 1
Output
5
-1
Submitted Solution:
```
import sys
input = sys.stdin.readline
def init_max(init_max_val):
#set_val
for i in range(n):
seg_max[i+num_max-1]=init_max_val[i]
#built
for i in range(num_max-2,-1,-1) :
seg_max[i]=max(seg_max[2*i+1],seg_max[2*i+2])
def update_max(k,x):
k += num_max-1
seg_max[k] = x
while k:
k = (k-1)//2
seg_max[k] = max(seg_max[k*2+1],seg_max[k*2+2])
def query_max(p,q):
if q<=p:
return ide_ele_max
p += num_max-1
q += num_max-2
res=ide_ele_max
while q-p>1:
if p&1 == 0:
res = max(res,seg_max[p])
if q&1 == 1:
res = max(res,seg_max[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = max(res,seg_max[p])
else:
res = max(max(res,seg_max[p]),seg_max[q])
return res
qq = int(input())
for testcases in [0]*qq:
n = int(input())
a = list(map(int,input().split()))
m = int(input())
p = [-1]*n
for _ in [0]*m:
x,y = map(int,input().split())
p[y-1] = max(p[y-1],x)
tmp_max = -1
for i in range(n-1,-1,-1):
tmp_max = max(tmp_max,p[i])
p[i] = tmp_max
if p[0] < max(a):
print(-1)
continue
if n == 1:
print(1)
continue
if n == 2:
if p[1] >= a[0] and p[1] >= a[1]:
print(1)
else:
print(2)
continue
ide_ele_max = -1
num_max =2**(n-1).bit_length()
seg_max=[ide_ele_max]*2*num_max
init_max(a)
#print(p)
start = 0
res = 0
while start < n:
ok = 0
ng = n-start
while ng-ok > 1:
mid = (ok+ng)//2
if query_max(start,start+mid+1) <= p[mid]:
ok = mid
else:
ng = mid
res += 1
start += ok+1
print(res)
```
Yes
| 86,731 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You play a computer game. In this game, you lead a party of m heroes, and you have to clear a dungeon with n monsters. Each monster is characterized by its power a_i. Each hero is characterized by his power p_i and endurance s_i.
The heroes clear the dungeon day by day. In the beginning of each day, you choose a hero (exactly one) who is going to enter the dungeon this day.
When the hero enters the dungeon, he is challenged by the first monster which was not defeated during the previous days (so, if the heroes have already defeated k monsters, the hero fights with the monster k + 1). When the hero fights the monster, there are two possible outcomes:
* if the monster's power is strictly greater than the hero's power, the hero retreats from the dungeon. The current day ends;
* otherwise, the monster is defeated.
After defeating a monster, the hero either continues fighting with the next monster or leaves the dungeon. He leaves the dungeon either if he has already defeated the number of monsters equal to his endurance during this day (so, the i-th hero cannot defeat more than s_i monsters during each day), or if all monsters are defeated — otherwise, he fights with the next monster. When the hero leaves the dungeon, the current day ends.
Your goal is to defeat the last monster. What is the minimum number of days that you need to achieve your goal? Each day you have to use exactly one hero; it is possible that some heroes don't fight the monsters at all. Each hero can be used arbitrary number of times.
Input
The first line contains one integer t (1 ≤ t ≤ 10^5) — the number of test cases. Then the test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of monsters in the dungeon.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the power of the i-th monster.
The third line contains one integer m (1 ≤ m ≤ 2 ⋅ 10^5) — the number of heroes in your party.
Then m lines follow, each describing a hero. Each line contains two integers p_i and s_i (1 ≤ p_i ≤ 10^9, 1 ≤ s_i ≤ n) — the power and the endurance of the i-th hero.
It is guaranteed that the sum of n + m over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print one integer — the minimum number of days you have to spend to defeat all of the monsters (or -1 if it is impossible).
Example
Input
2
6
2 3 11 14 1 8
2
3 2
100 1
5
3 5 100 2 3
2
30 5
90 1
Output
5
-1
Submitted Solution:
```
from sys import stdin
input=stdin.readline
from bisect import *
t = int(input())
while t:
n = int(input())
a = list(map(int,input().split()))
m = int(input())
p = []
mx = max(a)
flag = 0
for i in range(m):
x, y = map(int,input().split())
if x >= mx:
flag = 1
p.append([y, x])
if not flag:
print(-1)
t -= 1
continue
p.sort(reverse=True)
pre = 0
np = []
for x, y in p:
if pre and y <= pre:
continue
pre = y
np.append([y, x])
ans = 0
i = 0
inf = float('inf')
while i < n:
# print(i)
cnt = 0
mx = 0
flag = 0
for j in range(i, n):
mx = max(mx, a[j])
pos = bisect_left(np, [mx, -inf])
# print(ans,t,mx,np[t])
if np[pos][1] < j - i + 1:
ans += 1
i = j
flag = 1
break
if not flag:
ans += 1
break
print(ans)
t -= 1
```
Yes
| 86,732 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You play a computer game. In this game, you lead a party of m heroes, and you have to clear a dungeon with n monsters. Each monster is characterized by its power a_i. Each hero is characterized by his power p_i and endurance s_i.
The heroes clear the dungeon day by day. In the beginning of each day, you choose a hero (exactly one) who is going to enter the dungeon this day.
When the hero enters the dungeon, he is challenged by the first monster which was not defeated during the previous days (so, if the heroes have already defeated k monsters, the hero fights with the monster k + 1). When the hero fights the monster, there are two possible outcomes:
* if the monster's power is strictly greater than the hero's power, the hero retreats from the dungeon. The current day ends;
* otherwise, the monster is defeated.
After defeating a monster, the hero either continues fighting with the next monster or leaves the dungeon. He leaves the dungeon either if he has already defeated the number of monsters equal to his endurance during this day (so, the i-th hero cannot defeat more than s_i monsters during each day), or if all monsters are defeated — otherwise, he fights with the next monster. When the hero leaves the dungeon, the current day ends.
Your goal is to defeat the last monster. What is the minimum number of days that you need to achieve your goal? Each day you have to use exactly one hero; it is possible that some heroes don't fight the monsters at all. Each hero can be used arbitrary number of times.
Input
The first line contains one integer t (1 ≤ t ≤ 10^5) — the number of test cases. Then the test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of monsters in the dungeon.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the power of the i-th monster.
The third line contains one integer m (1 ≤ m ≤ 2 ⋅ 10^5) — the number of heroes in your party.
Then m lines follow, each describing a hero. Each line contains two integers p_i and s_i (1 ≤ p_i ≤ 10^9, 1 ≤ s_i ≤ n) — the power and the endurance of the i-th hero.
It is guaranteed that the sum of n + m over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print one integer — the minimum number of days you have to spend to defeat all of the monsters (or -1 if it is impossible).
Example
Input
2
6
2 3 11 14 1 8
2
3 2
100 1
5
3 5 100 2 3
2
30 5
90 1
Output
5
-1
Submitted Solution:
```
# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase
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")
# ------------------- fast io --------------------
import bisect
testcases=int(input())
for j in range(testcases):
n=int(input())
monst=list(map(int,input().split()))
m=int(input())
hero=[]
for s in range(m):
p,s=map(int,input().split())
hero.append((p,s))
hero.sort(key= lambda x: x[0])
hero.reverse()
#look for more endurance
power=[]
endu=[]
for s in range(m):
h1=hero[s]
if s==0:
power.append(h1[0])
endu.append(h1[1])
else:
if h1[1]>endu[-1]:
power.append(h1[0])
endu.append(h1[1])
power.reverse()
endu.reverse()
days=0
monsofar=0
for s in range(n):
monster=monst[s]
ind=min(bisect.bisect_left(power,monster+1),len(power)-1)
if endu[ind]>=monsofar+1:
monsofar+=1
else:
days+=1
monsofar=1
if monsofar>=2:
days+=1
if power[-1]<max(monst):
print(-1)
else:
print(days)
```
No
| 86,733 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You play a computer game. In this game, you lead a party of m heroes, and you have to clear a dungeon with n monsters. Each monster is characterized by its power a_i. Each hero is characterized by his power p_i and endurance s_i.
The heroes clear the dungeon day by day. In the beginning of each day, you choose a hero (exactly one) who is going to enter the dungeon this day.
When the hero enters the dungeon, he is challenged by the first monster which was not defeated during the previous days (so, if the heroes have already defeated k monsters, the hero fights with the monster k + 1). When the hero fights the monster, there are two possible outcomes:
* if the monster's power is strictly greater than the hero's power, the hero retreats from the dungeon. The current day ends;
* otherwise, the monster is defeated.
After defeating a monster, the hero either continues fighting with the next monster or leaves the dungeon. He leaves the dungeon either if he has already defeated the number of monsters equal to his endurance during this day (so, the i-th hero cannot defeat more than s_i monsters during each day), or if all monsters are defeated — otherwise, he fights with the next monster. When the hero leaves the dungeon, the current day ends.
Your goal is to defeat the last monster. What is the minimum number of days that you need to achieve your goal? Each day you have to use exactly one hero; it is possible that some heroes don't fight the monsters at all. Each hero can be used arbitrary number of times.
Input
The first line contains one integer t (1 ≤ t ≤ 10^5) — the number of test cases. Then the test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of monsters in the dungeon.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the power of the i-th monster.
The third line contains one integer m (1 ≤ m ≤ 2 ⋅ 10^5) — the number of heroes in your party.
Then m lines follow, each describing a hero. Each line contains two integers p_i and s_i (1 ≤ p_i ≤ 10^9, 1 ≤ s_i ≤ n) — the power and the endurance of the i-th hero.
It is guaranteed that the sum of n + m over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print one integer — the minimum number of days you have to spend to defeat all of the monsters (or -1 if it is impossible).
Example
Input
2
6
2 3 11 14 1 8
2
3 2
100 1
5
3 5 100 2 3
2
30 5
90 1
Output
5
-1
Submitted Solution:
```
import sys
input=sys.stdin.buffer.readline
count=0
for t in range(int(input())):
count+=1
m=int(input())
mon=list(map(int,input().split()))
p=int(input())
store = [[0,0] for i in range(101)]
if(count==34):
print(m,end='')
for i in range(m):
print(mon[i],end='')
for i in range(p):
a,b=map(int,input().split())
store[a]=[a,b]
for i in range(99,-1,-1):
if(store[i][1]<store[i+1][1]):
store[i][0]=store[i+1][0]
store[i][1]=store[i+1][1]
i=0
p_count=99999999999
add=0
flag=1
pre=0
while(i<m):
num=store[mon[i]][0]
count=store[mon[i]][1]
if(num==0):
flag=0
break
if(count>p_count and num>pre):
print(count,p_count,i)
add-=1
count-=p_count
p_count=0
pre=num
while(i<m and count>0):
if(mon[i]>num):
break
count-=1
p_count+=1
i+=1
add+=1
if(flag==0):
print(-1)
else:
print(add)
```
No
| 86,734 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You play a computer game. In this game, you lead a party of m heroes, and you have to clear a dungeon with n monsters. Each monster is characterized by its power a_i. Each hero is characterized by his power p_i and endurance s_i.
The heroes clear the dungeon day by day. In the beginning of each day, you choose a hero (exactly one) who is going to enter the dungeon this day.
When the hero enters the dungeon, he is challenged by the first monster which was not defeated during the previous days (so, if the heroes have already defeated k monsters, the hero fights with the monster k + 1). When the hero fights the monster, there are two possible outcomes:
* if the monster's power is strictly greater than the hero's power, the hero retreats from the dungeon. The current day ends;
* otherwise, the monster is defeated.
After defeating a monster, the hero either continues fighting with the next monster or leaves the dungeon. He leaves the dungeon either if he has already defeated the number of monsters equal to his endurance during this day (so, the i-th hero cannot defeat more than s_i monsters during each day), or if all monsters are defeated — otherwise, he fights with the next monster. When the hero leaves the dungeon, the current day ends.
Your goal is to defeat the last monster. What is the minimum number of days that you need to achieve your goal? Each day you have to use exactly one hero; it is possible that some heroes don't fight the monsters at all. Each hero can be used arbitrary number of times.
Input
The first line contains one integer t (1 ≤ t ≤ 10^5) — the number of test cases. Then the test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of monsters in the dungeon.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the power of the i-th monster.
The third line contains one integer m (1 ≤ m ≤ 2 ⋅ 10^5) — the number of heroes in your party.
Then m lines follow, each describing a hero. Each line contains two integers p_i and s_i (1 ≤ p_i ≤ 10^9, 1 ≤ s_i ≤ n) — the power and the endurance of the i-th hero.
It is guaranteed that the sum of n + m over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print one integer — the minimum number of days you have to spend to defeat all of the monsters (or -1 if it is impossible).
Example
Input
2
6
2 3 11 14 1 8
2
3 2
100 1
5
3 5 100 2 3
2
30 5
90 1
Output
5
-1
Submitted Solution:
```
def f(mp,hero):
hero.sort()
x=0
d=0
try:
while x < len(mp):
e = 0
for i in range(len(hero) - 1, -1, -1):
if hero[i][1] >= mp[x]:
a = i
e = 1
break
if e == 0:
return (-1)
b = hero[a][0]
while b > 0 and hero[a][1] >= mp[x]:
b = b - 1
x = x + 1
d += 1
return (d)
except IndexError:
return(-1)
t=int(input())
for i in range(0,t):
n=int(input())
mp=list(map(int,input().split()))
m=int(input())
hero=[]
for i in range(0,m):
p,s=map(int,input().split())
hero.append((s,p))
print(f(mp,hero))
```
No
| 86,735 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You play a computer game. In this game, you lead a party of m heroes, and you have to clear a dungeon with n monsters. Each monster is characterized by its power a_i. Each hero is characterized by his power p_i and endurance s_i.
The heroes clear the dungeon day by day. In the beginning of each day, you choose a hero (exactly one) who is going to enter the dungeon this day.
When the hero enters the dungeon, he is challenged by the first monster which was not defeated during the previous days (so, if the heroes have already defeated k monsters, the hero fights with the monster k + 1). When the hero fights the monster, there are two possible outcomes:
* if the monster's power is strictly greater than the hero's power, the hero retreats from the dungeon. The current day ends;
* otherwise, the monster is defeated.
After defeating a monster, the hero either continues fighting with the next monster or leaves the dungeon. He leaves the dungeon either if he has already defeated the number of monsters equal to his endurance during this day (so, the i-th hero cannot defeat more than s_i monsters during each day), or if all monsters are defeated — otherwise, he fights with the next monster. When the hero leaves the dungeon, the current day ends.
Your goal is to defeat the last monster. What is the minimum number of days that you need to achieve your goal? Each day you have to use exactly one hero; it is possible that some heroes don't fight the monsters at all. Each hero can be used arbitrary number of times.
Input
The first line contains one integer t (1 ≤ t ≤ 10^5) — the number of test cases. Then the test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of monsters in the dungeon.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the power of the i-th monster.
The third line contains one integer m (1 ≤ m ≤ 2 ⋅ 10^5) — the number of heroes in your party.
Then m lines follow, each describing a hero. Each line contains two integers p_i and s_i (1 ≤ p_i ≤ 10^9, 1 ≤ s_i ≤ n) — the power and the endurance of the i-th hero.
It is guaranteed that the sum of n + m over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case print one integer — the minimum number of days you have to spend to defeat all of the monsters (or -1 if it is impossible).
Example
Input
2
6
2 3 11 14 1 8
2
3 2
100 1
5
3 5 100 2 3
2
30 5
90 1
Output
5
-1
Submitted Solution:
```
for _ in range(int(input())):
input()
m = list(map(int, input().split()))
h = [list(map(int, input().split())) for __ in range(int(input()))]
sas = [0 for i in range(len(m) + 2)]
for i in h:
for j in range(i[1], 0, -1):
if sas[j] < i[0]:
sas[j] = i[0]
else:
break
g = 0
ind = 0
while ind < len(m):
hero = 1
if m[ind] > sas[hero]:
print(-1)
break
test = m[ind]
while test <= sas[hero] and ind + hero < len(m):
hero += 1
test = max(m[ind + hero - 1], test)
if hero > 1:
hero -= 1
ind += hero
g += 1
else:
print(g)
```
No
| 86,736 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Guy-Manuel and Thomas are going to build a polygon spaceship.
You're given a strictly convex (i. e. no three points are collinear) polygon P which is defined by coordinates of its vertices. Define P(x,y) as a polygon obtained by translating P by vector \overrightarrow {(x,y)}. The picture below depicts an example of the translation:
<image>
Define T as a set of points which is the union of all P(x,y) such that the origin (0,0) lies in P(x,y) (both strictly inside and on the boundary). There is also an equivalent definition: a point (x,y) lies in T only if there are two points A,B in P such that \overrightarrow {AB} = \overrightarrow {(x,y)}. One can prove T is a polygon too. For example, if P is a regular triangle then T is a regular hexagon. At the picture below P is drawn in black and some P(x,y) which contain the origin are drawn in colored:
<image>
The spaceship has the best aerodynamic performance if P and T are similar. Your task is to check whether the polygons P and T are [similar](https://tinyurl.com/vp5m7vl).
Input
The first line of input will contain a single integer n (3 ≤ n ≤ 10^5) — the number of points.
The i-th of the next n lines contains two integers x_i, y_i (|x_i|, |y_i| ≤ 10^9), denoting the coordinates of the i-th vertex.
It is guaranteed that these points are listed in counterclockwise order and these points form a strictly convex polygon.
Output
Output "YES" in a separate line, if P and T are similar. Otherwise, output "NO" in a separate line. You can print each letter in any case (upper or lower).
Examples
Input
4
1 0
4 1
3 4
0 3
Output
YES
Input
3
100 86
50 0
150 0
Output
nO
Input
8
0 0
1 0
2 1
3 3
4 6
3 6
2 5
1 3
Output
YES
Note
The following image shows the first sample: both P and T are squares. The second sample was shown in the statements.
<image>
Tags: geometry
Correct Solution:
```
n = int(input())
pts = set([tuple(map(int, input().split())) for i in range(n)])
centre = (sum([a for a,b in pts])/n, sum([b for a,b in pts])/n)
ok = True
for x,y in pts:
if (int(x+(centre[0]-x)*2), int(y+(centre[1]-y)*2)) not in pts:
ok = False
break
if ok:
print("YES")
else:
print("NO")
```
| 86,737 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Guy-Manuel and Thomas are going to build a polygon spaceship.
You're given a strictly convex (i. e. no three points are collinear) polygon P which is defined by coordinates of its vertices. Define P(x,y) as a polygon obtained by translating P by vector \overrightarrow {(x,y)}. The picture below depicts an example of the translation:
<image>
Define T as a set of points which is the union of all P(x,y) such that the origin (0,0) lies in P(x,y) (both strictly inside and on the boundary). There is also an equivalent definition: a point (x,y) lies in T only if there are two points A,B in P such that \overrightarrow {AB} = \overrightarrow {(x,y)}. One can prove T is a polygon too. For example, if P is a regular triangle then T is a regular hexagon. At the picture below P is drawn in black and some P(x,y) which contain the origin are drawn in colored:
<image>
The spaceship has the best aerodynamic performance if P and T are similar. Your task is to check whether the polygons P and T are [similar](https://tinyurl.com/vp5m7vl).
Input
The first line of input will contain a single integer n (3 ≤ n ≤ 10^5) — the number of points.
The i-th of the next n lines contains two integers x_i, y_i (|x_i|, |y_i| ≤ 10^9), denoting the coordinates of the i-th vertex.
It is guaranteed that these points are listed in counterclockwise order and these points form a strictly convex polygon.
Output
Output "YES" in a separate line, if P and T are similar. Otherwise, output "NO" in a separate line. You can print each letter in any case (upper or lower).
Examples
Input
4
1 0
4 1
3 4
0 3
Output
YES
Input
3
100 86
50 0
150 0
Output
nO
Input
8
0 0
1 0
2 1
3 3
4 6
3 6
2 5
1 3
Output
YES
Note
The following image shows the first sample: both P and T are squares. The second sample was shown in the statements.
<image>
Tags: geometry
Correct Solution:
```
from sys import stdin, stdout
def deg(p1, p2):
if p1[0] == p2[0]:
return 1e20
return (p1[1] - p2[1]) / (p1[0] - p2[0])
def dist2(p1, p2):
return (p1[0] - p2[0]) * (p1[0] - p2[0]) + (p1[1] - p2[1]) * (p1[1] - p2[1])
n = int(input())
a = []
for i in range(n):
x, y = map(int, stdin.readline().split())
a.append((x, y))
if n % 2 == 1:
print('no')
exit()
for i in range(n // 2):
j = n-1 if i == 0 else i-1
ii = i + n // 2
jj = n-1 if ii == 0 else ii-1
if (deg(a[i], a[j]) != deg(a[ii], a[jj])) or (dist2(a[i], a[j]) != dist2(a[ii], a[jj])):
print('no')
exit()
print('YES')
```
| 86,738 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Guy-Manuel and Thomas are going to build a polygon spaceship.
You're given a strictly convex (i. e. no three points are collinear) polygon P which is defined by coordinates of its vertices. Define P(x,y) as a polygon obtained by translating P by vector \overrightarrow {(x,y)}. The picture below depicts an example of the translation:
<image>
Define T as a set of points which is the union of all P(x,y) such that the origin (0,0) lies in P(x,y) (both strictly inside and on the boundary). There is also an equivalent definition: a point (x,y) lies in T only if there are two points A,B in P such that \overrightarrow {AB} = \overrightarrow {(x,y)}. One can prove T is a polygon too. For example, if P is a regular triangle then T is a regular hexagon. At the picture below P is drawn in black and some P(x,y) which contain the origin are drawn in colored:
<image>
The spaceship has the best aerodynamic performance if P and T are similar. Your task is to check whether the polygons P and T are [similar](https://tinyurl.com/vp5m7vl).
Input
The first line of input will contain a single integer n (3 ≤ n ≤ 10^5) — the number of points.
The i-th of the next n lines contains two integers x_i, y_i (|x_i|, |y_i| ≤ 10^9), denoting the coordinates of the i-th vertex.
It is guaranteed that these points are listed in counterclockwise order and these points form a strictly convex polygon.
Output
Output "YES" in a separate line, if P and T are similar. Otherwise, output "NO" in a separate line. You can print each letter in any case (upper or lower).
Examples
Input
4
1 0
4 1
3 4
0 3
Output
YES
Input
3
100 86
50 0
150 0
Output
nO
Input
8
0 0
1 0
2 1
3 3
4 6
3 6
2 5
1 3
Output
YES
Note
The following image shows the first sample: both P and T are squares. The second sample was shown in the statements.
<image>
Tags: geometry
Correct Solution:
```
"""
Author: guiferviz
Time: 2020-02-09 15:05:02
"""
def normalize_pol(P):
x_min, y_min, x_max, y_max = P[0][0], P[0][1], P[0][0], P[0][1]
for x, y in P:
x_min = min(x_min, x)
x_max = max(x_max, x)
y_min = min(y_min, y)
y_max = max(y_max, y)
P_norm = []
for x, y in P:
p = ((x - x_min) / (x_max - x_min), (y - y_min) / (y_max - y_min))
P_norm.append(p)
return P_norm
def solve_tle():
n = int(input())
P = []
for i in range(n):
x, y = map(int, input().split())
P.append((x,y))
pol = {}
for x, y in P:
for x2, y2 in P:
tp = (x2-x, y2-y)
count = pol.get(tp, 0)
pol[tp] = count + 1
T = []
for (x, y), count in pol.items():
if count == 1:
T.append((x,y))
# Test if P and T are similar.
P = sorted(normalize_pol(P))
T = sorted(normalize_pol(T))
same = True
for (xp, yp), (xt, yt) in zip(P, T):
if xp != xt or yp != yt:
same = False
break
if same:
print("YES")
else:
print("NO")
def solve():
n = int(input())
P = []
for i in range(n):
x, y = map(int, input().split())
P.append((x,y))
if n % 2 != 0:
print("NO")
return
h = n // 2 # half
p = (P[0][0] + P[h][0], P[0][1] + P[h][1])
for i in range(1, h):
pi = (P[i][0] + P[i + h][0], P[i][1] + P[i + h][1])
if p != pi:
print("NO")
return
print("YES")
def main():
solve()
if __name__ == "__main__":
main()
```
| 86,739 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Guy-Manuel and Thomas are going to build a polygon spaceship.
You're given a strictly convex (i. e. no three points are collinear) polygon P which is defined by coordinates of its vertices. Define P(x,y) as a polygon obtained by translating P by vector \overrightarrow {(x,y)}. The picture below depicts an example of the translation:
<image>
Define T as a set of points which is the union of all P(x,y) such that the origin (0,0) lies in P(x,y) (both strictly inside and on the boundary). There is also an equivalent definition: a point (x,y) lies in T only if there are two points A,B in P such that \overrightarrow {AB} = \overrightarrow {(x,y)}. One can prove T is a polygon too. For example, if P is a regular triangle then T is a regular hexagon. At the picture below P is drawn in black and some P(x,y) which contain the origin are drawn in colored:
<image>
The spaceship has the best aerodynamic performance if P and T are similar. Your task is to check whether the polygons P and T are [similar](https://tinyurl.com/vp5m7vl).
Input
The first line of input will contain a single integer n (3 ≤ n ≤ 10^5) — the number of points.
The i-th of the next n lines contains two integers x_i, y_i (|x_i|, |y_i| ≤ 10^9), denoting the coordinates of the i-th vertex.
It is guaranteed that these points are listed in counterclockwise order and these points form a strictly convex polygon.
Output
Output "YES" in a separate line, if P and T are similar. Otherwise, output "NO" in a separate line. You can print each letter in any case (upper or lower).
Examples
Input
4
1 0
4 1
3 4
0 3
Output
YES
Input
3
100 86
50 0
150 0
Output
nO
Input
8
0 0
1 0
2 1
3 3
4 6
3 6
2 5
1 3
Output
YES
Note
The following image shows the first sample: both P and T are squares. The second sample was shown in the statements.
<image>
Tags: geometry
Correct Solution:
```
import os,io
import sys
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
n=int(input())
shape=[]
for _ in range(n):
x,y=map(int,input().split())
shape.append([x,y])
if n%2==1:
print('NO')
sys.exit()
for i in range(n):
if shape[i][0]-shape[i-1][0]!=shape[(n//2+i-1)%n][0]-shape[(n//2+i)%n][0]:
print('NO')
sys.exit()
if shape[i][1]-shape[i-1][1]!=shape[(n//2+i-1)%n][1]-shape[(n//2+i)%n][1]:
print('NO')
sys.exit()
print('YES')
```
| 86,740 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Guy-Manuel and Thomas are going to build a polygon spaceship.
You're given a strictly convex (i. e. no three points are collinear) polygon P which is defined by coordinates of its vertices. Define P(x,y) as a polygon obtained by translating P by vector \overrightarrow {(x,y)}. The picture below depicts an example of the translation:
<image>
Define T as a set of points which is the union of all P(x,y) such that the origin (0,0) lies in P(x,y) (both strictly inside and on the boundary). There is also an equivalent definition: a point (x,y) lies in T only if there are two points A,B in P such that \overrightarrow {AB} = \overrightarrow {(x,y)}. One can prove T is a polygon too. For example, if P is a regular triangle then T is a regular hexagon. At the picture below P is drawn in black and some P(x,y) which contain the origin are drawn in colored:
<image>
The spaceship has the best aerodynamic performance if P and T are similar. Your task is to check whether the polygons P and T are [similar](https://tinyurl.com/vp5m7vl).
Input
The first line of input will contain a single integer n (3 ≤ n ≤ 10^5) — the number of points.
The i-th of the next n lines contains two integers x_i, y_i (|x_i|, |y_i| ≤ 10^9), denoting the coordinates of the i-th vertex.
It is guaranteed that these points are listed in counterclockwise order and these points form a strictly convex polygon.
Output
Output "YES" in a separate line, if P and T are similar. Otherwise, output "NO" in a separate line. You can print each letter in any case (upper or lower).
Examples
Input
4
1 0
4 1
3 4
0 3
Output
YES
Input
3
100 86
50 0
150 0
Output
nO
Input
8
0 0
1 0
2 1
3 3
4 6
3 6
2 5
1 3
Output
YES
Note
The following image shows the first sample: both P and T are squares. The second sample was shown in the statements.
<image>
Tags: geometry
Correct Solution:
```
n = int(input())
p = []
for i in range(n):
p.append(list(map(int,input().split())))
if n%2==1:
print("NO")
else:
ok = True
for i in range(n//2):
if p[0][0]+p[n//2][0]!=p[i][0]+p[i+n//2][0] or p[0][1]+p[n//2][1]!=p[i][1]+p[i+n//2][1]:
ok = False
print("NO")
break
if ok:
print("YES")
```
| 86,741 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Guy-Manuel and Thomas are going to build a polygon spaceship.
You're given a strictly convex (i. e. no three points are collinear) polygon P which is defined by coordinates of its vertices. Define P(x,y) as a polygon obtained by translating P by vector \overrightarrow {(x,y)}. The picture below depicts an example of the translation:
<image>
Define T as a set of points which is the union of all P(x,y) such that the origin (0,0) lies in P(x,y) (both strictly inside and on the boundary). There is also an equivalent definition: a point (x,y) lies in T only if there are two points A,B in P such that \overrightarrow {AB} = \overrightarrow {(x,y)}. One can prove T is a polygon too. For example, if P is a regular triangle then T is a regular hexagon. At the picture below P is drawn in black and some P(x,y) which contain the origin are drawn in colored:
<image>
The spaceship has the best aerodynamic performance if P and T are similar. Your task is to check whether the polygons P and T are [similar](https://tinyurl.com/vp5m7vl).
Input
The first line of input will contain a single integer n (3 ≤ n ≤ 10^5) — the number of points.
The i-th of the next n lines contains two integers x_i, y_i (|x_i|, |y_i| ≤ 10^9), denoting the coordinates of the i-th vertex.
It is guaranteed that these points are listed in counterclockwise order and these points form a strictly convex polygon.
Output
Output "YES" in a separate line, if P and T are similar. Otherwise, output "NO" in a separate line. You can print each letter in any case (upper or lower).
Examples
Input
4
1 0
4 1
3 4
0 3
Output
YES
Input
3
100 86
50 0
150 0
Output
nO
Input
8
0 0
1 0
2 1
3 3
4 6
3 6
2 5
1 3
Output
YES
Note
The following image shows the first sample: both P and T are squares. The second sample was shown in the statements.
<image>
Tags: geometry
Correct Solution:
```
import sys
input = lambda: sys.stdin.readline().rstrip()
n = int(input())
xy = []
for _ in range(n):
x, y = map(int, input().split())
xy.append((x, y))
if n%2:
print('NO')
exit(0)
for i in range(n//2):
xy0 = xy[i]
xy1 = xy[i+1]
xy2 = xy[n//2+i]
xy3 = xy[(n//2+i+1)%n]
if xy3[0]-xy2[0]!=xy0[0]-xy1[0]:
print('NO')
exit(0)
if xy3[1]-xy2[1]!=xy0[1]-xy1[1]:
print('NO')
exit(0)
print('YES')
```
| 86,742 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Guy-Manuel and Thomas are going to build a polygon spaceship.
You're given a strictly convex (i. e. no three points are collinear) polygon P which is defined by coordinates of its vertices. Define P(x,y) as a polygon obtained by translating P by vector \overrightarrow {(x,y)}. The picture below depicts an example of the translation:
<image>
Define T as a set of points which is the union of all P(x,y) such that the origin (0,0) lies in P(x,y) (both strictly inside and on the boundary). There is also an equivalent definition: a point (x,y) lies in T only if there are two points A,B in P such that \overrightarrow {AB} = \overrightarrow {(x,y)}. One can prove T is a polygon too. For example, if P is a regular triangle then T is a regular hexagon. At the picture below P is drawn in black and some P(x,y) which contain the origin are drawn in colored:
<image>
The spaceship has the best aerodynamic performance if P and T are similar. Your task is to check whether the polygons P and T are [similar](https://tinyurl.com/vp5m7vl).
Input
The first line of input will contain a single integer n (3 ≤ n ≤ 10^5) — the number of points.
The i-th of the next n lines contains two integers x_i, y_i (|x_i|, |y_i| ≤ 10^9), denoting the coordinates of the i-th vertex.
It is guaranteed that these points are listed in counterclockwise order and these points form a strictly convex polygon.
Output
Output "YES" in a separate line, if P and T are similar. Otherwise, output "NO" in a separate line. You can print each letter in any case (upper or lower).
Examples
Input
4
1 0
4 1
3 4
0 3
Output
YES
Input
3
100 86
50 0
150 0
Output
nO
Input
8
0 0
1 0
2 1
3 3
4 6
3 6
2 5
1 3
Output
YES
Note
The following image shows the first sample: both P and T are squares. The second sample was shown in the statements.
<image>
Tags: geometry
Correct Solution:
```
import sys
def main():
n = int(sys.stdin.readline().split()[0])
a = [list(map(int, sys.stdin.readline().split())) for _ in range(n)]
if n&1 == 1:
print("NO")
return
m = n//2
for i in range(-1, m-1):
if a[i+1][0]-a[i][0] != -a[i+1+m][0]+a[i+m][0] or a[i+1][1]-a[i][1] != -a[i+1+m][1]+a[i+m][1]:
print("NO")
return
print("YES")
return
main()
```
| 86,743 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Guy-Manuel and Thomas are going to build a polygon spaceship.
You're given a strictly convex (i. e. no three points are collinear) polygon P which is defined by coordinates of its vertices. Define P(x,y) as a polygon obtained by translating P by vector \overrightarrow {(x,y)}. The picture below depicts an example of the translation:
<image>
Define T as a set of points which is the union of all P(x,y) such that the origin (0,0) lies in P(x,y) (both strictly inside and on the boundary). There is also an equivalent definition: a point (x,y) lies in T only if there are two points A,B in P such that \overrightarrow {AB} = \overrightarrow {(x,y)}. One can prove T is a polygon too. For example, if P is a regular triangle then T is a regular hexagon. At the picture below P is drawn in black and some P(x,y) which contain the origin are drawn in colored:
<image>
The spaceship has the best aerodynamic performance if P and T are similar. Your task is to check whether the polygons P and T are [similar](https://tinyurl.com/vp5m7vl).
Input
The first line of input will contain a single integer n (3 ≤ n ≤ 10^5) — the number of points.
The i-th of the next n lines contains two integers x_i, y_i (|x_i|, |y_i| ≤ 10^9), denoting the coordinates of the i-th vertex.
It is guaranteed that these points are listed in counterclockwise order and these points form a strictly convex polygon.
Output
Output "YES" in a separate line, if P and T are similar. Otherwise, output "NO" in a separate line. You can print each letter in any case (upper or lower).
Examples
Input
4
1 0
4 1
3 4
0 3
Output
YES
Input
3
100 86
50 0
150 0
Output
nO
Input
8
0 0
1 0
2 1
3 3
4 6
3 6
2 5
1 3
Output
YES
Note
The following image shows the first sample: both P and T are squares. The second sample was shown in the statements.
<image>
Tags: geometry
Correct Solution:
```
n = int(input())
P = [list(map(int, input().split())) for i in range(n)]
if n % 2 == 1:
print('NO')
else:
dx, dy = P[0][0]-P[1][0], P[0][1]-P[1][1]
for i in range(2, n):
dx2, dy2 = P[i][0]-P[(i+1)%n][0], P[i][1]-P[(i+1)%n][1]
if dx2 == -dx and dy2 == -dy:
break
r = 'YES'
for j in range(n//2):
dx, dy = P[j][0]-P[j+1][0], P[j][1]-P[j+1][1]
dx2, dy2 = P[(i+j)%n][0]-P[(i+j+1)%n][0], P[(i+j)%n][1]-P[(i+j+1)%n][1]
if dx != -dx2 or dy != -dy2:
r = 'NO'
break
print(r)
```
| 86,744 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Guy-Manuel and Thomas are going to build a polygon spaceship.
You're given a strictly convex (i. e. no three points are collinear) polygon P which is defined by coordinates of its vertices. Define P(x,y) as a polygon obtained by translating P by vector \overrightarrow {(x,y)}. The picture below depicts an example of the translation:
<image>
Define T as a set of points which is the union of all P(x,y) such that the origin (0,0) lies in P(x,y) (both strictly inside and on the boundary). There is also an equivalent definition: a point (x,y) lies in T only if there are two points A,B in P such that \overrightarrow {AB} = \overrightarrow {(x,y)}. One can prove T is a polygon too. For example, if P is a regular triangle then T is a regular hexagon. At the picture below P is drawn in black and some P(x,y) which contain the origin are drawn in colored:
<image>
The spaceship has the best aerodynamic performance if P and T are similar. Your task is to check whether the polygons P and T are [similar](https://tinyurl.com/vp5m7vl).
Input
The first line of input will contain a single integer n (3 ≤ n ≤ 10^5) — the number of points.
The i-th of the next n lines contains two integers x_i, y_i (|x_i|, |y_i| ≤ 10^9), denoting the coordinates of the i-th vertex.
It is guaranteed that these points are listed in counterclockwise order and these points form a strictly convex polygon.
Output
Output "YES" in a separate line, if P and T are similar. Otherwise, output "NO" in a separate line. You can print each letter in any case (upper or lower).
Examples
Input
4
1 0
4 1
3 4
0 3
Output
YES
Input
3
100 86
50 0
150 0
Output
nO
Input
8
0 0
1 0
2 1
3 3
4 6
3 6
2 5
1 3
Output
YES
Note
The following image shows the first sample: both P and T are squares. The second sample was shown in the statements.
<image>
Submitted Solution:
```
import sys
input = sys.stdin.readline
N, = map(int, input().split())
if N%2:
print("NO")
else:
E = []
bx, by = None, None
for _ in range(N):
x, y = map(int, input().split())
if bx != None:
E.append(((x-bx), (y-by)))
else:
fx, fy = x, y
bx, by = x, y
E.append(((fx-bx), (fy-by)))
for i in range(N//2):
x, y = E[i]
z, w = E[N//2+i]
if not (x == -z and y == -w):
print("No")
break
else:
print("Yes")
```
Yes
| 86,745 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Guy-Manuel and Thomas are going to build a polygon spaceship.
You're given a strictly convex (i. e. no three points are collinear) polygon P which is defined by coordinates of its vertices. Define P(x,y) as a polygon obtained by translating P by vector \overrightarrow {(x,y)}. The picture below depicts an example of the translation:
<image>
Define T as a set of points which is the union of all P(x,y) such that the origin (0,0) lies in P(x,y) (both strictly inside and on the boundary). There is also an equivalent definition: a point (x,y) lies in T only if there are two points A,B in P such that \overrightarrow {AB} = \overrightarrow {(x,y)}. One can prove T is a polygon too. For example, if P is a regular triangle then T is a regular hexagon. At the picture below P is drawn in black and some P(x,y) which contain the origin are drawn in colored:
<image>
The spaceship has the best aerodynamic performance if P and T are similar. Your task is to check whether the polygons P and T are [similar](https://tinyurl.com/vp5m7vl).
Input
The first line of input will contain a single integer n (3 ≤ n ≤ 10^5) — the number of points.
The i-th of the next n lines contains two integers x_i, y_i (|x_i|, |y_i| ≤ 10^9), denoting the coordinates of the i-th vertex.
It is guaranteed that these points are listed in counterclockwise order and these points form a strictly convex polygon.
Output
Output "YES" in a separate line, if P and T are similar. Otherwise, output "NO" in a separate line. You can print each letter in any case (upper or lower).
Examples
Input
4
1 0
4 1
3 4
0 3
Output
YES
Input
3
100 86
50 0
150 0
Output
nO
Input
8
0 0
1 0
2 1
3 3
4 6
3 6
2 5
1 3
Output
YES
Note
The following image shows the first sample: both P and T are squares. The second sample was shown in the statements.
<image>
Submitted Solution:
```
import sys
input = sys.stdin.readline
n = int(input())
info = [list(map(int, input().split())) for i in range(n)]
ox = 0
oy = 0
set_ = set()
for i in range(n):
x, y = info[i]
set_.add((x, y))
ox += x
oy += y
ox = ox / n
oy = oy / n
for p in set_:
x, y = p
tmp1 = x - ox
tmp2 = y - oy
tmpx, tmpy = x - 2*tmp1, y - 2*tmp2
if (tmpx, tmpy) not in set_:
print("NO")
exit()
print("YES")
```
Yes
| 86,746 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Guy-Manuel and Thomas are going to build a polygon spaceship.
You're given a strictly convex (i. e. no three points are collinear) polygon P which is defined by coordinates of its vertices. Define P(x,y) as a polygon obtained by translating P by vector \overrightarrow {(x,y)}. The picture below depicts an example of the translation:
<image>
Define T as a set of points which is the union of all P(x,y) such that the origin (0,0) lies in P(x,y) (both strictly inside and on the boundary). There is also an equivalent definition: a point (x,y) lies in T only if there are two points A,B in P such that \overrightarrow {AB} = \overrightarrow {(x,y)}. One can prove T is a polygon too. For example, if P is a regular triangle then T is a regular hexagon. At the picture below P is drawn in black and some P(x,y) which contain the origin are drawn in colored:
<image>
The spaceship has the best aerodynamic performance if P and T are similar. Your task is to check whether the polygons P and T are [similar](https://tinyurl.com/vp5m7vl).
Input
The first line of input will contain a single integer n (3 ≤ n ≤ 10^5) — the number of points.
The i-th of the next n lines contains two integers x_i, y_i (|x_i|, |y_i| ≤ 10^9), denoting the coordinates of the i-th vertex.
It is guaranteed that these points are listed in counterclockwise order and these points form a strictly convex polygon.
Output
Output "YES" in a separate line, if P and T are similar. Otherwise, output "NO" in a separate line. You can print each letter in any case (upper or lower).
Examples
Input
4
1 0
4 1
3 4
0 3
Output
YES
Input
3
100 86
50 0
150 0
Output
nO
Input
8
0 0
1 0
2 1
3 3
4 6
3 6
2 5
1 3
Output
YES
Note
The following image shows the first sample: both P and T are squares. The second sample was shown in the statements.
<image>
Submitted Solution:
```
from bisect import *
from math import *
n = int(input())
arr = []
for i in range(n):
x, y = input().split()
x = int(x)-1
y = int(y)-1
arr.append((x, y))
if n%2==1:
print("NO")
else:
flag = True
for i in range(0, n//2):
if (arr[(i+1)%n][0]-arr[i%n][0], arr[(i+1)%n][1]-arr[i%n][1]) != (arr[(i+n//2)%n][0]-arr[(i+1+n//2)%n][0], arr[(i+n//2)%n][1]-arr[(i+1+n//2)%n][1]):
flag = False
break
if flag == True:
print("YES")
else:
print("NO")
```
Yes
| 86,747 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Guy-Manuel and Thomas are going to build a polygon spaceship.
You're given a strictly convex (i. e. no three points are collinear) polygon P which is defined by coordinates of its vertices. Define P(x,y) as a polygon obtained by translating P by vector \overrightarrow {(x,y)}. The picture below depicts an example of the translation:
<image>
Define T as a set of points which is the union of all P(x,y) such that the origin (0,0) lies in P(x,y) (both strictly inside and on the boundary). There is also an equivalent definition: a point (x,y) lies in T only if there are two points A,B in P such that \overrightarrow {AB} = \overrightarrow {(x,y)}. One can prove T is a polygon too. For example, if P is a regular triangle then T is a regular hexagon. At the picture below P is drawn in black and some P(x,y) which contain the origin are drawn in colored:
<image>
The spaceship has the best aerodynamic performance if P and T are similar. Your task is to check whether the polygons P and T are [similar](https://tinyurl.com/vp5m7vl).
Input
The first line of input will contain a single integer n (3 ≤ n ≤ 10^5) — the number of points.
The i-th of the next n lines contains two integers x_i, y_i (|x_i|, |y_i| ≤ 10^9), denoting the coordinates of the i-th vertex.
It is guaranteed that these points are listed in counterclockwise order and these points form a strictly convex polygon.
Output
Output "YES" in a separate line, if P and T are similar. Otherwise, output "NO" in a separate line. You can print each letter in any case (upper or lower).
Examples
Input
4
1 0
4 1
3 4
0 3
Output
YES
Input
3
100 86
50 0
150 0
Output
nO
Input
8
0 0
1 0
2 1
3 3
4 6
3 6
2 5
1 3
Output
YES
Note
The following image shows the first sample: both P and T are squares. The second sample was shown in the statements.
<image>
Submitted Solution:
```
from sys import stdin
from os import getenv
# if getenv('ONLINE_JUDGE'):
def input():
return next(stdin)[:-1]
def main():
n = int(input())
pp = []
for _ in range(n):
pp.append(list(map(int, input().split())))
if n%2 != 0:
print("NO")
return
for i in range(n//2):
x1 = pp[i+1][0] - pp[i][0]
y1 = pp[i+1][1] - pp[i][1]
x2 = pp[(i+1+n//2) % n][0] - pp[i+n//2][0]
y2 = pp[(i+1+n//2) % n][1] - pp[i+n//2][1]
if x1 != -x2 or y1 != -y2:
print("NO")
return
print("YES")
if __name__ == "__main__":
main()
```
Yes
| 86,748 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Guy-Manuel and Thomas are going to build a polygon spaceship.
You're given a strictly convex (i. e. no three points are collinear) polygon P which is defined by coordinates of its vertices. Define P(x,y) as a polygon obtained by translating P by vector \overrightarrow {(x,y)}. The picture below depicts an example of the translation:
<image>
Define T as a set of points which is the union of all P(x,y) such that the origin (0,0) lies in P(x,y) (both strictly inside and on the boundary). There is also an equivalent definition: a point (x,y) lies in T only if there are two points A,B in P such that \overrightarrow {AB} = \overrightarrow {(x,y)}. One can prove T is a polygon too. For example, if P is a regular triangle then T is a regular hexagon. At the picture below P is drawn in black and some P(x,y) which contain the origin are drawn in colored:
<image>
The spaceship has the best aerodynamic performance if P and T are similar. Your task is to check whether the polygons P and T are [similar](https://tinyurl.com/vp5m7vl).
Input
The first line of input will contain a single integer n (3 ≤ n ≤ 10^5) — the number of points.
The i-th of the next n lines contains two integers x_i, y_i (|x_i|, |y_i| ≤ 10^9), denoting the coordinates of the i-th vertex.
It is guaranteed that these points are listed in counterclockwise order and these points form a strictly convex polygon.
Output
Output "YES" in a separate line, if P and T are similar. Otherwise, output "NO" in a separate line. You can print each letter in any case (upper or lower).
Examples
Input
4
1 0
4 1
3 4
0 3
Output
YES
Input
3
100 86
50 0
150 0
Output
nO
Input
8
0 0
1 0
2 1
3 3
4 6
3 6
2 5
1 3
Output
YES
Note
The following image shows the first sample: both P and T are squares. The second sample was shown in the statements.
<image>
Submitted Solution:
```
from sys import stdin
from collections import deque
mod = 10**9 + 7
import sys
# sys.setrecursionlimit(10**6)
from queue import PriorityQueue
# def rl():
# return [int(w) for w in stdin.readline().split()]
from bisect import bisect_right
from bisect import bisect_left
from collections import defaultdict
from math import sqrt,factorial,gcd,log2,inf,ceil
# map(int,input().split())
# # l = list(map(int,input().split()))
# from itertools import permutations
import heapq
# input = lambda: sys.stdin.readline().rstrip()
input = lambda : sys.stdin.readline().rstrip()
from sys import stdin, stdout
from heapq import heapify, heappush, heappop
from itertools import permutations
n = int(input())
ba = []
if n%4!=0:
print('NO')
exit()
for i in range(n):
a,b = map(int,input().split())
ba.append([a,b])
slope = []
for i in range(1,n+1):
a,b = ba[i%n]
c,d = ba[(i-1)%n]
try:
slope.append((d-b)/(c-a))
except:
slope.append(10**18)
flag = 0
for i in range(len(slope)):
if slope[i] == slope[(i+n//2)%n]:
continue
else:
flag = 1
break
if flag == 1:
print('NO')
else:
print('YES')
```
No
| 86,749 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Guy-Manuel and Thomas are going to build a polygon spaceship.
You're given a strictly convex (i. e. no three points are collinear) polygon P which is defined by coordinates of its vertices. Define P(x,y) as a polygon obtained by translating P by vector \overrightarrow {(x,y)}. The picture below depicts an example of the translation:
<image>
Define T as a set of points which is the union of all P(x,y) such that the origin (0,0) lies in P(x,y) (both strictly inside and on the boundary). There is also an equivalent definition: a point (x,y) lies in T only if there are two points A,B in P such that \overrightarrow {AB} = \overrightarrow {(x,y)}. One can prove T is a polygon too. For example, if P is a regular triangle then T is a regular hexagon. At the picture below P is drawn in black and some P(x,y) which contain the origin are drawn in colored:
<image>
The spaceship has the best aerodynamic performance if P and T are similar. Your task is to check whether the polygons P and T are [similar](https://tinyurl.com/vp5m7vl).
Input
The first line of input will contain a single integer n (3 ≤ n ≤ 10^5) — the number of points.
The i-th of the next n lines contains two integers x_i, y_i (|x_i|, |y_i| ≤ 10^9), denoting the coordinates of the i-th vertex.
It is guaranteed that these points are listed in counterclockwise order and these points form a strictly convex polygon.
Output
Output "YES" in a separate line, if P and T are similar. Otherwise, output "NO" in a separate line. You can print each letter in any case (upper or lower).
Examples
Input
4
1 0
4 1
3 4
0 3
Output
YES
Input
3
100 86
50 0
150 0
Output
nO
Input
8
0 0
1 0
2 1
3 3
4 6
3 6
2 5
1 3
Output
YES
Note
The following image shows the first sample: both P and T are squares. The second sample was shown in the statements.
<image>
Submitted Solution:
```
from sys import stdin
from collections import deque
mod = 10**9 + 7
import sys
# sys.setrecursionlimit(10**6)
from queue import PriorityQueue
# def rl():
# return [int(w) for w in stdin.readline().split()]
from bisect import bisect_right
from bisect import bisect_left
from collections import defaultdict
from math import sqrt,factorial,gcd,log2,inf,ceil
# map(int,input().split())
# # l = list(map(int,input().split()))
# from itertools import permutations
import heapq
# input = lambda: sys.stdin.readline().rstrip()
input = lambda : sys.stdin.readline().rstrip()
from sys import stdin, stdout
from heapq import heapify, heappush, heappop
from itertools import permutations
n = int(input())
ba = []
# if n%4!=0:
# print('NO')
# exit()
for i in range(n):
a,b = map(int,input().split())
ba.append([a,b])
slope = []
for i in range(1,n+1):
a,b = ba[i%n]
c,d = ba[(i-1)%n]
try:
slope.append((d-b)/(c-a))
except:
slope.append(10**18)
flag = 0
for i in range(len(slope)):
if slope[i] == slope[(i+n//2)%n]:
continue
else:
flag = 1
break
if flag == 1:
print('NO')
else:
print('YES')
```
No
| 86,750 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Guy-Manuel and Thomas are going to build a polygon spaceship.
You're given a strictly convex (i. e. no three points are collinear) polygon P which is defined by coordinates of its vertices. Define P(x,y) as a polygon obtained by translating P by vector \overrightarrow {(x,y)}. The picture below depicts an example of the translation:
<image>
Define T as a set of points which is the union of all P(x,y) such that the origin (0,0) lies in P(x,y) (both strictly inside and on the boundary). There is also an equivalent definition: a point (x,y) lies in T only if there are two points A,B in P such that \overrightarrow {AB} = \overrightarrow {(x,y)}. One can prove T is a polygon too. For example, if P is a regular triangle then T is a regular hexagon. At the picture below P is drawn in black and some P(x,y) which contain the origin are drawn in colored:
<image>
The spaceship has the best aerodynamic performance if P and T are similar. Your task is to check whether the polygons P and T are [similar](https://tinyurl.com/vp5m7vl).
Input
The first line of input will contain a single integer n (3 ≤ n ≤ 10^5) — the number of points.
The i-th of the next n lines contains two integers x_i, y_i (|x_i|, |y_i| ≤ 10^9), denoting the coordinates of the i-th vertex.
It is guaranteed that these points are listed in counterclockwise order and these points form a strictly convex polygon.
Output
Output "YES" in a separate line, if P and T are similar. Otherwise, output "NO" in a separate line. You can print each letter in any case (upper or lower).
Examples
Input
4
1 0
4 1
3 4
0 3
Output
YES
Input
3
100 86
50 0
150 0
Output
nO
Input
8
0 0
1 0
2 1
3 3
4 6
3 6
2 5
1 3
Output
YES
Note
The following image shows the first sample: both P and T are squares. The second sample was shown in the statements.
<image>
Submitted Solution:
```
n=int(input())
for i in range(n):
x,y=map(int,input().split())
if n%2==0:
print("YES")
else:
print("NO")
```
No
| 86,751 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Guy-Manuel and Thomas are going to build a polygon spaceship.
You're given a strictly convex (i. e. no three points are collinear) polygon P which is defined by coordinates of its vertices. Define P(x,y) as a polygon obtained by translating P by vector \overrightarrow {(x,y)}. The picture below depicts an example of the translation:
<image>
Define T as a set of points which is the union of all P(x,y) such that the origin (0,0) lies in P(x,y) (both strictly inside and on the boundary). There is also an equivalent definition: a point (x,y) lies in T only if there are two points A,B in P such that \overrightarrow {AB} = \overrightarrow {(x,y)}. One can prove T is a polygon too. For example, if P is a regular triangle then T is a regular hexagon. At the picture below P is drawn in black and some P(x,y) which contain the origin are drawn in colored:
<image>
The spaceship has the best aerodynamic performance if P and T are similar. Your task is to check whether the polygons P and T are [similar](https://tinyurl.com/vp5m7vl).
Input
The first line of input will contain a single integer n (3 ≤ n ≤ 10^5) — the number of points.
The i-th of the next n lines contains two integers x_i, y_i (|x_i|, |y_i| ≤ 10^9), denoting the coordinates of the i-th vertex.
It is guaranteed that these points are listed in counterclockwise order and these points form a strictly convex polygon.
Output
Output "YES" in a separate line, if P and T are similar. Otherwise, output "NO" in a separate line. You can print each letter in any case (upper or lower).
Examples
Input
4
1 0
4 1
3 4
0 3
Output
YES
Input
3
100 86
50 0
150 0
Output
nO
Input
8
0 0
1 0
2 1
3 3
4 6
3 6
2 5
1 3
Output
YES
Note
The following image shows the first sample: both P and T are squares. The second sample was shown in the statements.
<image>
Submitted Solution:
```
from __future__ import division
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def Left_index(points):
'''
Finding the left most point
'''
minn = 0
for i in range(1,len(points)):
if points[i].x < points[minn].x:
minn = i
elif points[i].x == points[minn].x:
if points[i].y > points[minn].y:
minn = i
return minn
def orientation(p, q, r):
'''
To find orientation of ordered triplet (p, q, r).
The function returns following values
0 --> p, q and r are colinear
1 --> Clockwise
2 --> Counterclockwise
'''
val = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y)
if val == 0:
return 0
elif val > 0:
return 1
else:
return 2
def convexHull(points, n):
# There must be at least 3 points
if n < 3:
return
# Find the leftmost point
l = Left_index(points)
hull = []
'''
Start from leftmost point, keep moving counterclockwise
until reach the start point again. This loop runs O(h)
times where h is number of points in result or output.
'''
p = l
q = 0
while(True):
if len(hull) >= 2:
fp = points[hull[-2]]
sp = points[hull[-1]]
v_1 = sp.x - fp.x
v_2 = sp.y - fp.y
zp = points[p]
w_1 = zp.x - sp.x
w_2 = zp.y - sp.y
if w_2*v_1 == v_2*w_1:
hull.remove(hull[-1])
hull.append(p)
else:
hull.append(p)
else:
hull.append(p)
# Add current point to result
'''
Search for a point 'q' such that orientation(p, x,
q) is counterclockwise for all points 'x'. The idea
is to keep track of last visited most counterclock-
wise point in q. If any point 'i' is more counterclock-
wise than q, then update q.
'''
q = (p + 1) % n
for i in range(n):
# If i is more counterclockwise
# than current q, then update q
if(orientation(points[p],
points[i], points[q]) == 2):
q = i
'''
Now q is the most counterclockwise with respect to p
Set p as q for next iteration, so that q is added to
result 'hull'
'''
p = q
# While we don't come to first point
if(p == l):
# check to see if the second to last point and the
# first point are collinear
fp = points[hull[-2]]
sp = points[l]
zp = points[hull[-1]]
v_1, v_2 = (fp.x - zp.x, fp.y - zp.y)
w_1, w_2 = (zp.x - sp.x, zp.y - sp.y)
if w_1*v_2 == w_2*v_1:
hull.remove(hull[-1])
break
# Print Result
'''
for each in hull:
print(points[each].x, points[each].y)
'''
# Instead of printing we return the list
out_list = []
for each in hull:
out_list.append((points[each].x, points[each].y))
return out_list
# number of points
N = int(input())
# points in clockwise orientation
pnts = []
for points in range(N):
x, y = [int(x) for x in input().split()]
pnts.append((x, y))
def translate(pnts, v):
v_1, v_2 = v
t_pnts = []
for points in range(len(pnts)):
x, y = pnts[points]
t_pnts.append((x + v_1, y + v_2))
return t_pnts
def translate_p(pnt, v):
x, y = pnt
v_1, v_2 = v
return (x + v_1, y + v_2)
first_v = pnts[0]
v_1, v_2 = first_v
first_v = -v_1, -v_2
# move the polygon so that a single vertex is on the origin
pnts = translate(pnts, first_v)
# translate the polygon sides along the origin
c_pnts = pnts
T_pnts = [c_pnts]
for pos in range(N):
if pos < N - 1:
fp = c_pnts[pos]
sp = c_pnts[pos + 1]
fp_x, fp_y = fp[0], fp[1]
sp_x, sp_y = sp[0], sp[1]
v = (fp_x - sp_x, fp_y - sp_y)
c_pnts = translate(c_pnts, v)
T_pnts.append(c_pnts)
else:
fp = c_pnts[pos]
sp = c_pnts[0]
fp_x, fp_y = fp[0], fp[1]
sp_x, sp_y = sp[0], sp[1]
v = (fp_x - sp_x, fp_y - sp_y)
c_pnts = translate(c_pnts, v)
T_pnts.append(c_pnts)
T_pnts = sum(T_pnts, [])
# traced out figure is new polygon
# Can use Jarvis' Algorithm to find the convex hull of T_pnts
for pos in range(len(T_pnts)):
x, y = T_pnts[pos]
T_pnts[pos] = Point(x, y)
T_pnts = convexHull(T_pnts, len(T_pnts))
if len(T_pnts) == len(pnts):
print ('YES')
else:
print ('NO')
```
No
| 86,752 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vova had a pretty weird sleeping schedule. There are h hours in a day. Vova will sleep exactly n times. The i-th time he will sleep exactly after a_i hours from the time he woke up. You can assume that Vova woke up exactly at the beginning of this story (the initial time is 0). Each time Vova sleeps exactly one day (in other words, h hours).
Vova thinks that the i-th sleeping time is good if he starts to sleep between hours l and r inclusive.
Vova can control himself and before the i-th time can choose between two options: go to sleep after a_i hours or after a_i - 1 hours.
Your task is to say the maximum number of good sleeping times Vova can obtain if he acts optimally.
Input
The first line of the input contains four integers n, h, l and r (1 ≤ n ≤ 2000, 3 ≤ h ≤ 2000, 0 ≤ l ≤ r < h) — the number of times Vova goes to sleep, the number of hours in a day and the segment of the good sleeping time.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i < h), where a_i is the number of hours after which Vova goes to sleep the i-th time.
Output
Print one integer — the maximum number of good sleeping times Vova can obtain if he acts optimally.
Example
Input
7 24 21 23
16 17 14 20 20 11 22
Output
3
Note
The maximum number of good times in the example is 3.
The story starts from t=0. Then Vova goes to sleep after a_1 - 1 hours, now the time is 15. This time is not good. Then Vova goes to sleep after a_2 - 1 hours, now the time is 15 + 16 = 7. This time is also not good. Then Vova goes to sleep after a_3 hours, now the time is 7 + 14 = 21. This time is good. Then Vova goes to sleep after a_4 - 1 hours, now the time is 21 + 19 = 16. This time is not good. Then Vova goes to sleep after a_5 hours, now the time is 16 + 20 = 12. This time is not good. Then Vova goes to sleep after a_6 hours, now the time is 12 + 11 = 23. This time is good. Then Vova goes to sleep after a_7 hours, now the time is 23 + 22 = 21. This time is also good.
Tags: dp, implementation
Correct Solution:
```
n, h, l, r = map(int, input().split())
a = list(map(int, input().split()))
cursum = [0] * (n + 1)
for i in range(n):
cursum[i + 1] += cursum[i] + a[i]
cursum[i + 1] %= h
dp = [[0] * (n + 1) for i in range(n + 1)]
for i in range(n):
for j in range(i + 1):
# ai
t = (cursum[i + 1] - j) % h
if l <= t <= r:
dp[i + 1][j] = max(dp[i][j] + 1, dp[i + 1][j])
else:
dp[i + 1][j] = max(dp[i][j], dp[i + 1][j])
# ai - 1
t = (cursum[i + 1] - j - 1) % h
if l <= t <= r:
dp[i + 1][j + 1] = max(dp[i][j] + 1, dp[i + 1][j + 1])
else:
dp[i + 1][j + 1] = max(dp[i][j], dp[i + 1][j + 1])
print(max(dp[-1]))
```
| 86,753 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vova had a pretty weird sleeping schedule. There are h hours in a day. Vova will sleep exactly n times. The i-th time he will sleep exactly after a_i hours from the time he woke up. You can assume that Vova woke up exactly at the beginning of this story (the initial time is 0). Each time Vova sleeps exactly one day (in other words, h hours).
Vova thinks that the i-th sleeping time is good if he starts to sleep between hours l and r inclusive.
Vova can control himself and before the i-th time can choose between two options: go to sleep after a_i hours or after a_i - 1 hours.
Your task is to say the maximum number of good sleeping times Vova can obtain if he acts optimally.
Input
The first line of the input contains four integers n, h, l and r (1 ≤ n ≤ 2000, 3 ≤ h ≤ 2000, 0 ≤ l ≤ r < h) — the number of times Vova goes to sleep, the number of hours in a day and the segment of the good sleeping time.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i < h), where a_i is the number of hours after which Vova goes to sleep the i-th time.
Output
Print one integer — the maximum number of good sleeping times Vova can obtain if he acts optimally.
Example
Input
7 24 21 23
16 17 14 20 20 11 22
Output
3
Note
The maximum number of good times in the example is 3.
The story starts from t=0. Then Vova goes to sleep after a_1 - 1 hours, now the time is 15. This time is not good. Then Vova goes to sleep after a_2 - 1 hours, now the time is 15 + 16 = 7. This time is also not good. Then Vova goes to sleep after a_3 hours, now the time is 7 + 14 = 21. This time is good. Then Vova goes to sleep after a_4 - 1 hours, now the time is 21 + 19 = 16. This time is not good. Then Vova goes to sleep after a_5 hours, now the time is 16 + 20 = 12. This time is not good. Then Vova goes to sleep after a_6 hours, now the time is 12 + 11 = 23. This time is good. Then Vova goes to sleep after a_7 hours, now the time is 23 + 22 = 21. This time is also good.
Tags: dp, implementation
Correct Solution:
```
z=lambda:map(int,input().split());a,b,c,d=z();e=[-10000000000]*b;f=list(map(int,input().split()));e[0]=0
for i in range(a):
k=[]
for j in range(b):
o=max(e[(j-f[i])%b],e[(j-f[i]+1)%b])
if c<=j<=d:o+=1
k+=[o]
e=k
print(max(e))
```
| 86,754 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vova had a pretty weird sleeping schedule. There are h hours in a day. Vova will sleep exactly n times. The i-th time he will sleep exactly after a_i hours from the time he woke up. You can assume that Vova woke up exactly at the beginning of this story (the initial time is 0). Each time Vova sleeps exactly one day (in other words, h hours).
Vova thinks that the i-th sleeping time is good if he starts to sleep between hours l and r inclusive.
Vova can control himself and before the i-th time can choose between two options: go to sleep after a_i hours or after a_i - 1 hours.
Your task is to say the maximum number of good sleeping times Vova can obtain if he acts optimally.
Input
The first line of the input contains four integers n, h, l and r (1 ≤ n ≤ 2000, 3 ≤ h ≤ 2000, 0 ≤ l ≤ r < h) — the number of times Vova goes to sleep, the number of hours in a day and the segment of the good sleeping time.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i < h), where a_i is the number of hours after which Vova goes to sleep the i-th time.
Output
Print one integer — the maximum number of good sleeping times Vova can obtain if he acts optimally.
Example
Input
7 24 21 23
16 17 14 20 20 11 22
Output
3
Note
The maximum number of good times in the example is 3.
The story starts from t=0. Then Vova goes to sleep after a_1 - 1 hours, now the time is 15. This time is not good. Then Vova goes to sleep after a_2 - 1 hours, now the time is 15 + 16 = 7. This time is also not good. Then Vova goes to sleep after a_3 hours, now the time is 7 + 14 = 21. This time is good. Then Vova goes to sleep after a_4 - 1 hours, now the time is 21 + 19 = 16. This time is not good. Then Vova goes to sleep after a_5 hours, now the time is 16 + 20 = 12. This time is not good. Then Vova goes to sleep after a_6 hours, now the time is 12 + 11 = 23. This time is good. Then Vova goes to sleep after a_7 hours, now the time is 23 + 22 = 21. This time is also good.
Tags: dp, implementation
Correct Solution:
```
n, h, l, r = map(int, input().split())
a = list(map(int, input().split()))
cur = [-3000] * h
cur[0] = 0
for x in a:
new = []
for i in range(h):
f = max(cur[(i-x)%h], cur[(i-x+1)%h])
if l<=i<=r:
f += 1
new += [f]
cur = new
print(max(cur))
```
| 86,755 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vova had a pretty weird sleeping schedule. There are h hours in a day. Vova will sleep exactly n times. The i-th time he will sleep exactly after a_i hours from the time he woke up. You can assume that Vova woke up exactly at the beginning of this story (the initial time is 0). Each time Vova sleeps exactly one day (in other words, h hours).
Vova thinks that the i-th sleeping time is good if he starts to sleep between hours l and r inclusive.
Vova can control himself and before the i-th time can choose between two options: go to sleep after a_i hours or after a_i - 1 hours.
Your task is to say the maximum number of good sleeping times Vova can obtain if he acts optimally.
Input
The first line of the input contains four integers n, h, l and r (1 ≤ n ≤ 2000, 3 ≤ h ≤ 2000, 0 ≤ l ≤ r < h) — the number of times Vova goes to sleep, the number of hours in a day and the segment of the good sleeping time.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i < h), where a_i is the number of hours after which Vova goes to sleep the i-th time.
Output
Print one integer — the maximum number of good sleeping times Vova can obtain if he acts optimally.
Example
Input
7 24 21 23
16 17 14 20 20 11 22
Output
3
Note
The maximum number of good times in the example is 3.
The story starts from t=0. Then Vova goes to sleep after a_1 - 1 hours, now the time is 15. This time is not good. Then Vova goes to sleep after a_2 - 1 hours, now the time is 15 + 16 = 7. This time is also not good. Then Vova goes to sleep after a_3 hours, now the time is 7 + 14 = 21. This time is good. Then Vova goes to sleep after a_4 - 1 hours, now the time is 21 + 19 = 16. This time is not good. Then Vova goes to sleep after a_5 hours, now the time is 16 + 20 = 12. This time is not good. Then Vova goes to sleep after a_6 hours, now the time is 12 + 11 = 23. This time is good. Then Vova goes to sleep after a_7 hours, now the time is 23 + 22 = 21. This time is also good.
Tags: dp, implementation
Correct Solution:
```
# https://codeforces.com/problemset/problem/1324/E
n, h,l,r = list(map(int,input().strip().split()))
arr = list(map(int,input().strip().split()))
dp_arr = [[0 for j in range(h)] for i in range(n+1)]
pre_set = set([0])
for i in range(n):
# print(arr[i],pre_set)
temp_set = set()
for j in pre_set:
for k in [arr[i],arr[i]-1]:
pre_val = dp_arr[i][j]
new_time = (j+k)%h
if l<=new_time and new_time<=r:
pre_val+=1
dp_arr[i+1][new_time] = max(dp_arr[i+1][new_time],pre_val)
temp_set.add(new_time)
pre_set = temp_set
# print(pre_set)
# for i in dp_arr:
# print(*i)
print(max(dp_arr[-1]))
```
| 86,756 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vova had a pretty weird sleeping schedule. There are h hours in a day. Vova will sleep exactly n times. The i-th time he will sleep exactly after a_i hours from the time he woke up. You can assume that Vova woke up exactly at the beginning of this story (the initial time is 0). Each time Vova sleeps exactly one day (in other words, h hours).
Vova thinks that the i-th sleeping time is good if he starts to sleep between hours l and r inclusive.
Vova can control himself and before the i-th time can choose between two options: go to sleep after a_i hours or after a_i - 1 hours.
Your task is to say the maximum number of good sleeping times Vova can obtain if he acts optimally.
Input
The first line of the input contains four integers n, h, l and r (1 ≤ n ≤ 2000, 3 ≤ h ≤ 2000, 0 ≤ l ≤ r < h) — the number of times Vova goes to sleep, the number of hours in a day and the segment of the good sleeping time.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i < h), where a_i is the number of hours after which Vova goes to sleep the i-th time.
Output
Print one integer — the maximum number of good sleeping times Vova can obtain if he acts optimally.
Example
Input
7 24 21 23
16 17 14 20 20 11 22
Output
3
Note
The maximum number of good times in the example is 3.
The story starts from t=0. Then Vova goes to sleep after a_1 - 1 hours, now the time is 15. This time is not good. Then Vova goes to sleep after a_2 - 1 hours, now the time is 15 + 16 = 7. This time is also not good. Then Vova goes to sleep after a_3 hours, now the time is 7 + 14 = 21. This time is good. Then Vova goes to sleep after a_4 - 1 hours, now the time is 21 + 19 = 16. This time is not good. Then Vova goes to sleep after a_5 hours, now the time is 16 + 20 = 12. This time is not good. Then Vova goes to sleep after a_6 hours, now the time is 12 + 11 = 23. This time is good. Then Vova goes to sleep after a_7 hours, now the time is 23 + 22 = 21. This time is also good.
Tags: dp, implementation
Correct Solution:
```
n, h, l, r = map(int, input().split())
a = list(map(int, input().split()))
MINN = -int(1e9)
dp = [[MINN] * (n + 1) for i in range(n + 1)]
dp[0][0] = 0
s = 0
for i in range(n):
s += a[i]
for j in range(n + 1):
dp[i + 1][j] = max(dp[i + 1][j],dp[i][j] + int((l <= (s - j) % h <= r)))
if j < n: dp[i + 1][j + 1] = max(dp[i + 1][j + 1],dp[i][j] + int((l <= (s - j - 1) % h <= r)))
print(max(dp[n]))
```
| 86,757 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vova had a pretty weird sleeping schedule. There are h hours in a day. Vova will sleep exactly n times. The i-th time he will sleep exactly after a_i hours from the time he woke up. You can assume that Vova woke up exactly at the beginning of this story (the initial time is 0). Each time Vova sleeps exactly one day (in other words, h hours).
Vova thinks that the i-th sleeping time is good if he starts to sleep between hours l and r inclusive.
Vova can control himself and before the i-th time can choose between two options: go to sleep after a_i hours or after a_i - 1 hours.
Your task is to say the maximum number of good sleeping times Vova can obtain if he acts optimally.
Input
The first line of the input contains four integers n, h, l and r (1 ≤ n ≤ 2000, 3 ≤ h ≤ 2000, 0 ≤ l ≤ r < h) — the number of times Vova goes to sleep, the number of hours in a day and the segment of the good sleeping time.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i < h), where a_i is the number of hours after which Vova goes to sleep the i-th time.
Output
Print one integer — the maximum number of good sleeping times Vova can obtain if he acts optimally.
Example
Input
7 24 21 23
16 17 14 20 20 11 22
Output
3
Note
The maximum number of good times in the example is 3.
The story starts from t=0. Then Vova goes to sleep after a_1 - 1 hours, now the time is 15. This time is not good. Then Vova goes to sleep after a_2 - 1 hours, now the time is 15 + 16 = 7. This time is also not good. Then Vova goes to sleep after a_3 hours, now the time is 7 + 14 = 21. This time is good. Then Vova goes to sleep after a_4 - 1 hours, now the time is 21 + 19 = 16. This time is not good. Then Vova goes to sleep after a_5 hours, now the time is 16 + 20 = 12. This time is not good. Then Vova goes to sleep after a_6 hours, now the time is 12 + 11 = 23. This time is good. Then Vova goes to sleep after a_7 hours, now the time is 23 + 22 = 21. This time is also good.
Tags: dp, implementation
Correct Solution:
```
n, h, l, r = map(int, input().split())
dp = [[0] * h for _ in range(n + 1)]
possible = [set() for i in range(n + 1)]
possible[0].add(0)
for i, length in zip(range(1, n + 1), map(int, input().split())):
for time in possible[i - 1]:
trans0 = (time + length) % h
trans1 = (h + time + length - 1) % h
dp[i][trans0] = max(dp[i][trans0], dp[i - 1][time])
dp[i][trans1] = max(dp[i][trans1], dp[i - 1][time])
possible[i].add(trans0)
possible[i].add(trans1)
for time in possible[i]:
if l <= time <= r:
dp[i][time] += 1
print(max(dp[n]))
```
| 86,758 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vova had a pretty weird sleeping schedule. There are h hours in a day. Vova will sleep exactly n times. The i-th time he will sleep exactly after a_i hours from the time he woke up. You can assume that Vova woke up exactly at the beginning of this story (the initial time is 0). Each time Vova sleeps exactly one day (in other words, h hours).
Vova thinks that the i-th sleeping time is good if he starts to sleep between hours l and r inclusive.
Vova can control himself and before the i-th time can choose between two options: go to sleep after a_i hours or after a_i - 1 hours.
Your task is to say the maximum number of good sleeping times Vova can obtain if he acts optimally.
Input
The first line of the input contains four integers n, h, l and r (1 ≤ n ≤ 2000, 3 ≤ h ≤ 2000, 0 ≤ l ≤ r < h) — the number of times Vova goes to sleep, the number of hours in a day and the segment of the good sleeping time.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i < h), where a_i is the number of hours after which Vova goes to sleep the i-th time.
Output
Print one integer — the maximum number of good sleeping times Vova can obtain if he acts optimally.
Example
Input
7 24 21 23
16 17 14 20 20 11 22
Output
3
Note
The maximum number of good times in the example is 3.
The story starts from t=0. Then Vova goes to sleep after a_1 - 1 hours, now the time is 15. This time is not good. Then Vova goes to sleep after a_2 - 1 hours, now the time is 15 + 16 = 7. This time is also not good. Then Vova goes to sleep after a_3 hours, now the time is 7 + 14 = 21. This time is good. Then Vova goes to sleep after a_4 - 1 hours, now the time is 21 + 19 = 16. This time is not good. Then Vova goes to sleep after a_5 hours, now the time is 16 + 20 = 12. This time is not good. Then Vova goes to sleep after a_6 hours, now the time is 12 + 11 = 23. This time is good. Then Vova goes to sleep after a_7 hours, now the time is 23 + 22 = 21. This time is also good.
Tags: dp, implementation
Correct Solution:
```
n,h,l,r=map(int,input().split())
a=list(map(int,input().split()))
b=[a[0]]
for i in a[1:]:b.append(b[-1]+i)
dp=[(n+1)*[0]for _ in range(n)]
if l<=a[0]<=r:dp[0][0]=1
if l<=a[0]-1<=r:dp[0][1]=1
for i in range(1,n):
for j in range(i+2):
if j==0:
dp[i][j]=dp[i-1][j]
if l<=b[i]%h<=r:dp[i][j]+=1
m=(b[i]-j)%h
if l<=m<=r:f=1
else:f=0
dp[i][j]=max(dp[i-1][j-1],dp[i-1][j])+f
print(max(dp[n-1]))
```
| 86,759 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vova had a pretty weird sleeping schedule. There are h hours in a day. Vova will sleep exactly n times. The i-th time he will sleep exactly after a_i hours from the time he woke up. You can assume that Vova woke up exactly at the beginning of this story (the initial time is 0). Each time Vova sleeps exactly one day (in other words, h hours).
Vova thinks that the i-th sleeping time is good if he starts to sleep between hours l and r inclusive.
Vova can control himself and before the i-th time can choose between two options: go to sleep after a_i hours or after a_i - 1 hours.
Your task is to say the maximum number of good sleeping times Vova can obtain if he acts optimally.
Input
The first line of the input contains four integers n, h, l and r (1 ≤ n ≤ 2000, 3 ≤ h ≤ 2000, 0 ≤ l ≤ r < h) — the number of times Vova goes to sleep, the number of hours in a day and the segment of the good sleeping time.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i < h), where a_i is the number of hours after which Vova goes to sleep the i-th time.
Output
Print one integer — the maximum number of good sleeping times Vova can obtain if he acts optimally.
Example
Input
7 24 21 23
16 17 14 20 20 11 22
Output
3
Note
The maximum number of good times in the example is 3.
The story starts from t=0. Then Vova goes to sleep after a_1 - 1 hours, now the time is 15. This time is not good. Then Vova goes to sleep after a_2 - 1 hours, now the time is 15 + 16 = 7. This time is also not good. Then Vova goes to sleep after a_3 hours, now the time is 7 + 14 = 21. This time is good. Then Vova goes to sleep after a_4 - 1 hours, now the time is 21 + 19 = 16. This time is not good. Then Vova goes to sleep after a_5 hours, now the time is 16 + 20 = 12. This time is not good. Then Vova goes to sleep after a_6 hours, now the time is 12 + 11 = 23. This time is good. Then Vova goes to sleep after a_7 hours, now the time is 23 + 22 = 21. This time is also good.
Tags: dp, implementation
Correct Solution:
```
from math import *
n, h, l, r = map(int, input().split())
a = [int(i) for i in input().split()]
dp = []
for i in range(n):
dp.append([0] * (n+1))
s = sum(a)
for i in range(n - 1, -1, -1):
for j in range(i + 2):
if r >= (s - j) % h >= l:
dp[i][j] += 1
if i < n - 1:
dp[i][j] += max(dp[i+1][j], dp[i+1][j+1])
s -= a[i]
#for i in dp:
# print(i)
print(max(dp[0][0], dp[0][1]))
```
| 86,760 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova had a pretty weird sleeping schedule. There are h hours in a day. Vova will sleep exactly n times. The i-th time he will sleep exactly after a_i hours from the time he woke up. You can assume that Vova woke up exactly at the beginning of this story (the initial time is 0). Each time Vova sleeps exactly one day (in other words, h hours).
Vova thinks that the i-th sleeping time is good if he starts to sleep between hours l and r inclusive.
Vova can control himself and before the i-th time can choose between two options: go to sleep after a_i hours or after a_i - 1 hours.
Your task is to say the maximum number of good sleeping times Vova can obtain if he acts optimally.
Input
The first line of the input contains four integers n, h, l and r (1 ≤ n ≤ 2000, 3 ≤ h ≤ 2000, 0 ≤ l ≤ r < h) — the number of times Vova goes to sleep, the number of hours in a day and the segment of the good sleeping time.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i < h), where a_i is the number of hours after which Vova goes to sleep the i-th time.
Output
Print one integer — the maximum number of good sleeping times Vova can obtain if he acts optimally.
Example
Input
7 24 21 23
16 17 14 20 20 11 22
Output
3
Note
The maximum number of good times in the example is 3.
The story starts from t=0. Then Vova goes to sleep after a_1 - 1 hours, now the time is 15. This time is not good. Then Vova goes to sleep after a_2 - 1 hours, now the time is 15 + 16 = 7. This time is also not good. Then Vova goes to sleep after a_3 hours, now the time is 7 + 14 = 21. This time is good. Then Vova goes to sleep after a_4 - 1 hours, now the time is 21 + 19 = 16. This time is not good. Then Vova goes to sleep after a_5 hours, now the time is 16 + 20 = 12. This time is not good. Then Vova goes to sleep after a_6 hours, now the time is 12 + 11 = 23. This time is good. Then Vova goes to sleep after a_7 hours, now the time is 23 + 22 = 21. This time is also good.
Submitted Solution:
```
n, h, l, r = map(int, input().split())
a = list(map(int, input().split()))
s = 0
d = [[-float('inf') for i in range(n + 1)] for j in range(n + 1)]
d[0][0] = 0
for i in range(n):
s += a[i]
for j in range(n + 1):
d[i + 1][j] = max(d[i + 1][j], d[i][j] + int(l <= (s - j) % h <= r))
if j < n:
d[i + 1][j + 1] = max(d[i + 1][j + 1], d[i][j] + int(l <= (s - j - 1) % h <= r))
print(max(d[n]))
```
Yes
| 86,761 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova had a pretty weird sleeping schedule. There are h hours in a day. Vova will sleep exactly n times. The i-th time he will sleep exactly after a_i hours from the time he woke up. You can assume that Vova woke up exactly at the beginning of this story (the initial time is 0). Each time Vova sleeps exactly one day (in other words, h hours).
Vova thinks that the i-th sleeping time is good if he starts to sleep between hours l and r inclusive.
Vova can control himself and before the i-th time can choose between two options: go to sleep after a_i hours or after a_i - 1 hours.
Your task is to say the maximum number of good sleeping times Vova can obtain if he acts optimally.
Input
The first line of the input contains four integers n, h, l and r (1 ≤ n ≤ 2000, 3 ≤ h ≤ 2000, 0 ≤ l ≤ r < h) — the number of times Vova goes to sleep, the number of hours in a day and the segment of the good sleeping time.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i < h), where a_i is the number of hours after which Vova goes to sleep the i-th time.
Output
Print one integer — the maximum number of good sleeping times Vova can obtain if he acts optimally.
Example
Input
7 24 21 23
16 17 14 20 20 11 22
Output
3
Note
The maximum number of good times in the example is 3.
The story starts from t=0. Then Vova goes to sleep after a_1 - 1 hours, now the time is 15. This time is not good. Then Vova goes to sleep after a_2 - 1 hours, now the time is 15 + 16 = 7. This time is also not good. Then Vova goes to sleep after a_3 hours, now the time is 7 + 14 = 21. This time is good. Then Vova goes to sleep after a_4 - 1 hours, now the time is 21 + 19 = 16. This time is not good. Then Vova goes to sleep after a_5 hours, now the time is 16 + 20 = 12. This time is not good. Then Vova goes to sleep after a_6 hours, now the time is 12 + 11 = 23. This time is good. Then Vova goes to sleep after a_7 hours, now the time is 23 + 22 = 21. This time is also good.
Submitted Solution:
```
n, h, l, r = map(int, input().split())
a = [int(_) for _ in input().split()]
d = [[-2024] * h for _ in range(n)]
d[0][a[0]] = (1 if l <= a[0] and a[0] <= r else 0)
d[0][a[0] - 1] = (1 if l <= a[0]-1 and a[0]-1 <= r else 0)
for i in range(1, n):
x = a[i]
for v in range(h):
d[i][v] = max(d[i-1][v-x], d[i-1][v-x+1]) + (1 if l <= v and v <= r else 0)
print(max(d[-1]))
```
Yes
| 86,762 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova had a pretty weird sleeping schedule. There are h hours in a day. Vova will sleep exactly n times. The i-th time he will sleep exactly after a_i hours from the time he woke up. You can assume that Vova woke up exactly at the beginning of this story (the initial time is 0). Each time Vova sleeps exactly one day (in other words, h hours).
Vova thinks that the i-th sleeping time is good if he starts to sleep between hours l and r inclusive.
Vova can control himself and before the i-th time can choose between two options: go to sleep after a_i hours or after a_i - 1 hours.
Your task is to say the maximum number of good sleeping times Vova can obtain if he acts optimally.
Input
The first line of the input contains four integers n, h, l and r (1 ≤ n ≤ 2000, 3 ≤ h ≤ 2000, 0 ≤ l ≤ r < h) — the number of times Vova goes to sleep, the number of hours in a day and the segment of the good sleeping time.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i < h), where a_i is the number of hours after which Vova goes to sleep the i-th time.
Output
Print one integer — the maximum number of good sleeping times Vova can obtain if he acts optimally.
Example
Input
7 24 21 23
16 17 14 20 20 11 22
Output
3
Note
The maximum number of good times in the example is 3.
The story starts from t=0. Then Vova goes to sleep after a_1 - 1 hours, now the time is 15. This time is not good. Then Vova goes to sleep after a_2 - 1 hours, now the time is 15 + 16 = 7. This time is also not good. Then Vova goes to sleep after a_3 hours, now the time is 7 + 14 = 21. This time is good. Then Vova goes to sleep after a_4 - 1 hours, now the time is 21 + 19 = 16. This time is not good. Then Vova goes to sleep after a_5 hours, now the time is 16 + 20 = 12. This time is not good. Then Vova goes to sleep after a_6 hours, now the time is 12 + 11 = 23. This time is good. Then Vova goes to sleep after a_7 hours, now the time is 23 + 22 = 21. This time is also good.
Submitted Solution:
```
n, h, l, r = map(int, input().split())
a = list(map(int, input().split()))
cur = [-1] * h
cur[0] = 0
for i in range(n):
next = [-1] * h
for j in range(h):
if cur[j] > -1:
p = (j + a[i]) % h
next[p] = max(cur[j] + (l <= p <= r), next[p])
p = (j + a[i] - 1) % h
next[p] = max(cur[j] + (l <= p <= r), next[p])
cur = next.copy()
print(max(cur))
```
Yes
| 86,763 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova had a pretty weird sleeping schedule. There are h hours in a day. Vova will sleep exactly n times. The i-th time he will sleep exactly after a_i hours from the time he woke up. You can assume that Vova woke up exactly at the beginning of this story (the initial time is 0). Each time Vova sleeps exactly one day (in other words, h hours).
Vova thinks that the i-th sleeping time is good if he starts to sleep between hours l and r inclusive.
Vova can control himself and before the i-th time can choose between two options: go to sleep after a_i hours or after a_i - 1 hours.
Your task is to say the maximum number of good sleeping times Vova can obtain if he acts optimally.
Input
The first line of the input contains four integers n, h, l and r (1 ≤ n ≤ 2000, 3 ≤ h ≤ 2000, 0 ≤ l ≤ r < h) — the number of times Vova goes to sleep, the number of hours in a day and the segment of the good sleeping time.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i < h), where a_i is the number of hours after which Vova goes to sleep the i-th time.
Output
Print one integer — the maximum number of good sleeping times Vova can obtain if he acts optimally.
Example
Input
7 24 21 23
16 17 14 20 20 11 22
Output
3
Note
The maximum number of good times in the example is 3.
The story starts from t=0. Then Vova goes to sleep after a_1 - 1 hours, now the time is 15. This time is not good. Then Vova goes to sleep after a_2 - 1 hours, now the time is 15 + 16 = 7. This time is also not good. Then Vova goes to sleep after a_3 hours, now the time is 7 + 14 = 21. This time is good. Then Vova goes to sleep after a_4 - 1 hours, now the time is 21 + 19 = 16. This time is not good. Then Vova goes to sleep after a_5 hours, now the time is 16 + 20 = 12. This time is not good. Then Vova goes to sleep after a_6 hours, now the time is 12 + 11 = 23. This time is good. Then Vova goes to sleep after a_7 hours, now the time is 23 + 22 = 21. This time is also good.
Submitted Solution:
```
n, h, l, r = map(int, input().split())
a = list(map(int, input().split()))
dp = [[None for i in range(h)] for i in range(n)]
if l <= a[0] <= r:
dp[0][a[0]] = 1
else:
dp[0][a[0]] = 0
if l <= a[0] - 1 <= r:
dp[0][a[0] - 1] = 1
else:
dp[0][a[0] - 1] = 0
for i in range(1, n):
for j in range(0, h):
if dp[i-1][(j+h-a[i])%h] != None:
if l <= j <= r:
if dp[i][j] != None:
dp[i][j] = max(dp[i-1][(j+h-a[i])%h] + 1, dp[i][j])
else:
dp[i][j] = dp[i-1][(j+h-a[i])%h] + 1
else:
if dp[i][j] != None:
dp[i][j] = max(dp[i-1][(j+h-a[i])%h] + 1, dp[i][j])
else:
dp[i][j] = dp[i-1][(j+h-a[i])%h]
if dp[i-1][(j+h-a[i]+1)%h] != None:
if l <= j <= r:
if dp[i][j] != None:
dp[i][j] = max(dp[i-1][(j+h-a[i]+1)%h] + 1, dp[i][j])
else:
dp[i][j] = dp[i-1][(j+h-a[i]+1)%h] + 1
else:
if dp[i][j] != None:
dp[i][j] = max(dp[i-1][(j+h-a[i]+1)%h], dp[i][j])
else:
dp[i][j] = dp[i-1][(j+h-a[i]+1)%h]
ans = 0
for i in range(h):
if dp[n-1][i] != None:
ans = max(ans, dp[n-1][i])
print(ans)
```
Yes
| 86,764 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova had a pretty weird sleeping schedule. There are h hours in a day. Vova will sleep exactly n times. The i-th time he will sleep exactly after a_i hours from the time he woke up. You can assume that Vova woke up exactly at the beginning of this story (the initial time is 0). Each time Vova sleeps exactly one day (in other words, h hours).
Vova thinks that the i-th sleeping time is good if he starts to sleep between hours l and r inclusive.
Vova can control himself and before the i-th time can choose between two options: go to sleep after a_i hours or after a_i - 1 hours.
Your task is to say the maximum number of good sleeping times Vova can obtain if he acts optimally.
Input
The first line of the input contains four integers n, h, l and r (1 ≤ n ≤ 2000, 3 ≤ h ≤ 2000, 0 ≤ l ≤ r < h) — the number of times Vova goes to sleep, the number of hours in a day and the segment of the good sleeping time.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i < h), where a_i is the number of hours after which Vova goes to sleep the i-th time.
Output
Print one integer — the maximum number of good sleeping times Vova can obtain if he acts optimally.
Example
Input
7 24 21 23
16 17 14 20 20 11 22
Output
3
Note
The maximum number of good times in the example is 3.
The story starts from t=0. Then Vova goes to sleep after a_1 - 1 hours, now the time is 15. This time is not good. Then Vova goes to sleep after a_2 - 1 hours, now the time is 15 + 16 = 7. This time is also not good. Then Vova goes to sleep after a_3 hours, now the time is 7 + 14 = 21. This time is good. Then Vova goes to sleep after a_4 - 1 hours, now the time is 21 + 19 = 16. This time is not good. Then Vova goes to sleep after a_5 hours, now the time is 16 + 20 = 12. This time is not good. Then Vova goes to sleep after a_6 hours, now the time is 12 + 11 = 23. This time is good. Then Vova goes to sleep after a_7 hours, now the time is 23 + 22 = 21. This time is also good.
Submitted Solution:
```
def printit(matrix):
for i in matrix:
for j in i:
print (j,end=" ")
print ()
n,h,start,end=map(int,input().split())
l=list(map(int,input().split()))
dp=[[0 for i in range(h)] for j in range(n)]
dp[0][l[0]-1]=1
dp[0][l[0]-2]=1
#printit(dp)
for i in range(1,n):
for j in range(h):
time1=j+h-l[i]
time2=j+h-l[i]+1
if time1>=h:
time1-=h
if time2>=h:
time2-=h
#print (time1,time2)
dp[i][j]=max(dp[i-1][time1],dp[i-1][time2])
#printit(dp)
ans=0
for i in range(start,end+1):
count=0
for j in range(n):
if dp[j][i]==1:
count+=1
if count>ans:
ans=count
print (ans)
```
No
| 86,765 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova had a pretty weird sleeping schedule. There are h hours in a day. Vova will sleep exactly n times. The i-th time he will sleep exactly after a_i hours from the time he woke up. You can assume that Vova woke up exactly at the beginning of this story (the initial time is 0). Each time Vova sleeps exactly one day (in other words, h hours).
Vova thinks that the i-th sleeping time is good if he starts to sleep between hours l and r inclusive.
Vova can control himself and before the i-th time can choose between two options: go to sleep after a_i hours or after a_i - 1 hours.
Your task is to say the maximum number of good sleeping times Vova can obtain if he acts optimally.
Input
The first line of the input contains four integers n, h, l and r (1 ≤ n ≤ 2000, 3 ≤ h ≤ 2000, 0 ≤ l ≤ r < h) — the number of times Vova goes to sleep, the number of hours in a day and the segment of the good sleeping time.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i < h), where a_i is the number of hours after which Vova goes to sleep the i-th time.
Output
Print one integer — the maximum number of good sleeping times Vova can obtain if he acts optimally.
Example
Input
7 24 21 23
16 17 14 20 20 11 22
Output
3
Note
The maximum number of good times in the example is 3.
The story starts from t=0. Then Vova goes to sleep after a_1 - 1 hours, now the time is 15. This time is not good. Then Vova goes to sleep after a_2 - 1 hours, now the time is 15 + 16 = 7. This time is also not good. Then Vova goes to sleep after a_3 hours, now the time is 7 + 14 = 21. This time is good. Then Vova goes to sleep after a_4 - 1 hours, now the time is 21 + 19 = 16. This time is not good. Then Vova goes to sleep after a_5 hours, now the time is 16 + 20 = 12. This time is not good. Then Vova goes to sleep after a_6 hours, now the time is 12 + 11 = 23. This time is good. Then Vova goes to sleep after a_7 hours, now the time is 23 + 22 = 21. This time is also good.
Submitted Solution:
```
n,h,l,r = map(int,input().split())
a = list(map(int,input().split()))
t = 0
hson = 0
for x in range(n):
if t > h:
t -= h
if t + a[x] >= l and t + a[x] <= r:
hson += 1
t += a[x]
elif t + a[x] - 1 and t + a[x] - 1 <= r:
hson += 1
t += a[x] - 1
else:
t += a[x] - 1
print(hson)
```
No
| 86,766 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova had a pretty weird sleeping schedule. There are h hours in a day. Vova will sleep exactly n times. The i-th time he will sleep exactly after a_i hours from the time he woke up. You can assume that Vova woke up exactly at the beginning of this story (the initial time is 0). Each time Vova sleeps exactly one day (in other words, h hours).
Vova thinks that the i-th sleeping time is good if he starts to sleep between hours l and r inclusive.
Vova can control himself and before the i-th time can choose between two options: go to sleep after a_i hours or after a_i - 1 hours.
Your task is to say the maximum number of good sleeping times Vova can obtain if he acts optimally.
Input
The first line of the input contains four integers n, h, l and r (1 ≤ n ≤ 2000, 3 ≤ h ≤ 2000, 0 ≤ l ≤ r < h) — the number of times Vova goes to sleep, the number of hours in a day and the segment of the good sleeping time.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i < h), where a_i is the number of hours after which Vova goes to sleep the i-th time.
Output
Print one integer — the maximum number of good sleeping times Vova can obtain if he acts optimally.
Example
Input
7 24 21 23
16 17 14 20 20 11 22
Output
3
Note
The maximum number of good times in the example is 3.
The story starts from t=0. Then Vova goes to sleep after a_1 - 1 hours, now the time is 15. This time is not good. Then Vova goes to sleep after a_2 - 1 hours, now the time is 15 + 16 = 7. This time is also not good. Then Vova goes to sleep after a_3 hours, now the time is 7 + 14 = 21. This time is good. Then Vova goes to sleep after a_4 - 1 hours, now the time is 21 + 19 = 16. This time is not good. Then Vova goes to sleep after a_5 hours, now the time is 16 + 20 = 12. This time is not good. Then Vova goes to sleep after a_6 hours, now the time is 12 + 11 = 23. This time is good. Then Vova goes to sleep after a_7 hours, now the time is 23 + 22 = 21. This time is also good.
Submitted Solution:
```
###### ### ####### ####### ## # ##### ### #####
# # # # # # # # # # # # # ###
# # # # # # # # # # # # # ###
###### ######### # # # # # # ######### #
###### ######### # # # # # # ######### #
# # # # # # # # # # #### # # #
# # # # # # # ## # # # # #
###### # # ####### ####### # # ##### # # # #
# mandatory imports
import os
import sys
from io import BytesIO, IOBase
from math import log2, ceil, sqrt, gcd, log
# optional imports
# from itertools import permutations
# from functools import cmp_to_key # for adding custom comparator
# from fractions import Fraction
from collections import *
from bisect import *
# from __future__ import print_function # for PyPy2
from heapq import *
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")
g = lambda : input().strip()
gl = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
rr = lambda x : reversed(range(x))
mod = int(1e9)+7
inf = float("inf")
n, h, l, r = gil()
a = gil()
for i in range(1, n):
a[i] += a[i-1]
a[i] %= h
dp = [[0 for _ in range(n)] for _ in range(n)]
for i in range(n):
dp[0][i] += (1 if l <= a[i] <= r else 0) + (dp[0][i-1] if i else 0)
ans = dp[0][-1]
for i in range(1, n):
for j in range(i-1, n):
at = a[j] - i
if at < 0:at += h
dp[i][j] += (1 if l <= at <= r else 0) + max((dp[i-1][j-1] if j else 0), (dp[i][j-1] if j else 0))
ans = max(ans, dp[i][-1])
# for r in dp:
# print(*r)
print(ans)
```
No
| 86,767 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vova had a pretty weird sleeping schedule. There are h hours in a day. Vova will sleep exactly n times. The i-th time he will sleep exactly after a_i hours from the time he woke up. You can assume that Vova woke up exactly at the beginning of this story (the initial time is 0). Each time Vova sleeps exactly one day (in other words, h hours).
Vova thinks that the i-th sleeping time is good if he starts to sleep between hours l and r inclusive.
Vova can control himself and before the i-th time can choose between two options: go to sleep after a_i hours or after a_i - 1 hours.
Your task is to say the maximum number of good sleeping times Vova can obtain if he acts optimally.
Input
The first line of the input contains four integers n, h, l and r (1 ≤ n ≤ 2000, 3 ≤ h ≤ 2000, 0 ≤ l ≤ r < h) — the number of times Vova goes to sleep, the number of hours in a day and the segment of the good sleeping time.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i < h), where a_i is the number of hours after which Vova goes to sleep the i-th time.
Output
Print one integer — the maximum number of good sleeping times Vova can obtain if he acts optimally.
Example
Input
7 24 21 23
16 17 14 20 20 11 22
Output
3
Note
The maximum number of good times in the example is 3.
The story starts from t=0. Then Vova goes to sleep after a_1 - 1 hours, now the time is 15. This time is not good. Then Vova goes to sleep after a_2 - 1 hours, now the time is 15 + 16 = 7. This time is also not good. Then Vova goes to sleep after a_3 hours, now the time is 7 + 14 = 21. This time is good. Then Vova goes to sleep after a_4 - 1 hours, now the time is 21 + 19 = 16. This time is not good. Then Vova goes to sleep after a_5 hours, now the time is 16 + 20 = 12. This time is not good. Then Vova goes to sleep after a_6 hours, now the time is 12 + 11 = 23. This time is good. Then Vova goes to sleep after a_7 hours, now the time is 23 + 22 = 21. This time is also good.
Submitted Solution:
```
import sys
input=sys.stdin.readline
from math import *
n,h,l,r=map(int,input().split())
a=[int(x) for x in input().split()]
s=[0 for i in range(n)]
s[0]=a[0]
for i in range(1,n):
s[i]=s[i-1]+a[i]
c=0
#print(s)
for i in range(n):
for j in range(i+2):
if l<=(s[i]-j)%h<=r:
c+=1
break
print(c)
```
No
| 86,768 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
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 first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Tags: brute force, data structures, greedy, two pointers
Correct Solution:
```
import string
from collections import defaultdict,Counter
from math import sqrt, log10, log2, log, gcd, ceil, floor,factorial
from bisect import bisect_left, bisect_right
from itertools import combinations,combinations_with_replacement
import sys,io,os
input=sys.stdin.readline
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
# print=sys.stdout.write
sys.setrecursionlimit(10000)
mod=10**9+7
inf = float('inf')
def get_list():
return [int(i) for i in input().split()]
def yn(a):
print("YES" if a else "NO",flush=False)
t=1
t=int(input())
for i in range(t):
n,k=get_list()
l=get_list()
pre=[0]*(2*k+2)
for iter1 in range(n):
iter2=n-1-iter1
pre[2]+=2
pre[2*k+1]-=2
mina=min(1+l[iter1],1+l[iter2])
maxa=max(k+l[iter1],k+l[iter2])
pre[mina]-=1
pre[maxa+1]+=1
pre[l[iter1]+l[iter2]]-=1
pre[l[iter1]+l[iter2]+1]+=1
for i in range(1,len(pre)):
pre[i]+=pre[i-1]
print(min(pre[2:2*k+1])//2)
```
| 86,769 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
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 first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Tags: brute force, data structures, greedy, two pointers
Correct Solution:
```
from itertools import accumulate
### TEMPLATE <<<
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return (map(int,input().split()))
### TEMPLATE >>>
def sgn(x):
if x>0:
return '+'
else:
return '-'
def solve(n, k, a):
h = [0] * (2*k + 5)
# print(h)
for i in range(n//2):
j = n - i - 1
h[0] += 2;
h[min(a[i], a[j]) + 1] -= 1
h[a[i] + a[j]] -= 1
h[a[i] + a[j] + 1] += 1
h[max(a[i], a[j]) + k + 1] += 1
pref = list(accumulate(h))
return min(pref)
def main():
T = int(input())
for tt in range(T):
n, k = invr()
a = list(invr())
print(solve(n, k, a))
main()
```
| 86,770 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
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 first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Tags: brute force, data structures, greedy, two pointers
Correct Solution:
```
import sys
input = sys.stdin.buffer.readline
from itertools import accumulate
t = int(input())
for _ in range(t):
n, k = map(int, input().split())
A = list(map(int, input().split()))
B = [0]*(2*k+2)
for i in range(n//2):
m = min(A[i], A[n-1-i])
M = max(A[i], A[n-1-i])
s = A[i] + A[n-1-i]
l = m+1
r = M+k
#2
B[0] += 2
B[l] -= 2
B[r+1] += 2
B[-1] -= 2
#1
B[l] += 1
B[s] -= 1
B[s+1] += 1
B[r+1] -= 1
C = list(accumulate(B))
#print(C)
ans = 10**18
for i in range(2, 2*k+1):
ans = min(ans, C[i])
print(ans)
```
| 86,771 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
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 first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Tags: brute force, data structures, greedy, two pointers
Correct Solution:
```
import sys
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(sys.stdin.readline())
def ria(): return list(map(int, sys.stdin.readline().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
def rotate(a, i):
t = a[i+2]
a[i + 2] = a[i + 1]
a[i + 1] = a[i]
a[i] = t
def solve(n, a):
sa = sorted(a)
s = []
rolled = False
i = 0
while i < n:
for j in range(i, n):
if a[j] == sa[i]:
break
while j - i >= 2:
j -= 2
rotate(a, j)
s.append(j+1)
if i+1 == j:
if i+2 < n:
rotate(a, i)
rotate(a, i)
s.append(i+1)
s.append(i+1)
else:
if rolled:
wi(-1)
return
found = False
for k in range(n-2, 0, -1):
if len(set(a[k-1:k+2])) == 2:
found = True
break
if found:
if a[k-1] == a[k]:
rotate(a, k - 1)
rotate(a, k - 1)
s.append(k)
s.append(k)
else:
rotate(a, k - 1)
s.append(k)
rolled = True
i = k-2
else:
wi(-1)
return
i += 1
if len(s) <= n*n:
wi(len(s))
wia(s)
else:
wi(-1)
def main():
for _ in range(ri()):
n = ri()
a = ria()
solve(n, a)
if __name__ == '__main__':
main()
```
| 86,772 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
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 first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Tags: brute force, data structures, greedy, two pointers
Correct Solution:
```
#!/usr/bin/env python
from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
def main():
t = inp()
for i in range(t):
solve()
def solve():
nk = inlt()
n = nk[0]
k = nk[1]
lst = inlt()
count_map = {}
prefs = [0] * (2 * k + 2)
for i in range(n // 2):
a = lst[i]
b = lst[n - i - 1]
s = a + b
count_map[s] = count_map.get(s, 0) + 1
start = min(a, b) + 1
end = max(a, b) + k + 1
prefs[start] += 1
prefs[end] -= 1
sums = []
total = 0
for num in prefs:
total += num
sums.append(total)
min_len = n
for x in range(2, 2 * k + 1):
cur = sums[x] - count_map.get(x, 0) + (n // 2 - sums[x]) * 2
min_len = min(min_len, cur)
print(min_len)
BUFSIZE = 8192
def inp():
return (int(input()))
def inlt():
return (list(map(int, input().split())))
def insr():
return (input().strip())
def invr():
return (map(int, input().split()))
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)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
```
| 86,773 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
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 first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Tags: brute force, data structures, greedy, two pointers
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
s=[]
for i in range(n):
for j in range(n-2):
if(l[j]>l[j+1]):
l[j],l[j+2]=l[j+2],l[j]
l[j],l[j+1]=l[j+1],l[j]
s.append(j+1)
s.append(j+1)
elif(l[j+1]>l[j+2]):
l[j],l[j+1]=l[j+1],l[j]
l[j],l[j+2]=l[j+2],l[j]
s.append(j+1)
if(l!=sorted(l)):
print(-1)
else:
print(len(s))
print(*s)
```
| 86,774 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
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 first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Tags: brute force, data structures, greedy, two pointers
Correct Solution:
```
import sys
input=sys.stdin.readline
def bs(l,target,n):
low=0
high=n
ans=-1
while low<=high:
mid=low+(high-low)//2
if l[mid]<=target:
ans=max(ans,mid)
low=mid+1
else:
high=mid-1
return ans
t=int(input())
for r in range(t):
n,k=map(int,input().split())
l=list(map(int,input().split()))
d={}
start=[]
end=[]
i=0
j=n-1
while i<j:
start.append(min(l[i],l[j])+1)
end.append(max(l[i],l[j])+k)
try:
d[l[i]+l[j]]+=1
except:
d[l[i]+l[j]]=1
i+=1
j-=1
start.sort()
end.sort()
mini=999999999999999
for i in range(1,(2*k)+1):
a=bs(start,i,len(start)-1)+1
b=bs(end,i-1,len(end)-1)+1
# print(a,b)
one=a-b
zero=0
try:
zero=d[i]
except:
pass
twos=(n//2)-(one)
ans=(twos*2)+(one-zero)
# print("x: "+str(i)+" ans: "+str(ans))
# print("0: "+str(zero)+" 1: "+str(one-zero)+" 2: "+str(twos))
mini=min(mini,ans)
print(mini)
```
| 86,775 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
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 first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Tags: brute force, data structures, greedy, two pointers
Correct Solution:
```
import math
from decimal import *
getcontext().prec = 30
t = int(input())
while t:
t -= 1
n, k = map(int, input().split())
a = list(map(int, input().split()))
l=[0]*(2*k+2)
for i in range(n//2):
l[1]+=2
l[2*k+1]-=2
mini=min(a[i],a[n-1-i])+1
maxi=max(a[i],a[n-1-i])+k
sum=a[i]+a[n-1-i]
l[mini]+=-1
l[maxi+1]+=1
l[sum]+=-1
l[sum+1]+=1
ans=10**10
for i in range(2,2*k+1):
l[i]+=l[i-1]
ans=min(ans,l[i])
print(ans)
```
| 86,776 |
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 (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
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 first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Submitted Solution:
```
from bisect import bisect, bisect_left, bisect_right
def solve():
n, k = map(int, input().split())
ar = list(map(int, input().split()))
ocr = {}
mpv = [None] * (n // 2)
spv = [None] * (n // 2)
for i in range(n // 2):
x = ar[i] + ar[n - i - 1]
mpx = max(ar[i], ar[n - i - 1]) + k
spx = min(ar[i], ar[n - i - 1]) + 1
spv[i] = spx
mpv[i] = mpx
if x in ocr:
ocr[x] += 1
else:
ocr[x] = 1
mpv.sort()
spv.sort()
items = [(v, k) for k, v in ocr.items()]
items.sort()
items.reverse()
best = n // 2
for ocr, x in items:
over = bisect_left(mpv, x, 0, len(mpv))
under = n // 2 - bisect_right(spv, x, 0, len(spv))
cur = n // 2 - ocr + over + under
if cur < best:
best = cur
print(best)
t = int(input())
for _ in range(t):
solve()
# solve()
```
Yes
| 86,777 |
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 (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
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 first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Submitted Solution:
```
def solve(n, k, arr):
temp = [0 for i in range(0, 2*k + 10)]
for i in range(0, n//2):
v1 = arr[i]
v2 = arr[n - 1 - i]
# p1 = 2
p1 = min(v1, v2) + 1
p2 = v1 + v2
p3 = max(v1, v2) + k
# p5 = k + k
temp[2] += 2
temp[p1] -= 1
temp[p2] -= 1
temp[p2 + 1] += 1
temp[p3 + 1] += 1
res = n
cur = 0
for i in range(2, 2*k + 1):
cur += temp[i]
res = min(cur, res)
return res
t = int(input())
for i in range(0, t):
n, k = map(int, input().split())
arr = list(map(int, input().split()))
res = solve(n, k, arr)
print(res)
```
Yes
| 86,778 |
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 (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
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 first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Submitted Solution:
```
t=int(input())
for _ in range(t):
n,k=map(int,input().split(" "))
arr=list(map(int,input().split(" ")))
start,end=2,2*k
ans=float('inf')
pairs=n//2
temp=[0]*(2*k+1)
d={}
for i in range(n//2):
val=arr[i]+arr[n-i-1]
if val not in d:
d[val]=1
else:
d[val]+=1
for i in range(n//2):
mm=min(arr[i],arr[n-i-1])+1
maxx=max(min(arr[i]+k,2*k),min(arr[n-i-1]+k,2*k))
temp[mm]+=1
if maxx+1<=2*k:
temp[maxx+1]-=1
for i in range(1,2*k+1):
temp[i]+=temp[i-1]
for num in range(start,end+1):
zeros=ones=twos=0
if num in d:
zeros=d[num]
ones=temp[num]-zeros
twos=pairs-ones-zeros
val=ones+(twos*2)
ans=min(ans,val)
print(ans)
```
Yes
| 86,779 |
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 (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
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 first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Submitted Solution:
```
def foo(n, data, k):
farr = [0] * (2 * k + 1)
sarr = [0] * (2 * k + 2)
i = 0
while i < n // 2:
farr[data[i] + data[size - i - 1]] += 1
i += 1
i = 0
while i < n // 2:
sarr[min(data[i], data[size - i - 1]) + 1] += 1
sarr[max(data[i], data[size - i - 1]) + k + 1] -= 1
i += 1
i = 1
while i < (2 * k + 1):
sarr[i] += sarr[i - 1]
i += 1
i = 0
minimum = int(2 * 10e5)
while i <= k * 2:
minimum = min(minimum, (sarr[i] - farr[i]) + 2 * (n // 2 - sarr[i]))
i += 1
print(minimum)
if __name__ == '__main__':
test = int(input())
while test:
size, k = [int(x) for x in input().split()]
data = [int(i) for i in input().split()]
foo(size, data, k)
test -= 1
```
Yes
| 86,780 |
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 (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
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 first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Submitted Solution:
```
import collections
line = input()
t = int(line)
for _ in range(t):
line = input()
n = int(line)
line = input()
nums = [int(i) for i in line.split(' ')]
res = collections.deque()
for i in range(n - 2):
for j in range(n - 3, i-1, -1):
if nums[j + 2] < nums[j + 1] and nums[j + 2] < nums[j]:
a, b, c = nums[j + 2], nums[j + 1], nums[j]
nums[j], nums[j + 1], nums[j + 2] = a, c, b
res.append(j + 1)
if nums[i] > nums[i + 1]:
a, b, c = nums[i], nums[i + 1], nums[i + 2]
nums[i], nums[i + 1], nums[i + 2] = b, c, a
res.append(i + 1)
res.append(i + 1)
# print(nums)
if nums[-1] < nums[-2]:
i = n - 2
while i >= 0 and nums[i] != nums[i + 1]:
i -= 1
if i < 0:
print(-1)
else:
while i < n - 2:
res.append(i + 1)
res.append(i + 1)
i += 1
print(len(res))
for i in res:
print(i, end= ' ')
print()
else:
print(len(res))
for i in res:
print(i, end= ' ')
print()
```
No
| 86,781 |
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 (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
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 first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Submitted Solution:
```
q = int(input())
for _ in range(q):
n, k = list(map(int, input().split(" ")))
arr = list(map(int, input().split(" ")))
ans = [0 for i in range(2*k + 1)]
# MIN = float("inf")
# for i in range(2, 2*k + 1):
# count = 0
if n == 2:
print(0)
continue
for j in range(n//2):
x, y = arr[j], arr[n-1-j]
mid = x + y
if 2 < mid < 2*k :
ans[mid+1] += 1
ans[mid] -= 1
endr = max(x, y) + k
endl = min(x, y) + 1
if endr < 2*k :
ans[endr+1] += 1
ans[endl] += 1
if endl != 2:
ans[2] += 2
ans[endl] -= 2
for i in range(1, 2*k + 1):
ans[i] += ans[i-1]
ans[0], ans[1] =float("inf"), float("inf")
print(min(ans))
# val = arr[j] + arr[n-1-j]
# if val == i:
# continue
# elif val > i:
# if 1 + min(arr[j] , arr[n-1-j]) > i:
# count += 2
# else:
# count += 1
#
# else:
# if max(arr[j] , arr[n-1-j]) + k < i:
# count += 2
# else:
# count += 1
#
# MIN = min(MIN, count)
# print(MIN)
```
No
| 86,782 |
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 (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
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 first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Submitted Solution:
```
''' Constant Palindrome Sum
'''
def search(ls, bound, dxn, home, outer):
print(ls, bound, dxn, home, outer)
if home == outer:
return home
if home - outer == 1:
if (ls[outer] - bound)*dxn <= 0:
return outer
elif (ls[home] - bound)*dxn <= 0:
return home
avg = (home + outer) // 2
val = ls[avg]
if (val - bound)*dxn > 0:
return search(ls, bound, dxn, home, avg)
elif (val - bound)*dxn < 0:
return search(ls, bound, dxn, avg, outer)
else:
return avg
''' routine '''
T = int(input())
for test in range(T):
N , K = list(map(int, input().split()))
array = list(map(int, input().split()))
totalpairs = N // 2
pairsum = {}
lowerbound = 2
upperbound = 2*K
bothexceed = 0
exceed = 0
for n in range(totalpairs):
a1 = array[n]
a2 = array[N - 1 - n]
sm = a1 + a2
if a1 > K and a2 > K:
bothexceed += 1
continue
elif a1 > K or a2 > K:
exceed += 1
elif a1 <= K and a2 <= K and sm > K and sm <= 2*K:
if sm in pairsum.keys():
pairsum[sm] += 1
else:
pairsum[sm] = 1
lowerbound = max(min(a1, a2) + 1, lowerbound)
upperbound = min(max(a1, a2) + K, upperbound)
# print(lowerbound, upperbound)
pairsum = list(pairsum.items())
pairsum.sort(key=lambda x:x[0])
if len(pairsum) == 0:
print(2*bothexceed + exceed)
continue
sums = [pair[0] for pair in pairsum]
mincoord = len(sums)
while True:
if mincoord == 0:
break
elif sums[mincoord - 1] >= lowerbound:
mincoord -= 1
else: break
maxcoord = -1
while True:
if maxcoord == len(sums) - 1:
break
elif sums[maxcoord + 1] <= upperbound:
maxcoord += 1
else: break
# print(mincoord, maxcoord)
if maxcoord + 1 - mincoord > 0:
shortlist = pairsum[mincoord:maxcoord + 1]
shortlist.sort(key=lambda x:x[1])
# print(shortlist)
modesum = shortlist[-1][0]
modeqty = shortlist[-1][1]
changes = totalpairs - modeqty + bothexceed
else:
changes = totalpairs + bothexceed
# no common sum in range without
print(changes)
```
No
| 86,783 |
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 (it is guaranteed that n is even, i.e. divisible by 2). All a_i does not exceed some integer k.
Your task is to replace the minimum number of elements (replacement is the following operation: choose some index i from 1 to n and replace a_i with some integer in range [1; k]) to satisfy the following conditions:
* after all replacements, all a_i are positive integers not greater than k;
* for all i from 1 to n/2 the following equation is true: a_i + a_{n - i + 1} = x, where x should be the same for all n/2 pairs of elements.
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 first line of the test case contains two integers n and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 2 ⋅ 10^5) — the length of a and the maximum possible value of some a_i correspondingly. It is guratanteed that n is even (i.e. divisible by 2). The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ k), where a_i is the i-th element of a.
It is guaranteed that the sum of n (as well as the sum of k) over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5, ∑ k ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the minimum number of elements you have to replace in a to satisfy the conditions from the problem statement.
Example
Input
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Output
0
1
4
2
Submitted Solution:
```
def solve(arr,s,k):
hs = s // 2
psum = [0]*hs
for i in range(hs):
psum[i] = arr[i]+arr[s-i-1]
highsum = [0]*hs
lowsum = [0]*hs
ans = 10**10
loh = ans
hol = 0
for i in range(hs) :
lowsum[i] = min(arr[i],arr[s-i-1])+1
highsum[i] = max(arr[i],arr[s-i-1])+k
hol = max(hol,lowsum[i])
loh = min(loh,highsum[i])
# print("hol {}".format(hol))
# print("loh {}".format(loh))
for ele in range(hol,loh+1) :
changes = 0
for i in range(hs) :
if(ele != psum[i]) :
if(ele >= lowsum[i] and ele <= highsum[i]) :
changes += 1
else :
changes += 2
ans = min(ans,changes)
return ans
tc = int(input())
fun = solve
ans = ""
for ll in range(tc) :
_,k = map(int,input().split())
li = [int(x) for x in input().split()]
ans += "{}\n".format(fun(li,_,k))
print(ans)
```
No
| 86,784 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ridhiman challenged Ashish to find the maximum valued subsequence of an array a of size n consisting of positive integers.
The value of a non-empty subsequence of k elements of a is defined as ∑ 2^i over all integers i ≥ 0 such that at least max(1, k - 2) elements of the subsequence have the i-th bit set in their binary representation (value x has the i-th bit set in its binary representation if ⌊ (x)/(2^i) ⌋ mod 2 is equal to 1).
Recall that b is a subsequence of a, if b can be obtained by deleting some(possibly zero) elements from a.
Help Ashish find the maximum value he can get by choosing some subsequence of a.
Input
The first line of the input consists of a single integer n (1 ≤ n ≤ 500) — the size of a.
The next line consists of n space-separated integers — the elements of the array (1 ≤ a_i ≤ 10^{18}).
Output
Print a single integer — the maximum value Ashish can get by choosing some subsequence of a.
Examples
Input
3
2 1 3
Output
3
Input
3
3 1 4
Output
7
Input
1
1
Output
1
Input
4
7 7 1 1
Output
7
Note
For the first test case, Ashish can pick the subsequence \{{2, 3}\} of size 2. The binary representation of 2 is 10 and that of 3 is 11. Since max(k - 2, 1) is equal to 1, the value of the subsequence is 2^0 + 2^1 (both 2 and 3 have 1-st bit set in their binary representation and 3 has 0-th bit set in its binary representation). Note that he could also pick the subsequence \{{3\}} or \{{2, 1, 3\}}.
For the second test case, Ashish can pick the subsequence \{{3, 4\}} with value 7.
For the third test case, Ashish can pick the subsequence \{{1\}} with value 1.
For the fourth test case, Ashish can pick the subsequence \{{7, 7\}} with value 7.
Tags: brute force, constructive algorithms
Correct Solution:
```
n = int(input())
lis = list(map(int,input().split()))
ans=0
for i in range(n):
for j in range(i,n):
for k in range(j,n):
ans = max(ans,lis[i] | lis[j] | lis[k])
print(ans)
```
| 86,785 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ridhiman challenged Ashish to find the maximum valued subsequence of an array a of size n consisting of positive integers.
The value of a non-empty subsequence of k elements of a is defined as ∑ 2^i over all integers i ≥ 0 such that at least max(1, k - 2) elements of the subsequence have the i-th bit set in their binary representation (value x has the i-th bit set in its binary representation if ⌊ (x)/(2^i) ⌋ mod 2 is equal to 1).
Recall that b is a subsequence of a, if b can be obtained by deleting some(possibly zero) elements from a.
Help Ashish find the maximum value he can get by choosing some subsequence of a.
Input
The first line of the input consists of a single integer n (1 ≤ n ≤ 500) — the size of a.
The next line consists of n space-separated integers — the elements of the array (1 ≤ a_i ≤ 10^{18}).
Output
Print a single integer — the maximum value Ashish can get by choosing some subsequence of a.
Examples
Input
3
2 1 3
Output
3
Input
3
3 1 4
Output
7
Input
1
1
Output
1
Input
4
7 7 1 1
Output
7
Note
For the first test case, Ashish can pick the subsequence \{{2, 3}\} of size 2. The binary representation of 2 is 10 and that of 3 is 11. Since max(k - 2, 1) is equal to 1, the value of the subsequence is 2^0 + 2^1 (both 2 and 3 have 1-st bit set in their binary representation and 3 has 0-th bit set in its binary representation). Note that he could also pick the subsequence \{{3\}} or \{{2, 1, 3\}}.
For the second test case, Ashish can pick the subsequence \{{3, 4\}} with value 7.
For the third test case, Ashish can pick the subsequence \{{1\}} with value 1.
For the fourth test case, Ashish can pick the subsequence \{{7, 7\}} with value 7.
Tags: brute force, constructive algorithms
Correct Solution:
```
import sys, os, io
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(sys.stdin.readline())
def ria(): return list(map(int, sys.stdin.readline().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
def solve(n, a):
ans = 0
for i in range(n):
for j in range(i, n):
for k in range(j, n):
ans = max(ans, a[i] | a[j] | a[k])
return ans
def main():
n = ri()
a = ria()
wi(solve(n, a))
if __name__ == '__main__':
main()
```
| 86,786 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ridhiman challenged Ashish to find the maximum valued subsequence of an array a of size n consisting of positive integers.
The value of a non-empty subsequence of k elements of a is defined as ∑ 2^i over all integers i ≥ 0 such that at least max(1, k - 2) elements of the subsequence have the i-th bit set in their binary representation (value x has the i-th bit set in its binary representation if ⌊ (x)/(2^i) ⌋ mod 2 is equal to 1).
Recall that b is a subsequence of a, if b can be obtained by deleting some(possibly zero) elements from a.
Help Ashish find the maximum value he can get by choosing some subsequence of a.
Input
The first line of the input consists of a single integer n (1 ≤ n ≤ 500) — the size of a.
The next line consists of n space-separated integers — the elements of the array (1 ≤ a_i ≤ 10^{18}).
Output
Print a single integer — the maximum value Ashish can get by choosing some subsequence of a.
Examples
Input
3
2 1 3
Output
3
Input
3
3 1 4
Output
7
Input
1
1
Output
1
Input
4
7 7 1 1
Output
7
Note
For the first test case, Ashish can pick the subsequence \{{2, 3}\} of size 2. The binary representation of 2 is 10 and that of 3 is 11. Since max(k - 2, 1) is equal to 1, the value of the subsequence is 2^0 + 2^1 (both 2 and 3 have 1-st bit set in their binary representation and 3 has 0-th bit set in its binary representation). Note that he could also pick the subsequence \{{3\}} or \{{2, 1, 3\}}.
For the second test case, Ashish can pick the subsequence \{{3, 4\}} with value 7.
For the third test case, Ashish can pick the subsequence \{{1\}} with value 1.
For the fourth test case, Ashish can pick the subsequence \{{7, 7\}} with value 7.
Tags: brute force, constructive algorithms
Correct Solution:
```
n=int(input())
l=input().split()
li=[int(i) for i in l]
dp=[0 for i in range(n)]
if(n==1):
print(li[0])
elif(n==2):
print(li[0]|li[1])
else:
maxa=0
for i in range(n):
for j in range(i+1,n):
for k in range(j+1,n):
curr=(li[i]|li[j])|li[k]
if(curr>maxa):
maxa=curr
print(maxa)
```
| 86,787 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ridhiman challenged Ashish to find the maximum valued subsequence of an array a of size n consisting of positive integers.
The value of a non-empty subsequence of k elements of a is defined as ∑ 2^i over all integers i ≥ 0 such that at least max(1, k - 2) elements of the subsequence have the i-th bit set in their binary representation (value x has the i-th bit set in its binary representation if ⌊ (x)/(2^i) ⌋ mod 2 is equal to 1).
Recall that b is a subsequence of a, if b can be obtained by deleting some(possibly zero) elements from a.
Help Ashish find the maximum value he can get by choosing some subsequence of a.
Input
The first line of the input consists of a single integer n (1 ≤ n ≤ 500) — the size of a.
The next line consists of n space-separated integers — the elements of the array (1 ≤ a_i ≤ 10^{18}).
Output
Print a single integer — the maximum value Ashish can get by choosing some subsequence of a.
Examples
Input
3
2 1 3
Output
3
Input
3
3 1 4
Output
7
Input
1
1
Output
1
Input
4
7 7 1 1
Output
7
Note
For the first test case, Ashish can pick the subsequence \{{2, 3}\} of size 2. The binary representation of 2 is 10 and that of 3 is 11. Since max(k - 2, 1) is equal to 1, the value of the subsequence is 2^0 + 2^1 (both 2 and 3 have 1-st bit set in their binary representation and 3 has 0-th bit set in its binary representation). Note that he could also pick the subsequence \{{3\}} or \{{2, 1, 3\}}.
For the second test case, Ashish can pick the subsequence \{{3, 4\}} with value 7.
For the third test case, Ashish can pick the subsequence \{{1\}} with value 1.
For the fourth test case, Ashish can pick the subsequence \{{7, 7\}} with value 7.
Tags: brute force, constructive algorithms
Correct Solution:
```
from sys import stdin,stdout
from math import gcd,sqrt
from collections import deque
input=stdin.readline
R=lambda:map(int,input().split())
I=lambda:int(input())
S=lambda:input().rstrip('\n')
P=lambda x:stdout.write(x)
hg=lambda x,y:((y+x-1)//x)*x
cu=lambda x:max(0,x-1)
cd=lambda x:min(r-1,x+1)
cl=lambda x:max(0,x-1)
cr=lambda x:min(c-1,x+1)
n=I()
a=list(R())
ans=0
for i in range(n):
for j in range(i,n):
for k in range(j,n):
ans=max(ans,(a[i] | a[j] | a[k]))
print(ans)
```
| 86,788 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ridhiman challenged Ashish to find the maximum valued subsequence of an array a of size n consisting of positive integers.
The value of a non-empty subsequence of k elements of a is defined as ∑ 2^i over all integers i ≥ 0 such that at least max(1, k - 2) elements of the subsequence have the i-th bit set in their binary representation (value x has the i-th bit set in its binary representation if ⌊ (x)/(2^i) ⌋ mod 2 is equal to 1).
Recall that b is a subsequence of a, if b can be obtained by deleting some(possibly zero) elements from a.
Help Ashish find the maximum value he can get by choosing some subsequence of a.
Input
The first line of the input consists of a single integer n (1 ≤ n ≤ 500) — the size of a.
The next line consists of n space-separated integers — the elements of the array (1 ≤ a_i ≤ 10^{18}).
Output
Print a single integer — the maximum value Ashish can get by choosing some subsequence of a.
Examples
Input
3
2 1 3
Output
3
Input
3
3 1 4
Output
7
Input
1
1
Output
1
Input
4
7 7 1 1
Output
7
Note
For the first test case, Ashish can pick the subsequence \{{2, 3}\} of size 2. The binary representation of 2 is 10 and that of 3 is 11. Since max(k - 2, 1) is equal to 1, the value of the subsequence is 2^0 + 2^1 (both 2 and 3 have 1-st bit set in their binary representation and 3 has 0-th bit set in its binary representation). Note that he could also pick the subsequence \{{3\}} or \{{2, 1, 3\}}.
For the second test case, Ashish can pick the subsequence \{{3, 4\}} with value 7.
For the third test case, Ashish can pick the subsequence \{{1\}} with value 1.
For the fourth test case, Ashish can pick the subsequence \{{7, 7\}} with value 7.
Tags: brute force, constructive algorithms
Correct Solution:
```
import sys
# sys.setrecursionlimit(10**6)
input=sys.stdin.readline
# t=int(input())
# for t1 in range(t):
import math
n=int(input())
l=list(map(int,input().split(" ")))
ans=0
if(n<3):
for i in range(n):
ans=ans | l[i]
for i in range(n):
for j in range(i+1,n):
for k in range(j+1,n):
temp=l[i]|l[j]
temp=temp|l[k]
ans=max(ans,temp)
print(ans)
```
| 86,789 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ridhiman challenged Ashish to find the maximum valued subsequence of an array a of size n consisting of positive integers.
The value of a non-empty subsequence of k elements of a is defined as ∑ 2^i over all integers i ≥ 0 such that at least max(1, k - 2) elements of the subsequence have the i-th bit set in their binary representation (value x has the i-th bit set in its binary representation if ⌊ (x)/(2^i) ⌋ mod 2 is equal to 1).
Recall that b is a subsequence of a, if b can be obtained by deleting some(possibly zero) elements from a.
Help Ashish find the maximum value he can get by choosing some subsequence of a.
Input
The first line of the input consists of a single integer n (1 ≤ n ≤ 500) — the size of a.
The next line consists of n space-separated integers — the elements of the array (1 ≤ a_i ≤ 10^{18}).
Output
Print a single integer — the maximum value Ashish can get by choosing some subsequence of a.
Examples
Input
3
2 1 3
Output
3
Input
3
3 1 4
Output
7
Input
1
1
Output
1
Input
4
7 7 1 1
Output
7
Note
For the first test case, Ashish can pick the subsequence \{{2, 3}\} of size 2. The binary representation of 2 is 10 and that of 3 is 11. Since max(k - 2, 1) is equal to 1, the value of the subsequence is 2^0 + 2^1 (both 2 and 3 have 1-st bit set in their binary representation and 3 has 0-th bit set in its binary representation). Note that he could also pick the subsequence \{{3\}} or \{{2, 1, 3\}}.
For the second test case, Ashish can pick the subsequence \{{3, 4\}} with value 7.
For the third test case, Ashish can pick the subsequence \{{1\}} with value 1.
For the fourth test case, Ashish can pick the subsequence \{{7, 7\}} with value 7.
Tags: brute force, constructive algorithms
Correct Solution:
```
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
import threading
def main(n,arr):
a=max(arr)
res=0
for i in range(min(3,n)):
res|=arr[i]
for k in range(n):
for i in range(k+1,n):
for j in range(i+1,n):
res=max(res,arr[k]|arr[i]|arr[j])
p_2=1
ans=0
for i in range(64):
if 1<<i &res:
ans+=p_2
p_2*=2
return ans
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__":
n=int(input())
arr=tuple(map(int,input().split() ))
print(main(n,arr))
```
| 86,790 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ridhiman challenged Ashish to find the maximum valued subsequence of an array a of size n consisting of positive integers.
The value of a non-empty subsequence of k elements of a is defined as ∑ 2^i over all integers i ≥ 0 such that at least max(1, k - 2) elements of the subsequence have the i-th bit set in their binary representation (value x has the i-th bit set in its binary representation if ⌊ (x)/(2^i) ⌋ mod 2 is equal to 1).
Recall that b is a subsequence of a, if b can be obtained by deleting some(possibly zero) elements from a.
Help Ashish find the maximum value he can get by choosing some subsequence of a.
Input
The first line of the input consists of a single integer n (1 ≤ n ≤ 500) — the size of a.
The next line consists of n space-separated integers — the elements of the array (1 ≤ a_i ≤ 10^{18}).
Output
Print a single integer — the maximum value Ashish can get by choosing some subsequence of a.
Examples
Input
3
2 1 3
Output
3
Input
3
3 1 4
Output
7
Input
1
1
Output
1
Input
4
7 7 1 1
Output
7
Note
For the first test case, Ashish can pick the subsequence \{{2, 3}\} of size 2. The binary representation of 2 is 10 and that of 3 is 11. Since max(k - 2, 1) is equal to 1, the value of the subsequence is 2^0 + 2^1 (both 2 and 3 have 1-st bit set in their binary representation and 3 has 0-th bit set in its binary representation). Note that he could also pick the subsequence \{{3\}} or \{{2, 1, 3\}}.
For the second test case, Ashish can pick the subsequence \{{3, 4\}} with value 7.
For the third test case, Ashish can pick the subsequence \{{1\}} with value 1.
For the fourth test case, Ashish can pick the subsequence \{{7, 7\}} with value 7.
Tags: brute force, constructive algorithms
Correct Solution:
```
import sys
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def main():
n=II()
aa=LI()
ans=0
if n==1:
ans=aa[0]
elif n==2:
for i in range(n):
for j in range(i):
ans = max(ans, aa[i] | aa[j])
else:
for i in range(n):
for j in range(i):
for k in range(j):
ans=max(ans,aa[i]|aa[j]|aa[k])
print(ans)
main()
```
| 86,791 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ridhiman challenged Ashish to find the maximum valued subsequence of an array a of size n consisting of positive integers.
The value of a non-empty subsequence of k elements of a is defined as ∑ 2^i over all integers i ≥ 0 such that at least max(1, k - 2) elements of the subsequence have the i-th bit set in their binary representation (value x has the i-th bit set in its binary representation if ⌊ (x)/(2^i) ⌋ mod 2 is equal to 1).
Recall that b is a subsequence of a, if b can be obtained by deleting some(possibly zero) elements from a.
Help Ashish find the maximum value he can get by choosing some subsequence of a.
Input
The first line of the input consists of a single integer n (1 ≤ n ≤ 500) — the size of a.
The next line consists of n space-separated integers — the elements of the array (1 ≤ a_i ≤ 10^{18}).
Output
Print a single integer — the maximum value Ashish can get by choosing some subsequence of a.
Examples
Input
3
2 1 3
Output
3
Input
3
3 1 4
Output
7
Input
1
1
Output
1
Input
4
7 7 1 1
Output
7
Note
For the first test case, Ashish can pick the subsequence \{{2, 3}\} of size 2. The binary representation of 2 is 10 and that of 3 is 11. Since max(k - 2, 1) is equal to 1, the value of the subsequence is 2^0 + 2^1 (both 2 and 3 have 1-st bit set in their binary representation and 3 has 0-th bit set in its binary representation). Note that he could also pick the subsequence \{{3\}} or \{{2, 1, 3\}}.
For the second test case, Ashish can pick the subsequence \{{3, 4\}} with value 7.
For the third test case, Ashish can pick the subsequence \{{1\}} with value 1.
For the fourth test case, Ashish can pick the subsequence \{{7, 7\}} with value 7.
Tags: brute force, constructive algorithms
Correct Solution:
```
n = int(input())
arr = list(map(int,input().split()))
ans=0
for i in range(n):
for j in range(i,n):
for k in range(j,n):
ans = max( ans, arr[i] | arr[j] | arr[k] )
print(ans)
```
| 86,792 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ridhiman challenged Ashish to find the maximum valued subsequence of an array a of size n consisting of positive integers.
The value of a non-empty subsequence of k elements of a is defined as ∑ 2^i over all integers i ≥ 0 such that at least max(1, k - 2) elements of the subsequence have the i-th bit set in their binary representation (value x has the i-th bit set in its binary representation if ⌊ (x)/(2^i) ⌋ mod 2 is equal to 1).
Recall that b is a subsequence of a, if b can be obtained by deleting some(possibly zero) elements from a.
Help Ashish find the maximum value he can get by choosing some subsequence of a.
Input
The first line of the input consists of a single integer n (1 ≤ n ≤ 500) — the size of a.
The next line consists of n space-separated integers — the elements of the array (1 ≤ a_i ≤ 10^{18}).
Output
Print a single integer — the maximum value Ashish can get by choosing some subsequence of a.
Examples
Input
3
2 1 3
Output
3
Input
3
3 1 4
Output
7
Input
1
1
Output
1
Input
4
7 7 1 1
Output
7
Note
For the first test case, Ashish can pick the subsequence \{{2, 3}\} of size 2. The binary representation of 2 is 10 and that of 3 is 11. Since max(k - 2, 1) is equal to 1, the value of the subsequence is 2^0 + 2^1 (both 2 and 3 have 1-st bit set in their binary representation and 3 has 0-th bit set in its binary representation). Note that he could also pick the subsequence \{{3\}} or \{{2, 1, 3\}}.
For the second test case, Ashish can pick the subsequence \{{3, 4\}} with value 7.
For the third test case, Ashish can pick the subsequence \{{1\}} with value 1.
For the fourth test case, Ashish can pick the subsequence \{{7, 7\}} with value 7.
Submitted Solution:
```
import sys
input = sys.stdin.readline
def calc(arr):
v = max(1,len(arr)-2)
ans = 0
for i in range(m):
count = 0
for j in range(len(arr)):
if arr[j][i]=="1":
count += 1
if count>=v:
ans += 2**(m-i-1)
return ans
n = int(input())
a = sorted(list(map(int,input().split())))
a = a[::-1]
if n==1:
print (a[0])
exit()
if n==2:
print (a[0]|a[1])
exit()
ans = 0
for i in range(n):
for j in range(i+1,n):
for k in range(j+1,n):
ans = max(ans,a[i]|a[j]|a[k])
print (ans)
```
Yes
| 86,793 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ridhiman challenged Ashish to find the maximum valued subsequence of an array a of size n consisting of positive integers.
The value of a non-empty subsequence of k elements of a is defined as ∑ 2^i over all integers i ≥ 0 such that at least max(1, k - 2) elements of the subsequence have the i-th bit set in their binary representation (value x has the i-th bit set in its binary representation if ⌊ (x)/(2^i) ⌋ mod 2 is equal to 1).
Recall that b is a subsequence of a, if b can be obtained by deleting some(possibly zero) elements from a.
Help Ashish find the maximum value he can get by choosing some subsequence of a.
Input
The first line of the input consists of a single integer n (1 ≤ n ≤ 500) — the size of a.
The next line consists of n space-separated integers — the elements of the array (1 ≤ a_i ≤ 10^{18}).
Output
Print a single integer — the maximum value Ashish can get by choosing some subsequence of a.
Examples
Input
3
2 1 3
Output
3
Input
3
3 1 4
Output
7
Input
1
1
Output
1
Input
4
7 7 1 1
Output
7
Note
For the first test case, Ashish can pick the subsequence \{{2, 3}\} of size 2. The binary representation of 2 is 10 and that of 3 is 11. Since max(k - 2, 1) is equal to 1, the value of the subsequence is 2^0 + 2^1 (both 2 and 3 have 1-st bit set in their binary representation and 3 has 0-th bit set in its binary representation). Note that he could also pick the subsequence \{{3\}} or \{{2, 1, 3\}}.
For the second test case, Ashish can pick the subsequence \{{3, 4\}} with value 7.
For the third test case, Ashish can pick the subsequence \{{1\}} with value 1.
For the fourth test case, Ashish can pick the subsequence \{{7, 7\}} with value 7.
Submitted Solution:
```
import sys
import collections as cc
import bisect as bi
input = sys.stdin.readline
I=lambda:list(map(int,input().split()))
n,=I()
l=I()
if n<3:
ans=0
for i in l:
ans|=i
print(ans)
else:
ans=0
for i in range(n):
for j in range(i+1,n):
for k in range(j+1,n):
ans=max(ans,l[i]|l[j]|l[k])
print(ans)
```
Yes
| 86,794 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ridhiman challenged Ashish to find the maximum valued subsequence of an array a of size n consisting of positive integers.
The value of a non-empty subsequence of k elements of a is defined as ∑ 2^i over all integers i ≥ 0 such that at least max(1, k - 2) elements of the subsequence have the i-th bit set in their binary representation (value x has the i-th bit set in its binary representation if ⌊ (x)/(2^i) ⌋ mod 2 is equal to 1).
Recall that b is a subsequence of a, if b can be obtained by deleting some(possibly zero) elements from a.
Help Ashish find the maximum value he can get by choosing some subsequence of a.
Input
The first line of the input consists of a single integer n (1 ≤ n ≤ 500) — the size of a.
The next line consists of n space-separated integers — the elements of the array (1 ≤ a_i ≤ 10^{18}).
Output
Print a single integer — the maximum value Ashish can get by choosing some subsequence of a.
Examples
Input
3
2 1 3
Output
3
Input
3
3 1 4
Output
7
Input
1
1
Output
1
Input
4
7 7 1 1
Output
7
Note
For the first test case, Ashish can pick the subsequence \{{2, 3}\} of size 2. The binary representation of 2 is 10 and that of 3 is 11. Since max(k - 2, 1) is equal to 1, the value of the subsequence is 2^0 + 2^1 (both 2 and 3 have 1-st bit set in their binary representation and 3 has 0-th bit set in its binary representation). Note that he could also pick the subsequence \{{3\}} or \{{2, 1, 3\}}.
For the second test case, Ashish can pick the subsequence \{{3, 4\}} with value 7.
For the third test case, Ashish can pick the subsequence \{{1\}} with value 1.
For the fourth test case, Ashish can pick the subsequence \{{7, 7\}} with value 7.
Submitted Solution:
```
'''input
4
7 7 1 1
'''
import math
from itertools import combinations
def calc_final(nums):
count_bit = [0 for i in range(65)]
for i in range(65):
for j in range(len(nums)):
if nums[j] % 2 == 1:
count_bit[i] += 1
nums[j] //= 2
final = 0
po = 1
for i in range(65):
if count_bit[i] >= max(1, len(nums) - 2):
final += po
po *= 2
return final
n = int(input())
arr = list(map(int, input().split()))
if n <= 2:
ans = 0
for i in range(1, n + 1):
combs = combinations(arr, i)
for comb in combs:
# print(list(comb))
ans = max(ans, calc_final(list(comb)))
print(ans)
else:
ans = 0
for i in range(len(arr)):
ans = max(ans, arr[i])
for j in range(i + 1, len(arr)):
ans = max(ans, arr[i] | arr[j])
for k in range(j + 1, len(arr)):
ans = max(ans, arr[i] | arr[j] | arr[k])
print(ans)
```
Yes
| 86,795 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ridhiman challenged Ashish to find the maximum valued subsequence of an array a of size n consisting of positive integers.
The value of a non-empty subsequence of k elements of a is defined as ∑ 2^i over all integers i ≥ 0 such that at least max(1, k - 2) elements of the subsequence have the i-th bit set in their binary representation (value x has the i-th bit set in its binary representation if ⌊ (x)/(2^i) ⌋ mod 2 is equal to 1).
Recall that b is a subsequence of a, if b can be obtained by deleting some(possibly zero) elements from a.
Help Ashish find the maximum value he can get by choosing some subsequence of a.
Input
The first line of the input consists of a single integer n (1 ≤ n ≤ 500) — the size of a.
The next line consists of n space-separated integers — the elements of the array (1 ≤ a_i ≤ 10^{18}).
Output
Print a single integer — the maximum value Ashish can get by choosing some subsequence of a.
Examples
Input
3
2 1 3
Output
3
Input
3
3 1 4
Output
7
Input
1
1
Output
1
Input
4
7 7 1 1
Output
7
Note
For the first test case, Ashish can pick the subsequence \{{2, 3}\} of size 2. The binary representation of 2 is 10 and that of 3 is 11. Since max(k - 2, 1) is equal to 1, the value of the subsequence is 2^0 + 2^1 (both 2 and 3 have 1-st bit set in their binary representation and 3 has 0-th bit set in its binary representation). Note that he could also pick the subsequence \{{3\}} or \{{2, 1, 3\}}.
For the second test case, Ashish can pick the subsequence \{{3, 4\}} with value 7.
For the third test case, Ashish can pick the subsequence \{{1\}} with value 1.
For the fourth test case, Ashish can pick the subsequence \{{7, 7\}} with value 7.
Submitted Solution:
```
import sys
import math
from collections import defaultdict,deque
import heapq
n=int(sys.stdin.readline())
arr=list(map(int,sys.stdin.readline().split()))
ans=0
for i in range(n):
for j in range(i,n):
for k in range(j,n):
ans=max(ans,arr[i]|arr[j]|arr[k])
print(ans)
```
Yes
| 86,796 |
Evaluate the correctness of the submitted Python 2 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ridhiman challenged Ashish to find the maximum valued subsequence of an array a of size n consisting of positive integers.
The value of a non-empty subsequence of k elements of a is defined as ∑ 2^i over all integers i ≥ 0 such that at least max(1, k - 2) elements of the subsequence have the i-th bit set in their binary representation (value x has the i-th bit set in its binary representation if ⌊ (x)/(2^i) ⌋ mod 2 is equal to 1).
Recall that b is a subsequence of a, if b can be obtained by deleting some(possibly zero) elements from a.
Help Ashish find the maximum value he can get by choosing some subsequence of a.
Input
The first line of the input consists of a single integer n (1 ≤ n ≤ 500) — the size of a.
The next line consists of n space-separated integers — the elements of the array (1 ≤ a_i ≤ 10^{18}).
Output
Print a single integer — the maximum value Ashish can get by choosing some subsequence of a.
Examples
Input
3
2 1 3
Output
3
Input
3
3 1 4
Output
7
Input
1
1
Output
1
Input
4
7 7 1 1
Output
7
Note
For the first test case, Ashish can pick the subsequence \{{2, 3}\} of size 2. The binary representation of 2 is 10 and that of 3 is 11. Since max(k - 2, 1) is equal to 1, the value of the subsequence is 2^0 + 2^1 (both 2 and 3 have 1-st bit set in their binary representation and 3 has 0-th bit set in its binary representation). Note that he could also pick the subsequence \{{3\}} or \{{2, 1, 3\}}.
For the second test case, Ashish can pick the subsequence \{{3, 4\}} with value 7.
For the third test case, Ashish can pick the subsequence \{{1\}} with value 1.
For the fourth test case, Ashish can pick the subsequence \{{7, 7\}} with value 7.
Submitted Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
from fractions import gcd
import heapq
raw_input = stdin.readline
pr = stdout.write
mod=998244353
def ni():
return int(raw_input())
def li():
return list(map(int,raw_input().split()))
def pn(n):
stdout.write(str(n)+'\n')
def pa(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return tuple(map(int,stdin.read().split()))
range = xrange # not for python 3.0+
def fun(l):
ans=0
n=len(l)
for i in range(61):
x=1<<i
c=0
for j in l:
if j&x:
c+=1
if c>=max(1,n-2):
ans+=x
return ans
# main code
n=ni()
l=li()
d=defaultdict(set)
ans=0
for i in range(61):
x=1<<i
f=0
for j in range(n):
if l[j]&x:
f=1
#print x,l[j]
d[i].add(l[j])
if f:
ans=x
for i in d:
s1=[]
n1=0
for i1 in range(n):
if l[i1] not in d[i]:
s1.append(l[i1])
n1+=1
for j in range(n1):
temp=Counter(d[i])
temp[l[j]]+=1
ans=max(ans,fun(temp))
for k in range(j+1,n1):
temp[l[k]]+=1
ans=max(ans,fun(temp))
temp[l[k]]-=1
pn(ans)
```
No
| 86,797 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ridhiman challenged Ashish to find the maximum valued subsequence of an array a of size n consisting of positive integers.
The value of a non-empty subsequence of k elements of a is defined as ∑ 2^i over all integers i ≥ 0 such that at least max(1, k - 2) elements of the subsequence have the i-th bit set in their binary representation (value x has the i-th bit set in its binary representation if ⌊ (x)/(2^i) ⌋ mod 2 is equal to 1).
Recall that b is a subsequence of a, if b can be obtained by deleting some(possibly zero) elements from a.
Help Ashish find the maximum value he can get by choosing some subsequence of a.
Input
The first line of the input consists of a single integer n (1 ≤ n ≤ 500) — the size of a.
The next line consists of n space-separated integers — the elements of the array (1 ≤ a_i ≤ 10^{18}).
Output
Print a single integer — the maximum value Ashish can get by choosing some subsequence of a.
Examples
Input
3
2 1 3
Output
3
Input
3
3 1 4
Output
7
Input
1
1
Output
1
Input
4
7 7 1 1
Output
7
Note
For the first test case, Ashish can pick the subsequence \{{2, 3}\} of size 2. The binary representation of 2 is 10 and that of 3 is 11. Since max(k - 2, 1) is equal to 1, the value of the subsequence is 2^0 + 2^1 (both 2 and 3 have 1-st bit set in their binary representation and 3 has 0-th bit set in its binary representation). Note that he could also pick the subsequence \{{3\}} or \{{2, 1, 3\}}.
For the second test case, Ashish can pick the subsequence \{{3, 4\}} with value 7.
For the third test case, Ashish can pick the subsequence \{{1\}} with value 1.
For the fourth test case, Ashish can pick the subsequence \{{7, 7\}} with value 7.
Submitted Solution:
```
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
import threading
def main(n,arr):
a=max(arr)
res=0
for k in range(n):
for i in range(k+1,n):
for j in range(i+1,n):
res=max(res,arr[k]|arr[i]|arr[j])
p_2=1
ans=0
for i in range(64):
if 1<<i &res:
ans+=p_2
p_2*=2
return ans
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__":
n=int(input())
arr=tuple(map(int,input().split() ))
print(main(n,arr))
```
No
| 86,798 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ridhiman challenged Ashish to find the maximum valued subsequence of an array a of size n consisting of positive integers.
The value of a non-empty subsequence of k elements of a is defined as ∑ 2^i over all integers i ≥ 0 such that at least max(1, k - 2) elements of the subsequence have the i-th bit set in their binary representation (value x has the i-th bit set in its binary representation if ⌊ (x)/(2^i) ⌋ mod 2 is equal to 1).
Recall that b is a subsequence of a, if b can be obtained by deleting some(possibly zero) elements from a.
Help Ashish find the maximum value he can get by choosing some subsequence of a.
Input
The first line of the input consists of a single integer n (1 ≤ n ≤ 500) — the size of a.
The next line consists of n space-separated integers — the elements of the array (1 ≤ a_i ≤ 10^{18}).
Output
Print a single integer — the maximum value Ashish can get by choosing some subsequence of a.
Examples
Input
3
2 1 3
Output
3
Input
3
3 1 4
Output
7
Input
1
1
Output
1
Input
4
7 7 1 1
Output
7
Note
For the first test case, Ashish can pick the subsequence \{{2, 3}\} of size 2. The binary representation of 2 is 10 and that of 3 is 11. Since max(k - 2, 1) is equal to 1, the value of the subsequence is 2^0 + 2^1 (both 2 and 3 have 1-st bit set in their binary representation and 3 has 0-th bit set in its binary representation). Note that he could also pick the subsequence \{{3\}} or \{{2, 1, 3\}}.
For the second test case, Ashish can pick the subsequence \{{3, 4\}} with value 7.
For the third test case, Ashish can pick the subsequence \{{1\}} with value 1.
For the fourth test case, Ashish can pick the subsequence \{{7, 7\}} with value 7.
Submitted Solution:
```
"""
NTC here
"""
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
profile = 0
pypy = 1
def iin(): return int(input())
def lin(): return list(map(int, input().split()))
def check(val):
x = val
ch = 0
while x:
if x%2==0:
return False
ch += 1
x//=2
return ch
def main():
n = iin()
a = lin()
b = [[] for i in range(61)]
for j, i in enumerate(a):
x = i
ch = 0
while x:
if x%2:
b[ch].append(j)
x //= 2
ch += 1
ans = -1
st = set()
ch = 1
# print(b)
for i in range(61):
if b[i]:
st.update(b[i])
ch1 = len(st)
# print(i, st, ch1)
a1 = 0
for i in st:
a1 |= a[i]
x = check(a1)
# print(x, a1)
if x:
ans = max(x-1, ans)
print(pow(2, ans+1)-1)
# 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")
if pypy:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
if profile:
import cProfile
cProfile.run('main()')
else:
main()
```
No
| 86,799 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.