message stringlengths 2 433k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As usual, Sereja has array a, its elements are integers: a[1], a[2], ..., a[n]. Let's introduce notation:
<image>
A swap operation is the following sequence of actions:
* choose two indexes i, j (i ≠ j);
* perform assignments tmp = a[i], a[i] = a[j], a[j] = tmp.
What maximum value of function m(a) can Sereja get if he is allowed to perform at most k swap operations?
Input
The first line contains two integers n and k (1 ≤ n ≤ 200; 1 ≤ k ≤ 10). The next line contains n integers a[1], a[2], ..., a[n] ( - 1000 ≤ a[i] ≤ 1000).
Output
In a single line print the maximum value of m(a) that Sereja can get if he is allowed to perform at most k swap operations.
Examples
Input
10 2
10 -1 2 2 2 2 2 2 -1 10
Output
32
Input
5 10
-1 -1 -1 -1 -1
Output
-1
Submitted Solution:
```
n, k = map(int, input().split())
a = list(map(int, input().split()))
ans, beg = max(a), 0
while (beg < n):
if (a[beg] < 0):
beg += 1
continue
tans, end = a[beg], beg + 1
for i in range(beg + 1, n):
if (a[i] >= 0):
tans += a[i]
end += 1
elif (k > 0):
# tans += a[i]
k -= 1
end += 1
else:
break
beg = end
ans = max(ans, tans)
print(ans)
``` | instruction | 0 | 72,866 | 12 | 145,732 |
No | output | 1 | 72,866 | 12 | 145,733 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As usual, Sereja has array a, its elements are integers: a[1], a[2], ..., a[n]. Let's introduce notation:
<image>
A swap operation is the following sequence of actions:
* choose two indexes i, j (i ≠ j);
* perform assignments tmp = a[i], a[i] = a[j], a[j] = tmp.
What maximum value of function m(a) can Sereja get if he is allowed to perform at most k swap operations?
Input
The first line contains two integers n and k (1 ≤ n ≤ 200; 1 ≤ k ≤ 10). The next line contains n integers a[1], a[2], ..., a[n] ( - 1000 ≤ a[i] ≤ 1000).
Output
In a single line print the maximum value of m(a) that Sereja can get if he is allowed to perform at most k swap operations.
Examples
Input
10 2
10 -1 2 2 2 2 2 2 -1 10
Output
32
Input
5 10
-1 -1 -1 -1 -1
Output
-1
Submitted Solution:
```
import sys
n, k = map(int, input().split())
a = list(map(int, input().split()))
sums = [0] * (n + 1)
for i in range(n):
sums[i] += sums[i - 1] + a[i]
maximum, maxl, maxr = -1005, 0, 0
for l in range(-1, n):
for r in range(l + 1, n):
if sums[r] - sums[l] > maximum:
maxl = l
maxr = r
maximum = sums[r] - sums[l]
trint = sorted(a[maxl + 1:maxr + 1])
flint = sorted(a[:maxl + 1] + a[maxr + 1:], reverse=True)
for i in range(len(trint)):
if not flint:
break
for j in range(len(flint) - 1, -1, -1):
if i < len(trint) and j < len(flint) and trint[i] < flint[j]:
trint[i] = flint.pop()
k -= 1
break
else:
flint = []
for i in range(len(trint)):
if not k:
break
if trint[i] < 0 and len(trint) > 1:
k -= 1
trint[i] = 0
print(sum(trint))
``` | instruction | 0 | 72,867 | 12 | 145,734 |
No | output | 1 | 72,867 | 12 | 145,735 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As usual, Sereja has array a, its elements are integers: a[1], a[2], ..., a[n]. Let's introduce notation:
<image>
A swap operation is the following sequence of actions:
* choose two indexes i, j (i ≠ j);
* perform assignments tmp = a[i], a[i] = a[j], a[j] = tmp.
What maximum value of function m(a) can Sereja get if he is allowed to perform at most k swap operations?
Input
The first line contains two integers n and k (1 ≤ n ≤ 200; 1 ≤ k ≤ 10). The next line contains n integers a[1], a[2], ..., a[n] ( - 1000 ≤ a[i] ≤ 1000).
Output
In a single line print the maximum value of m(a) that Sereja can get if he is allowed to perform at most k swap operations.
Examples
Input
10 2
10 -1 2 2 2 2 2 2 -1 10
Output
32
Input
5 10
-1 -1 -1 -1 -1
Output
-1
Submitted Solution:
```
n, k = map(int, input().split())
a = list(map(int, input().split()))
res = a[0]
for l in range(n):
for r in range(l, n):
inside = sorted(a[l:r+1])
outside = sorted(a[:l] + a[r+1:], reverse=True)
new_res = sum(inside)
for i in range(min(k, len(inside), len(outside))):
if outside[i] > inside[i]:
new_res += outside[i]-inside[i]
else:
break
if new_res > res:
res = new_res
print(res)
``` | instruction | 0 | 72,868 | 12 | 145,736 |
No | output | 1 | 72,868 | 12 | 145,737 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
As usual, Sereja has array a, its elements are integers: a[1], a[2], ..., a[n]. Let's introduce notation:
<image>
A swap operation is the following sequence of actions:
* choose two indexes i, j (i ≠ j);
* perform assignments tmp = a[i], a[i] = a[j], a[j] = tmp.
What maximum value of function m(a) can Sereja get if he is allowed to perform at most k swap operations?
Input
The first line contains two integers n and k (1 ≤ n ≤ 200; 1 ≤ k ≤ 10). The next line contains n integers a[1], a[2], ..., a[n] ( - 1000 ≤ a[i] ≤ 1000).
Output
In a single line print the maximum value of m(a) that Sereja can get if he is allowed to perform at most k swap operations.
Examples
Input
10 2
10 -1 2 2 2 2 2 2 -1 10
Output
32
Input
5 10
-1 -1 -1 -1 -1
Output
-1
Submitted Solution:
```
n,k = map(int,input().split())
l = [0]*n
dp = [[-1001*200]*(k+1)]*n
l = list(map(int,input().split()))
maxSum = 200*-1001
m = 0
while m <n:
r = m
while r < n:
while r+1 < n and l[r] > 0 :
r = r + 1
i = m
sum = 0
negs = []
while i <= r:
sum = sum + l[i]
if l[i] < 0:
negs.append(l[i])
i = i + 1
negs.sort(reverse=True)
rem = []
if r < n-1:
rem = l[r+1:]
if m > 0:
rem = rem + l[0:m]
#print(m,r,rem)
rem.sort(reverse=True)
i = 0
while i<k and i < len(negs) and i < len(rem):
if sum + rem[i] - negs[i] > sum:
sum = sum + rem[i] - negs[i]
i = i + 1
maxSum = max(sum, maxSum)
r = r + 1
m = m + 1
print(maxSum)
``` | instruction | 0 | 72,869 | 12 | 145,738 |
No | output | 1 | 72,869 | 12 | 145,739 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After bracket sequences Arthur took up number theory. He has got a new favorite sequence of length n (a1, a2, ..., an), consisting of integers and integer k, not exceeding n.
This sequence had the following property: if you write out the sums of all its segments consisting of k consecutive elements (a1 + a2 ... + ak, a2 + a3 + ... + ak + 1, ..., an - k + 1 + an - k + 2 + ... + an), then those numbers will form strictly increasing sequence.
For example, for the following sample: n = 5, k = 3, a = (1, 2, 4, 5, 6) the sequence of numbers will look as follows: (1 + 2 + 4, 2 + 4 + 5, 4 + 5 + 6) = (7, 11, 15), that means that sequence a meets the described property.
Obviously the sequence of sums will have n - k + 1 elements.
Somebody (we won't say who) replaced some numbers in Arthur's sequence by question marks (if this number is replaced, it is replaced by exactly one question mark). We need to restore the sequence so that it meets the required property and also minimize the sum |ai|, where |ai| is the absolute value of ai.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105), showing how many numbers are in Arthur's sequence and the lengths of segments respectively.
The next line contains n space-separated elements ai (1 ≤ i ≤ n).
If ai = ?, then the i-th element of Arthur's sequence was replaced by a question mark.
Otherwise, ai ( - 109 ≤ ai ≤ 109) is the i-th element of Arthur's sequence.
Output
If Arthur is wrong at some point and there is no sequence that could fit the given information, print a single string "Incorrect sequence" (without the quotes).
Otherwise, print n integers — Arthur's favorite sequence. If there are multiple such sequences, print the sequence with the minimum sum |ai|, where |ai| is the absolute value of ai. If there are still several such sequences, you are allowed to print any of them. Print the elements of the sequence without leading zeroes.
Examples
Input
3 2
? 1 2
Output
0 1 2
Input
5 1
-10 -9 ? -7 -6
Output
-10 -9 -8 -7 -6
Input
5 3
4 6 7 2 9
Output
Incorrect sequence
Submitted Solution:
```
#!/usr/bin/env python3
import sys, math
N, K = input().split(' ')
N = int(N)
K = int(K)
raw_a = input().split(' ')
a = ['?'] * N
known_idxs = set()
for i, e in enumerate(raw_a):
if e != '?':
a[i] = int(e)
known_idxs.add(i)
def fail():
print('Incorrect sequence')
sys.exit(0)
def do_fix(aa, b, c, d, e):
assert(len(range(aa, b, c)) == len(range(d, e)))
a[aa:b:c] = range(d, e)
def fix(start, end):
# fix [start...end] with stride K
l = len(range(start, end+1, K))
if l == 2 and a[start] == '?' and a[end] == '?':
a[start] = 0
a[end] = 1
return
a_e = float('+inf') if a[end] == '?' else a[end]
a_s = float('-inf') if a[start] == '?' else a[start]
left_0 = l - a_e - 2
right_0 = -1 - a_s
if (left_0 > right_0):
fail()
else:
assert(left_0 <= right_0)
def opt_0(c1, c2, b1, b2):
assert c1 <= c2
assert b1 <= b2
if b2 < c1:
return b2
if c2 < b1:
return b1
c1 = min(b2, c1)
c1 = max(b1, c1)
return c1
opt_0_l = math.floor((l - 2) / 2)
opt_0_r = math.ceil((l - 2) / 2)
s = -opt_0(opt_0_l, opt_0_r, left_0, right_0)
do_fix(start+K, end, K, s, s+l-2)
# print("done middle", a[start:end+1:K])
if a[end] == '?' and end-K >= 0:
a[end] = max(0, a[end-K] + 1)
elif a[end] == '?':
a[end] = 0
# print(":)", a[start:end+1:K])
if a[start] == '?' and start+K < N:
a[start] = min(0, a[start+K] - 1)
elif a[start] == '?':
a[start] = 0
# print("done", a[start:end+1:K])
for s in range(0, K):
sub_idxs = list(range(s, N, K))
sub_ki = [i for i in sub_idxs if i in known_idxs]
if sub_idxs[0] not in sub_ki:
sub_ki = [sub_idxs[0]] + sub_ki
if sub_idxs[-1] not in sub_ki:
sub_ki = sub_ki + [sub_idxs[-1]]
if len(sub_ki) == 1:
(i, ) = sub_ki
if a[i] == '?':
a[i] = 0
for i in range(0, len(sub_ki) - 1):
fix(sub_ki[i], sub_ki[i + 1])
print(' '.join(map(str, a)))
``` | instruction | 0 | 72,895 | 12 | 145,790 |
No | output | 1 | 72,895 | 12 | 145,791 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After bracket sequences Arthur took up number theory. He has got a new favorite sequence of length n (a1, a2, ..., an), consisting of integers and integer k, not exceeding n.
This sequence had the following property: if you write out the sums of all its segments consisting of k consecutive elements (a1 + a2 ... + ak, a2 + a3 + ... + ak + 1, ..., an - k + 1 + an - k + 2 + ... + an), then those numbers will form strictly increasing sequence.
For example, for the following sample: n = 5, k = 3, a = (1, 2, 4, 5, 6) the sequence of numbers will look as follows: (1 + 2 + 4, 2 + 4 + 5, 4 + 5 + 6) = (7, 11, 15), that means that sequence a meets the described property.
Obviously the sequence of sums will have n - k + 1 elements.
Somebody (we won't say who) replaced some numbers in Arthur's sequence by question marks (if this number is replaced, it is replaced by exactly one question mark). We need to restore the sequence so that it meets the required property and also minimize the sum |ai|, where |ai| is the absolute value of ai.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105), showing how many numbers are in Arthur's sequence and the lengths of segments respectively.
The next line contains n space-separated elements ai (1 ≤ i ≤ n).
If ai = ?, then the i-th element of Arthur's sequence was replaced by a question mark.
Otherwise, ai ( - 109 ≤ ai ≤ 109) is the i-th element of Arthur's sequence.
Output
If Arthur is wrong at some point and there is no sequence that could fit the given information, print a single string "Incorrect sequence" (without the quotes).
Otherwise, print n integers — Arthur's favorite sequence. If there are multiple such sequences, print the sequence with the minimum sum |ai|, where |ai| is the absolute value of ai. If there are still several such sequences, you are allowed to print any of them. Print the elements of the sequence without leading zeroes.
Examples
Input
3 2
? 1 2
Output
0 1 2
Input
5 1
-10 -9 ? -7 -6
Output
-10 -9 -8 -7 -6
Input
5 3
4 6 7 2 9
Output
Incorrect sequence
Submitted Solution:
```
#!/usr/bin/env python3
import sys, math
N, K = input().split(' ')
N = int(N)
K = int(K)
raw_a = input().split(' ')
a = ['?'] * N
known_idxs = set()
for i, e in enumerate(raw_a):
if e != '?':
a[i] = int(e)
known_idxs.add(i)
def fail():
print('Incorrect sequence')
sys.exit(0)
def do_fix(aa, b, c, d, e, f = 1):
assert(len(range(aa, b, c)) == len(range(d, e, f)))
a[aa:b:c] = range(d, e, f)
def fix(start, end):
l = len(range(start, end, K))
# print("fixing", a[start:end+1:K], l)
if l == 1 and a[start] == '?' and a[end] == '?':
a[start] = 0
a[end] = 1
return
a_e = float('+inf') if a[end] == '?' else a[end]
a_s = float('-inf') if a[start] == '?' else a[start]
if a_e - a_s < l:
fail()
else:
left_0 = l - a_e - 1
right_0 = -1 - a_s
opt_0 = math.floor((l - 1.1) / 2)
opt_0 = min(opt_0, right_0)
opt_0 = max(opt_0, left_0)
s = -opt_0
do_fix(start+K, end, K, s, s+l-1)
# print("done middle", a[start:end+1:K])
if a[end] == '?' and end-K >= 0:
a[end] = max(0, a[end-K] + 1)
elif a[end] == '?':
a[end] = 0
# print(":)", a[start:end+1:K])
if a[start] == '?' and start+K < N:
a[start] = min(0, a[start+K] - 1)
elif a[start] == '?':
a[start] = 0
# print("done", a[start:end+1:K])
for s in range(0, K):
sub_idxs = list(range(s, N, K))
sub_ki = [i for i in sub_idxs if i in known_idxs]
if sub_idxs[0] not in sub_ki:
sub_ki = [sub_idxs[0]] + sub_ki
if sub_idxs[-1] not in sub_ki:
sub_ki = sub_ki + [sub_idxs[-1]]
if len(sub_ki) == 1:
(i, ) = sub_ki
if a[i] == '?':
a[i] = 0
for i in range(0, len(sub_ki) - 1):
fix(sub_ki[i], sub_ki[i + 1])
print(' '.join(map(str, a)))
``` | instruction | 0 | 72,896 | 12 | 145,792 |
No | output | 1 | 72,896 | 12 | 145,793 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After bracket sequences Arthur took up number theory. He has got a new favorite sequence of length n (a1, a2, ..., an), consisting of integers and integer k, not exceeding n.
This sequence had the following property: if you write out the sums of all its segments consisting of k consecutive elements (a1 + a2 ... + ak, a2 + a3 + ... + ak + 1, ..., an - k + 1 + an - k + 2 + ... + an), then those numbers will form strictly increasing sequence.
For example, for the following sample: n = 5, k = 3, a = (1, 2, 4, 5, 6) the sequence of numbers will look as follows: (1 + 2 + 4, 2 + 4 + 5, 4 + 5 + 6) = (7, 11, 15), that means that sequence a meets the described property.
Obviously the sequence of sums will have n - k + 1 elements.
Somebody (we won't say who) replaced some numbers in Arthur's sequence by question marks (if this number is replaced, it is replaced by exactly one question mark). We need to restore the sequence so that it meets the required property and also minimize the sum |ai|, where |ai| is the absolute value of ai.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105), showing how many numbers are in Arthur's sequence and the lengths of segments respectively.
The next line contains n space-separated elements ai (1 ≤ i ≤ n).
If ai = ?, then the i-th element of Arthur's sequence was replaced by a question mark.
Otherwise, ai ( - 109 ≤ ai ≤ 109) is the i-th element of Arthur's sequence.
Output
If Arthur is wrong at some point and there is no sequence that could fit the given information, print a single string "Incorrect sequence" (without the quotes).
Otherwise, print n integers — Arthur's favorite sequence. If there are multiple such sequences, print the sequence with the minimum sum |ai|, where |ai| is the absolute value of ai. If there are still several such sequences, you are allowed to print any of them. Print the elements of the sequence without leading zeroes.
Examples
Input
3 2
? 1 2
Output
0 1 2
Input
5 1
-10 -9 ? -7 -6
Output
-10 -9 -8 -7 -6
Input
5 3
4 6 7 2 9
Output
Incorrect sequence
Submitted Solution:
```
#!/usr/bin/env python3
[n,k] = map(int,input().split())
a = input().split()
q = None
for i in range(len(a)):
if a[i] == '?':
q = i
a[i] = float('inf')
else:
a[i] = int(a[i])
ok = True
if q is not None:
l = None
u = None
if 0 <= q-k: l = a[q-k]
if q+k < len(a): u = a[q+k]
if l is None and u is None:
a[q] = 0
elif l is None:
a[q] = min(0,u-1)
elif u is None:
a[q] = max(0,l+1)
else:
if l < 0 < u:
a[q] = 0
elif l < u-1 < u < 0:
a[q] = u-1
elif 0 < l < l+1 < u:
a[q] = l+1
else:
ok = False
if ok:
for i in range(len(a)):
if i+k < len(a):
if not a[i] < a[i+k]:
ok = False
break
else:
break
if ok:
print(' '.join(map(str,a)))
else:
print("Incorrect sequence")
``` | instruction | 0 | 72,897 | 12 | 145,794 |
No | output | 1 | 72,897 | 12 | 145,795 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After bracket sequences Arthur took up number theory. He has got a new favorite sequence of length n (a1, a2, ..., an), consisting of integers and integer k, not exceeding n.
This sequence had the following property: if you write out the sums of all its segments consisting of k consecutive elements (a1 + a2 ... + ak, a2 + a3 + ... + ak + 1, ..., an - k + 1 + an - k + 2 + ... + an), then those numbers will form strictly increasing sequence.
For example, for the following sample: n = 5, k = 3, a = (1, 2, 4, 5, 6) the sequence of numbers will look as follows: (1 + 2 + 4, 2 + 4 + 5, 4 + 5 + 6) = (7, 11, 15), that means that sequence a meets the described property.
Obviously the sequence of sums will have n - k + 1 elements.
Somebody (we won't say who) replaced some numbers in Arthur's sequence by question marks (if this number is replaced, it is replaced by exactly one question mark). We need to restore the sequence so that it meets the required property and also minimize the sum |ai|, where |ai| is the absolute value of ai.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105), showing how many numbers are in Arthur's sequence and the lengths of segments respectively.
The next line contains n space-separated elements ai (1 ≤ i ≤ n).
If ai = ?, then the i-th element of Arthur's sequence was replaced by a question mark.
Otherwise, ai ( - 109 ≤ ai ≤ 109) is the i-th element of Arthur's sequence.
Output
If Arthur is wrong at some point and there is no sequence that could fit the given information, print a single string "Incorrect sequence" (without the quotes).
Otherwise, print n integers — Arthur's favorite sequence. If there are multiple such sequences, print the sequence with the minimum sum |ai|, where |ai| is the absolute value of ai. If there are still several such sequences, you are allowed to print any of them. Print the elements of the sequence without leading zeroes.
Examples
Input
3 2
? 1 2
Output
0 1 2
Input
5 1
-10 -9 ? -7 -6
Output
-10 -9 -8 -7 -6
Input
5 3
4 6 7 2 9
Output
Incorrect sequence
Submitted Solution:
```
#!/usr/bin/env python3
import sys
N, K = input().split(' ')
N = int(N)
K = int(K)
raw_a = input().split(' ')
a = ['?'] * N
known_idxs = set()
for i, e in enumerate(raw_a):
if e != '?':
a[i] = int(e)
known_idxs.add(i)
def fail():
print('Incorrect sequence')
sys.exit(0)
def do_fix(aa, b, c, d, e, f = 1):
assert(len(range(aa, b, c)) == len(range(d, e, f)))
# print(a[aa:b:c], list(range(d, e, f)))
a[aa:b:c] = range(d, e, f)
def fix(start, end):
l = len(range(start, end, K))
# print("fixing", a[start:end+1:K], l)
if l == 1 and a[start] == '?' and a[end] == '?':
a[start] = 0
a[end] = 1
return
a_e = float('+inf') if a[end] == '?' else a[end]
a_s = float('-inf') if a[start] == '?' else a[start]
if a_e - a_s < l:
fail()
else:
left_0 = l - a_e - 1
right_0 = -1 - a_s
opt_0 = (l - 1) // 2
opt_0 = min(opt_0, right_0)
opt_0 = max(opt_0, left_0)
s = -opt_0
do_fix(start+K, end, K, s, s+l-1)
# print("done middle", a[start:end+1:K])
if a[end] == '?' and end-K >= 0:
a[end] = max(0, a[end-K] + 1)
elif a[end] == '?':
a[end] = 0
# print(":)", a[start:end+1:K])
if a[start] == '?' and start+K < N:
a[start] = min(0, a[start+K] - 1)
elif a[start] == '?':
a[start] = 0
# print("done", a[start:end+1:K])
for s in range(0, K):
sub_idxs = list(range(s, N, K))
sub_ki = [i for i in sub_idxs if i in known_idxs]
if sub_idxs[0] not in sub_ki:
sub_ki = [sub_idxs[0]] + sub_ki
if sub_idxs[-1] not in sub_ki:
sub_ki = sub_ki + [sub_idxs[-1]]
if len(sub_ki) == 1:
(i, ) = sub_ki
if a[i] == '?':
a[i] = 0
for i in range(0, len(sub_ki) - 1):
fix(sub_ki[i], sub_ki[i + 1])
print(' '.join(map(str, a)))
``` | instruction | 0 | 72,898 | 12 | 145,796 |
No | output | 1 | 72,898 | 12 | 145,797 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got array A, consisting of n integers and a positive integer k. Array A is indexed by integers from 1 to n.
You need to permute the array elements so that value
<image> became minimal possible. In particular, it is allowed not to change order of elements at all.
Input
The first line contains two integers n, k (2 ≤ n ≤ 3·105, 1 ≤ k ≤ min(5000, n - 1)).
The second line contains n integers A[1], A[2], ..., A[n] ( - 109 ≤ A[i] ≤ 109), separate by spaces — elements of the array A.
Output
Print the minimum possible value of the sum described in the statement.
Examples
Input
3 2
1 2 4
Output
1
Input
5 2
3 -5 3 -5 3
Output
0
Input
6 3
4 3 4 3 2 5
Output
3
Note
In the first test one of the optimal permutations is 1 4 2.
In the second test the initial order is optimal.
In the third test one of the optimal permutations is 2 3 4 4 3 5. | instruction | 0 | 72,904 | 12 | 145,808 |
Tags: dp, greedy, sortings
Correct Solution:
```
def solve(n, k, As):
As.sort()
m, r = divmod(n, k)
dp = [0] * (r + 1)
for i in range(1, k):
im = i * m
new_dp = [0] * (r + 1)
new_dp[0] = dp[0] + As[im] - As[im - 1]
for h in range(1, min(i, r) + 1):
new_dp[h] = max(dp[h], dp[h - 1]) + As[im + h] - As[im + h - 1]
dp = new_dp
return As[-1] - As[0] - max(dp[r], dp[r-1])
n, k = map(int, input().split())
As = list(map(int, input().split()))
print(solve(n, k, As))
``` | output | 1 | 72,904 | 12 | 145,809 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got array A, consisting of n integers and a positive integer k. Array A is indexed by integers from 1 to n.
You need to permute the array elements so that value
<image> became minimal possible. In particular, it is allowed not to change order of elements at all.
Input
The first line contains two integers n, k (2 ≤ n ≤ 3·105, 1 ≤ k ≤ min(5000, n - 1)).
The second line contains n integers A[1], A[2], ..., A[n] ( - 109 ≤ A[i] ≤ 109), separate by spaces — elements of the array A.
Output
Print the minimum possible value of the sum described in the statement.
Examples
Input
3 2
1 2 4
Output
1
Input
5 2
3 -5 3 -5 3
Output
0
Input
6 3
4 3 4 3 2 5
Output
3
Note
In the first test one of the optimal permutations is 1 4 2.
In the second test the initial order is optimal.
In the third test one of the optimal permutations is 2 3 4 4 3 5. | instruction | 0 | 72,905 | 12 | 145,810 |
Tags: dp, greedy, sortings
Correct Solution:
```
f = lambda: map(int, input().split())
n, k = f()
p = sorted(f())
m, d = n // k, n % k
u, v = d + 1, k - d + 1
g = [0] * u * v
i = 0
for a in range(u):
j = a * m + a - 1
for b in range(v):
x = g[i - 1] + p[j] - p[j - m + 1] if b else 9e9
y = g[i - v] + p[j] - p[j - m] if a else 9e9
if i: g[i] = min(x, y)
i += 1
j += m
print(g[-1])
``` | output | 1 | 72,905 | 12 | 145,811 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got array A, consisting of n integers and a positive integer k. Array A is indexed by integers from 1 to n.
You need to permute the array elements so that value
<image> became minimal possible. In particular, it is allowed not to change order of elements at all.
Input
The first line contains two integers n, k (2 ≤ n ≤ 3·105, 1 ≤ k ≤ min(5000, n - 1)).
The second line contains n integers A[1], A[2], ..., A[n] ( - 109 ≤ A[i] ≤ 109), separate by spaces — elements of the array A.
Output
Print the minimum possible value of the sum described in the statement.
Examples
Input
3 2
1 2 4
Output
1
Input
5 2
3 -5 3 -5 3
Output
0
Input
6 3
4 3 4 3 2 5
Output
3
Note
In the first test one of the optimal permutations is 1 4 2.
In the second test the initial order is optimal.
In the third test one of the optimal permutations is 2 3 4 4 3 5. | instruction | 0 | 72,906 | 12 | 145,812 |
Tags: dp, greedy, sortings
Correct Solution:
```
inf = 10 ** 10
n, k = map(int, input().split())
a = sorted(map(int, input().split()))
L, M = n // k, n % k
dp = [[0] * (k - M + 1) for i in range(M + 1)]
for i in range(M + 1):
for j in range(k - M + 1):
pos = i * (L + 1) + j * L
dp[i][j] = min((dp[i - 1][j] + a[pos - 1] - a[pos - L - 1] if i else inf), \
(dp[i][j - 1] + a[pos - 1] - a[pos - L] if j else inf)) if (i or j) else 0
print(dp[M][k - M])
``` | output | 1 | 72,906 | 12 | 145,813 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got array A, consisting of n integers and a positive integer k. Array A is indexed by integers from 1 to n.
You need to permute the array elements so that value
<image> became minimal possible. In particular, it is allowed not to change order of elements at all.
Input
The first line contains two integers n, k (2 ≤ n ≤ 3·105, 1 ≤ k ≤ min(5000, n - 1)).
The second line contains n integers A[1], A[2], ..., A[n] ( - 109 ≤ A[i] ≤ 109), separate by spaces — elements of the array A.
Output
Print the minimum possible value of the sum described in the statement.
Examples
Input
3 2
1 2 4
Output
1
Input
5 2
3 -5 3 -5 3
Output
0
Input
6 3
4 3 4 3 2 5
Output
3
Note
In the first test one of the optimal permutations is 1 4 2.
In the second test the initial order is optimal.
In the third test one of the optimal permutations is 2 3 4 4 3 5. | instruction | 0 | 72,907 | 12 | 145,814 |
Tags: dp, greedy, sortings
Correct Solution:
```
INF = 10 ** 18 + 179
[n, k], a = [list(map(int, input().split())) for x in range(2)]
a.sort()
dp, l = [[0] * (k - n % k + 1) for x in range(n % k + 1)], n // k
for i in range(n % k + 1):
for j in range(k - n % k + 1):
pos = i * (l + 1) + j * l
dp[i][j] = min((dp[i - 1][j] + a[pos - 1] - a[pos - l - 1] if i else INF), \
(dp[i][j - 1] + a[pos - 1] - a[pos - l] if j else INF)) if (i or j) else 0
print(dp[n % k][k - n % k])
``` | output | 1 | 72,907 | 12 | 145,815 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got array A, consisting of n integers and a positive integer k. Array A is indexed by integers from 1 to n.
You need to permute the array elements so that value
<image> became minimal possible. In particular, it is allowed not to change order of elements at all.
Input
The first line contains two integers n, k (2 ≤ n ≤ 3·105, 1 ≤ k ≤ min(5000, n - 1)).
The second line contains n integers A[1], A[2], ..., A[n] ( - 109 ≤ A[i] ≤ 109), separate by spaces — elements of the array A.
Output
Print the minimum possible value of the sum described in the statement.
Examples
Input
3 2
1 2 4
Output
1
Input
5 2
3 -5 3 -5 3
Output
0
Input
6 3
4 3 4 3 2 5
Output
3
Note
In the first test one of the optimal permutations is 1 4 2.
In the second test the initial order is optimal.
In the third test one of the optimal permutations is 2 3 4 4 3 5.
Submitted 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,k=map(int,input().split())
l=list(map(int,input().split()))
l.sort()
gap=[]
for i in range(k):
t=i
c=0
while(t<n):
c+=1
t+=k
gap.append(c)
ans=0
cur=0
t=gap[cur]
open=l[0]
for i in range(n):
t-=1
if t==0:
ans+=l[i]-open
cur+=1
if cur<len(gap):
t=gap[cur]
if i+1<n:
open=l[i+1]
gap.reverse()
ans1=0
cur=0
t=gap[cur]
open=l[0]
for i in range(n):
t-=1
if t==0:
ans1+=l[i]-open
cur+=1
if cur<len(gap):
t=gap[cur]
if i+1<n:
open=l[i+1]
print(min(ans1,ans))
``` | instruction | 0 | 72,908 | 12 | 145,816 |
No | output | 1 | 72,908 | 12 | 145,817 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got array A, consisting of n integers and a positive integer k. Array A is indexed by integers from 1 to n.
You need to permute the array elements so that value
<image> became minimal possible. In particular, it is allowed not to change order of elements at all.
Input
The first line contains two integers n, k (2 ≤ n ≤ 3·105, 1 ≤ k ≤ min(5000, n - 1)).
The second line contains n integers A[1], A[2], ..., A[n] ( - 109 ≤ A[i] ≤ 109), separate by spaces — elements of the array A.
Output
Print the minimum possible value of the sum described in the statement.
Examples
Input
3 2
1 2 4
Output
1
Input
5 2
3 -5 3 -5 3
Output
0
Input
6 3
4 3 4 3 2 5
Output
3
Note
In the first test one of the optimal permutations is 1 4 2.
In the second test the initial order is optimal.
In the third test one of the optimal permutations is 2 3 4 4 3 5.
Submitted 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,k=map(int,input().split())
l=list(map(int,input().split()))
l.sort()
gap=[]
for i in range(k):
t=i
c=0
while(t<n):
c+=1
t+=k
gap.append(c)
ans=0
cur=0
t=gap[cur]
open=l[0]
for i in range(n):
t-=1
if t==0:
ans+=l[i]-open
cur+=1
if cur<len(gap):
t=gap[cur]
if i+1<n:
open=l[i+1]
gap.reverse()
ans1=0
cur=0
t=gap[cur]
open=l[0]
for i in range(n):
t-=1
if t==0:
ans1+=l[i]-open
cur+=1
if cur<len(gap):
t=gap[cur]
if i+1<n:
open=l[i+1]
l.reverse()
ans2=0
cur=0
t=gap[cur]
open=l[0]
for i in range(n):
t-=1
if t==0:
ans2+=abs(l[i]-open)
cur+=1
if cur<len(gap):
t=gap[cur]
if i+1<n:
open=l[i+1]
gap.reverse()
ans3=0
cur=0
t=gap[cur]
open=l[0]
for i in range(n):
t-=1
if t==0:
ans3+=abs(l[i]-open)
cur+=1
if cur<len(gap):
t=gap[cur]
if i+1<n:
open=l[i+1]
print(min(ans,ans1,ans2,ans3))
``` | instruction | 0 | 72,909 | 12 | 145,818 |
No | output | 1 | 72,909 | 12 | 145,819 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got array A, consisting of n integers and a positive integer k. Array A is indexed by integers from 1 to n.
You need to permute the array elements so that value
<image> became minimal possible. In particular, it is allowed not to change order of elements at all.
Input
The first line contains two integers n, k (2 ≤ n ≤ 3·105, 1 ≤ k ≤ min(5000, n - 1)).
The second line contains n integers A[1], A[2], ..., A[n] ( - 109 ≤ A[i] ≤ 109), separate by spaces — elements of the array A.
Output
Print the minimum possible value of the sum described in the statement.
Examples
Input
3 2
1 2 4
Output
1
Input
5 2
3 -5 3 -5 3
Output
0
Input
6 3
4 3 4 3 2 5
Output
3
Note
In the first test one of the optimal permutations is 1 4 2.
In the second test the initial order is optimal.
In the third test one of the optimal permutations is 2 3 4 4 3 5.
Submitted Solution:
```
def comp(tab, n, k):
s = 0
for i in range(n - k):
s += abs(tab[i] - tab[i + k])
return s
def indices(n, k):
used = set()
for i in range(n):
if i not in used:
yield i
used.add(i)
if i + k not in used:
yield i + k
used.add(i + k)
n, k = map(int, input().split())
a = sorted([int(x) for x in input().split()])
r = [0] * n
m = None
for c in range(k):
j = 0
for i in indices(n, k):
if j >= n:
break
r[(i + c) % n] = a[j]
j += 1
res = comp(r, n, k)
if m is None or m > res:
m = res
print(m)
``` | instruction | 0 | 72,910 | 12 | 145,820 |
No | output | 1 | 72,910 | 12 | 145,821 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got array A, consisting of n integers and a positive integer k. Array A is indexed by integers from 1 to n.
You need to permute the array elements so that value
<image> became minimal possible. In particular, it is allowed not to change order of elements at all.
Input
The first line contains two integers n, k (2 ≤ n ≤ 3·105, 1 ≤ k ≤ min(5000, n - 1)).
The second line contains n integers A[1], A[2], ..., A[n] ( - 109 ≤ A[i] ≤ 109), separate by spaces — elements of the array A.
Output
Print the minimum possible value of the sum described in the statement.
Examples
Input
3 2
1 2 4
Output
1
Input
5 2
3 -5 3 -5 3
Output
0
Input
6 3
4 3 4 3 2 5
Output
3
Note
In the first test one of the optimal permutations is 1 4 2.
In the second test the initial order is optimal.
In the third test one of the optimal permutations is 2 3 4 4 3 5.
Submitted 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,k=map(int,input().split())
l=list(map(int,input().split()))
l.sort()
gap=[]
for i in range(k):
t=i
c=0
while(t<n):
c+=1
t+=k
gap.append(c)
ans=0
cur=0
t=gap[cur]
open=l[0]
for i in range(n):
t-=1
if t==0:
ans+=l[i]-open
cur+=1
if cur<len(gap):
t=gap[cur]
if i+1<n:
open=l[i+1]
gap.reverse()
ans1=0
cur=0
t=gap[cur]
open=l[0]
for i in range(n):
t-=1
if t==0:
ans1+=l[i]-open
cur+=1
if cur<len(gap):
t=gap[cur]
if i+1<n:
open=l[i+1]
l.reverse()
ans2=0
cur=0
t=gap[cur]
open=l[0]
for i in range(n):
t-=1
if t==0:
ans2+=l[i]-open
cur+=1
if cur<len(gap):
t=gap[cur]
if i+1<n:
open=l[i+1]
gap.reverse()
ans3=0
cur=0
t=gap[cur]
open=l[0]
for i in range(n):
t-=1
if t==0:
ans3+=l[i]-open
cur+=1
if cur<len(gap):
t=gap[cur]
if i+1<n:
open=l[i+1]
print(min(ans,ans1,ans2,ans3))
``` | instruction | 0 | 72,911 | 12 | 145,822 |
No | output | 1 | 72,911 | 12 | 145,823 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Yash is finally tired of computing the length of the longest Fibonacci-ish sequence. He now plays around with more complex things such as Fibonacci-ish potentials.
Fibonacci-ish potential of an array ai is computed as follows:
1. Remove all elements j if there exists i < j such that ai = aj.
2. Sort the remaining elements in ascending order, i.e. a1 < a2 < ... < an.
3. Compute the potential as P(a) = a1·F1 + a2·F2 + ... + an·Fn, where Fi is the i-th Fibonacci number (see notes for clarification).
You are given an array ai of length n and q ranges from lj to rj. For each range j you have to compute the Fibonacci-ish potential of the array bi, composed using all elements of ai from lj to rj inclusive. Find these potentials modulo m.
Input
The first line of the input contains integers of n and m (1 ≤ n, m ≤ 30 000) — the length of the initial array and the modulo, respectively.
The next line contains n integers ai (0 ≤ ai ≤ 109) — elements of the array.
Then follow the number of ranges q (1 ≤ q ≤ 30 000).
Last q lines contain pairs of indices li and ri (1 ≤ li ≤ ri ≤ n) — ranges to compute Fibonacci-ish potentials.
Output
Print q lines, i-th of them must contain the Fibonacci-ish potential of the i-th range modulo m.
Example
Input
5 10
2 1 2 1 2
2
2 4
4 5
Output
3
3
Note
For the purpose of this problem define Fibonacci numbers as follows:
1. F1 = F2 = 1.
2. Fn = Fn - 1 + Fn - 2 for each n > 2.
In the first query, the subarray [1,2,1] can be formed using the minimal set {1,2}. Thus, the potential of this subarray is 1*1+2*1=3.
Submitted Solution:
```
import os
import math
import time
import re
fib = [0,1]
for i in range(2,30005):
fib.append(fib[i-1]+fib[i-2])
[n,m] = [int(x) for x in input().split(' ')]
a = [int(x) for x in input().split(' ')]
q = int(input())
for mj in range(q):
[l,r]=[int(x) for x in input().split(' ')]
b = a[l-1:r]
res = 0
b = list(set(b))
for j in range(len(b)):
res+=b[j]*fib[j+1]
res%=m
print(res)
``` | instruction | 0 | 72,933 | 12 | 145,866 |
No | output | 1 | 72,933 | 12 | 145,867 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Yash is finally tired of computing the length of the longest Fibonacci-ish sequence. He now plays around with more complex things such as Fibonacci-ish potentials.
Fibonacci-ish potential of an array ai is computed as follows:
1. Remove all elements j if there exists i < j such that ai = aj.
2. Sort the remaining elements in ascending order, i.e. a1 < a2 < ... < an.
3. Compute the potential as P(a) = a1·F1 + a2·F2 + ... + an·Fn, where Fi is the i-th Fibonacci number (see notes for clarification).
You are given an array ai of length n and q ranges from lj to rj. For each range j you have to compute the Fibonacci-ish potential of the array bi, composed using all elements of ai from lj to rj inclusive. Find these potentials modulo m.
Input
The first line of the input contains integers of n and m (1 ≤ n, m ≤ 30 000) — the length of the initial array and the modulo, respectively.
The next line contains n integers ai (0 ≤ ai ≤ 109) — elements of the array.
Then follow the number of ranges q (1 ≤ q ≤ 30 000).
Last q lines contain pairs of indices li and ri (1 ≤ li ≤ ri ≤ n) — ranges to compute Fibonacci-ish potentials.
Output
Print q lines, i-th of them must contain the Fibonacci-ish potential of the i-th range modulo m.
Example
Input
5 10
2 1 2 1 2
2
2 4
4 5
Output
3
3
Note
For the purpose of this problem define Fibonacci numbers as follows:
1. F1 = F2 = 1.
2. Fn = Fn - 1 + Fn - 2 for each n > 2.
In the first query, the subarray [1,2,1] can be formed using the minimal set {1,2}. Thus, the potential of this subarray is 1*1+2*1=3.
Submitted Solution:
```
fibonacci = [1, 1]
mx = int(1e8)
n, m = map(int, input().split())
for i in range(n-2):
fibonacci.append(fibonacci[-1]+fibonacci[-2])
fibonacci[-1]%=m
inp = [(val, i+1) for i , val in enumerate(map(int, input().split()))]
inp.sort()
exit()
q = int(input())
for _ in range(q):
l, r = map(int, input().split())
last = -1
tot = 0
cc = 0
for val, i in inp:
if val == last:continue
if i < l or i > r: continue
if tot > mx:tot %= m
last = val
tot += val*fibonacci[cc]
cc+=1
tot %= m
print(tot)
``` | instruction | 0 | 72,934 | 12 | 145,868 |
No | output | 1 | 72,934 | 12 | 145,869 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a table consisting of n rows and m columns. Each cell of the table contains either 0 or 1. In one move, you are allowed to pick any row or any column and invert all values, that is, replace 0 by 1 and vice versa.
What is the minimum number of cells with value 1 you can get after applying some number of operations?
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 20, 1 ≤ m ≤ 100 000) — the number of rows and the number of columns, respectively.
Then n lines follows with the descriptions of the rows. Each line has length m and contains only digits '0' and '1'.
Output
Output a single integer — the minimum possible number of ones you can get after applying some sequence of operations.
Example
Input
3 4
0110
1010
0111
Output
2
Submitted Solution:
```
l = input().split()
n = int(l[0])
m = int(l[1])
lines = [[int(x) for x in input()] for i in range(n)]
d = 0
for i in range(n):
reversible = True
for j in range(m):
if lines[i][j] != 1:
reversible = False
break
if reversible:
for j in range(m):
lines[i][j] = 0
for j in range(m):
reversible = True
for i in range(n):
if lines[i][j] != 1:
reversible = False
break
if reversible:
for i in range(n):
lines[i][j] = 0
for i in range(n):
a = 0
for j in range(m):
a += lines[i][j]
if a > d:
d = a
for j in range(m):
a = 0
for i in range(n):
a += lines[i][j]
if a > d:
d = a
print(d)
``` | instruction | 0 | 72,935 | 12 | 145,870 |
No | output | 1 | 72,935 | 12 | 145,871 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a permutation p_1,p_2,...,p_N consisting of 1,2,..,N. You can perform the following operation any number of times (possibly zero):
Operation: Swap two adjacent elements in the permutation.
You want to have p_i ≠ i for all 1≤i≤N. Find the minimum required number of operations to achieve this.
Constraints
* 2≤N≤10^5
* p_1,p_2,..,p_N is a permutation of 1,2,..,N.
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 .. p_N
Output
Print the minimum required number of operations
Examples
Input
5
1 4 3 5 2
Output
2
Input
2
1 2
Output
1
Input
2
2 1
Output
0
Input
9
1 2 4 9 5 8 7 3 6
Output
3 | instruction | 0 | 73,167 | 12 | 146,334 |
"Correct Solution:
```
n=int(input())
p=[int(i) for i in input().split()]
cnt=0
for i in range(n-1):
if p[i]==i+1:
p[i],p[i+1]=p[i+1],p[i]
cnt+=1
if p[-1]==n:cnt+=1
print(cnt)
``` | output | 1 | 73,167 | 12 | 146,335 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a permutation p_1,p_2,...,p_N consisting of 1,2,..,N. You can perform the following operation any number of times (possibly zero):
Operation: Swap two adjacent elements in the permutation.
You want to have p_i ≠ i for all 1≤i≤N. Find the minimum required number of operations to achieve this.
Constraints
* 2≤N≤10^5
* p_1,p_2,..,p_N is a permutation of 1,2,..,N.
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 .. p_N
Output
Print the minimum required number of operations
Examples
Input
5
1 4 3 5 2
Output
2
Input
2
1 2
Output
1
Input
2
2 1
Output
0
Input
9
1 2 4 9 5 8 7 3 6
Output
3 | instruction | 0 | 73,168 | 12 | 146,336 |
"Correct Solution:
```
N=int(input())
k=0
s=0
m=0
L=list(map(int,input().split()))
for i in range(N):
if L[i]==i+1:
m+=1
else:
s+=m//2+m%2
m=0
s+=m//2+m%2
print(s)
``` | output | 1 | 73,168 | 12 | 146,337 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a permutation p_1,p_2,...,p_N consisting of 1,2,..,N. You can perform the following operation any number of times (possibly zero):
Operation: Swap two adjacent elements in the permutation.
You want to have p_i ≠ i for all 1≤i≤N. Find the minimum required number of operations to achieve this.
Constraints
* 2≤N≤10^5
* p_1,p_2,..,p_N is a permutation of 1,2,..,N.
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 .. p_N
Output
Print the minimum required number of operations
Examples
Input
5
1 4 3 5 2
Output
2
Input
2
1 2
Output
1
Input
2
2 1
Output
0
Input
9
1 2 4 9 5 8 7 3 6
Output
3 | instruction | 0 | 73,169 | 12 | 146,338 |
"Correct Solution:
```
n=int(input())
p=list(map(int,input().split()))
c=0
def swap(i):
global c
t=p[i+1]
p[i+1]=p[i]
p[i]=t
c+=1
for i in range(n-1):
if p[i]==i+1:swap(i)
print(c+(p[n-1]==n))
``` | output | 1 | 73,169 | 12 | 146,339 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a permutation p_1,p_2,...,p_N consisting of 1,2,..,N. You can perform the following operation any number of times (possibly zero):
Operation: Swap two adjacent elements in the permutation.
You want to have p_i ≠ i for all 1≤i≤N. Find the minimum required number of operations to achieve this.
Constraints
* 2≤N≤10^5
* p_1,p_2,..,p_N is a permutation of 1,2,..,N.
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 .. p_N
Output
Print the minimum required number of operations
Examples
Input
5
1 4 3 5 2
Output
2
Input
2
1 2
Output
1
Input
2
2 1
Output
0
Input
9
1 2 4 9 5 8 7 3 6
Output
3 | instruction | 0 | 73,170 | 12 | 146,340 |
"Correct Solution:
```
N = int(input())
P = list(map(lambda p: int(p) - 1, input().split()))
i, ans = 0, 0
while i < N:
if P[i] == i:
ans += 1
i += 1
i += 1
print(ans)
``` | output | 1 | 73,170 | 12 | 146,341 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a permutation p_1,p_2,...,p_N consisting of 1,2,..,N. You can perform the following operation any number of times (possibly zero):
Operation: Swap two adjacent elements in the permutation.
You want to have p_i ≠ i for all 1≤i≤N. Find the minimum required number of operations to achieve this.
Constraints
* 2≤N≤10^5
* p_1,p_2,..,p_N is a permutation of 1,2,..,N.
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 .. p_N
Output
Print the minimum required number of operations
Examples
Input
5
1 4 3 5 2
Output
2
Input
2
1 2
Output
1
Input
2
2 1
Output
0
Input
9
1 2 4 9 5 8 7 3 6
Output
3 | instruction | 0 | 73,171 | 12 | 146,342 |
"Correct Solution:
```
N = int(input())
P = list(map(int, input().split()))
i, count = 0, 0
while i < N:
#print(i, i + 1, P[i])
if i + 1 == P[i]:
count += 1
i += 2
else:
i += 1
print(count)
``` | output | 1 | 73,171 | 12 | 146,343 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a permutation p_1,p_2,...,p_N consisting of 1,2,..,N. You can perform the following operation any number of times (possibly zero):
Operation: Swap two adjacent elements in the permutation.
You want to have p_i ≠ i for all 1≤i≤N. Find the minimum required number of operations to achieve this.
Constraints
* 2≤N≤10^5
* p_1,p_2,..,p_N is a permutation of 1,2,..,N.
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 .. p_N
Output
Print the minimum required number of operations
Examples
Input
5
1 4 3 5 2
Output
2
Input
2
1 2
Output
1
Input
2
2 1
Output
0
Input
9
1 2 4 9 5 8 7 3 6
Output
3 | instruction | 0 | 73,172 | 12 | 146,344 |
"Correct Solution:
```
n = int(input())
p = list(map(int, input().split()))
ans = 0
i = 0
while i<n:
if p[i]==i+1:
ans += 1
i += 1
i += 1
print(ans)
``` | output | 1 | 73,172 | 12 | 146,345 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a permutation p_1,p_2,...,p_N consisting of 1,2,..,N. You can perform the following operation any number of times (possibly zero):
Operation: Swap two adjacent elements in the permutation.
You want to have p_i ≠ i for all 1≤i≤N. Find the minimum required number of operations to achieve this.
Constraints
* 2≤N≤10^5
* p_1,p_2,..,p_N is a permutation of 1,2,..,N.
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 .. p_N
Output
Print the minimum required number of operations
Examples
Input
5
1 4 3 5 2
Output
2
Input
2
1 2
Output
1
Input
2
2 1
Output
0
Input
9
1 2 4 9 5 8 7 3 6
Output
3 | instruction | 0 | 73,173 | 12 | 146,346 |
"Correct Solution:
```
n=int(input())
p=list(map(int,input().split()))
r=p[:]
ans=0
for i in range(n):
if p[i]==i+1:
ans+=1
if i!=n-1:
p[i]=r[i+1]
p[i+1]=r[i]
print(ans)
``` | output | 1 | 73,173 | 12 | 146,347 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a permutation p_1,p_2,...,p_N consisting of 1,2,..,N. You can perform the following operation any number of times (possibly zero):
Operation: Swap two adjacent elements in the permutation.
You want to have p_i ≠ i for all 1≤i≤N. Find the minimum required number of operations to achieve this.
Constraints
* 2≤N≤10^5
* p_1,p_2,..,p_N is a permutation of 1,2,..,N.
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 .. p_N
Output
Print the minimum required number of operations
Examples
Input
5
1 4 3 5 2
Output
2
Input
2
1 2
Output
1
Input
2
2 1
Output
0
Input
9
1 2 4 9 5 8 7 3 6
Output
3 | instruction | 0 | 73,174 | 12 | 146,348 |
"Correct Solution:
```
N=int(input())
P=[int(x)-1 for x in input().split()]
T=[0]*N
for i in range(N):
if P[i]==i:
T[i]=1
for i in range(1,N):
if T[i]==T[i-1]==1:
T[i]=0
print(sum(T))
``` | output | 1 | 73,174 | 12 | 146,349 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p_1,p_2,...,p_N consisting of 1,2,..,N. You can perform the following operation any number of times (possibly zero):
Operation: Swap two adjacent elements in the permutation.
You want to have p_i ≠ i for all 1≤i≤N. Find the minimum required number of operations to achieve this.
Constraints
* 2≤N≤10^5
* p_1,p_2,..,p_N is a permutation of 1,2,..,N.
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 .. p_N
Output
Print the minimum required number of operations
Examples
Input
5
1 4 3 5 2
Output
2
Input
2
1 2
Output
1
Input
2
2 1
Output
0
Input
9
1 2 4 9 5 8 7 3 6
Output
3
Submitted Solution:
```
n=int(input())
p=list(map(int,input().split()))
cnt=0
i=0
for i in range(n):
if p[i]==i+1:
if i!=n-1:
p[i+1]=p[i]
cnt+=1
else:
cnt+=1
print(cnt)
``` | instruction | 0 | 73,175 | 12 | 146,350 |
Yes | output | 1 | 73,175 | 12 | 146,351 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p_1,p_2,...,p_N consisting of 1,2,..,N. You can perform the following operation any number of times (possibly zero):
Operation: Swap two adjacent elements in the permutation.
You want to have p_i ≠ i for all 1≤i≤N. Find the minimum required number of operations to achieve this.
Constraints
* 2≤N≤10^5
* p_1,p_2,..,p_N is a permutation of 1,2,..,N.
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 .. p_N
Output
Print the minimum required number of operations
Examples
Input
5
1 4 3 5 2
Output
2
Input
2
1 2
Output
1
Input
2
2 1
Output
0
Input
9
1 2 4 9 5 8 7 3 6
Output
3
Submitted Solution:
```
N = int(input())
P = list(map(int, input().split()))
cnt = 0
i = 0
while i < N:
if i+1 == P[i]:
i += 2
cnt += 1
else:
i += 1
print(cnt)
``` | instruction | 0 | 73,176 | 12 | 146,352 |
Yes | output | 1 | 73,176 | 12 | 146,353 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p_1,p_2,...,p_N consisting of 1,2,..,N. You can perform the following operation any number of times (possibly zero):
Operation: Swap two adjacent elements in the permutation.
You want to have p_i ≠ i for all 1≤i≤N. Find the minimum required number of operations to achieve this.
Constraints
* 2≤N≤10^5
* p_1,p_2,..,p_N is a permutation of 1,2,..,N.
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 .. p_N
Output
Print the minimum required number of operations
Examples
Input
5
1 4 3 5 2
Output
2
Input
2
1 2
Output
1
Input
2
2 1
Output
0
Input
9
1 2 4 9 5 8 7 3 6
Output
3
Submitted Solution:
```
N=int(input())
*P,=map(int,input().split())
i=0
ans=0
while i<N:
if i+1==P[i]:
i+=1
ans+=1
i+=1
print(ans)
``` | instruction | 0 | 73,177 | 12 | 146,354 |
Yes | output | 1 | 73,177 | 12 | 146,355 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p_1,p_2,...,p_N consisting of 1,2,..,N. You can perform the following operation any number of times (possibly zero):
Operation: Swap two adjacent elements in the permutation.
You want to have p_i ≠ i for all 1≤i≤N. Find the minimum required number of operations to achieve this.
Constraints
* 2≤N≤10^5
* p_1,p_2,..,p_N is a permutation of 1,2,..,N.
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 .. p_N
Output
Print the minimum required number of operations
Examples
Input
5
1 4 3 5 2
Output
2
Input
2
1 2
Output
1
Input
2
2 1
Output
0
Input
9
1 2 4 9 5 8 7 3 6
Output
3
Submitted Solution:
```
n = int(input())
p = list(map(int, input().split()))
i, ans = 0, 0
while i < n:
if p[i] == i + 1:
i += 1
ans += 1
i += 1
print(ans)
``` | instruction | 0 | 73,178 | 12 | 146,356 |
Yes | output | 1 | 73,178 | 12 | 146,357 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p_1,p_2,...,p_N consisting of 1,2,..,N. You can perform the following operation any number of times (possibly zero):
Operation: Swap two adjacent elements in the permutation.
You want to have p_i ≠ i for all 1≤i≤N. Find the minimum required number of operations to achieve this.
Constraints
* 2≤N≤10^5
* p_1,p_2,..,p_N is a permutation of 1,2,..,N.
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 .. p_N
Output
Print the minimum required number of operations
Examples
Input
5
1 4 3 5 2
Output
2
Input
2
1 2
Output
1
Input
2
2 1
Output
0
Input
9
1 2 4 9 5 8 7 3 6
Output
3
Submitted Solution:
```
import bisect,copy,heapq,itertools,string
from collections import *
from math import *
import sys
def input() : return sys.stdin.readline().strip()
def INT() : return int(input())
def MAP() : return map(int,input().split())
def LIST() : return list(MAP())
n = INT()
s = LIST()
count = 0
for i in range(n):
if s[i] == i+1:
if i > 0 and s[i-1] == i:
continue
else:
count += 1
print(count)
``` | instruction | 0 | 73,179 | 12 | 146,358 |
No | output | 1 | 73,179 | 12 | 146,359 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p_1,p_2,...,p_N consisting of 1,2,..,N. You can perform the following operation any number of times (possibly zero):
Operation: Swap two adjacent elements in the permutation.
You want to have p_i ≠ i for all 1≤i≤N. Find the minimum required number of operations to achieve this.
Constraints
* 2≤N≤10^5
* p_1,p_2,..,p_N is a permutation of 1,2,..,N.
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 .. p_N
Output
Print the minimum required number of operations
Examples
Input
5
1 4 3 5 2
Output
2
Input
2
1 2
Output
1
Input
2
2 1
Output
0
Input
9
1 2 4 9 5 8 7 3 6
Output
3
Submitted Solution:
```
N = int(input())
P = [int(i) for i in input().split()]
ans = 0
flag = 0
for i in range(N):
if i+1 == P[i]:
ans += 1
if flag:
ans -= 1
flag = 1
else:
flag = 0
print(ans)
``` | instruction | 0 | 73,180 | 12 | 146,360 |
No | output | 1 | 73,180 | 12 | 146,361 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p_1,p_2,...,p_N consisting of 1,2,..,N. You can perform the following operation any number of times (possibly zero):
Operation: Swap two adjacent elements in the permutation.
You want to have p_i ≠ i for all 1≤i≤N. Find the minimum required number of operations to achieve this.
Constraints
* 2≤N≤10^5
* p_1,p_2,..,p_N is a permutation of 1,2,..,N.
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 .. p_N
Output
Print the minimum required number of operations
Examples
Input
5
1 4 3 5 2
Output
2
Input
2
1 2
Output
1
Input
2
2 1
Output
0
Input
9
1 2 4 9 5 8 7 3 6
Output
3
Submitted Solution:
```
N = int(input())
P = [int(x) for x in input().split()]
ans = 0
for i in range(N-1):
if P[i] == i+1:
temp = P[i]
P[i] = P[i+1]
P[i+1] = P[i]
ans += 1
print(ans)
``` | instruction | 0 | 73,181 | 12 | 146,362 |
No | output | 1 | 73,181 | 12 | 146,363 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p_1,p_2,...,p_N consisting of 1,2,..,N. You can perform the following operation any number of times (possibly zero):
Operation: Swap two adjacent elements in the permutation.
You want to have p_i ≠ i for all 1≤i≤N. Find the minimum required number of operations to achieve this.
Constraints
* 2≤N≤10^5
* p_1,p_2,..,p_N is a permutation of 1,2,..,N.
Input
The input is given from Standard Input in the following format:
N
p_1 p_2 .. p_N
Output
Print the minimum required number of operations
Examples
Input
5
1 4 3 5 2
Output
2
Input
2
1 2
Output
1
Input
2
2 1
Output
0
Input
9
1 2 4 9 5 8 7 3 6
Output
3
Submitted Solution:
```
N = int(input())
A = list(map(int, input().split()))
cnt = 0
for i, a in enumerate(A, 1):
if a == i:
x = a[i - 1]
y = a[i]
a[i - 1] = y
a[i] = x
cnt += 1
print(cnt)
``` | instruction | 0 | 73,182 | 12 | 146,364 |
No | output | 1 | 73,182 | 12 | 146,365 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation of length k is a sequence of k integers from 1 to k containing each integer exactly once. For example, the sequence [3, 1, 2] is a permutation of length 3.
When Neko was five, he thought of an array a of n positive integers and a permutation p of length n - 1. Then, he performed the following:
* Constructed an array b of length n-1, where b_i = min(a_i, a_{i+1}).
* Constructed an array c of length n-1, where c_i = max(a_i, a_{i+1}).
* Constructed an array b' of length n-1, where b'_i = b_{p_i}.
* Constructed an array c' of length n-1, where c'_i = c_{p_i}.
For example, if the array a was [3, 4, 6, 5, 7] and permutation p was [2, 4, 1, 3], then Neko would have constructed the following arrays:
* b = [3, 4, 5, 5]
* c = [4, 6, 6, 7]
* b' = [4, 5, 3, 5]
* c' = [6, 7, 4, 6]
Then, he wrote two arrays b' and c' on a piece of paper and forgot about it. 14 years later, when he was cleaning up his room, he discovered this old piece of paper with two arrays b' and c' written on it. However he can't remember the array a and permutation p he used.
In case Neko made a mistake and there is no array a and permutation p resulting in such b' and c', print -1. Otherwise, help him recover any possible array a.
Input
The first line contains an integer n (2 ≤ n ≤ 10^5) — the number of elements in array a.
The second line contains n-1 integers b'_1, b'_2, …, b'_{n-1} (1 ≤ b'_i ≤ 10^9).
The third line contains n-1 integers c'_1, c'_2, …, c'_{n-1} (1 ≤ c'_i ≤ 10^9).
Output
If Neko made a mistake and there is no array a and a permutation p leading to the b' and c', print -1. Otherwise, print n positive integers a_i (1 ≤ a_i ≤ 10^9), denoting the elements of the array a.
If there are multiple possible solutions, print any of them.
Examples
Input
5
4 5 3 5
6 7 4 6
Output
3 4 6 5 7
Input
3
2 4
3 2
Output
-1
Input
8
2 3 1 1 2 4 3
3 4 4 2 5 5 4
Output
3 4 5 2 1 4 3 2
Note
The first example is explained is the problem statement.
In the third example, for a = [3, 4, 5, 2, 1, 4, 3, 2], a possible permutation p is [7, 1, 5, 4, 3, 2, 6]. In that case, Neko would have constructed the following arrays:
* b = [3, 4, 2, 1, 1, 3, 2]
* c = [4, 5, 5, 2, 4, 4, 3]
* b' = [2, 3, 1, 1, 2, 4, 3]
* c' = [3, 4, 4, 2, 5, 5, 4] | instruction | 0 | 73,383 | 12 | 146,766 |
Tags: constructive algorithms, dfs and similar, graphs
Correct Solution:
```
class multiset:
def __init__(self):
self.contenido = dict()
self.len = 0
def add(self, x):
self.contenido[x] = self.contenido.get(x, 0)+1
self.len += 1
def remove(self, x):
valor = self.contenido.get(x, 1)-1
if valor == 0:
del self.contenido[x]
else:
self.contenido[x] = valor
self.len -= 1
def pop(self):
x = next(iter(self.contenido.keys()))
self.remove(x)
return x
def __len__(self):
return self.len
def __str__(self):
return str(self.contenido)
n = int(input())
b = [int(a) for a in input().split()]
c = [int(a) for a in input().split()]
for x, y in zip(b, c):
if x > y:
print(-1)
exit()
trad = dict()
contador = 0
for a in b+c:
if not a in trad:
trad[a] = contador
contador += 1
v = [multiset() for _ in range(contador)]
auxb = [trad[a] for a in b]
auxc = [trad[a] for a in c]
for x, y in zip(auxb, auxc):
v[x].add(y)
v[y].add(x)
impares = []
for i, a in enumerate(v):
if len(a)%2:
impares.append(i)
primero = 0
if len(impares) == 2:
primero = impares[0]
elif len(impares) != 0:
print(-1)
exit()
stack = [primero]
sol = []
while len(stack):
p = stack[-1]
if len(v[p]) == 0:
sol.append(p)
stack.pop()
else:
h = v[p].pop()
v[h].remove(p)
stack.append(h)
tradaux = {v: k for k, v in trad.items()}
if len(sol) != n:
print(-1)
exit()
for i in sol:
print(tradaux[i])
``` | output | 1 | 73,383 | 12 | 146,767 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation of length k is a sequence of k integers from 1 to k containing each integer exactly once. For example, the sequence [3, 1, 2] is a permutation of length 3.
When Neko was five, he thought of an array a of n positive integers and a permutation p of length n - 1. Then, he performed the following:
* Constructed an array b of length n-1, where b_i = min(a_i, a_{i+1}).
* Constructed an array c of length n-1, where c_i = max(a_i, a_{i+1}).
* Constructed an array b' of length n-1, where b'_i = b_{p_i}.
* Constructed an array c' of length n-1, where c'_i = c_{p_i}.
For example, if the array a was [3, 4, 6, 5, 7] and permutation p was [2, 4, 1, 3], then Neko would have constructed the following arrays:
* b = [3, 4, 5, 5]
* c = [4, 6, 6, 7]
* b' = [4, 5, 3, 5]
* c' = [6, 7, 4, 6]
Then, he wrote two arrays b' and c' on a piece of paper and forgot about it. 14 years later, when he was cleaning up his room, he discovered this old piece of paper with two arrays b' and c' written on it. However he can't remember the array a and permutation p he used.
In case Neko made a mistake and there is no array a and permutation p resulting in such b' and c', print -1. Otherwise, help him recover any possible array a.
Input
The first line contains an integer n (2 ≤ n ≤ 10^5) — the number of elements in array a.
The second line contains n-1 integers b'_1, b'_2, …, b'_{n-1} (1 ≤ b'_i ≤ 10^9).
The third line contains n-1 integers c'_1, c'_2, …, c'_{n-1} (1 ≤ c'_i ≤ 10^9).
Output
If Neko made a mistake and there is no array a and a permutation p leading to the b' and c', print -1. Otherwise, print n positive integers a_i (1 ≤ a_i ≤ 10^9), denoting the elements of the array a.
If there are multiple possible solutions, print any of them.
Examples
Input
5
4 5 3 5
6 7 4 6
Output
3 4 6 5 7
Input
3
2 4
3 2
Output
-1
Input
8
2 3 1 1 2 4 3
3 4 4 2 5 5 4
Output
3 4 5 2 1 4 3 2
Note
The first example is explained is the problem statement.
In the third example, for a = [3, 4, 5, 2, 1, 4, 3, 2], a possible permutation p is [7, 1, 5, 4, 3, 2, 6]. In that case, Neko would have constructed the following arrays:
* b = [3, 4, 2, 1, 1, 3, 2]
* c = [4, 5, 5, 2, 4, 4, 3]
* b' = [2, 3, 1, 1, 2, 4, 3]
* c' = [3, 4, 4, 2, 5, 5, 4] | instruction | 0 | 73,384 | 12 | 146,768 |
Tags: constructive algorithms, dfs and similar, graphs
Correct Solution:
```
class multiset:
def __init__(self):
self.items = dict()
self.len = 0
def add(self, it):
self.items[it] = self.items.get(it,0) + 1
self.len += 1
def remove(self, it):
it_value = self.items.get(it,1) - 1
if it_value == 0:
self.items.__delitem__(it)
else:
self.items[it] = it_value
self.len -= 1
def pop(self):
it = next(iter(self.items.keys()))
self.remove(it)
return it
def __len__(self):
return self.len
def __str__(self):
return str(self.items)
import sys
fd = sys.stdin
#fd = open('TestCaseNekoAndFlachBack.txt','r')
n = int(fd.readline())
bp = [int(i) for i in fd.readline().split()]
cp = [int(i) for i in fd.readline().split()]
#fd.close() #Comentar ANTES DE MANDAR
for i in range(n-1):
if bp[i] > cp[i]:
print(-1)
sys.exit()
map_value = dict()
count = 0
for i in bp + cp:
if i not in map_value:
map_value[i] = count
count += 1
E = [multiset() for i in range(count)]
for i in range(n-1):
a,b = (map_value[bp[i]],map_value[cp[i]])
E[a].add(b)
E[b].add(a)
odd_vert = []
for i in range(count):
if len(E[i]) % 2 == 1:
odd_vert.append(i)
#check number of vertex with odd degree
first_vert = 0
if len(odd_vert) == 2:
first_vert = count
E.append(multiset())
E[count].add(odd_vert[0])
E[odd_vert[0]].add(count)
E[count].add(odd_vert[1])
E[odd_vert[1]].add(count)
elif len(odd_vert) != 0:
print(-1)
sys.exit()
stack = [first_vert]
sol = []
while stack:
v = stack[-1]
if len(E[v]) == 0:
sol.append(v)
stack.pop()
else:
u = E[v].pop()
E[u].remove(v)
stack.append(u)
inv_map_value = {v:i for i,v in map_value.items()}
if sol[0] == count and len(sol) != n+2:
print(-1)
else:
if sol[0] == count:
for i in range(1,len(sol)-1):
print(inv_map_value[sol[i]])
else:
if len(sol) != n:
print(-1)
else:
for i in sol:
print(inv_map_value[i])
``` | output | 1 | 73,384 | 12 | 146,769 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation of length k is a sequence of k integers from 1 to k containing each integer exactly once. For example, the sequence [3, 1, 2] is a permutation of length 3.
When Neko was five, he thought of an array a of n positive integers and a permutation p of length n - 1. Then, he performed the following:
* Constructed an array b of length n-1, where b_i = min(a_i, a_{i+1}).
* Constructed an array c of length n-1, where c_i = max(a_i, a_{i+1}).
* Constructed an array b' of length n-1, where b'_i = b_{p_i}.
* Constructed an array c' of length n-1, where c'_i = c_{p_i}.
For example, if the array a was [3, 4, 6, 5, 7] and permutation p was [2, 4, 1, 3], then Neko would have constructed the following arrays:
* b = [3, 4, 5, 5]
* c = [4, 6, 6, 7]
* b' = [4, 5, 3, 5]
* c' = [6, 7, 4, 6]
Then, he wrote two arrays b' and c' on a piece of paper and forgot about it. 14 years later, when he was cleaning up his room, he discovered this old piece of paper with two arrays b' and c' written on it. However he can't remember the array a and permutation p he used.
In case Neko made a mistake and there is no array a and permutation p resulting in such b' and c', print -1. Otherwise, help him recover any possible array a.
Input
The first line contains an integer n (2 ≤ n ≤ 10^5) — the number of elements in array a.
The second line contains n-1 integers b'_1, b'_2, …, b'_{n-1} (1 ≤ b'_i ≤ 10^9).
The third line contains n-1 integers c'_1, c'_2, …, c'_{n-1} (1 ≤ c'_i ≤ 10^9).
Output
If Neko made a mistake and there is no array a and a permutation p leading to the b' and c', print -1. Otherwise, print n positive integers a_i (1 ≤ a_i ≤ 10^9), denoting the elements of the array a.
If there are multiple possible solutions, print any of them.
Examples
Input
5
4 5 3 5
6 7 4 6
Output
3 4 6 5 7
Input
3
2 4
3 2
Output
-1
Input
8
2 3 1 1 2 4 3
3 4 4 2 5 5 4
Output
3 4 5 2 1 4 3 2
Note
The first example is explained is the problem statement.
In the third example, for a = [3, 4, 5, 2, 1, 4, 3, 2], a possible permutation p is [7, 1, 5, 4, 3, 2, 6]. In that case, Neko would have constructed the following arrays:
* b = [3, 4, 2, 1, 1, 3, 2]
* c = [4, 5, 5, 2, 4, 4, 3]
* b' = [2, 3, 1, 1, 2, 4, 3]
* c' = [3, 4, 4, 2, 5, 5, 4] | instruction | 0 | 73,385 | 12 | 146,770 |
Tags: constructive algorithms, dfs and similar, graphs
Correct Solution:
```
from collections import defaultdict, Counter
from sys import exit
N = int(input())
B = list(map(int, input().split()))
C = list(map(int, input().split()))
Edge = defaultdict(list)
Edc = defaultdict(int)
for b, c in zip(B, C):
if b > c:
print(-1)
exit()
Edge[b].append(c)
Edc[(b, c)] += 1
if b != c:
Edge[c].append(b)
Deg = Counter(B + C)
eul = 0
st = []
for k, v in Deg.items():
if v % 2:
eul += 1
st.append(k)
s, e = B[0], B[0]
if eul and eul != 2:
print(-1)
exit()
if eul:
s, e = st[0], st[1]
ans = [s]
while True:
vn = ans[-1]
while True:
vf = Edge[vn][-1]
if Deg[vf] != 0 and Edc[(vn, vf) if vn < vf else (vf, vn)]:
break
Edge[vn].pop()
vf = Edge[vn].pop()
Deg[vn] -= 1
Deg[vf] -= 1
Edc[(vn, vf) if vn < vf else (vf, vn)] -= 1
ans.append(vf)
if not Deg[vf]:
break
loop = defaultdict(list)
for a in ans:
if Deg[a]:
loopa = [a]
while Deg[a]:
vn = loopa[-1]
while True:
vf = Edge[vn][-1]
if Deg[vf] != 0 and Edc[(vn, vf) if vn < vf else (vf, vn)]:
break
Edge[vn].pop()
vf = Edge[vn].pop()
Deg[vn] -= 1
Deg[vf] -= 1
Edc[(vn, vf) if vn < vf else (vf, vn)] -= 1
loopa.append(vf)
if not Deg[vf]:
break
loop[a] = loopa
Ans = []
for a in ans:
if loop[a]:
Ans.extend(loop[a])
loop[a] = []
else:
Ans.append(a)
if len(Ans) != N:
print(-1)
exit()
print(*Ans)
``` | output | 1 | 73,385 | 12 | 146,771 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation of length k is a sequence of k integers from 1 to k containing each integer exactly once. For example, the sequence [3, 1, 2] is a permutation of length 3.
When Neko was five, he thought of an array a of n positive integers and a permutation p of length n - 1. Then, he performed the following:
* Constructed an array b of length n-1, where b_i = min(a_i, a_{i+1}).
* Constructed an array c of length n-1, where c_i = max(a_i, a_{i+1}).
* Constructed an array b' of length n-1, where b'_i = b_{p_i}.
* Constructed an array c' of length n-1, where c'_i = c_{p_i}.
For example, if the array a was [3, 4, 6, 5, 7] and permutation p was [2, 4, 1, 3], then Neko would have constructed the following arrays:
* b = [3, 4, 5, 5]
* c = [4, 6, 6, 7]
* b' = [4, 5, 3, 5]
* c' = [6, 7, 4, 6]
Then, he wrote two arrays b' and c' on a piece of paper and forgot about it. 14 years later, when he was cleaning up his room, he discovered this old piece of paper with two arrays b' and c' written on it. However he can't remember the array a and permutation p he used.
In case Neko made a mistake and there is no array a and permutation p resulting in such b' and c', print -1. Otherwise, help him recover any possible array a.
Input
The first line contains an integer n (2 ≤ n ≤ 10^5) — the number of elements in array a.
The second line contains n-1 integers b'_1, b'_2, …, b'_{n-1} (1 ≤ b'_i ≤ 10^9).
The third line contains n-1 integers c'_1, c'_2, …, c'_{n-1} (1 ≤ c'_i ≤ 10^9).
Output
If Neko made a mistake and there is no array a and a permutation p leading to the b' and c', print -1. Otherwise, print n positive integers a_i (1 ≤ a_i ≤ 10^9), denoting the elements of the array a.
If there are multiple possible solutions, print any of them.
Examples
Input
5
4 5 3 5
6 7 4 6
Output
3 4 6 5 7
Input
3
2 4
3 2
Output
-1
Input
8
2 3 1 1 2 4 3
3 4 4 2 5 5 4
Output
3 4 5 2 1 4 3 2
Note
The first example is explained is the problem statement.
In the third example, for a = [3, 4, 5, 2, 1, 4, 3, 2], a possible permutation p is [7, 1, 5, 4, 3, 2, 6]. In that case, Neko would have constructed the following arrays:
* b = [3, 4, 2, 1, 1, 3, 2]
* c = [4, 5, 5, 2, 4, 4, 3]
* b' = [2, 3, 1, 1, 2, 4, 3]
* c' = [3, 4, 4, 2, 5, 5, 4]
Submitted Solution:
```
class multiset:
def __init__(self):
self.items = dict()
self.len = 0
def add(self, it):
self.items[it] = self.items.get(it,0) + 1
self.len += 1
def remove(self, it):
it_value = self.items.get(it,1) - 1
if it_value == 0:
self.items.__delitem__(it)
else:
self.items[it] = it_value
self.len -= 1
def pop(self):
it = next(iter(self.items.keys()))
self.remove(it)
return it
def __len__(self):
return self.len
def __str__(self):
return str(self.items)
import sys
fd = sys.stdin
#fd = open('TestCaseNekoAndFlachBack.txt','r')
n = int(fd.readline())
bp = [int(i) for i in fd.readline().split()]
cp = [int(i) for i in fd.readline().split()]
#fd.close() #Comentar ANTES DE MANDAR
for i in range(n-1):
if bp[i] > cp[i]:
print(-1)
sys.exit()
map_value = dict()
count = 0
for i in bp + cp:
if i not in map_value:
map_value[i] = count
count += 1
E = [multiset() for i in range(count)]
for i in range(n-1):
a,b = (map_value[bp[i]],map_value[cp[i]])
E[a].add(b)
E[b].add(a)
odd_vert = []
for i in range(count):
if len(E[i]) % 2 == 1:
odd_vert.append(i)
#check number of vertex with odd degree
first_vert = 0
if len(odd_vert) == 2:
first_vert = count
E.append(multiset())
E[count].add(odd_vert[0])
E[odd_vert[0]].add(count)
E[count].add(odd_vert[1])
E[odd_vert[1]].add(count)
elif len(odd_vert) != 0:
print(-1)
sys.exit()
stack = [first_vert]
sol = []
while stack:
v = stack[-1]
if len(E[v]) == 0:
sol.append(v)
stack.pop()
else:
u = E[v].pop()
E[u].remove(v)
stack.append(u)
inv_map_value = {v:i for i,v in map_value.items()}
if len(sol) != n+2:
print(-1)
else:
for i in range(1,len(sol)-1):
print(inv_map_value[sol[i]])
``` | instruction | 0 | 73,386 | 12 | 146,772 |
No | output | 1 | 73,386 | 12 | 146,773 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation of length k is a sequence of k integers from 1 to k containing each integer exactly once. For example, the sequence [3, 1, 2] is a permutation of length 3.
When Neko was five, he thought of an array a of n positive integers and a permutation p of length n - 1. Then, he performed the following:
* Constructed an array b of length n-1, where b_i = min(a_i, a_{i+1}).
* Constructed an array c of length n-1, where c_i = max(a_i, a_{i+1}).
* Constructed an array b' of length n-1, where b'_i = b_{p_i}.
* Constructed an array c' of length n-1, where c'_i = c_{p_i}.
For example, if the array a was [3, 4, 6, 5, 7] and permutation p was [2, 4, 1, 3], then Neko would have constructed the following arrays:
* b = [3, 4, 5, 5]
* c = [4, 6, 6, 7]
* b' = [4, 5, 3, 5]
* c' = [6, 7, 4, 6]
Then, he wrote two arrays b' and c' on a piece of paper and forgot about it. 14 years later, when he was cleaning up his room, he discovered this old piece of paper with two arrays b' and c' written on it. However he can't remember the array a and permutation p he used.
In case Neko made a mistake and there is no array a and permutation p resulting in such b' and c', print -1. Otherwise, help him recover any possible array a.
Input
The first line contains an integer n (2 ≤ n ≤ 10^5) — the number of elements in array a.
The second line contains n-1 integers b'_1, b'_2, …, b'_{n-1} (1 ≤ b'_i ≤ 10^9).
The third line contains n-1 integers c'_1, c'_2, …, c'_{n-1} (1 ≤ c'_i ≤ 10^9).
Output
If Neko made a mistake and there is no array a and a permutation p leading to the b' and c', print -1. Otherwise, print n positive integers a_i (1 ≤ a_i ≤ 10^9), denoting the elements of the array a.
If there are multiple possible solutions, print any of them.
Examples
Input
5
4 5 3 5
6 7 4 6
Output
3 4 6 5 7
Input
3
2 4
3 2
Output
-1
Input
8
2 3 1 1 2 4 3
3 4 4 2 5 5 4
Output
3 4 5 2 1 4 3 2
Note
The first example is explained is the problem statement.
In the third example, for a = [3, 4, 5, 2, 1, 4, 3, 2], a possible permutation p is [7, 1, 5, 4, 3, 2, 6]. In that case, Neko would have constructed the following arrays:
* b = [3, 4, 2, 1, 1, 3, 2]
* c = [4, 5, 5, 2, 4, 4, 3]
* b' = [2, 3, 1, 1, 2, 4, 3]
* c' = [3, 4, 4, 2, 5, 5, 4]
Submitted Solution:
```
n=int(input())
bpr=input()
cpr=input()
bpr = bpr.split()
cpr = cpr.split()
bpr = sorted(bpr)
cpr = sorted(cpr)
#print(bpr)
#print(cpr)
p=[i+1 for i in range(n-1)]
#x = bpr+cpr
flag=True
for i in range(n-1):
if(bpr[i]==cpr[i]):
flag=False
break
#s=set(x)
if(flag==False):
print('-1')
else:
ans=[]
for i in range(n-2):
ans.append(bpr[i])
for i in range(n-3,n-1):
ans.append(cpr[i])
for i in ans:
print(i,end=' ')
print()
``` | instruction | 0 | 73,387 | 12 | 146,774 |
No | output | 1 | 73,387 | 12 | 146,775 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation of length k is a sequence of k integers from 1 to k containing each integer exactly once. For example, the sequence [3, 1, 2] is a permutation of length 3.
When Neko was five, he thought of an array a of n positive integers and a permutation p of length n - 1. Then, he performed the following:
* Constructed an array b of length n-1, where b_i = min(a_i, a_{i+1}).
* Constructed an array c of length n-1, where c_i = max(a_i, a_{i+1}).
* Constructed an array b' of length n-1, where b'_i = b_{p_i}.
* Constructed an array c' of length n-1, where c'_i = c_{p_i}.
For example, if the array a was [3, 4, 6, 5, 7] and permutation p was [2, 4, 1, 3], then Neko would have constructed the following arrays:
* b = [3, 4, 5, 5]
* c = [4, 6, 6, 7]
* b' = [4, 5, 3, 5]
* c' = [6, 7, 4, 6]
Then, he wrote two arrays b' and c' on a piece of paper and forgot about it. 14 years later, when he was cleaning up his room, he discovered this old piece of paper with two arrays b' and c' written on it. However he can't remember the array a and permutation p he used.
In case Neko made a mistake and there is no array a and permutation p resulting in such b' and c', print -1. Otherwise, help him recover any possible array a.
Input
The first line contains an integer n (2 ≤ n ≤ 10^5) — the number of elements in array a.
The second line contains n-1 integers b'_1, b'_2, …, b'_{n-1} (1 ≤ b'_i ≤ 10^9).
The third line contains n-1 integers c'_1, c'_2, …, c'_{n-1} (1 ≤ c'_i ≤ 10^9).
Output
If Neko made a mistake and there is no array a and a permutation p leading to the b' and c', print -1. Otherwise, print n positive integers a_i (1 ≤ a_i ≤ 10^9), denoting the elements of the array a.
If there are multiple possible solutions, print any of them.
Examples
Input
5
4 5 3 5
6 7 4 6
Output
3 4 6 5 7
Input
3
2 4
3 2
Output
-1
Input
8
2 3 1 1 2 4 3
3 4 4 2 5 5 4
Output
3 4 5 2 1 4 3 2
Note
The first example is explained is the problem statement.
In the third example, for a = [3, 4, 5, 2, 1, 4, 3, 2], a possible permutation p is [7, 1, 5, 4, 3, 2, 6]. In that case, Neko would have constructed the following arrays:
* b = [3, 4, 2, 1, 1, 3, 2]
* c = [4, 5, 5, 2, 4, 4, 3]
* b' = [2, 3, 1, 1, 2, 4, 3]
* c' = [3, 4, 4, 2, 5, 5, 4]
Submitted Solution:
```
import os
class edge:
def __init__ (self,to,c,next):
self.to=to
self.c=c
self.next=next
pos=1
head=[0 for i in range(0,100000+10)]
def add (a,b,c):
global pos
global e
pos+=1
e[pos]=edge(b,c,head[a])
head[a]=pos
def insert (a,b,c):
add(a,b,c)
add(b,a,c)
m=0
to={}
bc={}
def make(a,n):
global m,to
tmp=[0]+sorted(a[1:n+1])
tot=0
for i in range(1,n+1):
if tmp[i]!=tmp[i-1] or i==1:
tot+=1
tmp[tot]=tmp[i]
for i in range(1,tot+1):
to[tmp[i]]=i
bc[i]=tmp[i]
m=tot
b=[0]
c=[0]
n=int(input())-1
e=[edge(0,0,0) for i in range(0,n*2+10)]
b+=input().split()
c+=input().split()
for i in range(1,n+1):
b[i]=int(b[i])
c[i]=int(c[i])
flag=0
for i in range(1,n+1):
if b[i]>c[i]: flag=1
if flag :
print(-1)
os._exit(0)
make(b+c[1:n+1],n+n)
for i in range(1,n+1):
b[i]=to[b[i]]
c[i]=to[c[i]]
du=[0 for i in range(0,m+1)]
for i in range(1,n+1):
insert(b[i],c[i],1)
du[b[i]]+=1
du[c[i]]+=1
flag=0
t=0
for i in range(1,m+1):
if du[i]%2==1:
flag+=1
t=i
if flag>2:
print(-1)
os._exit()
if t==0:
for i in range(1,m+1):
if du[i]>0:t=i
top=0
st=[0]
def work(u):
global e,top
i=head[u]
while i>0:
# print(str(i)+str(e[i].next))
if e[i].c==0:
i=e[i].next
continue
v=e[i].to
e[i].c=e[i^1].c=0
work(v)
i=e[i].next
st.append(u)
top+=1
# print("ok"+str(u))
work(t)
out=""
for i in range(top,0,-1):
out+=str(bc[st[i]])+" "
print(out)
``` | instruction | 0 | 73,388 | 12 | 146,776 |
No | output | 1 | 73,388 | 12 | 146,777 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation of length k is a sequence of k integers from 1 to k containing each integer exactly once. For example, the sequence [3, 1, 2] is a permutation of length 3.
When Neko was five, he thought of an array a of n positive integers and a permutation p of length n - 1. Then, he performed the following:
* Constructed an array b of length n-1, where b_i = min(a_i, a_{i+1}).
* Constructed an array c of length n-1, where c_i = max(a_i, a_{i+1}).
* Constructed an array b' of length n-1, where b'_i = b_{p_i}.
* Constructed an array c' of length n-1, where c'_i = c_{p_i}.
For example, if the array a was [3, 4, 6, 5, 7] and permutation p was [2, 4, 1, 3], then Neko would have constructed the following arrays:
* b = [3, 4, 5, 5]
* c = [4, 6, 6, 7]
* b' = [4, 5, 3, 5]
* c' = [6, 7, 4, 6]
Then, he wrote two arrays b' and c' on a piece of paper and forgot about it. 14 years later, when he was cleaning up his room, he discovered this old piece of paper with two arrays b' and c' written on it. However he can't remember the array a and permutation p he used.
In case Neko made a mistake and there is no array a and permutation p resulting in such b' and c', print -1. Otherwise, help him recover any possible array a.
Input
The first line contains an integer n (2 ≤ n ≤ 10^5) — the number of elements in array a.
The second line contains n-1 integers b'_1, b'_2, …, b'_{n-1} (1 ≤ b'_i ≤ 10^9).
The third line contains n-1 integers c'_1, c'_2, …, c'_{n-1} (1 ≤ c'_i ≤ 10^9).
Output
If Neko made a mistake and there is no array a and a permutation p leading to the b' and c', print -1. Otherwise, print n positive integers a_i (1 ≤ a_i ≤ 10^9), denoting the elements of the array a.
If there are multiple possible solutions, print any of them.
Examples
Input
5
4 5 3 5
6 7 4 6
Output
3 4 6 5 7
Input
3
2 4
3 2
Output
-1
Input
8
2 3 1 1 2 4 3
3 4 4 2 5 5 4
Output
3 4 5 2 1 4 3 2
Note
The first example is explained is the problem statement.
In the third example, for a = [3, 4, 5, 2, 1, 4, 3, 2], a possible permutation p is [7, 1, 5, 4, 3, 2, 6]. In that case, Neko would have constructed the following arrays:
* b = [3, 4, 2, 1, 1, 3, 2]
* c = [4, 5, 5, 2, 4, 4, 3]
* b' = [2, 3, 1, 1, 2, 4, 3]
* c' = [3, 4, 4, 2, 5, 5, 4]
Submitted Solution:
```
n=int(input())
bpr=input()
cpr=input()
bpr = bpr.split()
cpr = cpr.split()
bpr = sorted(bpr)
cpr = sorted(cpr)
x = bpr+cpr
flag=True
for i in range(n-1):
if(bpr[i]==cpr[i]):
flag=False
break
s=set(x)
if(flag==False):
print('-1')
else:
ans=list(s)
x=list(s)
i=0
while(len(ans)!=n):
ans.append(x[i])
i=(i+1)%(len(s))
for i in ans:
print(i,end=' ')
print()
``` | instruction | 0 | 73,389 | 12 | 146,778 |
No | output | 1 | 73,389 | 12 | 146,779 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya likes to play very much. And most of all he likes to play the following game:
He is given a sequence of N integer numbers. At each step it is allowed to increase the value of any number by 1 or to decrease it by 1. The goal of the game is to make the sequence non-decreasing with the smallest number of steps. Petya is not good at math, so he asks for your help.
The sequence a is called non-decreasing if a1 ≤ a2 ≤ ... ≤ aN holds, where N is the length of the sequence.
Input
The first line of the input contains single integer N (1 ≤ N ≤ 5000) — the length of the initial sequence. The following N lines contain one integer each — elements of the sequence. These numbers do not exceed 109 by absolute value.
Output
Output one integer — minimum number of steps required to achieve the goal.
Examples
Input
5
3 2 -1 2 11
Output
4
Input
5
2 1 1 1 1
Output
1 | instruction | 0 | 73,522 | 12 | 147,044 |
Tags: dp, sortings
Correct Solution:
```
import heapq
input()
ans=0
a=[]
inf=10**9
for x in map(int,input().split()):
x=inf-x
heapq.heappush(a,x)
ans+=a[0]-x
heapq.heappop(a)
heapq.heappush(a,x)
print(-ans)
``` | output | 1 | 73,522 | 12 | 147,045 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya likes to play very much. And most of all he likes to play the following game:
He is given a sequence of N integer numbers. At each step it is allowed to increase the value of any number by 1 or to decrease it by 1. The goal of the game is to make the sequence non-decreasing with the smallest number of steps. Petya is not good at math, so he asks for your help.
The sequence a is called non-decreasing if a1 ≤ a2 ≤ ... ≤ aN holds, where N is the length of the sequence.
Input
The first line of the input contains single integer N (1 ≤ N ≤ 5000) — the length of the initial sequence. The following N lines contain one integer each — elements of the sequence. These numbers do not exceed 109 by absolute value.
Output
Output one integer — minimum number of steps required to achieve the goal.
Examples
Input
5
3 2 -1 2 11
Output
4
Input
5
2 1 1 1 1
Output
1 | instruction | 0 | 73,523 | 12 | 147,046 |
Tags: dp, sortings
Correct Solution:
```
from bisect import insort
def min_steps_N(arr):
pri_q = []
ans = 0
for n in arr:
if pri_q:
if pri_q[-1] > n:
ans += pri_q[-1] - n
pri_q.pop()
insort(pri_q, n)
insort(pri_q, n)
return ans
if __name__ == '__main__':
N = input()
arr = list(map(int, input().split(' ')))
print(min_steps_N(arr))
``` | output | 1 | 73,523 | 12 | 147,047 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] — are permutations, and [1, 1], [4, 3, 1], [2, 3, 4] — no.
Permutation a is lexicographically smaller than permutation b (they have the same length n), if in the first index i in which they differ, a[i] < b[i]. For example, the permutation [1, 3, 2, 4] is lexicographically smaller than the permutation [1, 3, 4, 2], because the first two elements are equal, and the third element in the first permutation is smaller than in the second.
The next permutation for a permutation a of length n — is the lexicographically smallest permutation b of length n that lexicographically larger than a. For example:
* for permutation [2, 1, 4, 3] the next permutation is [2, 3, 1, 4];
* for permutation [1, 2, 3] the next permutation is [1, 3, 2];
* for permutation [2, 1] next permutation does not exist.
You are given the number n — the length of the initial permutation. The initial permutation has the form a = [1, 2, …, n]. In other words, a[i] = i (1 ≤ i ≤ n).
You need to process q queries of two types:
* 1 l r: query for the sum of all elements on the segment [l, r]. More formally, you need to find a[l] + a[l + 1] + … + a[r].
* 2 x: x times replace the current permutation with the next permutation. For example, if x=2 and the current permutation has the form [1, 3, 4, 2], then we should perform such a chain of replacements [1, 3, 4, 2] → [1, 4, 2, 3] → [1, 4, 3, 2].
For each query of the 1-st type output the required sum.
Input
The first line contains two integers n (2 ≤ n ≤ 2 ⋅ 10^5) and q (1 ≤ q ≤ 2 ⋅ 10^5), where n — the length of the initial permutation, and q — the number of queries.
The next q lines contain a single query of the 1-st or 2-nd type. The 1-st type query consists of three integers 1, l and r (1 ≤ l ≤ r ≤ n), the 2-nd type query consists of two integers 2 and x (1 ≤ x ≤ 10^5).
It is guaranteed that all requests of the 2-nd type are possible to process.
Output
For each query of the 1-st type, output on a separate line one integer — the required sum.
Example
Input
4 4
1 2 4
2 3
1 1 2
1 3 4
Output
9
4
6
Note
Initially, the permutation has the form [1, 2, 3, 4]. Queries processing is as follows:
1. 2 + 3 + 4 = 9;
2. [1, 2, 3, 4] → [1, 2, 4, 3] → [1, 3, 2, 4] → [1, 3, 4, 2];
3. 1 + 3 = 4;
4. 4 + 2 = 6 | instruction | 0 | 73,528 | 12 | 147,056 |
Tags: brute force, math, two pointers
Correct Solution:
```
import io,os;from math import *;input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
manual = 20;n,Q = map(int,input().split());after = min(manual, n);before = n -after;ind = 0
def unrankperm(i):
unused = [i+1 for i in range(after)];r = []
for j in range(after)[::-1]:use = i // factorial(j);r.append(unused[use]);del unused[use];i -= use * factorial(j)
return r
p = unrankperm(ind)
for _ in range(Q):
q = list(map(int,input().split()))
if q[0] == 1:
l,r = q[1:];amt = 0
if l <= before:amt += (r * (r + 1) // 2 if r <= before else before * (before + 1) // 2);amt -= l * (l - 1) // 2;l = before + 1
if r > before:amt += sum(p[l-1-before:r-before]) + (r - l + 1) * (before)
print(amt)
else:ind += q[1];p = unrankperm(ind)
``` | output | 1 | 73,528 | 12 | 147,057 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] — are permutations, and [1, 1], [4, 3, 1], [2, 3, 4] — no.
Permutation a is lexicographically smaller than permutation b (they have the same length n), if in the first index i in which they differ, a[i] < b[i]. For example, the permutation [1, 3, 2, 4] is lexicographically smaller than the permutation [1, 3, 4, 2], because the first two elements are equal, and the third element in the first permutation is smaller than in the second.
The next permutation for a permutation a of length n — is the lexicographically smallest permutation b of length n that lexicographically larger than a. For example:
* for permutation [2, 1, 4, 3] the next permutation is [2, 3, 1, 4];
* for permutation [1, 2, 3] the next permutation is [1, 3, 2];
* for permutation [2, 1] next permutation does not exist.
You are given the number n — the length of the initial permutation. The initial permutation has the form a = [1, 2, …, n]. In other words, a[i] = i (1 ≤ i ≤ n).
You need to process q queries of two types:
* 1 l r: query for the sum of all elements on the segment [l, r]. More formally, you need to find a[l] + a[l + 1] + … + a[r].
* 2 x: x times replace the current permutation with the next permutation. For example, if x=2 and the current permutation has the form [1, 3, 4, 2], then we should perform such a chain of replacements [1, 3, 4, 2] → [1, 4, 2, 3] → [1, 4, 3, 2].
For each query of the 1-st type output the required sum.
Input
The first line contains two integers n (2 ≤ n ≤ 2 ⋅ 10^5) and q (1 ≤ q ≤ 2 ⋅ 10^5), where n — the length of the initial permutation, and q — the number of queries.
The next q lines contain a single query of the 1-st or 2-nd type. The 1-st type query consists of three integers 1, l and r (1 ≤ l ≤ r ≤ n), the 2-nd type query consists of two integers 2 and x (1 ≤ x ≤ 10^5).
It is guaranteed that all requests of the 2-nd type are possible to process.
Output
For each query of the 1-st type, output on a separate line one integer — the required sum.
Example
Input
4 4
1 2 4
2 3
1 1 2
1 3 4
Output
9
4
6
Note
Initially, the permutation has the form [1, 2, 3, 4]. Queries processing is as follows:
1. 2 + 3 + 4 = 9;
2. [1, 2, 3, 4] → [1, 2, 4, 3] → [1, 3, 2, 4] → [1, 3, 4, 2];
3. 1 + 3 = 4;
4. 4 + 2 = 6 | instruction | 0 | 73,529 | 12 | 147,058 |
Tags: brute force, math, two pointers
Correct Solution:
```
import sys
input = sys.stdin.readline
n,q=map(int,input().split())
X=list(range(1,n+1))
S=[0]
for x in X:
S.append(S[-1]+x)
FACT=[1,1]
for i in range(2,16):
FACT.append(FACT[-1]*i)
A=X[-15:]
LEN=len(A)
def calc(x):
AA=[a for a in A]
ANS=[]
for i in range(LEN,0,-1):
q=x//FACT[i-1]
x-=q*FACT[i-1]
ANS.append(AA.pop(q))
#print(q,x,AA,ANS)
return ANS
NOW=0
for queries in range(q):
Q=list(map(int,input().split()))
if Q[0]==2:
NOW+=Q[1]
continue
l,r=Q[1],Q[2]
if r<=n-LEN:
print(S[r]-S[l-1])
continue
elif l<=n-LEN:
ANS=S[-LEN-1]-S[l-1]
l=0
r-=n-LEN+1
else:
ANS=0
l-=n-LEN+1
r-=n-LEN+1
NOWA=calc(NOW)
print(ANS+sum(NOWA[l:r+1]))
``` | output | 1 | 73,529 | 12 | 147,059 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] — are permutations, and [1, 1], [4, 3, 1], [2, 3, 4] — no.
Permutation a is lexicographically smaller than permutation b (they have the same length n), if in the first index i in which they differ, a[i] < b[i]. For example, the permutation [1, 3, 2, 4] is lexicographically smaller than the permutation [1, 3, 4, 2], because the first two elements are equal, and the third element in the first permutation is smaller than in the second.
The next permutation for a permutation a of length n — is the lexicographically smallest permutation b of length n that lexicographically larger than a. For example:
* for permutation [2, 1, 4, 3] the next permutation is [2, 3, 1, 4];
* for permutation [1, 2, 3] the next permutation is [1, 3, 2];
* for permutation [2, 1] next permutation does not exist.
You are given the number n — the length of the initial permutation. The initial permutation has the form a = [1, 2, …, n]. In other words, a[i] = i (1 ≤ i ≤ n).
You need to process q queries of two types:
* 1 l r: query for the sum of all elements on the segment [l, r]. More formally, you need to find a[l] + a[l + 1] + … + a[r].
* 2 x: x times replace the current permutation with the next permutation. For example, if x=2 and the current permutation has the form [1, 3, 4, 2], then we should perform such a chain of replacements [1, 3, 4, 2] → [1, 4, 2, 3] → [1, 4, 3, 2].
For each query of the 1-st type output the required sum.
Input
The first line contains two integers n (2 ≤ n ≤ 2 ⋅ 10^5) and q (1 ≤ q ≤ 2 ⋅ 10^5), where n — the length of the initial permutation, and q — the number of queries.
The next q lines contain a single query of the 1-st or 2-nd type. The 1-st type query consists of three integers 1, l and r (1 ≤ l ≤ r ≤ n), the 2-nd type query consists of two integers 2 and x (1 ≤ x ≤ 10^5).
It is guaranteed that all requests of the 2-nd type are possible to process.
Output
For each query of the 1-st type, output on a separate line one integer — the required sum.
Example
Input
4 4
1 2 4
2 3
1 1 2
1 3 4
Output
9
4
6
Note
Initially, the permutation has the form [1, 2, 3, 4]. Queries processing is as follows:
1. 2 + 3 + 4 = 9;
2. [1, 2, 3, 4] → [1, 2, 4, 3] → [1, 3, 2, 4] → [1, 3, 4, 2];
3. 1 + 3 = 4;
4. 4 + 2 = 6 | instruction | 0 | 73,530 | 12 | 147,060 |
Tags: brute force, math, two pointers
Correct Solution:
```
import io,os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
import bisect
factor = [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 6227020800, 87178291200]
n,q = map(int,input().split())
def getpermute(x,n):
m = bisect.bisect(factor,x)+1
output = [0]*m
have = [i for i in range(m)]
for i in range(m-1):
add = x//factor[m-i-2]
x -= add*factor[m-i-2]
output[i] = have[add]+(n-m+1)
have.pop(add)
output[-1] = have[0]+(n-m+1)
return output
t = 1
x = 0
arr = [n]
while t<=q:
inp = list(map(int,input().split()))
if inp[0]==2:
x += inp[1]
arr = getpermute(x,n)
t += 1
continue
l,r = inp[1],inp[2]
base = n - len(arr)
if r<=base:
ans = (l+r)*(r-l+1)//2
print(ans)
elif l<=base:
ans = (l+base)*(base-l+1)//2
ans += sum(arr[:r-base])
print(ans)
else:
ans = sum(arr[l-base-1:r-base])
print(ans)
t += 1
``` | output | 1 | 73,530 | 12 | 147,061 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] — are permutations, and [1, 1], [4, 3, 1], [2, 3, 4] — no.
Permutation a is lexicographically smaller than permutation b (they have the same length n), if in the first index i in which they differ, a[i] < b[i]. For example, the permutation [1, 3, 2, 4] is lexicographically smaller than the permutation [1, 3, 4, 2], because the first two elements are equal, and the third element in the first permutation is smaller than in the second.
The next permutation for a permutation a of length n — is the lexicographically smallest permutation b of length n that lexicographically larger than a. For example:
* for permutation [2, 1, 4, 3] the next permutation is [2, 3, 1, 4];
* for permutation [1, 2, 3] the next permutation is [1, 3, 2];
* for permutation [2, 1] next permutation does not exist.
You are given the number n — the length of the initial permutation. The initial permutation has the form a = [1, 2, …, n]. In other words, a[i] = i (1 ≤ i ≤ n).
You need to process q queries of two types:
* 1 l r: query for the sum of all elements on the segment [l, r]. More formally, you need to find a[l] + a[l + 1] + … + a[r].
* 2 x: x times replace the current permutation with the next permutation. For example, if x=2 and the current permutation has the form [1, 3, 4, 2], then we should perform such a chain of replacements [1, 3, 4, 2] → [1, 4, 2, 3] → [1, 4, 3, 2].
For each query of the 1-st type output the required sum.
Input
The first line contains two integers n (2 ≤ n ≤ 2 ⋅ 10^5) and q (1 ≤ q ≤ 2 ⋅ 10^5), where n — the length of the initial permutation, and q — the number of queries.
The next q lines contain a single query of the 1-st or 2-nd type. The 1-st type query consists of three integers 1, l and r (1 ≤ l ≤ r ≤ n), the 2-nd type query consists of two integers 2 and x (1 ≤ x ≤ 10^5).
It is guaranteed that all requests of the 2-nd type are possible to process.
Output
For each query of the 1-st type, output on a separate line one integer — the required sum.
Example
Input
4 4
1 2 4
2 3
1 1 2
1 3 4
Output
9
4
6
Note
Initially, the permutation has the form [1, 2, 3, 4]. Queries processing is as follows:
1. 2 + 3 + 4 = 9;
2. [1, 2, 3, 4] → [1, 2, 4, 3] → [1, 3, 2, 4] → [1, 3, 4, 2];
3. 1 + 3 = 4;
4. 4 + 2 = 6 | instruction | 0 | 73,531 | 12 | 147,062 |
Tags: brute force, math, two pointers
Correct Solution:
```
import io,os
from math import *
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
n, q = list(map(int, input().split()))
after = min(15, n)
before = n - after
def perm(i):
unused = [i + 1 for i in range(after)]
arr = []
for j in reversed(range(after)):
cur = i // factorial(j)
arr.append(unused[cur])
del unused[cur]
i -= cur * factorial(j)
return arr
p = perm(0)
x = 0
for _ in range(q):
line = list(map(int, input().split()))
if len(line) == 3:
# type 1
l = line[1]
r = line[2]
res = 0
if l <= before:
if r <= before:
res += r * (r + 1) // 2
else:
res += before * (before + 1) // 2
res -= l * (l - 1) // 2
l = before + 1
if r > before:
res += sum(p[l-1-before:r-before]) + (r-l+1) * before
print(res)
else:
# type 2
x += line[1]
p = perm(x)
``` | output | 1 | 73,531 | 12 | 147,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] — are permutations, and [1, 1], [4, 3, 1], [2, 3, 4] — no.
Permutation a is lexicographically smaller than permutation b (they have the same length n), if in the first index i in which they differ, a[i] < b[i]. For example, the permutation [1, 3, 2, 4] is lexicographically smaller than the permutation [1, 3, 4, 2], because the first two elements are equal, and the third element in the first permutation is smaller than in the second.
The next permutation for a permutation a of length n — is the lexicographically smallest permutation b of length n that lexicographically larger than a. For example:
* for permutation [2, 1, 4, 3] the next permutation is [2, 3, 1, 4];
* for permutation [1, 2, 3] the next permutation is [1, 3, 2];
* for permutation [2, 1] next permutation does not exist.
You are given the number n — the length of the initial permutation. The initial permutation has the form a = [1, 2, …, n]. In other words, a[i] = i (1 ≤ i ≤ n).
You need to process q queries of two types:
* 1 l r: query for the sum of all elements on the segment [l, r]. More formally, you need to find a[l] + a[l + 1] + … + a[r].
* 2 x: x times replace the current permutation with the next permutation. For example, if x=2 and the current permutation has the form [1, 3, 4, 2], then we should perform such a chain of replacements [1, 3, 4, 2] → [1, 4, 2, 3] → [1, 4, 3, 2].
For each query of the 1-st type output the required sum.
Input
The first line contains two integers n (2 ≤ n ≤ 2 ⋅ 10^5) and q (1 ≤ q ≤ 2 ⋅ 10^5), where n — the length of the initial permutation, and q — the number of queries.
The next q lines contain a single query of the 1-st or 2-nd type. The 1-st type query consists of three integers 1, l and r (1 ≤ l ≤ r ≤ n), the 2-nd type query consists of two integers 2 and x (1 ≤ x ≤ 10^5).
It is guaranteed that all requests of the 2-nd type are possible to process.
Output
For each query of the 1-st type, output on a separate line one integer — the required sum.
Example
Input
4 4
1 2 4
2 3
1 1 2
1 3 4
Output
9
4
6
Note
Initially, the permutation has the form [1, 2, 3, 4]. Queries processing is as follows:
1. 2 + 3 + 4 = 9;
2. [1, 2, 3, 4] → [1, 2, 4, 3] → [1, 3, 2, 4] → [1, 3, 4, 2];
3. 1 + 3 = 4;
4. 4 + 2 = 6 | instruction | 0 | 73,532 | 12 | 147,064 |
Tags: brute force, math, two pointers
Correct Solution:
```
import sys
input=sys.stdin.readline
fact=[1]
for i in range(1,15+1):
fact.append(fact[-1]*i)
def generate_perm(n,m):
ret=[]
if n<=15:
cand=[i+1 for i in range(n)]
else:
cand=[i+1 for i in range(n-15,n)]
for i in range(1,min(15+1,n+1)):
pos=m//fact[min(15,n)-i]
m%=fact[min(15,n)-i]
ret.append(cand[pos])
del cand[pos]
return ret
n,q=map(int,input().split())
ids=0
if n<=15:
perm=[i+1 for i in range(n)]
else:
perm=[i+1 for i in range(n-15,n)]
for _ in range(q):
query=list(map(int,input().split()))
if query[0]==1:
l,r=query[1],query[2]
if n<=15:
print(sum(perm[l-1:r]))
else:
if l<=n-15:
if r<=n-15:
print((r*(r+1))//2-(l*(l-1))//2)
else:
print(((n-15)*(n-14))//2-(l*(l-1))//2+sum(perm[0:r-(n-15)]))
else:
print(sum(perm[l-1-(n-15):r-(n-15)]))
elif query[0]==2:
ids+=query[1]
perm=generate_perm(n,ids)
``` | output | 1 | 73,532 | 12 | 147,065 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] — are permutations, and [1, 1], [4, 3, 1], [2, 3, 4] — no.
Permutation a is lexicographically smaller than permutation b (they have the same length n), if in the first index i in which they differ, a[i] < b[i]. For example, the permutation [1, 3, 2, 4] is lexicographically smaller than the permutation [1, 3, 4, 2], because the first two elements are equal, and the third element in the first permutation is smaller than in the second.
The next permutation for a permutation a of length n — is the lexicographically smallest permutation b of length n that lexicographically larger than a. For example:
* for permutation [2, 1, 4, 3] the next permutation is [2, 3, 1, 4];
* for permutation [1, 2, 3] the next permutation is [1, 3, 2];
* for permutation [2, 1] next permutation does not exist.
You are given the number n — the length of the initial permutation. The initial permutation has the form a = [1, 2, …, n]. In other words, a[i] = i (1 ≤ i ≤ n).
You need to process q queries of two types:
* 1 l r: query for the sum of all elements on the segment [l, r]. More formally, you need to find a[l] + a[l + 1] + … + a[r].
* 2 x: x times replace the current permutation with the next permutation. For example, if x=2 and the current permutation has the form [1, 3, 4, 2], then we should perform such a chain of replacements [1, 3, 4, 2] → [1, 4, 2, 3] → [1, 4, 3, 2].
For each query of the 1-st type output the required sum.
Input
The first line contains two integers n (2 ≤ n ≤ 2 ⋅ 10^5) and q (1 ≤ q ≤ 2 ⋅ 10^5), where n — the length of the initial permutation, and q — the number of queries.
The next q lines contain a single query of the 1-st or 2-nd type. The 1-st type query consists of three integers 1, l and r (1 ≤ l ≤ r ≤ n), the 2-nd type query consists of two integers 2 and x (1 ≤ x ≤ 10^5).
It is guaranteed that all requests of the 2-nd type are possible to process.
Output
For each query of the 1-st type, output on a separate line one integer — the required sum.
Example
Input
4 4
1 2 4
2 3
1 1 2
1 3 4
Output
9
4
6
Note
Initially, the permutation has the form [1, 2, 3, 4]. Queries processing is as follows:
1. 2 + 3 + 4 = 9;
2. [1, 2, 3, 4] → [1, 2, 4, 3] → [1, 3, 2, 4] → [1, 3, 4, 2];
3. 1 + 3 = 4;
4. 4 + 2 = 6 | instruction | 0 | 73,533 | 12 | 147,066 |
Tags: brute force, math, two pointers
Correct Solution:
```
n, q = map(int, input().split())
A = [i for i in range(1, n + 1)]
prefix = [0] * (n + 1)
prefix[0] = A[0]
for i in range(1, n):
prefix[i] = prefix[i - 1] + A[i]
used0 = A[max(0, n - 15)::]
used0.sort()
used_d = {}
for i in used0:
used_d[i] = 0
fact = [0] * n
fact[-1] = 1
for i in range(n - 2, max(-1, n - 16), -1):
fact[i] = fact[i + 1] * (n - 1 - i)
number = 1
#print(fact)
def permutation_by_number(number):
for i in range(max(0, n - 15), n):
position = max(0, (number - 1) // fact[i])
#print(position)
counter = 0
for j in used_d:
if position == counter and not used_d[j]:
A[i] = j
used_d[j] = 1
break
if not used_d[j]:
counter += 1
number -= position * fact[i]
for i in range(max(0, n - 15), n):
prefix[i] = prefix[i - 1] + A[i]
for i in range(q):
#print(prefix, A, number)
t = list(map(int, input().split()))
if t[0] == 1:
l, r = t[1], t[2]
print(prefix[r - 1] - prefix[l - 2])
else:
for j in used_d:
used_d[j] = 0
x = t[1]
number += x
permutation_by_number(number)
``` | output | 1 | 73,533 | 12 | 147,067 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.