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.
You are given an array a consisting of n positive integers, numbered from 1 to n. You can perform the following operation no more than 3n times:
1. choose three integers i, j and x (1 ≤ i, j ≤ n; 0 ≤ x ≤ 10^9);
2. assign a_i := a_i - x ⋅ i, a_j := a_j + x ⋅ i.
After each operation, all elements of the array should be non-negative.
Can you find a sequence of no more than 3n operations after which all elements of the array are equal?
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^4) — the number of elements in the array. The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^5) — the elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^4.
Output
For each test case print the answer to it as follows:
* if there is no suitable sequence of operations, print -1;
* otherwise, print one integer k (0 ≤ k ≤ 3n) — the number of operations in the sequence. Then print k lines, the m-th of which should contain three integers i, j and x (1 ≤ i, j ≤ n; 0 ≤ x ≤ 10^9) for the m-th operation.
If there are multiple suitable sequences of operations, print any of them. Note that you don't have to minimize k.
Example
Input
3
4
2 16 4 18
6
1 2 3 4 5 6
5
11 19 1 1 3
Output
2
4 1 2
2 3 3
-1
4
1 2 4
2 4 5
2 3 3
4 5 1
Submitted Solution:
```
import math
import collections
t=int(input())
for w in range(t):
n=int(input())
l=[int(i) for i in input().split()]
s=sum(l)
if(s%n!=0):
print(-1)
else:
l1=[]
c=0
for i in range(1,n):
if(l[i]%(i+1)!=0):
c+=2
l1.append((1,i+1,(i+1-l[i]%(i+1))))
l1.append((i+1,1,(l[i]//(i+1))+1))
else:
c+=1
l1.append((i+1,1,l[i]//(i+1)))
print(c+n-1)
for i in range(c):
print(l1[i][0],l1[i][1],l1[i][2])
for i in range(1,n):
print(1,i+1,(s//n))
``` | instruction | 0 | 91,915 | 12 | 183,830 |
Yes | output | 1 | 91,915 | 12 | 183,831 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n positive integers, numbered from 1 to n. You can perform the following operation no more than 3n times:
1. choose three integers i, j and x (1 ≤ i, j ≤ n; 0 ≤ x ≤ 10^9);
2. assign a_i := a_i - x ⋅ i, a_j := a_j + x ⋅ i.
After each operation, all elements of the array should be non-negative.
Can you find a sequence of no more than 3n operations after which all elements of the array are equal?
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^4) — the number of elements in the array. The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^5) — the elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^4.
Output
For each test case print the answer to it as follows:
* if there is no suitable sequence of operations, print -1;
* otherwise, print one integer k (0 ≤ k ≤ 3n) — the number of operations in the sequence. Then print k lines, the m-th of which should contain three integers i, j and x (1 ≤ i, j ≤ n; 0 ≤ x ≤ 10^9) for the m-th operation.
If there are multiple suitable sequences of operations, print any of them. Note that you don't have to minimize k.
Example
Input
3
4
2 16 4 18
6
1 2 3 4 5 6
5
11 19 1 1 3
Output
2
4 1 2
2 3 3
-1
4
1 2 4
2 4 5
2 3 3
4 5 1
Submitted Solution:
```
from collections import defaultdict
t = int(input())
while(t):
n = int(input())
a = [-1] + [int(x) for x in input().split()]
res = []
k = 0
s = sum(a[1:])
if not (s / n).is_integer():
print(-1)
t -= 1
continue
for i in range(2, n + 1):
if a[i] % i == 0:
res.append((i, 1, a[i] // i))
k += 1
a[1] += a[i]
a[i] = 0
else:
res.append((1, i, i - (a[i] % i)))
k += 1
tmp = (i - (a[i] % i))
a[i] += tmp
a[1] -= tmp
res.append((i, 1, a[i] // i))
k += 1
a[1] += a[i]
a[i] = 0
for i in range(2, n + 1):
res.append((1, i, s // n))
k += 1
print(k)
for i in res:
print(i[0], i[1], i[2])
t -= 1
``` | instruction | 0 | 91,918 | 12 | 183,836 |
Yes | output | 1 | 91,918 | 12 | 183,837 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n positive integers, numbered from 1 to n. You can perform the following operation no more than 3n times:
1. choose three integers i, j and x (1 ≤ i, j ≤ n; 0 ≤ x ≤ 10^9);
2. assign a_i := a_i - x ⋅ i, a_j := a_j + x ⋅ i.
After each operation, all elements of the array should be non-negative.
Can you find a sequence of no more than 3n operations after which all elements of the array are equal?
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^4) — the number of elements in the array. The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^5) — the elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^4.
Output
For each test case print the answer to it as follows:
* if there is no suitable sequence of operations, print -1;
* otherwise, print one integer k (0 ≤ k ≤ 3n) — the number of operations in the sequence. Then print k lines, the m-th of which should contain three integers i, j and x (1 ≤ i, j ≤ n; 0 ≤ x ≤ 10^9) for the m-th operation.
If there are multiple suitable sequences of operations, print any of them. Note that you don't have to minimize k.
Example
Input
3
4
2 16 4 18
6
1 2 3 4 5 6
5
11 19 1 1 3
Output
2
4 1 2
2 3 3
-1
4
1 2 4
2 4 5
2 3 3
4 5 1
Submitted Solution:
```
# kill everyone
# redistribute everyone
t = int(input())
for _ in range(t):
n = int(input())
l1 = [int(x) for x in input().split()]
if sum(l1)%n:
print(-1)
else:
# kill everyone - dump to one
for i in range(1,n):
print(i+1,1,l1[i]//(i+1))
targ = sum(l1)//n
for i in range(2,n):
print(1,i+1,targ-l1[i]%(i+1))
``` | instruction | 0 | 91,920 | 12 | 183,840 |
No | output | 1 | 91,920 | 12 | 183,841 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n positive integers, numbered from 1 to n. You can perform the following operation no more than 3n times:
1. choose three integers i, j and x (1 ≤ i, j ≤ n; 0 ≤ x ≤ 10^9);
2. assign a_i := a_i - x ⋅ i, a_j := a_j + x ⋅ i.
After each operation, all elements of the array should be non-negative.
Can you find a sequence of no more than 3n operations after which all elements of the array are equal?
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^4) — the number of elements in the array. The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^5) — the elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^4.
Output
For each test case print the answer to it as follows:
* if there is no suitable sequence of operations, print -1;
* otherwise, print one integer k (0 ≤ k ≤ 3n) — the number of operations in the sequence. Then print k lines, the m-th of which should contain three integers i, j and x (1 ≤ i, j ≤ n; 0 ≤ x ≤ 10^9) for the m-th operation.
If there are multiple suitable sequences of operations, print any of them. Note that you don't have to minimize k.
Example
Input
3
4
2 16 4 18
6
1 2 3 4 5 6
5
11 19 1 1 3
Output
2
4 1 2
2 3 3
-1
4
1 2 4
2 4 5
2 3 3
4 5 1
Submitted Solution:
```
import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")
t = int(input())
for _ in range(t):
n = int(input())
a = [int(x) for x in input().split()]
tot = sum(a)
if tot % len(a) != 0:
print(-1)
continue
b = []
factor = tot // len(a)
for i in a:
b.append(i - factor)
ans = []
a = b
for i in range(1, n):
if a[i] > 0:
p = a[i] // (i + 1)
a[i] = a[i] % (i + 1)
a[0] += p * (i + 1)
ans.append((i + 1, 1, p))
c = []
d = []
for j in range(1, n):
if a[j] < 0:
c.append((abs(a[j]), j + 1, 0))
# ans.append((1, j + 1, abs(a[j])))
elif a[j] > 0:
d.append((j + 1 - a[j], j + 1, 1))
c.sort()
d.sort()
flag = 0
for x, y, z in d:
if a[0] < x:
print(-1)
flag = 1
break
else:
a[0] -= x
ans.append((1, y, x))
a[0] += y
ans.append((y, 1, 1))
if flag:
continue
for x, y, z in c:
if a[0] < x:
print(-1)
flag = 1
break
else:
a[0] -= x
ans.append((1, y, x))
if flag:
continue
else:
print(len(ans))
for i in ans:
print(*i)
``` | instruction | 0 | 91,921 | 12 | 183,842 |
No | output | 1 | 91,921 | 12 | 183,843 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given integers c_{0}, c_{1}, …, c_{k-1} we can define the cost of a number 0 ≤ x < 2^{k} as p(x) = ∑_{i=0}^{k-1} \left( \left⌊ \frac{x}{2^{i}} \right⌋ mod 2 \right) ⋅ c_{i}. In other words, the cost of number x is the sum of c_{i} over the bits of x which are equal to one.
Let's define the cost of array a of length n ≥ 2 with elements from [0, 2^{k}) as follows: cost(a) = ∑_{i=1}^{n - 1} p(a_{i} ⊕ a_{i+1}), where ⊕ denotes [bitwise exclusive OR](https://en.wikipedia.org/wiki/Exclusive_or) operation.
You have to construct an array of length n with minimal cost, given that each element should belong to the given segment: l_{i} ≤ a_{i} ≤ r_{i}.
Input
The first line contains two integers n and k (2 ≤ n ≤ 50, 1 ≤ k ≤ 50) — the size of an array and bit length of the numbers in question.
Next n lines contain the restrictions for elements of the array: the i-th line contains two integers l_{i} and r_{i} (0 ≤ l_{i} ≤ r_{i} < 2^{k}).
The last line contains integers c_{0}, c_{1}, …, c_{k-1} (0 ≤ c_{i} ≤ 10^{12}).
Output
Output one integer — the minimal cost of an array satisfying all the restrictions.
Examples
Input
4 3
3 3
5 5
6 6
1 1
5 2 7
Output
30
Input
3 3
2 2
3 4
4 6
1 10 100
Output
102
Note
In the first example there is only one array satisfying all the restrictions — [3, 5, 6, 1] — and its cost is equal to cost([3, 5, 6, 1]) = p(3 ⊕ 5) + p(5 ⊕ 6) + p(6 ⊕ 1) = p(6) + p(3) + p(7) = (c_{1} + c_{2}) + (c_{0} + c_{1}) + (c_{0} + c_{1} + c_{2}) = (2 + 7) + (5 + 2) + (5 + 2 + 7) = 30.
In the second example the only optimal array is [2, 3, 6].
Submitted Solution:
```
def answer(start, length):
return reduce(operator.xor, gen_nums(start, length))
def gen_nums(start, length):
l = length
while l > 0:
for x in xrange(start, start+l):
yield x
start = start + length
l = l - 1
``` | instruction | 0 | 91,939 | 12 | 183,878 |
No | output | 1 | 91,939 | 12 | 183,879 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given integers c_{0}, c_{1}, …, c_{k-1} we can define the cost of a number 0 ≤ x < 2^{k} as p(x) = ∑_{i=0}^{k-1} \left( \left⌊ \frac{x}{2^{i}} \right⌋ mod 2 \right) ⋅ c_{i}. In other words, the cost of number x is the sum of c_{i} over the bits of x which are equal to one.
Let's define the cost of array a of length n ≥ 2 with elements from [0, 2^{k}) as follows: cost(a) = ∑_{i=1}^{n - 1} p(a_{i} ⊕ a_{i+1}), where ⊕ denotes [bitwise exclusive OR](https://en.wikipedia.org/wiki/Exclusive_or) operation.
You have to construct an array of length n with minimal cost, given that each element should belong to the given segment: l_{i} ≤ a_{i} ≤ r_{i}.
Input
The first line contains two integers n and k (2 ≤ n ≤ 50, 1 ≤ k ≤ 50) — the size of an array and bit length of the numbers in question.
Next n lines contain the restrictions for elements of the array: the i-th line contains two integers l_{i} and r_{i} (0 ≤ l_{i} ≤ r_{i} < 2^{k}).
The last line contains integers c_{0}, c_{1}, …, c_{k-1} (0 ≤ c_{i} ≤ 10^{12}).
Output
Output one integer — the minimal cost of an array satisfying all the restrictions.
Examples
Input
4 3
3 3
5 5
6 6
1 1
5 2 7
Output
30
Input
3 3
2 2
3 4
4 6
1 10 100
Output
102
Note
In the first example there is only one array satisfying all the restrictions — [3, 5, 6, 1] — and its cost is equal to cost([3, 5, 6, 1]) = p(3 ⊕ 5) + p(5 ⊕ 6) + p(6 ⊕ 1) = p(6) + p(3) + p(7) = (c_{1} + c_{2}) + (c_{0} + c_{1}) + (c_{0} + c_{1} + c_{2}) = (2 + 7) + (5 + 2) + (5 + 2 + 7) = 30.
In the second example the only optimal array is [2, 3, 6].
Submitted Solution:
```
n, k = map(int, input().split())
num_tree = []
for i in range(n):
min_temp, max_temp = map(int, input().split())
num_tree.append({i: 0 for i in range(min_temp, max_temp + 1)})
c = list(map(int, input().split()))
def xorcost(x, y):
lst = [((x // (2 ** i) - y // (2 ** i)) % 2) * c[i] for i in range(k)]
return sum(lst)
for i in range(1, n):
for j in num_tree[i]:
minn = 0
for m in num_tree[i - 1]:
if minn == 0:
minn = xorcost(j, m) + num_tree[i - 1][m]
num_tree[i][j] = minn
else:
if xorcost(j, m) + num_tree[i - 1][m] <= minn:
minn = xorcost(j, m) + num_tree[i - 1][m]
num_tree[i][j] = minn
print(min(num_tree[-1].values()))
``` | instruction | 0 | 91,940 | 12 | 183,880 |
No | output | 1 | 91,940 | 12 | 183,881 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given integers c_{0}, c_{1}, …, c_{k-1} we can define the cost of a number 0 ≤ x < 2^{k} as p(x) = ∑_{i=0}^{k-1} \left( \left⌊ \frac{x}{2^{i}} \right⌋ mod 2 \right) ⋅ c_{i}. In other words, the cost of number x is the sum of c_{i} over the bits of x which are equal to one.
Let's define the cost of array a of length n ≥ 2 with elements from [0, 2^{k}) as follows: cost(a) = ∑_{i=1}^{n - 1} p(a_{i} ⊕ a_{i+1}), where ⊕ denotes [bitwise exclusive OR](https://en.wikipedia.org/wiki/Exclusive_or) operation.
You have to construct an array of length n with minimal cost, given that each element should belong to the given segment: l_{i} ≤ a_{i} ≤ r_{i}.
Input
The first line contains two integers n and k (2 ≤ n ≤ 50, 1 ≤ k ≤ 50) — the size of an array and bit length of the numbers in question.
Next n lines contain the restrictions for elements of the array: the i-th line contains two integers l_{i} and r_{i} (0 ≤ l_{i} ≤ r_{i} < 2^{k}).
The last line contains integers c_{0}, c_{1}, …, c_{k-1} (0 ≤ c_{i} ≤ 10^{12}).
Output
Output one integer — the minimal cost of an array satisfying all the restrictions.
Examples
Input
4 3
3 3
5 5
6 6
1 1
5 2 7
Output
30
Input
3 3
2 2
3 4
4 6
1 10 100
Output
102
Note
In the first example there is only one array satisfying all the restrictions — [3, 5, 6, 1] — and its cost is equal to cost([3, 5, 6, 1]) = p(3 ⊕ 5) + p(5 ⊕ 6) + p(6 ⊕ 1) = p(6) + p(3) + p(7) = (c_{1} + c_{2}) + (c_{0} + c_{1}) + (c_{0} + c_{1} + c_{2}) = (2 + 7) + (5 + 2) + (5 + 2 + 7) = 30.
In the second example the only optimal array is [2, 3, 6].
Submitted Solution:
```
#input
# import sys
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
import math
n, k = map(int, input().split())
LR = []
for _ in range(n):
l, r = map(int, input().split())
LR.append(list(range(l, r + 1)))
c = list(map(int, input().split()))
u = [int(math.pow(2, i)) for i in range(k)]
#Body
def p(x):
ans = 0
for i in range(k):
ans += (int(x / u[i]) & 1)*c[i]
return ans
def cost(arr):
n = len(arr)
ans = 0
for i in range(n - 1):
ans += p(arr[i] ^ arr[i + 1])
return ans
arr = []
for i in range(n):
arr.append(LR[i][(i & 1) - 1])
#result
print(cost(arr))
#debug
``` | instruction | 0 | 91,941 | 12 | 183,882 |
No | output | 1 | 91,941 | 12 | 183,883 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given integers c_{0}, c_{1}, …, c_{k-1} we can define the cost of a number 0 ≤ x < 2^{k} as p(x) = ∑_{i=0}^{k-1} \left( \left⌊ \frac{x}{2^{i}} \right⌋ mod 2 \right) ⋅ c_{i}. In other words, the cost of number x is the sum of c_{i} over the bits of x which are equal to one.
Let's define the cost of array a of length n ≥ 2 with elements from [0, 2^{k}) as follows: cost(a) = ∑_{i=1}^{n - 1} p(a_{i} ⊕ a_{i+1}), where ⊕ denotes [bitwise exclusive OR](https://en.wikipedia.org/wiki/Exclusive_or) operation.
You have to construct an array of length n with minimal cost, given that each element should belong to the given segment: l_{i} ≤ a_{i} ≤ r_{i}.
Input
The first line contains two integers n and k (2 ≤ n ≤ 50, 1 ≤ k ≤ 50) — the size of an array and bit length of the numbers in question.
Next n lines contain the restrictions for elements of the array: the i-th line contains two integers l_{i} and r_{i} (0 ≤ l_{i} ≤ r_{i} < 2^{k}).
The last line contains integers c_{0}, c_{1}, …, c_{k-1} (0 ≤ c_{i} ≤ 10^{12}).
Output
Output one integer — the minimal cost of an array satisfying all the restrictions.
Examples
Input
4 3
3 3
5 5
6 6
1 1
5 2 7
Output
30
Input
3 3
2 2
3 4
4 6
1 10 100
Output
102
Note
In the first example there is only one array satisfying all the restrictions — [3, 5, 6, 1] — and its cost is equal to cost([3, 5, 6, 1]) = p(3 ⊕ 5) + p(5 ⊕ 6) + p(6 ⊕ 1) = p(6) + p(3) + p(7) = (c_{1} + c_{2}) + (c_{0} + c_{1}) + (c_{0} + c_{1} + c_{2}) = (2 + 7) + (5 + 2) + (5 + 2 + 7) = 30.
In the second example the only optimal array is [2, 3, 6].
Submitted Solution:
```
from operator import xor
def findXOR(n):
mod = n % 4;
if (mod == 0):
return n;
elif (mod == 1):
return 1;
elif (mod == 2):
return n + 1;
elif (mod == 3):
return 0;
def findXORFun(l, r):
return (xor(findXOR(l - 1) , findXOR(r)));
l = 4; r = 8;
print(findXORFun(l, r));
``` | instruction | 0 | 91,942 | 12 | 183,884 |
No | output | 1 | 91,942 | 12 | 183,885 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
While Duff was resting in the beach, she accidentally found a strange array b0, b1, ..., bl - 1 consisting of l positive integers. This array was strange because it was extremely long, but there was another (maybe shorter) array, a0, ..., an - 1 that b can be build from a with formula: bi = ai mod n where a mod b denoted the remainder of dividing a by b.
<image>
Duff is so curious, she wants to know the number of subsequences of b like bi1, bi2, ..., bix (0 ≤ i1 < i2 < ... < ix < l), such that:
* 1 ≤ x ≤ k
* For each 1 ≤ j ≤ x - 1, <image>
* For each 1 ≤ j ≤ x - 1, bij ≤ bij + 1. i.e this subsequence is non-decreasing.
Since this number can be very large, she want to know it modulo 109 + 7.
Duff is not a programmer, and Malek is unavailable at the moment. So she asked for your help. Please tell her this number.
Input
The first line of input contains three integers, n, l and k (1 ≤ n, k, n × k ≤ 106 and 1 ≤ l ≤ 1018).
The second line contains n space separated integers, a0, a1, ..., an - 1 (1 ≤ ai ≤ 109 for each 0 ≤ i ≤ n - 1).
Output
Print the answer modulo 1 000 000 007 in one line.
Examples
Input
3 5 3
5 9 1
Output
10
Input
5 10 3
1 2 3 4 5
Output
25
Note
In the first sample case, <image>. So all such sequences are: <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image> and <image>.
Submitted Solution:
```
import sys
readline = sys.stdin.readline
MOD = 10**9+7
def frac(limit):
frac = [1]*limit
for i in range(2,limit):
frac[i] = i * frac[i-1]%MOD
fraci = [None]*limit
fraci[-1] = pow(frac[-1], MOD -2, MOD)
for i in range(-2, -limit-1, -1):
fraci[i] = fraci[i+1] * (limit + i + 1) % MOD
return frac, fraci
frac, fraci = frac(1341398)
def comb(a, b):
if not a >= b >= 0:
return 0
return frac[a]*fraci[b]*fraci[a-b]%MOD
def compress(L):
L2 = list(set(L))
L2.sort()
C = {v : k for k, v in enumerate(L2)}
return L2, C
N, L, K = map(int, readline().split())
A = list(map(int, readline().split()))
_, Ca = compress(A)
A = [Ca[a] for a in A]
dp1 = [1]*N
R = (L//N)
if N <= L:
ans = R*N
D = [R]*N
else:
ans = 0
D = [0]*N
cr = R
for r in range(2, min(R, K)+1):
da = [0]*N
for j in range(N):
a = A[j]
da[a] = (da[a] + dp1[j])%MOD
for a in range(1, N):
da[a] = (da[a] + da[a-1])%MOD
cr = cr*(R-r+1)*fraci[r]*frac[r-1]%MOD
for j in range(N):
a = A[j]
dp1[j] = da[a]
ans = (ans + cr*dp1[j])%MOD
if r < K:
D[j] = (D[j] + cr*dp1[j])%MOD
da = [0]*N
for j in range(N):
a = A[j]
da[a] = (da[a] + D[j])%MOD
for a in range(1, N):
da[a] = (da[a] + da[a-1])%MOD
for j in range(L%N):
a = A[j]
ans = (ans+da[a])%MOD
ans = (ans + L%N)%MOD
print(ans)
``` | instruction | 0 | 92,154 | 12 | 184,308 |
No | output | 1 | 92,154 | 12 | 184,309 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
While Duff was resting in the beach, she accidentally found a strange array b0, b1, ..., bl - 1 consisting of l positive integers. This array was strange because it was extremely long, but there was another (maybe shorter) array, a0, ..., an - 1 that b can be build from a with formula: bi = ai mod n where a mod b denoted the remainder of dividing a by b.
<image>
Duff is so curious, she wants to know the number of subsequences of b like bi1, bi2, ..., bix (0 ≤ i1 < i2 < ... < ix < l), such that:
* 1 ≤ x ≤ k
* For each 1 ≤ j ≤ x - 1, <image>
* For each 1 ≤ j ≤ x - 1, bij ≤ bij + 1. i.e this subsequence is non-decreasing.
Since this number can be very large, she want to know it modulo 109 + 7.
Duff is not a programmer, and Malek is unavailable at the moment. So she asked for your help. Please tell her this number.
Input
The first line of input contains three integers, n, l and k (1 ≤ n, k, n × k ≤ 106 and 1 ≤ l ≤ 1018).
The second line contains n space separated integers, a0, a1, ..., an - 1 (1 ≤ ai ≤ 109 for each 0 ≤ i ≤ n - 1).
Output
Print the answer modulo 1 000 000 007 in one line.
Examples
Input
3 5 3
5 9 1
Output
10
Input
5 10 3
1 2 3 4 5
Output
25
Note
In the first sample case, <image>. So all such sequences are: <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image> and <image>.
Submitted Solution:
```
#import sys
from operator import itemgetter
#sys.stdin = open('input.txt')
MOD = int(1e09+7)
n, l, k = map(int, input().split())
a = [[int(x), False] for x in input().split()]
rem = (l - 1)%n + 1
i = 0
while i < rem:
a[i][1] = True
i += 1
a.sort(key=itemgetter(0))
ans = 0
sums = []
k2 = (l - 1)//n + 1
k1 = min(k, k2)
cur = 0
i = 0
while i < min(l, n):
if a[i][0] != cur:
sums.append([0, False])
cur = a[i][0]
if a[i][1]:
sums[len(sums) - 1][1] = True
i += 1
len1 = len(sums)
sums[0][0] = 1
i = 1
while i <= k1:
not_last = i != k1
if sums[0][1]:
ans = (ans + k2 - i + 1) % MOD
elif not_last:
ans = (ans + k2 - i) % MOD
j = 1
while j < len1:
sums[j][0] = (sums[j][0] + sums[j - 1][0]) % MOD
if sums[j][1]:
ans = (ans + sums[j][0]*(k2 - i + 1)) % MOD
elif not_last:
ans = (ans + sums[j][0]*(k2 - 1)) % MOD
j += 1
i += 1
print(ans)
``` | instruction | 0 | 92,155 | 12 | 184,310 |
No | output | 1 | 92,155 | 12 | 184,311 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
While Duff was resting in the beach, she accidentally found a strange array b0, b1, ..., bl - 1 consisting of l positive integers. This array was strange because it was extremely long, but there was another (maybe shorter) array, a0, ..., an - 1 that b can be build from a with formula: bi = ai mod n where a mod b denoted the remainder of dividing a by b.
<image>
Duff is so curious, she wants to know the number of subsequences of b like bi1, bi2, ..., bix (0 ≤ i1 < i2 < ... < ix < l), such that:
* 1 ≤ x ≤ k
* For each 1 ≤ j ≤ x - 1, <image>
* For each 1 ≤ j ≤ x - 1, bij ≤ bij + 1. i.e this subsequence is non-decreasing.
Since this number can be very large, she want to know it modulo 109 + 7.
Duff is not a programmer, and Malek is unavailable at the moment. So she asked for your help. Please tell her this number.
Input
The first line of input contains three integers, n, l and k (1 ≤ n, k, n × k ≤ 106 and 1 ≤ l ≤ 1018).
The second line contains n space separated integers, a0, a1, ..., an - 1 (1 ≤ ai ≤ 109 for each 0 ≤ i ≤ n - 1).
Output
Print the answer modulo 1 000 000 007 in one line.
Examples
Input
3 5 3
5 9 1
Output
10
Input
5 10 3
1 2 3 4 5
Output
25
Note
In the first sample case, <image>. So all such sequences are: <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image> and <image>.
Submitted Solution:
```
import sys
readline = sys.stdin.readline
MOD = 10**9+7
def frac(limit):
frac = [1]*limit
for i in range(2,limit):
frac[i] = i * frac[i-1]%MOD
fraci = [None]*limit
fraci[-1] = pow(frac[-1], MOD -2, MOD)
for i in range(-2, -limit-1, -1):
fraci[i] = fraci[i+1] * (limit + i + 1) % MOD
return frac, fraci
frac, fraci = frac(1341398)
def comb(a, b):
if not a >= b >= 0:
return 0
return frac[a]*fraci[b]*fraci[a-b]%MOD
def compress(L):
L2 = list(set(L))
L2.sort()
C = {v : k for k, v in enumerate(L2)}
return L2, C
N, L, K = map(int, readline().split())
A = list(map(int, readline().split()))
_, Ca = compress(A)
A = [Ca[a] for a in A]
R = (L//N)
if R == 0:
print(L%MOD)
elif N >= L:
print(L%MOD)
else:
ans = L%MOD
D = [R]*N
dp1 = [1]*N
cr = R
for r in range(2, min(R, K)+1):
da = [0]*N
for j in range(N):
a = A[j]
da[a] = (da[a] + dp1[j])%MOD
for a in range(1, N):
da[a] = (da[a] + da[a-1])%MOD
cr = cr*(R-r+1)*fraci[r]*frac[r-1]%MOD
for j in range(N):
a = A[j]
dp1[j] = da[a]
ans = (ans + cr*dp1[j])%MOD
if r < K:
D[j] = (D[j] + cr*dp1[j])%MOD
if K > 1:
da = [0]*N
for j in range(N):
a = A[j]
da[a] = (da[a] + D[j])%MOD
for a in range(1, N):
da[a] = (da[a] + da[a-1])%MOD
for j in range(L%N):
a = A[j]
ans = (ans+da[a])%MOD
print(ans)
``` | instruction | 0 | 92,156 | 12 | 184,312 |
No | output | 1 | 92,156 | 12 | 184,313 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
While Duff was resting in the beach, she accidentally found a strange array b0, b1, ..., bl - 1 consisting of l positive integers. This array was strange because it was extremely long, but there was another (maybe shorter) array, a0, ..., an - 1 that b can be build from a with formula: bi = ai mod n where a mod b denoted the remainder of dividing a by b.
<image>
Duff is so curious, she wants to know the number of subsequences of b like bi1, bi2, ..., bix (0 ≤ i1 < i2 < ... < ix < l), such that:
* 1 ≤ x ≤ k
* For each 1 ≤ j ≤ x - 1, <image>
* For each 1 ≤ j ≤ x - 1, bij ≤ bij + 1. i.e this subsequence is non-decreasing.
Since this number can be very large, she want to know it modulo 109 + 7.
Duff is not a programmer, and Malek is unavailable at the moment. So she asked for your help. Please tell her this number.
Input
The first line of input contains three integers, n, l and k (1 ≤ n, k, n × k ≤ 106 and 1 ≤ l ≤ 1018).
The second line contains n space separated integers, a0, a1, ..., an - 1 (1 ≤ ai ≤ 109 for each 0 ≤ i ≤ n - 1).
Output
Print the answer modulo 1 000 000 007 in one line.
Examples
Input
3 5 3
5 9 1
Output
10
Input
5 10 3
1 2 3 4 5
Output
25
Note
In the first sample case, <image>. So all such sequences are: <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image>, <image> and <image>.
Submitted Solution:
```
import sys
readline = sys.stdin.readline
MOD = 10**9+7
def frac(limit):
frac = [1]*limit
for i in range(2,limit):
frac[i] = i * frac[i-1]%MOD
fraci = [None]*limit
fraci[-1] = pow(frac[-1], MOD -2, MOD)
for i in range(-2, -limit-1, -1):
fraci[i] = fraci[i+1] * (limit + i + 1) % MOD
return frac, fraci
frac, fraci = frac(1341398)
def comb(a, b):
if not a >= b >= 0:
return 0
return frac[a]*fraci[b]*fraci[a-b]%MOD
def compress(L):
L2 = list(set(L))
L2.sort()
C = {v : k for k, v in enumerate(L2)}
return L2, C
N, L, K = map(int, readline().split())
A = list(map(int, readline().split()))
_, Ca = compress(A)
A = [Ca[a] for a in A]
dp1 = [1]*N
R = (L//N)
if N <= L:
ans = R*N
D = [1]*N
else:
ans = 0
D = [0]*N
cr = R
for r in range(2, min(R, K)+1):
da = [0]*N
for j in range(N):
a = A[j]
da[a] = (da[a] + dp1[j])%MOD
for a in range(1, N):
da[a] = (da[a] + da[a-1])%MOD
for j in range(N):
a = A[j]
dp1[j] = da[a]
cr = cr*(R-r+1)*fraci[r]*frac[r-1]%MOD
for i in range(N):
d1 = dp1[i]
c = cr*d1%MOD
ans = (ans + c)%MOD
if r < K:
D[i] = (D[i] + c)%MOD
da = [0]*N
for j in range(N):
a = A[j]
da[a] = (da[a] + D[j])%MOD
for a in range(1, N):
da[a] = (da[a] + da[a-1])%MOD
for j in range(L%N):
a = A[j]
ans = (ans+da[a])%MOD
ans = (ans + L%N)%MOD
print(ans)
``` | instruction | 0 | 92,157 | 12 | 184,314 |
No | output | 1 | 92,157 | 12 | 184,315 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given an integer N, find two permutations:
1. Permutation p of numbers from 1 to N such that pi ≠ i and pi & i = 0 for all i = 1, 2, ..., N.
2. Permutation q of numbers from 1 to N such that qi ≠ i and qi & i ≠ 0 for all i = 1, 2, ..., N.
& is the [bitwise AND operation](https://en.wikipedia.org/wiki/Bitwise_operation#AND).
Input
The input consists of one line containing a single integer N (1 ≤ N ≤ 105).
Output
For each subtask, if the required permutation doesn't exist, output a single line containing the word "NO"; otherwise output the word "YES" in the first line and N elements of the permutation, separated by spaces, in the second line. If there are several possible permutations in a subtask, output any of them.
Examples
Input
3
Output
NO
NO
Input
6
Output
YES
6 5 4 3 2 1
YES
3 6 2 5 1 4 | instruction | 0 | 92,327 | 12 | 184,654 |
Tags: constructive algorithms
Correct Solution:
```
from math import*
n=int(input())
if n%2:
print('NO')
else:
print("YES")
k=floor(log2(n))+1
res = [0 for i in range(n)]
occupied = [0 for i in range(n)]
switch = 0
for i in range(n,0,-1):
val = 2**k-1-i
if val > n:
k-=1
val = 2**k-1-i
if occupied[val-1]:
while occupied[val-1]:
k-=1
val = 2**k-1-i
val = 2**k-1-i
occupied[val-1] = 1
res[i-1] = val
for i in res:
print(i,end=' ')
print()
if n in [1,2,3,4,5]:
print('NO')
elif int(log2(n)) == log2(n):
print('NO')
elif n == 6:
print('YES')
print('3 6 2 5 1 4')
else:
print('YES')
print('7 3 2 5 6 4 1',end=' ')
for i in range(8,n+1):
if int(log2(i)) == log2(i):
print(min(i*2-1,n),end=' ')
else:
print(i-1,end=' ')
print()
``` | output | 1 | 92,327 | 12 | 184,655 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given an integer N, find two permutations:
1. Permutation p of numbers from 1 to N such that pi ≠ i and pi & i = 0 for all i = 1, 2, ..., N.
2. Permutation q of numbers from 1 to N such that qi ≠ i and qi & i ≠ 0 for all i = 1, 2, ..., N.
& is the [bitwise AND operation](https://en.wikipedia.org/wiki/Bitwise_operation#AND).
Input
The input consists of one line containing a single integer N (1 ≤ N ≤ 105).
Output
For each subtask, if the required permutation doesn't exist, output a single line containing the word "NO"; otherwise output the word "YES" in the first line and N elements of the permutation, separated by spaces, in the second line. If there are several possible permutations in a subtask, output any of them.
Examples
Input
3
Output
NO
NO
Input
6
Output
YES
6 5 4 3 2 1
YES
3 6 2 5 1 4 | instruction | 0 | 92,328 | 12 | 184,656 |
Tags: constructive algorithms
Correct Solution:
```
def test(x, i):
i = list(i)
ok = True
for j in range(x):
if (i[j] == j+1 or (i[j]&(j+1) != 0)):
ok = False
if ok:
print(i)
def comp(n):
return 2**len(bin(n)[2:])-1-n
n = int(input())
nn = n
if (n%2 == 0):
x = []
while (n != 0):
#add n to comp(n) to the front of x
for i in range(comp(n), n+1):
x.append(i)
n = comp(n)-1
x.reverse()
print("YES")
print(' '.join([str(i) for i in x]))
else:
print("NO")
pow2 = [2**i for i in range(20)]
def make(n):
if n <= 5: return []
if n == 6: return [3, 6, 1, 5, 4, 2]
if n == 7: return [3, 6, 1, 5, 4, 7, 2]
if n in pow2:
return []
shift = 2**(len(bin(n)[2:])-1)
array = [i for i in range(shift, n+1)]
array = array[1:] + [array[0]]
return make(shift-1) + array
n = nn
k = make(n)
if k == []:
print("NO")
else:
print("YES")
print(' '.join([str(i) for i in k]))
``` | output | 1 | 92,328 | 12 | 184,657 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given an integer N, find two permutations:
1. Permutation p of numbers from 1 to N such that pi ≠ i and pi & i = 0 for all i = 1, 2, ..., N.
2. Permutation q of numbers from 1 to N such that qi ≠ i and qi & i ≠ 0 for all i = 1, 2, ..., N.
& is the [bitwise AND operation](https://en.wikipedia.org/wiki/Bitwise_operation#AND).
Input
The input consists of one line containing a single integer N (1 ≤ N ≤ 105).
Output
For each subtask, if the required permutation doesn't exist, output a single line containing the word "NO"; otherwise output the word "YES" in the first line and N elements of the permutation, separated by spaces, in the second line. If there are several possible permutations in a subtask, output any of them.
Examples
Input
3
Output
NO
NO
Input
6
Output
YES
6 5 4 3 2 1
YES
3 6 2 5 1 4 | instruction | 0 | 92,329 | 12 | 184,658 |
Tags: constructive algorithms
Correct Solution:
```
from math import log2, floor
n=int(input())
# n=100
if n%2:
print('NO')
else:
print("YES")
k=floor(log2(n))+1
res = [0 for i in range(n)]
occupied = [0 for i in range(n)]
switch = 0
for i in range(n,0,-1):
val = 2**k-1-i
if val > n:
k-=1
val = 2**k-1-i
if occupied[val-1]:
while occupied[val-1]:
k-=1
val = 2**k-1-i
val = 2**k-1-i
occupied[val-1] = 1
res[i-1] = val
for i in res:
print(i,end=' ')
print()
if n in [1,2,3,4,5]:
print('NO')
elif int(log2(n)) == log2(n):
print('NO')
elif n == 6:
print('YES')
print('3 6 2 5 1 4')
else:
print('YES')
print('7 3 2 5 6 4 1',end=' ')
for i in range(8,n+1):
if int(log2(i)) == log2(i):
print(min(i*2-1,n),end=' ')
else:
print(i-1,end=' ')
print()
``` | output | 1 | 92,329 | 12 | 184,659 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given an integer N, find two permutations:
1. Permutation p of numbers from 1 to N such that pi ≠ i and pi & i = 0 for all i = 1, 2, ..., N.
2. Permutation q of numbers from 1 to N such that qi ≠ i and qi & i ≠ 0 for all i = 1, 2, ..., N.
& is the [bitwise AND operation](https://en.wikipedia.org/wiki/Bitwise_operation#AND).
Input
The input consists of one line containing a single integer N (1 ≤ N ≤ 105).
Output
For each subtask, if the required permutation doesn't exist, output a single line containing the word "NO"; otherwise output the word "YES" in the first line and N elements of the permutation, separated by spaces, in the second line. If there are several possible permutations in a subtask, output any of them.
Examples
Input
3
Output
NO
NO
Input
6
Output
YES
6 5 4 3 2 1
YES
3 6 2 5 1 4 | instruction | 0 | 92,330 | 12 | 184,660 |
Tags: constructive algorithms
Correct Solution:
```
from math import log
from sys import exit
n = int(input())
a = [i for i in range(n + 1)]
def ans(n):
if n <= 0 or n % 2:
return
j, cr = (1 << int(log(n, 2))), 1
while j + cr - 1 <= n:
a[j - cr], a[j + cr - 1] = a[j + cr - 1], a[j - cr]
cr += 1
ans(j - cr)
if n % 2 == 0:
ans(n)
print("YES")
print(*a[1:])
else:
print("NO")
if n <= 5 or (1 << int(log(n, 2))) == n:
print("NO")
exit(0)
print("YES")
print("3 6 1 5 4 2" if n <= 6 else "3 6 1 5 4 7 2", end=' ')
cr = 8
v = (1 << int(log(n, 2)))
for i in range(8, n + 1):
if i >= v:
print(n if i == v else i - 1, end=' ')
continue
if i == cr:
cr *= 2
print(cr - 1, end=' ')
else:
print(i - 1, end=' ')
``` | output | 1 | 92,330 | 12 | 184,661 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given an integer N, find two permutations:
1. Permutation p of numbers from 1 to N such that pi ≠ i and pi & i = 0 for all i = 1, 2, ..., N.
2. Permutation q of numbers from 1 to N such that qi ≠ i and qi & i ≠ 0 for all i = 1, 2, ..., N.
& is the [bitwise AND operation](https://en.wikipedia.org/wiki/Bitwise_operation#AND).
Input
The input consists of one line containing a single integer N (1 ≤ N ≤ 105).
Output
For each subtask, if the required permutation doesn't exist, output a single line containing the word "NO"; otherwise output the word "YES" in the first line and N elements of the permutation, separated by spaces, in the second line. If there are several possible permutations in a subtask, output any of them.
Examples
Input
3
Output
NO
NO
Input
6
Output
YES
6 5 4 3 2 1
YES
3 6 2 5 1 4 | instruction | 0 | 92,331 | 12 | 184,662 |
Tags: constructive algorithms
Correct Solution:
```
from math import log2, floor
n=int(input())
# n=100
if n%2:
print('NO')
else:
print("YES")
k=floor(log2(n))+1
res = [0 for i in range(n)]
occupied = [0 for i in range(n)]
switch = 0
for i in range(n,0,-1):
val = 2**k-1-i
if val > n:
k-=1
val = 2**k-1-i
if occupied[val-1]:
while occupied[val-1]:
k-=1
val = 2**k-1-i
val = 2**k-1-i
occupied[val-1] = 1
res[i-1] = val
for i in res:
print(i,end=' ')
print()
if n in [1,2,3,4,5]:
print('NO')
elif int(log2(n)) == log2(n):
print('NO')
elif n == 6:
print('YES')
print('3 6 2 5 1 4')
else:
print('YES')
print('7 3 2 5 6 4 1',end=' ')
for i in range(8,n):
p = pow(2,floor(log2(i))+1)
if i < pow(2,floor(log2(n))):
print(p*3//2-1-i,end=' ')
else:
print(i+1,end=' ')
if n > 7:
print(pow(2,floor(log2(n))))
``` | output | 1 | 92,331 | 12 | 184,663 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given an integer N, find two permutations:
1. Permutation p of numbers from 1 to N such that pi ≠ i and pi & i = 0 for all i = 1, 2, ..., N.
2. Permutation q of numbers from 1 to N such that qi ≠ i and qi & i ≠ 0 for all i = 1, 2, ..., N.
& is the [bitwise AND operation](https://en.wikipedia.org/wiki/Bitwise_operation#AND).
Input
The input consists of one line containing a single integer N (1 ≤ N ≤ 105).
Output
For each subtask, if the required permutation doesn't exist, output a single line containing the word "NO"; otherwise output the word "YES" in the first line and N elements of the permutation, separated by spaces, in the second line. If there are several possible permutations in a subtask, output any of them.
Examples
Input
3
Output
NO
NO
Input
6
Output
YES
6 5 4 3 2 1
YES
3 6 2 5 1 4 | instruction | 0 | 92,332 | 12 | 184,664 |
Tags: constructive algorithms
Correct Solution:
```
from math import log2
n = int(input())
p = [0] * (n + 1)
def f(n):
k = int(log2(n))
while k:
i = 1
while (1 << k) + i - 1 <= n:
p[(1 << k) + i - 1] = (1 << k) - i
p[(1 << k) - i] = (1 << k) + i - 1
i += 1
n = (1 << k) - i
if not n:
break
k = int(log2(n))
if n & 1:
print('NO')
else:
print('YES')
f(n)
print(*p[1:])
if n < 6 or 1 << int(log2(n)) == n:
print('NO')
else:
print('YES')
if n == 6:
print('3 6 2 5 1 4')
elif n == 7:
print('7 3 6 5 1 2 4')
else:
print('7 3 6 5 1 2 4', end=' ')
k = 3
while (1 << k) < n:
for i in range((1 << k) + 1, min(1 << k + 1, n + 1)):
print(i, end=' ')
print(1 << k, end=' ')
k += 1
``` | output | 1 | 92,332 | 12 | 184,665 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between problems C1 and C2 is that all values in input of problem C1 are distinct (this condition may be false for problem C2).
You are given a sequence a consisting of n integers. All these integers are distinct, each value from 1 to n appears in the sequence exactly once.
You are making a sequence of moves. During each move you must take either the leftmost element of the sequence or the rightmost element of the sequence, write it down and remove it from the sequence. Your task is to write down a strictly increasing sequence, and among all such sequences you should take the longest (the length of the sequence is the number of elements in it).
For example, for the sequence [2, 1, 5, 4, 3] the answer is 4 (you take 2 and the sequence becomes [1, 5, 4, 3], then you take the rightmost element 3 and the sequence becomes [1, 5, 4], then you take 4 and the sequence becomes [1, 5] and then you take 5 and the sequence becomes [1], the obtained increasing sequence is [2, 3, 4, 5]).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a. All these integers are pairwise distinct.
Output
In the first line of the output print k — the maximum number of elements in a strictly increasing sequence you can obtain.
In the second line print a string s of length k, where the j-th character of this string s_j should be 'L' if you take the leftmost element during the j-th move and 'R' otherwise. If there are multiple answers, you can print any.
Examples
Input
5
2 1 5 4 3
Output
4
LRRR
Input
7
1 3 5 6 7 4 2
Output
7
LRLRLLL
Input
3
1 2 3
Output
3
LLL
Input
4
1 2 4 3
Output
4
LLRL
Note
The first example is described in the problem statement. | instruction | 0 | 92,677 | 12 | 185,354 |
Tags: greedy
Correct Solution:
```
numero = int(input())
pos = []
contador = 0
lista = [int(x) for x in input().split()]
if len(lista )== 1:
pos.append('R')
contador +=1
print(contador)
for x in pos:
print(x,end="")
print()
quit()
if lista[0] > lista[len(lista)-1]:
pos.append('R')
menor = lista.pop(len(lista)-1)
else:
pos.append('L')
menor = lista.pop(0)
contador += 1
inicio = 0
fim = len(lista)-1
tamanho = len(lista)
while True:
if tamanho == 1:
if lista[inicio] > menor:
contador +=1
pos.append('L')
break
else:
break
if lista[inicio] > lista[fim] and lista[fim] > menor:
pos.append('R')
menor = lista[fim]
fim = fim -1
tamanho -= 1
elif lista[inicio] < lista[fim] and lista[inicio] > menor:
pos.append('L')
menor = lista[inicio]
inicio += 1
tamanho -= 1
elif lista[inicio] > lista[fim] and lista[inicio] > menor:
pos.append('L')
menor = lista[inicio]
inicio += 1
tamanho -= 1
elif lista[inicio] < lista[fim] and lista[fim] > menor:
pos.append('R')
menor = lista[fim]
fim = fim -1
tamanho -= 1
else:
break
contador+=1
print(contador)
for x in pos:
print(x,end="")
print()
``` | output | 1 | 92,677 | 12 | 185,355 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between problems C1 and C2 is that all values in input of problem C1 are distinct (this condition may be false for problem C2).
You are given a sequence a consisting of n integers. All these integers are distinct, each value from 1 to n appears in the sequence exactly once.
You are making a sequence of moves. During each move you must take either the leftmost element of the sequence or the rightmost element of the sequence, write it down and remove it from the sequence. Your task is to write down a strictly increasing sequence, and among all such sequences you should take the longest (the length of the sequence is the number of elements in it).
For example, for the sequence [2, 1, 5, 4, 3] the answer is 4 (you take 2 and the sequence becomes [1, 5, 4, 3], then you take the rightmost element 3 and the sequence becomes [1, 5, 4], then you take 4 and the sequence becomes [1, 5] and then you take 5 and the sequence becomes [1], the obtained increasing sequence is [2, 3, 4, 5]).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a. All these integers are pairwise distinct.
Output
In the first line of the output print k — the maximum number of elements in a strictly increasing sequence you can obtain.
In the second line print a string s of length k, where the j-th character of this string s_j should be 'L' if you take the leftmost element during the j-th move and 'R' otherwise. If there are multiple answers, you can print any.
Examples
Input
5
2 1 5 4 3
Output
4
LRRR
Input
7
1 3 5 6 7 4 2
Output
7
LRLRLLL
Input
3
1 2 3
Output
3
LLL
Input
4
1 2 4 3
Output
4
LLRL
Note
The first example is described in the problem statement. | instruction | 0 | 92,678 | 12 | 185,356 |
Tags: greedy
Correct Solution:
```
def solve():
N = int(input())
A = list(map(int,input().split()))
ans = ''
l = 0
r = N - 1
old = 0
while l <= r:
#print(l,r)
if A[l] < A[r]:
if old < A[l]:
old = A[l]
ans += 'L'
l += 1
elif old < A[r]:
old = A[r]
ans += 'R'
r -= 1
else:
break
else:
if old < A[r]:
old = A[r]
ans += 'R'
r -= 1
elif old < A[l]:
old = A[l]
ans += 'L'
l += 1
else:
break
print(len(ans))
print(ans)
solve()
``` | output | 1 | 92,678 | 12 | 185,357 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between problems C1 and C2 is that all values in input of problem C1 are distinct (this condition may be false for problem C2).
You are given a sequence a consisting of n integers. All these integers are distinct, each value from 1 to n appears in the sequence exactly once.
You are making a sequence of moves. During each move you must take either the leftmost element of the sequence or the rightmost element of the sequence, write it down and remove it from the sequence. Your task is to write down a strictly increasing sequence, and among all such sequences you should take the longest (the length of the sequence is the number of elements in it).
For example, for the sequence [2, 1, 5, 4, 3] the answer is 4 (you take 2 and the sequence becomes [1, 5, 4, 3], then you take the rightmost element 3 and the sequence becomes [1, 5, 4], then you take 4 and the sequence becomes [1, 5] and then you take 5 and the sequence becomes [1], the obtained increasing sequence is [2, 3, 4, 5]).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a. All these integers are pairwise distinct.
Output
In the first line of the output print k — the maximum number of elements in a strictly increasing sequence you can obtain.
In the second line print a string s of length k, where the j-th character of this string s_j should be 'L' if you take the leftmost element during the j-th move and 'R' otherwise. If there are multiple answers, you can print any.
Examples
Input
5
2 1 5 4 3
Output
4
LRRR
Input
7
1 3 5 6 7 4 2
Output
7
LRLRLLL
Input
3
1 2 3
Output
3
LLL
Input
4
1 2 4 3
Output
4
LLRL
Note
The first example is described in the problem statement. | instruction | 0 | 92,679 | 12 | 185,358 |
Tags: greedy
Correct Solution:
```
n = int(input())
A = input()
A = [int(x) for x in A.split()]
i = 0
j = len(A) - 1
last = float("-inf")
out = []
while i <= j:
if A[i] > last and (A[i] <= A[j] or A[j] < last):
out.append("L")
last = A[i]
i += 1
elif A[j] > last and (A[j] <= A[i] or A[i] < last):
out.append("R")
last = A[j]
j -= 1
else:
break
print(len(out))
print("".join(out))
``` | output | 1 | 92,679 | 12 | 185,359 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between problems C1 and C2 is that all values in input of problem C1 are distinct (this condition may be false for problem C2).
You are given a sequence a consisting of n integers. All these integers are distinct, each value from 1 to n appears in the sequence exactly once.
You are making a sequence of moves. During each move you must take either the leftmost element of the sequence or the rightmost element of the sequence, write it down and remove it from the sequence. Your task is to write down a strictly increasing sequence, and among all such sequences you should take the longest (the length of the sequence is the number of elements in it).
For example, for the sequence [2, 1, 5, 4, 3] the answer is 4 (you take 2 and the sequence becomes [1, 5, 4, 3], then you take the rightmost element 3 and the sequence becomes [1, 5, 4], then you take 4 and the sequence becomes [1, 5] and then you take 5 and the sequence becomes [1], the obtained increasing sequence is [2, 3, 4, 5]).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a. All these integers are pairwise distinct.
Output
In the first line of the output print k — the maximum number of elements in a strictly increasing sequence you can obtain.
In the second line print a string s of length k, where the j-th character of this string s_j should be 'L' if you take the leftmost element during the j-th move and 'R' otherwise. If there are multiple answers, you can print any.
Examples
Input
5
2 1 5 4 3
Output
4
LRRR
Input
7
1 3 5 6 7 4 2
Output
7
LRLRLLL
Input
3
1 2 3
Output
3
LLL
Input
4
1 2 4 3
Output
4
LLRL
Note
The first example is described in the problem statement. | instruction | 0 | 92,680 | 12 | 185,360 |
Tags: greedy
Correct Solution:
```
n = int(input())
a = [int(x) for x in input().split()]
i = 0
j = n-1
prev = -1
ans = []
while(i<=j):
if a[i]<a[j]:
if a[i]>prev:
ans += 'L'
prev = a[i]
i += 1
elif a[j]>prev:
ans += 'R'
prev = a[j]
j -= 1
else:
break
elif a[i]>a[j]:
if a[j]>prev:
ans += 'R'
prev = a[j]
j -= 1
elif a[i]>prev:
ans += 'L'
prev = a[i]
i += 1
else:
break
elif a[i]>prev:
l = 0
for p in range(i+1, j):
if a[p]>a[p-1]:
l += 1
else:
break
r = 0
for p in range(j-1, i, -1):
if a[p]>a[p+1]:
r += 1
else:
break
if r>l:
ans += 'R'*(r+1)
prev = a[j]
j -= 1
else:
ans += 'L'*(l+1)
prev = a[i]
i += 1
break
else:
break
print(len(ans))
print(*ans, sep = "")
``` | output | 1 | 92,680 | 12 | 185,361 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between problems C1 and C2 is that all values in input of problem C1 are distinct (this condition may be false for problem C2).
You are given a sequence a consisting of n integers. All these integers are distinct, each value from 1 to n appears in the sequence exactly once.
You are making a sequence of moves. During each move you must take either the leftmost element of the sequence or the rightmost element of the sequence, write it down and remove it from the sequence. Your task is to write down a strictly increasing sequence, and among all such sequences you should take the longest (the length of the sequence is the number of elements in it).
For example, for the sequence [2, 1, 5, 4, 3] the answer is 4 (you take 2 and the sequence becomes [1, 5, 4, 3], then you take the rightmost element 3 and the sequence becomes [1, 5, 4], then you take 4 and the sequence becomes [1, 5] and then you take 5 and the sequence becomes [1], the obtained increasing sequence is [2, 3, 4, 5]).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a. All these integers are pairwise distinct.
Output
In the first line of the output print k — the maximum number of elements in a strictly increasing sequence you can obtain.
In the second line print a string s of length k, where the j-th character of this string s_j should be 'L' if you take the leftmost element during the j-th move and 'R' otherwise. If there are multiple answers, you can print any.
Examples
Input
5
2 1 5 4 3
Output
4
LRRR
Input
7
1 3 5 6 7 4 2
Output
7
LRLRLLL
Input
3
1 2 3
Output
3
LLL
Input
4
1 2 4 3
Output
4
LLRL
Note
The first example is described in the problem statement. | instruction | 0 | 92,681 | 12 | 185,362 |
Tags: greedy
Correct Solution:
```
input();a=*map(int,input().split()),;r,s=len(a)-1,'';l=e=0
while l<=r and max(a[l],a[r])>e:
L,R=a[l],a[r]
if L>e>R or R>L>e:e=L;l+=1;s+='L'
else:e=R;r-=1;s+='R'
print(len(s),s)
``` | output | 1 | 92,681 | 12 | 185,363 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between problems C1 and C2 is that all values in input of problem C1 are distinct (this condition may be false for problem C2).
You are given a sequence a consisting of n integers. All these integers are distinct, each value from 1 to n appears in the sequence exactly once.
You are making a sequence of moves. During each move you must take either the leftmost element of the sequence or the rightmost element of the sequence, write it down and remove it from the sequence. Your task is to write down a strictly increasing sequence, and among all such sequences you should take the longest (the length of the sequence is the number of elements in it).
For example, for the sequence [2, 1, 5, 4, 3] the answer is 4 (you take 2 and the sequence becomes [1, 5, 4, 3], then you take the rightmost element 3 and the sequence becomes [1, 5, 4], then you take 4 and the sequence becomes [1, 5] and then you take 5 and the sequence becomes [1], the obtained increasing sequence is [2, 3, 4, 5]).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a. All these integers are pairwise distinct.
Output
In the first line of the output print k — the maximum number of elements in a strictly increasing sequence you can obtain.
In the second line print a string s of length k, where the j-th character of this string s_j should be 'L' if you take the leftmost element during the j-th move and 'R' otherwise. If there are multiple answers, you can print any.
Examples
Input
5
2 1 5 4 3
Output
4
LRRR
Input
7
1 3 5 6 7 4 2
Output
7
LRLRLLL
Input
3
1 2 3
Output
3
LLL
Input
4
1 2 4 3
Output
4
LLRL
Note
The first example is described in the problem statement. | instruction | 0 | 92,682 | 12 | 185,364 |
Tags: greedy
Correct Solution:
```
def main():
n = int(input())
seq = list(map(int, input().split(' ')))
i = 0
j = len(seq) - 1
res = []
res_seq = []
while i < j:
if len(res) == 0:
if seq[i] <= seq[j]:
res.append(seq[i])
i += 1
res_seq.append('L')
else:
res.append(seq[j])
j -= 1
res_seq.append('R')
elif seq[i] > res[len(res) - 1] and seq[j] > res[len(res) - 1]:
if seq[i] < seq[j]:
res.append(seq[i])
i += 1
res_seq.append('L')
else:
res.append(seq[j])
j -= 1
res_seq.append('R')
else:
if seq[i] > res[len(res) - 1]:
res.append(seq[i])
res_seq.append('L')
i += 1
elif seq[j] > res[len(res) - 1]:
res.append(seq[j])
res_seq.append('R')
j -= 1
else:
break
if i == j and len(res) == 0:
res.append(seq[i])
res_seq.append('L')
elif i == j and seq[i] >= res[len(res) - 1]:
res.append(seq[i])
res_seq.append('L')
print(len(res))
print("".join(res_seq))
if __name__ == "__main__":
main()
``` | output | 1 | 92,682 | 12 | 185,365 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between problems C1 and C2 is that all values in input of problem C1 are distinct (this condition may be false for problem C2).
You are given a sequence a consisting of n integers. All these integers are distinct, each value from 1 to n appears in the sequence exactly once.
You are making a sequence of moves. During each move you must take either the leftmost element of the sequence or the rightmost element of the sequence, write it down and remove it from the sequence. Your task is to write down a strictly increasing sequence, and among all such sequences you should take the longest (the length of the sequence is the number of elements in it).
For example, for the sequence [2, 1, 5, 4, 3] the answer is 4 (you take 2 and the sequence becomes [1, 5, 4, 3], then you take the rightmost element 3 and the sequence becomes [1, 5, 4], then you take 4 and the sequence becomes [1, 5] and then you take 5 and the sequence becomes [1], the obtained increasing sequence is [2, 3, 4, 5]).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a. All these integers are pairwise distinct.
Output
In the first line of the output print k — the maximum number of elements in a strictly increasing sequence you can obtain.
In the second line print a string s of length k, where the j-th character of this string s_j should be 'L' if you take the leftmost element during the j-th move and 'R' otherwise. If there are multiple answers, you can print any.
Examples
Input
5
2 1 5 4 3
Output
4
LRRR
Input
7
1 3 5 6 7 4 2
Output
7
LRLRLLL
Input
3
1 2 3
Output
3
LLL
Input
4
1 2 4 3
Output
4
LLRL
Note
The first example is described in the problem statement. | instruction | 0 | 92,683 | 12 | 185,366 |
Tags: greedy
Correct Solution:
```
R = lambda: map(int, input().split())
n = int(input())
L = list(R())
mi = 0
i,j = 0,n-1
res = []
while i <= j:
if mi < L[j] and mi < L[i]:
if L[i] > L[j]:
res.append('R')
mi = L[j]
j -= 1
else:
res.append('L')
mi = L[i]
i += 1
elif mi < L[j]:
res.append('R')
mi = L[j]
j -= 1
elif mi < L[i]:
res.append('L')
mi = L[i]
i += 1
else:break
print(len(res))
print(''.join(res))
``` | output | 1 | 92,683 | 12 | 185,367 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between problems C1 and C2 is that all values in input of problem C1 are distinct (this condition may be false for problem C2).
You are given a sequence a consisting of n integers. All these integers are distinct, each value from 1 to n appears in the sequence exactly once.
You are making a sequence of moves. During each move you must take either the leftmost element of the sequence or the rightmost element of the sequence, write it down and remove it from the sequence. Your task is to write down a strictly increasing sequence, and among all such sequences you should take the longest (the length of the sequence is the number of elements in it).
For example, for the sequence [2, 1, 5, 4, 3] the answer is 4 (you take 2 and the sequence becomes [1, 5, 4, 3], then you take the rightmost element 3 and the sequence becomes [1, 5, 4], then you take 4 and the sequence becomes [1, 5] and then you take 5 and the sequence becomes [1], the obtained increasing sequence is [2, 3, 4, 5]).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a. All these integers are pairwise distinct.
Output
In the first line of the output print k — the maximum number of elements in a strictly increasing sequence you can obtain.
In the second line print a string s of length k, where the j-th character of this string s_j should be 'L' if you take the leftmost element during the j-th move and 'R' otherwise. If there are multiple answers, you can print any.
Examples
Input
5
2 1 5 4 3
Output
4
LRRR
Input
7
1 3 5 6 7 4 2
Output
7
LRLRLLL
Input
3
1 2 3
Output
3
LLL
Input
4
1 2 4 3
Output
4
LLRL
Note
The first example is described in the problem statement. | instruction | 0 | 92,684 | 12 | 185,368 |
Tags: greedy
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
fi, bi = 0, n - 1
prev = 0
res = []
while fi <= bi:
f, b = a[fi], a[bi]
if prev >= f and prev >= b:
break
elif f <= b:
if f > prev:
res.append('L')
fi += 1
prev = f
else:
res.append('R')
bi -= 1
prev = b
else:
if b > prev:
res.append('R')
bi -= 1
prev = b
else:
res.append('L')
fi += 1
prev = f
print(len(res))
for c in res:
print(c, end='')
print()
``` | output | 1 | 92,684 | 12 | 185,369 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between problems C1 and C2 is that all values in input of problem C1 are distinct (this condition may be false for problem C2).
You are given a sequence a consisting of n integers. All these integers are distinct, each value from 1 to n appears in the sequence exactly once.
You are making a sequence of moves. During each move you must take either the leftmost element of the sequence or the rightmost element of the sequence, write it down and remove it from the sequence. Your task is to write down a strictly increasing sequence, and among all such sequences you should take the longest (the length of the sequence is the number of elements in it).
For example, for the sequence [2, 1, 5, 4, 3] the answer is 4 (you take 2 and the sequence becomes [1, 5, 4, 3], then you take the rightmost element 3 and the sequence becomes [1, 5, 4], then you take 4 and the sequence becomes [1, 5] and then you take 5 and the sequence becomes [1], the obtained increasing sequence is [2, 3, 4, 5]).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a. All these integers are pairwise distinct.
Output
In the first line of the output print k — the maximum number of elements in a strictly increasing sequence you can obtain.
In the second line print a string s of length k, where the j-th character of this string s_j should be 'L' if you take the leftmost element during the j-th move and 'R' otherwise. If there are multiple answers, you can print any.
Examples
Input
5
2 1 5 4 3
Output
4
LRRR
Input
7
1 3 5 6 7 4 2
Output
7
LRLRLLL
Input
3
1 2 3
Output
3
LLL
Input
4
1 2 4 3
Output
4
LLRL
Note
The first example is described in the problem statement.
Submitted Solution:
```
from collections import deque
n = int(input())
a = deque(int(x) for x in input().split())
ans = []
temp = 0
while a:
if a[0] > temp:
if a[-1] > temp and a[-1] < a[0]:
ans.append('R')
temp = a[-1]
a.pop()
else:
ans.append('L')
temp = a[0]
a.popleft()
else:
if a[-1] > temp:
ans.append('R')
temp = a[-1]
a.pop()
else:
break
print(len(ans))
print(''.join(ans))
``` | instruction | 0 | 92,685 | 12 | 185,370 |
Yes | output | 1 | 92,685 | 12 | 185,371 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between problems C1 and C2 is that all values in input of problem C1 are distinct (this condition may be false for problem C2).
You are given a sequence a consisting of n integers. All these integers are distinct, each value from 1 to n appears in the sequence exactly once.
You are making a sequence of moves. During each move you must take either the leftmost element of the sequence or the rightmost element of the sequence, write it down and remove it from the sequence. Your task is to write down a strictly increasing sequence, and among all such sequences you should take the longest (the length of the sequence is the number of elements in it).
For example, for the sequence [2, 1, 5, 4, 3] the answer is 4 (you take 2 and the sequence becomes [1, 5, 4, 3], then you take the rightmost element 3 and the sequence becomes [1, 5, 4], then you take 4 and the sequence becomes [1, 5] and then you take 5 and the sequence becomes [1], the obtained increasing sequence is [2, 3, 4, 5]).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a. All these integers are pairwise distinct.
Output
In the first line of the output print k — the maximum number of elements in a strictly increasing sequence you can obtain.
In the second line print a string s of length k, where the j-th character of this string s_j should be 'L' if you take the leftmost element during the j-th move and 'R' otherwise. If there are multiple answers, you can print any.
Examples
Input
5
2 1 5 4 3
Output
4
LRRR
Input
7
1 3 5 6 7 4 2
Output
7
LRLRLLL
Input
3
1 2 3
Output
3
LLL
Input
4
1 2 4 3
Output
4
LLRL
Note
The first example is described in the problem statement.
Submitted Solution:
```
n=int(input())
a=*map(int,input().split()),
r=''
i=p=0
j=n-1
while i<=j and(a[i]>p or a[j]>p):
if a[i]>p>=a[j]or a[j]>=a[i]>p:r+='L';p=a[i];i+=1
elif a[j]>p>a[i]or a[i]>a[j]>p:r+='R';p=a[j];j-=1
print(len(r),r)
``` | instruction | 0 | 92,686 | 12 | 185,372 |
Yes | output | 1 | 92,686 | 12 | 185,373 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between problems C1 and C2 is that all values in input of problem C1 are distinct (this condition may be false for problem C2).
You are given a sequence a consisting of n integers. All these integers are distinct, each value from 1 to n appears in the sequence exactly once.
You are making a sequence of moves. During each move you must take either the leftmost element of the sequence or the rightmost element of the sequence, write it down and remove it from the sequence. Your task is to write down a strictly increasing sequence, and among all such sequences you should take the longest (the length of the sequence is the number of elements in it).
For example, for the sequence [2, 1, 5, 4, 3] the answer is 4 (you take 2 and the sequence becomes [1, 5, 4, 3], then you take the rightmost element 3 and the sequence becomes [1, 5, 4], then you take 4 and the sequence becomes [1, 5] and then you take 5 and the sequence becomes [1], the obtained increasing sequence is [2, 3, 4, 5]).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a. All these integers are pairwise distinct.
Output
In the first line of the output print k — the maximum number of elements in a strictly increasing sequence you can obtain.
In the second line print a string s of length k, where the j-th character of this string s_j should be 'L' if you take the leftmost element during the j-th move and 'R' otherwise. If there are multiple answers, you can print any.
Examples
Input
5
2 1 5 4 3
Output
4
LRRR
Input
7
1 3 5 6 7 4 2
Output
7
LRLRLLL
Input
3
1 2 3
Output
3
LLL
Input
4
1 2 4 3
Output
4
LLRL
Note
The first example is described in the problem statement.
Submitted Solution:
```
n = int(input())
s = list(map(int,input().split()))
t = 0
ans = ''
l = 0
r = n-1
while l <= r:
if t < s[l] < s[r]:
ans += 'L'
t = s[l]
l += 1
elif t < s[r] < s[l]:
ans += 'R'
t = s[r]
r -= 1
elif t < s[l]:
ans += 'L'
t = s[l]
l += 1
elif t < s[r]:
ans += 'R'
t = s[r]
r -= 1
else:
break
print(len(ans))
print(ans)
``` | instruction | 0 | 92,687 | 12 | 185,374 |
Yes | output | 1 | 92,687 | 12 | 185,375 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between problems C1 and C2 is that all values in input of problem C1 are distinct (this condition may be false for problem C2).
You are given a sequence a consisting of n integers. All these integers are distinct, each value from 1 to n appears in the sequence exactly once.
You are making a sequence of moves. During each move you must take either the leftmost element of the sequence or the rightmost element of the sequence, write it down and remove it from the sequence. Your task is to write down a strictly increasing sequence, and among all such sequences you should take the longest (the length of the sequence is the number of elements in it).
For example, for the sequence [2, 1, 5, 4, 3] the answer is 4 (you take 2 and the sequence becomes [1, 5, 4, 3], then you take the rightmost element 3 and the sequence becomes [1, 5, 4], then you take 4 and the sequence becomes [1, 5] and then you take 5 and the sequence becomes [1], the obtained increasing sequence is [2, 3, 4, 5]).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a. All these integers are pairwise distinct.
Output
In the first line of the output print k — the maximum number of elements in a strictly increasing sequence you can obtain.
In the second line print a string s of length k, where the j-th character of this string s_j should be 'L' if you take the leftmost element during the j-th move and 'R' otherwise. If there are multiple answers, you can print any.
Examples
Input
5
2 1 5 4 3
Output
4
LRRR
Input
7
1 3 5 6 7 4 2
Output
7
LRLRLLL
Input
3
1 2 3
Output
3
LLL
Input
4
1 2 4 3
Output
4
LLRL
Note
The first example is described in the problem statement.
Submitted Solution:
```
n = int(input())
x = list(map(int,input().split()))
l = 0
r = n-1
ans1 = 0
ans2 = ''
now = 0
while l <= r:
if now < x[l]:
if x[l] < x[r]:
ans1 += 1
ans2 = ans2+'L'
now = x[l]
l += 1
elif now > x[r]:
ans1 += 1
ans2 = ans2+'L'
now = x[l]
l += 1
else:
ans1 += 1
ans2 = ans2+'R'
now = x[r]
r -= 1
elif now < x[r]:
ans1 += 1
ans2 = ans2+'R'
now = x[r]
r -= 1
else:
break
print(ans1)
print(ans2)
``` | instruction | 0 | 92,688 | 12 | 185,376 |
Yes | output | 1 | 92,688 | 12 | 185,377 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between problems C1 and C2 is that all values in input of problem C1 are distinct (this condition may be false for problem C2).
You are given a sequence a consisting of n integers. All these integers are distinct, each value from 1 to n appears in the sequence exactly once.
You are making a sequence of moves. During each move you must take either the leftmost element of the sequence or the rightmost element of the sequence, write it down and remove it from the sequence. Your task is to write down a strictly increasing sequence, and among all such sequences you should take the longest (the length of the sequence is the number of elements in it).
For example, for the sequence [2, 1, 5, 4, 3] the answer is 4 (you take 2 and the sequence becomes [1, 5, 4, 3], then you take the rightmost element 3 and the sequence becomes [1, 5, 4], then you take 4 and the sequence becomes [1, 5] and then you take 5 and the sequence becomes [1], the obtained increasing sequence is [2, 3, 4, 5]).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a. All these integers are pairwise distinct.
Output
In the first line of the output print k — the maximum number of elements in a strictly increasing sequence you can obtain.
In the second line print a string s of length k, where the j-th character of this string s_j should be 'L' if you take the leftmost element during the j-th move and 'R' otherwise. If there are multiple answers, you can print any.
Examples
Input
5
2 1 5 4 3
Output
4
LRRR
Input
7
1 3 5 6 7 4 2
Output
7
LRLRLLL
Input
3
1 2 3
Output
3
LLL
Input
4
1 2 4 3
Output
4
LLRL
Note
The first example is described in the problem statement.
Submitted Solution:
```
n = int(input())
arr = list(map(int, input().split()))
l = 0
r = n - 1
ans = []
res = []
pos = 1
prep = []
a = n
for k in range(a):
prep.append([1, 1])
#prep = [[1 for j in range(2)] for i in range(n)]
for i in range(1, n):
if (arr[i] < arr[i - 1]):
prep[i][1] = prep[i - 1][1] + 1
for i in range(n - 2, -1, -1):
if (arr[i] < arr[i + 1]):
prep[i][0] = prep[i + 1][0] + 1
if arr[l] < arr[r]:
ans.append(arr[l])
l += 1
res.append('L')
else:
if (prep[l][0] > prep[r][1]):
ans.append(arr[l])
l += 1
res.append('L')
elif (prep[r][1] >= prep[l][0]):
ans.append(arr[r])
r -= 1
res.append('R')
while pos:
if (l == r):
if ans[len(ans) - 1] < arr[l]:
ans.append(arr[l])
res.append('R')
pos = 0
continue
elif arr[l] < arr[r]:
if arr[l] > ans[len(ans) - 1]:
ans.append(arr[l])
l += 1
res.append('L')
elif arr[r] > ans[len(ans) - 1]:
ans.append(arr[r])
r -= 1
res.append('R')
else:
pos = 0
elif arr[l] > arr[r]:
if arr[r] > ans[len(ans) - 1]:
ans.append(arr[r])
r -= 1
res.append('R')
elif arr[l] > ans[len(ans) - 1]:
ans.append(arr[l])
l += 1
res.append('L')
else:
pos = 0
else:
if r < l:
pos = 0
continue
elif (prep[l][0] > prep[r][1]):
if arr[l] > ans[len(ans) - 1]:
ans.append(arr[l])
l += 1
res.append('L')
elif arr[r] > ans[len(ans) - 1]:
ans.append(arr[r])
r -= 1
res.append('R')
else:
pos = 0
elif (prep[r][1] >= prep[l][0]):
if arr[r] > ans[len(ans) - 1]:
ans.append(arr[r])
r -= 1
res.append('R')
elif arr[l] > ans[len(ans) - 1]:
ans.append(arr[l])
l += 1
res.append('L')
else:
pos = 0
print(len(res))
for el in res:
print(el, end = "")
``` | instruction | 0 | 92,689 | 12 | 185,378 |
No | output | 1 | 92,689 | 12 | 185,379 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between problems C1 and C2 is that all values in input of problem C1 are distinct (this condition may be false for problem C2).
You are given a sequence a consisting of n integers. All these integers are distinct, each value from 1 to n appears in the sequence exactly once.
You are making a sequence of moves. During each move you must take either the leftmost element of the sequence or the rightmost element of the sequence, write it down and remove it from the sequence. Your task is to write down a strictly increasing sequence, and among all such sequences you should take the longest (the length of the sequence is the number of elements in it).
For example, for the sequence [2, 1, 5, 4, 3] the answer is 4 (you take 2 and the sequence becomes [1, 5, 4, 3], then you take the rightmost element 3 and the sequence becomes [1, 5, 4], then you take 4 and the sequence becomes [1, 5] and then you take 5 and the sequence becomes [1], the obtained increasing sequence is [2, 3, 4, 5]).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a. All these integers are pairwise distinct.
Output
In the first line of the output print k — the maximum number of elements in a strictly increasing sequence you can obtain.
In the second line print a string s of length k, where the j-th character of this string s_j should be 'L' if you take the leftmost element during the j-th move and 'R' otherwise. If there are multiple answers, you can print any.
Examples
Input
5
2 1 5 4 3
Output
4
LRRR
Input
7
1 3 5 6 7 4 2
Output
7
LRLRLLL
Input
3
1 2 3
Output
3
LLL
Input
4
1 2 4 3
Output
4
LLRL
Note
The first example is described in the problem statement.
Submitted Solution:
```
n = int(input())
nums = list(map(int, input().split()))
moves = []
prev = float('-inf')
print(prev)
while nums:
print(nums)
if nums[0] < prev and nums[-1] < prev:
break
elif nums[0] < nums[-1] and nums[0] > prev:
moves.append("L")
prev = nums.pop(0)
continue
elif nums[-1] > prev:
moves.append("R")
prev = nums.pop(-1)
continue
else:
break
print(len(moves))
print(''.join(moves))
``` | instruction | 0 | 92,690 | 12 | 185,380 |
No | output | 1 | 92,690 | 12 | 185,381 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between problems C1 and C2 is that all values in input of problem C1 are distinct (this condition may be false for problem C2).
You are given a sequence a consisting of n integers. All these integers are distinct, each value from 1 to n appears in the sequence exactly once.
You are making a sequence of moves. During each move you must take either the leftmost element of the sequence or the rightmost element of the sequence, write it down and remove it from the sequence. Your task is to write down a strictly increasing sequence, and among all such sequences you should take the longest (the length of the sequence is the number of elements in it).
For example, for the sequence [2, 1, 5, 4, 3] the answer is 4 (you take 2 and the sequence becomes [1, 5, 4, 3], then you take the rightmost element 3 and the sequence becomes [1, 5, 4], then you take 4 and the sequence becomes [1, 5] and then you take 5 and the sequence becomes [1], the obtained increasing sequence is [2, 3, 4, 5]).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a. All these integers are pairwise distinct.
Output
In the first line of the output print k — the maximum number of elements in a strictly increasing sequence you can obtain.
In the second line print a string s of length k, where the j-th character of this string s_j should be 'L' if you take the leftmost element during the j-th move and 'R' otherwise. If there are multiple answers, you can print any.
Examples
Input
5
2 1 5 4 3
Output
4
LRRR
Input
7
1 3 5 6 7 4 2
Output
7
LRLRLLL
Input
3
1 2 3
Output
3
LLL
Input
4
1 2 4 3
Output
4
LLRL
Note
The first example is described in the problem statement.
Submitted Solution:
```
def f(first, last, lastNum):
print(first, last, lastNum)
global a
if first == last:
if a[first] > lastNum:
return ['L']
else:
return []
else:
if a[first] > lastNum:
r1 = f(first + 1, last, a[first])
r1.insert(0, 'L')
else:
r1 = []
if a[last] > lastNum:
r2 = f(first, last - 1, a[last])
r2.insert(0, 'R')
else:
r2 = []
if len(r1) > len(r2):
return r1
elif len(r2) > len(r1):
return r2
elif len(r1) > 0:
return r1
else:
return []
n = int(input())
a = list(map(int, input().split()))
res = f(0, n-1, -1)
print(len(res))
print(*res, sep = '')
``` | instruction | 0 | 92,691 | 12 | 185,382 |
No | output | 1 | 92,691 | 12 | 185,383 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between problems C1 and C2 is that all values in input of problem C1 are distinct (this condition may be false for problem C2).
You are given a sequence a consisting of n integers. All these integers are distinct, each value from 1 to n appears in the sequence exactly once.
You are making a sequence of moves. During each move you must take either the leftmost element of the sequence or the rightmost element of the sequence, write it down and remove it from the sequence. Your task is to write down a strictly increasing sequence, and among all such sequences you should take the longest (the length of the sequence is the number of elements in it).
For example, for the sequence [2, 1, 5, 4, 3] the answer is 4 (you take 2 and the sequence becomes [1, 5, 4, 3], then you take the rightmost element 3 and the sequence becomes [1, 5, 4], then you take 4 and the sequence becomes [1, 5] and then you take 5 and the sequence becomes [1], the obtained increasing sequence is [2, 3, 4, 5]).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a. All these integers are pairwise distinct.
Output
In the first line of the output print k — the maximum number of elements in a strictly increasing sequence you can obtain.
In the second line print a string s of length k, where the j-th character of this string s_j should be 'L' if you take the leftmost element during the j-th move and 'R' otherwise. If there are multiple answers, you can print any.
Examples
Input
5
2 1 5 4 3
Output
4
LRRR
Input
7
1 3 5 6 7 4 2
Output
7
LRLRLLL
Input
3
1 2 3
Output
3
LLL
Input
4
1 2 4 3
Output
4
LLRL
Note
The first example is described in the problem statement.
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
Lind = 0
Rind = n - 1
flag = True
ans = list()
ans.append(0)
ans2 = list()
flag5 = True
flag6 = True
while flag and Rind >= Lind and flag5 and flag6:
if a[Rind] > a[Lind]:
if a[Lind] > ans[-1]:
ans.append(a[Lind])
Lind += 1
ans2.append('L')
else:
flag5 = False
elif a[Lind] > a[Rind]:
if a[Rind] > ans[-1]:
ans.append(a[Rind])
Rind -= 1
ans2.append('R')
else:
flag6 = False
else:
flag = False
if not flag or not flag5 or not flag6:
lmax = 0
rmax = 0
for i in range(Lind, Rind):
if a[i+1] > a[i]:
lmax += 1
else:
break
for i in reversed(range(Lind+1, Rind+1)):
if a[i-1] > a[i]:
rmax += 1
else:
break
if lmax > rmax:
for i in range(Lind, Lind+lmax+1):
ans.append(a[i])
ans2.append('L')
else:
for i in reversed(range(Rind-rmax, Rind+1)):
ans.append(a[i])
ans2.append('R')
print(len(ans)-1)
print(*ans2,end='',sep='')
``` | instruction | 0 | 92,692 | 12 | 185,384 |
No | output | 1 | 92,692 | 12 | 185,385 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation of length n. Recall that the permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2, 3, 1, 5, 4] is a permutation, but [1, 2, 2] is not a permutation (2 appears twice in the array) and [1, 3, 4] is also not a permutation (n=3 but there is 4 in the array).
You can perform at most n-1 operations with the given permutation (it is possible that you don't perform any operations at all). The i-th operation allows you to swap elements of the given permutation on positions i and i+1. Each operation can be performed at most once. The operations can be performed in arbitrary order.
Your task is to find the lexicographically minimum possible permutation obtained by performing some of the given operations in some order.
You can see the definition of the lexicographical order in the notes section.
You have to answer q independent test cases.
For example, let's consider the permutation [5, 4, 1, 3, 2]. The minimum possible permutation we can obtain is [1, 5, 2, 4, 3] and we can do it in the following way:
1. perform the second operation (swap the second and the third elements) and obtain the permutation [5, 1, 4, 3, 2];
2. perform the fourth operation (swap the fourth and the fifth elements) and obtain the permutation [5, 1, 4, 2, 3];
3. perform the third operation (swap the third and the fourth elements) and obtain the permutation [5, 1, 2, 4, 3].
4. perform the first operation (swap the first and the second elements) and obtain the permutation [1, 5, 2, 4, 3];
Another example is [1, 2, 4, 3]. The minimum possible permutation we can obtain is [1, 2, 3, 4] by performing the third operation (swap the third and the fourth elements).
Input
The first line of the input contains one integer q (1 ≤ q ≤ 100) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of elements in the permutation.
The second line of the test case contains n distinct integers from 1 to n — the given permutation.
Output
For each test case, print the answer on it — the lexicograhically minimum possible permutation obtained by performing some of the given operations in some order.
Example
Input
4
5
5 4 1 3 2
4
1 2 4 3
1
1
4
4 3 2 1
Output
1 5 2 4 3
1 2 3 4
1
1 4 3 2
Note
Recall that the permutation p of length n is lexicographically less than the permutation q of length n if there is such index i ≤ n that for all j from 1 to i - 1 the condition p_j = q_j is satisfied, and p_i < q_i. For example:
* p = [1, 3, 5, 2, 4] is less than q = [1, 3, 5, 4, 2] (such i=4 exists, that p_i < q_i and for each j < i holds p_j = q_j),
* p = [1, 2] is less than q = [2, 1] (such i=1 exists, that p_i < q_i and for each j < i holds p_j = q_j). | instruction | 0 | 92,710 | 12 | 185,420 |
Tags: greedy
Correct Solution:
```
for tc in [0]*int(input()):
n = int(input())
a = list(map(int, input().split()))
i = 0
j = 0
while i < n - 1:
m = min(a[i:])
i = a.index(m)
a = a[:j] + [m] + a[j:i] + a[i + 1:]
if i == j:
i += 1
j = i
print(*a)
``` | output | 1 | 92,710 | 12 | 185,421 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation of length n. Recall that the permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2, 3, 1, 5, 4] is a permutation, but [1, 2, 2] is not a permutation (2 appears twice in the array) and [1, 3, 4] is also not a permutation (n=3 but there is 4 in the array).
You can perform at most n-1 operations with the given permutation (it is possible that you don't perform any operations at all). The i-th operation allows you to swap elements of the given permutation on positions i and i+1. Each operation can be performed at most once. The operations can be performed in arbitrary order.
Your task is to find the lexicographically minimum possible permutation obtained by performing some of the given operations in some order.
You can see the definition of the lexicographical order in the notes section.
You have to answer q independent test cases.
For example, let's consider the permutation [5, 4, 1, 3, 2]. The minimum possible permutation we can obtain is [1, 5, 2, 4, 3] and we can do it in the following way:
1. perform the second operation (swap the second and the third elements) and obtain the permutation [5, 1, 4, 3, 2];
2. perform the fourth operation (swap the fourth and the fifth elements) and obtain the permutation [5, 1, 4, 2, 3];
3. perform the third operation (swap the third and the fourth elements) and obtain the permutation [5, 1, 2, 4, 3].
4. perform the first operation (swap the first and the second elements) and obtain the permutation [1, 5, 2, 4, 3];
Another example is [1, 2, 4, 3]. The minimum possible permutation we can obtain is [1, 2, 3, 4] by performing the third operation (swap the third and the fourth elements).
Input
The first line of the input contains one integer q (1 ≤ q ≤ 100) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of elements in the permutation.
The second line of the test case contains n distinct integers from 1 to n — the given permutation.
Output
For each test case, print the answer on it — the lexicograhically minimum possible permutation obtained by performing some of the given operations in some order.
Example
Input
4
5
5 4 1 3 2
4
1 2 4 3
1
1
4
4 3 2 1
Output
1 5 2 4 3
1 2 3 4
1
1 4 3 2
Note
Recall that the permutation p of length n is lexicographically less than the permutation q of length n if there is such index i ≤ n that for all j from 1 to i - 1 the condition p_j = q_j is satisfied, and p_i < q_i. For example:
* p = [1, 3, 5, 2, 4] is less than q = [1, 3, 5, 4, 2] (such i=4 exists, that p_i < q_i and for each j < i holds p_j = q_j),
* p = [1, 2] is less than q = [2, 1] (such i=1 exists, that p_i < q_i and for each j < i holds p_j = q_j). | instruction | 0 | 92,711 | 12 | 185,422 |
Tags: greedy
Correct Solution:
```
qq = int(input())
for q in range(qq):
n = int(input())
dat = list(map(int, input().split()))
already = [False] * 110
for j in range(0, n - 1):
#print("j:{0}".format(j))
ma = 99999
maindex = 99999
for i in range(0, n - 1):
if already[i]:
continue
if dat[i] < dat[i+1]:
continue
if dat[i + 1] < ma:
if dat[i+1] == n:
continue
maindex = i
ma = dat[i + 1]
if maindex == 99999:
break
else:
#print("maindex:{0}, ma:{1}".format(maindex, ma))
already[maindex] = True
dat[maindex], dat[maindex+1] = dat[maindex + 1], dat[maindex]
#print(dat)
dat = list(map(lambda x: str(x), dat))
print(" ".join(dat))
``` | output | 1 | 92,711 | 12 | 185,423 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation of length n. Recall that the permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2, 3, 1, 5, 4] is a permutation, but [1, 2, 2] is not a permutation (2 appears twice in the array) and [1, 3, 4] is also not a permutation (n=3 but there is 4 in the array).
You can perform at most n-1 operations with the given permutation (it is possible that you don't perform any operations at all). The i-th operation allows you to swap elements of the given permutation on positions i and i+1. Each operation can be performed at most once. The operations can be performed in arbitrary order.
Your task is to find the lexicographically minimum possible permutation obtained by performing some of the given operations in some order.
You can see the definition of the lexicographical order in the notes section.
You have to answer q independent test cases.
For example, let's consider the permutation [5, 4, 1, 3, 2]. The minimum possible permutation we can obtain is [1, 5, 2, 4, 3] and we can do it in the following way:
1. perform the second operation (swap the second and the third elements) and obtain the permutation [5, 1, 4, 3, 2];
2. perform the fourth operation (swap the fourth and the fifth elements) and obtain the permutation [5, 1, 4, 2, 3];
3. perform the third operation (swap the third and the fourth elements) and obtain the permutation [5, 1, 2, 4, 3].
4. perform the first operation (swap the first and the second elements) and obtain the permutation [1, 5, 2, 4, 3];
Another example is [1, 2, 4, 3]. The minimum possible permutation we can obtain is [1, 2, 3, 4] by performing the third operation (swap the third and the fourth elements).
Input
The first line of the input contains one integer q (1 ≤ q ≤ 100) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of elements in the permutation.
The second line of the test case contains n distinct integers from 1 to n — the given permutation.
Output
For each test case, print the answer on it — the lexicograhically minimum possible permutation obtained by performing some of the given operations in some order.
Example
Input
4
5
5 4 1 3 2
4
1 2 4 3
1
1
4
4 3 2 1
Output
1 5 2 4 3
1 2 3 4
1
1 4 3 2
Note
Recall that the permutation p of length n is lexicographically less than the permutation q of length n if there is such index i ≤ n that for all j from 1 to i - 1 the condition p_j = q_j is satisfied, and p_i < q_i. For example:
* p = [1, 3, 5, 2, 4] is less than q = [1, 3, 5, 4, 2] (such i=4 exists, that p_i < q_i and for each j < i holds p_j = q_j),
* p = [1, 2] is less than q = [2, 1] (such i=1 exists, that p_i < q_i and for each j < i holds p_j = q_j). | instruction | 0 | 92,712 | 12 | 185,424 |
Tags: greedy
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
s = list(map(int, input().split()))
perform = [0 for i in range(n)]
rec = [0 for i in range(n)]
for i in range(n):
rec[s[i] - 1] = i
# print(rec)
op = n - 1
# lim_for_n = 0
for i in range(n):
if op == 0:
break
p = rec[i] - 1
temp = op
tempP = p
lim = p + 1
while tempP >= 0 and temp > 0:
if perform[tempP] == 1:
break
if s[tempP] > i + 1 and perform[p] == 0:
lim = tempP
tempP -= 1
temp -= 1
# print('for ', i + 1, lim, 'p', p)
# print('p', p)
while p >= lim and op > 0:
rec[i] = p
s[p], s[p + 1] = s[p + 1], s[p]
perform[p] = 1
# print(p + 1)
# print("s, ", s[p + 1])
rec[s[p + 1] - 1] = p + 1
p -= 1
op -= 1
# print('inter', s, i + 1)
for i in s:
print(i, end=' ')
print('')
``` | output | 1 | 92,712 | 12 | 185,425 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation of length n. Recall that the permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2, 3, 1, 5, 4] is a permutation, but [1, 2, 2] is not a permutation (2 appears twice in the array) and [1, 3, 4] is also not a permutation (n=3 but there is 4 in the array).
You can perform at most n-1 operations with the given permutation (it is possible that you don't perform any operations at all). The i-th operation allows you to swap elements of the given permutation on positions i and i+1. Each operation can be performed at most once. The operations can be performed in arbitrary order.
Your task is to find the lexicographically minimum possible permutation obtained by performing some of the given operations in some order.
You can see the definition of the lexicographical order in the notes section.
You have to answer q independent test cases.
For example, let's consider the permutation [5, 4, 1, 3, 2]. The minimum possible permutation we can obtain is [1, 5, 2, 4, 3] and we can do it in the following way:
1. perform the second operation (swap the second and the third elements) and obtain the permutation [5, 1, 4, 3, 2];
2. perform the fourth operation (swap the fourth and the fifth elements) and obtain the permutation [5, 1, 4, 2, 3];
3. perform the third operation (swap the third and the fourth elements) and obtain the permutation [5, 1, 2, 4, 3].
4. perform the first operation (swap the first and the second elements) and obtain the permutation [1, 5, 2, 4, 3];
Another example is [1, 2, 4, 3]. The minimum possible permutation we can obtain is [1, 2, 3, 4] by performing the third operation (swap the third and the fourth elements).
Input
The first line of the input contains one integer q (1 ≤ q ≤ 100) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of elements in the permutation.
The second line of the test case contains n distinct integers from 1 to n — the given permutation.
Output
For each test case, print the answer on it — the lexicograhically minimum possible permutation obtained by performing some of the given operations in some order.
Example
Input
4
5
5 4 1 3 2
4
1 2 4 3
1
1
4
4 3 2 1
Output
1 5 2 4 3
1 2 3 4
1
1 4 3 2
Note
Recall that the permutation p of length n is lexicographically less than the permutation q of length n if there is such index i ≤ n that for all j from 1 to i - 1 the condition p_j = q_j is satisfied, and p_i < q_i. For example:
* p = [1, 3, 5, 2, 4] is less than q = [1, 3, 5, 4, 2] (such i=4 exists, that p_i < q_i and for each j < i holds p_j = q_j),
* p = [1, 2] is less than q = [2, 1] (such i=1 exists, that p_i < q_i and for each j < i holds p_j = q_j). | instruction | 0 | 92,713 | 12 | 185,426 |
Tags: greedy
Correct Solution:
```
q = int(input())
for i in range(q):
n = int(input())
A = list(map(int,input().split()))
B = []
k = 1
for i in range(n):
j = A.index(k)
if j != -1 and j not in B:
if len(B) == 0:
g = 0
else:
g = max(B) + 1
A.pop(j)
A.insert(g,k)
for f in range(g,j):
B.append(f)
if j == g:
B.append(j)
k += 1
print(*A)
``` | output | 1 | 92,713 | 12 | 185,427 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation of length n. Recall that the permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2, 3, 1, 5, 4] is a permutation, but [1, 2, 2] is not a permutation (2 appears twice in the array) and [1, 3, 4] is also not a permutation (n=3 but there is 4 in the array).
You can perform at most n-1 operations with the given permutation (it is possible that you don't perform any operations at all). The i-th operation allows you to swap elements of the given permutation on positions i and i+1. Each operation can be performed at most once. The operations can be performed in arbitrary order.
Your task is to find the lexicographically minimum possible permutation obtained by performing some of the given operations in some order.
You can see the definition of the lexicographical order in the notes section.
You have to answer q independent test cases.
For example, let's consider the permutation [5, 4, 1, 3, 2]. The minimum possible permutation we can obtain is [1, 5, 2, 4, 3] and we can do it in the following way:
1. perform the second operation (swap the second and the third elements) and obtain the permutation [5, 1, 4, 3, 2];
2. perform the fourth operation (swap the fourth and the fifth elements) and obtain the permutation [5, 1, 4, 2, 3];
3. perform the third operation (swap the third and the fourth elements) and obtain the permutation [5, 1, 2, 4, 3].
4. perform the first operation (swap the first and the second elements) and obtain the permutation [1, 5, 2, 4, 3];
Another example is [1, 2, 4, 3]. The minimum possible permutation we can obtain is [1, 2, 3, 4] by performing the third operation (swap the third and the fourth elements).
Input
The first line of the input contains one integer q (1 ≤ q ≤ 100) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of elements in the permutation.
The second line of the test case contains n distinct integers from 1 to n — the given permutation.
Output
For each test case, print the answer on it — the lexicograhically minimum possible permutation obtained by performing some of the given operations in some order.
Example
Input
4
5
5 4 1 3 2
4
1 2 4 3
1
1
4
4 3 2 1
Output
1 5 2 4 3
1 2 3 4
1
1 4 3 2
Note
Recall that the permutation p of length n is lexicographically less than the permutation q of length n if there is such index i ≤ n that for all j from 1 to i - 1 the condition p_j = q_j is satisfied, and p_i < q_i. For example:
* p = [1, 3, 5, 2, 4] is less than q = [1, 3, 5, 4, 2] (such i=4 exists, that p_i < q_i and for each j < i holds p_j = q_j),
* p = [1, 2] is less than q = [2, 1] (such i=1 exists, that p_i < q_i and for each j < i holds p_j = q_j). | instruction | 0 | 92,714 | 12 | 185,428 |
Tags: greedy
Correct Solution:
```
from sys import stdin, stdout
from collections import defaultdict
# 4
# 3 4 1 2
# 3 1 2 4
# 1 3 2 4
def swap(A, d, x, y):
t = A[x]
A[x] = A[y]
A[y] = t
# print(d, A[x], A[y], x, y)
d[A[x]] = x
d[A[y]] = y
# print(d, A[x], A[y], x, y)
return A,d
def solve():
n = int(input())
A = [int(i) for i in stdin.readline().split()]
d = defaultdict()
st = set()
for i in range(len(A)):
d[A[i]] = i
for i in range(len(A) - 1):
while True:
if d[i+1] == 0: break
if A[d[i+1] - 1] > A[d[i+1]] and d[i+1] - 1 not in st:
st.add(d[i+1] - 1)
A,d = swap(A, d, d[i+1] - 1, d[i+1])
else: break
for i in A:
print(str(i) + " ", end="")
print()
return 0
t = int(input())
for i in range(t):
solve()
``` | output | 1 | 92,714 | 12 | 185,429 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation of length n. Recall that the permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2, 3, 1, 5, 4] is a permutation, but [1, 2, 2] is not a permutation (2 appears twice in the array) and [1, 3, 4] is also not a permutation (n=3 but there is 4 in the array).
You can perform at most n-1 operations with the given permutation (it is possible that you don't perform any operations at all). The i-th operation allows you to swap elements of the given permutation on positions i and i+1. Each operation can be performed at most once. The operations can be performed in arbitrary order.
Your task is to find the lexicographically minimum possible permutation obtained by performing some of the given operations in some order.
You can see the definition of the lexicographical order in the notes section.
You have to answer q independent test cases.
For example, let's consider the permutation [5, 4, 1, 3, 2]. The minimum possible permutation we can obtain is [1, 5, 2, 4, 3] and we can do it in the following way:
1. perform the second operation (swap the second and the third elements) and obtain the permutation [5, 1, 4, 3, 2];
2. perform the fourth operation (swap the fourth and the fifth elements) and obtain the permutation [5, 1, 4, 2, 3];
3. perform the third operation (swap the third and the fourth elements) and obtain the permutation [5, 1, 2, 4, 3].
4. perform the first operation (swap the first and the second elements) and obtain the permutation [1, 5, 2, 4, 3];
Another example is [1, 2, 4, 3]. The minimum possible permutation we can obtain is [1, 2, 3, 4] by performing the third operation (swap the third and the fourth elements).
Input
The first line of the input contains one integer q (1 ≤ q ≤ 100) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of elements in the permutation.
The second line of the test case contains n distinct integers from 1 to n — the given permutation.
Output
For each test case, print the answer on it — the lexicograhically minimum possible permutation obtained by performing some of the given operations in some order.
Example
Input
4
5
5 4 1 3 2
4
1 2 4 3
1
1
4
4 3 2 1
Output
1 5 2 4 3
1 2 3 4
1
1 4 3 2
Note
Recall that the permutation p of length n is lexicographically less than the permutation q of length n if there is such index i ≤ n that for all j from 1 to i - 1 the condition p_j = q_j is satisfied, and p_i < q_i. For example:
* p = [1, 3, 5, 2, 4] is less than q = [1, 3, 5, 4, 2] (such i=4 exists, that p_i < q_i and for each j < i holds p_j = q_j),
* p = [1, 2] is less than q = [2, 1] (such i=1 exists, that p_i < q_i and for each j < i holds p_j = q_j). | instruction | 0 | 92,715 | 12 | 185,430 |
Tags: greedy
Correct Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
arr = list(map(int, input().split()))
visited = set()
for i in range(len(arr)):
if i in visited:
continue
best_idx = i
for j in range(i + 1, len(arr)):
if j in visited:
break
if arr[j] < arr[best_idx]:
best_idx = j
while best_idx != i:
visited.add(best_idx - 1)
arr[best_idx], arr[best_idx - 1] = arr[best_idx - 1], arr[best_idx]
best_idx -= 1
print(*arr)
``` | output | 1 | 92,715 | 12 | 185,431 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation of length n. Recall that the permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2, 3, 1, 5, 4] is a permutation, but [1, 2, 2] is not a permutation (2 appears twice in the array) and [1, 3, 4] is also not a permutation (n=3 but there is 4 in the array).
You can perform at most n-1 operations with the given permutation (it is possible that you don't perform any operations at all). The i-th operation allows you to swap elements of the given permutation on positions i and i+1. Each operation can be performed at most once. The operations can be performed in arbitrary order.
Your task is to find the lexicographically minimum possible permutation obtained by performing some of the given operations in some order.
You can see the definition of the lexicographical order in the notes section.
You have to answer q independent test cases.
For example, let's consider the permutation [5, 4, 1, 3, 2]. The minimum possible permutation we can obtain is [1, 5, 2, 4, 3] and we can do it in the following way:
1. perform the second operation (swap the second and the third elements) and obtain the permutation [5, 1, 4, 3, 2];
2. perform the fourth operation (swap the fourth and the fifth elements) and obtain the permutation [5, 1, 4, 2, 3];
3. perform the third operation (swap the third and the fourth elements) and obtain the permutation [5, 1, 2, 4, 3].
4. perform the first operation (swap the first and the second elements) and obtain the permutation [1, 5, 2, 4, 3];
Another example is [1, 2, 4, 3]. The minimum possible permutation we can obtain is [1, 2, 3, 4] by performing the third operation (swap the third and the fourth elements).
Input
The first line of the input contains one integer q (1 ≤ q ≤ 100) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of elements in the permutation.
The second line of the test case contains n distinct integers from 1 to n — the given permutation.
Output
For each test case, print the answer on it — the lexicograhically minimum possible permutation obtained by performing some of the given operations in some order.
Example
Input
4
5
5 4 1 3 2
4
1 2 4 3
1
1
4
4 3 2 1
Output
1 5 2 4 3
1 2 3 4
1
1 4 3 2
Note
Recall that the permutation p of length n is lexicographically less than the permutation q of length n if there is such index i ≤ n that for all j from 1 to i - 1 the condition p_j = q_j is satisfied, and p_i < q_i. For example:
* p = [1, 3, 5, 2, 4] is less than q = [1, 3, 5, 4, 2] (such i=4 exists, that p_i < q_i and for each j < i holds p_j = q_j),
* p = [1, 2] is less than q = [2, 1] (such i=1 exists, that p_i < q_i and for each j < i holds p_j = q_j). | instruction | 0 | 92,716 | 12 | 185,432 |
Tags: greedy
Correct Solution:
```
for i in range(int(input())):
n=int(input())
ar=list(map(int,input().split()))
if(n==1):
print(*ar)
elif(n==2):
ar.sort()
print(*ar)
else:
ans=[]
y=0
x=0
s=0
for j in range(1,n+1):
y=s
while(y<n):
if(ar[y]==j):
for k in range(y,x,-1):
if(ar[k-1]>ar[k]):
ar[k],ar[k-1]=ar[k-1],ar[k]
x=y
s=y
break
y+=1
print(*ar)
``` | output | 1 | 92,716 | 12 | 185,433 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation of length n. Recall that the permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2, 3, 1, 5, 4] is a permutation, but [1, 2, 2] is not a permutation (2 appears twice in the array) and [1, 3, 4] is also not a permutation (n=3 but there is 4 in the array).
You can perform at most n-1 operations with the given permutation (it is possible that you don't perform any operations at all). The i-th operation allows you to swap elements of the given permutation on positions i and i+1. Each operation can be performed at most once. The operations can be performed in arbitrary order.
Your task is to find the lexicographically minimum possible permutation obtained by performing some of the given operations in some order.
You can see the definition of the lexicographical order in the notes section.
You have to answer q independent test cases.
For example, let's consider the permutation [5, 4, 1, 3, 2]. The minimum possible permutation we can obtain is [1, 5, 2, 4, 3] and we can do it in the following way:
1. perform the second operation (swap the second and the third elements) and obtain the permutation [5, 1, 4, 3, 2];
2. perform the fourth operation (swap the fourth and the fifth elements) and obtain the permutation [5, 1, 4, 2, 3];
3. perform the third operation (swap the third and the fourth elements) and obtain the permutation [5, 1, 2, 4, 3].
4. perform the first operation (swap the first and the second elements) and obtain the permutation [1, 5, 2, 4, 3];
Another example is [1, 2, 4, 3]. The minimum possible permutation we can obtain is [1, 2, 3, 4] by performing the third operation (swap the third and the fourth elements).
Input
The first line of the input contains one integer q (1 ≤ q ≤ 100) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of elements in the permutation.
The second line of the test case contains n distinct integers from 1 to n — the given permutation.
Output
For each test case, print the answer on it — the lexicograhically minimum possible permutation obtained by performing some of the given operations in some order.
Example
Input
4
5
5 4 1 3 2
4
1 2 4 3
1
1
4
4 3 2 1
Output
1 5 2 4 3
1 2 3 4
1
1 4 3 2
Note
Recall that the permutation p of length n is lexicographically less than the permutation q of length n if there is such index i ≤ n that for all j from 1 to i - 1 the condition p_j = q_j is satisfied, and p_i < q_i. For example:
* p = [1, 3, 5, 2, 4] is less than q = [1, 3, 5, 4, 2] (such i=4 exists, that p_i < q_i and for each j < i holds p_j = q_j),
* p = [1, 2] is less than q = [2, 1] (such i=1 exists, that p_i < q_i and for each j < i holds p_j = q_j). | instruction | 0 | 92,717 | 12 | 185,434 |
Tags: greedy
Correct Solution:
```
def p_v(v):
for i in v:
print(i, end = " ")
return
def max_p(v, used):
ind_f = 0
ind_s = 1
mx_ind_s = -1
mx = 0
for i in range(len(v)- 1):
if v[ind_f] > v[ind_s] and used[ind_s] == 0:
if ind_s > mx:
mx = ind_s
mx_ind_s = ind_s
ind_f+=1
ind_s+=1
return mx_ind_s, used
m = int(input())
for i in range(m):
n = int(input())
v = a = list(map(int, input().split()))
used = [0 for i in range(n) ]
if len(v) == 1:
p_v(v)
else:
for j in range(n-1):
mx_ind, used = max_p(v, used)
if mx_ind > -1 and used[mx_ind] == 0:
used[mx_ind] = 1
t = v[mx_ind]
v[mx_ind] = v[mx_ind-1]
v[mx_ind-1] = t
else:
break
p_v(v)
``` | output | 1 | 92,717 | 12 | 185,435 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation of length n. Recall that the permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2, 3, 1, 5, 4] is a permutation, but [1, 2, 2] is not a permutation (2 appears twice in the array) and [1, 3, 4] is also not a permutation (n=3 but there is 4 in the array).
You can perform at most n-1 operations with the given permutation (it is possible that you don't perform any operations at all). The i-th operation allows you to swap elements of the given permutation on positions i and i+1. Each operation can be performed at most once. The operations can be performed in arbitrary order.
Your task is to find the lexicographically minimum possible permutation obtained by performing some of the given operations in some order.
You can see the definition of the lexicographical order in the notes section.
You have to answer q independent test cases.
For example, let's consider the permutation [5, 4, 1, 3, 2]. The minimum possible permutation we can obtain is [1, 5, 2, 4, 3] and we can do it in the following way:
1. perform the second operation (swap the second and the third elements) and obtain the permutation [5, 1, 4, 3, 2];
2. perform the fourth operation (swap the fourth and the fifth elements) and obtain the permutation [5, 1, 4, 2, 3];
3. perform the third operation (swap the third and the fourth elements) and obtain the permutation [5, 1, 2, 4, 3].
4. perform the first operation (swap the first and the second elements) and obtain the permutation [1, 5, 2, 4, 3];
Another example is [1, 2, 4, 3]. The minimum possible permutation we can obtain is [1, 2, 3, 4] by performing the third operation (swap the third and the fourth elements).
Input
The first line of the input contains one integer q (1 ≤ q ≤ 100) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of elements in the permutation.
The second line of the test case contains n distinct integers from 1 to n — the given permutation.
Output
For each test case, print the answer on it — the lexicograhically minimum possible permutation obtained by performing some of the given operations in some order.
Example
Input
4
5
5 4 1 3 2
4
1 2 4 3
1
1
4
4 3 2 1
Output
1 5 2 4 3
1 2 3 4
1
1 4 3 2
Note
Recall that the permutation p of length n is lexicographically less than the permutation q of length n if there is such index i ≤ n that for all j from 1 to i - 1 the condition p_j = q_j is satisfied, and p_i < q_i. For example:
* p = [1, 3, 5, 2, 4] is less than q = [1, 3, 5, 4, 2] (such i=4 exists, that p_i < q_i and for each j < i holds p_j = q_j),
* p = [1, 2] is less than q = [2, 1] (such i=1 exists, that p_i < q_i and for each j < i holds p_j = q_j).
Submitted Solution:
```
import sys
input = sys.stdin.readline
q = int(input())
for _ in range(q):
w = int(input())
e = list(map(int, input().split()))
minpos = []
mn = w - 1
m = min(e)
nn = e.index(m)
while mn - nn > 0 and w > 0:
mn -= nn
if nn > 1:
minpos += [m] + e[:nn - 1]
e = [e[nn - 1]] + e[nn + 1:]
elif nn == 0:
minpos += [m]
e = e[nn + 1:]
w -= 1
else:
minpos += [m]
e = [e[nn - 1]] + e[nn + 1:]
w -= nn
if w > 0:
m = min(e)
nn = e.index(m)
if w > 0:
e = e[:nn - mn] + [e[nn]] + e[nn - mn:nn] + e[nn + 1:]
minpos += e
print(*minpos)
``` | instruction | 0 | 92,718 | 12 | 185,436 |
Yes | output | 1 | 92,718 | 12 | 185,437 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation of length n. Recall that the permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2, 3, 1, 5, 4] is a permutation, but [1, 2, 2] is not a permutation (2 appears twice in the array) and [1, 3, 4] is also not a permutation (n=3 but there is 4 in the array).
You can perform at most n-1 operations with the given permutation (it is possible that you don't perform any operations at all). The i-th operation allows you to swap elements of the given permutation on positions i and i+1. Each operation can be performed at most once. The operations can be performed in arbitrary order.
Your task is to find the lexicographically minimum possible permutation obtained by performing some of the given operations in some order.
You can see the definition of the lexicographical order in the notes section.
You have to answer q independent test cases.
For example, let's consider the permutation [5, 4, 1, 3, 2]. The minimum possible permutation we can obtain is [1, 5, 2, 4, 3] and we can do it in the following way:
1. perform the second operation (swap the second and the third elements) and obtain the permutation [5, 1, 4, 3, 2];
2. perform the fourth operation (swap the fourth and the fifth elements) and obtain the permutation [5, 1, 4, 2, 3];
3. perform the third operation (swap the third and the fourth elements) and obtain the permutation [5, 1, 2, 4, 3].
4. perform the first operation (swap the first and the second elements) and obtain the permutation [1, 5, 2, 4, 3];
Another example is [1, 2, 4, 3]. The minimum possible permutation we can obtain is [1, 2, 3, 4] by performing the third operation (swap the third and the fourth elements).
Input
The first line of the input contains one integer q (1 ≤ q ≤ 100) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of elements in the permutation.
The second line of the test case contains n distinct integers from 1 to n — the given permutation.
Output
For each test case, print the answer on it — the lexicograhically minimum possible permutation obtained by performing some of the given operations in some order.
Example
Input
4
5
5 4 1 3 2
4
1 2 4 3
1
1
4
4 3 2 1
Output
1 5 2 4 3
1 2 3 4
1
1 4 3 2
Note
Recall that the permutation p of length n is lexicographically less than the permutation q of length n if there is such index i ≤ n that for all j from 1 to i - 1 the condition p_j = q_j is satisfied, and p_i < q_i. For example:
* p = [1, 3, 5, 2, 4] is less than q = [1, 3, 5, 4, 2] (such i=4 exists, that p_i < q_i and for each j < i holds p_j = q_j),
* p = [1, 2] is less than q = [2, 1] (such i=1 exists, that p_i < q_i and for each j < i holds p_j = q_j).
Submitted Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
# import time,random,resource
# sys.setrecursionlimit(10**6)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod2 = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def IF(c, t, f): return t if c else f
def YES(c): return IF(c, "YES", "NO")
def Yes(c): return IF(c, "Yes", "No")
def main():
t = I()
rr = []
for _ in range(t):
n = I()
a = LI()
j = -1
for c in range(1,n+1):
nj = i = a.index(c)
while j < i and i >= c and a[i] < a[i-1]:
a[i],a[i-1] = a[i-1],a[i]
i -= 1
j = max(j, nj)
rr.append(JA(a, " "))
return JA(rr, "\n")
print(main())
``` | instruction | 0 | 92,719 | 12 | 185,438 |
Yes | output | 1 | 92,719 | 12 | 185,439 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation of length n. Recall that the permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2, 3, 1, 5, 4] is a permutation, but [1, 2, 2] is not a permutation (2 appears twice in the array) and [1, 3, 4] is also not a permutation (n=3 but there is 4 in the array).
You can perform at most n-1 operations with the given permutation (it is possible that you don't perform any operations at all). The i-th operation allows you to swap elements of the given permutation on positions i and i+1. Each operation can be performed at most once. The operations can be performed in arbitrary order.
Your task is to find the lexicographically minimum possible permutation obtained by performing some of the given operations in some order.
You can see the definition of the lexicographical order in the notes section.
You have to answer q independent test cases.
For example, let's consider the permutation [5, 4, 1, 3, 2]. The minimum possible permutation we can obtain is [1, 5, 2, 4, 3] and we can do it in the following way:
1. perform the second operation (swap the second and the third elements) and obtain the permutation [5, 1, 4, 3, 2];
2. perform the fourth operation (swap the fourth and the fifth elements) and obtain the permutation [5, 1, 4, 2, 3];
3. perform the third operation (swap the third and the fourth elements) and obtain the permutation [5, 1, 2, 4, 3].
4. perform the first operation (swap the first and the second elements) and obtain the permutation [1, 5, 2, 4, 3];
Another example is [1, 2, 4, 3]. The minimum possible permutation we can obtain is [1, 2, 3, 4] by performing the third operation (swap the third and the fourth elements).
Input
The first line of the input contains one integer q (1 ≤ q ≤ 100) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of elements in the permutation.
The second line of the test case contains n distinct integers from 1 to n — the given permutation.
Output
For each test case, print the answer on it — the lexicograhically minimum possible permutation obtained by performing some of the given operations in some order.
Example
Input
4
5
5 4 1 3 2
4
1 2 4 3
1
1
4
4 3 2 1
Output
1 5 2 4 3
1 2 3 4
1
1 4 3 2
Note
Recall that the permutation p of length n is lexicographically less than the permutation q of length n if there is such index i ≤ n that for all j from 1 to i - 1 the condition p_j = q_j is satisfied, and p_i < q_i. For example:
* p = [1, 3, 5, 2, 4] is less than q = [1, 3, 5, 4, 2] (such i=4 exists, that p_i < q_i and for each j < i holds p_j = q_j),
* p = [1, 2] is less than q = [2, 1] (such i=1 exists, that p_i < q_i and for each j < i holds p_j = q_j).
Submitted Solution:
```
q=int(input())
for j in range(q):
n=int(input())
ch=input()
l=ch.split()
for i in range(n):
l[i]=int(l[i])
if n==1:
print(l[0])
else:
s=set(range(n))
s.remove(0)
s.add(n)
if l[0]==1:
i=2
else:
i=1
h=l.index(1)
for k in range(h):
s.remove(k+1)
while h>0:
x=l[h]
l[h]=l[h-1]
l[h-1]=x
h-=1
i=2
while(s and i<n):
h=l.index(i)
if l[h]<l[h-1] and h in s:
x=l[h-1]
l[h-1]=l[h]
l[h]=x
s.remove(h)
else:
i+=1
for m in range(n):
print(l[m],end=' ')
print()
``` | instruction | 0 | 92,720 | 12 | 185,440 |
Yes | output | 1 | 92,720 | 12 | 185,441 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation of length n. Recall that the permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2, 3, 1, 5, 4] is a permutation, but [1, 2, 2] is not a permutation (2 appears twice in the array) and [1, 3, 4] is also not a permutation (n=3 but there is 4 in the array).
You can perform at most n-1 operations with the given permutation (it is possible that you don't perform any operations at all). The i-th operation allows you to swap elements of the given permutation on positions i and i+1. Each operation can be performed at most once. The operations can be performed in arbitrary order.
Your task is to find the lexicographically minimum possible permutation obtained by performing some of the given operations in some order.
You can see the definition of the lexicographical order in the notes section.
You have to answer q independent test cases.
For example, let's consider the permutation [5, 4, 1, 3, 2]. The minimum possible permutation we can obtain is [1, 5, 2, 4, 3] and we can do it in the following way:
1. perform the second operation (swap the second and the third elements) and obtain the permutation [5, 1, 4, 3, 2];
2. perform the fourth operation (swap the fourth and the fifth elements) and obtain the permutation [5, 1, 4, 2, 3];
3. perform the third operation (swap the third and the fourth elements) and obtain the permutation [5, 1, 2, 4, 3].
4. perform the first operation (swap the first and the second elements) and obtain the permutation [1, 5, 2, 4, 3];
Another example is [1, 2, 4, 3]. The minimum possible permutation we can obtain is [1, 2, 3, 4] by performing the third operation (swap the third and the fourth elements).
Input
The first line of the input contains one integer q (1 ≤ q ≤ 100) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of elements in the permutation.
The second line of the test case contains n distinct integers from 1 to n — the given permutation.
Output
For each test case, print the answer on it — the lexicograhically minimum possible permutation obtained by performing some of the given operations in some order.
Example
Input
4
5
5 4 1 3 2
4
1 2 4 3
1
1
4
4 3 2 1
Output
1 5 2 4 3
1 2 3 4
1
1 4 3 2
Note
Recall that the permutation p of length n is lexicographically less than the permutation q of length n if there is such index i ≤ n that for all j from 1 to i - 1 the condition p_j = q_j is satisfied, and p_i < q_i. For example:
* p = [1, 3, 5, 2, 4] is less than q = [1, 3, 5, 4, 2] (such i=4 exists, that p_i < q_i and for each j < i holds p_j = q_j),
* p = [1, 2] is less than q = [2, 1] (such i=1 exists, that p_i < q_i and for each j < i holds p_j = q_j).
Submitted Solution:
```
q = int(input())
for qi in range(q):
n = int(input())
a = list(map(int, input().split()))
used = [False] * n
for t in range(n):
for i in range(len(a) - 1, 0, -1):
if used[i]:
continue
if a[i] < a[i - 1]:
a[i], a[i - 1] = a[i - 1], a[i]
used[i] = True
print(' '.join(str(x) for x in a))
``` | instruction | 0 | 92,721 | 12 | 185,442 |
Yes | output | 1 | 92,721 | 12 | 185,443 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation of length n. Recall that the permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2, 3, 1, 5, 4] is a permutation, but [1, 2, 2] is not a permutation (2 appears twice in the array) and [1, 3, 4] is also not a permutation (n=3 but there is 4 in the array).
You can perform at most n-1 operations with the given permutation (it is possible that you don't perform any operations at all). The i-th operation allows you to swap elements of the given permutation on positions i and i+1. Each operation can be performed at most once. The operations can be performed in arbitrary order.
Your task is to find the lexicographically minimum possible permutation obtained by performing some of the given operations in some order.
You can see the definition of the lexicographical order in the notes section.
You have to answer q independent test cases.
For example, let's consider the permutation [5, 4, 1, 3, 2]. The minimum possible permutation we can obtain is [1, 5, 2, 4, 3] and we can do it in the following way:
1. perform the second operation (swap the second and the third elements) and obtain the permutation [5, 1, 4, 3, 2];
2. perform the fourth operation (swap the fourth and the fifth elements) and obtain the permutation [5, 1, 4, 2, 3];
3. perform the third operation (swap the third and the fourth elements) and obtain the permutation [5, 1, 2, 4, 3].
4. perform the first operation (swap the first and the second elements) and obtain the permutation [1, 5, 2, 4, 3];
Another example is [1, 2, 4, 3]. The minimum possible permutation we can obtain is [1, 2, 3, 4] by performing the third operation (swap the third and the fourth elements).
Input
The first line of the input contains one integer q (1 ≤ q ≤ 100) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of elements in the permutation.
The second line of the test case contains n distinct integers from 1 to n — the given permutation.
Output
For each test case, print the answer on it — the lexicograhically minimum possible permutation obtained by performing some of the given operations in some order.
Example
Input
4
5
5 4 1 3 2
4
1 2 4 3
1
1
4
4 3 2 1
Output
1 5 2 4 3
1 2 3 4
1
1 4 3 2
Note
Recall that the permutation p of length n is lexicographically less than the permutation q of length n if there is such index i ≤ n that for all j from 1 to i - 1 the condition p_j = q_j is satisfied, and p_i < q_i. For example:
* p = [1, 3, 5, 2, 4] is less than q = [1, 3, 5, 4, 2] (such i=4 exists, that p_i < q_i and for each j < i holds p_j = q_j),
* p = [1, 2] is less than q = [2, 1] (such i=1 exists, that p_i < q_i and for each j < i holds p_j = q_j).
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
l = list(map(int,input().split()))
c = 1
i = 0
l2 = [i for i in range(1,n+1)]
w = l.index(c)
while i!=n-1:
if c == l.index(c) + 1:
if l == l2:
break
c+=1
w = l.index(c)
else:
if l == l2:
break
else:
dck = l[w]
l[w] = l[w-1]
l[w-1] = dck
w-=1
i+=1
print(l)
``` | instruction | 0 | 92,722 | 12 | 185,444 |
No | output | 1 | 92,722 | 12 | 185,445 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation of length n. Recall that the permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2, 3, 1, 5, 4] is a permutation, but [1, 2, 2] is not a permutation (2 appears twice in the array) and [1, 3, 4] is also not a permutation (n=3 but there is 4 in the array).
You can perform at most n-1 operations with the given permutation (it is possible that you don't perform any operations at all). The i-th operation allows you to swap elements of the given permutation on positions i and i+1. Each operation can be performed at most once. The operations can be performed in arbitrary order.
Your task is to find the lexicographically minimum possible permutation obtained by performing some of the given operations in some order.
You can see the definition of the lexicographical order in the notes section.
You have to answer q independent test cases.
For example, let's consider the permutation [5, 4, 1, 3, 2]. The minimum possible permutation we can obtain is [1, 5, 2, 4, 3] and we can do it in the following way:
1. perform the second operation (swap the second and the third elements) and obtain the permutation [5, 1, 4, 3, 2];
2. perform the fourth operation (swap the fourth and the fifth elements) and obtain the permutation [5, 1, 4, 2, 3];
3. perform the third operation (swap the third and the fourth elements) and obtain the permutation [5, 1, 2, 4, 3].
4. perform the first operation (swap the first and the second elements) and obtain the permutation [1, 5, 2, 4, 3];
Another example is [1, 2, 4, 3]. The minimum possible permutation we can obtain is [1, 2, 3, 4] by performing the third operation (swap the third and the fourth elements).
Input
The first line of the input contains one integer q (1 ≤ q ≤ 100) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of elements in the permutation.
The second line of the test case contains n distinct integers from 1 to n — the given permutation.
Output
For each test case, print the answer on it — the lexicograhically minimum possible permutation obtained by performing some of the given operations in some order.
Example
Input
4
5
5 4 1 3 2
4
1 2 4 3
1
1
4
4 3 2 1
Output
1 5 2 4 3
1 2 3 4
1
1 4 3 2
Note
Recall that the permutation p of length n is lexicographically less than the permutation q of length n if there is such index i ≤ n that for all j from 1 to i - 1 the condition p_j = q_j is satisfied, and p_i < q_i. For example:
* p = [1, 3, 5, 2, 4] is less than q = [1, 3, 5, 4, 2] (such i=4 exists, that p_i < q_i and for each j < i holds p_j = q_j),
* p = [1, 2] is less than q = [2, 1] (such i=1 exists, that p_i < q_i and for each j < i holds p_j = q_j).
Submitted Solution:
```
amount = int(input())
for i in range(amount):
n = int(input())
array = [int(s) for s in input().split()]
for j in range(len(array) - 1, 0, -1):
if array[j] < array[j - 1]:
array[j], array[j - 1] = array[j - 1], array[j]
print(" ".join([str(s) for s in array]))
``` | instruction | 0 | 92,723 | 12 | 185,446 |
No | output | 1 | 92,723 | 12 | 185,447 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation of length n. Recall that the permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2, 3, 1, 5, 4] is a permutation, but [1, 2, 2] is not a permutation (2 appears twice in the array) and [1, 3, 4] is also not a permutation (n=3 but there is 4 in the array).
You can perform at most n-1 operations with the given permutation (it is possible that you don't perform any operations at all). The i-th operation allows you to swap elements of the given permutation on positions i and i+1. Each operation can be performed at most once. The operations can be performed in arbitrary order.
Your task is to find the lexicographically minimum possible permutation obtained by performing some of the given operations in some order.
You can see the definition of the lexicographical order in the notes section.
You have to answer q independent test cases.
For example, let's consider the permutation [5, 4, 1, 3, 2]. The minimum possible permutation we can obtain is [1, 5, 2, 4, 3] and we can do it in the following way:
1. perform the second operation (swap the second and the third elements) and obtain the permutation [5, 1, 4, 3, 2];
2. perform the fourth operation (swap the fourth and the fifth elements) and obtain the permutation [5, 1, 4, 2, 3];
3. perform the third operation (swap the third and the fourth elements) and obtain the permutation [5, 1, 2, 4, 3].
4. perform the first operation (swap the first and the second elements) and obtain the permutation [1, 5, 2, 4, 3];
Another example is [1, 2, 4, 3]. The minimum possible permutation we can obtain is [1, 2, 3, 4] by performing the third operation (swap the third and the fourth elements).
Input
The first line of the input contains one integer q (1 ≤ q ≤ 100) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of elements in the permutation.
The second line of the test case contains n distinct integers from 1 to n — the given permutation.
Output
For each test case, print the answer on it — the lexicograhically minimum possible permutation obtained by performing some of the given operations in some order.
Example
Input
4
5
5 4 1 3 2
4
1 2 4 3
1
1
4
4 3 2 1
Output
1 5 2 4 3
1 2 3 4
1
1 4 3 2
Note
Recall that the permutation p of length n is lexicographically less than the permutation q of length n if there is such index i ≤ n that for all j from 1 to i - 1 the condition p_j = q_j is satisfied, and p_i < q_i. For example:
* p = [1, 3, 5, 2, 4] is less than q = [1, 3, 5, 4, 2] (such i=4 exists, that p_i < q_i and for each j < i holds p_j = q_j),
* p = [1, 2] is less than q = [2, 1] (such i=1 exists, that p_i < q_i and for each j < i holds p_j = q_j).
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
seq = [int(x) for x in input().split()]
val = 1
op = [False]*(len(seq)-1)
op_perf = 0
for val in range(1, n+1):
swap = seq.index(val)
for i in range(swap-1,val-2,-1):
if not op[i]:
op[i] = True
swap = i
else:
break
seq.remove(val)
seq.insert(swap, val)
if all(op):
break
print(' '.join(map(str,seq)))
``` | instruction | 0 | 92,724 | 12 | 185,448 |
No | output | 1 | 92,724 | 12 | 185,449 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation of length n. Recall that the permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2, 3, 1, 5, 4] is a permutation, but [1, 2, 2] is not a permutation (2 appears twice in the array) and [1, 3, 4] is also not a permutation (n=3 but there is 4 in the array).
You can perform at most n-1 operations with the given permutation (it is possible that you don't perform any operations at all). The i-th operation allows you to swap elements of the given permutation on positions i and i+1. Each operation can be performed at most once. The operations can be performed in arbitrary order.
Your task is to find the lexicographically minimum possible permutation obtained by performing some of the given operations in some order.
You can see the definition of the lexicographical order in the notes section.
You have to answer q independent test cases.
For example, let's consider the permutation [5, 4, 1, 3, 2]. The minimum possible permutation we can obtain is [1, 5, 2, 4, 3] and we can do it in the following way:
1. perform the second operation (swap the second and the third elements) and obtain the permutation [5, 1, 4, 3, 2];
2. perform the fourth operation (swap the fourth and the fifth elements) and obtain the permutation [5, 1, 4, 2, 3];
3. perform the third operation (swap the third and the fourth elements) and obtain the permutation [5, 1, 2, 4, 3].
4. perform the first operation (swap the first and the second elements) and obtain the permutation [1, 5, 2, 4, 3];
Another example is [1, 2, 4, 3]. The minimum possible permutation we can obtain is [1, 2, 3, 4] by performing the third operation (swap the third and the fourth elements).
Input
The first line of the input contains one integer q (1 ≤ q ≤ 100) — the number of test cases. Then q test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of elements in the permutation.
The second line of the test case contains n distinct integers from 1 to n — the given permutation.
Output
For each test case, print the answer on it — the lexicograhically minimum possible permutation obtained by performing some of the given operations in some order.
Example
Input
4
5
5 4 1 3 2
4
1 2 4 3
1
1
4
4 3 2 1
Output
1 5 2 4 3
1 2 3 4
1
1 4 3 2
Note
Recall that the permutation p of length n is lexicographically less than the permutation q of length n if there is such index i ≤ n that for all j from 1 to i - 1 the condition p_j = q_j is satisfied, and p_i < q_i. For example:
* p = [1, 3, 5, 2, 4] is less than q = [1, 3, 5, 4, 2] (such i=4 exists, that p_i < q_i and for each j < i holds p_j = q_j),
* p = [1, 2] is less than q = [2, 1] (such i=1 exists, that p_i < q_i and for each j < i holds p_j = q_j).
Submitted Solution:
```
for __ in range(int(input())):
n = int(input())
ar = list(map(int, input().split()))
x = 1
i = ar.index(x)
num = 0
while x < n and i < n:
if x != 1:
while n > i >= ar.index(x):
i += 1
x += 1
if i < n:
i = ar.index(x)
for j in range(i, num, -1):
if ar[j] < ar[j - 1]:
ar[j], ar[j - 1] = ar[j - 1], ar[j]
num = i
x += 1
print(*ar)
``` | instruction | 0 | 92,725 | 12 | 185,450 |
No | output | 1 | 92,725 | 12 | 185,451 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.