message stringlengths 2 433k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
The life goes up and down, just like nice sequences. Sequence t1, t2, ..., tn is called nice if the following two conditions are satisfied:
* ti < ti + 1 for each odd i < n;
* ti > ti + 1 for each even i < n.
For example, sequences (2, 8), (1, 5, 1) and (2, 5, 1, 100, 99, 120) are nice, while (1, 1), (1, 2, 3) and (2, 5, 3, 2) are not.
Bear Limak has a sequence of positive integers t1, t2, ..., tn. This sequence is not nice now and Limak wants to fix it by a single swap. He is going to choose two indices i < j and swap elements ti and tj in order to get a nice sequence. Count the number of ways to do so. Two ways are considered different if indices of elements chosen for a swap are different.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 150 000) — the length of the sequence.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 150 000) — the initial sequence. It's guaranteed that the given sequence is not nice.
Output
Print the number of ways to swap two elements exactly once in order to get a nice sequence.
Examples
Input
5
2 8 4 7 7
Output
2
Input
4
200 150 100 50
Output
1
Input
10
3 2 1 4 1 4 1 4 1 4
Output
8
Input
9
1 2 3 4 5 6 7 8 9
Output
0
Note
In the first sample, there are two ways to get a nice sequence with one swap:
1. Swap t2 = 8 with t4 = 7.
2. Swap t1 = 2 with t5 = 7.
In the second sample, there is only one way — Limak should swap t1 = 200 with t4 = 50. | instruction | 0 | 15,512 | 12 | 31,024 |
Tags: brute force, implementation
Correct Solution:
```
def get_bit(diff, i):
return 1 if ((i%2==1 and diff<=0) or (i%2==0 and diff>=0)) else 0
def swap_(i, j, a):
temp = a[i]
a[i] = a[j]
a[j] = temp
def swap(i, j, n, a, mask, S):
change = 0
swap_(i, j, a)
set_index = set([i, j])
if i<n-1:
set_index.add(i+1)
if j<n-1:
set_index.add(j+1)
for index in set_index:
if index > 0:
diff = a[index] - a[index-1]
bit_ = get_bit(diff, index)
change += bit_ - mask[index]
swap_(i, j, a)
if S + change == 0:
return 1
return 0
n = int(input())
a = list(map(int, input().split()))
diff = [-1] + [x-y for x, y in zip(a[1:], a[:-1])]
mask = [get_bit(diff[i], i) for i in range(n)]
S = sum(mask)
first = -1
for i, x in enumerate(mask):
if x == 1:
first = i
break
cnt = 0
for second in range(n):
if swap(first, second, n, a, mask, S) == 1:
cnt += 1
if first != 0 and swap(first-1, second, n, a, mask, S) == 1:
cnt += 1
if first!=0 and swap(first-1, first, n, a, mask, S) == 1:
cnt-=1
print(cnt)
#9
#1 2 3 4 5 6 7 8 9
#10
#3 2 1 4 1 4 1 4 1 4
#4
#200 150 100 50
#5
#2 8 4 7 7
``` | output | 1 | 15,512 | 12 | 31,025 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The life goes up and down, just like nice sequences. Sequence t1, t2, ..., tn is called nice if the following two conditions are satisfied:
* ti < ti + 1 for each odd i < n;
* ti > ti + 1 for each even i < n.
For example, sequences (2, 8), (1, 5, 1) and (2, 5, 1, 100, 99, 120) are nice, while (1, 1), (1, 2, 3) and (2, 5, 3, 2) are not.
Bear Limak has a sequence of positive integers t1, t2, ..., tn. This sequence is not nice now and Limak wants to fix it by a single swap. He is going to choose two indices i < j and swap elements ti and tj in order to get a nice sequence. Count the number of ways to do so. Two ways are considered different if indices of elements chosen for a swap are different.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 150 000) — the length of the sequence.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 150 000) — the initial sequence. It's guaranteed that the given sequence is not nice.
Output
Print the number of ways to swap two elements exactly once in order to get a nice sequence.
Examples
Input
5
2 8 4 7 7
Output
2
Input
4
200 150 100 50
Output
1
Input
10
3 2 1 4 1 4 1 4 1 4
Output
8
Input
9
1 2 3 4 5 6 7 8 9
Output
0
Note
In the first sample, there are two ways to get a nice sequence with one swap:
1. Swap t2 = 8 with t4 = 7.
2. Swap t1 = 2 with t5 = 7.
In the second sample, there is only one way — Limak should swap t1 = 200 with t4 = 50. | instruction | 0 | 15,513 | 12 | 31,026 |
Tags: brute force, implementation
Correct Solution:
```
def main():
n, l = int(input()), list(map(int, input().split()))
if not (n & 1):
l.append(0)
l.append(150001)
a, b, fails, tmp, res = 0, 150001, [], [], 0
for i, c in enumerate(l, -1):
if i & 1:
if a >= b or b <= c:
if len(fails) > 5:
print(0)
return
fails.append(i)
else:
if a <= b or b >= c:
if len(fails) > 5:
print(0)
return
fails.append(i)
a, b = b, c
for b in fails:
tmp.append("><"[b & 1] if b - a == 1 else "and ")
tmp.append("l[{:n}]".format(b))
a = b
check = compile("".join(tmp[1:]), "<string>", "eval")
for i in fails:
a = l[i]
for j in range(n):
l[i], l[j] = l[j], a
if eval(check) and ((l[j - 1] < l[j] > l[j + 1]) if j & 1 else (l[j - 1] > l[j] < l[j + 1])):
res += 1 if j in fails else 2
l[j] = l[i]
l[i] = a
print(res // 2)
if __name__ == '__main__':
main()
``` | output | 1 | 15,513 | 12 | 31,027 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The life goes up and down, just like nice sequences. Sequence t1, t2, ..., tn is called nice if the following two conditions are satisfied:
* ti < ti + 1 for each odd i < n;
* ti > ti + 1 for each even i < n.
For example, sequences (2, 8), (1, 5, 1) and (2, 5, 1, 100, 99, 120) are nice, while (1, 1), (1, 2, 3) and (2, 5, 3, 2) are not.
Bear Limak has a sequence of positive integers t1, t2, ..., tn. This sequence is not nice now and Limak wants to fix it by a single swap. He is going to choose two indices i < j and swap elements ti and tj in order to get a nice sequence. Count the number of ways to do so. Two ways are considered different if indices of elements chosen for a swap are different.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 150 000) — the length of the sequence.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 150 000) — the initial sequence. It's guaranteed that the given sequence is not nice.
Output
Print the number of ways to swap two elements exactly once in order to get a nice sequence.
Examples
Input
5
2 8 4 7 7
Output
2
Input
4
200 150 100 50
Output
1
Input
10
3 2 1 4 1 4 1 4 1 4
Output
8
Input
9
1 2 3 4 5 6 7 8 9
Output
0
Note
In the first sample, there are two ways to get a nice sequence with one swap:
1. Swap t2 = 8 with t4 = 7.
2. Swap t1 = 2 with t5 = 7.
In the second sample, there is only one way — Limak should swap t1 = 200 with t4 = 50. | instruction | 0 | 15,514 | 12 | 31,028 |
Tags: brute force, implementation
Correct Solution:
```
def main():
n, l = int(input()), list(map(int, input().split()))
if not (n & 1):
l.append(0)
l.append(150001)
a, b, fails, res = 0, 150001, [], 0
for i, c in enumerate(l, -1):
if i & 1:
if a >= b or b <= c:
if len(fails) > 5:
print(0)
return
fails.append(i)
else:
if a <= b or b >= c:
if len(fails) > 5:
print(0)
return
fails.append(i)
a, b = b, c
check = compile("and".join(
"(l[{:n}]{:s}l[{:n}]{:s}l[{:n}])".format(i - 1, "><"[i & 1], i, "<>"[i & 1], i + 1) for i in fails),
"<string>", "eval")
for i in fails:
a = l[i]
for j in range(n):
l[i], l[j] = l[j], a
if eval(check) and ((l[j - 1] < l[j] > l[j + 1]) if j & 1 else (l[j - 1] > l[j] < l[j + 1])):
res += 1 if j in fails else 2
l[j] = l[i]
l[i] = a
print(res // 2)
if __name__ == '__main__':
main()
``` | output | 1 | 15,514 | 12 | 31,029 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The life goes up and down, just like nice sequences. Sequence t1, t2, ..., tn is called nice if the following two conditions are satisfied:
* ti < ti + 1 for each odd i < n;
* ti > ti + 1 for each even i < n.
For example, sequences (2, 8), (1, 5, 1) and (2, 5, 1, 100, 99, 120) are nice, while (1, 1), (1, 2, 3) and (2, 5, 3, 2) are not.
Bear Limak has a sequence of positive integers t1, t2, ..., tn. This sequence is not nice now and Limak wants to fix it by a single swap. He is going to choose two indices i < j and swap elements ti and tj in order to get a nice sequence. Count the number of ways to do so. Two ways are considered different if indices of elements chosen for a swap are different.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 150 000) — the length of the sequence.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 150 000) — the initial sequence. It's guaranteed that the given sequence is not nice.
Output
Print the number of ways to swap two elements exactly once in order to get a nice sequence.
Examples
Input
5
2 8 4 7 7
Output
2
Input
4
200 150 100 50
Output
1
Input
10
3 2 1 4 1 4 1 4 1 4
Output
8
Input
9
1 2 3 4 5 6 7 8 9
Output
0
Note
In the first sample, there are two ways to get a nice sequence with one swap:
1. Swap t2 = 8 with t4 = 7.
2. Swap t1 = 2 with t5 = 7.
In the second sample, there is only one way — Limak should swap t1 = 200 with t4 = 50. | instruction | 0 | 15,515 | 12 | 31,030 |
Tags: brute force, implementation
Correct Solution:
```
def main():
n, l = int(input()), list(map(int, input().split()))
if not (n & 1):
l.append(0)
l.append(150001)
i, b, c, fails0, fails1 = 0, 0, 150001, [], []
try:
while True:
a, b, c = b, c, l[i]
if a >= b or b <= c:
if len(fails0) + len(fails1) > 5:
print(0)
return
fails1.append(i - 1)
i += 1
a, b, c = b, c, l[i]
if a <= b or b >= c:
if len(fails0) + len(fails1) > 5:
print(0)
return
fails0.append(i - 1)
i += 1
except IndexError:
fails, res = fails0 + fails1, 0
for i in fails:
a = l[i]
for j in range(n):
f = fails1 if j & 1 else fails0
f.append(j)
l[i], l[j] = l[j], a
if (all(l[b - 1] > l[b] < l[b + 1] for b in fails0) and
all(l[b - 1] < l[b] > l[b + 1] for b in fails1)):
res += 1 if j in fails else 2
l[j] = l[i]
del f[-1]
l[i] = a
print(res // 2)
if __name__ == '__main__':
main()
``` | output | 1 | 15,515 | 12 | 31,031 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The life goes up and down, just like nice sequences. Sequence t1, t2, ..., tn is called nice if the following two conditions are satisfied:
* ti < ti + 1 for each odd i < n;
* ti > ti + 1 for each even i < n.
For example, sequences (2, 8), (1, 5, 1) and (2, 5, 1, 100, 99, 120) are nice, while (1, 1), (1, 2, 3) and (2, 5, 3, 2) are not.
Bear Limak has a sequence of positive integers t1, t2, ..., tn. This sequence is not nice now and Limak wants to fix it by a single swap. He is going to choose two indices i < j and swap elements ti and tj in order to get a nice sequence. Count the number of ways to do so. Two ways are considered different if indices of elements chosen for a swap are different.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 150 000) — the length of the sequence.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 150 000) — the initial sequence. It's guaranteed that the given sequence is not nice.
Output
Print the number of ways to swap two elements exactly once in order to get a nice sequence.
Examples
Input
5
2 8 4 7 7
Output
2
Input
4
200 150 100 50
Output
1
Input
10
3 2 1 4 1 4 1 4 1 4
Output
8
Input
9
1 2 3 4 5 6 7 8 9
Output
0
Note
In the first sample, there are two ways to get a nice sequence with one swap:
1. Swap t2 = 8 with t4 = 7.
2. Swap t1 = 2 with t5 = 7.
In the second sample, there is only one way — Limak should swap t1 = 200 with t4 = 50. | instruction | 0 | 15,516 | 12 | 31,032 |
Tags: brute force, implementation
Correct Solution:
```
def main():
n, l = int(input()), list(map(int, input().split()))
if not (n & 1):
l.append(0)
l.append(150001)
a, b, fails, res = 0, 150001, [], 0
for i, c in enumerate(l, -1):
if i & 1:
if a >= b or b <= c:
if len(fails) > 5:
print(0)
return
fails.append(i)
else:
if a <= b or b >= c:
if len(fails) > 5:
print(0)
return
fails.append(i)
a, b = b, c
check = compile("and".join(
"(l[{:n}]{:s}l[{:n}]{:s}l[{:n}])".format(i - 1, "><"[i & 1], i, "<>"[i & 1], i + 1) for i in fails),
"<string>", "eval")
for i in fails:
a = l[i]
for j in range(n):
l[i], l[j] = l[j], a
if eval(check) and ((l[j - 1] < l[j] > l[j + 1]) if j & 1 else (l[j - 1] > l[j] < l[j + 1])):
res += 1 if j in fails else 2
l[j] = l[i]
l[i] = a
print(res // 2)
if __name__ == '__main__':
main()
# Made By Mostafa_Khaled
``` | output | 1 | 15,516 | 12 | 31,033 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The life goes up and down, just like nice sequences. Sequence t1, t2, ..., tn is called nice if the following two conditions are satisfied:
* ti < ti + 1 for each odd i < n;
* ti > ti + 1 for each even i < n.
For example, sequences (2, 8), (1, 5, 1) and (2, 5, 1, 100, 99, 120) are nice, while (1, 1), (1, 2, 3) and (2, 5, 3, 2) are not.
Bear Limak has a sequence of positive integers t1, t2, ..., tn. This sequence is not nice now and Limak wants to fix it by a single swap. He is going to choose two indices i < j and swap elements ti and tj in order to get a nice sequence. Count the number of ways to do so. Two ways are considered different if indices of elements chosen for a swap are different.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 150 000) — the length of the sequence.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 150 000) — the initial sequence. It's guaranteed that the given sequence is not nice.
Output
Print the number of ways to swap two elements exactly once in order to get a nice sequence.
Examples
Input
5
2 8 4 7 7
Output
2
Input
4
200 150 100 50
Output
1
Input
10
3 2 1 4 1 4 1 4 1 4
Output
8
Input
9
1 2 3 4 5 6 7 8 9
Output
0
Note
In the first sample, there are two ways to get a nice sequence with one swap:
1. Swap t2 = 8 with t4 = 7.
2. Swap t1 = 2 with t5 = 7.
In the second sample, there is only one way — Limak should swap t1 = 200 with t4 = 50.
Submitted Solution:
```
n, m = int(input()), 150001
p = [m] + list(map(int, input().split())) + [m * (n & 1)]
f = lambda i: p[i] >= p[i + 1] if i & 1 else p[i] <= p[i + 1]
g = lambda i, j: sum(f(k) for k in {i, i - 1, j, j - 1})
t = [f(i) for i in range(n + 1)]
r, s = 0, sum(t)
if s > 4: exit(print(0))
e = {i + 1 for i in range(n) if t[i] or t[i + 1]}
for i in e:
for j in range(1, n + 1):
if (i < j or (i > j and j not in e)) and g(i, j) == s:
p[i], p[j] = p[j], p[i]
r += g(i, j) == 0
p[i], p[j] = p[j], p[i]
print(r)
``` | instruction | 0 | 15,517 | 12 | 31,034 |
Yes | output | 1 | 15,517 | 12 | 31,035 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The life goes up and down, just like nice sequences. Sequence t1, t2, ..., tn is called nice if the following two conditions are satisfied:
* ti < ti + 1 for each odd i < n;
* ti > ti + 1 for each even i < n.
For example, sequences (2, 8), (1, 5, 1) and (2, 5, 1, 100, 99, 120) are nice, while (1, 1), (1, 2, 3) and (2, 5, 3, 2) are not.
Bear Limak has a sequence of positive integers t1, t2, ..., tn. This sequence is not nice now and Limak wants to fix it by a single swap. He is going to choose two indices i < j and swap elements ti and tj in order to get a nice sequence. Count the number of ways to do so. Two ways are considered different if indices of elements chosen for a swap are different.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 150 000) — the length of the sequence.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 150 000) — the initial sequence. It's guaranteed that the given sequence is not nice.
Output
Print the number of ways to swap two elements exactly once in order to get a nice sequence.
Examples
Input
5
2 8 4 7 7
Output
2
Input
4
200 150 100 50
Output
1
Input
10
3 2 1 4 1 4 1 4 1 4
Output
8
Input
9
1 2 3 4 5 6 7 8 9
Output
0
Note
In the first sample, there are two ways to get a nice sequence with one swap:
1. Swap t2 = 8 with t4 = 7.
2. Swap t1 = 2 with t5 = 7.
In the second sample, there is only one way — Limak should swap t1 = 200 with t4 = 50.
Submitted Solution:
```
def main():
n, l = int(input()), list(map(int, input().split()))
if not (n & 1):
l.append(0)
l.append(150001)
a, b, fails, tmp, res = 0, 150001, [], [], 0
for i, c in enumerate(l, -1):
if i & 1:
if a >= b or b <= c:
if len(fails) > 5:
print(0)
return
fails.append(i)
else:
if a <= b or b >= c:
if len(fails) > 5:
print(0)
return
fails.append(i)
a, b = b, c
for b in fails:
tmp.append("><"[b & 1] if b - a == 1 else "and ")
tmp.append("l[{:n}]".format(b))
a = b
check = compile("".join(tmp[1:]), "<string>", "eval")
for i in fails:
a = l[i]
for j in range(0, n, 2):
l[i], l[j] = l[j], a
if l[j - 1] > a < l[j + 1] and eval(check):
res += 1 if j in fails else 2
l[j] = l[i]
for j in range(1, n, 2):
l[i], l[j] = l[j], a
if l[j - 1] < a > l[j + 1] and eval(check):
res += 1 if j in fails else 2
l[j] = l[i]
l[i] = a
print(res // 2)
if __name__ == '__main__':
main()
``` | instruction | 0 | 15,518 | 12 | 31,036 |
Yes | output | 1 | 15,518 | 12 | 31,037 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The life goes up and down, just like nice sequences. Sequence t1, t2, ..., tn is called nice if the following two conditions are satisfied:
* ti < ti + 1 for each odd i < n;
* ti > ti + 1 for each even i < n.
For example, sequences (2, 8), (1, 5, 1) and (2, 5, 1, 100, 99, 120) are nice, while (1, 1), (1, 2, 3) and (2, 5, 3, 2) are not.
Bear Limak has a sequence of positive integers t1, t2, ..., tn. This sequence is not nice now and Limak wants to fix it by a single swap. He is going to choose two indices i < j and swap elements ti and tj in order to get a nice sequence. Count the number of ways to do so. Two ways are considered different if indices of elements chosen for a swap are different.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 150 000) — the length of the sequence.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 150 000) — the initial sequence. It's guaranteed that the given sequence is not nice.
Output
Print the number of ways to swap two elements exactly once in order to get a nice sequence.
Examples
Input
5
2 8 4 7 7
Output
2
Input
4
200 150 100 50
Output
1
Input
10
3 2 1 4 1 4 1 4 1 4
Output
8
Input
9
1 2 3 4 5 6 7 8 9
Output
0
Note
In the first sample, there are two ways to get a nice sequence with one swap:
1. Swap t2 = 8 with t4 = 7.
2. Swap t1 = 2 with t5 = 7.
In the second sample, there is only one way — Limak should swap t1 = 200 with t4 = 50.
Submitted Solution:
```
def main():
n, l = int(input()), list(map(int, input().split()))
if not (n & 1):
l.append(0)
l.append(150001)
a, b, fails, res = 0, 150001, [], 0
for i, c in enumerate(l, -1):
if i & 1:
if a >= b or b <= c:
if len(fails) > 5:
print(0)
return
fails.append(i)
else:
if a <= b or b >= c:
if len(fails) > 5:
print(0)
return
fails.append(i)
a, b = b, c
ff = fails + [0]
for i in fails:
a = l[i]
for j in range(n):
l[i], l[j], ff[-1] = l[j], a, j
if (all((l[b - 1] < l[b] > l[b + 1]) if b & 1 else
(l[b - 1] > l[b] < l[b + 1]) for b in ff)):
res += 1 if j in fails else 2
l[j] = l[i]
l[i] = a
print(res // 2)
if __name__ == '__main__':
main()
``` | instruction | 0 | 15,519 | 12 | 31,038 |
Yes | output | 1 | 15,519 | 12 | 31,039 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The life goes up and down, just like nice sequences. Sequence t1, t2, ..., tn is called nice if the following two conditions are satisfied:
* ti < ti + 1 for each odd i < n;
* ti > ti + 1 for each even i < n.
For example, sequences (2, 8), (1, 5, 1) and (2, 5, 1, 100, 99, 120) are nice, while (1, 1), (1, 2, 3) and (2, 5, 3, 2) are not.
Bear Limak has a sequence of positive integers t1, t2, ..., tn. This sequence is not nice now and Limak wants to fix it by a single swap. He is going to choose two indices i < j and swap elements ti and tj in order to get a nice sequence. Count the number of ways to do so. Two ways are considered different if indices of elements chosen for a swap are different.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 150 000) — the length of the sequence.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 150 000) — the initial sequence. It's guaranteed that the given sequence is not nice.
Output
Print the number of ways to swap two elements exactly once in order to get a nice sequence.
Examples
Input
5
2 8 4 7 7
Output
2
Input
4
200 150 100 50
Output
1
Input
10
3 2 1 4 1 4 1 4 1 4
Output
8
Input
9
1 2 3 4 5 6 7 8 9
Output
0
Note
In the first sample, there are two ways to get a nice sequence with one swap:
1. Swap t2 = 8 with t4 = 7.
2. Swap t1 = 2 with t5 = 7.
In the second sample, there is only one way — Limak should swap t1 = 200 with t4 = 50.
Submitted Solution:
```
n = int(input())
t = [int(d) for d in input().split()]
m = 0
ind = [0,0]
nb = [0,0]
res = -1
def mis(i,v):
if i==n-1: return False
if i==-1: return False
if ((v>=t[i+1]) and i%2==0) or ((v<=t[i+1]) and i%2==1): return True
return False
def miso(i,v):
if i==n-1: return False
if i==-1: return False
if ((t[i]>=v) and i%2==0) or ((t[i]<=v) and i%2==1): return True
return False
for i in range(n-1):
if mis(i,t[i]):
#mis
if m==2:
res = 0
break
if nb[m]>0: nb[m] = nb[m]+1
else:
ind[m] = i
nb[m] = 2
if (i==n-2) and (nb[m]>0):
m = m+1
else:
#god
if m==2:
continue
if nb[m]>0:
m = m+1
def switch(i,j):
if i==j-1:
t[i],t[j] = t[j],t[i]
bol = not (mis(i,t[i]) or miso(i-1,t[i]) or
mis(j,t[j]) or miso(j-1,t[j]))
t[i],t[j] = t[j],t[i]
return bol
return not (mis(i,t[j]) or miso(i-1,t[j]) or
mis(j,t[i]) or miso(j-1,t[i]))
if res==0 or (nb[0]>5) or (nb[1]>5): print(0)
elif ((nb[0]==4) or (nb[0]==5)) and (m==2): print(0)
elif ((nb[1]==4) or (nb[1]==5)) and (m==2): print(0)
else:
res = 0
i = ind[0]
j = ind[1]
if nb[0]==5:
#m==1
if switch(i+1,i+3): res = 1
elif nb[0]==4:
#m==1
res = int(switch(i+1,i+2))+int(switch(i+1,i+3))+int(switch(i,i+2))
elif m==2:
#nb[i] == 2 or 3
if switch(i+1,j+1): res = res+1
if (nb[0]==2) and switch(i,j+1): res = res+1
if (nb[1]==2) and switch(i+1,j): res = res+1
if (nb[0]==2) and (nb[1]==2) and switch(i,j):
res = res+1
else:
#m==1
for k in range(n):
if (k!=i+1) and switch(min(i+1,k),max(i+1,k)): res = res+1
if (nb[0]==2) and (k!=i) and (k!=i+1) and switch(min(i,k),max(i,k)):
res = res+1
print(res)
``` | instruction | 0 | 15,520 | 12 | 31,040 |
Yes | output | 1 | 15,520 | 12 | 31,041 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The life goes up and down, just like nice sequences. Sequence t1, t2, ..., tn is called nice if the following two conditions are satisfied:
* ti < ti + 1 for each odd i < n;
* ti > ti + 1 for each even i < n.
For example, sequences (2, 8), (1, 5, 1) and (2, 5, 1, 100, 99, 120) are nice, while (1, 1), (1, 2, 3) and (2, 5, 3, 2) are not.
Bear Limak has a sequence of positive integers t1, t2, ..., tn. This sequence is not nice now and Limak wants to fix it by a single swap. He is going to choose two indices i < j and swap elements ti and tj in order to get a nice sequence. Count the number of ways to do so. Two ways are considered different if indices of elements chosen for a swap are different.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 150 000) — the length of the sequence.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 150 000) — the initial sequence. It's guaranteed that the given sequence is not nice.
Output
Print the number of ways to swap two elements exactly once in order to get a nice sequence.
Examples
Input
5
2 8 4 7 7
Output
2
Input
4
200 150 100 50
Output
1
Input
10
3 2 1 4 1 4 1 4 1 4
Output
8
Input
9
1 2 3 4 5 6 7 8 9
Output
0
Note
In the first sample, there are two ways to get a nice sequence with one swap:
1. Swap t2 = 8 with t4 = 7.
2. Swap t1 = 2 with t5 = 7.
In the second sample, there is only one way — Limak should swap t1 = 200 with t4 = 50.
Submitted Solution:
```
n = int(input())
a = [int(x) for x in input().split()]
def check(x):
if x == 0:
return a[0] < a[1]
if x == len(a)-1:
return check(x-1)
if x%2 == 0:
return (a[x] < a[x+1] and a[x-1] > a[x])
else:
return (a[x] > a[x+1] and a[x-1] < a[x])
hits = 0
x = 0
for i in range(len(a)-1):
if (i%2) == 0:
if a[i] >= a[i+1]:
hits += 1
x = i
else:
if a[i] <= a[i+1]:
hits += 1
x = i
if hits > 2:
print(0)
elif hits == 2:
print('1')
else:
ans = 0
d = {}
for i in range(len(a)):
a[x], a[i] = a[i], a[x]
if check(x) and check(i):
p,q = sorted((x,i))
if (p,q) not in d:
d[(p,q)]=1
ans += 1
a[i], a[x] = a[x], a[i]
x += 1
for i in range(len(a)):
a[x], a[i] = a[i], a[x]
if check(x) and check(i):
p,q = sorted((x,i))
if (p,q) not in d:
d[(p,q)]=1
ans += 1
a[i], a[x] = a[x], a[i]
print(ans)
``` | instruction | 0 | 15,521 | 12 | 31,042 |
No | output | 1 | 15,521 | 12 | 31,043 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The life goes up and down, just like nice sequences. Sequence t1, t2, ..., tn is called nice if the following two conditions are satisfied:
* ti < ti + 1 for each odd i < n;
* ti > ti + 1 for each even i < n.
For example, sequences (2, 8), (1, 5, 1) and (2, 5, 1, 100, 99, 120) are nice, while (1, 1), (1, 2, 3) and (2, 5, 3, 2) are not.
Bear Limak has a sequence of positive integers t1, t2, ..., tn. This sequence is not nice now and Limak wants to fix it by a single swap. He is going to choose two indices i < j and swap elements ti and tj in order to get a nice sequence. Count the number of ways to do so. Two ways are considered different if indices of elements chosen for a swap are different.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 150 000) — the length of the sequence.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 150 000) — the initial sequence. It's guaranteed that the given sequence is not nice.
Output
Print the number of ways to swap two elements exactly once in order to get a nice sequence.
Examples
Input
5
2 8 4 7 7
Output
2
Input
4
200 150 100 50
Output
1
Input
10
3 2 1 4 1 4 1 4 1 4
Output
8
Input
9
1 2 3 4 5 6 7 8 9
Output
0
Note
In the first sample, there are two ways to get a nice sequence with one swap:
1. Swap t2 = 8 with t4 = 7.
2. Swap t1 = 2 with t5 = 7.
In the second sample, there is only one way — Limak should swap t1 = 200 with t4 = 50.
Submitted Solution:
```
# even, odd
def check_even(i):
if i == 0:
if t[i] <= t[i+1]:
return False
elif i == n - 1:
if t[i] <= t[i-1]:
return False
elif t[i] <= t[i-1] or t[i] <= t[i+1]:
return False
return True
def check_odd(i):
if i == 0:
if t[i] >= t[i+1]:
return False
elif i == n - 1:
if t[i] >= t[i-1]:
return False
elif t[i] >= t[i-1] or t[i] >= t[i+1]:
return False
return True
def check(x=None):
for j in not_nice:
for k in range(-1, 2):
if j + k < 0 or j + k >= n:
continue
if (j + k + 1) % 2 == 0:
if not check_even(j + k):
return False
else:
if not check_odd(j + k):
return False
if x:
if (x + 1) % 2 == 0:
if not check_even(x):
return False
else:
if not check_odd(x):
return False
return True
n = int(input())
t = list(map(int, input().split()))
not_nice = list()
for i in range(n):
if (i + 1) % 2 == 0:
if not check_even(i):
not_nice.append(i)
else:
if not check_odd(i):
not_nice.append(i)
if len(not_nice) > 10:
print(0)
else:
ret = set()
for x in not_nice:
for i in range(n):
if (x + 1) % 2 == 0 and t[x] >= t[i]:
continue
if (x + 1) % 2 == 1 and t[x] <= t[i]:
continue
t[i], t[x] = t[x], t[i]
if check(x):
if i < x:
ret.add((i, x))
else:
ret.add((x, i))
t[i], t[x] = t[x], t[i]
print(len(ret))
``` | instruction | 0 | 15,522 | 12 | 31,044 |
No | output | 1 | 15,522 | 12 | 31,045 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The life goes up and down, just like nice sequences. Sequence t1, t2, ..., tn is called nice if the following two conditions are satisfied:
* ti < ti + 1 for each odd i < n;
* ti > ti + 1 for each even i < n.
For example, sequences (2, 8), (1, 5, 1) and (2, 5, 1, 100, 99, 120) are nice, while (1, 1), (1, 2, 3) and (2, 5, 3, 2) are not.
Bear Limak has a sequence of positive integers t1, t2, ..., tn. This sequence is not nice now and Limak wants to fix it by a single swap. He is going to choose two indices i < j and swap elements ti and tj in order to get a nice sequence. Count the number of ways to do so. Two ways are considered different if indices of elements chosen for a swap are different.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 150 000) — the length of the sequence.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 150 000) — the initial sequence. It's guaranteed that the given sequence is not nice.
Output
Print the number of ways to swap two elements exactly once in order to get a nice sequence.
Examples
Input
5
2 8 4 7 7
Output
2
Input
4
200 150 100 50
Output
1
Input
10
3 2 1 4 1 4 1 4 1 4
Output
8
Input
9
1 2 3 4 5 6 7 8 9
Output
0
Note
In the first sample, there are two ways to get a nice sequence with one swap:
1. Swap t2 = 8 with t4 = 7.
2. Swap t1 = 2 with t5 = 7.
In the second sample, there is only one way — Limak should swap t1 = 200 with t4 = 50.
Submitted Solution:
```
n = int(input())
t = list(map(int, input().split()))
def checkeven(i):
if i > 0:
if t[i] <= t[i-1]: return False
if i < n-1:
if t[i] <= t[i+1]: return False
return True
def checkodd(i):
if i > 0:
if t[i] >= t[i-1]: return False
if i < n-1:
if t[i] >= t[i+1]: return False
return True
def checkswap(i, x, p):
if (i < 0 or i >= n or x < 0 or x >= n): return False
t[i], t[x] = t[x], t[i]
check = True
if (i % 2 == 0): check = checkodd(i)
else: check = checkeven(i)
if not check:
t[i], t[x] = t[x], t[i]
return check
if (x % 2 == 0): check = checkodd(x)
else: check = checkeven(x)
if not check:
t[i], t[x] = t[x], t[i]
return check
if (p % 2 == 0): check = checkodd(p)
else: check = checkeven(p)
if not check:
t[i], t[x] = t[x], t[i]
return check
if check:
t[i], t[x] = t[x], t[i]
return check
def checkswapanother(i, x, p, q):
if (i < 0 or i >= n or x < 0 or x >= n): return False
t[i], t[x] = t[x], t[i]
check = True
if (i % 2 == 0): check = checkodd(i)
else: check = checkeven(i)
if not check:
t[i], t[x] = t[x], t[i]
return check
if (x % 2 == 0): check = checkodd(x)
else: check = checkeven(x)
if not check:
t[i], t[x] = t[x], t[i]
return check
if (p % 2 == 0): check = checkodd(p)
else: check = checkeven(p)
if not check:
t[i], t[x] = t[x], t[i]
return check
if (q % 2 == 0): check = checkodd(q)
else: check = checkeven(q)
if not check:
t[i], t[x] = t[x], t[i]
return check
if check:
t[i], t[x] = t[x], t[i]
return check
if (n == 2):
print("1")
else:
index = [-1, -1]
j = 0
count = 0
# count no of wrongly placed integers
for i in range(1, n, 2):
if (t[i] <= t[i-1]):
if count == 2:
count += 1
break
index[j] = i
j = j + 1
count = count + 1
elif (i < n-1 and t[i] <= t[i+1]):
if count == 2:
count += 1
break
index[j] = i
j = j + 1
count = count + 1
if count >= 3:
print("0")
if count == 1:
ans = 0
for i in range(n):
for j in range(-1, 2):
x = index[0] + j
if (x == i): continue
if (i == index[0]) or (i == index[0]-1) or (i == index[0]+1):continue
#print(i, x)
ch = checkswap(i,x, index[0])
if ch: ans += 1
if checkswap(index[0]-1, index[0], index[0]): ans+=1
if checkswap(index[0]-1, index[0]+1, index[0]): ans+=1
if checkswap(index[0], index[0]+1, index[0]): ans+=1
print(ans)
if count == 2:
ans = 0
for i in range(-1, 2):
for j in range(-1, 2):
x = index[0] + i
y = index[1] + j
if (x == y): continue
ch = checkswapanother(x,y,index[0], index[1])
if ch: ans += 1
print(ans)
``` | instruction | 0 | 15,523 | 12 | 31,046 |
No | output | 1 | 15,523 | 12 | 31,047 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The life goes up and down, just like nice sequences. Sequence t1, t2, ..., tn is called nice if the following two conditions are satisfied:
* ti < ti + 1 for each odd i < n;
* ti > ti + 1 for each even i < n.
For example, sequences (2, 8), (1, 5, 1) and (2, 5, 1, 100, 99, 120) are nice, while (1, 1), (1, 2, 3) and (2, 5, 3, 2) are not.
Bear Limak has a sequence of positive integers t1, t2, ..., tn. This sequence is not nice now and Limak wants to fix it by a single swap. He is going to choose two indices i < j and swap elements ti and tj in order to get a nice sequence. Count the number of ways to do so. Two ways are considered different if indices of elements chosen for a swap are different.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 150 000) — the length of the sequence.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 150 000) — the initial sequence. It's guaranteed that the given sequence is not nice.
Output
Print the number of ways to swap two elements exactly once in order to get a nice sequence.
Examples
Input
5
2 8 4 7 7
Output
2
Input
4
200 150 100 50
Output
1
Input
10
3 2 1 4 1 4 1 4 1 4
Output
8
Input
9
1 2 3 4 5 6 7 8 9
Output
0
Note
In the first sample, there are two ways to get a nice sequence with one swap:
1. Swap t2 = 8 with t4 = 7.
2. Swap t1 = 2 with t5 = 7.
In the second sample, there is only one way — Limak should swap t1 = 200 with t4 = 50.
Submitted Solution:
```
# You lost the game.
def tester(L,i,j):
e = i % 2
f = j % 2
r = 0
R = L[:]
R[i],R[j] = R[j],R[i]
if e == 0:
if R[i] > R[i+1] and R[i] > R[i-1]:
r += 1
else:
if R[i] < R[i+1] and R[i] < R[i-1]:
r += 1
if f == 0:
if R[j] > R[j+1] and R[j] > R[j-1]:
r += 1
else:
if R[j] < R[j+1] and R[j] < R[j-1]:
r += 1
return (r == 2)
n = int(input())
L = list(map(int, input().split()))
a = 0
F = []
for i in range(1,n):
if i % 2 and L[i] <= L[i-1]:
a += 1
F = F + [i]
if i % 2 == 0 and L[i] >= L[i-1]:
a += 1
F = F + [i]
L = [10**6]+L+[(-1)**(1-n%2)*10**6]
if a > 3:
print(0)
elif a == 2:
z = F[0]
b = F[0]+1
c = F[1]
d = F[1]+1
r = 0
P = [[z,c],[z,d],[b,c],[b,d]]
for i in range(4):
r = r + tester(L,P[i][0],P[i][1])
print(r)
elif a == 3:
z = F[0]
b = F[0]+1
c = F[1]
d = F[1]+1
e = F[2]
f = F[2]+1
if b < c and d < e:
print(0)
elif c == b and d < e:
r = 0 + tester(L,c,f)
elif d == e and b < c:
r = 0 + tester(L,z,d)
elif d == e and b == c:
r = tester(L,z,d) + tester(L,b,d) + tester(L,c,f)
print(r)
else:
z = F[0]
b = F[0]+1
r = 0
for i in range(1,n+1):
if i != z:
r = r + tester(L,min(i,z),max(i,z))
for i in range(1,n+1):
if i != z and i != b:
r = r + tester(L,min(i,b),max(i,b))
print(r)
``` | instruction | 0 | 15,524 | 12 | 31,048 |
No | output | 1 | 15,524 | 12 | 31,049 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For an array b of length m we define the function f as
f(b) = \begin{cases} b[1] & if m = 1 \\\ f(b[1] ⊕ b[2],b[2] ⊕ b[3],...,b[m-1] ⊕ b[m]) & otherwise, \end{cases}
where ⊕ is [bitwise exclusive OR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
For example, f(1,2,4,8)=f(1⊕2,2⊕4,4⊕8)=f(3,6,12)=f(3⊕6,6⊕12)=f(5,10)=f(5⊕10)=f(15)=15
You are given an array a and a few queries. Each query is represented as two integers l and r. The answer is the maximum value of f on all continuous subsegments of the array a_l, a_{l+1}, …, a_r.
Input
The first line contains a single integer n (1 ≤ n ≤ 5000) — the length of a.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 2^{30}-1) — the elements of the array.
The third line contains a single integer q (1 ≤ q ≤ 100 000) — the number of queries.
Each of the next q lines contains a query represented as two integers l, r (1 ≤ l ≤ r ≤ n).
Output
Print q lines — the answers for the queries.
Examples
Input
3
8 4 1
2
2 3
1 2
Output
5
12
Input
6
1 2 4 8 16 32
4
1 6
2 5
3 4
1 2
Output
60
30
12
3
Note
In first sample in both queries the maximum value of the function is reached on the subsegment that is equal to the whole segment.
In second sample, optimal segment for first query are [3,6], for second query — [2,5], for third — [3,4], for fourth — [1,2]. | instruction | 0 | 15,682 | 12 | 31,364 |
Tags: dp
Correct Solution:
```
import bisect
import os, sys, atexit,threading
from io import BytesIO, StringIO
input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
_OUTPUT_BUFFER = StringIO()
sys.stdout = _OUTPUT_BUFFER
@atexit.register
def write():
sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
def calculate(array):
n = len(array)
finalarray = []
finalarray.append(array)
finalarray.append([])
while (n!=1):
for x in range(n-1):
finalarray[-1].append(finalarray[-2][x]^finalarray[-2][x+1])
finalarray.append([])
n-=1
return finalarray
def solve():
n = int(input())
array = [0]
array.extend(list(map(int,input().split())))
ranges = []
q = int(input())
for _ in range(q):
l, r = map(int,input().split())
ranges.append([l,r])
subArrays = []
for x in range(n+1):
subArrays.append([0]*(n+1))
finalarray = calculate(array)
# print (finalarray,len(finalarray))
for x in range(1,n+1):
for y in range(x,n+1):
# print (y-x+1,x,finalarray[y-x+1])
value = finalarray[y-x][x]
subArrays[1][y] = max(subArrays[1][y],value)
subArrays[x][y] = max(subArrays[x][y],value)
# print (subArrays)
for x in range(1,n+1):
for y in range(2,n+1):
subArrays[x][y] = max(subArrays[x][y],subArrays[x][y-1])
# print (subArrays)
for y in range(1,n+1):
for x in range(n-1,0,-1):
subArrays[x][y] = max(subArrays[x][y],subArrays[x+1][y])
# print (subArrays)
for l,r in ranges:
print (subArrays[l][r])
try:
solve()
except Exception as e:
print (e)
# solve()
``` | output | 1 | 15,682 | 12 | 31,365 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For an array b of length m we define the function f as
f(b) = \begin{cases} b[1] & if m = 1 \\\ f(b[1] ⊕ b[2],b[2] ⊕ b[3],...,b[m-1] ⊕ b[m]) & otherwise, \end{cases}
where ⊕ is [bitwise exclusive OR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
For example, f(1,2,4,8)=f(1⊕2,2⊕4,4⊕8)=f(3,6,12)=f(3⊕6,6⊕12)=f(5,10)=f(5⊕10)=f(15)=15
You are given an array a and a few queries. Each query is represented as two integers l and r. The answer is the maximum value of f on all continuous subsegments of the array a_l, a_{l+1}, …, a_r.
Input
The first line contains a single integer n (1 ≤ n ≤ 5000) — the length of a.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 2^{30}-1) — the elements of the array.
The third line contains a single integer q (1 ≤ q ≤ 100 000) — the number of queries.
Each of the next q lines contains a query represented as two integers l, r (1 ≤ l ≤ r ≤ n).
Output
Print q lines — the answers for the queries.
Examples
Input
3
8 4 1
2
2 3
1 2
Output
5
12
Input
6
1 2 4 8 16 32
4
1 6
2 5
3 4
1 2
Output
60
30
12
3
Note
In first sample in both queries the maximum value of the function is reached on the subsegment that is equal to the whole segment.
In second sample, optimal segment for first query are [3,6], for second query — [2,5], for third — [3,4], for fourth — [1,2]. | instruction | 0 | 15,683 | 12 | 31,366 |
Tags: dp
Correct Solution:
```
from sys import stdin, stdout
n = int(stdin.readline())
a = list(map(int, stdin.readline().split(' ')))
list_a = [a]
for _ in range(n - 1):
temp = []
for j in range(1, len(list_a[-1])):
temp.append(list_a[-1][j-1] ^ list_a[-1][j])
list_a.append(temp)
for j in range(1, len(list_a)):
for k in range(len(list_a[j])):
list_a[j][k] = max(list_a[j][k], list_a[j-1][k], list_a[j - 1][k + 1])
q = int(stdin.readline())
for _ in range(q):
l, r = map(int, stdin.readline().split(' '))
stdout.write(str(list_a[r - l][l - 1]) + "\n")
``` | output | 1 | 15,683 | 12 | 31,367 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For an array b of length m we define the function f as
f(b) = \begin{cases} b[1] & if m = 1 \\\ f(b[1] ⊕ b[2],b[2] ⊕ b[3],...,b[m-1] ⊕ b[m]) & otherwise, \end{cases}
where ⊕ is [bitwise exclusive OR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
For example, f(1,2,4,8)=f(1⊕2,2⊕4,4⊕8)=f(3,6,12)=f(3⊕6,6⊕12)=f(5,10)=f(5⊕10)=f(15)=15
You are given an array a and a few queries. Each query is represented as two integers l and r. The answer is the maximum value of f on all continuous subsegments of the array a_l, a_{l+1}, …, a_r.
Input
The first line contains a single integer n (1 ≤ n ≤ 5000) — the length of a.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 2^{30}-1) — the elements of the array.
The third line contains a single integer q (1 ≤ q ≤ 100 000) — the number of queries.
Each of the next q lines contains a query represented as two integers l, r (1 ≤ l ≤ r ≤ n).
Output
Print q lines — the answers for the queries.
Examples
Input
3
8 4 1
2
2 3
1 2
Output
5
12
Input
6
1 2 4 8 16 32
4
1 6
2 5
3 4
1 2
Output
60
30
12
3
Note
In first sample in both queries the maximum value of the function is reached on the subsegment that is equal to the whole segment.
In second sample, optimal segment for first query are [3,6], for second query — [2,5], for third — [3,4], for fourth — [1,2]. | instruction | 0 | 15,684 | 12 | 31,368 |
Tags: dp
Correct Solution:
```
import bisect
import os, sys, atexit,threading
from io import BytesIO, StringIO
from sys import stdin, stdout
# input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
# _OUTPUT_BUFFER = StringIO()
# sys.stdout = _OUTPUT_BUFFER
# @atexit.register
# def write():
# sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
def calculate(array):
n = len(array)
finalarray = []
finalarray.append(array)
finalarray.append([])
while (n!=1):
for x in range(n-1):
finalarray[-1].append(finalarray[-2][x]^finalarray[-2][x+1])
finalarray.append([])
n-=1
return finalarray
def solve():
n = int(input())
array = [0]
array.extend(list(map(int,stdin.readline().strip().split())))
subArrays = []
for x in range(n+1):
subArrays.append([0]*(n+1))
finalarray = calculate(array)
# print (finalarray,len(finalarray))
for x in range(1,n+1):
for y in range(x,n+1):
# print (y-x+1,x,finalarray[y-x+1])
value = finalarray[y-x][x]
subArrays[1][y] = max(subArrays[1][y],value)
subArrays[x][y] = max(subArrays[x][y],value)
# print (subArrays)
for x in range(1,n+1):
for y in range(2,n+1):
subArrays[x][y] = max(subArrays[x][y],subArrays[x][y-1])
# print (subArrays)
for y in range(1,n+1):
for x in range(n-1,0,-1):
subArrays[x][y] = max(subArrays[x][y],subArrays[x+1][y])
# print (subArrays)
q = int(input())
for _ in range(q):
l, r = map(int,stdin.readline().strip().split())
print (subArrays[l][r])
try:
solve()
except Exception as e:
print (e)
# solve()
``` | output | 1 | 15,684 | 12 | 31,369 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For an array b of length m we define the function f as
f(b) = \begin{cases} b[1] & if m = 1 \\\ f(b[1] ⊕ b[2],b[2] ⊕ b[3],...,b[m-1] ⊕ b[m]) & otherwise, \end{cases}
where ⊕ is [bitwise exclusive OR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
For example, f(1,2,4,8)=f(1⊕2,2⊕4,4⊕8)=f(3,6,12)=f(3⊕6,6⊕12)=f(5,10)=f(5⊕10)=f(15)=15
You are given an array a and a few queries. Each query is represented as two integers l and r. The answer is the maximum value of f on all continuous subsegments of the array a_l, a_{l+1}, …, a_r.
Input
The first line contains a single integer n (1 ≤ n ≤ 5000) — the length of a.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 2^{30}-1) — the elements of the array.
The third line contains a single integer q (1 ≤ q ≤ 100 000) — the number of queries.
Each of the next q lines contains a query represented as two integers l, r (1 ≤ l ≤ r ≤ n).
Output
Print q lines — the answers for the queries.
Examples
Input
3
8 4 1
2
2 3
1 2
Output
5
12
Input
6
1 2 4 8 16 32
4
1 6
2 5
3 4
1 2
Output
60
30
12
3
Note
In first sample in both queries the maximum value of the function is reached on the subsegment that is equal to the whole segment.
In second sample, optimal segment for first query are [3,6], for second query — [2,5], for third — [3,4], for fourth — [1,2]. | instruction | 0 | 15,685 | 12 | 31,370 |
Tags: dp
Correct Solution:
```
tamanho = int(input())
elementos = list(map(int, input().split()))
matriz = [[0] * tamanho for i in range(tamanho)]
for i in range(tamanho):
matriz[0][i] = elementos[i]
for i in range(1, tamanho):
for j in range(tamanho-i):
matriz[i][j] = matriz[i-1][j] ^ matriz[i-1][j+1]
for i in range(1, tamanho):
for j in range(tamanho-i):
matriz[i][j] = max(matriz[i][j], matriz[i-1][j], matriz[i-1][j+1])
num_buscas = int(input())
for i in range(num_buscas):
busca_l, busca_r = map(int, input().split())
busca_l, busca_r = busca_l-1, busca_r-1
print(matriz[busca_r-busca_l][busca_l])
``` | output | 1 | 15,685 | 12 | 31,371 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For an array b of length m we define the function f as
f(b) = \begin{cases} b[1] & if m = 1 \\\ f(b[1] ⊕ b[2],b[2] ⊕ b[3],...,b[m-1] ⊕ b[m]) & otherwise, \end{cases}
where ⊕ is [bitwise exclusive OR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
For example, f(1,2,4,8)=f(1⊕2,2⊕4,4⊕8)=f(3,6,12)=f(3⊕6,6⊕12)=f(5,10)=f(5⊕10)=f(15)=15
You are given an array a and a few queries. Each query is represented as two integers l and r. The answer is the maximum value of f on all continuous subsegments of the array a_l, a_{l+1}, …, a_r.
Input
The first line contains a single integer n (1 ≤ n ≤ 5000) — the length of a.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 2^{30}-1) — the elements of the array.
The third line contains a single integer q (1 ≤ q ≤ 100 000) — the number of queries.
Each of the next q lines contains a query represented as two integers l, r (1 ≤ l ≤ r ≤ n).
Output
Print q lines — the answers for the queries.
Examples
Input
3
8 4 1
2
2 3
1 2
Output
5
12
Input
6
1 2 4 8 16 32
4
1 6
2 5
3 4
1 2
Output
60
30
12
3
Note
In first sample in both queries the maximum value of the function is reached on the subsegment that is equal to the whole segment.
In second sample, optimal segment for first query are [3,6], for second query — [2,5], for third — [3,4], for fourth — [1,2]. | instruction | 0 | 15,686 | 12 | 31,372 |
Tags: dp
Correct Solution:
```
n=int(input())
dp=[[-1 for i in range(n+1)]for j in range(n+1)]
dp[0] = list(map(int,input().split()))
for i in range(1,n):
for j in range(n-i):
dp[i][j] = dp[i-1][j]^dp[i-1][j+1]
for i in range(1,n):
for j in range(n-i):
dp[i][j] = max(dp[i-1][j],dp[i-1][j+1], dp[i][j])
q=int(input())
for i in range(q):
l, r = map(int, input().split())
print(dp[r-l][l-1])
``` | output | 1 | 15,686 | 12 | 31,373 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For an array b of length m we define the function f as
f(b) = \begin{cases} b[1] & if m = 1 \\\ f(b[1] ⊕ b[2],b[2] ⊕ b[3],...,b[m-1] ⊕ b[m]) & otherwise, \end{cases}
where ⊕ is [bitwise exclusive OR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
For example, f(1,2,4,8)=f(1⊕2,2⊕4,4⊕8)=f(3,6,12)=f(3⊕6,6⊕12)=f(5,10)=f(5⊕10)=f(15)=15
You are given an array a and a few queries. Each query is represented as two integers l and r. The answer is the maximum value of f on all continuous subsegments of the array a_l, a_{l+1}, …, a_r.
Input
The first line contains a single integer n (1 ≤ n ≤ 5000) — the length of a.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 2^{30}-1) — the elements of the array.
The third line contains a single integer q (1 ≤ q ≤ 100 000) — the number of queries.
Each of the next q lines contains a query represented as two integers l, r (1 ≤ l ≤ r ≤ n).
Output
Print q lines — the answers for the queries.
Examples
Input
3
8 4 1
2
2 3
1 2
Output
5
12
Input
6
1 2 4 8 16 32
4
1 6
2 5
3 4
1 2
Output
60
30
12
3
Note
In first sample in both queries the maximum value of the function is reached on the subsegment that is equal to the whole segment.
In second sample, optimal segment for first query are [3,6], for second query — [2,5], for third — [3,4], for fourth — [1,2]. | instruction | 0 | 15,687 | 12 | 31,374 |
Tags: dp
Correct Solution:
```
# coding: utf-8
n = int(input())
arr = list(map(int, input().split()))
matrix = [[0] * n for _ in range(n)]
for i in range(n):
matrix[0][i] = arr[i]
for i in range(1, n):
for j in range(n - i):
matrix[i][j] = matrix[i-1][j] ^ matrix[i-1][j+1]
for i in range(1, n):
for j in range(n - i):
matrix[i][j] = max(matrix[i][j], matrix[i-1][j], matrix[i-1][j+1])
queries = int(input())
responses = []
while queries > 0:
l, r = list(map(int, input().split()))
l -= 1
r -= 1
responses.append(matrix[r - l][l])
queries -= 1
for response in responses:
print(response)
``` | output | 1 | 15,687 | 12 | 31,375 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For an array b of length m we define the function f as
f(b) = \begin{cases} b[1] & if m = 1 \\\ f(b[1] ⊕ b[2],b[2] ⊕ b[3],...,b[m-1] ⊕ b[m]) & otherwise, \end{cases}
where ⊕ is [bitwise exclusive OR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
For example, f(1,2,4,8)=f(1⊕2,2⊕4,4⊕8)=f(3,6,12)=f(3⊕6,6⊕12)=f(5,10)=f(5⊕10)=f(15)=15
You are given an array a and a few queries. Each query is represented as two integers l and r. The answer is the maximum value of f on all continuous subsegments of the array a_l, a_{l+1}, …, a_r.
Input
The first line contains a single integer n (1 ≤ n ≤ 5000) — the length of a.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 2^{30}-1) — the elements of the array.
The third line contains a single integer q (1 ≤ q ≤ 100 000) — the number of queries.
Each of the next q lines contains a query represented as two integers l, r (1 ≤ l ≤ r ≤ n).
Output
Print q lines — the answers for the queries.
Examples
Input
3
8 4 1
2
2 3
1 2
Output
5
12
Input
6
1 2 4 8 16 32
4
1 6
2 5
3 4
1 2
Output
60
30
12
3
Note
In first sample in both queries the maximum value of the function is reached on the subsegment that is equal to the whole segment.
In second sample, optimal segment for first query are [3,6], for second query — [2,5], for third — [3,4], for fourth — [1,2]. | instruction | 0 | 15,688 | 12 | 31,376 |
Tags: dp
Correct Solution:
```
tamanho = int(input())
elementos = list(map(int, input().split()))
dp = [[0] * tamanho for i in range(tamanho)]
for i in range(tamanho):
dp[0][i] = elementos[i]
for i in range(1, tamanho):
for j in range(tamanho-i):
dp[i][j] = dp[i-1][j] ^ dp[i-1][j+1]
for i in range(1, tamanho):
for j in range(tamanho-i):
dp[i][j] = max(dp[i][j], dp[i-1][j], dp[i-1][j+1])
num_buscas = int(input())
for i in range(num_buscas):
busca_l, busca_r = map(int, input().split())
busca_l, busca_r = busca_l-1, busca_r-1
print(dp[busca_r-busca_l][busca_l])
``` | output | 1 | 15,688 | 12 | 31,377 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For an array b of length m we define the function f as
f(b) = \begin{cases} b[1] & if m = 1 \\\ f(b[1] ⊕ b[2],b[2] ⊕ b[3],...,b[m-1] ⊕ b[m]) & otherwise, \end{cases}
where ⊕ is [bitwise exclusive OR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
For example, f(1,2,4,8)=f(1⊕2,2⊕4,4⊕8)=f(3,6,12)=f(3⊕6,6⊕12)=f(5,10)=f(5⊕10)=f(15)=15
You are given an array a and a few queries. Each query is represented as two integers l and r. The answer is the maximum value of f on all continuous subsegments of the array a_l, a_{l+1}, …, a_r.
Input
The first line contains a single integer n (1 ≤ n ≤ 5000) — the length of a.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 2^{30}-1) — the elements of the array.
The third line contains a single integer q (1 ≤ q ≤ 100 000) — the number of queries.
Each of the next q lines contains a query represented as two integers l, r (1 ≤ l ≤ r ≤ n).
Output
Print q lines — the answers for the queries.
Examples
Input
3
8 4 1
2
2 3
1 2
Output
5
12
Input
6
1 2 4 8 16 32
4
1 6
2 5
3 4
1 2
Output
60
30
12
3
Note
In first sample in both queries the maximum value of the function is reached on the subsegment that is equal to the whole segment.
In second sample, optimal segment for first query are [3,6], for second query — [2,5], for third — [3,4], for fourth — [1,2]. | instruction | 0 | 15,689 | 12 | 31,378 |
Tags: dp
Correct Solution:
```
import sys
input=sys.stdin.readline
n=int(input())
a=list(map(int,input().split()))
f=[[0]*n for i in range(n)]
for i in range(n):
f[0][i]=a[i]
for i in range(1,n):
for j in range(n-i):
f[i][j]=f[i-1][j]^f[i-1][j+1]
for i in range(1,n):
for j in range(n-i):
f[i][j]=max(f[i][j],f[i-1][j],f[i-1][j+1])
q=int(input())
for _ in range(q):
l,r=map(int,input().split())
print(f[r-l][l-1])
``` | output | 1 | 15,689 | 12 | 31,379 |
Provide tags and a correct Python 2 solution for this coding contest problem.
For an array b of length m we define the function f as
f(b) = \begin{cases} b[1] & if m = 1 \\\ f(b[1] ⊕ b[2],b[2] ⊕ b[3],...,b[m-1] ⊕ b[m]) & otherwise, \end{cases}
where ⊕ is [bitwise exclusive OR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
For example, f(1,2,4,8)=f(1⊕2,2⊕4,4⊕8)=f(3,6,12)=f(3⊕6,6⊕12)=f(5,10)=f(5⊕10)=f(15)=15
You are given an array a and a few queries. Each query is represented as two integers l and r. The answer is the maximum value of f on all continuous subsegments of the array a_l, a_{l+1}, …, a_r.
Input
The first line contains a single integer n (1 ≤ n ≤ 5000) — the length of a.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 2^{30}-1) — the elements of the array.
The third line contains a single integer q (1 ≤ q ≤ 100 000) — the number of queries.
Each of the next q lines contains a query represented as two integers l, r (1 ≤ l ≤ r ≤ n).
Output
Print q lines — the answers for the queries.
Examples
Input
3
8 4 1
2
2 3
1 2
Output
5
12
Input
6
1 2 4 8 16 32
4
1 6
2 5
3 4
1 2
Output
60
30
12
3
Note
In first sample in both queries the maximum value of the function is reached on the subsegment that is equal to the whole segment.
In second sample, optimal segment for first query are [3,6], for second query — [2,5], for third — [3,4], for fourth — [1,2]. | instruction | 0 | 15,690 | 12 | 31,380 |
Tags: dp
Correct Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
def in_num():
return int(raw_input())
def in_arr():
return map(int,raw_input().split())
def pr_num(n):
stdout.write(str(n)+'\n')
def pr_arr(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
n=in_num()
l=in_arr()
dp=[[0 for i in range(n)] for j in range(n)]
for i in range(n):
dp[i][i]=l[i]
for i in range(1,n):
p1,p2=0,i
for j in range(n-i):
#print p1,p2,p1,p2-1,p1+1,p2
dp[p1][p2]=dp[p1][p2-1]^dp[p1+1][p2]
p1+=1
p2+=1
for i in range(1,n):
p1,p2=0,i
for j in range(n-i):
#print p1,p2,p1,p2-1,p1+1,p2
dp[p1][p2]=max(dp[p1][p2],dp[p1][p2-1],dp[p1+1][p2])
p1+=1
p2+=1
for q in range(in_num()):
l,r=in_arr()
l-=1
r-=1
pr_num(dp[l][r])
``` | output | 1 | 15,690 | 12 | 31,381 |
Provide a correct Python 3 solution for this coding contest problem.
You are given integers N,\ A and B. Determine if there exists a permutation (P_0,\ P_1,\ ...\ P_{2^N-1}) of (0,\ 1,\ ...\ 2^N-1) that satisfies all of the following conditions, and create one such permutation if it exists.
* P_0=A
* P_{2^N-1}=B
* For all 0 \leq i < 2^N-1, the binary representations of P_i and P_{i+1} differ by exactly one bit.
Constraints
* 1 \leq N \leq 17
* 0 \leq A \leq 2^N-1
* 0 \leq B \leq 2^N-1
* A \neq B
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there is no permutation that satisfies the conditions, print `NO`.
If there is such a permutation, print `YES` in the first line. Then, print (P_0,\ P_1,\ ...\ P_{2^N-1}) in the second line, with spaces in between. If there are multiple solutions, any of them is accepted.
Examples
Input
2 1 3
Output
YES
1 0 2 3
Input
3 2 1
Output
NO | instruction | 0 | 15,763 | 12 | 31,526 |
"Correct Solution:
```
def split(n, a, b, remain, ai, ans, width, l=None):
# print(n, a, b, remain, ai, ans, width)
# print(*(f'{c:5d}' for c in ans))
# print(*(f'{c:05b}' for c in ans))
if width == 2:
ans[ai] = a
ans[ai + 1] = b
return
if l is None:
x = a ^ b
y = x & -x # Rightmost Bit at which is different for a and b
l = y.bit_length() - 1
else:
y = 1 << l
remain.remove(l)
i = next(iter(remain))
lb = a ^ (1 << i)
ra = lb ^ y
width >>= 1
split(n, a, a ^ (1 << i), remain, ai, ans, width, i)
split(n, ra, b, remain, ai + width, ans, width)
remain.add(l)
def solve(n, a, b):
if bin(a).count('1') % 2 == bin(b).count('1') % 2:
print('NO')
return
remain = set(range(n))
ans = [0] * (1 << n)
split(n, a, b, remain, 0, ans, 1 << n)
print('YES')
print(*ans)
n, a, b = list(map(int, input().split()))
solve(n, a, b)
``` | output | 1 | 15,763 | 12 | 31,527 |
Provide a correct Python 3 solution for this coding contest problem.
You are given integers N,\ A and B. Determine if there exists a permutation (P_0,\ P_1,\ ...\ P_{2^N-1}) of (0,\ 1,\ ...\ 2^N-1) that satisfies all of the following conditions, and create one such permutation if it exists.
* P_0=A
* P_{2^N-1}=B
* For all 0 \leq i < 2^N-1, the binary representations of P_i and P_{i+1} differ by exactly one bit.
Constraints
* 1 \leq N \leq 17
* 0 \leq A \leq 2^N-1
* 0 \leq B \leq 2^N-1
* A \neq B
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there is no permutation that satisfies the conditions, print `NO`.
If there is such a permutation, print `YES` in the first line. Then, print (P_0,\ P_1,\ ...\ P_{2^N-1}) in the second line, with spaces in between. If there are multiple solutions, any of them is accepted.
Examples
Input
2 1 3
Output
YES
1 0 2 3
Input
3 2 1
Output
NO | instruction | 0 | 15,764 | 12 | 31,528 |
"Correct Solution:
```
import sys
input = sys.stdin.readline
N,A,B = map(int,input().split())
def seq(start,bits):
arr = [0]
for i in bits:
arr += [x^(1<<i) for x in arr[::-1]]
return [x^start for x in arr]
def solve(A,B,rest):
if len(rest) == 1:
return [A,B]
if len(rest) == 2:
i,j = rest
x,y = 1<<i,1<<j
if A^x == B:
return [A,A^y,A^x^y,B]
elif A^y == B:
return [A,A^x,A^x^y,B]
else:
return None
diff_bit = [i for i in rest if (A&(1<<i)) != (B&(1<<i))]
if len(diff_bit) % 2 == 0:
return None
i = diff_bit[0]
rest = [j for j in rest if j != i]
if A^(1<<rest[0])^(1<<i) == B:
rest[0],rest[1] = rest[1],rest[0]
arr = seq(A,rest)
return arr + solve(arr[-1]^(1<<i),B,rest)
rest = list(range(N))
answer = solve(A,B,rest)
if answer is None:
print('NO')
else:
print('YES')
print(' '.join(map(str,answer)))
``` | output | 1 | 15,764 | 12 | 31,529 |
Provide a correct Python 3 solution for this coding contest problem.
You are given integers N,\ A and B. Determine if there exists a permutation (P_0,\ P_1,\ ...\ P_{2^N-1}) of (0,\ 1,\ ...\ 2^N-1) that satisfies all of the following conditions, and create one such permutation if it exists.
* P_0=A
* P_{2^N-1}=B
* For all 0 \leq i < 2^N-1, the binary representations of P_i and P_{i+1} differ by exactly one bit.
Constraints
* 1 \leq N \leq 17
* 0 \leq A \leq 2^N-1
* 0 \leq B \leq 2^N-1
* A \neq B
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there is no permutation that satisfies the conditions, print `NO`.
If there is such a permutation, print `YES` in the first line. Then, print (P_0,\ P_1,\ ...\ P_{2^N-1}) in the second line, with spaces in between. If there are multiple solutions, any of them is accepted.
Examples
Input
2 1 3
Output
YES
1 0 2 3
Input
3 2 1
Output
NO | instruction | 0 | 15,765 | 12 | 31,530 |
"Correct Solution:
```
def main():
n, a, b = map(int, input().split())
if (bin(a).count("1")+bin(b).count("1")) % 2 == 0:
print("NO")
return
print("YES")
def calc(a, b, k):
if k == 1:
return [a, b]
for i in range(k):
if ((a >> i) & 1) ^ ((b >> i) & 1):
break
a2 = (a & (2**i-1))+((a >> (i+1)) << i)
b2 = (b & (2**i-1))+((b >> (i+1)) << i)
a3 = ((a >> i) & 1)
b3 = ((b >> i) & 1)
c = a2 ^ 1
q = calc(a2, c, k-1)
r = calc(c, b2, k-1)
q = [((t >> i) << i+1)+(a3 << i)+(t & (2**i-1)) for t in q]
r = [((t >> i) << i+1)+(b3 << i)+(t & (2**i-1)) for t in r]
return q+r
print(*calc(a, b, n))
main()
``` | output | 1 | 15,765 | 12 | 31,531 |
Provide a correct Python 3 solution for this coding contest problem.
You are given integers N,\ A and B. Determine if there exists a permutation (P_0,\ P_1,\ ...\ P_{2^N-1}) of (0,\ 1,\ ...\ 2^N-1) that satisfies all of the following conditions, and create one such permutation if it exists.
* P_0=A
* P_{2^N-1}=B
* For all 0 \leq i < 2^N-1, the binary representations of P_i and P_{i+1} differ by exactly one bit.
Constraints
* 1 \leq N \leq 17
* 0 \leq A \leq 2^N-1
* 0 \leq B \leq 2^N-1
* A \neq B
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there is no permutation that satisfies the conditions, print `NO`.
If there is such a permutation, print `YES` in the first line. Then, print (P_0,\ P_1,\ ...\ P_{2^N-1}) in the second line, with spaces in between. If there are multiple solutions, any of them is accepted.
Examples
Input
2 1 3
Output
YES
1 0 2 3
Input
3 2 1
Output
NO | instruction | 0 | 15,766 | 12 | 31,532 |
"Correct Solution:
```
import sys
sys.setrecursionlimit(10 ** 6)
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 bit(xx):return [format(x,"b") for x in xx]
popcnt=lambda x:bin(x).count("1")
def solve(xx,a,b):
if len(xx)==2:return [a,b]
k=(a^b).bit_length()-1
aa=[]
bb=[]
for x in xx:
if (x>>k&1)==(a>>k&1):aa.append(x)
else:bb.append(x)
i=0
mid=aa[i]
while mid==a or (mid^1<<k)==b or popcnt(a)&1==popcnt(mid)&1:
i+=1
mid=aa[i]
#print(bit(xx),a,b,k,bit(aa),bit(bb),format(mid,"b"))
return solve(aa,a,mid)+solve(bb,mid^1<<k,b)
def main():
n,a,b=MI()
if (popcnt(a)&1)^(popcnt(b)&1)==0:
print("NO")
exit()
print("YES")
print(*solve(list(range(1<<n)),a,b))
main()
``` | output | 1 | 15,766 | 12 | 31,533 |
Provide a correct Python 3 solution for this coding contest problem.
You are given integers N,\ A and B. Determine if there exists a permutation (P_0,\ P_1,\ ...\ P_{2^N-1}) of (0,\ 1,\ ...\ 2^N-1) that satisfies all of the following conditions, and create one such permutation if it exists.
* P_0=A
* P_{2^N-1}=B
* For all 0 \leq i < 2^N-1, the binary representations of P_i and P_{i+1} differ by exactly one bit.
Constraints
* 1 \leq N \leq 17
* 0 \leq A \leq 2^N-1
* 0 \leq B \leq 2^N-1
* A \neq B
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there is no permutation that satisfies the conditions, print `NO`.
If there is such a permutation, print `YES` in the first line. Then, print (P_0,\ P_1,\ ...\ P_{2^N-1}) in the second line, with spaces in between. If there are multiple solutions, any of them is accepted.
Examples
Input
2 1 3
Output
YES
1 0 2 3
Input
3 2 1
Output
NO | instruction | 0 | 15,767 | 12 | 31,534 |
"Correct Solution:
```
import os
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
N, A, B = list(map(int, sys.stdin.buffer.readline().split()))
# 解説
# 違うbitの数が奇数なら戻ってこれる
def bitcount(n):
ret = 0
while n > 0:
ret += n & 1
n >>= 1
return ret
# vs = []
# for i in range(1 << N):
# for j in range(i, 1 << N):
# if bitcount(i ^ j) == 1:
# vs.append((i, j))
# plot_graph(vs)
# @lru_cache(maxsize=None)
# @debug
def solve(n, a, b):
if n <= 0:
return []
if bitcount(a ^ b) % 2 == 0:
return []
if n == 1:
return [a, b]
# 奇数
# 違うbitを1つ取り除く
mask = 1
while (a ^ b) & mask == 0:
mask <<= 1
r_mask = mask - 1
l_mask = ~mask - r_mask
na = ((a & l_mask) >> 1) + (a & r_mask)
nb = ((b & l_mask) >> 1) + (b & r_mask)
mid = na ^ 1
ret = []
for r in solve(n - 1, na, mid):
ret.append(((r << 1) & l_mask) + (a & mask) + (r & r_mask))
for r in solve(n - 1, mid, nb):
ret.append(((r << 1) & l_mask) + (b & mask) + (r & r_mask))
return ret
ans = solve(N, A, B)
if ans:
print('YES')
print(*ans)
else:
print('NO')
# for A in range(1 << N):
# for B in range(1 << N):
# ans = solve(N, A, B)
# if ans:
# assert ans[0] == A
# assert ans[-1] == B
# for a, b in zip(ans, ans[1:]):
# assert bitcount(a ^ b) == 1
# assert a < (1 << N)
``` | output | 1 | 15,767 | 12 | 31,535 |
Provide a correct Python 3 solution for this coding contest problem.
You are given integers N,\ A and B. Determine if there exists a permutation (P_0,\ P_1,\ ...\ P_{2^N-1}) of (0,\ 1,\ ...\ 2^N-1) that satisfies all of the following conditions, and create one such permutation if it exists.
* P_0=A
* P_{2^N-1}=B
* For all 0 \leq i < 2^N-1, the binary representations of P_i and P_{i+1} differ by exactly one bit.
Constraints
* 1 \leq N \leq 17
* 0 \leq A \leq 2^N-1
* 0 \leq B \leq 2^N-1
* A \neq B
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there is no permutation that satisfies the conditions, print `NO`.
If there is such a permutation, print `YES` in the first line. Then, print (P_0,\ P_1,\ ...\ P_{2^N-1}) in the second line, with spaces in between. If there are multiple solutions, any of them is accepted.
Examples
Input
2 1 3
Output
YES
1 0 2 3
Input
3 2 1
Output
NO | instruction | 0 | 15,768 | 12 | 31,536 |
"Correct Solution:
```
N, A, B = map(int, input().split())
AB = A ^ B
D = bin(AB)[2:].count('1')
if D % 2 == 0:
print('NO')
else:
print('YES')
C = [0] * (2 ** N)
C[0] = str(A)
P = []
for i in range(N):
if AB % 2:
P = P + [i]
else:
P = [i] + P
AB >>= 1
for i in range(1, 2 ** N):
k = 0
b = i
while b % 2 == 0:
k += 1
b >>= 1
A ^= 1 << P[k]
C[i] = str(A)
k = 0
for i in range(D // 2):
k += 1 / (4 ** (i + 1))
K = int(2 ** N * (1 - k))
C = C[:K-1] + C[K+1:] + C[K-1:K+1][::-1]
print(' '.join(C))
``` | output | 1 | 15,768 | 12 | 31,537 |
Provide a correct Python 3 solution for this coding contest problem.
You are given integers N,\ A and B. Determine if there exists a permutation (P_0,\ P_1,\ ...\ P_{2^N-1}) of (0,\ 1,\ ...\ 2^N-1) that satisfies all of the following conditions, and create one such permutation if it exists.
* P_0=A
* P_{2^N-1}=B
* For all 0 \leq i < 2^N-1, the binary representations of P_i and P_{i+1} differ by exactly one bit.
Constraints
* 1 \leq N \leq 17
* 0 \leq A \leq 2^N-1
* 0 \leq B \leq 2^N-1
* A \neq B
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there is no permutation that satisfies the conditions, print `NO`.
If there is such a permutation, print `YES` in the first line. Then, print (P_0,\ P_1,\ ...\ P_{2^N-1}) in the second line, with spaces in between. If there are multiple solutions, any of them is accepted.
Examples
Input
2 1 3
Output
YES
1 0 2 3
Input
3 2 1
Output
NO | instruction | 0 | 15,769 | 12 | 31,538 |
"Correct Solution:
```
from sys import exit, setrecursionlimit, stderr, stdin
from functools import reduce
from itertools import *
from collections import defaultdict, Counter
from bisect import bisect
setrecursionlimit(10**7)
M = 10 ** 9 + 7
def input():
return stdin.readline().strip()
def read():
return int(input())
def reads():
return [int(x) for x in input().split()]
def bitcount(a, N):
return sum((a & (1 << i)) > 0 for i in range(N))
def topbit(a, N):
return next(i for i in range(N-1, -1, -1) if (a & (1 << i)) > 0)
def swap(x, i, j):
y = x & ~(1 << i) & ~(1 << j)
if (x & (1 << i)) > 0:
y |= 1 << j
if (x & (1 << j)) > 0:
y |= 1 << i
return y
def solve(N, A, B):
if N == 1:
ans = [A & 1, B & 1]
return ans
C = A ^ B
t = topbit(C, N)
AA = swap(A, t, N-1)
BB = swap(B, t, N-1)
D = AA ^ 1
ans = []
if B & (1 << t) > 0:
ans.extend(swap(x, t, N-1) for x in solve(N-1, AA, D))
ans.extend(swap(x, t, N-1) | (1 << t) for x in solve(N-1, D, BB))
else:
ans.extend(swap(x, t, N-1) | (1 << t)for x in solve(N-1, AA, D))
ans.extend(swap(x, t, N-1) for x in solve(N-1, D, BB))
return ans
N, A, B = reads()
if bitcount(A ^ B, N) % 2 == 0:
print("NO"); exit()
print("YES")
print(*solve(N, A, B))
``` | output | 1 | 15,769 | 12 | 31,539 |
Provide a correct Python 3 solution for this coding contest problem.
You are given integers N,\ A and B. Determine if there exists a permutation (P_0,\ P_1,\ ...\ P_{2^N-1}) of (0,\ 1,\ ...\ 2^N-1) that satisfies all of the following conditions, and create one such permutation if it exists.
* P_0=A
* P_{2^N-1}=B
* For all 0 \leq i < 2^N-1, the binary representations of P_i and P_{i+1} differ by exactly one bit.
Constraints
* 1 \leq N \leq 17
* 0 \leq A \leq 2^N-1
* 0 \leq B \leq 2^N-1
* A \neq B
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there is no permutation that satisfies the conditions, print `NO`.
If there is such a permutation, print `YES` in the first line. Then, print (P_0,\ P_1,\ ...\ P_{2^N-1}) in the second line, with spaces in between. If there are multiple solutions, any of them is accepted.
Examples
Input
2 1 3
Output
YES
1 0 2 3
Input
3 2 1
Output
NO | instruction | 0 | 15,770 | 12 | 31,540 |
"Correct Solution:
```
def makep(n, l, mask):
a = l[0] & mask
b = l[-1] & mask
ll = len(l)
diff = a ^ b
for i in range(n):
if(((diff >> i) & 1) != 0):
diff = 1 << i
break
# print("a = {}, b = {}, mask = {}, ll = {}, diff = {}".format(a, b, mask, ll, diff))
for i, elem in enumerate(l[1:-1], 1):
if(i < ll // 2):
l[i] = (l[i] & ~diff) | (a & diff)
else:
l[i] = (l[i] & ~diff) | (b & diff)
# print("l = {}".format(l))
nextbit = mask & ~diff
if(0 != nextbit):
for i in range(n):
if(((nextbit >> i) & 1) != 0):
nextbit = 1 << i
break
l[ll // 2 - 1] = (l[ll // 2 - 1] | (a & ~diff)) ^ nextbit
l[ll // 2 - 0] = (l[ll // 2 - 0] | (a & ~diff)) ^ nextbit
# print("nextbit = {}, ll//2 = {}, l = {}".format(nextbit, ll//2, l))
if(ll > 2):
l[:ll // 2] = makep(n, l[:ll // 2], mask & ~diff)
l[ll // 2:] = makep(n, l[ll // 2:], mask & ~diff)
return(l)
N, A, B = map(int, input().split())
A1num = "{:b}".format(A).count("1")
B1num = "{:b}".format(B).count("1")
if((A1num % 2) == (B1num % 2)):
print("NO")
exit()
print("YES")
p = [0] * (2 ** N)
p[0] = A
p[-1] = B
p = makep(N, p, 2 ** N - 1)
#for i in p:
# print("{:08b}".format(i))
print(" ".join(map(str, p)))
``` | output | 1 | 15,770 | 12 | 31,541 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has a sequence a consisting of n integers a_1, a_2, ..., a_n. Vasya may pefrom the following operation: choose some number from the sequence and swap any pair of bits in its binary representation. For example, Vasya can transform number 6 (... 00000000110_2) into 3 (... 00000000011_2), 12 (... 000000001100_2), 1026 (... 10000000010_2) and many others. Vasya can use this operation any (possibly zero) number of times on any number from the sequence.
Vasya names a sequence as good one, if, using operation mentioned above, he can obtain the sequence with [bitwise exclusive or](https://en.wikipedia.org/wiki/Exclusive_or) of all elements equal to 0.
For the given sequence a_1, a_2, …, a_n Vasya'd like to calculate number of integer pairs (l, r) such that 1 ≤ l ≤ r ≤ n and sequence a_l, a_{l + 1}, ..., a_r is good.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — length of the sequence.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^{18}) — the sequence a.
Output
Print one integer — the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ n and the sequence a_l, a_{l + 1}, ..., a_r is good.
Examples
Input
3
6 7 14
Output
2
Input
4
1 2 1 16
Output
4
Note
In the first example pairs (2, 3) and (1, 3) are valid. Pair (2, 3) is valid since a_2 = 7 → 11, a_3 = 14 → 11 and 11 ⊕ 11 = 0, where ⊕ — bitwise exclusive or. Pair (1, 3) is valid since a_1 = 6 → 3, a_2 = 7 → 13, a_3 = 14 → 14 and 3 ⊕ 13 ⊕ 14 = 0.
In the second example pairs (1, 2), (2, 3), (3, 4) and (1, 4) are valid. | instruction | 0 | 15,951 | 12 | 31,902 |
Tags: bitmasks, dp
Correct Solution:
```
n = int(input())
cnt = [[0 for _ in range(n + 1)] for _ in range(2)]
b = [bin(_).count('1') for _ in list(map(int, input().split()))]
res = 0
suf_sum = 0
cnt[0][n] = 1
for i in range(n)[::-1]:
_sum, mx = 0, 0
lst_j = i
add = 0
for j in range(i, min(n, i + 65)):
_sum += b[j]
mx = max(mx, b[j])
if mx > _sum - mx and _sum % 2 == 0:
add -= 1
lst_j = j
suf_sum += b[i]
add += cnt[suf_sum & 1][i + 1]
res += add
cnt[0][i] = cnt[0][i + 1]
cnt[1][i] = cnt[1][i + 1]
if suf_sum & 1:
cnt[1][i] += 1
else:
cnt[0][i] += 1
print(res)
``` | output | 1 | 15,951 | 12 | 31,903 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has a sequence a consisting of n integers a_1, a_2, ..., a_n. Vasya may pefrom the following operation: choose some number from the sequence and swap any pair of bits in its binary representation. For example, Vasya can transform number 6 (... 00000000110_2) into 3 (... 00000000011_2), 12 (... 000000001100_2), 1026 (... 10000000010_2) and many others. Vasya can use this operation any (possibly zero) number of times on any number from the sequence.
Vasya names a sequence as good one, if, using operation mentioned above, he can obtain the sequence with [bitwise exclusive or](https://en.wikipedia.org/wiki/Exclusive_or) of all elements equal to 0.
For the given sequence a_1, a_2, …, a_n Vasya'd like to calculate number of integer pairs (l, r) such that 1 ≤ l ≤ r ≤ n and sequence a_l, a_{l + 1}, ..., a_r is good.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — length of the sequence.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^{18}) — the sequence a.
Output
Print one integer — the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ n and the sequence a_l, a_{l + 1}, ..., a_r is good.
Examples
Input
3
6 7 14
Output
2
Input
4
1 2 1 16
Output
4
Note
In the first example pairs (2, 3) and (1, 3) are valid. Pair (2, 3) is valid since a_2 = 7 → 11, a_3 = 14 → 11 and 11 ⊕ 11 = 0, where ⊕ — bitwise exclusive or. Pair (1, 3) is valid since a_1 = 6 → 3, a_2 = 7 → 13, a_3 = 14 → 14 and 3 ⊕ 13 ⊕ 14 = 0.
In the second example pairs (1, 2), (2, 3), (3, 4) and (1, 4) are valid. | instruction | 0 | 15,952 | 12 | 31,904 |
Tags: bitmasks, dp
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
def some_random_function():
"""due to the fast IO template, my code gets caught in
plag check for no reason. That is why, I am making
random functions"""
x = 10
x *= 100
i_dont_know = x
why_am_i_writing_this = x*x
print(i_dont_know)
print(why_am_i_writing_this)
def some_random_function5():
"""due to the fast IO template, my code gets caught in
plag check for no reason. That is why, I am making
random functions"""
x = 10
x *= 100
i_dont_know = x
why_am_i_writing_this = x*x
print(i_dont_know)
print(why_am_i_writing_this)
import os,sys
from io import BytesIO,IOBase
def set_bits(x):
ans,x = 0,int(x)
while x:
x &= x-1
ans += 1
return ans
def main():
n = int(input())
a = list(map(set_bits,input().split()))
dp = [[0,0] for _ in range(n)]
# odd even
dp[0] = [a[-1]&1,(a[-1]&1)^1]
for i in range(1,n):
if a[-1-i]&1:
dp[i][0] = dp[i-1][1]+1
dp[i][1] = dp[i-1][0]
else:
dp[i] = dp[i-1][:]
dp[i][1] += 1
dp.reverse()
dp.append([0,0])
ans = 0
for i in range(n):
maxi,bi = 0,0
for j in range(i,min(n,i+61)):
maxi = max(maxi,a[j])
bi += a[j]
if not bi&1 and maxi <= bi>>1:
ans += 1
ans += dp[j+1][0] if bi&1 else dp[j+1][1]
print(ans)
#Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def some_random_function1():
"""due to the fast IO template, my code gets caught in
plag check for no reason. That is why, I am making
random functions"""
x = 10
x *= 100
i_dont_know = x
why_am_i_writing_this = x*x
print(i_dont_know)
print(why_am_i_writing_this)
def some_random_function2():
"""due to the fast IO template, my code gets caught in
plag check for no reason. That is why, I am making
random functions"""
x = 10
x *= 100
i_dont_know = x
why_am_i_writing_this = x*x
print(i_dont_know)
print(why_am_i_writing_this)
def some_random_function3():
"""due to the fast IO template, my code gets caught in
plag check for no reason. That is why, I am making
random functions"""
x = 10
x *= 100
i_dont_know = x
why_am_i_writing_this = x*x
print(i_dont_know)
print(why_am_i_writing_this)
def some_random_function4():
"""due to the fast IO template, my code gets caught in
plag check for no reason. That is why, I am making
random functions"""
x = 10
x *= 100
i_dont_know = x
why_am_i_writing_this = x*x
print(i_dont_know)
print(why_am_i_writing_this)
def some_random_function6():
"""due to the fast IO template, my code gets caught in
plag check for no reason. That is why, I am making
random functions"""
x = 10
x *= 100
i_dont_know = x
why_am_i_writing_this = x*x
print(i_dont_know)
print(why_am_i_writing_this)
def some_random_function7():
"""due to the fast IO template, my code gets caught in
plag check for no reason. That is why, I am making
random functions"""
x = 10
x *= 100
i_dont_know = x
why_am_i_writing_this = x*x
print(i_dont_know)
print(why_am_i_writing_this)
def some_random_function8():
"""due to the fast IO template, my code gets caught in
plag check for no reason. That is why, I am making
random functions"""
x = 10
x *= 100
i_dont_know = x
why_am_i_writing_this = x*x
print(i_dont_know)
print(why_am_i_writing_this)
if __name__ == '__main__':
main()
``` | output | 1 | 15,952 | 12 | 31,905 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has a sequence a consisting of n integers a_1, a_2, ..., a_n. Vasya may pefrom the following operation: choose some number from the sequence and swap any pair of bits in its binary representation. For example, Vasya can transform number 6 (... 00000000110_2) into 3 (... 00000000011_2), 12 (... 000000001100_2), 1026 (... 10000000010_2) and many others. Vasya can use this operation any (possibly zero) number of times on any number from the sequence.
Vasya names a sequence as good one, if, using operation mentioned above, he can obtain the sequence with [bitwise exclusive or](https://en.wikipedia.org/wiki/Exclusive_or) of all elements equal to 0.
For the given sequence a_1, a_2, …, a_n Vasya'd like to calculate number of integer pairs (l, r) such that 1 ≤ l ≤ r ≤ n and sequence a_l, a_{l + 1}, ..., a_r is good.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — length of the sequence.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^{18}) — the sequence a.
Output
Print one integer — the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ n and the sequence a_l, a_{l + 1}, ..., a_r is good.
Examples
Input
3
6 7 14
Output
2
Input
4
1 2 1 16
Output
4
Note
In the first example pairs (2, 3) and (1, 3) are valid. Pair (2, 3) is valid since a_2 = 7 → 11, a_3 = 14 → 11 and 11 ⊕ 11 = 0, where ⊕ — bitwise exclusive or. Pair (1, 3) is valid since a_1 = 6 → 3, a_2 = 7 → 13, a_3 = 14 → 14 and 3 ⊕ 13 ⊕ 14 = 0.
In the second example pairs (1, 2), (2, 3), (3, 4) and (1, 4) are valid. | instruction | 0 | 15,953 | 12 | 31,906 |
Tags: bitmasks, dp
Correct Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
# from fractions import *
# from heapq import*
from bisect import *
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
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")
ALPHA='abcdefghijklmnopqrstuvwxyz'
M=998244353
EPS=1e-6
def Ceil(a,b): return a//b+int(a%b>0)
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
# vsInput()
def setBit(x):
ans = 0
while( x ):
x = x & (x-1)
ans += 1
return ans
n = Int()
a=[ setBit(i) for i in array()]
# print(a)
have = [1,0]
ans = 0
cur = 0
prev = 0
for i in range(n):
cur += a[i]
ans += have[cur%2]
# print(cur)
have[cur%2] += 1
j = 0
ma = -1
temp = 0
while ( i-j>=0 and j<100):
temp += a[i-j]
ma = max(ma, a[i-j])
ans -= (temp%2==0 and ma * 2 >temp)
j += 1
print(ans)
``` | output | 1 | 15,953 | 12 | 31,907 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has a sequence a consisting of n integers a_1, a_2, ..., a_n. Vasya may pefrom the following operation: choose some number from the sequence and swap any pair of bits in its binary representation. For example, Vasya can transform number 6 (... 00000000110_2) into 3 (... 00000000011_2), 12 (... 000000001100_2), 1026 (... 10000000010_2) and many others. Vasya can use this operation any (possibly zero) number of times on any number from the sequence.
Vasya names a sequence as good one, if, using operation mentioned above, he can obtain the sequence with [bitwise exclusive or](https://en.wikipedia.org/wiki/Exclusive_or) of all elements equal to 0.
For the given sequence a_1, a_2, …, a_n Vasya'd like to calculate number of integer pairs (l, r) such that 1 ≤ l ≤ r ≤ n and sequence a_l, a_{l + 1}, ..., a_r is good.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — length of the sequence.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^{18}) — the sequence a.
Output
Print one integer — the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ n and the sequence a_l, a_{l + 1}, ..., a_r is good.
Examples
Input
3
6 7 14
Output
2
Input
4
1 2 1 16
Output
4
Note
In the first example pairs (2, 3) and (1, 3) are valid. Pair (2, 3) is valid since a_2 = 7 → 11, a_3 = 14 → 11 and 11 ⊕ 11 = 0, where ⊕ — bitwise exclusive or. Pair (1, 3) is valid since a_1 = 6 → 3, a_2 = 7 → 13, a_3 = 14 → 14 and 3 ⊕ 13 ⊕ 14 = 0.
In the second example pairs (1, 2), (2, 3), (3, 4) and (1, 4) are valid. | instruction | 0 | 15,954 | 12 | 31,908 |
Tags: bitmasks, dp
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: 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=arr[n-1]
while (left <= right):
mid = (right + left)//2
if (arr[mid] >= key):
res=arr[mid]
right = mid-1
else:
left = mid + 1
return res
def binarySearch1(arr, n, key):
left = 0
right = n-1
mid = 0
res=arr[0]
while (left <= right):
mid = (right + left)//2
if (arr[mid] > key):
right = mid-1
else:
res=arr[mid]
left = mid + 1
return res
#---------------------------------running code------------------------------------------
n = int(input())
cnt = [[0 for _ in range(n + 1)] for _ in range(2)]
b = [bin(_).count('1') for _ in list(map(int, input().split()))]
res = 0
suf_sum = 0
cnt[0][n] = 1
for i in range(n)[::-1]:
_sum, mx = 0, 0
lst_j = i
add = 0
for j in range(i, min(n, i + 65)):
_sum += b[j]
mx = max(mx, b[j])
if mx > _sum - mx and _sum % 2 == 0:
add -= 1
lst_j = j
suf_sum += b[i]
add += cnt[suf_sum & 1][i + 1]
res += add
cnt[0][i] = cnt[0][i + 1]
cnt[1][i] = cnt[1][i + 1]
if suf_sum & 1:
cnt[1][i] += 1
else:
cnt[0][i] += 1
print(res)
``` | output | 1 | 15,954 | 12 | 31,909 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has a sequence a consisting of n integers a_1, a_2, ..., a_n. Vasya may pefrom the following operation: choose some number from the sequence and swap any pair of bits in its binary representation. For example, Vasya can transform number 6 (... 00000000110_2) into 3 (... 00000000011_2), 12 (... 000000001100_2), 1026 (... 10000000010_2) and many others. Vasya can use this operation any (possibly zero) number of times on any number from the sequence.
Vasya names a sequence as good one, if, using operation mentioned above, he can obtain the sequence with [bitwise exclusive or](https://en.wikipedia.org/wiki/Exclusive_or) of all elements equal to 0.
For the given sequence a_1, a_2, …, a_n Vasya'd like to calculate number of integer pairs (l, r) such that 1 ≤ l ≤ r ≤ n and sequence a_l, a_{l + 1}, ..., a_r is good.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — length of the sequence.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^{18}) — the sequence a.
Output
Print one integer — the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ n and the sequence a_l, a_{l + 1}, ..., a_r is good.
Examples
Input
3
6 7 14
Output
2
Input
4
1 2 1 16
Output
4
Note
In the first example pairs (2, 3) and (1, 3) are valid. Pair (2, 3) is valid since a_2 = 7 → 11, a_3 = 14 → 11 and 11 ⊕ 11 = 0, where ⊕ — bitwise exclusive or. Pair (1, 3) is valid since a_1 = 6 → 3, a_2 = 7 → 13, a_3 = 14 → 14 and 3 ⊕ 13 ⊕ 14 = 0.
In the second example pairs (1, 2), (2, 3), (3, 4) and (1, 4) are valid. | instruction | 0 | 15,955 | 12 | 31,910 |
Tags: bitmasks, dp
Correct Solution:
```
import sys
#range = xrange
input = sys.stdin.readline
n = int(input())
A = [int(x) for x in input().split()]
B = [bin(a).count('1') for a in A]
Bcumsum = [0]
for b in B:
Bcumsum.append((Bcumsum[-1]+b)%2)
count0 = [0]*(n+1)
for i in reversed(range(n)):
count0[i] = count0[i+1] + (Bcumsum[i+1]==0)
numb = 65
sol = 0
for i in range(n):
mini = B[i]
maxi = mini
for j in range(i+1,min(i+1+numb,n)):
if mini<=B[j]<=maxi:
if (mini+B[j])%2==0:
mini = 0
else:
mini = 1
else:
if B[j]<mini:
mini = mini-B[j]
else:
mini = B[j]-maxi
#mini = min(abs(x-B[j]) for x in range(mini,maxi+1,2))
maxi = B[j] + maxi
if mini==0:
sol += 1
if i+1+numb<n:
count = count0[i+1+numb]
if (mini+Bcumsum[i+1+numb])%2==1:
count = n-(i+1+numb) - count
sol += count
print(sol)
``` | output | 1 | 15,955 | 12 | 31,911 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has a sequence a consisting of n integers a_1, a_2, ..., a_n. Vasya may pefrom the following operation: choose some number from the sequence and swap any pair of bits in its binary representation. For example, Vasya can transform number 6 (... 00000000110_2) into 3 (... 00000000011_2), 12 (... 000000001100_2), 1026 (... 10000000010_2) and many others. Vasya can use this operation any (possibly zero) number of times on any number from the sequence.
Vasya names a sequence as good one, if, using operation mentioned above, he can obtain the sequence with [bitwise exclusive or](https://en.wikipedia.org/wiki/Exclusive_or) of all elements equal to 0.
For the given sequence a_1, a_2, …, a_n Vasya'd like to calculate number of integer pairs (l, r) such that 1 ≤ l ≤ r ≤ n and sequence a_l, a_{l + 1}, ..., a_r is good.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — length of the sequence.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^{18}) — the sequence a.
Output
Print one integer — the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ n and the sequence a_l, a_{l + 1}, ..., a_r is good.
Examples
Input
3
6 7 14
Output
2
Input
4
1 2 1 16
Output
4
Note
In the first example pairs (2, 3) and (1, 3) are valid. Pair (2, 3) is valid since a_2 = 7 → 11, a_3 = 14 → 11 and 11 ⊕ 11 = 0, where ⊕ — bitwise exclusive or. Pair (1, 3) is valid since a_1 = 6 → 3, a_2 = 7 → 13, a_3 = 14 → 14 and 3 ⊕ 13 ⊕ 14 = 0.
In the second example pairs (1, 2), (2, 3), (3, 4) and (1, 4) are valid. | instruction | 0 | 15,956 | 12 | 31,912 |
Tags: bitmasks, dp
Correct Solution:
```
from array import array
def popcount(x):
res = 0;
while(x > 0):
res += (x & 1)
x >>= 1
return res
def main():
n = int(input())
a = array('i',[popcount(int(x)) for x in input().split(' ')])
ans,s0,s1 = 0,0,0
for i in range(n):
if(a[i] & 1):
s0,s1 = s1,s0 + 1
else:
s0,s1 = s0 + 1, s1
ans += s0
for i in range(n):
mx,sum = a[i],0
for j in range(i, min(n, i + 70)):
mx = max(mx, a[j]<<1)
sum += a[j]
if( (sum & 1 is 0) and (mx > sum)):
ans-=1
print(ans)
main()
``` | output | 1 | 15,956 | 12 | 31,913 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has a sequence a consisting of n integers a_1, a_2, ..., a_n. Vasya may pefrom the following operation: choose some number from the sequence and swap any pair of bits in its binary representation. For example, Vasya can transform number 6 (... 00000000110_2) into 3 (... 00000000011_2), 12 (... 000000001100_2), 1026 (... 10000000010_2) and many others. Vasya can use this operation any (possibly zero) number of times on any number from the sequence.
Vasya names a sequence as good one, if, using operation mentioned above, he can obtain the sequence with [bitwise exclusive or](https://en.wikipedia.org/wiki/Exclusive_or) of all elements equal to 0.
For the given sequence a_1, a_2, …, a_n Vasya'd like to calculate number of integer pairs (l, r) such that 1 ≤ l ≤ r ≤ n and sequence a_l, a_{l + 1}, ..., a_r is good.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — length of the sequence.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^{18}) — the sequence a.
Output
Print one integer — the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ n and the sequence a_l, a_{l + 1}, ..., a_r is good.
Examples
Input
3
6 7 14
Output
2
Input
4
1 2 1 16
Output
4
Note
In the first example pairs (2, 3) and (1, 3) are valid. Pair (2, 3) is valid since a_2 = 7 → 11, a_3 = 14 → 11 and 11 ⊕ 11 = 0, where ⊕ — bitwise exclusive or. Pair (1, 3) is valid since a_1 = 6 → 3, a_2 = 7 → 13, a_3 = 14 → 14 and 3 ⊕ 13 ⊕ 14 = 0.
In the second example pairs (1, 2), (2, 3), (3, 4) and (1, 4) are valid. | instruction | 0 | 15,957 | 12 | 31,914 |
Tags: bitmasks, dp
Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Sun Sep 23 09:23:00 2018
@author: yanni
"""
n = int(input())
a = [int(x) for x in input().split()]
c = [bin(x).count("1") for x in a]
d = [0 for i in range(n+1)]
even = 1
for i in range(1,n+1):
d[i] = d[i-1] + c[i-1]
if (d[i] % 2 == 0):
even += 1
odd = (n+1)-even
temp = (even * (even-1)) // 2 + (odd * (odd-1)) // 2
#print(temp)
for i in range(n):
C = c[i]
if (C == 1):
continue
if (C == 2):
temp -= 1
continue
for a in range(C):
if (i-a < 0):
break
if (d[i]-d[i-a] >= C):
break
for b in range(C-a):
if (i+b > n-1):
break
if (d[i+b+1]-d[i-a] < 2*C):
if ((d[i+b+1]-d[i-a]) % 2 == 0):
temp -= 1
else:
break
print(temp)
``` | output | 1 | 15,957 | 12 | 31,915 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vasya has a sequence a consisting of n integers a_1, a_2, ..., a_n. Vasya may pefrom the following operation: choose some number from the sequence and swap any pair of bits in its binary representation. For example, Vasya can transform number 6 (... 00000000110_2) into 3 (... 00000000011_2), 12 (... 000000001100_2), 1026 (... 10000000010_2) and many others. Vasya can use this operation any (possibly zero) number of times on any number from the sequence.
Vasya names a sequence as good one, if, using operation mentioned above, he can obtain the sequence with [bitwise exclusive or](https://en.wikipedia.org/wiki/Exclusive_or) of all elements equal to 0.
For the given sequence a_1, a_2, …, a_n Vasya'd like to calculate number of integer pairs (l, r) such that 1 ≤ l ≤ r ≤ n and sequence a_l, a_{l + 1}, ..., a_r is good.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — length of the sequence.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^{18}) — the sequence a.
Output
Print one integer — the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ n and the sequence a_l, a_{l + 1}, ..., a_r is good.
Examples
Input
3
6 7 14
Output
2
Input
4
1 2 1 16
Output
4
Note
In the first example pairs (2, 3) and (1, 3) are valid. Pair (2, 3) is valid since a_2 = 7 → 11, a_3 = 14 → 11 and 11 ⊕ 11 = 0, where ⊕ — bitwise exclusive or. Pair (1, 3) is valid since a_1 = 6 → 3, a_2 = 7 → 13, a_3 = 14 → 14 and 3 ⊕ 13 ⊕ 14 = 0.
In the second example pairs (1, 2), (2, 3), (3, 4) and (1, 4) are valid. | instruction | 0 | 15,958 | 12 | 31,916 |
Tags: bitmasks, dp
Correct Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
sys.setrecursionlimit(300000)
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")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=2**51, func=lambda a, b: 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)
# -------------------game starts now----------------------------------------------------import math
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)
# -------------------------------iye ha chutiya zindegi-------------------------------------
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
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] < key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
n=int(input())
l=list(map(int,input().split()))
def cou(n):
return (n*(n-1))//2
a=[bin(l[i])[2:].count('1') for i in range(n)]
su=[0]*(n+1)
s=0
for i in range(n):
s+=a[i]
su[i+1]=s%2
s=[0]*(n+1)
s1=[0]*(n+1)
for i in range(1,n+1):
s[i]=s[i-1]+su[i]
s1[i]=s1[i-1]+a[i-1]
ans=0
for i in range(n):
an=s[n]-s[i+1]
if su[i]%2==1:
ans+=an
else:
ans+=n-i-1-an
swq=a[i]
for j in range(i+1,min(n,i+62)):
swq=max(swq,a[j])
if (s1[j+1]-s1[i])%2==0 and swq>s1[j+1]-s1[i]-swq:
ans-=1
print(ans)
``` | output | 1 | 15,958 | 12 | 31,917 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has a sequence a consisting of n integers a_1, a_2, ..., a_n. Vasya may pefrom the following operation: choose some number from the sequence and swap any pair of bits in its binary representation. For example, Vasya can transform number 6 (... 00000000110_2) into 3 (... 00000000011_2), 12 (... 000000001100_2), 1026 (... 10000000010_2) and many others. Vasya can use this operation any (possibly zero) number of times on any number from the sequence.
Vasya names a sequence as good one, if, using operation mentioned above, he can obtain the sequence with [bitwise exclusive or](https://en.wikipedia.org/wiki/Exclusive_or) of all elements equal to 0.
For the given sequence a_1, a_2, …, a_n Vasya'd like to calculate number of integer pairs (l, r) such that 1 ≤ l ≤ r ≤ n and sequence a_l, a_{l + 1}, ..., a_r is good.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — length of the sequence.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^{18}) — the sequence a.
Output
Print one integer — the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ n and the sequence a_l, a_{l + 1}, ..., a_r is good.
Examples
Input
3
6 7 14
Output
2
Input
4
1 2 1 16
Output
4
Note
In the first example pairs (2, 3) and (1, 3) are valid. Pair (2, 3) is valid since a_2 = 7 → 11, a_3 = 14 → 11 and 11 ⊕ 11 = 0, where ⊕ — bitwise exclusive or. Pair (1, 3) is valid since a_1 = 6 → 3, a_2 = 7 → 13, a_3 = 14 → 14 and 3 ⊕ 13 ⊕ 14 = 0.
In the second example pairs (1, 2), (2, 3), (3, 4) and (1, 4) are valid.
Submitted Solution:
```
N = int(input())
a = list(map(int, input().split()))
cnt = [[0] * (N + 1) for i in range(2)]
b = [0] * N
for i in range(N):
b[i] = bin(a[i]).count("1")
num = 0
suf = 0
cnt[0][N] = 1
for i in range(N - 1, -1, -1):
s = 0
ma = 0
add = 0
for j in range(i, min(N, i + 65)):
s += b[j]
ma = max(ma, b[j])
if ma * 2 > s and s % 2 == 0:
add -= 1
suf += b[i]
add += cnt[suf & 1][i + 1]
num += add
cnt[0][i] = cnt[0][i + 1]
cnt[1][i] = cnt[1][i + 1]
if suf & 1:
cnt[1][i] += 1
else:
cnt[0][i] += 1
print(num)
``` | instruction | 0 | 15,959 | 12 | 31,918 |
Yes | output | 1 | 15,959 | 12 | 31,919 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has a sequence a consisting of n integers a_1, a_2, ..., a_n. Vasya may pefrom the following operation: choose some number from the sequence and swap any pair of bits in its binary representation. For example, Vasya can transform number 6 (... 00000000110_2) into 3 (... 00000000011_2), 12 (... 000000001100_2), 1026 (... 10000000010_2) and many others. Vasya can use this operation any (possibly zero) number of times on any number from the sequence.
Vasya names a sequence as good one, if, using operation mentioned above, he can obtain the sequence with [bitwise exclusive or](https://en.wikipedia.org/wiki/Exclusive_or) of all elements equal to 0.
For the given sequence a_1, a_2, …, a_n Vasya'd like to calculate number of integer pairs (l, r) such that 1 ≤ l ≤ r ≤ n and sequence a_l, a_{l + 1}, ..., a_r is good.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — length of the sequence.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^{18}) — the sequence a.
Output
Print one integer — the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ n and the sequence a_l, a_{l + 1}, ..., a_r is good.
Examples
Input
3
6 7 14
Output
2
Input
4
1 2 1 16
Output
4
Note
In the first example pairs (2, 3) and (1, 3) are valid. Pair (2, 3) is valid since a_2 = 7 → 11, a_3 = 14 → 11 and 11 ⊕ 11 = 0, where ⊕ — bitwise exclusive or. Pair (1, 3) is valid since a_1 = 6 → 3, a_2 = 7 → 13, a_3 = 14 → 14 and 3 ⊕ 13 ⊕ 14 = 0.
In the second example pairs (1, 2), (2, 3), (3, 4) and (1, 4) are valid.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
from math import factorial
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
# ------------------------------
def main():
n = N()
arr = RLL()
narr = [bin(i).count('1') for i in arr]
res = 0
dp = [[0, 0] for _ in range(n+1)]
dp[0][0] = 1
sm = [0]
for i in narr: sm.append(sm[-1]+i)
for i in range(1, n+1):
t = res
if i>1:
if sm[i]%2:
res+=dp[i-2][1]
else:
res+=dp[i-2][0]
# print(i, res-t, sm[i])
dp[i][sm[i]%2] = dp[i-1][sm[i]%2]+1
dp[i][(sm[i]%2)^1] = dp[i-1][(sm[i]%2)^1]
for l in range(1, n+1):
ma = narr[l-1]
for r in range(l+1, n+1):
ma = max(ma, narr[r-1])
now = sm[r]-sm[l-1]
if now>120: break
if now%2==0 and ma>now-ma:
res-=1
print(res)
if __name__ == "__main__":
main()
``` | instruction | 0 | 15,960 | 12 | 31,920 |
Yes | output | 1 | 15,960 | 12 | 31,921 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has a sequence a consisting of n integers a_1, a_2, ..., a_n. Vasya may pefrom the following operation: choose some number from the sequence and swap any pair of bits in its binary representation. For example, Vasya can transform number 6 (... 00000000110_2) into 3 (... 00000000011_2), 12 (... 000000001100_2), 1026 (... 10000000010_2) and many others. Vasya can use this operation any (possibly zero) number of times on any number from the sequence.
Vasya names a sequence as good one, if, using operation mentioned above, he can obtain the sequence with [bitwise exclusive or](https://en.wikipedia.org/wiki/Exclusive_or) of all elements equal to 0.
For the given sequence a_1, a_2, …, a_n Vasya'd like to calculate number of integer pairs (l, r) such that 1 ≤ l ≤ r ≤ n and sequence a_l, a_{l + 1}, ..., a_r is good.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — length of the sequence.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^{18}) — the sequence a.
Output
Print one integer — the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ n and the sequence a_l, a_{l + 1}, ..., a_r is good.
Examples
Input
3
6 7 14
Output
2
Input
4
1 2 1 16
Output
4
Note
In the first example pairs (2, 3) and (1, 3) are valid. Pair (2, 3) is valid since a_2 = 7 → 11, a_3 = 14 → 11 and 11 ⊕ 11 = 0, where ⊕ — bitwise exclusive or. Pair (1, 3) is valid since a_1 = 6 → 3, a_2 = 7 → 13, a_3 = 14 → 14 and 3 ⊕ 13 ⊕ 14 = 0.
In the second example pairs (1, 2), (2, 3), (3, 4) and (1, 4) are valid.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
from math import factorial
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
# ------------------------------
def main():
n = N()
arr = RLL()
narr = [bin(i).count('1') for i in arr]
res = 0
dp = [[0, 0] for _ in range(n+1)]
dp[0][0] = 1
sm = [0]
for i in narr: sm.append(sm[-1]+i)
for i in range(1, n+1):
t = res
if i>1:
if sm[i]%2:
res+=dp[i-2][1]
else:
res+=dp[i-2][0]
# print(i, res-t, sm[i])
dp[i][sm[i]%2] = dp[i-1][sm[i]%2]+1
dp[i][(sm[i]%2)^1] = dp[i-1][(sm[i]%2)^1]
for l in range(1, n+1):
ma = narr[l-1]
for r in range(l+1, min(n+1, l+63)):
ma = max(ma, narr[r-1])
now = sm[r]-sm[l-1]
if now%2==0 and ma>now-ma:
res-=1
print(res)
if __name__ == "__main__":
main()
``` | instruction | 0 | 15,961 | 12 | 31,922 |
Yes | output | 1 | 15,961 | 12 | 31,923 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has a sequence a consisting of n integers a_1, a_2, ..., a_n. Vasya may pefrom the following operation: choose some number from the sequence and swap any pair of bits in its binary representation. For example, Vasya can transform number 6 (... 00000000110_2) into 3 (... 00000000011_2), 12 (... 000000001100_2), 1026 (... 10000000010_2) and many others. Vasya can use this operation any (possibly zero) number of times on any number from the sequence.
Vasya names a sequence as good one, if, using operation mentioned above, he can obtain the sequence with [bitwise exclusive or](https://en.wikipedia.org/wiki/Exclusive_or) of all elements equal to 0.
For the given sequence a_1, a_2, …, a_n Vasya'd like to calculate number of integer pairs (l, r) such that 1 ≤ l ≤ r ≤ n and sequence a_l, a_{l + 1}, ..., a_r is good.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — length of the sequence.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^{18}) — the sequence a.
Output
Print one integer — the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ n and the sequence a_l, a_{l + 1}, ..., a_r is good.
Examples
Input
3
6 7 14
Output
2
Input
4
1 2 1 16
Output
4
Note
In the first example pairs (2, 3) and (1, 3) are valid. Pair (2, 3) is valid since a_2 = 7 → 11, a_3 = 14 → 11 and 11 ⊕ 11 = 0, where ⊕ — bitwise exclusive or. Pair (1, 3) is valid since a_1 = 6 → 3, a_2 = 7 → 13, a_3 = 14 → 14 and 3 ⊕ 13 ⊕ 14 = 0.
In the second example pairs (1, 2), (2, 3), (3, 4) and (1, 4) are valid.
Submitted Solution:
```
n = int(input())
a= list(map(int,input().split()))
for i in range(n):
x = bin(a[i])
a[i] = x.count('1')
even = 0
odd = 0
cnt = 0
#print(a)
sofar = 0
for i in range(n):
sofar += a[i]
if(sofar % 2):
odd += 1
else:
even += 1
even += 1
#print(even,odd)
sofar = 0
for i in range(n):
if(sofar % 2):
odd -= 1
cnt += odd
else:
even -= 1
cnt += even
sofar += a[i]
#print(cnt)
for i in range(n):
sum1 = 0
max1 = a[i]
for j in range(i, min(i + 100 , n) ):
sum1 += a[j]
max1 = max(max1,a[j])
if(sum1 % 2 == 0 and sum1 < 2*max1):
cnt -= 1
print(cnt)
``` | instruction | 0 | 15,962 | 12 | 31,924 |
Yes | output | 1 | 15,962 | 12 | 31,925 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has a sequence a consisting of n integers a_1, a_2, ..., a_n. Vasya may pefrom the following operation: choose some number from the sequence and swap any pair of bits in its binary representation. For example, Vasya can transform number 6 (... 00000000110_2) into 3 (... 00000000011_2), 12 (... 000000001100_2), 1026 (... 10000000010_2) and many others. Vasya can use this operation any (possibly zero) number of times on any number from the sequence.
Vasya names a sequence as good one, if, using operation mentioned above, he can obtain the sequence with [bitwise exclusive or](https://en.wikipedia.org/wiki/Exclusive_or) of all elements equal to 0.
For the given sequence a_1, a_2, …, a_n Vasya'd like to calculate number of integer pairs (l, r) such that 1 ≤ l ≤ r ≤ n and sequence a_l, a_{l + 1}, ..., a_r is good.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — length of the sequence.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^{18}) — the sequence a.
Output
Print one integer — the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ n and the sequence a_l, a_{l + 1}, ..., a_r is good.
Examples
Input
3
6 7 14
Output
2
Input
4
1 2 1 16
Output
4
Note
In the first example pairs (2, 3) and (1, 3) are valid. Pair (2, 3) is valid since a_2 = 7 → 11, a_3 = 14 → 11 and 11 ⊕ 11 = 0, where ⊕ — bitwise exclusive or. Pair (1, 3) is valid since a_1 = 6 → 3, a_2 = 7 → 13, a_3 = 14 → 14 and 3 ⊕ 13 ⊕ 14 = 0.
In the second example pairs (1, 2), (2, 3), (3, 4) and (1, 4) are valid.
Submitted Solution:
```
k = int(input())
lis = input().split(" ")
su=[]
x=[]
for i in lis:
# print(i, format(int(i), "b"))
x=str(format(int(i), "b")).split('0')
for k in x:
if k=='':
pass
else:
su.append(len(k))
ok=0
#rint(su)
for l in range(len(su)+1):
for p in range(l+2,len(su)+1):
#print(l+1,p,l,p,su[l:p],sum(su[l:p]))
try:
if sum(su[l:p])%2==0:
#print(l, p)
ok+=1
except:
pass
print(ok)
``` | instruction | 0 | 15,963 | 12 | 31,926 |
No | output | 1 | 15,963 | 12 | 31,927 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has a sequence a consisting of n integers a_1, a_2, ..., a_n. Vasya may pefrom the following operation: choose some number from the sequence and swap any pair of bits in its binary representation. For example, Vasya can transform number 6 (... 00000000110_2) into 3 (... 00000000011_2), 12 (... 000000001100_2), 1026 (... 10000000010_2) and many others. Vasya can use this operation any (possibly zero) number of times on any number from the sequence.
Vasya names a sequence as good one, if, using operation mentioned above, he can obtain the sequence with [bitwise exclusive or](https://en.wikipedia.org/wiki/Exclusive_or) of all elements equal to 0.
For the given sequence a_1, a_2, …, a_n Vasya'd like to calculate number of integer pairs (l, r) such that 1 ≤ l ≤ r ≤ n and sequence a_l, a_{l + 1}, ..., a_r is good.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — length of the sequence.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^{18}) — the sequence a.
Output
Print one integer — the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ n and the sequence a_l, a_{l + 1}, ..., a_r is good.
Examples
Input
3
6 7 14
Output
2
Input
4
1 2 1 16
Output
4
Note
In the first example pairs (2, 3) and (1, 3) are valid. Pair (2, 3) is valid since a_2 = 7 → 11, a_3 = 14 → 11 and 11 ⊕ 11 = 0, where ⊕ — bitwise exclusive or. Pair (1, 3) is valid since a_1 = 6 → 3, a_2 = 7 → 13, a_3 = 14 → 14 and 3 ⊕ 13 ⊕ 14 = 0.
In the second example pairs (1, 2), (2, 3), (3, 4) and (1, 4) are valid.
Submitted Solution:
```
def get_cnt(x):
ret = 0
while x > 0:
ret = ret + (x % 2)
x //= 2
return ret
n = eval(input())
a = [int(x) for x in input().split()]
cnt = [0] * (n + 1)
pre = [0] * (n + 1)
suf = [[0] * 2] * (n + 2)
for i in range(1, n + 1):
cnt[i] = get_cnt(a[i - 1])
pre[i] = pre[i - 1] + cnt[i]
for i in range(n, 0, -1):
for j in range(2):
suf[i][j] = suf[i + 1][j]
suf[i][pre[i] % 2] += 1
ans = 0
for i in range(1, n + 1):
mx = cnt[i]
for j in range(0, 60):
if i + j > n:
break
mx = max(mx, cnt[i + j])
if pre[i - 1] % 2 == pre[i + j] % 2 and pre[i + j] - pre[i - 1] >= 2 * mx:
ans += 1
if i + 60 <= n:
ans += suf[i + 60][pre[i - 1] % 2]
print(ans)
``` | instruction | 0 | 15,964 | 12 | 31,928 |
No | output | 1 | 15,964 | 12 | 31,929 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has a sequence a consisting of n integers a_1, a_2, ..., a_n. Vasya may pefrom the following operation: choose some number from the sequence and swap any pair of bits in its binary representation. For example, Vasya can transform number 6 (... 00000000110_2) into 3 (... 00000000011_2), 12 (... 000000001100_2), 1026 (... 10000000010_2) and many others. Vasya can use this operation any (possibly zero) number of times on any number from the sequence.
Vasya names a sequence as good one, if, using operation mentioned above, he can obtain the sequence with [bitwise exclusive or](https://en.wikipedia.org/wiki/Exclusive_or) of all elements equal to 0.
For the given sequence a_1, a_2, …, a_n Vasya'd like to calculate number of integer pairs (l, r) such that 1 ≤ l ≤ r ≤ n and sequence a_l, a_{l + 1}, ..., a_r is good.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — length of the sequence.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^{18}) — the sequence a.
Output
Print one integer — the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ n and the sequence a_l, a_{l + 1}, ..., a_r is good.
Examples
Input
3
6 7 14
Output
2
Input
4
1 2 1 16
Output
4
Note
In the first example pairs (2, 3) and (1, 3) are valid. Pair (2, 3) is valid since a_2 = 7 → 11, a_3 = 14 → 11 and 11 ⊕ 11 = 0, where ⊕ — bitwise exclusive or. Pair (1, 3) is valid since a_1 = 6 → 3, a_2 = 7 → 13, a_3 = 14 → 14 and 3 ⊕ 13 ⊕ 14 = 0.
In the second example pairs (1, 2), (2, 3), (3, 4) and (1, 4) are valid.
Submitted Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
# from fractions import *
# from heapq import*
from bisect import *
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
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")
ALPHA='abcdefghijklmnopqrstuvwxyz'
M=998244353
EPS=1e-6
def Ceil(a,b): return a//b+int(a%b>0)
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
# vsInput()
def setBit(x):
ans = 0
while( x ):
x = x & (x-1)
ans += 1
return ans
n = Int()
a=[ setBit(i) for i in array()]
# print(a)
have = [1,0]
ans = 0
cur = 0
prev = 0
for i in range(n):
cur += a[i]
ans += have[cur%2]
have[cur%2] += 1
j= 1
ma = a[i]
temp = a[i]
while ( i-j>=0 and j<100):
temp += a[i-j]
ma = max(ma, a[i-j])
ans -= (temp%2 and ma * 2 >temp)
j += 1
print(ans)
``` | instruction | 0 | 15,965 | 12 | 31,930 |
No | output | 1 | 15,965 | 12 | 31,931 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has a sequence a consisting of n integers a_1, a_2, ..., a_n. Vasya may pefrom the following operation: choose some number from the sequence and swap any pair of bits in its binary representation. For example, Vasya can transform number 6 (... 00000000110_2) into 3 (... 00000000011_2), 12 (... 000000001100_2), 1026 (... 10000000010_2) and many others. Vasya can use this operation any (possibly zero) number of times on any number from the sequence.
Vasya names a sequence as good one, if, using operation mentioned above, he can obtain the sequence with [bitwise exclusive or](https://en.wikipedia.org/wiki/Exclusive_or) of all elements equal to 0.
For the given sequence a_1, a_2, …, a_n Vasya'd like to calculate number of integer pairs (l, r) such that 1 ≤ l ≤ r ≤ n and sequence a_l, a_{l + 1}, ..., a_r is good.
Input
The first line contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5) — length of the sequence.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^{18}) — the sequence a.
Output
Print one integer — the number of pairs (l, r) such that 1 ≤ l ≤ r ≤ n and the sequence a_l, a_{l + 1}, ..., a_r is good.
Examples
Input
3
6 7 14
Output
2
Input
4
1 2 1 16
Output
4
Note
In the first example pairs (2, 3) and (1, 3) are valid. Pair (2, 3) is valid since a_2 = 7 → 11, a_3 = 14 → 11 and 11 ⊕ 11 = 0, where ⊕ — bitwise exclusive or. Pair (1, 3) is valid since a_1 = 6 → 3, a_2 = 7 → 13, a_3 = 14 → 14 and 3 ⊕ 13 ⊕ 14 = 0.
In the second example pairs (1, 2), (2, 3), (3, 4) and (1, 4) are valid.
Submitted Solution:
```
def get_cnt(x):
ret = 0
while x > 0:
ret += x % 2
x >>= 1
return ret
MX = int(3e5 + 5)
n = eval(input())
a = [0] + [eval(x) for x in input().split()]
cnt = [0] * MX
pre = [0] * MX
suf = [[0] * 3] * MX
for i in range(1, n + 1):
cnt[i] = get_cnt(a[i])
pre[i] = pre[i - 1] + cnt[i]
for i in range(n, 0):
for j in range(2):
suf[i][j] = suf[i + 1][j]
suf[i][pre[i] % 2] += 1
ans = 0
for i in range(1, n + 1):
mx = cnt[i]
for j in range(1, 60):
if i + j > n:
break
mx = max(mx, cnt[i + j])
if ((pre[i - 1] % 2) == (pre[i + j] % 2)) and ((pre[i + j] - pre[i - 1]) >= (2 * mx)):
ans += 1
if (i + 60) <= n:
ans += suf[i + 60][pre[i - 1] % 2]
print(ans)
``` | instruction | 0 | 15,966 | 12 | 31,932 |
No | output | 1 | 15,966 | 12 | 31,933 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gildong recently learned how to find the [longest increasing subsequence](https://en.wikipedia.org/wiki/Longest_increasing_subsequence) (LIS) in O(nlog{n}) time for a sequence of length n. He wants to test himself if he can implement it correctly, but he couldn't find any online judges that would do it (even though there are actually many of them). So instead he's going to make a quiz for you about making permutations of n distinct integers between 1 and n, inclusive, to test his code with your output.
The quiz is as follows.
Gildong provides a string of length n-1, consisting of characters '<' and '>' only. The i-th (1-indexed) character is the comparison result between the i-th element and the i+1-st element of the sequence. If the i-th character of the string is '<', then the i-th element of the sequence is less than the i+1-st element. If the i-th character of the string is '>', then the i-th element of the sequence is greater than the i+1-st element.
He wants you to find two possible sequences (not necessarily distinct) consisting of n distinct integers between 1 and n, inclusive, each satisfying the comparison results, where the length of the LIS of the first sequence is minimum possible, and the length of the LIS of the second sequence is maximum possible.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4).
Each test case contains exactly one line, consisting of an integer and a string consisting of characters '<' and '>' only. The integer is n (2 ≤ n ≤ 2 ⋅ 10^5), the length of the permutation you need to find. The string is the comparison results explained in the description. The length of the string is n-1.
It is guaranteed that the sum of all n in all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print two lines with n integers each. The first line is the sequence with the minimum length of the LIS, and the second line is the sequence with the maximum length of the LIS. If there are multiple answers, print any one of them. Each sequence should contain all integers between 1 and n, inclusive, and should satisfy the comparison results.
It can be shown that at least one answer always exists.
Example
Input
3
3 <<
7 >><>><
5 >>><
Output
1 2 3
1 2 3
5 4 3 7 2 1 6
4 3 1 7 5 2 6
4 3 2 1 5
5 4 2 1 3
Note
In the first case, 1 2 3 is the only possible answer.
In the second case, the shortest length of the LIS is 2, and the longest length of the LIS is 3. In the example of the maximum LIS sequence, 4 '3' 1 7 '5' 2 '6' can be one of the possible LIS. | instruction | 0 | 16,082 | 12 | 32,164 |
Tags: constructive algorithms, graphs, greedy, two pointers
Correct Solution:
```
import sys; input = sys.stdin.readline
for __ in range(int(input())):
s = input().split()[1]
n = len(s) + 1
amin = []
i = 0; t = n
while i < n - 1:
c = s[i]
if c == '>':
amin.append(t); t -= 1
i += 1
else:
j = i + 1
while j < n - 1 and s[j] != '>':
j += 1
amin.extend(range(t - (j - i), t + 1))
t -= j - i + 1
i = j + 1
if len(amin) < n: amin.append(t)
print(*amin)
amax = []
i = 0; t = 1
while i < n - 1:
c = s[i]
if c == '<':
amax.append(t); t += 1
i += 1
else:
j = i + 1
while j < n - 1 and s[j] != '<':
j += 1
amax.extend(range(t + (j - i), t - 1, -1))
t += j - i + 1
i = j + 1
if len(amax) < n: amax.append(t)
print(*amax)
``` | output | 1 | 16,082 | 12 | 32,165 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gildong recently learned how to find the [longest increasing subsequence](https://en.wikipedia.org/wiki/Longest_increasing_subsequence) (LIS) in O(nlog{n}) time for a sequence of length n. He wants to test himself if he can implement it correctly, but he couldn't find any online judges that would do it (even though there are actually many of them). So instead he's going to make a quiz for you about making permutations of n distinct integers between 1 and n, inclusive, to test his code with your output.
The quiz is as follows.
Gildong provides a string of length n-1, consisting of characters '<' and '>' only. The i-th (1-indexed) character is the comparison result between the i-th element and the i+1-st element of the sequence. If the i-th character of the string is '<', then the i-th element of the sequence is less than the i+1-st element. If the i-th character of the string is '>', then the i-th element of the sequence is greater than the i+1-st element.
He wants you to find two possible sequences (not necessarily distinct) consisting of n distinct integers between 1 and n, inclusive, each satisfying the comparison results, where the length of the LIS of the first sequence is minimum possible, and the length of the LIS of the second sequence is maximum possible.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4).
Each test case contains exactly one line, consisting of an integer and a string consisting of characters '<' and '>' only. The integer is n (2 ≤ n ≤ 2 ⋅ 10^5), the length of the permutation you need to find. The string is the comparison results explained in the description. The length of the string is n-1.
It is guaranteed that the sum of all n in all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print two lines with n integers each. The first line is the sequence with the minimum length of the LIS, and the second line is the sequence with the maximum length of the LIS. If there are multiple answers, print any one of them. Each sequence should contain all integers between 1 and n, inclusive, and should satisfy the comparison results.
It can be shown that at least one answer always exists.
Example
Input
3
3 <<
7 >><>><
5 >>><
Output
1 2 3
1 2 3
5 4 3 7 2 1 6
4 3 1 7 5 2 6
4 3 2 1 5
5 4 2 1 3
Note
In the first case, 1 2 3 is the only possible answer.
In the second case, the shortest length of the LIS is 2, and the longest length of the LIS is 3. In the example of the maximum LIS sequence, 4 '3' 1 7 '5' 2 '6' can be one of the possible LIS. | instruction | 0 | 16,083 | 12 | 32,166 |
Tags: constructive algorithms, graphs, greedy, two pointers
Correct Solution:
```
from sys import stdin,stdout
t = int(stdin.readline().strip())
for _ in range(t):
n,comp = stdin.readline().split()
n = int(n)
clist = []
last,cnt = None,0
lt = 0
for i in range(len(comp)):
if comp[i] == '<':
lt+=1
if last:
if comp[i] != last:
clist.append((last, cnt))
cnt=0
last = comp[i]
cnt+=1
else:
clist.append((last, cnt))
i,j = 0,0
sht,lng = [],[]
for c,v in clist:
if c == '<':
for x in range(i+1,i+v+1):
lng.append(str(x))
for x in range(lt-i-v+1,lt-i+1):
sht.append(str(x))
i+=v
else:
for _ in range(v):
s = str(n-j)
sht.append(s)
lng.append(s)
j+=1
else:
s = str(n-j)
sht.append(s)
lng.append(s)
stdout.write("{}\n{}\n".format(' '.join(sht),' '.join(lng)))
``` | output | 1 | 16,083 | 12 | 32,167 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gildong recently learned how to find the [longest increasing subsequence](https://en.wikipedia.org/wiki/Longest_increasing_subsequence) (LIS) in O(nlog{n}) time for a sequence of length n. He wants to test himself if he can implement it correctly, but he couldn't find any online judges that would do it (even though there are actually many of them). So instead he's going to make a quiz for you about making permutations of n distinct integers between 1 and n, inclusive, to test his code with your output.
The quiz is as follows.
Gildong provides a string of length n-1, consisting of characters '<' and '>' only. The i-th (1-indexed) character is the comparison result between the i-th element and the i+1-st element of the sequence. If the i-th character of the string is '<', then the i-th element of the sequence is less than the i+1-st element. If the i-th character of the string is '>', then the i-th element of the sequence is greater than the i+1-st element.
He wants you to find two possible sequences (not necessarily distinct) consisting of n distinct integers between 1 and n, inclusive, each satisfying the comparison results, where the length of the LIS of the first sequence is minimum possible, and the length of the LIS of the second sequence is maximum possible.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4).
Each test case contains exactly one line, consisting of an integer and a string consisting of characters '<' and '>' only. The integer is n (2 ≤ n ≤ 2 ⋅ 10^5), the length of the permutation you need to find. The string is the comparison results explained in the description. The length of the string is n-1.
It is guaranteed that the sum of all n in all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print two lines with n integers each. The first line is the sequence with the minimum length of the LIS, and the second line is the sequence with the maximum length of the LIS. If there are multiple answers, print any one of them. Each sequence should contain all integers between 1 and n, inclusive, and should satisfy the comparison results.
It can be shown that at least one answer always exists.
Example
Input
3
3 <<
7 >><>><
5 >>><
Output
1 2 3
1 2 3
5 4 3 7 2 1 6
4 3 1 7 5 2 6
4 3 2 1 5
5 4 2 1 3
Note
In the first case, 1 2 3 is the only possible answer.
In the second case, the shortest length of the LIS is 2, and the longest length of the LIS is 3. In the example of the maximum LIS sequence, 4 '3' 1 7 '5' 2 '6' can be one of the possible LIS. | instruction | 0 | 16,084 | 12 | 32,168 |
Tags: constructive algorithms, graphs, greedy, two pointers
Correct Solution:
```
import sys
Q = int(sys.stdin.readline().strip())
for q in range (0, Q):
n, s = sys.stdin.readline().strip().split()
n = int(n)
U = [1]
D = [1]
for i in range (0, n-1):
if s[i] == "<":
U[-1] = U[-1] + 1
D.append(1)
else:
D[-1] = D[-1] + 1
U.append(1)
m = n
i = 0
A = []
while m > 0:
for j in range (0, U[i]):
A.append(str(m-U[i]+j+1))
m = m - U[i]
i = i + 1
print(" ".join(A))
m = 0
i = 0
A = []
while i < len(D):
for j in range (0, D[i]):
A.append(str(m+D[i]-j))
m = m + D[i]
i = i + 1
print(" ".join(A))
``` | output | 1 | 16,084 | 12 | 32,169 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gildong recently learned how to find the [longest increasing subsequence](https://en.wikipedia.org/wiki/Longest_increasing_subsequence) (LIS) in O(nlog{n}) time for a sequence of length n. He wants to test himself if he can implement it correctly, but he couldn't find any online judges that would do it (even though there are actually many of them). So instead he's going to make a quiz for you about making permutations of n distinct integers between 1 and n, inclusive, to test his code with your output.
The quiz is as follows.
Gildong provides a string of length n-1, consisting of characters '<' and '>' only. The i-th (1-indexed) character is the comparison result between the i-th element and the i+1-st element of the sequence. If the i-th character of the string is '<', then the i-th element of the sequence is less than the i+1-st element. If the i-th character of the string is '>', then the i-th element of the sequence is greater than the i+1-st element.
He wants you to find two possible sequences (not necessarily distinct) consisting of n distinct integers between 1 and n, inclusive, each satisfying the comparison results, where the length of the LIS of the first sequence is minimum possible, and the length of the LIS of the second sequence is maximum possible.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4).
Each test case contains exactly one line, consisting of an integer and a string consisting of characters '<' and '>' only. The integer is n (2 ≤ n ≤ 2 ⋅ 10^5), the length of the permutation you need to find. The string is the comparison results explained in the description. The length of the string is n-1.
It is guaranteed that the sum of all n in all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print two lines with n integers each. The first line is the sequence with the minimum length of the LIS, and the second line is the sequence with the maximum length of the LIS. If there are multiple answers, print any one of them. Each sequence should contain all integers between 1 and n, inclusive, and should satisfy the comparison results.
It can be shown that at least one answer always exists.
Example
Input
3
3 <<
7 >><>><
5 >>><
Output
1 2 3
1 2 3
5 4 3 7 2 1 6
4 3 1 7 5 2 6
4 3 2 1 5
5 4 2 1 3
Note
In the first case, 1 2 3 is the only possible answer.
In the second case, the shortest length of the LIS is 2, and the longest length of the LIS is 3. In the example of the maximum LIS sequence, 4 '3' 1 7 '5' 2 '6' can be one of the possible LIS. | instruction | 0 | 16,085 | 12 | 32,170 |
Tags: constructive algorithms, graphs, greedy, two pointers
Correct Solution:
```
def getInput():
line = input().split()
return int(line[0]), line[1]
def sLIS(n, s):
ans = list(range(n, 0, -1))
rev = []
i = 0
while i < n-1:
if s[i] == '<':
j = i+1
while j < n-1 and s[j] == '<':
j += 1
rev.append((i, j))
i = j+1
else:
i += 1
for r in rev:
i, j = r
while i <= j:
ans[i], ans[j] = ans[j], ans[i]
i += 1
j -= 1
return ans
def lLIS(n, s):
ans = list(range(1, n+1))
rev = []
i = 0
while i < n-1:
if s[i] == '>':
j = i+1
while j < n-1 and s[j] == '>':
j += 1
rev.append((i, j))
i = j+1
else:
i += 1
for r in rev:
i, j = r
while i <= j:
ans[i], ans[j] = ans[j], ans[i]
i += 1
j -= 1
return ans
for _ in range(int(input())):
n, s = getInput()
"""
p = []
c = +1 if s[0] == '<' else -1
for e in s[1:]:
if c > 0 and e == '>':
p.append(c)
c = -1
elif c < 0 and e == '<':
p.append(c)
c = +1
else:
c += +1 if e == '<' else -1
p.append(c)
"""
print(*sLIS(n, s))
print(*lLIS(n, s))
``` | output | 1 | 16,085 | 12 | 32,171 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.