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.
John Doe has found the beautiful permutation formula.
Let's take permutation p = p1, p2, ..., pn. Let's define transformation f of this permutation:
<image>
where k (k > 1) is an integer, the transformation parameter, r is such maximum integer that rk ≤ n. If rk = n, then elements prk + 1, prk + 2 and so on are omitted. In other words, the described transformation of permutation p cyclically shifts to the left each consecutive block of length k and the last block with the length equal to the remainder after dividing n by k.
John Doe thinks that permutation f(f( ... f(p = [1, 2, ..., n], 2) ... , n - 1), n) is beautiful. Unfortunately, he cannot quickly find the beautiful permutation he's interested in. That's why he asked you to help him.
Your task is to find a beautiful permutation for the given n. For clarifications, see the notes to the third sample.
Input
A single line contains integer n (2 ≤ n ≤ 106).
Output
Print n distinct space-separated integers from 1 to n — a beautiful permutation of size n.
Examples
Input
2
Output
2 1
Input
3
Output
1 3 2
Input
4
Output
4 2 3 1
Note
A note to the third test sample:
* f([1, 2, 3, 4], 2) = [2, 1, 4, 3]
* f([2, 1, 4, 3], 3) = [1, 4, 2, 3]
* f([1, 4, 2, 3], 4) = [4, 2, 3, 1]
Submitted Solution:
```
n = int(input())
a = [0] * (n + 1)
for i in range(1, n + 1):
a[i] = i
for i in range(2, n + 1):
tmp = a[i - 1]
j = i
for c in range(0, n // i):
if (i - 1 + j) % n == 0:
tmp, a[n] = a[n], tmp
else:
tmp, a[(i - 1 + j) % n] = a[(i - 1 + j) % n], tmp
if n % i != 0:
a[i - 1] = tmp
print(a[n], end=' ')
for i in range(1, n):
print(a[i], end=' ')
``` | instruction | 0 | 62,627 | 12 | 125,254 |
No | output | 1 | 62,627 | 12 | 125,255 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
John Doe has found the beautiful permutation formula.
Let's take permutation p = p1, p2, ..., pn. Let's define transformation f of this permutation:
<image>
where k (k > 1) is an integer, the transformation parameter, r is such maximum integer that rk ≤ n. If rk = n, then elements prk + 1, prk + 2 and so on are omitted. In other words, the described transformation of permutation p cyclically shifts to the left each consecutive block of length k and the last block with the length equal to the remainder after dividing n by k.
John Doe thinks that permutation f(f( ... f(p = [1, 2, ..., n], 2) ... , n - 1), n) is beautiful. Unfortunately, he cannot quickly find the beautiful permutation he's interested in. That's why he asked you to help him.
Your task is to find a beautiful permutation for the given n. For clarifications, see the notes to the third sample.
Input
A single line contains integer n (2 ≤ n ≤ 106).
Output
Print n distinct space-separated integers from 1 to n — a beautiful permutation of size n.
Examples
Input
2
Output
2 1
Input
3
Output
1 3 2
Input
4
Output
4 2 3 1
Note
A note to the third test sample:
* f([1, 2, 3, 4], 2) = [2, 1, 4, 3]
* f([2, 1, 4, 3], 3) = [1, 4, 2, 3]
* f([1, 4, 2, 3], 4) = [4, 2, 3, 1]
Submitted Solution:
```
def get_button_presses(n):
s1 = n
s2 = (n * (n - 1) * n) // 2
s3 = ((n - 1) * n * (2 * n - 1)) // 6
return s1 + s2 - s3
if __name__ == '__main__':
n = int(input())
e=get_button_presses(n)
print(e)
``` | instruction | 0 | 62,628 | 12 | 125,256 |
No | output | 1 | 62,628 | 12 | 125,257 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob has a permutation of integers from 1 to n. Denote this permutation as p. The i-th element of p will be denoted as pi. For all pairs of distinct integers i, j between 1 and n, he wrote the number ai, j = min(pi, pj). He writes ai, i = 0 for all integer i from 1 to n.
Bob gave you all the values of ai, j that he wrote down. Your job is to reconstruct any permutation that could have generated these values. The input will be formed so that it is guaranteed that there is at least one solution that is consistent with the information given.
Input
The first line of the input will contain a single integer n (2 ≤ n ≤ 50).
The next n lines will contain the values of ai, j. The j-th number on the i-th line will represent ai, j. The i-th number on the i-th line will be 0. It's guaranteed that ai, j = aj, i and there is at least one solution consistent with the information given.
Output
Print n space separated integers, which represents a permutation that could have generated these values. If there are multiple possible solutions, print any of them.
Examples
Input
2
0 1
1 0
Output
2 1
Input
5
0 2 2 1 2
2 0 4 1 3
2 4 0 1 3
1 1 1 0 1
2 3 3 1 0
Output
2 5 4 1 3
Note
In the first case, the answer can be {1, 2} or {2, 1}.
In the second case, another possible answer is {2, 4, 5, 1, 3}. | instruction | 0 | 62,734 | 12 | 125,468 |
Tags: constructive algorithms
Correct Solution:
```
n = int(input())
a = [list(map(int, input().split())) for x in range(n)]
result = [0] * n
for x in range(1, n):
result[max(range(n), key = lambda i: a[i].count(x))] = x
print(*[(x if x else n) for x in result])
``` | output | 1 | 62,734 | 12 | 125,469 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob has a permutation of integers from 1 to n. Denote this permutation as p. The i-th element of p will be denoted as pi. For all pairs of distinct integers i, j between 1 and n, he wrote the number ai, j = min(pi, pj). He writes ai, i = 0 for all integer i from 1 to n.
Bob gave you all the values of ai, j that he wrote down. Your job is to reconstruct any permutation that could have generated these values. The input will be formed so that it is guaranteed that there is at least one solution that is consistent with the information given.
Input
The first line of the input will contain a single integer n (2 ≤ n ≤ 50).
The next n lines will contain the values of ai, j. The j-th number on the i-th line will represent ai, j. The i-th number on the i-th line will be 0. It's guaranteed that ai, j = aj, i and there is at least one solution consistent with the information given.
Output
Print n space separated integers, which represents a permutation that could have generated these values. If there are multiple possible solutions, print any of them.
Examples
Input
2
0 1
1 0
Output
2 1
Input
5
0 2 2 1 2
2 0 4 1 3
2 4 0 1 3
1 1 1 0 1
2 3 3 1 0
Output
2 5 4 1 3
Note
In the first case, the answer can be {1, 2} or {2, 1}.
In the second case, another possible answer is {2, 4, 5, 1, 3}. | instruction | 0 | 62,735 | 12 | 125,470 |
Tags: constructive algorithms
Correct Solution:
```
__author__ = 'Admin'
n = int(input())
m = [list(map(int, input().split())) for j in range(n)]
ans = []
for i in range(n):
if len(ans) > 0:
if max(m[i]) == max(ans):
ans.append(max(m[i]) + 1)
else:
ans.append(max(m[i]))
else:
ans.append(max(m[i]))
print(*ans)
``` | output | 1 | 62,735 | 12 | 125,471 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob has a permutation of integers from 1 to n. Denote this permutation as p. The i-th element of p will be denoted as pi. For all pairs of distinct integers i, j between 1 and n, he wrote the number ai, j = min(pi, pj). He writes ai, i = 0 for all integer i from 1 to n.
Bob gave you all the values of ai, j that he wrote down. Your job is to reconstruct any permutation that could have generated these values. The input will be formed so that it is guaranteed that there is at least one solution that is consistent with the information given.
Input
The first line of the input will contain a single integer n (2 ≤ n ≤ 50).
The next n lines will contain the values of ai, j. The j-th number on the i-th line will represent ai, j. The i-th number on the i-th line will be 0. It's guaranteed that ai, j = aj, i and there is at least one solution consistent with the information given.
Output
Print n space separated integers, which represents a permutation that could have generated these values. If there are multiple possible solutions, print any of them.
Examples
Input
2
0 1
1 0
Output
2 1
Input
5
0 2 2 1 2
2 0 4 1 3
2 4 0 1 3
1 1 1 0 1
2 3 3 1 0
Output
2 5 4 1 3
Note
In the first case, the answer can be {1, 2} or {2, 1}.
In the second case, another possible answer is {2, 4, 5, 1, 3}. | instruction | 0 | 62,736 | 12 | 125,472 |
Tags: constructive algorithms
Correct Solution:
```
n = int(input())
resp = []
flag = False
for i in range(n):
tc = 0
p = 0
aux = [0 for x in range(n)]
arr = [int(x) for x in input().split()]
for j in range(n):
aux[arr[j]] += 1
for c in range(n):
if aux[c] == 1 and c == n-1:
if not flag:
p = c
flag = True
else:
p = c+1
break
elif aux[c] > tc:
tc = aux[c]
p = c
resp.append(p)
f = ' '.join(map(str, resp))
print (f)
``` | output | 1 | 62,736 | 12 | 125,473 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob has a permutation of integers from 1 to n. Denote this permutation as p. The i-th element of p will be denoted as pi. For all pairs of distinct integers i, j between 1 and n, he wrote the number ai, j = min(pi, pj). He writes ai, i = 0 for all integer i from 1 to n.
Bob gave you all the values of ai, j that he wrote down. Your job is to reconstruct any permutation that could have generated these values. The input will be formed so that it is guaranteed that there is at least one solution that is consistent with the information given.
Input
The first line of the input will contain a single integer n (2 ≤ n ≤ 50).
The next n lines will contain the values of ai, j. The j-th number on the i-th line will represent ai, j. The i-th number on the i-th line will be 0. It's guaranteed that ai, j = aj, i and there is at least one solution consistent with the information given.
Output
Print n space separated integers, which represents a permutation that could have generated these values. If there are multiple possible solutions, print any of them.
Examples
Input
2
0 1
1 0
Output
2 1
Input
5
0 2 2 1 2
2 0 4 1 3
2 4 0 1 3
1 1 1 0 1
2 3 3 1 0
Output
2 5 4 1 3
Note
In the first case, the answer can be {1, 2} or {2, 1}.
In the second case, another possible answer is {2, 4, 5, 1, 3}. | instruction | 0 | 62,737 | 12 | 125,474 |
Tags: constructive algorithms
Correct Solution:
```
n = int(input())
a = [list(map(int, input().split())) for _ in range(n)]
res = list()
used = set()
for i in range(n):
count = dict()
for j in range(n):
if i == j:
continue
if a[i][j] not in count:
count[a[i][j]] = 0
count[a[i][j]] += 1
for c in count:
if n - count[c] == c:
if c in used:
res.append(c+1)
else:
res.append(c)
used.add(c)
print(" ".join(map(str, res)))
``` | output | 1 | 62,737 | 12 | 125,475 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob has a permutation of integers from 1 to n. Denote this permutation as p. The i-th element of p will be denoted as pi. For all pairs of distinct integers i, j between 1 and n, he wrote the number ai, j = min(pi, pj). He writes ai, i = 0 for all integer i from 1 to n.
Bob gave you all the values of ai, j that he wrote down. Your job is to reconstruct any permutation that could have generated these values. The input will be formed so that it is guaranteed that there is at least one solution that is consistent with the information given.
Input
The first line of the input will contain a single integer n (2 ≤ n ≤ 50).
The next n lines will contain the values of ai, j. The j-th number on the i-th line will represent ai, j. The i-th number on the i-th line will be 0. It's guaranteed that ai, j = aj, i and there is at least one solution consistent with the information given.
Output
Print n space separated integers, which represents a permutation that could have generated these values. If there are multiple possible solutions, print any of them.
Examples
Input
2
0 1
1 0
Output
2 1
Input
5
0 2 2 1 2
2 0 4 1 3
2 4 0 1 3
1 1 1 0 1
2 3 3 1 0
Output
2 5 4 1 3
Note
In the first case, the answer can be {1, 2} or {2, 1}.
In the second case, another possible answer is {2, 4, 5, 1, 3}. | instruction | 0 | 62,738 | 12 | 125,476 |
Tags: constructive algorithms
Correct Solution:
```
n=int(input());v=[];tmp=0;t=False
for i in range(n):
v.append([0 for i in range(n+1)])
p=[0 for i in range(n)];
for i in range(n):
inp=list(map(int,input().split(" ")))
for k in inp:
v[i][k]+=1
for i in range(1,n+1):
for j in range(n):
if ((p[j]==0) and (v[j][i]==n-i)):
p[j]=i
for i in p:
if (t==0) and (i==n-1):
print(n,end=" ")
else:
print(i,end=" ")
if (i==n-1):
t=1
``` | output | 1 | 62,738 | 12 | 125,477 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob has a permutation of integers from 1 to n. Denote this permutation as p. The i-th element of p will be denoted as pi. For all pairs of distinct integers i, j between 1 and n, he wrote the number ai, j = min(pi, pj). He writes ai, i = 0 for all integer i from 1 to n.
Bob gave you all the values of ai, j that he wrote down. Your job is to reconstruct any permutation that could have generated these values. The input will be formed so that it is guaranteed that there is at least one solution that is consistent with the information given.
Input
The first line of the input will contain a single integer n (2 ≤ n ≤ 50).
The next n lines will contain the values of ai, j. The j-th number on the i-th line will represent ai, j. The i-th number on the i-th line will be 0. It's guaranteed that ai, j = aj, i and there is at least one solution consistent with the information given.
Output
Print n space separated integers, which represents a permutation that could have generated these values. If there are multiple possible solutions, print any of them.
Examples
Input
2
0 1
1 0
Output
2 1
Input
5
0 2 2 1 2
2 0 4 1 3
2 4 0 1 3
1 1 1 0 1
2 3 3 1 0
Output
2 5 4 1 3
Note
In the first case, the answer can be {1, 2} or {2, 1}.
In the second case, another possible answer is {2, 4, 5, 1, 3}. | instruction | 0 | 62,739 | 12 | 125,478 |
Tags: constructive algorithms
Correct Solution:
```
def s():
n = int(input())
a = []
for _ in range(n):
a.append(max(map(int,input().split(' '))))
a[a.index(n-1)] = n
print(*a)
s()
``` | output | 1 | 62,739 | 12 | 125,479 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob has a permutation of integers from 1 to n. Denote this permutation as p. The i-th element of p will be denoted as pi. For all pairs of distinct integers i, j between 1 and n, he wrote the number ai, j = min(pi, pj). He writes ai, i = 0 for all integer i from 1 to n.
Bob gave you all the values of ai, j that he wrote down. Your job is to reconstruct any permutation that could have generated these values. The input will be formed so that it is guaranteed that there is at least one solution that is consistent with the information given.
Input
The first line of the input will contain a single integer n (2 ≤ n ≤ 50).
The next n lines will contain the values of ai, j. The j-th number on the i-th line will represent ai, j. The i-th number on the i-th line will be 0. It's guaranteed that ai, j = aj, i and there is at least one solution consistent with the information given.
Output
Print n space separated integers, which represents a permutation that could have generated these values. If there are multiple possible solutions, print any of them.
Examples
Input
2
0 1
1 0
Output
2 1
Input
5
0 2 2 1 2
2 0 4 1 3
2 4 0 1 3
1 1 1 0 1
2 3 3 1 0
Output
2 5 4 1 3
Note
In the first case, the answer can be {1, 2} or {2, 1}.
In the second case, another possible answer is {2, 4, 5, 1, 3}. | instruction | 0 | 62,740 | 12 | 125,480 |
Tags: constructive algorithms
Correct Solution:
```
n = int(input())
R = lambda : map(int, input().split())
v = []
for i in range(n):
v.append((max(R()),i))
r = [0]*n
v = sorted(v)
for i in range(n):
r[v[i][1]]=i+1
print(*r)
``` | output | 1 | 62,740 | 12 | 125,481 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Bob has a permutation of integers from 1 to n. Denote this permutation as p. The i-th element of p will be denoted as pi. For all pairs of distinct integers i, j between 1 and n, he wrote the number ai, j = min(pi, pj). He writes ai, i = 0 for all integer i from 1 to n.
Bob gave you all the values of ai, j that he wrote down. Your job is to reconstruct any permutation that could have generated these values. The input will be formed so that it is guaranteed that there is at least one solution that is consistent with the information given.
Input
The first line of the input will contain a single integer n (2 ≤ n ≤ 50).
The next n lines will contain the values of ai, j. The j-th number on the i-th line will represent ai, j. The i-th number on the i-th line will be 0. It's guaranteed that ai, j = aj, i and there is at least one solution consistent with the information given.
Output
Print n space separated integers, which represents a permutation that could have generated these values. If there are multiple possible solutions, print any of them.
Examples
Input
2
0 1
1 0
Output
2 1
Input
5
0 2 2 1 2
2 0 4 1 3
2 4 0 1 3
1 1 1 0 1
2 3 3 1 0
Output
2 5 4 1 3
Note
In the first case, the answer can be {1, 2} or {2, 1}.
In the second case, another possible answer is {2, 4, 5, 1, 3}. | instruction | 0 | 62,741 | 12 | 125,482 |
Tags: constructive algorithms
Correct Solution:
```
n = int(input())
saida = []
for _ in range(n):
l = [int(x) for x in input().split()]
saida.append(max(l))
i = saida.index(max(saida))
saida[i] = n
print(' '.join(map(str, saida)))
# print(min(matriz))
``` | output | 1 | 62,741 | 12 | 125,483 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob has a permutation of integers from 1 to n. Denote this permutation as p. The i-th element of p will be denoted as pi. For all pairs of distinct integers i, j between 1 and n, he wrote the number ai, j = min(pi, pj). He writes ai, i = 0 for all integer i from 1 to n.
Bob gave you all the values of ai, j that he wrote down. Your job is to reconstruct any permutation that could have generated these values. The input will be formed so that it is guaranteed that there is at least one solution that is consistent with the information given.
Input
The first line of the input will contain a single integer n (2 ≤ n ≤ 50).
The next n lines will contain the values of ai, j. The j-th number on the i-th line will represent ai, j. The i-th number on the i-th line will be 0. It's guaranteed that ai, j = aj, i and there is at least one solution consistent with the information given.
Output
Print n space separated integers, which represents a permutation that could have generated these values. If there are multiple possible solutions, print any of them.
Examples
Input
2
0 1
1 0
Output
2 1
Input
5
0 2 2 1 2
2 0 4 1 3
2 4 0 1 3
1 1 1 0 1
2 3 3 1 0
Output
2 5 4 1 3
Note
In the first case, the answer can be {1, 2} or {2, 1}.
In the second case, another possible answer is {2, 4, 5, 1, 3}.
Submitted Solution:
```
t=int(input())
for i in range(t):
l=[]
l=list(map(int,input().split()))
s=set(l)
if(len(s)==len(l)):
break
for i in l:
if(i==0):
print(t,end=" ")
else:
print(i,end=" ")
``` | instruction | 0 | 62,742 | 12 | 125,484 |
Yes | output | 1 | 62,742 | 12 | 125,485 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob has a permutation of integers from 1 to n. Denote this permutation as p. The i-th element of p will be denoted as pi. For all pairs of distinct integers i, j between 1 and n, he wrote the number ai, j = min(pi, pj). He writes ai, i = 0 for all integer i from 1 to n.
Bob gave you all the values of ai, j that he wrote down. Your job is to reconstruct any permutation that could have generated these values. The input will be formed so that it is guaranteed that there is at least one solution that is consistent with the information given.
Input
The first line of the input will contain a single integer n (2 ≤ n ≤ 50).
The next n lines will contain the values of ai, j. The j-th number on the i-th line will represent ai, j. The i-th number on the i-th line will be 0. It's guaranteed that ai, j = aj, i and there is at least one solution consistent with the information given.
Output
Print n space separated integers, which represents a permutation that could have generated these values. If there are multiple possible solutions, print any of them.
Examples
Input
2
0 1
1 0
Output
2 1
Input
5
0 2 2 1 2
2 0 4 1 3
2 4 0 1 3
1 1 1 0 1
2 3 3 1 0
Output
2 5 4 1 3
Note
In the first case, the answer can be {1, 2} or {2, 1}.
In the second case, another possible answer is {2, 4, 5, 1, 3}.
Submitted Solution:
```
n = int(input())
b = [[0] * 2 for i in range(n)]
for i in range(n):
a = [int(s) for s in input().split()]
for j in range(n):
b[i][0] += a[j]
b[i][1] = i
b.sort()
ans = [0]*n
sum = 0
for i in range(n - 1):
ans[b[i][1]] = (b[i][0] - sum)// (n - 1 - i)
sum += ans[b[i][1]]
ans[b[n - 1][1]] = n
s = ''
for i in range(n):
s += str(ans[i]) + ' '
print(s)
``` | instruction | 0 | 62,743 | 12 | 125,486 |
Yes | output | 1 | 62,743 | 12 | 125,487 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob has a permutation of integers from 1 to n. Denote this permutation as p. The i-th element of p will be denoted as pi. For all pairs of distinct integers i, j between 1 and n, he wrote the number ai, j = min(pi, pj). He writes ai, i = 0 for all integer i from 1 to n.
Bob gave you all the values of ai, j that he wrote down. Your job is to reconstruct any permutation that could have generated these values. The input will be formed so that it is guaranteed that there is at least one solution that is consistent with the information given.
Input
The first line of the input will contain a single integer n (2 ≤ n ≤ 50).
The next n lines will contain the values of ai, j. The j-th number on the i-th line will represent ai, j. The i-th number on the i-th line will be 0. It's guaranteed that ai, j = aj, i and there is at least one solution consistent with the information given.
Output
Print n space separated integers, which represents a permutation that could have generated these values. If there are multiple possible solutions, print any of them.
Examples
Input
2
0 1
1 0
Output
2 1
Input
5
0 2 2 1 2
2 0 4 1 3
2 4 0 1 3
1 1 1 0 1
2 3 3 1 0
Output
2 5 4 1 3
Note
In the first case, the answer can be {1, 2} or {2, 1}.
In the second case, another possible answer is {2, 4, 5, 1, 3}.
Submitted Solution:
```
from sys import *
inp = lambda : stdin.readline()
def main():
n = int(inp())
ans = None
for i in range(n):
l = list(map(int,inp().split()))
if len(set(l)) == n:
ans = l
break
for i in range(len(ans)):
if ans[i] == 0: ans[i] = n
print(' '.join(map(str,ans)))
if __name__ == "__main__":
main()
``` | instruction | 0 | 62,744 | 12 | 125,488 |
Yes | output | 1 | 62,744 | 12 | 125,489 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob has a permutation of integers from 1 to n. Denote this permutation as p. The i-th element of p will be denoted as pi. For all pairs of distinct integers i, j between 1 and n, he wrote the number ai, j = min(pi, pj). He writes ai, i = 0 for all integer i from 1 to n.
Bob gave you all the values of ai, j that he wrote down. Your job is to reconstruct any permutation that could have generated these values. The input will be formed so that it is guaranteed that there is at least one solution that is consistent with the information given.
Input
The first line of the input will contain a single integer n (2 ≤ n ≤ 50).
The next n lines will contain the values of ai, j. The j-th number on the i-th line will represent ai, j. The i-th number on the i-th line will be 0. It's guaranteed that ai, j = aj, i and there is at least one solution consistent with the information given.
Output
Print n space separated integers, which represents a permutation that could have generated these values. If there are multiple possible solutions, print any of them.
Examples
Input
2
0 1
1 0
Output
2 1
Input
5
0 2 2 1 2
2 0 4 1 3
2 4 0 1 3
1 1 1 0 1
2 3 3 1 0
Output
2 5 4 1 3
Note
In the first case, the answer can be {1, 2} or {2, 1}.
In the second case, another possible answer is {2, 4, 5, 1, 3}.
Submitted Solution:
```
n = int(input())
p = []
for i in range(n):
p.append(list(map(int, input().split())))
p[i].sort()
p[i].append(i)
p.sort()
pos = [0] * n
for i in range(n):
pos[p[i][-1]] = i + 1
print(*pos)
``` | instruction | 0 | 62,745 | 12 | 125,490 |
Yes | output | 1 | 62,745 | 12 | 125,491 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob has a permutation of integers from 1 to n. Denote this permutation as p. The i-th element of p will be denoted as pi. For all pairs of distinct integers i, j between 1 and n, he wrote the number ai, j = min(pi, pj). He writes ai, i = 0 for all integer i from 1 to n.
Bob gave you all the values of ai, j that he wrote down. Your job is to reconstruct any permutation that could have generated these values. The input will be formed so that it is guaranteed that there is at least one solution that is consistent with the information given.
Input
The first line of the input will contain a single integer n (2 ≤ n ≤ 50).
The next n lines will contain the values of ai, j. The j-th number on the i-th line will represent ai, j. The i-th number on the i-th line will be 0. It's guaranteed that ai, j = aj, i and there is at least one solution consistent with the information given.
Output
Print n space separated integers, which represents a permutation that could have generated these values. If there are multiple possible solutions, print any of them.
Examples
Input
2
0 1
1 0
Output
2 1
Input
5
0 2 2 1 2
2 0 4 1 3
2 4 0 1 3
1 1 1 0 1
2 3 3 1 0
Output
2 5 4 1 3
Note
In the first case, the answer can be {1, 2} or {2, 1}.
In the second case, another possible answer is {2, 4, 5, 1, 3}.
Submitted Solution:
```
n = int(input())
a = [list(map(int, input().split())) for _ in range(n)]
res = list()
for i in range(n):
greater = {a[i][j] for j in range(n)}
res.append(len(greater) - 1)
if i >= 1 and res[i] == res[i-1]:
res[i] += 1
wrong = False
for x in range(i+1):
if wrong:
break
for y in range(x+1, i+1):
if min(res[x], res[y]) != a[x][y]:
wrong = True
break
if wrong:
res[i] -= 1
res[i-1] += 1
print(" ".join(map(str, res)))
``` | instruction | 0 | 62,746 | 12 | 125,492 |
No | output | 1 | 62,746 | 12 | 125,493 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob has a permutation of integers from 1 to n. Denote this permutation as p. The i-th element of p will be denoted as pi. For all pairs of distinct integers i, j between 1 and n, he wrote the number ai, j = min(pi, pj). He writes ai, i = 0 for all integer i from 1 to n.
Bob gave you all the values of ai, j that he wrote down. Your job is to reconstruct any permutation that could have generated these values. The input will be formed so that it is guaranteed that there is at least one solution that is consistent with the information given.
Input
The first line of the input will contain a single integer n (2 ≤ n ≤ 50).
The next n lines will contain the values of ai, j. The j-th number on the i-th line will represent ai, j. The i-th number on the i-th line will be 0. It's guaranteed that ai, j = aj, i and there is at least one solution consistent with the information given.
Output
Print n space separated integers, which represents a permutation that could have generated these values. If there are multiple possible solutions, print any of them.
Examples
Input
2
0 1
1 0
Output
2 1
Input
5
0 2 2 1 2
2 0 4 1 3
2 4 0 1 3
1 1 1 0 1
2 3 3 1 0
Output
2 5 4 1 3
Note
In the first case, the answer can be {1, 2} or {2, 1}.
In the second case, another possible answer is {2, 4, 5, 1, 3}.
Submitted Solution:
```
n = int(input());lst=[0]*n
for i in range(n):
x=list(map(int,input().split()))
for j in x[i+1:]:
if j not in lst:
if lst[i]==0:
lst[i]=j
else:
lst[x.index(j)]=j
lst[lst.index(0)] = n
print(*lst)
``` | instruction | 0 | 62,747 | 12 | 125,494 |
No | output | 1 | 62,747 | 12 | 125,495 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob has a permutation of integers from 1 to n. Denote this permutation as p. The i-th element of p will be denoted as pi. For all pairs of distinct integers i, j between 1 and n, he wrote the number ai, j = min(pi, pj). He writes ai, i = 0 for all integer i from 1 to n.
Bob gave you all the values of ai, j that he wrote down. Your job is to reconstruct any permutation that could have generated these values. The input will be formed so that it is guaranteed that there is at least one solution that is consistent with the information given.
Input
The first line of the input will contain a single integer n (2 ≤ n ≤ 50).
The next n lines will contain the values of ai, j. The j-th number on the i-th line will represent ai, j. The i-th number on the i-th line will be 0. It's guaranteed that ai, j = aj, i and there is at least one solution consistent with the information given.
Output
Print n space separated integers, which represents a permutation that could have generated these values. If there are multiple possible solutions, print any of them.
Examples
Input
2
0 1
1 0
Output
2 1
Input
5
0 2 2 1 2
2 0 4 1 3
2 4 0 1 3
1 1 1 0 1
2 3 3 1 0
Output
2 5 4 1 3
Note
In the first case, the answer can be {1, 2} or {2, 1}.
In the second case, another possible answer is {2, 4, 5, 1, 3}.
Submitted Solution:
```
n = int(input())
x = list()
for i in range(n):
y = input().split(' ')
y = [int(k) for k in y]
y = int(max(y))
x.append(y)
for i in range(len(x)):
if x[i] in x[i+1:]:
x[x[i+1:].index(x[i]) + i] = x[i] + 1
print(x)
``` | instruction | 0 | 62,748 | 12 | 125,496 |
No | output | 1 | 62,748 | 12 | 125,497 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bob has a permutation of integers from 1 to n. Denote this permutation as p. The i-th element of p will be denoted as pi. For all pairs of distinct integers i, j between 1 and n, he wrote the number ai, j = min(pi, pj). He writes ai, i = 0 for all integer i from 1 to n.
Bob gave you all the values of ai, j that he wrote down. Your job is to reconstruct any permutation that could have generated these values. The input will be formed so that it is guaranteed that there is at least one solution that is consistent with the information given.
Input
The first line of the input will contain a single integer n (2 ≤ n ≤ 50).
The next n lines will contain the values of ai, j. The j-th number on the i-th line will represent ai, j. The i-th number on the i-th line will be 0. It's guaranteed that ai, j = aj, i and there is at least one solution consistent with the information given.
Output
Print n space separated integers, which represents a permutation that could have generated these values. If there are multiple possible solutions, print any of them.
Examples
Input
2
0 1
1 0
Output
2 1
Input
5
0 2 2 1 2
2 0 4 1 3
2 4 0 1 3
1 1 1 0 1
2 3 3 1 0
Output
2 5 4 1 3
Note
In the first case, the answer can be {1, 2} or {2, 1}.
In the second case, another possible answer is {2, 4, 5, 1, 3}.
Submitted Solution:
```
if __name__=='__main__':
n = int(input())
lst = []
# i = 1
while n>=1:
if len(lst)==0:
#print("he")
lst.append(1)
else:
lst.append(1)
#print("se")
while lst[len(lst)-1]==lst[len(lst)-2] and len(lst)>1:
k = lst[len(lst)-1]+1
lst.pop()
lst.pop()
lst.append(k)
#i += 1
n -= 1
for i in lst:
print(i,end=' ')
``` | instruction | 0 | 62,749 | 12 | 125,498 |
No | output | 1 | 62,749 | 12 | 125,499 |
Provide a correct Python 3 solution for this coding contest problem.
Shortest Common Non-Subsequence
A subsequence of a sequence $P$ is a sequence that can be derived from the original sequence $P$ by picking up some or no elements of $P$ preserving the order. For example, "ICPC" is a subsequence of "MICROPROCESSOR".
A common subsequence of two sequences is a subsequence of both sequences. The famous longest common subsequence problem is finding the longest of common subsequences of two given sequences.
In this problem, conversely, we consider the shortest common non-subsequence problem: Given two sequences consisting of 0 and 1, your task is to find the shortest sequence also consisting of 0 and 1 that is a subsequence of neither of the two sequences.
Input
The input consists of a single test case with two lines. Both lines are sequences consisting only of 0 and 1. Their lengths are between 1 and 4000, inclusive.
Output
Output in one line the shortest common non-subsequence of two given sequences. If there are two or more such sequences, you should output the lexicographically smallest one. Here, a sequence $P$ is lexicographically smaller than another sequence $Q$ of the same length if there exists $k$ such that $P_1 = Q_1, ... , P_{k-1} = Q_{k-1}$, and $P_k < Q_k$, where $S_i$ is the $i$-th character of a sequence $S$.
Sample Input 1
0101
1100001
Sample Output 1
0010
Sample Input 2
101010101
010101010
Sample Output 2
000000
Sample Input 3
11111111
00000000
Sample Output 3
01
Example
Input
0101
1100001
Output
0010 | instruction | 0 | 63,085 | 12 | 126,170 |
"Correct Solution:
```
#!/usr/bin/python3
import array
import os
import sys
def main():
S = inp()
T = inp()
print(solve(S, T))
def solve(S, T):
sn = len(S)
tn = len(T)
sd = [[sn + 1] * (sn + 1), [sn + 1] * (sn + 1)]
for i in range(sn):
idx = ord(S[i]) - ord('0')
for j in range(i, -1, -1):
if sd[idx][j] != sn + 1:
break
sd[idx][j] = i + 1
td = [[tn + 1] * (tn + 1), [tn + 1] * (tn + 1)]
for i in range(tn):
idx = ord(T[i]) - ord('0')
for j in range(i, -1, -1):
if td[idx][j] != tn + 1:
break
td[idx][j] = i + 1
#dprint('sd', sd)
#dprint('td', td)
sb = [[[] for _ in range(sn + 2)] for _ in range(2)]
for b in (0, 1):
for i in range(sn + 1):
sb[b][sd[b][i]].append(i)
sb[b][sn + 1].append(sn + 1)
tb = [[[] for _ in range(tn + 2)] for _ in range(2)]
for b in (0, 1):
for i in range(tn + 1):
tb[b][td[b][i]].append(i)
tb[b][tn + 1].append(tn + 1)
#dprint('sb', sb)
#dprint('tb', tb)
INF = max(sn, tn) + 2
arr_temp = [INF] * (tn + 2)
dists = [array.array('i', arr_temp) for _ in range(sn + 2)]
q = set()
q.add((sn + 1, tn + 1))
d = 0
while q:
nq = set()
for i, j in q:
if dists[i][j] != INF:
continue
dists[i][j] = d
for b in (0, 1):
for ni in sb[b][i]:
for nj in tb[b][j]:
if dists[ni][nj] == INF and (ni, nj) not in q:
nq.add((ni, nj))
d += 1
q = nq
#dprint('dists', dists)
ans = []
i, j = 0, 0
d = dists[0][0]
while (i, j) != (sn + 1, tn + 1):
#dprint('->', i, j)
ni = sd[0][i] if i < sn + 1 else sn + 1
nj = td[0][j] if j < tn + 1 else tn + 1
if dists[ni][nj] == d - 1:
ans.append('0')
else:
ans.append('1')
ni = sd[1][i] if i < sn + 1 else sn + 1
nj = td[1][j] if j < tn + 1 else tn + 1
i = ni
j = nj
d -= 1
return ''.join(ans)
###############################################################################
# AUXILIARY FUNCTIONS
DEBUG = 'DEBUG' in os.environ
def inp():
return sys.stdin.readline().rstrip()
def read_int():
return int(inp())
def read_ints():
return [int(e) for e in inp().split()]
def dprint(*value, sep=' ', end='\n'):
if DEBUG:
print(*value, sep=sep, end=end)
if __name__ == '__main__':
main()
``` | output | 1 | 63,085 | 12 | 126,171 |
Provide a correct Python 3 solution for this coding contest problem.
Shortest Common Non-Subsequence
A subsequence of a sequence $P$ is a sequence that can be derived from the original sequence $P$ by picking up some or no elements of $P$ preserving the order. For example, "ICPC" is a subsequence of "MICROPROCESSOR".
A common subsequence of two sequences is a subsequence of both sequences. The famous longest common subsequence problem is finding the longest of common subsequences of two given sequences.
In this problem, conversely, we consider the shortest common non-subsequence problem: Given two sequences consisting of 0 and 1, your task is to find the shortest sequence also consisting of 0 and 1 that is a subsequence of neither of the two sequences.
Input
The input consists of a single test case with two lines. Both lines are sequences consisting only of 0 and 1. Their lengths are between 1 and 4000, inclusive.
Output
Output in one line the shortest common non-subsequence of two given sequences. If there are two or more such sequences, you should output the lexicographically smallest one. Here, a sequence $P$ is lexicographically smaller than another sequence $Q$ of the same length if there exists $k$ such that $P_1 = Q_1, ... , P_{k-1} = Q_{k-1}$, and $P_k < Q_k$, where $S_i$ is the $i$-th character of a sequence $S$.
Sample Input 1
0101
1100001
Sample Output 1
0010
Sample Input 2
101010101
010101010
Sample Output 2
000000
Sample Input 3
11111111
00000000
Sample Output 3
01
Example
Input
0101
1100001
Output
0010 | instruction | 0 | 63,086 | 12 | 126,172 |
"Correct Solution:
```
def main():
p=input()
q=input()
lp=len(p)
lq=len(q)
memop=[[0,0] for _ in [0]*(lp+2)]
memoq=[[0,0] for _ in [0]*(lq+2)]
memop[lp+1]=[lp+1,lp+1]
memoq[lq+1]=[lq+1,lq+1]
memop[lp]=[lp+1,lp+1]
memoq[lq]=[lq+1,lq+1]
for i in range(lp-1,-1,-1):
if p[i]=="0":
memop[i][0]=i+1
memop[i][1]=memop[i+1][1]
else:
memop[i][0]=memop[i+1][0]
memop[i][1]=i+1
for i in range(lq-1,-1,-1):
if q[i]=="0":
memoq[i][0]=i+1
memoq[i][1]=memoq[i+1][1]
else:
memoq[i][0]=memoq[i+1][0]
memoq[i][1]=i+1
dp=[dict() for _ in [0]*(lp+2)]
dp[lp+1][lq+1]=[0,0]
q=[[0,0]]
while q:
i,j=q.pop()
if j not in dp[i].keys():
dp[i][j]=[None,None]
a,b=None,None
else:
a,b=dp[i][j]
if a==None or b==None:
q.append([i,j])
if a==None:
ap,bq=memop[i][0],memoq[j][0]
if bq not in dp[ap].keys():
dp[ap][bq]=[None,None]
q.append([ap,bq])
else:
aa,bb=dp[ap][bq]
if aa==None or bb==None:
q.append([ap,bq])
else:
dp[i][j][0]=min(aa,bb)+1
if b==None:
ap,bq=memop[i][1],memoq[j][1]
if bq not in dp[ap].keys():
dp[ap][bq]=[None,None]
q.append([ap,bq])
else:
aa,bb=dp[ap][bq]
if aa==None or bb==None:
q.append([ap,bq])
else:
dp[i][j][1]=min(aa,bb)+1
q=[[0,0]]
ans=""
while q:
i,j=q.pop()
a,b=dp[i][j]
if a==0 or b==0:
break
if a>b:
q.append([memop[i][1],memoq[j][1]])
ans+="1"
else:
q.append([memop[i][0],memoq[j][0]])
ans+="0"
print(ans)
if __name__=='__main__':
main()
``` | output | 1 | 63,086 | 12 | 126,173 |
Provide a correct Python 3 solution for this coding contest problem.
You are given $n$ integers $w_i (i = 0, 1, ..., n-1)$ to be sorted in ascending order. You can swap two integers $w_i$ and $w_j$. Each swap operation has a cost, which is the sum of the two integers $w_i + w_j$. You can perform the operations any number of times.
Write a program which reports the minimal total cost to sort the given integers.
Constraints
* $1 \leq n \leq 1,000$
* $0 \leq w_i\leq 10^4$
* $w_i$ are all different
Input
In the first line, an integer $n$ is given. In the second line, $n$ integers $w_i (i = 0, 1, 2, ... n-1)$ separated by space characters are given.
Output
Print the minimal cost in a line.
Examples
Input
5
1 5 3 4 2
Output
7
Input
4
4 3 2 1
Output
10 | instruction | 0 | 63,124 | 12 | 126,248 |
"Correct Solution:
```
n = int(input())
w = list(map(int, input().split()))
b = w[:]
w.sort()
s = w[0]
class Solve():
def __init__(self, w, b, s):
self.w = w
self.b = b
self.s = s
self.ans = 0
self.v = [0] * n
def sort(self):
T = [0] * 10001
for i in range(n):
T[self.w[i]] = i
for i in range(n):
if self.v[i]:
continue
cur = i
S = 0
m = 10001
an = 0
while 1:
self.v[cur] = 1
an += 1
l = self.b[cur]
m = min(m, l)
S += l
cur = T[l]
if self.v[cur]:
break
self.ans += min(S + (an - 2) * m, S + m +(an + 1) * self.s)
return self
cost = Solve(w, b, s).sort()
print(cost.ans)
``` | output | 1 | 63,124 | 12 | 126,249 |
Provide a correct Python 3 solution for this coding contest problem.
You are given $n$ integers $w_i (i = 0, 1, ..., n-1)$ to be sorted in ascending order. You can swap two integers $w_i$ and $w_j$. Each swap operation has a cost, which is the sum of the two integers $w_i + w_j$. You can perform the operations any number of times.
Write a program which reports the minimal total cost to sort the given integers.
Constraints
* $1 \leq n \leq 1,000$
* $0 \leq w_i\leq 10^4$
* $w_i$ are all different
Input
In the first line, an integer $n$ is given. In the second line, $n$ integers $w_i (i = 0, 1, 2, ... n-1)$ separated by space characters are given.
Output
Print the minimal cost in a line.
Examples
Input
5
1 5 3 4 2
Output
7
Input
4
4 3 2 1
Output
10 | instruction | 0 | 63,125 | 12 | 126,250 |
"Correct Solution:
```
import copy
INFTY=1000000000
MAX = 1000
VMAX = 100000
def solve(W,N,VMAX):
T = [-1 for _ in range(VMAX)]
for i in range(N):
ans = 0
V = [False for _ in range(N)]
WW=copy.deepcopy(W)
WW.sort()
for i in range(N):
T[WW[i]] = i
for i in range(N):
if V[i]:
continue
cur = i
S = 0
m = VMAX
an = 0
while True:
V[cur] = True
an += 1
v = W[cur]
m = min(m,v)
S += v
cur = T[v]
if V[cur]:
break
ans += min(S + (an - 2) * m, m + S + (an + 1) * s)
return ans
N = int(input())
W = list(map(int,input().split()))
s = min(W)
ans = solve(W,N,VMAX)
print(ans)
``` | output | 1 | 63,125 | 12 | 126,251 |
Provide a correct Python 3 solution for this coding contest problem.
You are given $n$ integers $w_i (i = 0, 1, ..., n-1)$ to be sorted in ascending order. You can swap two integers $w_i$ and $w_j$. Each swap operation has a cost, which is the sum of the two integers $w_i + w_j$. You can perform the operations any number of times.
Write a program which reports the minimal total cost to sort the given integers.
Constraints
* $1 \leq n \leq 1,000$
* $0 \leq w_i\leq 10^4$
* $w_i$ are all different
Input
In the first line, an integer $n$ is given. In the second line, $n$ integers $w_i (i = 0, 1, 2, ... n-1)$ separated by space characters are given.
Output
Print the minimal cost in a line.
Examples
Input
5
1 5 3 4 2
Output
7
Input
4
4 3 2 1
Output
10 | instruction | 0 | 63,126 | 12 | 126,252 |
"Correct Solution:
```
def solve(A, n, s):
ans = 0
V = [False for i in range(n)] # 値が交換済みかどうか
B = sorted(A)
T = [None for i in range(10001)]
for i in range(n):
T[B[i]] = i
for i in range(n):
if V[i]: continue
cur = i # カーソル(サークル内で動かす)
S = 0 # サークル内の数字の総和
m = 10000
an = 0 # サークルに含まれる数字の数
while True:
V[cur] = True
an += 1
v = A[cur]
m = min(m, v) # mがサークル内の数字の最小値
S += v
cur = T[v]
if V[cur]: break
ans += min(S + (an-2)*m, m+S+(an+1)*s)
return ans
n = int(input())
A = list(map(int, input().split(' ')))
s = min(A)
ans = solve(A, n, s)
print(ans)
``` | output | 1 | 63,126 | 12 | 126,253 |
Provide a correct Python 3 solution for this coding contest problem.
You are given $n$ integers $w_i (i = 0, 1, ..., n-1)$ to be sorted in ascending order. You can swap two integers $w_i$ and $w_j$. Each swap operation has a cost, which is the sum of the two integers $w_i + w_j$. You can perform the operations any number of times.
Write a program which reports the minimal total cost to sort the given integers.
Constraints
* $1 \leq n \leq 1,000$
* $0 \leq w_i\leq 10^4$
* $w_i$ are all different
Input
In the first line, an integer $n$ is given. In the second line, $n$ integers $w_i (i = 0, 1, 2, ... n-1)$ separated by space characters are given.
Output
Print the minimal cost in a line.
Examples
Input
5
1 5 3 4 2
Output
7
Input
4
4 3 2 1
Output
10 | instruction | 0 | 63,127 | 12 | 126,254 |
"Correct Solution:
```
n = int(input())
wlist = list(map(int,input().split()))
wdic = {j:i for i,j in enumerate(wlist)}
wlist.sort()
cost = 0
used = [0]*n
res = []
for i in range(n):
storage = []
if used[i]:
continue # next loop
w = wlist[i]
minimum = w
used[i] = 1
a = wdic[w]
b = wlist[a]
storage.append(w)
while b not in storage:
w = b
used[a] = 1
a = wdic[w]
b = wlist[a]
storage.append(w)
#print(w,a,b,storage)
ls = len(storage)
cost += (sum(storage) - minimum)
res.append((minimum,ls))
m,l = res[0]
if l>=2:
cost += m*(l-1)
for minimum,ls in res[1:]:
if ls>=2:
cost += min(2*(m+minimum)+m*(ls-1), minimum*(ls-1))
print(cost)
``` | output | 1 | 63,127 | 12 | 126,255 |
Provide a correct Python 3 solution for this coding contest problem.
You are given $n$ integers $w_i (i = 0, 1, ..., n-1)$ to be sorted in ascending order. You can swap two integers $w_i$ and $w_j$. Each swap operation has a cost, which is the sum of the two integers $w_i + w_j$. You can perform the operations any number of times.
Write a program which reports the minimal total cost to sort the given integers.
Constraints
* $1 \leq n \leq 1,000$
* $0 \leq w_i\leq 10^4$
* $w_i$ are all different
Input
In the first line, an integer $n$ is given. In the second line, $n$ integers $w_i (i = 0, 1, 2, ... n-1)$ separated by space characters are given.
Output
Print the minimal cost in a line.
Examples
Input
5
1 5 3 4 2
Output
7
Input
4
4 3 2 1
Output
10 | instruction | 0 | 63,128 | 12 | 126,256 |
"Correct Solution:
```
def decode():
n = int(input())
w = [int(x) for x in input().split()]
return n, w
def search(w, sw, swi):
wi = w.index(sw[swi])
cost = 0
count = 0
while wi != swi:
tw = sw[wi]
ti = w.index(tw)
w[ti], w[wi] = w[wi], w[ti]
cost += w[ti] + w[wi]
count += 1
wi = ti
return cost, count
def search_min_cost(w):
sorted_w = list(w)
sorted_w.sort()
min_w = sorted_w[0]
cost = 0
for i, sww in enumerate(sorted_w):
tmp_cost, count = search(w, sorted_w, i)
cost += min(tmp_cost, tmp_cost + (min_w + sww) * 2 - (sww - min_w) * count)
return cost
if __name__ == '__main__':
n, w = decode()
print(search_min_cost(w))
``` | output | 1 | 63,128 | 12 | 126,257 |
Provide a correct Python 3 solution for this coding contest problem.
You are given $n$ integers $w_i (i = 0, 1, ..., n-1)$ to be sorted in ascending order. You can swap two integers $w_i$ and $w_j$. Each swap operation has a cost, which is the sum of the two integers $w_i + w_j$. You can perform the operations any number of times.
Write a program which reports the minimal total cost to sort the given integers.
Constraints
* $1 \leq n \leq 1,000$
* $0 \leq w_i\leq 10^4$
* $w_i$ are all different
Input
In the first line, an integer $n$ is given. In the second line, $n$ integers $w_i (i = 0, 1, 2, ... n-1)$ separated by space characters are given.
Output
Print the minimal cost in a line.
Examples
Input
5
1 5 3 4 2
Output
7
Input
4
4 3 2 1
Output
10 | instruction | 0 | 63,129 | 12 | 126,258 |
"Correct Solution:
```
def minimumCostSort(arr, arr_size):
cost = 0
sortarr = sorted(arr)
cyclecontainer = []
for i in range(arr_size):
cycle = [arr[i]]
next = sortarr.index(arr[i])
while arr[next] != arr[i]:
cycle += [arr[next]]
next = sortarr.index(arr[next])
cycle = sorted(cycle)
if cycle not in cyclecontainer:
cyclecontainer.append(cycle)
if len(cycle) == 1:
pass
elif len(cycle) == 2:
cost += sum(cycle)
elif len(cycle) >= 3:
cost += min(sum(cycle)+((len(cycle)-2)*min(cycle)), sum(cycle)+min(cycle)+((len(cycle)+1)*min(arr)))
return cost
n = int(input())
w = list(map(int, input().split()))
print(minimumCostSort(w, n))
``` | output | 1 | 63,129 | 12 | 126,259 |
Provide a correct Python 3 solution for this coding contest problem.
You are given $n$ integers $w_i (i = 0, 1, ..., n-1)$ to be sorted in ascending order. You can swap two integers $w_i$ and $w_j$. Each swap operation has a cost, which is the sum of the two integers $w_i + w_j$. You can perform the operations any number of times.
Write a program which reports the minimal total cost to sort the given integers.
Constraints
* $1 \leq n \leq 1,000$
* $0 \leq w_i\leq 10^4$
* $w_i$ are all different
Input
In the first line, an integer $n$ is given. In the second line, $n$ integers $w_i (i = 0, 1, 2, ... n-1)$ separated by space characters are given.
Output
Print the minimal cost in a line.
Examples
Input
5
1 5 3 4 2
Output
7
Input
4
4 3 2 1
Output
10 | instruction | 0 | 63,130 | 12 | 126,260 |
"Correct Solution:
```
def silly_sort(target):
ranked = sorted(target)
length = len(target)
rings = [n for n in range(length)]
all_cost = 0
minimum = ranked[0]
base_index = {}
rank_index = {}
for i, (t, r) in enumerate(zip(target, ranked)):
base_index[t] = i
rank_index[r] = i
for i in range(length):
if rings[i] != -1 and target[i] != ranked[i]:
ring_sum = target[i]
min_m = target[i]
num_ring = 1
next_index = rank_index[target[i]]
next_num = target[next_index]
while next_index != i:
# print(i, next_index, target[i], min_m, ring_sum)
num_ring += 1
ring_sum += next_num
min_m = min(min_m, next_num)
rings[next_index] = -1
next_index = rank_index[target[next_index]]
next_num = target[next_index]
# print(min((ring_sum + min_m * (num_ring - 2) ), (ring_sum + min_m + minimum * (num_ring + 1) ) ))
all_cost += min((ring_sum + min_m * (num_ring - 2) ), (ring_sum + min_m + minimum * (num_ring + 1) ) )
rings[i] = -1
return all_cost
l = int(input())
t = [int(n) for n in input().split(" ")]
print(silly_sort(t))
``` | output | 1 | 63,130 | 12 | 126,261 |
Provide a correct Python 3 solution for this coding contest problem.
You are given $n$ integers $w_i (i = 0, 1, ..., n-1)$ to be sorted in ascending order. You can swap two integers $w_i$ and $w_j$. Each swap operation has a cost, which is the sum of the two integers $w_i + w_j$. You can perform the operations any number of times.
Write a program which reports the minimal total cost to sort the given integers.
Constraints
* $1 \leq n \leq 1,000$
* $0 \leq w_i\leq 10^4$
* $w_i$ are all different
Input
In the first line, an integer $n$ is given. In the second line, $n$ integers $w_i (i = 0, 1, 2, ... n-1)$ separated by space characters are given.
Output
Print the minimal cost in a line.
Examples
Input
5
1 5 3 4 2
Output
7
Input
4
4 3 2 1
Output
10 | instruction | 0 | 63,131 | 12 | 126,262 |
"Correct Solution:
```
import copy
MAX_LENGTH = 1000
MAX_WEIGHT = 10001
def minimum_sort_cost(A):
cost = 0
n = len(A)
s = min(A)
B = sorted(A)
V = [False] * n
T = [None] * MAX_WEIGHT
for i in range(n):
T[B[i]] = i
for i in range(n):
if V[i]:
continue
cur = i
circle_len = 0
min_weight = MAX_WEIGHT
circle_weight = 0
while(True):
V[cur] = True
circle_len += 1
weight = A[cur]
min_weight = min(min_weight, weight)
circle_weight += weight
cur = T[weight]
if V[cur]:
break
cost += min(circle_weight + (circle_len - 2) * min_weight,\
min_weight + circle_weight + (circle_len + 1) * s)
return cost
if __name__ == "__main__":
n = int(input())
*A, = map(int, input().split())
print(minimum_sort_cost(A))
``` | output | 1 | 63,131 | 12 | 126,263 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given $n$ integers $w_i (i = 0, 1, ..., n-1)$ to be sorted in ascending order. You can swap two integers $w_i$ and $w_j$. Each swap operation has a cost, which is the sum of the two integers $w_i + w_j$. You can perform the operations any number of times.
Write a program which reports the minimal total cost to sort the given integers.
Constraints
* $1 \leq n \leq 1,000$
* $0 \leq w_i\leq 10^4$
* $w_i$ are all different
Input
In the first line, an integer $n$ is given. In the second line, $n$ integers $w_i (i = 0, 1, 2, ... n-1)$ separated by space characters are given.
Output
Print the minimal cost in a line.
Examples
Input
5
1 5 3 4 2
Output
7
Input
4
4 3 2 1
Output
10
Submitted Solution:
```
def minimum_cost_sort(A):
cost = 0
B = sorted(A)
for i in range(len(B)):
x = A.index(B[i])
cnt = 0
tmp = 0
while x != i:
y = A.index(B[x])
A[x], A[y] = A[y], A[x]
tmp += A[x] + A[y]
cnt += 1
x = y
if cnt > 0:
# compare with procedure as follows:
# convert B[i] and B[0] (minimum item) : cost = B[i] + B[0]
# sort with B[0] in the same way : cost diff = (B[i] - B[0]) * cnt
# reconvert B[0] and B[i] : cost = B[i] + B[0]
cost += min(tmp, (B[i] + B[0]) * 2 + tmp - (B[i] - B[0]) * cnt)
return cost
N = int(input())
A = list(map(int, input().split()))
print(minimum_cost_sort(A))
``` | instruction | 0 | 63,132 | 12 | 126,264 |
Yes | output | 1 | 63,132 | 12 | 126,265 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given $n$ integers $w_i (i = 0, 1, ..., n-1)$ to be sorted in ascending order. You can swap two integers $w_i$ and $w_j$. Each swap operation has a cost, which is the sum of the two integers $w_i + w_j$. You can perform the operations any number of times.
Write a program which reports the minimal total cost to sort the given integers.
Constraints
* $1 \leq n \leq 1,000$
* $0 \leq w_i\leq 10^4$
* $w_i$ are all different
Input
In the first line, an integer $n$ is given. In the second line, $n$ integers $w_i (i = 0, 1, 2, ... n-1)$ separated by space characters are given.
Output
Print the minimal cost in a line.
Examples
Input
5
1 5 3 4 2
Output
7
Input
4
4 3 2 1
Output
10
Submitted Solution:
```
"""Minimum cost Sort."""
def min_cost_sort(A):
"""Sort list A in ascending order.
And return the switching cost in sorting.
"""
B = list(A)
B.sort()
cost = 0
min_w = B[0]
for i, b in enumerate(B):
tmp_cost = 0
bi = A.index(b)
cnt = 0
while bi != i:
cnt += 1
st = B[bi]
si = A.index(st)
tmp_cost += b + st
A[bi], A[si] = st, b
bi = si
dec = cnt * (b - min_w)
inc = 2 * (min_w + b)
if dec < inc:
cost += tmp_cost
else:
cost += tmp_cost - dec + inc
return cost
n = input()
A = list(map(int, input().split()))
ans = min_cost_sort(A)
print(ans)
``` | instruction | 0 | 63,133 | 12 | 126,266 |
Yes | output | 1 | 63,133 | 12 | 126,267 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given $n$ integers $w_i (i = 0, 1, ..., n-1)$ to be sorted in ascending order. You can swap two integers $w_i$ and $w_j$. Each swap operation has a cost, which is the sum of the two integers $w_i + w_j$. You can perform the operations any number of times.
Write a program which reports the minimal total cost to sort the given integers.
Constraints
* $1 \leq n \leq 1,000$
* $0 \leq w_i\leq 10^4$
* $w_i$ are all different
Input
In the first line, an integer $n$ is given. In the second line, $n$ integers $w_i (i = 0, 1, 2, ... n-1)$ separated by space characters are given.
Output
Print the minimal cost in a line.
Examples
Input
5
1 5 3 4 2
Output
7
Input
4
4 3 2 1
Output
10
Submitted Solution:
```
mp = {}
MAXN = 1010
mini = 100000
w = [0] * MAXN
done = [False] * MAXN
n = int(input())
w1 = [int(i) for i in input().split()]
for index, value in enumerate(w1):
w[index] = value
for i in range(n):
mp[w[i]] = 0
mini = min(mini, w[i])
k = 0
for i in sorted(w1):
mp[i] = k
k += 1
ans = 0
for i in range(n):
if done[i]: continue
cnt = 0
now = i
mi = 100000
total = 0
while (True):
if done[now]: break
cnt += 1
done[now] = True
mi = min(mi, w[now])
total += w[now]
now = mp[w[now]]
tmp = total + (cnt - 2) * mi
tmp = min(tmp, total + mi + mini * (cnt + 1))
ans += tmp
print(ans)
``` | instruction | 0 | 63,134 | 12 | 126,268 |
Yes | output | 1 | 63,134 | 12 | 126,269 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given $n$ integers $w_i (i = 0, 1, ..., n-1)$ to be sorted in ascending order. You can swap two integers $w_i$ and $w_j$. Each swap operation has a cost, which is the sum of the two integers $w_i + w_j$. You can perform the operations any number of times.
Write a program which reports the minimal total cost to sort the given integers.
Constraints
* $1 \leq n \leq 1,000$
* $0 \leq w_i\leq 10^4$
* $w_i$ are all different
Input
In the first line, an integer $n$ is given. In the second line, $n$ integers $w_i (i = 0, 1, 2, ... n-1)$ separated by space characters are given.
Output
Print the minimal cost in a line.
Examples
Input
5
1 5 3 4 2
Output
7
Input
4
4 3 2 1
Output
10
Submitted Solution:
```
n=int(input())
a=[int(i) for i in input().split()]
b=sorted(a)
c=0
for i in range(n-1):
t,cnt=0,0
x=a.index(b[i])
while x!=i:
y=a.index(b[x])
a[x],a[y]=b[x],b[i]
t+=b[x]+b[i]
cnt+=1
x=y
if cnt:
c+=min(t,(b[i]+b[0])*2+t-(b[i]-b[0])*cnt)
print(c)
``` | instruction | 0 | 63,135 | 12 | 126,270 |
Yes | output | 1 | 63,135 | 12 | 126,271 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given $n$ integers $w_i (i = 0, 1, ..., n-1)$ to be sorted in ascending order. You can swap two integers $w_i$ and $w_j$. Each swap operation has a cost, which is the sum of the two integers $w_i + w_j$. You can perform the operations any number of times.
Write a program which reports the minimal total cost to sort the given integers.
Constraints
* $1 \leq n \leq 1,000$
* $0 \leq w_i\leq 10^4$
* $w_i$ are all different
Input
In the first line, an integer $n$ is given. In the second line, $n$ integers $w_i (i = 0, 1, 2, ... n-1)$ separated by space characters are given.
Output
Print the minimal cost in a line.
Examples
Input
5
1 5 3 4 2
Output
7
Input
4
4 3 2 1
Output
10
Submitted Solution:
```
"""Minimum cost Sort."""
def min_c_sort(A, n):
cost = 0
for i in range(n - 1):
min_i = i
for j in range(i + 1, n):
if A[min_i] > A[j]:
min_i = j
if min_i != i:
cost += A[min_i]
cost += A[i]
A[min_i], A[i] = A[i], A[min_i]
return cost
n = int(input())
A = list(map(int, input().split()))
cost = min_c_sort(A, n)
print(cost)
``` | instruction | 0 | 63,136 | 12 | 126,272 |
No | output | 1 | 63,136 | 12 | 126,273 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given $n$ integers $w_i (i = 0, 1, ..., n-1)$ to be sorted in ascending order. You can swap two integers $w_i$ and $w_j$. Each swap operation has a cost, which is the sum of the two integers $w_i + w_j$. You can perform the operations any number of times.
Write a program which reports the minimal total cost to sort the given integers.
Constraints
* $1 \leq n \leq 1,000$
* $0 \leq w_i\leq 10^4$
* $w_i$ are all different
Input
In the first line, an integer $n$ is given. In the second line, $n$ integers $w_i (i = 0, 1, 2, ... n-1)$ separated by space characters are given.
Output
Print the minimal cost in a line.
Examples
Input
5
1 5 3 4 2
Output
7
Input
4
4 3 2 1
Output
10
Submitted Solution:
```
#http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_6_D
#????°???????????????????
def partition(target_list, l, r):
x = target_list[r]
i = l - 1
for j in range(l, r):
if target_list[j] <= x:
i = i + 1
tmp = target_list[i]
target_list[i] = target_list[j]
target_list[j] = tmp
tmp = target_list[r]
target_list[r] = target_list[i + 1]
target_list[i + 1] = tmp
return i + 1
def quick_sort(target_list, l, r):
if l < r:
c = partition(target_list, l, r)
quick_sort(target_list, l, c - 1)
quick_sort(target_list, c + 1, r)
def processA(target_list, correct_list, i):
cost = 0
while not correct_list[i] == target_list[i]:
min_i = target_list.index(correct_list[i])
change_i = target_list.index(correct_list[min_i])
cost += (target_list[min_i] + target_list[change_i])
target_list[min_i], target_list[change_i] = target_list[change_i], target_list[min_i]
return cost
def processB(target_list, correct_list, i):
most_min = correct_list[0]
second_min = correct_list[i]
cost = (most_min + second_min)
mmi = target_list.index(most_min)
smi = target_list.index(second_min)
target_list[mmi], target_list[smi] = target_list[smi], target_list[mmi]
while not correct_list[i] == target_list[i]:
print(target_list)
min_i = target_list.index(correct_list[i])
change_i = target_list.index(correct_list[min_i])
cost += (target_list[min_i] + target_list[change_i])
target_list[min_i], target_list[change_i] = target_list[change_i], target_list[min_i]
return cost
def minimum_cost_sort(target_list):
correct_list = [a for a in target_list]
quick_sort(correct_list, 0, len(correct_list) - 1)
cost = 0
i = 0
while not correct_list == target_list:
cost_a = processA(target_list, correct_list, i)
cost_b = processB([a for a in target_list], correct_list, i)
cost += min(cost_a, cost_b)
print(cost_a, cost_b)
#print(target_list)
i += 1
return cost
def main():
n_list = input()
target_list = [int(s) for s in input().split()]
print(minimum_cost_sort(target_list))
if __name__ == "__main__":
main()
``` | instruction | 0 | 63,137 | 12 | 126,274 |
No | output | 1 | 63,137 | 12 | 126,275 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given $n$ integers $w_i (i = 0, 1, ..., n-1)$ to be sorted in ascending order. You can swap two integers $w_i$ and $w_j$. Each swap operation has a cost, which is the sum of the two integers $w_i + w_j$. You can perform the operations any number of times.
Write a program which reports the minimal total cost to sort the given integers.
Constraints
* $1 \leq n \leq 1,000$
* $0 \leq w_i\leq 10^4$
* $w_i$ are all different
Input
In the first line, an integer $n$ is given. In the second line, $n$ integers $w_i (i = 0, 1, 2, ... n-1)$ separated by space characters are given.
Output
Print the minimal cost in a line.
Examples
Input
5
1 5 3 4 2
Output
7
Input
4
4 3 2 1
Output
10
Submitted Solution:
```
MAX_NUM = int(1E4 + 1)
if __name__ == '__main__':
N = int(input())
A = [int(i) for i in input().strip().split()]
sorted_A = sorted(A)
smallest = sorted_A[0]
correct_pos = [0] * MAX_NUM
flag_A = [False] * MAX_NUM
for i, val in enumerate(sorted_A):
correct_pos[val] = i
ans = 0
for i in range(len(A)):
if flag_A[i]:
continue
next_pos = i
sum = 0
m = 1E4
an = 0
while True:
an += 1
val = A[next_pos]
sum += val
m = min([m, val])
flag_A[A[next_pos]] = True
next_pos = correct_pos[val]
if flag_A[A[next_pos]]:
break
ans += min([sum + (an - 2) * m, m + sum + (an + 1) * smallest])
print(ans)
``` | instruction | 0 | 63,138 | 12 | 126,276 |
No | output | 1 | 63,138 | 12 | 126,277 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given $n$ integers $w_i (i = 0, 1, ..., n-1)$ to be sorted in ascending order. You can swap two integers $w_i$ and $w_j$. Each swap operation has a cost, which is the sum of the two integers $w_i + w_j$. You can perform the operations any number of times.
Write a program which reports the minimal total cost to sort the given integers.
Constraints
* $1 \leq n \leq 1,000$
* $0 \leq w_i\leq 10^4$
* $w_i$ are all different
Input
In the first line, an integer $n$ is given. In the second line, $n$ integers $w_i (i = 0, 1, 2, ... n-1)$ separated by space characters are given.
Output
Print the minimal cost in a line.
Examples
Input
5
1 5 3 4 2
Output
7
Input
4
4 3 2 1
Output
10
Submitted Solution:
```
#! /usr/local/bin/python3
# coding: utf-8
from bisect import bisect_left
def swap(w, i, j):
tmp = w[i]
w[i] = w[j]
w[j] = tmp
def min_weight(w):
ws = sorted(w)
weight = 0
for i in reversed(range(len(w))):
j = bisect_left(ws, w[i])
if i != j:
weight += w[i] + w[j]
swap(w, i, j)
return weight
def main():
n = int(input())
w = [int(x) for x in input().split()]
print(min_weight(w))
main()
``` | instruction | 0 | 63,139 | 12 | 126,278 |
No | output | 1 | 63,139 | 12 | 126,279 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya got an array consisting of n numbers, it is the gift for his birthday. Now he wants to sort it in the non-decreasing order. However, a usual sorting is boring to perform, that's why Petya invented the following limitation: one can swap any two numbers but only if at least one of them is lucky. Your task is to sort the array according to the specified limitation. Find any possible sequence of the swaps (the number of operations in the sequence should not exceed 2n).
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of elements in the array. The second line contains n positive integers, not exceeding 109 — the array that needs to be sorted in the non-decreasing order.
Output
On the first line print number k (0 ≤ k ≤ 2n) — the number of the swaps in the sorting. On the following k lines print one pair of distinct numbers (a pair per line) — the indexes of elements to swap. The numbers in the array are numbered starting from 1. If it is impossible to sort the given sequence, print the single number -1.
If there are several solutions, output any. Note that you don't have to minimize k. Any sorting with no more than 2n swaps is accepted.
Examples
Input
2
4 7
Output
0
Input
3
4 2 1
Output
1
1 3
Input
7
77 66 55 44 33 22 11
Output
7
1 7
7 2
2 6
6 7
3 4
5 3
4 5 | instruction | 0 | 63,181 | 12 | 126,362 |
Tags: constructive algorithms, sortings
Correct Solution:
```
#!/usr/bin/env python3
def is_lucky(v):
while v > 0:
r = v % 10
if r != 4 and r != 7:
return False
v //= 10
return True
n = int(input())
arr = list(map(int, input().split()))
arr_with_pos = sorted([[a, i] for i, a in enumerate(arr)])
pos, tpos = None, None # pos and target pos for one of the lucky numbers
not_ordered = set()
need = [i for _, i in arr_with_pos]
belong = [0] * n
for i in range(n):
belong[need[i]] = i
for i in range(n):
a, opos = arr_with_pos[i]
if pos is None and is_lucky(a):
pos, tpos = opos, i
if opos != i:
not_ordered.add(opos)
if pos is None:
ordered = True
for i in range(n):
if arr[i] != arr_with_pos[i][0]:
ordered = False
break
print(0 if ordered else -1)
else:
ans = []
while not_ordered:
if pos == tpos:
for first in not_ordered:
break
if first == tpos:
not_ordered.discard(first)
continue
ans.append([pos, first])
need[pos] = first
belong[pos] = belong[first]
need[belong[first]] = pos
belong[first] = tpos
pos = first
else:
ans.append([need[pos], pos])
not_ordered.discard(pos)
pos = need[pos]
need[tpos] = pos
belong[pos] = tpos
print(len(ans))
for p1, p2 in ans:
print(p1 + 1, p2 + 1)
``` | output | 1 | 63,181 | 12 | 126,363 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya got an array consisting of n numbers, it is the gift for his birthday. Now he wants to sort it in the non-decreasing order. However, a usual sorting is boring to perform, that's why Petya invented the following limitation: one can swap any two numbers but only if at least one of them is lucky. Your task is to sort the array according to the specified limitation. Find any possible sequence of the swaps (the number of operations in the sequence should not exceed 2n).
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of elements in the array. The second line contains n positive integers, not exceeding 109 — the array that needs to be sorted in the non-decreasing order.
Output
On the first line print number k (0 ≤ k ≤ 2n) — the number of the swaps in the sorting. On the following k lines print one pair of distinct numbers (a pair per line) — the indexes of elements to swap. The numbers in the array are numbered starting from 1. If it is impossible to sort the given sequence, print the single number -1.
If there are several solutions, output any. Note that you don't have to minimize k. Any sorting with no more than 2n swaps is accepted.
Examples
Input
2
4 7
Output
0
Input
3
4 2 1
Output
1
1 3
Input
7
77 66 55 44 33 22 11
Output
7
1 7
7 2
2 6
6 7
3 4
5 3
4 5 | instruction | 0 | 63,182 | 12 | 126,364 |
Tags: constructive algorithms, sortings
Correct Solution:
```
def good(n):
while n > 0:
if n % 10 != 4 and n % 10 != 7: return False
n //= 10
return True
n = int(input())
a = list(map(int, input().split()))
b = [i for i in range(n)]
b.sort(key = lambda i:a[i])
g = -1
for i in range(n):
if good(a[i]):
g = i
break
ans = []
ok = True
if g != -1:
for i in range(n):
a[b[i]] = i
for i in range(n):
if b[i] == i or b[i] == g:
continue
if i != g:
ans.append('{} {}'.format(i + 1, g + 1))
b[a[i]], b[a[g]]=b[a[g]],b[a[i]]
a[i],a[g]=a[g],a[i]
g = b[i]
if i != g:
ans.append('{} {}'.format(i + 1, g + 1))
b[a[i]], b[a[g]]=b[a[g]],b[a[i]]
a[i],a[g]=a[g],a[i]
else:
for i in range(1,n):
if a[i] < a[i-1]:
ok = False
break
if not ok:
print(-1)
else:
print(len(ans))
print('\n'.join(ans))
``` | output | 1 | 63,182 | 12 | 126,365 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya got an array consisting of n numbers, it is the gift for his birthday. Now he wants to sort it in the non-decreasing order. However, a usual sorting is boring to perform, that's why Petya invented the following limitation: one can swap any two numbers but only if at least one of them is lucky. Your task is to sort the array according to the specified limitation. Find any possible sequence of the swaps (the number of operations in the sequence should not exceed 2n).
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of elements in the array. The second line contains n positive integers, not exceeding 109 — the array that needs to be sorted in the non-decreasing order.
Output
On the first line print number k (0 ≤ k ≤ 2n) — the number of the swaps in the sorting. On the following k lines print one pair of distinct numbers (a pair per line) — the indexes of elements to swap. The numbers in the array are numbered starting from 1. If it is impossible to sort the given sequence, print the single number -1.
If there are several solutions, output any. Note that you don't have to minimize k. Any sorting with no more than 2n swaps is accepted.
Examples
Input
2
4 7
Output
0
Input
3
4 2 1
Output
1
1 3
Input
7
77 66 55 44 33 22 11
Output
7
1 7
7 2
2 6
6 7
3 4
5 3
4 5
Submitted Solution:
```
def good(n):
while n > 0:
if n % 10 != 4 & n % 10 != 7: return False
n //= 10
return True
n = int(input())
a = list(map(int, input().split()))
b = [i for i in range(n)]
b.sort(key = lambda i:a[i])
g = -1
for i in range(n):
if good(a[i]):
g = i
break
ans = []
ok = True
if g != -1:
for i in range(n):
a[b[i]] = i
for i in range(n):
if b[i] == i or b[i] == g:
continue
if i != g:
ans.append('{} {}'.format(i + 1, g + 1))
b[a[i]], b[a[g]]=b[a[g]],b[a[i]]
a[i],a[g]=a[g],a[i]
g = b[i]
if i != g:
ans.append('{} {}'.format(i + 1, g + 1))
b[a[i]], b[a[g]]=b[a[g]],b[a[i]]
a[i],a[g]=a[g],a[i]
else:
for i in range(1,n):
if a[i] < a[i-1]:
ok = False
break
if not ok:
print(-1)
else:
print(len(ans))
print('\n'.join(ans))
``` | instruction | 0 | 63,183 | 12 | 126,366 |
No | output | 1 | 63,183 | 12 | 126,367 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya got an array consisting of n numbers, it is the gift for his birthday. Now he wants to sort it in the non-decreasing order. However, a usual sorting is boring to perform, that's why Petya invented the following limitation: one can swap any two numbers but only if at least one of them is lucky. Your task is to sort the array according to the specified limitation. Find any possible sequence of the swaps (the number of operations in the sequence should not exceed 2n).
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of elements in the array. The second line contains n positive integers, not exceeding 109 — the array that needs to be sorted in the non-decreasing order.
Output
On the first line print number k (0 ≤ k ≤ 2n) — the number of the swaps in the sorting. On the following k lines print one pair of distinct numbers (a pair per line) — the indexes of elements to swap. The numbers in the array are numbered starting from 1. If it is impossible to sort the given sequence, print the single number -1.
If there are several solutions, output any. Note that you don't have to minimize k. Any sorting with no more than 2n swaps is accepted.
Examples
Input
2
4 7
Output
0
Input
3
4 2 1
Output
1
1 3
Input
7
77 66 55 44 33 22 11
Output
7
1 7
7 2
2 6
6 7
3 4
5 3
4 5
Submitted Solution:
```
def good(n):
while n > 0:
if n % 10 != 4 & n % 10 != 7: return False
n //= 10
return True
n = int(input())
a = list(map(int, input().split()))
b = [i for i in range(n)]
b.sort(key = lambda i:a[i])
g = -1
for i in range(n):
if good(a[i]):
g = i
break
ans = []
ok = True
if g != -1:
for i in range(n):
a[b[i]] = i
for i in range(n):
if b[i] == i:
continue
if i != g:
ans.append('{} {}'.format(i + 1, g + 1))
b[a[i]], b[a[g]]=b[a[g]],b[a[i]]
a[i],a[g]=a[g],a[i]
ans.append('{} {}'.format(i + 1, b[i] + 1))
b[a[i]],b[a[b[i]]]=b[a[b[i]]],b[a[i]]
a[i],a[b[i]]=a[b[i]],a[i]
g = b[i]
else:
for i in range(1,n):
if a[i] < a[i-1]:
ok = False
break
if not ok:
print(-1)
else:
print(len(ans))
print('\n'.join(ans))
``` | instruction | 0 | 63,184 | 12 | 126,368 |
No | output | 1 | 63,184 | 12 | 126,369 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya got an array consisting of n numbers, it is the gift for his birthday. Now he wants to sort it in the non-decreasing order. However, a usual sorting is boring to perform, that's why Petya invented the following limitation: one can swap any two numbers but only if at least one of them is lucky. Your task is to sort the array according to the specified limitation. Find any possible sequence of the swaps (the number of operations in the sequence should not exceed 2n).
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of elements in the array. The second line contains n positive integers, not exceeding 109 — the array that needs to be sorted in the non-decreasing order.
Output
On the first line print number k (0 ≤ k ≤ 2n) — the number of the swaps in the sorting. On the following k lines print one pair of distinct numbers (a pair per line) — the indexes of elements to swap. The numbers in the array are numbered starting from 1. If it is impossible to sort the given sequence, print the single number -1.
If there are several solutions, output any. Note that you don't have to minimize k. Any sorting with no more than 2n swaps is accepted.
Examples
Input
2
4 7
Output
0
Input
3
4 2 1
Output
1
1 3
Input
7
77 66 55 44 33 22 11
Output
7
1 7
7 2
2 6
6 7
3 4
5 3
4 5
Submitted Solution:
```
#!/usr/bin/env python3
n = int(input())
l = list(map(int, input().split()))
# Store original indices in the list
sorted_l = [(l[i], i) for i in range(len(l))]
sorted_l.sort()
sorted_l, source = zip(*sorted_l)
sorted_l = list(sorted_l)
source = list(source)
if (l == sorted_l):
# List was already sorted
print(0)
exit()
# Function to determine if a number is lucky
def is_lucky(nr):
digits = set(d for d in str(nr))
digits.discard('4')
digits.discard('7')
return len(digits) == 0
# Find the first lucky number
lucky_index = -1
for (i,v) in enumerate(l):
if is_lucky(v):
lucky_index = i
break
if (lucky_index == -1):
# List is not already sorted and no lucky numbers available
print(-1)
exit()
# Keep track of the locations where we still have to put the final number
to_be_moved = set(i for i in range(n) if (source[i] != i))
moves = []
lucky_destination = source.index(lucky_index)
while (len(to_be_moved) > 0):
if (lucky_index != lucky_destination):
moves.append((lucky_index, source[lucky_index]))
to_be_moved.remove(lucky_index)
lucky_index = source[lucky_index]
elif (len(to_be_moved) == 1):
# The lucky number is in its final position, and it was the last thing that needed moving
to_be_moved.discard(lucky_index)
else:
# The lucky number is in its final position, but haven't finished sorting yet
pick = to_be_moved.pop()
to_be_moved.add(pick)
moves.append((lucky_index, pick))
source = [s if (s != pick) and (s != lucky_index) else (pick if s == lucky_index else lucky_index) for s in source]
lucky_index = pick
#print(moves)
# Print output
print(len(moves))
for (a,b) in moves:
print(a+1,b+1)
``` | instruction | 0 | 63,185 | 12 | 126,370 |
No | output | 1 | 63,185 | 12 | 126,371 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya got an array consisting of n numbers, it is the gift for his birthday. Now he wants to sort it in the non-decreasing order. However, a usual sorting is boring to perform, that's why Petya invented the following limitation: one can swap any two numbers but only if at least one of them is lucky. Your task is to sort the array according to the specified limitation. Find any possible sequence of the swaps (the number of operations in the sequence should not exceed 2n).
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of elements in the array. The second line contains n positive integers, not exceeding 109 — the array that needs to be sorted in the non-decreasing order.
Output
On the first line print number k (0 ≤ k ≤ 2n) — the number of the swaps in the sorting. On the following k lines print one pair of distinct numbers (a pair per line) — the indexes of elements to swap. The numbers in the array are numbered starting from 1. If it is impossible to sort the given sequence, print the single number -1.
If there are several solutions, output any. Note that you don't have to minimize k. Any sorting with no more than 2n swaps is accepted.
Examples
Input
2
4 7
Output
0
Input
3
4 2 1
Output
1
1 3
Input
7
77 66 55 44 33 22 11
Output
7
1 7
7 2
2 6
6 7
3 4
5 3
4 5
Submitted Solution:
```
def good(n):
while n > 0:
if n % 10 != 4 & n % 10 != 7: return False
n //= 10
return True
n = int(input())
a = list(map(int, input().split()))
b = [i for i in range(n)]
b.sort(key = lambda i:a[i])
g = -1
for i in range(n):
if good(a[i]):
g = i
break
ans = []
ok = True
if g != -1:
for i in range(n):
a[b[i]] = i
for i in range(n):
if b[i] == i:
continue
if i != g:
ans.append('{} {}'.format(i + 1, g + 1))
b[a[i]], b[a[g]]=b[a[g]],b[a[i]]
a[i],a[g]=a[g],a[i]
g = b[i]
if i != g:
ans.append('{} {}'.format(i + 1, g + 1))
b[a[i]], b[a[g]]=b[a[g]],b[a[i]]
a[i],a[g]=a[g],a[i]
else:
for i in range(1,n):
if a[i] < a[i-1]:
ok = False
break
if not ok:
print(-1)
else:
print(len(ans))
print('\n'.join(ans))
``` | instruction | 0 | 63,186 | 12 | 126,372 |
No | output | 1 | 63,186 | 12 | 126,373 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a_1, a_2, ..., a_n and an array b_1, b_2, ..., b_n.
For one operation you can sort in non-decreasing order any subarray a[l ... r] of the array a.
For example, if a = [4, 2, 2, 1, 3, 1] and you choose subbarray a[2 ... 5], then the array turns into [4, 1, 2, 2, 3, 1].
You are asked to determine whether it is possible to obtain the array b by applying this operation any number of times (possibly zero) to the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 3 ⋅ 10^5) — the number of queries.
The first line of each query contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5).
The second line of each query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n).
The third line of each query contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ n).
It is guaranteed that ∑ n ≤ 3 ⋅ 10^5 over all queries in a test.
Output
For each query print YES (in any letter case) if it is possible to obtain an array b and NO (in any letter case) otherwise.
Example
Input
4
7
1 7 1 4 4 5 6
1 1 4 4 5 7 6
5
1 1 3 3 5
1 1 3 3 5
2
1 1
1 2
3
1 2 3
3 2 1
Output
YES
YES
NO
NO
Note
In first test case the can sort subarray a_1 ... a_5, then a will turn into [1, 1, 4, 4, 7, 5, 6], and then sort subarray a_5 ... a_6. | instruction | 0 | 63,206 | 12 | 126,412 |
Tags: data structures, sortings
Correct Solution:
```
from sys import stdin
from collections import deque
class Stree:
def __init__(self, n, default):
self.ln = 2**(n-1).bit_length()
self.data = [default] * (self.ln * 2)
self.default = default
def update(self, i, a):
p = self.ln + i
self.data[p] = a
while p > 1:
p = p // 2
self.data[p] = min(self.data[p*2], self.data[p*2+1])
def get(self, i, j):
def _get(l, r, p):
if i <= l and j >= r:
return self.data[p]
else:
m = (l+r)//2
if j <= m:
return _get(l, m, p*2)
elif i >= m:
return _get(m, r, p*2+1)
else:
return min(_get(l, m, p*2), _get(m, r, p*2+1))
return _get(0, self.ln, 1)
si = iter(stdin)
t = int(next(si))
for _ in range(t):
n = int(next(si))
aa = list(map(int, next(si).split()))
bb = list(map(int, next(si).split()))
pp = {}
for i in range(n-1, -1, -1):
a = aa[i]
if a in pp:
pp[a].append(i)
else:
pp[a] = [i]
stree = Stree(n+1, n+1)
for i, p in pp.items():
stree.update(i, p[-1])
result = 'YES'
m = 0
for b in bb:
if b in pp and pp[b] != []:
p = pp[b].pop()
if stree.get(0, b) < p:
result = 'NO'
break
# del aa[p]
# aa.insert(i,b)
# print(aa)
if pp[b] == []:
stree.update(b, n+1)
else:
stree.update(b, pp[b][-1])
else:
result = 'NO'
break
print(result)
``` | output | 1 | 63,206 | 12 | 126,413 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a_1, a_2, ..., a_n and an array b_1, b_2, ..., b_n.
For one operation you can sort in non-decreasing order any subarray a[l ... r] of the array a.
For example, if a = [4, 2, 2, 1, 3, 1] and you choose subbarray a[2 ... 5], then the array turns into [4, 1, 2, 2, 3, 1].
You are asked to determine whether it is possible to obtain the array b by applying this operation any number of times (possibly zero) to the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 3 ⋅ 10^5) — the number of queries.
The first line of each query contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5).
The second line of each query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n).
The third line of each query contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ n).
It is guaranteed that ∑ n ≤ 3 ⋅ 10^5 over all queries in a test.
Output
For each query print YES (in any letter case) if it is possible to obtain an array b and NO (in any letter case) otherwise.
Example
Input
4
7
1 7 1 4 4 5 6
1 1 4 4 5 7 6
5
1 1 3 3 5
1 1 3 3 5
2
1 1
1 2
3
1 2 3
3 2 1
Output
YES
YES
NO
NO
Note
In first test case the can sort subarray a_1 ... a_5, then a will turn into [1, 1, 4, 4, 7, 5, 6], and then sort subarray a_5 ... a_6. | instruction | 0 | 63,207 | 12 | 126,414 |
Tags: data structures, sortings
Correct Solution:
```
from sys import stdin
from collections import deque
class Stree:
def __init__(self, f, n, default, init_data):
self.ln = 2**(n-1).bit_length()
self.data = [default] * (self.ln * 2)
self.f = f
self.default = default
for i, d in init_data.items():
self.data[self.ln + i] = d
for j in range(self.ln - 1, -1, -1):
self.data[j] = f(self.data[j*2], self.data[j*2+1])
def update(self, i, a):
p = self.ln + i
self.data[p] = a
while p > 1:
p = p // 2
self.data[p] = self.f(self.data[p*2], self.data[p*2+1])
def get(self, i, j):
def _get(l, r, p):
if i >= r or j <= l:
return self.default
if i <= l and j >= r:
return self.data[p]
else:
m = (l+r)//2
while j < m:
r = m
p = p*2
m = (l+r)//2
while i > m:
r = m
p = p*2
m = (l+r)//2
return self.f(_get(l, m, p*2), _get(m, r, p*2+1))
return _get(0, self.ln, 1)
si = iter(stdin)
t = int(next(si))
for _ in range(t):
n = int(next(si))
aa = list(map(int, next(si).split()))
bb = list(map(int, next(si).split()))
pp = {}
for i in range(n-1, -1, -1):
a = aa[i]
if a in pp:
pp[a].append(i)
else:
pp[a] = [i]
pplast = { a: p[-1] for (a,p) in pp.items()}
stree = Stree(min, n+1, n+1, pplast)
result = 'YES'
m = 0
for b in bb:
if b in pp and pp[b] != []:
p = pp[b].pop()
if stree.get(0, b) < p:
result = 'NO'
break
# del aa[p]
# aa.insert(i,b)
# print(aa)
if pp[b] == []:
stree.update(b, n+1)
else:
stree.update(b, pp[b][-1])
else:
result = 'NO'
break
print(result)
``` | output | 1 | 63,207 | 12 | 126,415 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a_1, a_2, ..., a_n and an array b_1, b_2, ..., b_n.
For one operation you can sort in non-decreasing order any subarray a[l ... r] of the array a.
For example, if a = [4, 2, 2, 1, 3, 1] and you choose subbarray a[2 ... 5], then the array turns into [4, 1, 2, 2, 3, 1].
You are asked to determine whether it is possible to obtain the array b by applying this operation any number of times (possibly zero) to the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 3 ⋅ 10^5) — the number of queries.
The first line of each query contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5).
The second line of each query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n).
The third line of each query contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ n).
It is guaranteed that ∑ n ≤ 3 ⋅ 10^5 over all queries in a test.
Output
For each query print YES (in any letter case) if it is possible to obtain an array b and NO (in any letter case) otherwise.
Example
Input
4
7
1 7 1 4 4 5 6
1 1 4 4 5 7 6
5
1 1 3 3 5
1 1 3 3 5
2
1 1
1 2
3
1 2 3
3 2 1
Output
YES
YES
NO
NO
Note
In first test case the can sort subarray a_1 ... a_5, then a will turn into [1, 1, 4, 4, 7, 5, 6], and then sort subarray a_5 ... a_6. | instruction | 0 | 63,208 | 12 | 126,416 |
Tags: data structures, sortings
Correct Solution:
```
from sys import stdin, stdout
from collections import defaultdict
t = int(stdin.readline())
inf = 10**6
def merge_sort(order, a):
if len(order) == 1:
return order, a
mid = (len(order) + 1) // 2
left_o, left_a = merge_sort(order[:mid], a[:mid])
right_o, right_a = merge_sort(order[mid:], a[mid:])
l_mins = []
cur_min = inf
for i in range(mid-1, -1, -1):
cur_min = min(cur_min, left_a[i])
l_mins.append(cur_min)
l_mins.reverse()
# print("Merging, mid=", mid)
# print(left_o, left_a)
# print(right_o, right_a)
# print(l_mins)
l_idx = 0
r_idx = 0
o_ans = []
a_ans = []
while l_idx < mid and r_idx < len(order) - mid:
if left_o[l_idx] < right_o[r_idx]:
o_ans.append(left_o[l_idx])
a_ans.append(left_a[l_idx])
l_idx += 1
else:
if right_a[r_idx] > l_mins[l_idx]:
raise Exception
o_ans.append(right_o[r_idx])
a_ans.append(right_a[r_idx])
r_idx += 1
if l_idx < mid:
o_ans += left_o[l_idx:]
a_ans += left_a[l_idx:]
if r_idx < len(order) - mid:
o_ans += right_o[r_idx:]
a_ans += right_a[r_idx:]
#print("merged")
#print(o_ans, a_ans)
return o_ans, a_ans
def process():
n = int(stdin.readline())
a = list(map(int, stdin.readline().split()))
b = list(map(int, stdin.readline().split()))
order = [0]*n
occurrences = defaultdict(list)
for i, num in enumerate(b):
occurrences[num].append(i)
for i in range(n-1, -1, -1):
x = a[i]
if len(occurrences[x]) == 0:
stdout.write("NO\n")
return
order[i] = occurrences[x].pop()
#print("matched multiset")
#print(order)
try:
merge_sort(order, a)
stdout.write("YES\n")
except:
stdout.write("NO\n")
for it in range(t):
process()
``` | output | 1 | 63,208 | 12 | 126,417 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a_1, a_2, ..., a_n and an array b_1, b_2, ..., b_n.
For one operation you can sort in non-decreasing order any subarray a[l ... r] of the array a.
For example, if a = [4, 2, 2, 1, 3, 1] and you choose subbarray a[2 ... 5], then the array turns into [4, 1, 2, 2, 3, 1].
You are asked to determine whether it is possible to obtain the array b by applying this operation any number of times (possibly zero) to the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 3 ⋅ 10^5) — the number of queries.
The first line of each query contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5).
The second line of each query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n).
The third line of each query contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ n).
It is guaranteed that ∑ n ≤ 3 ⋅ 10^5 over all queries in a test.
Output
For each query print YES (in any letter case) if it is possible to obtain an array b and NO (in any letter case) otherwise.
Example
Input
4
7
1 7 1 4 4 5 6
1 1 4 4 5 7 6
5
1 1 3 3 5
1 1 3 3 5
2
1 1
1 2
3
1 2 3
3 2 1
Output
YES
YES
NO
NO
Note
In first test case the can sort subarray a_1 ... a_5, then a will turn into [1, 1, 4, 4, 7, 5, 6], and then sort subarray a_5 ... a_6. | instruction | 0 | 63,209 | 12 | 126,418 |
Tags: data structures, sortings
Correct Solution:
```
from sys import stdin, stdout
from collections import defaultdict
t = int(stdin.readline())
inf = 10**6
def merge_sort(order, a):
if len(order) == 1:
return order, a
mid = (len(order) + 1) // 2
left_o, left_a = merge_sort(order[:mid], a[:mid])
right_o, right_a = merge_sort(order[mid:], a[mid:])
l_mins = []
cur_min = inf
for i in range(mid-1, -1, -1):
cur_min = min(cur_min, left_a[i])
l_mins.append(cur_min)
l_mins.reverse()
# print("Merging, mid=", mid)
# print(left_o, left_a)
# print(right_o, right_a)
# print(l_mins)
l_idx = 0
r_idx = 0
o_ans = []
a_ans = []
while l_idx < mid and r_idx < len(order) - mid:
if left_o[l_idx] < right_o[r_idx]:
o_ans.append(left_o[l_idx])
a_ans.append(left_a[l_idx])
l_idx += 1
else:
if right_a[r_idx] > l_mins[l_idx]:
raise Exception
o_ans.append(right_o[r_idx])
a_ans.append(right_a[r_idx])
r_idx += 1
while l_idx < mid:
o_ans.append(left_o[l_idx])
a_ans.append(left_a[l_idx])
l_idx += 1
while r_idx < len(order) - mid:
o_ans.append(right_o[r_idx])
a_ans.append(right_a[r_idx])
r_idx += 1
#print("merged")
#print(o_ans, a_ans)
return o_ans, a_ans
def process():
n = int(stdin.readline())
a = list(map(int, stdin.readline().split()))
b = list(map(int, stdin.readline().split()))
order = [0]*n
occurrences = defaultdict(list)
for i, num in enumerate(b):
occurrences[num].append(i)
for i in range(n-1, -1, -1):
x = a[i]
if len(occurrences[x]) == 0:
stdout.write("NO\n")
return
order[i] = occurrences[x].pop()
#print("matched multiset")
#print(order)
try:
merge_sort(order, a)
stdout.write("YES\n")
except:
stdout.write("NO\n")
for it in range(t):
process()
``` | output | 1 | 63,209 | 12 | 126,419 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a_1, a_2, ..., a_n and an array b_1, b_2, ..., b_n.
For one operation you can sort in non-decreasing order any subarray a[l ... r] of the array a.
For example, if a = [4, 2, 2, 1, 3, 1] and you choose subbarray a[2 ... 5], then the array turns into [4, 1, 2, 2, 3, 1].
You are asked to determine whether it is possible to obtain the array b by applying this operation any number of times (possibly zero) to the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 3 ⋅ 10^5) — the number of queries.
The first line of each query contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5).
The second line of each query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n).
The third line of each query contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ n).
It is guaranteed that ∑ n ≤ 3 ⋅ 10^5 over all queries in a test.
Output
For each query print YES (in any letter case) if it is possible to obtain an array b and NO (in any letter case) otherwise.
Example
Input
4
7
1 7 1 4 4 5 6
1 1 4 4 5 7 6
5
1 1 3 3 5
1 1 3 3 5
2
1 1
1 2
3
1 2 3
3 2 1
Output
YES
YES
NO
NO
Note
In first test case the can sort subarray a_1 ... a_5, then a will turn into [1, 1, 4, 4, 7, 5, 6], and then sort subarray a_5 ... a_6. | instruction | 0 | 63,210 | 12 | 126,420 |
Tags: data structures, sortings
Correct Solution:
```
import sys
inp = iter(map(int, sys.stdin.read().split())).__next__
def fenwick_upd(a, i, x):
while i < len(a):
a[i] = max(x, a[i])
i += i & -i
def fenwick_qry(a, i):
r = 0
while i > 0:
r = max(r, a[i])
i -= i & -i
return r
out = []
for t in range(inp()):
n = inp()
a = [inp() for _ in range(n)]
b = [inp() for _ in range(n)]
ok = 1
p = [[] for _ in range(n + 1)]
for i in range(n - 1, -1, -1):
p[b[i]].append(i)
f = [0] * (n + 1)
for x in a:
if not p[x] or fenwick_qry(f, x) > p[x][-1]:
ok = 0
break
fenwick_upd(f, x, p[x].pop())
out.append('YES' if ok else 'NO')
print(*out, sep='\n')
``` | output | 1 | 63,210 | 12 | 126,421 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a_1, a_2, ..., a_n and an array b_1, b_2, ..., b_n.
For one operation you can sort in non-decreasing order any subarray a[l ... r] of the array a.
For example, if a = [4, 2, 2, 1, 3, 1] and you choose subbarray a[2 ... 5], then the array turns into [4, 1, 2, 2, 3, 1].
You are asked to determine whether it is possible to obtain the array b by applying this operation any number of times (possibly zero) to the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 3 ⋅ 10^5) — the number of queries.
The first line of each query contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5).
The second line of each query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n).
The third line of each query contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ n).
It is guaranteed that ∑ n ≤ 3 ⋅ 10^5 over all queries in a test.
Output
For each query print YES (in any letter case) if it is possible to obtain an array b and NO (in any letter case) otherwise.
Example
Input
4
7
1 7 1 4 4 5 6
1 1 4 4 5 7 6
5
1 1 3 3 5
1 1 3 3 5
2
1 1
1 2
3
1 2 3
3 2 1
Output
YES
YES
NO
NO
Note
In first test case the can sort subarray a_1 ... a_5, then a will turn into [1, 1, 4, 4, 7, 5, 6], and then sort subarray a_5 ... a_6. | instruction | 0 | 63,211 | 12 | 126,422 |
Tags: data structures, sortings
Correct Solution:
```
from sys import stdin
from collections import deque
class Stree:
def __init__(self, f, n, default, init_data):
self.ln = 2**(n-1).bit_length()
self.data = [default] * (self.ln * 2)
self.f = f
for i, d in init_data.items():
self.data[self.ln + i] = d
for j in range(self.ln - 1, -1, -1):
self.data[j] = f(self.data[j*2], self.data[j*2+1])
def update(self, i, a):
p = self.ln + i
self.data[p] = a
while p > 1:
p = p // 2
self.data[p] = self.f(self.data[p*2], self.data[p*2+1])
def get(self, i, j):
def _get(l, r, p):
if i <= l and j >= r:
return self.data[p]
else:
m = (l+r)//2
if j <= m:
return _get(l, m, p*2)
elif i >= m:
return _get(m, r, p*2+1)
else:
return self.f(_get(l, m, p*2), _get(m, r, p*2+1))
return _get(0, self.ln, 1)
si = iter(stdin)
t = int(next(si))
for _ in range(t):
n = int(next(si))
aa = list(map(int, next(si).split()))
bb = list(map(int, next(si).split()))
pp = {}
pplast = {}
for i in range(n-1, -1, -1):
a = aa[i]
pplast[a] = i
if a in pp:
pp[a].append(i)
else:
pp[a] = [i]
stree = Stree(min, n+1, n+1, pplast)
result = 'YES'
m = 0
for b in bb:
if b in pp and pp[b] != []:
p = pp[b].pop()
if stree.get(0, b) < p:
result = 'NO'
break
if pp[b] == []:
stree.update(b, n+1)
else:
stree.update(b, pp[b][-1])
else:
result = 'NO'
break
print(result)
``` | output | 1 | 63,211 | 12 | 126,423 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a_1, a_2, ..., a_n and an array b_1, b_2, ..., b_n.
For one operation you can sort in non-decreasing order any subarray a[l ... r] of the array a.
For example, if a = [4, 2, 2, 1, 3, 1] and you choose subbarray a[2 ... 5], then the array turns into [4, 1, 2, 2, 3, 1].
You are asked to determine whether it is possible to obtain the array b by applying this operation any number of times (possibly zero) to the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 3 ⋅ 10^5) — the number of queries.
The first line of each query contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5).
The second line of each query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n).
The third line of each query contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ n).
It is guaranteed that ∑ n ≤ 3 ⋅ 10^5 over all queries in a test.
Output
For each query print YES (in any letter case) if it is possible to obtain an array b and NO (in any letter case) otherwise.
Example
Input
4
7
1 7 1 4 4 5 6
1 1 4 4 5 7 6
5
1 1 3 3 5
1 1 3 3 5
2
1 1
1 2
3
1 2 3
3 2 1
Output
YES
YES
NO
NO
Note
In first test case the can sort subarray a_1 ... a_5, then a will turn into [1, 1, 4, 4, 7, 5, 6], and then sort subarray a_5 ... a_6. | instruction | 0 | 63,212 | 12 | 126,424 |
Tags: data structures, sortings
Correct Solution:
```
ide = 10**18
def func(a,b):
return min(a,b)
class SegmentTree:
def __init__(self,ls,commutative = True):
if commutative == True:
self.n = len(ls)
self.tree = [ide for i in range(self.n)]+ls
else:
self.n = 2**((len(ls)-1).bit_length())
self.tree = [ide for i in range(self.n)]+ls+[ide for i in range(self.n-len(ls))]
for i in range(1,self.n)[::-1]:
self.tree[i] = func(self.tree[i<<1|0],self.tree[i<<1|1])
def getall(self):
return self.tree[1]
def get(self,l,r):
lret = ide
rret = ide
l += self.n
r += self.n
while l < r:
if l&1:
lret = func(lret,self.tree[l])
l += 1
if r&1:
rret = func(self.tree[r-1],rret)
l >>= 1
r >>= 1
ret = func(lret,rret)
return ret
def update(self,i,x):
i += self.n
self.tree[i] = x
while i > 1:
i >>= 1
self.tree[i] = func(self.tree[i<<1|0],self.tree[i<<1|1])
import sys
input = sys.stdin.readline
from collections import Counter, defaultdict
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
if Counter(a) != Counter(b):
print("NO")
continue
segtree = SegmentTree(a)
dc = defaultdict(list)
for i in range(n)[::-1]:
dc[a[i]].append(i)
for i in range(n):
x = b[i]
aix = dc[x].pop()
if segtree.get(0,aix+1) == x:
segtree.update(aix,ide)
else:
print("NO")
break
else:
print("YES")
``` | output | 1 | 63,212 | 12 | 126,425 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a_1, a_2, ..., a_n and an array b_1, b_2, ..., b_n.
For one operation you can sort in non-decreasing order any subarray a[l ... r] of the array a.
For example, if a = [4, 2, 2, 1, 3, 1] and you choose subbarray a[2 ... 5], then the array turns into [4, 1, 2, 2, 3, 1].
You are asked to determine whether it is possible to obtain the array b by applying this operation any number of times (possibly zero) to the array a.
Input
The first line contains one integer t (1 ≤ t ≤ 3 ⋅ 10^5) — the number of queries.
The first line of each query contains one integer n (1 ≤ n ≤ 3 ⋅ 10^5).
The second line of each query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n).
The third line of each query contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ n).
It is guaranteed that ∑ n ≤ 3 ⋅ 10^5 over all queries in a test.
Output
For each query print YES (in any letter case) if it is possible to obtain an array b and NO (in any letter case) otherwise.
Example
Input
4
7
1 7 1 4 4 5 6
1 1 4 4 5 7 6
5
1 1 3 3 5
1 1 3 3 5
2
1 1
1 2
3
1 2 3
3 2 1
Output
YES
YES
NO
NO
Note
In first test case the can sort subarray a_1 ... a_5, then a will turn into [1, 1, 4, 4, 7, 5, 6], and then sort subarray a_5 ... a_6. | instruction | 0 | 63,213 | 12 | 126,426 |
Tags: data structures, sortings
Correct Solution:
```
import sys
from collections import Counter
class Segtree:
def __init__(self, A, intv, initialize = True, segf = min):
self.N = len(A)
self.N0 = 2**(self.N-1).bit_length()
self.intv = intv
self.segf = segf
if initialize:
self.data = [intv]*(self.N0-1) + A + [intv]*(self.N0 - self.N + 1)
for i in range(self.N0-2, -1, -1):
self.data[i] = self.segf(self.data[2*i+1], self.data[2*i+2])
else:
self.data = [intv]*(2*self.N0)
def update(self, k, x):
k += self.N0-1
self.data[k] = x
while k >= 0 :
k = (k-1)//2
self.data[k] = self.segf(self.data[2*k+1], self.data[2*k+2])
def query(self, l, r):
L, R = l+self.N0, r+self.N0
s = self.intv
while L < R:
if R & 1:
R -= 1
s = self.segf(s, self.data[R-1])
if L & 1:
s = self.segf(s, self.data[L-1])
L += 1
L >>= 1
R >>= 1
return s
T = int(input())
def solve(N, A, B):
if Counter(A) != Counter(B):
return False
ctr = [0]*(N+1)
tableA = [[] for _ in range(N+1)]
for i in range(N):
tableA[A[i]].append(i)
bri = [None]*N
for i in range(N):
b = B[i]
bri[i] = tableA[b][ctr[b]]
ctr[b] += 1
St = Segtree(A, 10**9, True, min)
for idx in bri:
if A[idx] > St.query(0, idx):
return False
St.update(idx, 10**9)
return True
for _ in range(T):
if solve(int(sys.stdin.readline()), list(map(int, sys.stdin.readline().split())), list(map(int, sys.stdin.readline().split()))):
print('YES')
else:
print('NO')
``` | output | 1 | 63,213 | 12 | 126,427 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.