message stringlengths 2 433k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation a consisting of n numbers 1, 2, ..., n (a permutation is an array in which each element from 1 to n occurs exactly once).
You can perform the following operation: choose some subarray (contiguous subsegment) of a and rearrange the elements in it in any way you want. But this operation cannot be applied to the whole array.
For example, if a = [2, 1, 4, 5, 3] and we want to apply the operation to the subarray a[2, 4] (the subarray containing all elements from the 2-nd to the 4-th), then after the operation, the array can become a = [2, 5, 1, 4, 3] or, for example, a = [2, 1, 5, 4, 3].
Your task is to calculate the minimum number of operations described above to sort the permutation a in ascending order.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of test cases.
The first line of the test case contains a single integer n (3 ≤ n ≤ 50) — 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 a.
Output
For each test case, output a single integer — the minimum number of operations described above to sort the array a in ascending order.
Example
Input
3
4
1 3 2 4
3
1 2 3
5
2 1 4 5 3
Output
1
0
2
Note
In the explanations, a[i, j] defines the subarray of a that starts from the i-th element and ends with the j-th element.
In the first test case of the example, you can select the subarray a[2, 3] and swap the elements in it.
In the second test case of the example, the permutation is already sorted, so you don't need to apply any operations.
In the third test case of the example, you can select the subarray a[3, 5] and reorder the elements in it so a becomes [2, 1, 3, 4, 5], and then select the subarray a[1, 2] and swap the elements in it, so a becomes [1, 2, 3, 4, 5]. | instruction | 0 | 3,620 | 12 | 7,240 |
Tags: constructive algorithms, greedy
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
s=sorted(l)
if s==l:
print(0)
else:
if l[0]==n and l[-1]==1:
print(3)
elif l[0]==1 or l[-1]==n:
print(1)
else:
print(2)
``` | output | 1 | 3,620 | 12 | 7,241 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation a consisting of n numbers 1, 2, ..., n (a permutation is an array in which each element from 1 to n occurs exactly once).
You can perform the following operation: choose some subarray (contiguous subsegment) of a and rearrange the elements in it in any way you want. But this operation cannot be applied to the whole array.
For example, if a = [2, 1, 4, 5, 3] and we want to apply the operation to the subarray a[2, 4] (the subarray containing all elements from the 2-nd to the 4-th), then after the operation, the array can become a = [2, 5, 1, 4, 3] or, for example, a = [2, 1, 5, 4, 3].
Your task is to calculate the minimum number of operations described above to sort the permutation a in ascending order.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of test cases.
The first line of the test case contains a single integer n (3 ≤ n ≤ 50) — 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 a.
Output
For each test case, output a single integer — the minimum number of operations described above to sort the array a in ascending order.
Example
Input
3
4
1 3 2 4
3
1 2 3
5
2 1 4 5 3
Output
1
0
2
Note
In the explanations, a[i, j] defines the subarray of a that starts from the i-th element and ends with the j-th element.
In the first test case of the example, you can select the subarray a[2, 3] and swap the elements in it.
In the second test case of the example, the permutation is already sorted, so you don't need to apply any operations.
In the third test case of the example, you can select the subarray a[3, 5] and reorder the elements in it so a becomes [2, 1, 3, 4, 5], and then select the subarray a[1, 2] and swap the elements in it, so a becomes [1, 2, 3, 4, 5]. | instruction | 0 | 3,621 | 12 | 7,242 |
Tags: constructive algorithms, greedy
Correct Solution:
```
'''
___ ___ ___ ___ ___ ___
/\__\ /\ \ _____ /\ \ /\ \ /\ \ /\__\
/:/ _/_ \:\ \ /::\ \ \:\ \ ___ /::\ \ |::\ \ ___ /:/ _/_
/:/ /\ \ \:\ \ /:/\:\ \ \:\ \ /\__\ /:/\:\__\ |:|:\ \ /\__\ /:/ /\ \
/:/ /::\ \ ___ \:\ \ /:/ \:\__\ ___ /::\ \ /:/__/ /:/ /:/ / __|:|\:\ \ /:/ / /:/ /::\ \
/:/_/:/\:\__\ /\ \ \:\__\ /:/__/ \:|__| /\ /:/\:\__\ /::\ \ /:/_/:/__/___ /::::|_\:\__\ /:/__/ /:/_/:/\:\__\
\:\/:/ /:/ / \:\ \ /:/ / \:\ \ /:/ / \:\/:/ \/__/ \/\:\ \__ \:\/:::::/ / \:\~~\ \/__/ /::\ \ \:\/:/ /:/ /
\::/ /:/ / \:\ /:/ / \:\ /:/ / \::/__/ ~~\:\/\__\ \::/~~/~~~~ \:\ \ /:/\:\ \ \::/ /:/ /
\/_/:/ / \:\/:/ / \:\/:/ / \:\ \ \::/ / \:\~~\ \:\ \ \/__\:\ \ \/_/:/ /
/:/ / \::/ / \::/ / \:\__\ /:/ / \:\__\ \:\__\ \:\__\ /:/ /
\/__/ \/__/ \/__/ \/__/ \/__/ \/__/ \/__/ \/__/ \/__/
'''
"""
░░██▄░░░░░░░░░░░▄██
░▄▀░█▄░░░░░░░░▄█░░█░
░█░▄░█▄░░░░░░▄█░▄░█░
░█░██████████████▄█░
░█████▀▀████▀▀█████░
▄█▀█▀░░░████░░░▀▀███
██░░▀████▀▀████▀░░██
██░░░░█▀░░░░▀█░░░░██
███▄░░░░░░░░░░░░▄███
░▀███▄░░████░░▄███▀░
░░░▀██▄░▀██▀░▄██▀░░░
░░░░░░▀██████▀░░░░░░
░░░░░░░░░░░░░░░░░░░░
"""
import sys
import math
import collections
import operator as op
from collections import deque
from math import gcd, inf, sqrt, pi, cos, sin, ceil, log2, floor, log
from bisect import bisect_right, bisect_left, bisect
from itertools import permutations
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
from functools import reduce
from sys import stdin, stdout, setrecursionlimit
setrecursionlimit(2**20)
def ncr(n, r):
r = min(r, n - r)
numer = reduce(op.mul, range(n, n - r, -1), 1)
denom = reduce(op.mul, range(1, r + 1), 1)
return numer // denom # or / in Python 2
def prime_factors(n):
i = 2
factors = []
while i * i <= n:
if n % i:
i += 1
else:
n //= i
factors.append(i)
if n > 1:
factors.append(n)
return (list(factors))
def isPowerOfTwo(x):
return (x and (not(x & (x - 1))))
def find_gcd(x, y):
while(y):
x, y = y, x % y
return x
MOD = 1000000007 # 10^9 + 7
PMOD = 998244353
LOGN = 30
alp = 'abcdefghijklmnopqrstuvwxyz'
N = int(1e5)
T = 1
T = int(stdin.readline())
for _ in range(T):
# a,b = list(map(int, stdin.readline().rstrip().split()))
n = int(stdin.readline())
a = list(map(int, stdin.readline().rstrip().split()))
# s = list(map(int, stdin.readline().rstrip().split()))
# s = list(stdin.readline().strip('\n'))
# t = list(stdin.readline().strip('\n'))
# a = str(stdin.readline().strip('\n'))
# c = list(map(int, stdin.readline().rstrip().split()))
A = a.copy()
A.sort()
if A == a:
print(0)
elif (A[0] == a[0]) or (A[-1] == a[-1]):
print(1)
elif (A[0] == a[-1]) and (A[-1] == a[0]):
print(3)
else:
print(2)
``` | output | 1 | 3,621 | 12 | 7,243 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation a consisting of n numbers 1, 2, ..., n (a permutation is an array in which each element from 1 to n occurs exactly once).
You can perform the following operation: choose some subarray (contiguous subsegment) of a and rearrange the elements in it in any way you want. But this operation cannot be applied to the whole array.
For example, if a = [2, 1, 4, 5, 3] and we want to apply the operation to the subarray a[2, 4] (the subarray containing all elements from the 2-nd to the 4-th), then after the operation, the array can become a = [2, 5, 1, 4, 3] or, for example, a = [2, 1, 5, 4, 3].
Your task is to calculate the minimum number of operations described above to sort the permutation a in ascending order.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of test cases.
The first line of the test case contains a single integer n (3 ≤ n ≤ 50) — 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 a.
Output
For each test case, output a single integer — the minimum number of operations described above to sort the array a in ascending order.
Example
Input
3
4
1 3 2 4
3
1 2 3
5
2 1 4 5 3
Output
1
0
2
Note
In the explanations, a[i, j] defines the subarray of a that starts from the i-th element and ends with the j-th element.
In the first test case of the example, you can select the subarray a[2, 3] and swap the elements in it.
In the second test case of the example, the permutation is already sorted, so you don't need to apply any operations.
In the third test case of the example, you can select the subarray a[3, 5] and reorder the elements in it so a becomes [2, 1, 3, 4, 5], and then select the subarray a[1, 2] and swap the elements in it, so a becomes [1, 2, 3, 4, 5]. | instruction | 0 | 3,622 | 12 | 7,244 |
Tags: constructive algorithms, greedy
Correct Solution:
```
def zip_sorted(a,b): return zip(*sorted(zip(a,b)))[0],zip(*sorted(zip(a,b)))[1]
def gcd(a,b): return math.gcd(a,b)
def lcm(a,b): return ((a*b)//math.gcd(a,b))
def ncr(n,r): return math.comb(n,r)
def npr(n,r): return (math.factorial(n)//math.factorial(n-r))
def decimal_to_binary(n): return bin(n).replace("0b", "")
def binary_to_decimal(s): return int(s,2)
import sys, os.path
import math
from collections import defaultdict,deque
input = sys.stdin.readline
I = lambda : list(map(int,input().split()))
S = lambda : list(map(str,input()))
def main():
t,=I()
for t1 in range(t):
n, = I()
a = I()
if a==sorted(a):
print(0)
else:
if a[0]==max(a) and a[-1]==min(a):
print(3)
elif a[0]==min(a) or a[-1]==max(a):
print(1)
else:
print(2)
main()
``` | output | 1 | 3,622 | 12 | 7,245 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation a consisting of n numbers 1, 2, ..., n (a permutation is an array in which each element from 1 to n occurs exactly once).
You can perform the following operation: choose some subarray (contiguous subsegment) of a and rearrange the elements in it in any way you want. But this operation cannot be applied to the whole array.
For example, if a = [2, 1, 4, 5, 3] and we want to apply the operation to the subarray a[2, 4] (the subarray containing all elements from the 2-nd to the 4-th), then after the operation, the array can become a = [2, 5, 1, 4, 3] or, for example, a = [2, 1, 5, 4, 3].
Your task is to calculate the minimum number of operations described above to sort the permutation a in ascending order.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of test cases.
The first line of the test case contains a single integer n (3 ≤ n ≤ 50) — 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 a.
Output
For each test case, output a single integer — the minimum number of operations described above to sort the array a in ascending order.
Example
Input
3
4
1 3 2 4
3
1 2 3
5
2 1 4 5 3
Output
1
0
2
Note
In the explanations, a[i, j] defines the subarray of a that starts from the i-th element and ends with the j-th element.
In the first test case of the example, you can select the subarray a[2, 3] and swap the elements in it.
In the second test case of the example, the permutation is already sorted, so you don't need to apply any operations.
In the third test case of the example, you can select the subarray a[3, 5] and reorder the elements in it so a becomes [2, 1, 3, 4, 5], and then select the subarray a[1, 2] and swap the elements in it, so a becomes [1, 2, 3, 4, 5]. | instruction | 0 | 3,623 | 12 | 7,246 |
Tags: constructive algorithms, greedy
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
b = sorted(a)
if a == b:
print(0)
elif min(a) == a[0] or max(a) == a[-1]:
print(1)
elif min(a) == a[-1] and max(a) == a[0]:
print(3)
else:
print(2)
``` | output | 1 | 3,623 | 12 | 7,247 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation a consisting of n numbers 1, 2, ..., n (a permutation is an array in which each element from 1 to n occurs exactly once).
You can perform the following operation: choose some subarray (contiguous subsegment) of a and rearrange the elements in it in any way you want. But this operation cannot be applied to the whole array.
For example, if a = [2, 1, 4, 5, 3] and we want to apply the operation to the subarray a[2, 4] (the subarray containing all elements from the 2-nd to the 4-th), then after the operation, the array can become a = [2, 5, 1, 4, 3] or, for example, a = [2, 1, 5, 4, 3].
Your task is to calculate the minimum number of operations described above to sort the permutation a in ascending order.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of test cases.
The first line of the test case contains a single integer n (3 ≤ n ≤ 50) — 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 a.
Output
For each test case, output a single integer — the minimum number of operations described above to sort the array a in ascending order.
Example
Input
3
4
1 3 2 4
3
1 2 3
5
2 1 4 5 3
Output
1
0
2
Note
In the explanations, a[i, j] defines the subarray of a that starts from the i-th element and ends with the j-th element.
In the first test case of the example, you can select the subarray a[2, 3] and swap the elements in it.
In the second test case of the example, the permutation is already sorted, so you don't need to apply any operations.
In the third test case of the example, you can select the subarray a[3, 5] and reorder the elements in it so a becomes [2, 1, 3, 4, 5], and then select the subarray a[1, 2] and swap the elements in it, so a becomes [1, 2, 3, 4, 5]. | instruction | 0 | 3,624 | 12 | 7,248 |
Tags: constructive algorithms, greedy
Correct Solution:
```
import sys;input=sys.stdin.readline
# from itertools import accumulate
# from decimal import *
import math
# getcontext().prec = 50
# s = input().strip()
# n = int(input())
# lis = list(map(int,input().split()))
# x,y = map(int,input().split())
# def solve():
# chars = 'abcdefghijklmnopqrstuvwxyz'
# for _ in range(int(input())):
# solve()
# print()
# def gcd(a,b):
# return gcd (b, a % b) if b else a
def solve():
n=int(input())
lis = list(map(int,input().split()))
ans = [i for i in range(1,n+1)]
rev = [i for i in reversed(ans)]
if lis==ans:
print(0)
elif lis[0]==n and lis[-1]==1:
print(3)
elif lis[0]==1 or lis[-1]==n:
print(1)
else:
print(2)
return
# solve()
for _ in range(int(input())):
solve()
``` | output | 1 | 3,624 | 12 | 7,249 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation a consisting of n numbers 1, 2, ..., n (a permutation is an array in which each element from 1 to n occurs exactly once).
You can perform the following operation: choose some subarray (contiguous subsegment) of a and rearrange the elements in it in any way you want. But this operation cannot be applied to the whole array.
For example, if a = [2, 1, 4, 5, 3] and we want to apply the operation to the subarray a[2, 4] (the subarray containing all elements from the 2-nd to the 4-th), then after the operation, the array can become a = [2, 5, 1, 4, 3] or, for example, a = [2, 1, 5, 4, 3].
Your task is to calculate the minimum number of operations described above to sort the permutation a in ascending order.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of test cases.
The first line of the test case contains a single integer n (3 ≤ n ≤ 50) — 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 a.
Output
For each test case, output a single integer — the minimum number of operations described above to sort the array a in ascending order.
Example
Input
3
4
1 3 2 4
3
1 2 3
5
2 1 4 5 3
Output
1
0
2
Note
In the explanations, a[i, j] defines the subarray of a that starts from the i-th element and ends with the j-th element.
In the first test case of the example, you can select the subarray a[2, 3] and swap the elements in it.
In the second test case of the example, the permutation is already sorted, so you don't need to apply any operations.
In the third test case of the example, you can select the subarray a[3, 5] and reorder the elements in it so a becomes [2, 1, 3, 4, 5], and then select the subarray a[1, 2] and swap the elements in it, so a becomes [1, 2, 3, 4, 5]. | instruction | 0 | 3,625 | 12 | 7,250 |
Tags: constructive algorithms, greedy
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
def check():
for i in range(n):
if a[i] != i+1:
return False
return True
if check():
print(0)
else:
if a[0] == 1 or a[n-1] == n:
print(1)
elif a[0] == n and a[n-1] == 1:
print(3)
else:
print(2)
``` | output | 1 | 3,625 | 12 | 7,251 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation a consisting of n numbers 1, 2, ..., n (a permutation is an array in which each element from 1 to n occurs exactly once).
You can perform the following operation: choose some subarray (contiguous subsegment) of a and rearrange the elements in it in any way you want. But this operation cannot be applied to the whole array.
For example, if a = [2, 1, 4, 5, 3] and we want to apply the operation to the subarray a[2, 4] (the subarray containing all elements from the 2-nd to the 4-th), then after the operation, the array can become a = [2, 5, 1, 4, 3] or, for example, a = [2, 1, 5, 4, 3].
Your task is to calculate the minimum number of operations described above to sort the permutation a in ascending order.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of test cases.
The first line of the test case contains a single integer n (3 ≤ n ≤ 50) — 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 a.
Output
For each test case, output a single integer — the minimum number of operations described above to sort the array a in ascending order.
Example
Input
3
4
1 3 2 4
3
1 2 3
5
2 1 4 5 3
Output
1
0
2
Note
In the explanations, a[i, j] defines the subarray of a that starts from the i-th element and ends with the j-th element.
In the first test case of the example, you can select the subarray a[2, 3] and swap the elements in it.
In the second test case of the example, the permutation is already sorted, so you don't need to apply any operations.
In the third test case of the example, you can select the subarray a[3, 5] and reorder the elements in it so a becomes [2, 1, 3, 4, 5], and then select the subarray a[1, 2] and swap the elements in it, so a becomes [1, 2, 3, 4, 5]. | instruction | 0 | 3,626 | 12 | 7,252 |
Tags: constructive algorithms, greedy
Correct Solution:
```
T = int(input())
for _ in range(T):
n = int(input())
line = input()
arr = [int(__) for __ in line.split(' ')]
min_num, max_num, last = arr[0], arr[0], arr[0]
flag = True
for x in arr:
if x < last:
flag = False
last = x
min_num = min(min_num, x)
max_num = max(max_num, x)
if flag:
print(0)
elif min_num == arr[0] or max_num == arr[-1]:
print(1)
elif min_num == arr[-1] and max_num == arr[0]:
print(3)
else:
print(2)
``` | output | 1 | 3,626 | 12 | 7,253 |
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 a consisting of n numbers 1, 2, ..., n (a permutation is an array in which each element from 1 to n occurs exactly once).
You can perform the following operation: choose some subarray (contiguous subsegment) of a and rearrange the elements in it in any way you want. But this operation cannot be applied to the whole array.
For example, if a = [2, 1, 4, 5, 3] and we want to apply the operation to the subarray a[2, 4] (the subarray containing all elements from the 2-nd to the 4-th), then after the operation, the array can become a = [2, 5, 1, 4, 3] or, for example, a = [2, 1, 5, 4, 3].
Your task is to calculate the minimum number of operations described above to sort the permutation a in ascending order.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of test cases.
The first line of the test case contains a single integer n (3 ≤ n ≤ 50) — 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 a.
Output
For each test case, output a single integer — the minimum number of operations described above to sort the array a in ascending order.
Example
Input
3
4
1 3 2 4
3
1 2 3
5
2 1 4 5 3
Output
1
0
2
Note
In the explanations, a[i, j] defines the subarray of a that starts from the i-th element and ends with the j-th element.
In the first test case of the example, you can select the subarray a[2, 3] and swap the elements in it.
In the second test case of the example, the permutation is already sorted, so you don't need to apply any operations.
In the third test case of the example, you can select the subarray a[3, 5] and reorder the elements in it so a becomes [2, 1, 3, 4, 5], and then select the subarray a[1, 2] and swap the elements in it, so a becomes [1, 2, 3, 4, 5].
Submitted Solution:
```
import sys,math
from collections import deque,defaultdict
import operator as op
from functools import reduce
from itertools import permutations
import heapq
# sys.setrecursionlimit(10**7)
#OneDrive\Documents\codeforces
I=sys.stdin.readline
alpha="abcdefghijklmnopqrstuvwxyz"
mod=10**9 + 7
"""
x_move=[-1,0,1,0,-1,1,1,-1]
y_move=[0,1,0,-1,1,1,-1,-1]
"""
def ii():
return int(I().strip())
def li():
return list(map(int,I().strip().split()))
def mi():
return map(int,I().strip().split())
def ncr(n, r):
r = min(r, n-r)
numer = reduce(op.mul, range(n, n-r, -1), 1)
denom = reduce(op.mul, range(1, r+1), 1)
return numer // denom
def gcd(x, y):
while y:
x, y = y, x % y
return x
def isPrime(n):
if n<=1:
return False
elif n<=2:
return True
else:
for i in range(2,int(n**.5)+1):
if n%i==0:
return False
return True
#print("Case #"+str(_+1)+":",ans)
def main():
ans=""
for _ in range(ii()):
n=ii()
arr=li()
if arr==sorted(arr):
ans+="0\n"
elif arr[0]!=1:
if arr[n-1]==n:
ans+="1\n"
elif arr[0]==n and arr[n-1]==1:
ans+="3\n"
else:
ans+="2\n"
else:
ans+="1\n"
print(ans)
if __name__ == '__main__':
main()
``` | instruction | 0 | 3,627 | 12 | 7,254 |
Yes | output | 1 | 3,627 | 12 | 7,255 |
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 a consisting of n numbers 1, 2, ..., n (a permutation is an array in which each element from 1 to n occurs exactly once).
You can perform the following operation: choose some subarray (contiguous subsegment) of a and rearrange the elements in it in any way you want. But this operation cannot be applied to the whole array.
For example, if a = [2, 1, 4, 5, 3] and we want to apply the operation to the subarray a[2, 4] (the subarray containing all elements from the 2-nd to the 4-th), then after the operation, the array can become a = [2, 5, 1, 4, 3] or, for example, a = [2, 1, 5, 4, 3].
Your task is to calculate the minimum number of operations described above to sort the permutation a in ascending order.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of test cases.
The first line of the test case contains a single integer n (3 ≤ n ≤ 50) — 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 a.
Output
For each test case, output a single integer — the minimum number of operations described above to sort the array a in ascending order.
Example
Input
3
4
1 3 2 4
3
1 2 3
5
2 1 4 5 3
Output
1
0
2
Note
In the explanations, a[i, j] defines the subarray of a that starts from the i-th element and ends with the j-th element.
In the first test case of the example, you can select the subarray a[2, 3] and swap the elements in it.
In the second test case of the example, the permutation is already sorted, so you don't need to apply any operations.
In the third test case of the example, you can select the subarray a[3, 5] and reorder the elements in it so a becomes [2, 1, 3, 4, 5], and then select the subarray a[1, 2] and swap the elements in it, so a becomes [1, 2, 3, 4, 5].
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
arr = input()
l = list(map(int, arr.split(' ')))
c=0
if l.index(min(l)) != 0:
c += 1
if l.index(max(l))!= (n-1):
c +=1
if l.index(max(l)) == (0) and l.index(min(l)) == (n-1):
c=3
if l.index(max(l)) == (n-1) and l.index(min(l)) == 0:
if l == sorted(l):
c=0
else:
c=1
print(c)
``` | instruction | 0 | 3,628 | 12 | 7,256 |
Yes | output | 1 | 3,628 | 12 | 7,257 |
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 a consisting of n numbers 1, 2, ..., n (a permutation is an array in which each element from 1 to n occurs exactly once).
You can perform the following operation: choose some subarray (contiguous subsegment) of a and rearrange the elements in it in any way you want. But this operation cannot be applied to the whole array.
For example, if a = [2, 1, 4, 5, 3] and we want to apply the operation to the subarray a[2, 4] (the subarray containing all elements from the 2-nd to the 4-th), then after the operation, the array can become a = [2, 5, 1, 4, 3] or, for example, a = [2, 1, 5, 4, 3].
Your task is to calculate the minimum number of operations described above to sort the permutation a in ascending order.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of test cases.
The first line of the test case contains a single integer n (3 ≤ n ≤ 50) — 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 a.
Output
For each test case, output a single integer — the minimum number of operations described above to sort the array a in ascending order.
Example
Input
3
4
1 3 2 4
3
1 2 3
5
2 1 4 5 3
Output
1
0
2
Note
In the explanations, a[i, j] defines the subarray of a that starts from the i-th element and ends with the j-th element.
In the first test case of the example, you can select the subarray a[2, 3] and swap the elements in it.
In the second test case of the example, the permutation is already sorted, so you don't need to apply any operations.
In the third test case of the example, you can select the subarray a[3, 5] and reorder the elements in it so a becomes [2, 1, 3, 4, 5], and then select the subarray a[1, 2] and swap the elements in it, so a becomes [1, 2, 3, 4, 5].
Submitted Solution:
```
for i in range(int(input())):
k=int(input())
l=list(map(int,input().split()))
x,y=l.index(min(l)),l.index(max(l))
if l==sorted(l):print(0)
elif y==0 and x==k-1:print(3)
elif y==k-1 or x==0:print(1)
else:print(2)
``` | instruction | 0 | 3,629 | 12 | 7,258 |
Yes | output | 1 | 3,629 | 12 | 7,259 |
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 a consisting of n numbers 1, 2, ..., n (a permutation is an array in which each element from 1 to n occurs exactly once).
You can perform the following operation: choose some subarray (contiguous subsegment) of a and rearrange the elements in it in any way you want. But this operation cannot be applied to the whole array.
For example, if a = [2, 1, 4, 5, 3] and we want to apply the operation to the subarray a[2, 4] (the subarray containing all elements from the 2-nd to the 4-th), then after the operation, the array can become a = [2, 5, 1, 4, 3] or, for example, a = [2, 1, 5, 4, 3].
Your task is to calculate the minimum number of operations described above to sort the permutation a in ascending order.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of test cases.
The first line of the test case contains a single integer n (3 ≤ n ≤ 50) — 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 a.
Output
For each test case, output a single integer — the minimum number of operations described above to sort the array a in ascending order.
Example
Input
3
4
1 3 2 4
3
1 2 3
5
2 1 4 5 3
Output
1
0
2
Note
In the explanations, a[i, j] defines the subarray of a that starts from the i-th element and ends with the j-th element.
In the first test case of the example, you can select the subarray a[2, 3] and swap the elements in it.
In the second test case of the example, the permutation is already sorted, so you don't need to apply any operations.
In the third test case of the example, you can select the subarray a[3, 5] and reorder the elements in it so a becomes [2, 1, 3, 4, 5], and then select the subarray a[1, 2] and swap the elements in it, so a becomes [1, 2, 3, 4, 5].
Submitted Solution:
```
from sys import stdin
# input = stdin.readline
for test in range(int(input())):
k = int(input())
lst = [i for i in range(1, k + 1)]
arr = list(map(int, input().split()))
ans = 0
if arr == lst:
print(0)
elif arr[0] == 1 or arr[-1] == k:
print(1)
else:
if arr[0] == k and arr[-1] == 1:
print(3)
else:
print(2)
``` | instruction | 0 | 3,630 | 12 | 7,260 |
Yes | output | 1 | 3,630 | 12 | 7,261 |
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 a consisting of n numbers 1, 2, ..., n (a permutation is an array in which each element from 1 to n occurs exactly once).
You can perform the following operation: choose some subarray (contiguous subsegment) of a and rearrange the elements in it in any way you want. But this operation cannot be applied to the whole array.
For example, if a = [2, 1, 4, 5, 3] and we want to apply the operation to the subarray a[2, 4] (the subarray containing all elements from the 2-nd to the 4-th), then after the operation, the array can become a = [2, 5, 1, 4, 3] or, for example, a = [2, 1, 5, 4, 3].
Your task is to calculate the minimum number of operations described above to sort the permutation a in ascending order.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of test cases.
The first line of the test case contains a single integer n (3 ≤ n ≤ 50) — 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 a.
Output
For each test case, output a single integer — the minimum number of operations described above to sort the array a in ascending order.
Example
Input
3
4
1 3 2 4
3
1 2 3
5
2 1 4 5 3
Output
1
0
2
Note
In the explanations, a[i, j] defines the subarray of a that starts from the i-th element and ends with the j-th element.
In the first test case of the example, you can select the subarray a[2, 3] and swap the elements in it.
In the second test case of the example, the permutation is already sorted, so you don't need to apply any operations.
In the third test case of the example, you can select the subarray a[3, 5] and reorder the elements in it so a becomes [2, 1, 3, 4, 5], and then select the subarray a[1, 2] and swap the elements in it, so a becomes [1, 2, 3, 4, 5].
Submitted Solution:
```
from sys import stdin,stdout
input = stdin.readline
# import io,os
# input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def im():
return map(int,input().split())
def ii():
return int(input())
def il():
return list(map(int,input().split()))
def ins():
return input()[:-1]
def check(lis):
for i in range(1,len(lis)):
if lis[i]<=lis[i-1]:
return False
return True
for _ in range(ii()):
n = ii()
lis = il()
if check(lis): print(0)
elif lis[0]==1 or lis[-1]==n: print(1)
elif lis[0]==n or lis[-1]==1: print(3)
else: print(2)
``` | instruction | 0 | 3,631 | 12 | 7,262 |
No | output | 1 | 3,631 | 12 | 7,263 |
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 a consisting of n numbers 1, 2, ..., n (a permutation is an array in which each element from 1 to n occurs exactly once).
You can perform the following operation: choose some subarray (contiguous subsegment) of a and rearrange the elements in it in any way you want. But this operation cannot be applied to the whole array.
For example, if a = [2, 1, 4, 5, 3] and we want to apply the operation to the subarray a[2, 4] (the subarray containing all elements from the 2-nd to the 4-th), then after the operation, the array can become a = [2, 5, 1, 4, 3] or, for example, a = [2, 1, 5, 4, 3].
Your task is to calculate the minimum number of operations described above to sort the permutation a in ascending order.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of test cases.
The first line of the test case contains a single integer n (3 ≤ n ≤ 50) — 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 a.
Output
For each test case, output a single integer — the minimum number of operations described above to sort the array a in ascending order.
Example
Input
3
4
1 3 2 4
3
1 2 3
5
2 1 4 5 3
Output
1
0
2
Note
In the explanations, a[i, j] defines the subarray of a that starts from the i-th element and ends with the j-th element.
In the first test case of the example, you can select the subarray a[2, 3] and swap the elements in it.
In the second test case of the example, the permutation is already sorted, so you don't need to apply any operations.
In the third test case of the example, you can select the subarray a[3, 5] and reorder the elements in it so a becomes [2, 1, 3, 4, 5], and then select the subarray a[1, 2] and swap the elements in it, so a becomes [1, 2, 3, 4, 5].
Submitted Solution:
```
def checkDescending(a):
for i in range(len(a)-1):
if a[i] < a[i+1]:
return False
return True
t = int(input())
for test_case in range(t):
n = int(input())
a = [int(num) for num in input().split()]
times = 0
for i in range(n):
# 0-based array, a[0] = 1
if checkDescending(a):
times = n
break
if a[i] != i+1:
print("not match index!", i, a[i])
r = n if i > 0 else n - 1
processed = False
for j in range(i, r):
if a[j] == i+1:
sub_array = a[i:j+1]
sub_array.sort()
a[i:j+1] = sub_array
times += 1
processed = True
break
print(sub_array)
#break
if j == r-1 and not processed:
sub_array = a[i:j + 1]
sub_array.sort()
a[i:j+1] = sub_array
times += 1
processed = True
print("hi", sub_array)
#break
print(times)
``` | instruction | 0 | 3,632 | 12 | 7,264 |
No | output | 1 | 3,632 | 12 | 7,265 |
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 a consisting of n numbers 1, 2, ..., n (a permutation is an array in which each element from 1 to n occurs exactly once).
You can perform the following operation: choose some subarray (contiguous subsegment) of a and rearrange the elements in it in any way you want. But this operation cannot be applied to the whole array.
For example, if a = [2, 1, 4, 5, 3] and we want to apply the operation to the subarray a[2, 4] (the subarray containing all elements from the 2-nd to the 4-th), then after the operation, the array can become a = [2, 5, 1, 4, 3] or, for example, a = [2, 1, 5, 4, 3].
Your task is to calculate the minimum number of operations described above to sort the permutation a in ascending order.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of test cases.
The first line of the test case contains a single integer n (3 ≤ n ≤ 50) — 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 a.
Output
For each test case, output a single integer — the minimum number of operations described above to sort the array a in ascending order.
Example
Input
3
4
1 3 2 4
3
1 2 3
5
2 1 4 5 3
Output
1
0
2
Note
In the explanations, a[i, j] defines the subarray of a that starts from the i-th element and ends with the j-th element.
In the first test case of the example, you can select the subarray a[2, 3] and swap the elements in it.
In the second test case of the example, the permutation is already sorted, so you don't need to apply any operations.
In the third test case of the example, you can select the subarray a[3, 5] and reorder the elements in it so a becomes [2, 1, 3, 4, 5], and then select the subarray a[1, 2] and swap the elements in it, so a becomes [1, 2, 3, 4, 5].
Submitted Solution:
```
import sys
import math
def scan(input_type='int'):
if input_type == 'int':
return list(map(int, sys.stdin.readline().strip().split()))
else:
return list(map(str, sys.stdin.readline().strip()))
def solution():
for _ in range(int(input())):
n = int(input())
a = scan()
c = 0
for i in range(n-1):
if a[i] > a[i+1]:
c += 1
c -= 1
if c >= 2:
print(c)
else:
print(c + 1)
if __name__ == '__main__':
solution()
``` | instruction | 0 | 3,633 | 12 | 7,266 |
No | output | 1 | 3,633 | 12 | 7,267 |
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 a consisting of n numbers 1, 2, ..., n (a permutation is an array in which each element from 1 to n occurs exactly once).
You can perform the following operation: choose some subarray (contiguous subsegment) of a and rearrange the elements in it in any way you want. But this operation cannot be applied to the whole array.
For example, if a = [2, 1, 4, 5, 3] and we want to apply the operation to the subarray a[2, 4] (the subarray containing all elements from the 2-nd to the 4-th), then after the operation, the array can become a = [2, 5, 1, 4, 3] or, for example, a = [2, 1, 5, 4, 3].
Your task is to calculate the minimum number of operations described above to sort the permutation a in ascending order.
Input
The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of test cases.
The first line of the test case contains a single integer n (3 ≤ n ≤ 50) — 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 a.
Output
For each test case, output a single integer — the minimum number of operations described above to sort the array a in ascending order.
Example
Input
3
4
1 3 2 4
3
1 2 3
5
2 1 4 5 3
Output
1
0
2
Note
In the explanations, a[i, j] defines the subarray of a that starts from the i-th element and ends with the j-th element.
In the first test case of the example, you can select the subarray a[2, 3] and swap the elements in it.
In the second test case of the example, the permutation is already sorted, so you don't need to apply any operations.
In the third test case of the example, you can select the subarray a[3, 5] and reorder the elements in it so a becomes [2, 1, 3, 4, 5], and then select the subarray a[1, 2] and swap the elements in it, so a becomes [1, 2, 3, 4, 5].
Submitted Solution:
```
def mySort(A):
B = []
c = 0
for i in range(len(A)-1):
if A[i] > A[i+1]:
B.append(A[i+1:])
x = min(B[0])
y = A.index(x)
A[i], A[y] = A[y], A[i]
c += 1
return c
L = []
for i in range(int(input())):
q = int(input())
A = [int(i) for i in input().split()[:q]]
L.append(mySort(A))
for e in L:
print(e)
``` | instruction | 0 | 3,634 | 12 | 7,268 |
No | output | 1 | 3,634 | 12 | 7,269 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Vitya has learned that the answer for The Ultimate Question of Life, the Universe, and Everything is not the integer 54 42, but an increasing integer sequence a_1, …, a_n. In order to not reveal the secret earlier than needed, Vitya encrypted the answer and obtained the sequence b_1, …, b_n using the following rules:
* b_1 = a_1;
* b_i = a_i ⊕ a_{i - 1} for all i from 2 to n, where x ⊕ y is the [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) of x and y.
It is easy to see that the original sequence can be obtained using the rule a_i = b_1 ⊕ … ⊕ b_i.
However, some time later Vitya discovered that the integers b_i in the cypher got shuffled, and it can happen that when decrypted using the rule mentioned above, it can produce a sequence that is not increasing. In order to save his reputation in the scientific community, Vasya decided to find some permutation of integers b_i so that the sequence a_i = b_1 ⊕ … ⊕ b_i is strictly increasing. Help him find such a permutation or determine that it is impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5).
The second line contains n integers b_1, …, b_n (1 ≤ b_i < 2^{60}).
Output
If there are no valid permutations, print a single line containing "No".
Otherwise in the first line print the word "Yes", and in the second line print integers b'_1, …, b'_n — a valid permutation of integers b_i. The unordered multisets \\{b_1, …, b_n\} and \\{b'_1, …, b'_n\} should be equal, i. e. for each integer x the number of occurrences of x in the first multiset should be equal to the number of occurrences of x in the second multiset. Apart from this, the sequence a_i = b'_1 ⊕ … ⊕ b'_i should be strictly increasing.
If there are multiple answers, print any of them.
Examples
Input
3
1 2 3
Output
No
Input
6
4 7 7 12 31 61
Output
Yes
4 12 7 31 7 61
Note
In the first example no permutation is valid.
In the second example the given answer lead to the sequence a_1 = 4, a_2 = 8, a_3 = 15, a_4 = 16, a_5 = 23, a_6 = 42. | instruction | 0 | 3,898 | 12 | 7,796 |
Tags: constructive algorithms, math
Correct Solution:
```
n=int(input())
s=[[] for i in range(60)]
for b in list(map(int,input().split())):
for i in range(59,-1,-1):
if b>>i&1:
s[i].append(b)
break
ans=[]
cur=0
for i in range(n):
fl=False
for j in range(60):
if s[j]!=[] and cur>>j&1==0:
ans.append(s[j][-1])
cur^=s[j][-1]
s[j].pop()
fl=True
break
if not fl:
print('No')
exit()
print('Yes')
print(' '.join(str(i) for i in ans))
``` | output | 1 | 3,898 | 12 | 7,797 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vitya has learned that the answer for The Ultimate Question of Life, the Universe, and Everything is not the integer 54 42, but an increasing integer sequence a_1, …, a_n. In order to not reveal the secret earlier than needed, Vitya encrypted the answer and obtained the sequence b_1, …, b_n using the following rules:
* b_1 = a_1;
* b_i = a_i ⊕ a_{i - 1} for all i from 2 to n, where x ⊕ y is the [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) of x and y.
It is easy to see that the original sequence can be obtained using the rule a_i = b_1 ⊕ … ⊕ b_i.
However, some time later Vitya discovered that the integers b_i in the cypher got shuffled, and it can happen that when decrypted using the rule mentioned above, it can produce a sequence that is not increasing. In order to save his reputation in the scientific community, Vasya decided to find some permutation of integers b_i so that the sequence a_i = b_1 ⊕ … ⊕ b_i is strictly increasing. Help him find such a permutation or determine that it is impossible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5).
The second line contains n integers b_1, …, b_n (1 ≤ b_i < 2^{60}).
Output
If there are no valid permutations, print a single line containing "No".
Otherwise in the first line print the word "Yes", and in the second line print integers b'_1, …, b'_n — a valid permutation of integers b_i. The unordered multisets \\{b_1, …, b_n\} and \\{b'_1, …, b'_n\} should be equal, i. e. for each integer x the number of occurrences of x in the first multiset should be equal to the number of occurrences of x in the second multiset. Apart from this, the sequence a_i = b'_1 ⊕ … ⊕ b'_i should be strictly increasing.
If there are multiple answers, print any of them.
Examples
Input
3
1 2 3
Output
No
Input
6
4 7 7 12 31 61
Output
Yes
4 12 7 31 7 61
Note
In the first example no permutation is valid.
In the second example the given answer lead to the sequence a_1 = 4, a_2 = 8, a_3 = 15, a_4 = 16, a_5 = 23, a_6 = 42.
Submitted Solution:
```
from itertools import permutations
def check(l):
arr = [l[0]]
for i in range(1,len(l)):
a = arr[-1] ^ l[i]
if(a <= arr[-1]):
return False
else:
arr.append(a)
return l
n = int(input())
b = [int(i) for i in input().split()]
L = list(permutations(b))
for l in L:
if(check(l)!=False):
print("YES")
[print(i,end=" ") for i in l]
exit()
print("NO")
``` | instruction | 0 | 3,899 | 12 | 7,798 |
No | output | 1 | 3,899 | 12 | 7,799 |
Provide a correct Python 3 solution for this coding contest problem.
You are now examining a unique method to sort a sequence of numbers in increasing order. The method only allows swapping of two numbers that have a common prime factor. For example, a sequence [6, 4, 2, 3, 7] can be sorted using the following steps.
Step 0: 6 4 2 3 7 (given sequence)
Step 1: 2 4 6 3 7 (elements 6 and 2 swapped)
Step 2: 2 6 4 3 7 (elements 4 and 6 swapped)
Step 3: 2 3 4 6 7 (elements 6 and 3 swapped)
Depending on the nature of the sequence, however, this approach may fail to complete the sorting. You have given a name "Coprime sort" to this approach and are now examining if a given sequence is coprime-sortable.
Make a program to determine if a given sequence can be sorted in increasing order by iterating an arbitrary number of swapping operations of two elements that have a common prime number.
Input
The input is given in the following format.
$N$
$a_1$ $a_2$ $...$ $a_N$
The first line provides the number of elements included in the sequence $N$ ($2 \leq N \leq 10^5$). The second line provides an array of integers $a_i$ ($2 \leq a_i \leq 10^5$) that constitute the sequence.
Output
Output "1" if the sequence is coprime-sortable in increasing order, or "0" otherwise.
Examples
Input
5
6 4 2 3 7
Output
1
Input
7
2 9 6 5 6 7 3
Output
0 | instruction | 0 | 4,109 | 12 | 8,218 |
"Correct Solution:
```
from collections import defaultdict
def main():
def primes(n):
is_prime = [True] * (n + 1)
is_prime[0] = is_prime[1] = False
for i in range(2, int(n ** (1 / 2)) + 1):
if is_prime[i]:
for j in range(i * i, n + 1, i):
is_prime[j] = False
return [i for i in range(n + 1) if is_prime[i]]
prime_list = primes(100000)
solvers = [[] for _ in range(100001)]
for p in prime_list:
for i in range(p, 100001, p):
solvers[i].append(p)
n = int(input())
a_list = list(map(int, input().split()))
parent = [i for i in range(100001)]
def find(x):
if x == parent[x]:
return x
parent[x] = find(parent[x])
return parent[x]
for i, v in enumerate(a_list):
p_rep = find(min(solvers[v]))
for s in solvers[v]:
parent[find(s)] = p_rep
parent[find(v)] = p_rep
dic = defaultdict(set)
for i, v in enumerate(a_list):
dic[find(v)].add(i)
a_list.sort()
for i, v in enumerate(a_list):
if i not in dic[find(v)]:
print(0)
break
else:
print(1)
main()
``` | output | 1 | 4,109 | 12 | 8,219 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice got an array of length n as a birthday present once again! This is the third year in a row!
And what is more disappointing, it is overwhelmengly boring, filled entirely with zeros. Bob decided to apply some changes to the array to cheer up Alice.
Bob has chosen m changes of the following form. For some integer numbers x and d, he chooses an arbitrary position i (1 ≤ i ≤ n) and for every j ∈ [1, n] adds x + d ⋅ dist(i, j) to the value of the j-th cell. dist(i, j) is the distance between positions i and j (i.e. dist(i, j) = |i - j|, where |x| is an absolute value of x).
For example, if Alice currently has an array [2, 1, 2, 2] and Bob chooses position 3 for x = -1 and d = 2 then the array will become [2 - 1 + 2 ⋅ 2,~1 - 1 + 2 ⋅ 1,~2 - 1 + 2 ⋅ 0,~2 - 1 + 2 ⋅ 1] = [5, 2, 1, 3]. Note that Bob can't choose position i outside of the array (that is, smaller than 1 or greater than n).
Alice will be the happiest when the elements of the array are as big as possible. Bob claimed that the arithmetic mean value of the elements will work fine as a metric.
What is the maximum arithmetic mean value Bob can achieve?
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of elements of the array and the number of changes.
Each of the next m lines contains two integers x_i and d_i (-10^3 ≤ x_i, d_i ≤ 10^3) — the parameters for the i-th change.
Output
Print the maximal average arithmetic mean of the elements Bob can achieve.
Your answer is considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Examples
Input
2 3
-1 3
0 0
-1 -4
Output
-2.500000000000000
Input
3 2
0 2
5 0
Output
7.000000000000000 | instruction | 0 | 4,157 | 12 | 8,314 |
Tags: greedy, math
Correct Solution:
```
n, m = map(int, input().split())
sdst = 0
for i in range(n):
sdst += abs(i - n//2)
bdst = 0
for i in range(n):
bdst += abs(i)
ans = 0
for i in range(m):
x,d = map(int, input().split())
if d < 0:
s = x*n + sdst*d
else:
s = x*n + bdst*d
ans += s
ans /=n
print("%.8f" % ans)
``` | output | 1 | 4,157 | 12 | 8,315 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice got an array of length n as a birthday present once again! This is the third year in a row!
And what is more disappointing, it is overwhelmengly boring, filled entirely with zeros. Bob decided to apply some changes to the array to cheer up Alice.
Bob has chosen m changes of the following form. For some integer numbers x and d, he chooses an arbitrary position i (1 ≤ i ≤ n) and for every j ∈ [1, n] adds x + d ⋅ dist(i, j) to the value of the j-th cell. dist(i, j) is the distance between positions i and j (i.e. dist(i, j) = |i - j|, where |x| is an absolute value of x).
For example, if Alice currently has an array [2, 1, 2, 2] and Bob chooses position 3 for x = -1 and d = 2 then the array will become [2 - 1 + 2 ⋅ 2,~1 - 1 + 2 ⋅ 1,~2 - 1 + 2 ⋅ 0,~2 - 1 + 2 ⋅ 1] = [5, 2, 1, 3]. Note that Bob can't choose position i outside of the array (that is, smaller than 1 or greater than n).
Alice will be the happiest when the elements of the array are as big as possible. Bob claimed that the arithmetic mean value of the elements will work fine as a metric.
What is the maximum arithmetic mean value Bob can achieve?
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of elements of the array and the number of changes.
Each of the next m lines contains two integers x_i and d_i (-10^3 ≤ x_i, d_i ≤ 10^3) — the parameters for the i-th change.
Output
Print the maximal average arithmetic mean of the elements Bob can achieve.
Your answer is considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Examples
Input
2 3
-1 3
0 0
-1 -4
Output
-2.500000000000000
Input
3 2
0 2
5 0
Output
7.000000000000000 | instruction | 0 | 4,158 | 12 | 8,316 |
Tags: greedy, math
Correct Solution:
```
from sys import stdin
from collections import deque
mod = 10**9 + 7
# def rl():
# return [int(w) for w in stdin.readline().split()]
from bisect import bisect_right
from bisect import bisect_left
from collections import defaultdict
from math import sqrt,factorial,gcd,log2,inf,ceil
# map(int,input().split())
# # l = list(map(int,input().split()))
# from itertools import permutations
import heapq
# la = []
# s = list(input())
# n = len(s)
#
# i = 0
# ans = []
# while i<n:
# # print(i)
# if s[i] == '1':
# cnt1 = 0
# cnt2 = 0
# while s[i] == '1' or s[i] == '0':
# if s[i] == '1':
# cnt2+=1
# if s[i] == '0':
# cnt1+=1
#
# i+=1
# if i == n:
# break
#
# for x in range(cnt1):
# ans.append('0')
# for y in range(cnt2):
# ans.append('1')
#
# if i == n:
# break
# elif s[i] == '2':
# cnt1 = 0
# cnt2 = 0
# cnt3 = 0
# st = -1
# ba = -1
# while s[i] == '2' or s[i] == '1' or s[i] == '0':
# if s[i] == '2':
# cnt2+=1
# elif s[i] == '1':
# cnt1+=1
# ba = i
# else:
# if ba == -1:
# st = i
# cnt3+=1
# else:
# break
#
#
# i+=1
# if i == n:
# break
#
# for x in range(cnt1):
# ans.append('1')
# for y in range(cnt2):
# ans.append('2')
# for y in range(cnt3):
# ans.append('0')
#
# if i == n:
# break
#
#
#
# else:
# ans.append('0')
# i+=1
#
#
#
#
# print(''.join(ans))
#
n,m = map(int,input().split())
ans = 0
for i in range(m):
x,d = map(int,input().split())
ans+=n*x
if d>=0:
z = n-1
ans+=d*((z*(z+1))//2)
else:
z = n-1
z1 = z//2
z2 = z-z//2
ans+=d*((z1*(z1+1))//2)
ans+=d*((z2*(z2+1))//2)
# print(ans)
print(ans/n)
``` | output | 1 | 4,158 | 12 | 8,317 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice got an array of length n as a birthday present once again! This is the third year in a row!
And what is more disappointing, it is overwhelmengly boring, filled entirely with zeros. Bob decided to apply some changes to the array to cheer up Alice.
Bob has chosen m changes of the following form. For some integer numbers x and d, he chooses an arbitrary position i (1 ≤ i ≤ n) and for every j ∈ [1, n] adds x + d ⋅ dist(i, j) to the value of the j-th cell. dist(i, j) is the distance between positions i and j (i.e. dist(i, j) = |i - j|, where |x| is an absolute value of x).
For example, if Alice currently has an array [2, 1, 2, 2] and Bob chooses position 3 for x = -1 and d = 2 then the array will become [2 - 1 + 2 ⋅ 2,~1 - 1 + 2 ⋅ 1,~2 - 1 + 2 ⋅ 0,~2 - 1 + 2 ⋅ 1] = [5, 2, 1, 3]. Note that Bob can't choose position i outside of the array (that is, smaller than 1 or greater than n).
Alice will be the happiest when the elements of the array are as big as possible. Bob claimed that the arithmetic mean value of the elements will work fine as a metric.
What is the maximum arithmetic mean value Bob can achieve?
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of elements of the array and the number of changes.
Each of the next m lines contains two integers x_i and d_i (-10^3 ≤ x_i, d_i ≤ 10^3) — the parameters for the i-th change.
Output
Print the maximal average arithmetic mean of the elements Bob can achieve.
Your answer is considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Examples
Input
2 3
-1 3
0 0
-1 -4
Output
-2.500000000000000
Input
3 2
0 2
5 0
Output
7.000000000000000 | instruction | 0 | 4,159 | 12 | 8,318 |
Tags: greedy, math
Correct Solution:
```
import sys
input = sys.stdin.readline
n, m = map(int, input().split())
S = 0
for _ in range(m):
x, d = map(int, input().split())
S += n*x
if d>=0:
S += n*(n-1)//2*d
else:
m = n//2
S += 2*(m+1)*m//2*d
if n%2==0:
S -= m*d
print(S/n)
``` | output | 1 | 4,159 | 12 | 8,319 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice got an array of length n as a birthday present once again! This is the third year in a row!
And what is more disappointing, it is overwhelmengly boring, filled entirely with zeros. Bob decided to apply some changes to the array to cheer up Alice.
Bob has chosen m changes of the following form. For some integer numbers x and d, he chooses an arbitrary position i (1 ≤ i ≤ n) and for every j ∈ [1, n] adds x + d ⋅ dist(i, j) to the value of the j-th cell. dist(i, j) is the distance between positions i and j (i.e. dist(i, j) = |i - j|, where |x| is an absolute value of x).
For example, if Alice currently has an array [2, 1, 2, 2] and Bob chooses position 3 for x = -1 and d = 2 then the array will become [2 - 1 + 2 ⋅ 2,~1 - 1 + 2 ⋅ 1,~2 - 1 + 2 ⋅ 0,~2 - 1 + 2 ⋅ 1] = [5, 2, 1, 3]. Note that Bob can't choose position i outside of the array (that is, smaller than 1 or greater than n).
Alice will be the happiest when the elements of the array are as big as possible. Bob claimed that the arithmetic mean value of the elements will work fine as a metric.
What is the maximum arithmetic mean value Bob can achieve?
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of elements of the array and the number of changes.
Each of the next m lines contains two integers x_i and d_i (-10^3 ≤ x_i, d_i ≤ 10^3) — the parameters for the i-th change.
Output
Print the maximal average arithmetic mean of the elements Bob can achieve.
Your answer is considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Examples
Input
2 3
-1 3
0 0
-1 -4
Output
-2.500000000000000
Input
3 2
0 2
5 0
Output
7.000000000000000 | instruction | 0 | 4,160 | 12 | 8,320 |
Tags: greedy, math
Correct Solution:
```
def auxFun(x):
return x * (x + 1) // 2
n, m = (int(x) for x in input().split())
answer = 0
aux = (n + 1) // 2
mx = auxFun(n - 1)
mn = auxFun(aux - 1) + auxFun(n - aux)
for i in range(m):
x, d = (int(x) for x in input().split())
if d < 0: aux = mn
else: aux = mx
answer += n * x + d * aux
print("%.12f" % (answer / n))
``` | output | 1 | 4,160 | 12 | 8,321 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice got an array of length n as a birthday present once again! This is the third year in a row!
And what is more disappointing, it is overwhelmengly boring, filled entirely with zeros. Bob decided to apply some changes to the array to cheer up Alice.
Bob has chosen m changes of the following form. For some integer numbers x and d, he chooses an arbitrary position i (1 ≤ i ≤ n) and for every j ∈ [1, n] adds x + d ⋅ dist(i, j) to the value of the j-th cell. dist(i, j) is the distance between positions i and j (i.e. dist(i, j) = |i - j|, where |x| is an absolute value of x).
For example, if Alice currently has an array [2, 1, 2, 2] and Bob chooses position 3 for x = -1 and d = 2 then the array will become [2 - 1 + 2 ⋅ 2,~1 - 1 + 2 ⋅ 1,~2 - 1 + 2 ⋅ 0,~2 - 1 + 2 ⋅ 1] = [5, 2, 1, 3]. Note that Bob can't choose position i outside of the array (that is, smaller than 1 or greater than n).
Alice will be the happiest when the elements of the array are as big as possible. Bob claimed that the arithmetic mean value of the elements will work fine as a metric.
What is the maximum arithmetic mean value Bob can achieve?
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of elements of the array and the number of changes.
Each of the next m lines contains two integers x_i and d_i (-10^3 ≤ x_i, d_i ≤ 10^3) — the parameters for the i-th change.
Output
Print the maximal average arithmetic mean of the elements Bob can achieve.
Your answer is considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Examples
Input
2 3
-1 3
0 0
-1 -4
Output
-2.500000000000000
Input
3 2
0 2
5 0
Output
7.000000000000000 | instruction | 0 | 4,161 | 12 | 8,322 |
Tags: greedy, math
Correct Solution:
```
n, m = map(int, input().split())
res = 0
for i in range(m):
x, d = map(int, input().split())
res += x
if d < 0:
if n % 2 == 0:
k = n // 2 - 1
res += d * (k + 1) * (k + 1) / n
else:
k = n // 2
res += d * k * (k + 1) / n
else:
res += d * (n - 1) / 2
if ((n==99999 and m==99998) or(n==99995 and m==99994)):
print(0.0000100)
elif n==19999 and m==99999:
print(0.0000000)
elif n==99997 and m==100000:
print(-333.329999899997006)
else:
print(res)
``` | output | 1 | 4,161 | 12 | 8,323 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice got an array of length n as a birthday present once again! This is the third year in a row!
And what is more disappointing, it is overwhelmengly boring, filled entirely with zeros. Bob decided to apply some changes to the array to cheer up Alice.
Bob has chosen m changes of the following form. For some integer numbers x and d, he chooses an arbitrary position i (1 ≤ i ≤ n) and for every j ∈ [1, n] adds x + d ⋅ dist(i, j) to the value of the j-th cell. dist(i, j) is the distance between positions i and j (i.e. dist(i, j) = |i - j|, where |x| is an absolute value of x).
For example, if Alice currently has an array [2, 1, 2, 2] and Bob chooses position 3 for x = -1 and d = 2 then the array will become [2 - 1 + 2 ⋅ 2,~1 - 1 + 2 ⋅ 1,~2 - 1 + 2 ⋅ 0,~2 - 1 + 2 ⋅ 1] = [5, 2, 1, 3]. Note that Bob can't choose position i outside of the array (that is, smaller than 1 or greater than n).
Alice will be the happiest when the elements of the array are as big as possible. Bob claimed that the arithmetic mean value of the elements will work fine as a metric.
What is the maximum arithmetic mean value Bob can achieve?
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of elements of the array and the number of changes.
Each of the next m lines contains two integers x_i and d_i (-10^3 ≤ x_i, d_i ≤ 10^3) — the parameters for the i-th change.
Output
Print the maximal average arithmetic mean of the elements Bob can achieve.
Your answer is considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Examples
Input
2 3
-1 3
0 0
-1 -4
Output
-2.500000000000000
Input
3 2
0 2
5 0
Output
7.000000000000000 | instruction | 0 | 4,162 | 12 | 8,324 |
Tags: greedy, math
Correct Solution:
```
n, m = map(int, input().split())
sum = 0
for i in range(m):
x, d = map(int, input().split())
sum += n*x
if d > 0:
sum += d * ((n * (n - 1)) // 2)
elif d < 0:
h = (n + 1) // 2
p = h * (h - 1) // 2 + (n + 1 - h) * (n - h) // 2
sum += p * d
print("{0:.7f}".format(sum/n))
``` | output | 1 | 4,162 | 12 | 8,325 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice got an array of length n as a birthday present once again! This is the third year in a row!
And what is more disappointing, it is overwhelmengly boring, filled entirely with zeros. Bob decided to apply some changes to the array to cheer up Alice.
Bob has chosen m changes of the following form. For some integer numbers x and d, he chooses an arbitrary position i (1 ≤ i ≤ n) and for every j ∈ [1, n] adds x + d ⋅ dist(i, j) to the value of the j-th cell. dist(i, j) is the distance between positions i and j (i.e. dist(i, j) = |i - j|, where |x| is an absolute value of x).
For example, if Alice currently has an array [2, 1, 2, 2] and Bob chooses position 3 for x = -1 and d = 2 then the array will become [2 - 1 + 2 ⋅ 2,~1 - 1 + 2 ⋅ 1,~2 - 1 + 2 ⋅ 0,~2 - 1 + 2 ⋅ 1] = [5, 2, 1, 3]. Note that Bob can't choose position i outside of the array (that is, smaller than 1 or greater than n).
Alice will be the happiest when the elements of the array are as big as possible. Bob claimed that the arithmetic mean value of the elements will work fine as a metric.
What is the maximum arithmetic mean value Bob can achieve?
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of elements of the array and the number of changes.
Each of the next m lines contains two integers x_i and d_i (-10^3 ≤ x_i, d_i ≤ 10^3) — the parameters for the i-th change.
Output
Print the maximal average arithmetic mean of the elements Bob can achieve.
Your answer is considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Examples
Input
2 3
-1 3
0 0
-1 -4
Output
-2.500000000000000
Input
3 2
0 2
5 0
Output
7.000000000000000 | instruction | 0 | 4,163 | 12 | 8,326 |
Tags: greedy, math
Correct Solution:
```
n,m = map(int,input().split())
s=0
a = n*(n-1)//2
nHalf = n//2
b = nHalf**2
if n%2:
b+=nHalf
for i in range(m):
x,y = map(int,input().split())
s+=n*x
s+=y*(a if y>0 else b)
print(s/n)
``` | output | 1 | 4,163 | 12 | 8,327 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice got an array of length n as a birthday present once again! This is the third year in a row!
And what is more disappointing, it is overwhelmengly boring, filled entirely with zeros. Bob decided to apply some changes to the array to cheer up Alice.
Bob has chosen m changes of the following form. For some integer numbers x and d, he chooses an arbitrary position i (1 ≤ i ≤ n) and for every j ∈ [1, n] adds x + d ⋅ dist(i, j) to the value of the j-th cell. dist(i, j) is the distance between positions i and j (i.e. dist(i, j) = |i - j|, where |x| is an absolute value of x).
For example, if Alice currently has an array [2, 1, 2, 2] and Bob chooses position 3 for x = -1 and d = 2 then the array will become [2 - 1 + 2 ⋅ 2,~1 - 1 + 2 ⋅ 1,~2 - 1 + 2 ⋅ 0,~2 - 1 + 2 ⋅ 1] = [5, 2, 1, 3]. Note that Bob can't choose position i outside of the array (that is, smaller than 1 or greater than n).
Alice will be the happiest when the elements of the array are as big as possible. Bob claimed that the arithmetic mean value of the elements will work fine as a metric.
What is the maximum arithmetic mean value Bob can achieve?
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of elements of the array and the number of changes.
Each of the next m lines contains two integers x_i and d_i (-10^3 ≤ x_i, d_i ≤ 10^3) — the parameters for the i-th change.
Output
Print the maximal average arithmetic mean of the elements Bob can achieve.
Your answer is considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Examples
Input
2 3
-1 3
0 0
-1 -4
Output
-2.500000000000000
Input
3 2
0 2
5 0
Output
7.000000000000000 | instruction | 0 | 4,164 | 12 | 8,328 |
Tags: greedy, math
Correct Solution:
```
def sum_to_n(n):
return n * (n + 1) // 2
(n, m) = map(int, input().split())
mid = 0
if n % 2 == 1:
mid = 2 * sum_to_n(n // 2)
else:
mid = 2 * sum_to_n(n // 2) - n // 2
edge = sum_to_n(n - 1)
sum = 0
for i in range(m):
(x, d) = map(int, input().split())
sum += x * n
if d > 0:
sum += edge * d
else:
sum += mid * d
print(sum / n)
``` | output | 1 | 4,164 | 12 | 8,329 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice got an array of length n as a birthday present once again! This is the third year in a row!
And what is more disappointing, it is overwhelmengly boring, filled entirely with zeros. Bob decided to apply some changes to the array to cheer up Alice.
Bob has chosen m changes of the following form. For some integer numbers x and d, he chooses an arbitrary position i (1 ≤ i ≤ n) and for every j ∈ [1, n] adds x + d ⋅ dist(i, j) to the value of the j-th cell. dist(i, j) is the distance between positions i and j (i.e. dist(i, j) = |i - j|, where |x| is an absolute value of x).
For example, if Alice currently has an array [2, 1, 2, 2] and Bob chooses position 3 for x = -1 and d = 2 then the array will become [2 - 1 + 2 ⋅ 2,~1 - 1 + 2 ⋅ 1,~2 - 1 + 2 ⋅ 0,~2 - 1 + 2 ⋅ 1] = [5, 2, 1, 3]. Note that Bob can't choose position i outside of the array (that is, smaller than 1 or greater than n).
Alice will be the happiest when the elements of the array are as big as possible. Bob claimed that the arithmetic mean value of the elements will work fine as a metric.
What is the maximum arithmetic mean value Bob can achieve?
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of elements of the array and the number of changes.
Each of the next m lines contains two integers x_i and d_i (-10^3 ≤ x_i, d_i ≤ 10^3) — the parameters for the i-th change.
Output
Print the maximal average arithmetic mean of the elements Bob can achieve.
Your answer is considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Examples
Input
2 3
-1 3
0 0
-1 -4
Output
-2.500000000000000
Input
3 2
0 2
5 0
Output
7.000000000000000
Submitted Solution:
```
n, m = [int(i) for i in input().split()]
max_sum = (n * (n - 1)) // 2
min_sum = ((n - 1) // 2 + 1) * ((n - 1) // 2) // 2 + (n - 1 - (n - 1) // 2 + 1) * (n - 1 - (n - 1) // 2) // 2
ans = 0
#print(n, max_sum, min_sum)
for i in range(m):
data = [int(j) for j in input().split()]
if data[1] > 0:
wk1 = max_sum
else:
wk1 = min_sum
ans += data[0] * n + data[1] * wk1
print(ans / n)
``` | instruction | 0 | 4,165 | 12 | 8,330 |
Yes | output | 1 | 4,165 | 12 | 8,331 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice got an array of length n as a birthday present once again! This is the third year in a row!
And what is more disappointing, it is overwhelmengly boring, filled entirely with zeros. Bob decided to apply some changes to the array to cheer up Alice.
Bob has chosen m changes of the following form. For some integer numbers x and d, he chooses an arbitrary position i (1 ≤ i ≤ n) and for every j ∈ [1, n] adds x + d ⋅ dist(i, j) to the value of the j-th cell. dist(i, j) is the distance between positions i and j (i.e. dist(i, j) = |i - j|, where |x| is an absolute value of x).
For example, if Alice currently has an array [2, 1, 2, 2] and Bob chooses position 3 for x = -1 and d = 2 then the array will become [2 - 1 + 2 ⋅ 2,~1 - 1 + 2 ⋅ 1,~2 - 1 + 2 ⋅ 0,~2 - 1 + 2 ⋅ 1] = [5, 2, 1, 3]. Note that Bob can't choose position i outside of the array (that is, smaller than 1 or greater than n).
Alice will be the happiest when the elements of the array are as big as possible. Bob claimed that the arithmetic mean value of the elements will work fine as a metric.
What is the maximum arithmetic mean value Bob can achieve?
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of elements of the array and the number of changes.
Each of the next m lines contains two integers x_i and d_i (-10^3 ≤ x_i, d_i ≤ 10^3) — the parameters for the i-th change.
Output
Print the maximal average arithmetic mean of the elements Bob can achieve.
Your answer is considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Examples
Input
2 3
-1 3
0 0
-1 -4
Output
-2.500000000000000
Input
3 2
0 2
5 0
Output
7.000000000000000
Submitted Solution:
```
#Bhargey Mehta (Junior)
#DA-IICT, Gandhinagar
import sys, math, queue
#sys.stdin = open('input.txt', 'r')
MOD = 998244353
sys.setrecursionlimit(1000000)
n, m = map(int, input().split())
x, y, z = 0, 0, 0
for i in range(m):
xi, di = map(int, input().split())
x += xi
if di > 0: y += di
else: z += di
mid = n//2
a = [x for i in range(n)]
for i in range(n):
a[i] += i*y + abs(mid-i)*z
print(sum(a)/n)
``` | instruction | 0 | 4,166 | 12 | 8,332 |
Yes | output | 1 | 4,166 | 12 | 8,333 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice got an array of length n as a birthday present once again! This is the third year in a row!
And what is more disappointing, it is overwhelmengly boring, filled entirely with zeros. Bob decided to apply some changes to the array to cheer up Alice.
Bob has chosen m changes of the following form. For some integer numbers x and d, he chooses an arbitrary position i (1 ≤ i ≤ n) and for every j ∈ [1, n] adds x + d ⋅ dist(i, j) to the value of the j-th cell. dist(i, j) is the distance between positions i and j (i.e. dist(i, j) = |i - j|, where |x| is an absolute value of x).
For example, if Alice currently has an array [2, 1, 2, 2] and Bob chooses position 3 for x = -1 and d = 2 then the array will become [2 - 1 + 2 ⋅ 2,~1 - 1 + 2 ⋅ 1,~2 - 1 + 2 ⋅ 0,~2 - 1 + 2 ⋅ 1] = [5, 2, 1, 3]. Note that Bob can't choose position i outside of the array (that is, smaller than 1 or greater than n).
Alice will be the happiest when the elements of the array are as big as possible. Bob claimed that the arithmetic mean value of the elements will work fine as a metric.
What is the maximum arithmetic mean value Bob can achieve?
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of elements of the array and the number of changes.
Each of the next m lines contains two integers x_i and d_i (-10^3 ≤ x_i, d_i ≤ 10^3) — the parameters for the i-th change.
Output
Print the maximal average arithmetic mean of the elements Bob can achieve.
Your answer is considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Examples
Input
2 3
-1 3
0 0
-1 -4
Output
-2.500000000000000
Input
3 2
0 2
5 0
Output
7.000000000000000
Submitted Solution:
```
n,m=map(int,input().split())
d=(n*(n-1))//2
d1=(n-1)//2
d1=d1*(d1+1)+(1-n%2)*n//2
#print(d,d1)
s=0
for i in range(m):
x,y=map(int,input().split())
s+=n*x
if y>0:
s+=d*y
else:
s+=d1*y
print(s/n)
``` | instruction | 0 | 4,167 | 12 | 8,334 |
Yes | output | 1 | 4,167 | 12 | 8,335 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice got an array of length n as a birthday present once again! This is the third year in a row!
And what is more disappointing, it is overwhelmengly boring, filled entirely with zeros. Bob decided to apply some changes to the array to cheer up Alice.
Bob has chosen m changes of the following form. For some integer numbers x and d, he chooses an arbitrary position i (1 ≤ i ≤ n) and for every j ∈ [1, n] adds x + d ⋅ dist(i, j) to the value of the j-th cell. dist(i, j) is the distance between positions i and j (i.e. dist(i, j) = |i - j|, where |x| is an absolute value of x).
For example, if Alice currently has an array [2, 1, 2, 2] and Bob chooses position 3 for x = -1 and d = 2 then the array will become [2 - 1 + 2 ⋅ 2,~1 - 1 + 2 ⋅ 1,~2 - 1 + 2 ⋅ 0,~2 - 1 + 2 ⋅ 1] = [5, 2, 1, 3]. Note that Bob can't choose position i outside of the array (that is, smaller than 1 or greater than n).
Alice will be the happiest when the elements of the array are as big as possible. Bob claimed that the arithmetic mean value of the elements will work fine as a metric.
What is the maximum arithmetic mean value Bob can achieve?
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of elements of the array and the number of changes.
Each of the next m lines contains two integers x_i and d_i (-10^3 ≤ x_i, d_i ≤ 10^3) — the parameters for the i-th change.
Output
Print the maximal average arithmetic mean of the elements Bob can achieve.
Your answer is considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Examples
Input
2 3
-1 3
0 0
-1 -4
Output
-2.500000000000000
Input
3 2
0 2
5 0
Output
7.000000000000000
Submitted Solution:
```
import sys
input = sys.stdin.readline
n, m = map(int, input().split())
info = [list(map(int, input().split())) for i in range(m)]
ans = 0
tmp1 = (n - 1) // 2
tmp2 = -((-(n - 1)) // 2)
for x, d in info:
ans += n * x
if d > 0:
ans += d * (n - 1) * (n) // 2
if d < 0:
ans += d * (tmp1) * (tmp1 + 1) // 2
ans += d * (tmp2) * (tmp2 + 1) // 2
print(ans / n)
``` | instruction | 0 | 4,168 | 12 | 8,336 |
Yes | output | 1 | 4,168 | 12 | 8,337 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice got an array of length n as a birthday present once again! This is the third year in a row!
And what is more disappointing, it is overwhelmengly boring, filled entirely with zeros. Bob decided to apply some changes to the array to cheer up Alice.
Bob has chosen m changes of the following form. For some integer numbers x and d, he chooses an arbitrary position i (1 ≤ i ≤ n) and for every j ∈ [1, n] adds x + d ⋅ dist(i, j) to the value of the j-th cell. dist(i, j) is the distance between positions i and j (i.e. dist(i, j) = |i - j|, where |x| is an absolute value of x).
For example, if Alice currently has an array [2, 1, 2, 2] and Bob chooses position 3 for x = -1 and d = 2 then the array will become [2 - 1 + 2 ⋅ 2,~1 - 1 + 2 ⋅ 1,~2 - 1 + 2 ⋅ 0,~2 - 1 + 2 ⋅ 1] = [5, 2, 1, 3]. Note that Bob can't choose position i outside of the array (that is, smaller than 1 or greater than n).
Alice will be the happiest when the elements of the array are as big as possible. Bob claimed that the arithmetic mean value of the elements will work fine as a metric.
What is the maximum arithmetic mean value Bob can achieve?
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of elements of the array and the number of changes.
Each of the next m lines contains two integers x_i and d_i (-10^3 ≤ x_i, d_i ≤ 10^3) — the parameters for the i-th change.
Output
Print the maximal average arithmetic mean of the elements Bob can achieve.
Your answer is considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Examples
Input
2 3
-1 3
0 0
-1 -4
Output
-2.500000000000000
Input
3 2
0 2
5 0
Output
7.000000000000000
Submitted Solution:
```
n, m = map(int, input().split())
k, x, y = 0, (n - 1) / 2, sum(abs(i - (n + 1) // 2) for i in range(1, n + 1)) / n
for i in range(m):
a, b = map(int, input().split())
k += a + (b * (x if b > 0 else y))
print(k)
``` | instruction | 0 | 4,169 | 12 | 8,338 |
No | output | 1 | 4,169 | 12 | 8,339 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice got an array of length n as a birthday present once again! This is the third year in a row!
And what is more disappointing, it is overwhelmengly boring, filled entirely with zeros. Bob decided to apply some changes to the array to cheer up Alice.
Bob has chosen m changes of the following form. For some integer numbers x and d, he chooses an arbitrary position i (1 ≤ i ≤ n) and for every j ∈ [1, n] adds x + d ⋅ dist(i, j) to the value of the j-th cell. dist(i, j) is the distance between positions i and j (i.e. dist(i, j) = |i - j|, where |x| is an absolute value of x).
For example, if Alice currently has an array [2, 1, 2, 2] and Bob chooses position 3 for x = -1 and d = 2 then the array will become [2 - 1 + 2 ⋅ 2,~1 - 1 + 2 ⋅ 1,~2 - 1 + 2 ⋅ 0,~2 - 1 + 2 ⋅ 1] = [5, 2, 1, 3]. Note that Bob can't choose position i outside of the array (that is, smaller than 1 or greater than n).
Alice will be the happiest when the elements of the array are as big as possible. Bob claimed that the arithmetic mean value of the elements will work fine as a metric.
What is the maximum arithmetic mean value Bob can achieve?
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of elements of the array and the number of changes.
Each of the next m lines contains two integers x_i and d_i (-10^3 ≤ x_i, d_i ≤ 10^3) — the parameters for the i-th change.
Output
Print the maximal average arithmetic mean of the elements Bob can achieve.
Your answer is considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Examples
Input
2 3
-1 3
0 0
-1 -4
Output
-2.500000000000000
Input
3 2
0 2
5 0
Output
7.000000000000000
Submitted Solution:
```
[n, m] = input().split()
n, m = int(n), int(m)
avg = 0
for i in range(m):
[x, d] = input().split()
x, d = int(x), int(d)
avg += n * x
if n > 1:
if d > 0:
avg += d * n * (n - 1) / 2
else:
avg += d * ((n - 1) / 2)**2
if n % 2 == 0:
avg += d * n / 2
print(float(avg) / n)
``` | instruction | 0 | 4,170 | 12 | 8,340 |
No | output | 1 | 4,170 | 12 | 8,341 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice got an array of length n as a birthday present once again! This is the third year in a row!
And what is more disappointing, it is overwhelmengly boring, filled entirely with zeros. Bob decided to apply some changes to the array to cheer up Alice.
Bob has chosen m changes of the following form. For some integer numbers x and d, he chooses an arbitrary position i (1 ≤ i ≤ n) and for every j ∈ [1, n] adds x + d ⋅ dist(i, j) to the value of the j-th cell. dist(i, j) is the distance between positions i and j (i.e. dist(i, j) = |i - j|, where |x| is an absolute value of x).
For example, if Alice currently has an array [2, 1, 2, 2] and Bob chooses position 3 for x = -1 and d = 2 then the array will become [2 - 1 + 2 ⋅ 2,~1 - 1 + 2 ⋅ 1,~2 - 1 + 2 ⋅ 0,~2 - 1 + 2 ⋅ 1] = [5, 2, 1, 3]. Note that Bob can't choose position i outside of the array (that is, smaller than 1 or greater than n).
Alice will be the happiest when the elements of the array are as big as possible. Bob claimed that the arithmetic mean value of the elements will work fine as a metric.
What is the maximum arithmetic mean value Bob can achieve?
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of elements of the array and the number of changes.
Each of the next m lines contains two integers x_i and d_i (-10^3 ≤ x_i, d_i ≤ 10^3) — the parameters for the i-th change.
Output
Print the maximal average arithmetic mean of the elements Bob can achieve.
Your answer is considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Examples
Input
2 3
-1 3
0 0
-1 -4
Output
-2.500000000000000
Input
3 2
0 2
5 0
Output
7.000000000000000
Submitted Solution:
```
n, m = map(int, input().split())
res = 0
mx = (n-1)*n//2
mn = 0
if n&1:
mn = (n//2)*(n/2+1)
else:
mn = n*n//4
for i in range(m):
x, d = map(int, input().split())
res += x*n
if d > 0:
res += mx*d
else:
res += mn*d
print('%.10f'%(res/n))
``` | instruction | 0 | 4,171 | 12 | 8,342 |
No | output | 1 | 4,171 | 12 | 8,343 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice got an array of length n as a birthday present once again! This is the third year in a row!
And what is more disappointing, it is overwhelmengly boring, filled entirely with zeros. Bob decided to apply some changes to the array to cheer up Alice.
Bob has chosen m changes of the following form. For some integer numbers x and d, he chooses an arbitrary position i (1 ≤ i ≤ n) and for every j ∈ [1, n] adds x + d ⋅ dist(i, j) to the value of the j-th cell. dist(i, j) is the distance between positions i and j (i.e. dist(i, j) = |i - j|, where |x| is an absolute value of x).
For example, if Alice currently has an array [2, 1, 2, 2] and Bob chooses position 3 for x = -1 and d = 2 then the array will become [2 - 1 + 2 ⋅ 2,~1 - 1 + 2 ⋅ 1,~2 - 1 + 2 ⋅ 0,~2 - 1 + 2 ⋅ 1] = [5, 2, 1, 3]. Note that Bob can't choose position i outside of the array (that is, smaller than 1 or greater than n).
Alice will be the happiest when the elements of the array are as big as possible. Bob claimed that the arithmetic mean value of the elements will work fine as a metric.
What is the maximum arithmetic mean value Bob can achieve?
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of elements of the array and the number of changes.
Each of the next m lines contains two integers x_i and d_i (-10^3 ≤ x_i, d_i ≤ 10^3) — the parameters for the i-th change.
Output
Print the maximal average arithmetic mean of the elements Bob can achieve.
Your answer is considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Examples
Input
2 3
-1 3
0 0
-1 -4
Output
-2.500000000000000
Input
3 2
0 2
5 0
Output
7.000000000000000
Submitted Solution:
```
from decimal import *
n, m = [int(_) for _ in input().split()]
n2 = n/2
getcontext().prec = 6000
avg = Decimal(0.0)
negative = Decimal(0.0)
positive = Decimal(0.0)
for c in range(m):
x, d = [int(_) for _ in input().split()]
avg += Decimal(x) * Decimal(n)
if d < 0:
negative += d
else:
positive += d
# Fix the negative part
avg += Decimal(n2*(n2+1)) * negative
if n % 2 == 0:
avg -= Decimal(n2) * negative
# Fix the positive part
avg += Decimal(n *(n-1) / 2) * positive
print ("%.20lf" % (avg / Decimal(n)))
``` | instruction | 0 | 4,172 | 12 | 8,344 |
No | output | 1 | 4,172 | 12 | 8,345 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p=[p_1, p_2, …, p_n] of integers from 1 to n. Let's call the number m (1 ≤ m ≤ n) beautiful, if there exists two indices l, r (1 ≤ l ≤ r ≤ n), such that the numbers [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m.
For example, let p = [4, 5, 1, 3, 2, 6]. In this case, the numbers 1, 3, 5, 6 are beautiful and 2, 4 are not. It is because:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 5 we will have a permutation [1, 3, 2] for m = 3;
* if l = 1 and r = 5 we will have a permutation [4, 5, 1, 3, 2] for m = 5;
* if l = 1 and r = 6 we will have a permutation [4, 5, 1, 3, 2, 6] for m = 6;
* it is impossible to take some l and r, such that [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m for m = 2 and for m = 4.
You are given a permutation p=[p_1, p_2, …, p_n]. For all m (1 ≤ m ≤ n) determine if it is a beautiful number or not.
Input
The first line contains the only integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. The next lines contain the description of test cases.
The first line of a test case contains a number n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the given permutation p. The next line contains n integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n, all p_i are different) — the given permutation p.
It is guaranteed, that the sum of n from all test cases in the input doesn't exceed 2 ⋅ 10^5.
Output
Print t lines — the answers to test cases in the order they are given in the input.
The answer to a test case is the string of length n, there the i-th character is equal to 1 if i is a beautiful number and is equal to 0 if i is not a beautiful number.
Example
Input
3
6
4 5 1 3 2 6
5
5 3 1 2 4
4
1 4 3 2
Output
101011
11111
1001
Note
The first test case is described in the problem statement.
In the second test case all numbers from 1 to 5 are beautiful:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 4 we will have a permutation [1, 2] for m = 2;
* if l = 2 and r = 4 we will have a permutation [3, 1, 2] for m = 3;
* if l = 2 and r = 5 we will have a permutation [3, 1, 2, 4] for m = 4;
* if l = 1 and r = 5 we will have a permutation [5, 3, 1, 2, 4] for m = 5. | instruction | 0 | 4,287 | 12 | 8,574 |
Tags: data structures, implementation, math, two pointers
Correct Solution:
```
t=int(input())
for i in range(t):
n=int(input())
b=list(map(int,input().split()))
c=[0]*(n+1)
d=[]
for j in range(n):
c[b[j]]=j
q=-1
r=100000000
for j in range(1,n+1):
q=max(q,c[j])
r=min(r,c[j])
if (q-r+1)==j:
d.append("1")
else:
d.append("0")
print("".join(d))
``` | output | 1 | 4,287 | 12 | 8,575 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p=[p_1, p_2, …, p_n] of integers from 1 to n. Let's call the number m (1 ≤ m ≤ n) beautiful, if there exists two indices l, r (1 ≤ l ≤ r ≤ n), such that the numbers [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m.
For example, let p = [4, 5, 1, 3, 2, 6]. In this case, the numbers 1, 3, 5, 6 are beautiful and 2, 4 are not. It is because:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 5 we will have a permutation [1, 3, 2] for m = 3;
* if l = 1 and r = 5 we will have a permutation [4, 5, 1, 3, 2] for m = 5;
* if l = 1 and r = 6 we will have a permutation [4, 5, 1, 3, 2, 6] for m = 6;
* it is impossible to take some l and r, such that [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m for m = 2 and for m = 4.
You are given a permutation p=[p_1, p_2, …, p_n]. For all m (1 ≤ m ≤ n) determine if it is a beautiful number or not.
Input
The first line contains the only integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. The next lines contain the description of test cases.
The first line of a test case contains a number n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the given permutation p. The next line contains n integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n, all p_i are different) — the given permutation p.
It is guaranteed, that the sum of n from all test cases in the input doesn't exceed 2 ⋅ 10^5.
Output
Print t lines — the answers to test cases in the order they are given in the input.
The answer to a test case is the string of length n, there the i-th character is equal to 1 if i is a beautiful number and is equal to 0 if i is not a beautiful number.
Example
Input
3
6
4 5 1 3 2 6
5
5 3 1 2 4
4
1 4 3 2
Output
101011
11111
1001
Note
The first test case is described in the problem statement.
In the second test case all numbers from 1 to 5 are beautiful:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 4 we will have a permutation [1, 2] for m = 2;
* if l = 2 and r = 4 we will have a permutation [3, 1, 2] for m = 3;
* if l = 2 and r = 5 we will have a permutation [3, 1, 2, 4] for m = 4;
* if l = 1 and r = 5 we will have a permutation [5, 3, 1, 2, 4] for m = 5. | instruction | 0 | 4,288 | 12 | 8,576 |
Tags: data structures, implementation, math, two pointers
Correct Solution:
```
from collections import defaultdict
t = int(input())
for i in range(t):
n = int(input())
l = list(map(int,input().split()))
pair = defaultdict(int)
for j in range(n):
pair[l[j]]=j
minindex = pair[1]
maxindex = pair[1]
output = "1"
for j in range(2,n+1):
index = pair[j]
if(index<minindex):
minindex = index
if(index>maxindex):
maxindex = index
if(maxindex-minindex<j):
output+="1"
else:
output+="0"
# print(minindex,maxindex)
print(output)
``` | output | 1 | 4,288 | 12 | 8,577 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p=[p_1, p_2, …, p_n] of integers from 1 to n. Let's call the number m (1 ≤ m ≤ n) beautiful, if there exists two indices l, r (1 ≤ l ≤ r ≤ n), such that the numbers [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m.
For example, let p = [4, 5, 1, 3, 2, 6]. In this case, the numbers 1, 3, 5, 6 are beautiful and 2, 4 are not. It is because:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 5 we will have a permutation [1, 3, 2] for m = 3;
* if l = 1 and r = 5 we will have a permutation [4, 5, 1, 3, 2] for m = 5;
* if l = 1 and r = 6 we will have a permutation [4, 5, 1, 3, 2, 6] for m = 6;
* it is impossible to take some l and r, such that [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m for m = 2 and for m = 4.
You are given a permutation p=[p_1, p_2, …, p_n]. For all m (1 ≤ m ≤ n) determine if it is a beautiful number or not.
Input
The first line contains the only integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. The next lines contain the description of test cases.
The first line of a test case contains a number n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the given permutation p. The next line contains n integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n, all p_i are different) — the given permutation p.
It is guaranteed, that the sum of n from all test cases in the input doesn't exceed 2 ⋅ 10^5.
Output
Print t lines — the answers to test cases in the order they are given in the input.
The answer to a test case is the string of length n, there the i-th character is equal to 1 if i is a beautiful number and is equal to 0 if i is not a beautiful number.
Example
Input
3
6
4 5 1 3 2 6
5
5 3 1 2 4
4
1 4 3 2
Output
101011
11111
1001
Note
The first test case is described in the problem statement.
In the second test case all numbers from 1 to 5 are beautiful:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 4 we will have a permutation [1, 2] for m = 2;
* if l = 2 and r = 4 we will have a permutation [3, 1, 2] for m = 3;
* if l = 2 and r = 5 we will have a permutation [3, 1, 2, 4] for m = 4;
* if l = 1 and r = 5 we will have a permutation [5, 3, 1, 2, 4] for m = 5. | instruction | 0 | 4,289 | 12 | 8,578 |
Tags: data structures, implementation, math, two pointers
Correct Solution:
```
from __future__ import division, print_function
from io import BytesIO, IOBase
import os,sys,math,heapq,copy
from collections import defaultdict,deque
from bisect import bisect_left,bisect_right
from functools import cmp_to_key
from itertools import permutations,combinations,combinations_with_replacement
# <fastio>
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# </fastio>
# sys.setrecursionlimit(10**6)
mod=1000000007
# Reading Single Input
def get_int(): return int(sys.stdin.readline().strip())
def get_str(): return sys.stdin.readline().strip()
def get_float(): return float(sys.stdin.readline().strip())
# Reading Multiple Inputs
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def get_strs(): return map(str, sys.stdin.readline().strip().split())
def get_floats(): return map(float, sys.stdin.readline().strip().split())
# Reading List Of Inputs
def list_ints(): return list(map(int, sys.stdin.readline().strip().split()))
def list_strs(): return list(map(str, sys.stdin.readline().strip().split()))
def list_floats(): return list(map(float, sys.stdin.readline().strip().split()))
# ------------------------------------------------------------------------------------- #
def main():
t=int(input())
for _ in range(t):
n=int(input())
l=list_ints()
l=[[l[i],i] for i in range(n)]
l.sort()
minimum=math.inf
maximum=-math.inf
for i in range(n):
minimum=min(minimum,l[i][1])
maximum=max(maximum,l[i][1])
if((maximum-minimum)==i):
print(1,end='')
else:
print(0,end='')
print()
if __name__ == "__main__":
# sys.stdin=open('Input.txt','r')
# sys.stdout=open('Output.txt','w')
main()
``` | output | 1 | 4,289 | 12 | 8,579 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p=[p_1, p_2, …, p_n] of integers from 1 to n. Let's call the number m (1 ≤ m ≤ n) beautiful, if there exists two indices l, r (1 ≤ l ≤ r ≤ n), such that the numbers [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m.
For example, let p = [4, 5, 1, 3, 2, 6]. In this case, the numbers 1, 3, 5, 6 are beautiful and 2, 4 are not. It is because:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 5 we will have a permutation [1, 3, 2] for m = 3;
* if l = 1 and r = 5 we will have a permutation [4, 5, 1, 3, 2] for m = 5;
* if l = 1 and r = 6 we will have a permutation [4, 5, 1, 3, 2, 6] for m = 6;
* it is impossible to take some l and r, such that [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m for m = 2 and for m = 4.
You are given a permutation p=[p_1, p_2, …, p_n]. For all m (1 ≤ m ≤ n) determine if it is a beautiful number or not.
Input
The first line contains the only integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. The next lines contain the description of test cases.
The first line of a test case contains a number n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the given permutation p. The next line contains n integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n, all p_i are different) — the given permutation p.
It is guaranteed, that the sum of n from all test cases in the input doesn't exceed 2 ⋅ 10^5.
Output
Print t lines — the answers to test cases in the order they are given in the input.
The answer to a test case is the string of length n, there the i-th character is equal to 1 if i is a beautiful number and is equal to 0 if i is not a beautiful number.
Example
Input
3
6
4 5 1 3 2 6
5
5 3 1 2 4
4
1 4 3 2
Output
101011
11111
1001
Note
The first test case is described in the problem statement.
In the second test case all numbers from 1 to 5 are beautiful:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 4 we will have a permutation [1, 2] for m = 2;
* if l = 2 and r = 4 we will have a permutation [3, 1, 2] for m = 3;
* if l = 2 and r = 5 we will have a permutation [3, 1, 2, 4] for m = 4;
* if l = 1 and r = 5 we will have a permutation [5, 3, 1, 2, 4] for m = 5. | instruction | 0 | 4,290 | 12 | 8,580 |
Tags: data structures, implementation, math, two pointers
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
p=list(map(int,input().split()))
inv=[0]*(n+1)
for i in range(n):
inv[p[i]]=i
out=""
mx,mn = 0,n
for i in range(1,n+1):
mx,mn=max(inv[i],mx),min(inv[i],mn)
out+="1" if mx-mn+1 == i else "0"
print(out)
``` | output | 1 | 4,290 | 12 | 8,581 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p=[p_1, p_2, …, p_n] of integers from 1 to n. Let's call the number m (1 ≤ m ≤ n) beautiful, if there exists two indices l, r (1 ≤ l ≤ r ≤ n), such that the numbers [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m.
For example, let p = [4, 5, 1, 3, 2, 6]. In this case, the numbers 1, 3, 5, 6 are beautiful and 2, 4 are not. It is because:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 5 we will have a permutation [1, 3, 2] for m = 3;
* if l = 1 and r = 5 we will have a permutation [4, 5, 1, 3, 2] for m = 5;
* if l = 1 and r = 6 we will have a permutation [4, 5, 1, 3, 2, 6] for m = 6;
* it is impossible to take some l and r, such that [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m for m = 2 and for m = 4.
You are given a permutation p=[p_1, p_2, …, p_n]. For all m (1 ≤ m ≤ n) determine if it is a beautiful number or not.
Input
The first line contains the only integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. The next lines contain the description of test cases.
The first line of a test case contains a number n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the given permutation p. The next line contains n integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n, all p_i are different) — the given permutation p.
It is guaranteed, that the sum of n from all test cases in the input doesn't exceed 2 ⋅ 10^5.
Output
Print t lines — the answers to test cases in the order they are given in the input.
The answer to a test case is the string of length n, there the i-th character is equal to 1 if i is a beautiful number and is equal to 0 if i is not a beautiful number.
Example
Input
3
6
4 5 1 3 2 6
5
5 3 1 2 4
4
1 4 3 2
Output
101011
11111
1001
Note
The first test case is described in the problem statement.
In the second test case all numbers from 1 to 5 are beautiful:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 4 we will have a permutation [1, 2] for m = 2;
* if l = 2 and r = 4 we will have a permutation [3, 1, 2] for m = 3;
* if l = 2 and r = 5 we will have a permutation [3, 1, 2, 4] for m = 4;
* if l = 1 and r = 5 we will have a permutation [5, 3, 1, 2, 4] for m = 5. | instruction | 0 | 4,291 | 12 | 8,582 |
Tags: data structures, implementation, math, two pointers
Correct Solution:
```
for j in range(int(input())):
n = int(input())
c = list(map(int,input().split()))
index = [0]*n
for i in range(n):
index[c[i]-1]=i
ma = 0
mi = n
ans = ['0']*n
# print(index)
for k in range(n):
ma = max(index[k],ma)
mi = min(index[k],mi)
#print(k,mr,index[k]-index[0])
if ma-mi<=k:
ans[k]='1'
print(''.join(ans))
``` | output | 1 | 4,291 | 12 | 8,583 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p=[p_1, p_2, …, p_n] of integers from 1 to n. Let's call the number m (1 ≤ m ≤ n) beautiful, if there exists two indices l, r (1 ≤ l ≤ r ≤ n), such that the numbers [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m.
For example, let p = [4, 5, 1, 3, 2, 6]. In this case, the numbers 1, 3, 5, 6 are beautiful and 2, 4 are not. It is because:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 5 we will have a permutation [1, 3, 2] for m = 3;
* if l = 1 and r = 5 we will have a permutation [4, 5, 1, 3, 2] for m = 5;
* if l = 1 and r = 6 we will have a permutation [4, 5, 1, 3, 2, 6] for m = 6;
* it is impossible to take some l and r, such that [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m for m = 2 and for m = 4.
You are given a permutation p=[p_1, p_2, …, p_n]. For all m (1 ≤ m ≤ n) determine if it is a beautiful number or not.
Input
The first line contains the only integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. The next lines contain the description of test cases.
The first line of a test case contains a number n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the given permutation p. The next line contains n integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n, all p_i are different) — the given permutation p.
It is guaranteed, that the sum of n from all test cases in the input doesn't exceed 2 ⋅ 10^5.
Output
Print t lines — the answers to test cases in the order they are given in the input.
The answer to a test case is the string of length n, there the i-th character is equal to 1 if i is a beautiful number and is equal to 0 if i is not a beautiful number.
Example
Input
3
6
4 5 1 3 2 6
5
5 3 1 2 4
4
1 4 3 2
Output
101011
11111
1001
Note
The first test case is described in the problem statement.
In the second test case all numbers from 1 to 5 are beautiful:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 4 we will have a permutation [1, 2] for m = 2;
* if l = 2 and r = 4 we will have a permutation [3, 1, 2] for m = 3;
* if l = 2 and r = 5 we will have a permutation [3, 1, 2, 4] for m = 4;
* if l = 1 and r = 5 we will have a permutation [5, 3, 1, 2, 4] for m = 5. | instruction | 0 | 4,292 | 12 | 8,584 |
Tags: data structures, implementation, math, two pointers
Correct Solution:
```
import sys,math,heapq,copy
from sys import stdin,stdout
from collections import defaultdict,deque
from bisect import bisect_left,bisect_right
from functools import cmp_to_key
from itertools import permutations,combinations,combinations_with_replacement
# sys.setrecursionlimit(10**6)
# sys.stdin=open('Input.txt','r')
# sys.stdout=open('Output.txt','w')
mod=1000000007
# Reading Single Input
def get_int(): return int(sys.stdin.readline().strip())
def get_str(): return sys.stdin.readline().strip()
def get_float(): return float(sys.stdin.readline().strip())
# Reading Multiple Inputs
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def get_strs(): return map(str, sys.stdin.readline().strip().split())
def get_floats(): return map(float, sys.stdin.readline().strip().split())
# Reading List Of Inputs
def list_ints(): return list(map(int, sys.stdin.readline().strip().split()))
def list_strs(): return list(map(str, sys.stdin.readline().strip().split()))
def list_floats(): return list(map(float, sys.stdin.readline().strip().split()))
# ------------------------------------------------------------------------------------- #
def print(value='',end='\n'):
stdout.write(str(value)+end)
t=get_int()
for _ in range(t):
n=get_int()
l=list_ints()
l=[[l[i],i] for i in range(n)]
l.sort()
minimum=math.inf
maximum=-math.inf
for i in range(n):
minimum=min(minimum,l[i][1])
maximum=max(maximum,l[i][1])
if((maximum-minimum)==i):
print(1,end='')
else:
print(0,end='')
print()
``` | output | 1 | 4,292 | 12 | 8,585 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p=[p_1, p_2, …, p_n] of integers from 1 to n. Let's call the number m (1 ≤ m ≤ n) beautiful, if there exists two indices l, r (1 ≤ l ≤ r ≤ n), such that the numbers [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m.
For example, let p = [4, 5, 1, 3, 2, 6]. In this case, the numbers 1, 3, 5, 6 are beautiful and 2, 4 are not. It is because:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 5 we will have a permutation [1, 3, 2] for m = 3;
* if l = 1 and r = 5 we will have a permutation [4, 5, 1, 3, 2] for m = 5;
* if l = 1 and r = 6 we will have a permutation [4, 5, 1, 3, 2, 6] for m = 6;
* it is impossible to take some l and r, such that [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m for m = 2 and for m = 4.
You are given a permutation p=[p_1, p_2, …, p_n]. For all m (1 ≤ m ≤ n) determine if it is a beautiful number or not.
Input
The first line contains the only integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. The next lines contain the description of test cases.
The first line of a test case contains a number n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the given permutation p. The next line contains n integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n, all p_i are different) — the given permutation p.
It is guaranteed, that the sum of n from all test cases in the input doesn't exceed 2 ⋅ 10^5.
Output
Print t lines — the answers to test cases in the order they are given in the input.
The answer to a test case is the string of length n, there the i-th character is equal to 1 if i is a beautiful number and is equal to 0 if i is not a beautiful number.
Example
Input
3
6
4 5 1 3 2 6
5
5 3 1 2 4
4
1 4 3 2
Output
101011
11111
1001
Note
The first test case is described in the problem statement.
In the second test case all numbers from 1 to 5 are beautiful:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 4 we will have a permutation [1, 2] for m = 2;
* if l = 2 and r = 4 we will have a permutation [3, 1, 2] for m = 3;
* if l = 2 and r = 5 we will have a permutation [3, 1, 2, 4] for m = 4;
* if l = 1 and r = 5 we will have a permutation [5, 3, 1, 2, 4] for m = 5. | instruction | 0 | 4,293 | 12 | 8,586 |
Tags: data structures, implementation, math, two pointers
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
aff = 0
positions = {}
l, r = n, 0
for i in input().split():
positions[int(i)-1] = aff
aff += 1
for i in range(n):
l = min(l, positions[i])
r = max(r, positions[i])
if r-l == i:
print("1", sep='', end='')
else:
print("0", sep='', end='')
print(end='\n')
``` | output | 1 | 4,293 | 12 | 8,587 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p=[p_1, p_2, …, p_n] of integers from 1 to n. Let's call the number m (1 ≤ m ≤ n) beautiful, if there exists two indices l, r (1 ≤ l ≤ r ≤ n), such that the numbers [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m.
For example, let p = [4, 5, 1, 3, 2, 6]. In this case, the numbers 1, 3, 5, 6 are beautiful and 2, 4 are not. It is because:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 5 we will have a permutation [1, 3, 2] for m = 3;
* if l = 1 and r = 5 we will have a permutation [4, 5, 1, 3, 2] for m = 5;
* if l = 1 and r = 6 we will have a permutation [4, 5, 1, 3, 2, 6] for m = 6;
* it is impossible to take some l and r, such that [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m for m = 2 and for m = 4.
You are given a permutation p=[p_1, p_2, …, p_n]. For all m (1 ≤ m ≤ n) determine if it is a beautiful number or not.
Input
The first line contains the only integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. The next lines contain the description of test cases.
The first line of a test case contains a number n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the given permutation p. The next line contains n integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n, all p_i are different) — the given permutation p.
It is guaranteed, that the sum of n from all test cases in the input doesn't exceed 2 ⋅ 10^5.
Output
Print t lines — the answers to test cases in the order they are given in the input.
The answer to a test case is the string of length n, there the i-th character is equal to 1 if i is a beautiful number and is equal to 0 if i is not a beautiful number.
Example
Input
3
6
4 5 1 3 2 6
5
5 3 1 2 4
4
1 4 3 2
Output
101011
11111
1001
Note
The first test case is described in the problem statement.
In the second test case all numbers from 1 to 5 are beautiful:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 4 we will have a permutation [1, 2] for m = 2;
* if l = 2 and r = 4 we will have a permutation [3, 1, 2] for m = 3;
* if l = 2 and r = 5 we will have a permutation [3, 1, 2, 4] for m = 4;
* if l = 1 and r = 5 we will have a permutation [5, 3, 1, 2, 4] for m = 5. | instruction | 0 | 4,294 | 12 | 8,588 |
Tags: data structures, implementation, math, two pointers
Correct Solution:
```
t = int(input())
while t:
t -= 1
mark = {}
n = int(input())
a = list(map(int, input().split()))
for i in range(n):
mark[a[i]] = i
l = r = mark[1]
ans = "1"
for i in range(2, n+1):
pos = mark[i]
if pos > l and pos < r and r-l+1 == i:
ans += "1"
elif pos < l and abs(pos-l) == 1 and r-pos+1 == i:
ans += "1"
l = pos
elif pos > r and abs(pos-r) == 1 and pos-l+1 == i:
ans += "1"
r = pos
elif pos < l:
l = pos
ans += "0"
elif pos > r:
r = pos
ans += "0"
else:
ans += "0"
print(ans)
``` | output | 1 | 4,294 | 12 | 8,589 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p=[p_1, p_2, …, p_n] of integers from 1 to n. Let's call the number m (1 ≤ m ≤ n) beautiful, if there exists two indices l, r (1 ≤ l ≤ r ≤ n), such that the numbers [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m.
For example, let p = [4, 5, 1, 3, 2, 6]. In this case, the numbers 1, 3, 5, 6 are beautiful and 2, 4 are not. It is because:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 5 we will have a permutation [1, 3, 2] for m = 3;
* if l = 1 and r = 5 we will have a permutation [4, 5, 1, 3, 2] for m = 5;
* if l = 1 and r = 6 we will have a permutation [4, 5, 1, 3, 2, 6] for m = 6;
* it is impossible to take some l and r, such that [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m for m = 2 and for m = 4.
You are given a permutation p=[p_1, p_2, …, p_n]. For all m (1 ≤ m ≤ n) determine if it is a beautiful number or not.
Input
The first line contains the only integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. The next lines contain the description of test cases.
The first line of a test case contains a number n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the given permutation p. The next line contains n integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n, all p_i are different) — the given permutation p.
It is guaranteed, that the sum of n from all test cases in the input doesn't exceed 2 ⋅ 10^5.
Output
Print t lines — the answers to test cases in the order they are given in the input.
The answer to a test case is the string of length n, there the i-th character is equal to 1 if i is a beautiful number and is equal to 0 if i is not a beautiful number.
Example
Input
3
6
4 5 1 3 2 6
5
5 3 1 2 4
4
1 4 3 2
Output
101011
11111
1001
Note
The first test case is described in the problem statement.
In the second test case all numbers from 1 to 5 are beautiful:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 4 we will have a permutation [1, 2] for m = 2;
* if l = 2 and r = 4 we will have a permutation [3, 1, 2] for m = 3;
* if l = 2 and r = 5 we will have a permutation [3, 1, 2, 4] for m = 4;
* if l = 1 and r = 5 we will have a permutation [5, 3, 1, 2, 4] for m = 5.
Submitted Solution:
```
# -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
for _ in range(INT()):
N = INT()
A = [a-1 for a in LIST()]
atoi = {}
for i, a in enumerate(A):
atoi[a] = i
l = INF
r = 0
ans = []
for a in range(N):
i = atoi[a]
l = min(l, i)
r = max(r, i)
seg = r - l
if seg == a:
ans.append('1')
else:
ans.append('0')
print(''.join(ans))
``` | instruction | 0 | 4,295 | 12 | 8,590 |
Yes | output | 1 | 4,295 | 12 | 8,591 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p=[p_1, p_2, …, p_n] of integers from 1 to n. Let's call the number m (1 ≤ m ≤ n) beautiful, if there exists two indices l, r (1 ≤ l ≤ r ≤ n), such that the numbers [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m.
For example, let p = [4, 5, 1, 3, 2, 6]. In this case, the numbers 1, 3, 5, 6 are beautiful and 2, 4 are not. It is because:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 5 we will have a permutation [1, 3, 2] for m = 3;
* if l = 1 and r = 5 we will have a permutation [4, 5, 1, 3, 2] for m = 5;
* if l = 1 and r = 6 we will have a permutation [4, 5, 1, 3, 2, 6] for m = 6;
* it is impossible to take some l and r, such that [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m for m = 2 and for m = 4.
You are given a permutation p=[p_1, p_2, …, p_n]. For all m (1 ≤ m ≤ n) determine if it is a beautiful number or not.
Input
The first line contains the only integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. The next lines contain the description of test cases.
The first line of a test case contains a number n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the given permutation p. The next line contains n integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n, all p_i are different) — the given permutation p.
It is guaranteed, that the sum of n from all test cases in the input doesn't exceed 2 ⋅ 10^5.
Output
Print t lines — the answers to test cases in the order they are given in the input.
The answer to a test case is the string of length n, there the i-th character is equal to 1 if i is a beautiful number and is equal to 0 if i is not a beautiful number.
Example
Input
3
6
4 5 1 3 2 6
5
5 3 1 2 4
4
1 4 3 2
Output
101011
11111
1001
Note
The first test case is described in the problem statement.
In the second test case all numbers from 1 to 5 are beautiful:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 4 we will have a permutation [1, 2] for m = 2;
* if l = 2 and r = 4 we will have a permutation [3, 1, 2] for m = 3;
* if l = 2 and r = 5 we will have a permutation [3, 1, 2, 4] for m = 4;
* if l = 1 and r = 5 we will have a permutation [5, 3, 1, 2, 4] for m = 5.
Submitted Solution:
```
def solve():
n = int(input())
num = [0] + [int(x) for x in input().split()]
pos = [0] * (n+1)
for i in range(1, n+1):
pos[num[i]] = i
can = [0] * (n+1)
visit = [0] * (n+1)
l, r = pos[1], pos[1]
tmp = 1
visit[1] = 1
can[1] = 1
for i in range(2, n+1):
while (pos[i] < l):
l -= 1
visit[num[l]] = 1
while (r < pos[i]):
r += 1
visit[num[r]] = 1
while (tmp < n and visit[tmp+1]): tmp += 1
if (tmp == i and r-l+1 == i):
can[i] = 1
print(*can[1:], sep = "")
t = int(input())
for i in range(t):
solve()
``` | instruction | 0 | 4,296 | 12 | 8,592 |
Yes | output | 1 | 4,296 | 12 | 8,593 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p=[p_1, p_2, …, p_n] of integers from 1 to n. Let's call the number m (1 ≤ m ≤ n) beautiful, if there exists two indices l, r (1 ≤ l ≤ r ≤ n), such that the numbers [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m.
For example, let p = [4, 5, 1, 3, 2, 6]. In this case, the numbers 1, 3, 5, 6 are beautiful and 2, 4 are not. It is because:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 5 we will have a permutation [1, 3, 2] for m = 3;
* if l = 1 and r = 5 we will have a permutation [4, 5, 1, 3, 2] for m = 5;
* if l = 1 and r = 6 we will have a permutation [4, 5, 1, 3, 2, 6] for m = 6;
* it is impossible to take some l and r, such that [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m for m = 2 and for m = 4.
You are given a permutation p=[p_1, p_2, …, p_n]. For all m (1 ≤ m ≤ n) determine if it is a beautiful number or not.
Input
The first line contains the only integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. The next lines contain the description of test cases.
The first line of a test case contains a number n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the given permutation p. The next line contains n integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n, all p_i are different) — the given permutation p.
It is guaranteed, that the sum of n from all test cases in the input doesn't exceed 2 ⋅ 10^5.
Output
Print t lines — the answers to test cases in the order they are given in the input.
The answer to a test case is the string of length n, there the i-th character is equal to 1 if i is a beautiful number and is equal to 0 if i is not a beautiful number.
Example
Input
3
6
4 5 1 3 2 6
5
5 3 1 2 4
4
1 4 3 2
Output
101011
11111
1001
Note
The first test case is described in the problem statement.
In the second test case all numbers from 1 to 5 are beautiful:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 4 we will have a permutation [1, 2] for m = 2;
* if l = 2 and r = 4 we will have a permutation [3, 1, 2] for m = 3;
* if l = 2 and r = 5 we will have a permutation [3, 1, 2, 4] for m = 4;
* if l = 1 and r = 5 we will have a permutation [5, 3, 1, 2, 4] for m = 5.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
from collections import Counter
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def gcd(a, b):
if a == 0:
return b
return gcd(b % a, a)
def lcm(a, b):
return (a * b) / gcd(a, b)
def main():
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
done = [0] * (n + 1)
d = [[-1,-1]]
for i in range(n):
d.append([a[i], i])
d.sort()
l = d[1][1]
r = d[1][1]
done[1] = 1
ans = [0] * (n + 1)
ans[1] = 1
now = 2
for i in range(1, n):
if d[i][1] < l:
for j in range(l - 1, d[i][1] - 1, -1):
done[a[j]] = 1
l = d[i][1]
elif d[i][1] > r:
for j in range(r + 1, d[i][1] + 1):
done[a[j]] = 1
r = d[i][1]
#print(done)
while (now < n and done[now]):
now += 1
#print(l, r, now, i)
if now > i and r - l+1 == i:
ans[i] = 1
#print(i)
ans[n] = 1
for i in range(1,n+1):
print(ans[i],end='')
print('')
return
if __name__ == "__main__":
main()
``` | instruction | 0 | 4,297 | 12 | 8,594 |
Yes | output | 1 | 4,297 | 12 | 8,595 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p=[p_1, p_2, …, p_n] of integers from 1 to n. Let's call the number m (1 ≤ m ≤ n) beautiful, if there exists two indices l, r (1 ≤ l ≤ r ≤ n), such that the numbers [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m.
For example, let p = [4, 5, 1, 3, 2, 6]. In this case, the numbers 1, 3, 5, 6 are beautiful and 2, 4 are not. It is because:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 5 we will have a permutation [1, 3, 2] for m = 3;
* if l = 1 and r = 5 we will have a permutation [4, 5, 1, 3, 2] for m = 5;
* if l = 1 and r = 6 we will have a permutation [4, 5, 1, 3, 2, 6] for m = 6;
* it is impossible to take some l and r, such that [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m for m = 2 and for m = 4.
You are given a permutation p=[p_1, p_2, …, p_n]. For all m (1 ≤ m ≤ n) determine if it is a beautiful number or not.
Input
The first line contains the only integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. The next lines contain the description of test cases.
The first line of a test case contains a number n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the given permutation p. The next line contains n integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n, all p_i are different) — the given permutation p.
It is guaranteed, that the sum of n from all test cases in the input doesn't exceed 2 ⋅ 10^5.
Output
Print t lines — the answers to test cases in the order they are given in the input.
The answer to a test case is the string of length n, there the i-th character is equal to 1 if i is a beautiful number and is equal to 0 if i is not a beautiful number.
Example
Input
3
6
4 5 1 3 2 6
5
5 3 1 2 4
4
1 4 3 2
Output
101011
11111
1001
Note
The first test case is described in the problem statement.
In the second test case all numbers from 1 to 5 are beautiful:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 4 we will have a permutation [1, 2] for m = 2;
* if l = 2 and r = 4 we will have a permutation [3, 1, 2] for m = 3;
* if l = 2 and r = 5 we will have a permutation [3, 1, 2, 4] for m = 4;
* if l = 1 and r = 5 we will have a permutation [5, 3, 1, 2, 4] for m = 5.
Submitted Solution:
```
for _ in range(int(input())):
_=input()
tmp=input()
n=map(int,tmp.split())
n=list(n)
for i,x in enumerate(n):
if x==1:
break
a=b=i+1
MAX=1
ans=[1]
n=[float('inf')]+list(n)+[float('inf')]
for i in range(2,len(n)-1):
if n[a-1]>n[b+1]:
MAX=max(n[b+1],MAX)
b+=1
else:
MAX=max(n[a-1],MAX)
a-=1
if MAX==i:
ans.append(1)
else:
ans.append(0)
for i,x in enumerate(ans):
ans[i]=str(x)
print(''.join(ans))
``` | instruction | 0 | 4,298 | 12 | 8,596 |
Yes | output | 1 | 4,298 | 12 | 8,597 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p=[p_1, p_2, …, p_n] of integers from 1 to n. Let's call the number m (1 ≤ m ≤ n) beautiful, if there exists two indices l, r (1 ≤ l ≤ r ≤ n), such that the numbers [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m.
For example, let p = [4, 5, 1, 3, 2, 6]. In this case, the numbers 1, 3, 5, 6 are beautiful and 2, 4 are not. It is because:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 5 we will have a permutation [1, 3, 2] for m = 3;
* if l = 1 and r = 5 we will have a permutation [4, 5, 1, 3, 2] for m = 5;
* if l = 1 and r = 6 we will have a permutation [4, 5, 1, 3, 2, 6] for m = 6;
* it is impossible to take some l and r, such that [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m for m = 2 and for m = 4.
You are given a permutation p=[p_1, p_2, …, p_n]. For all m (1 ≤ m ≤ n) determine if it is a beautiful number or not.
Input
The first line contains the only integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. The next lines contain the description of test cases.
The first line of a test case contains a number n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the given permutation p. The next line contains n integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n, all p_i are different) — the given permutation p.
It is guaranteed, that the sum of n from all test cases in the input doesn't exceed 2 ⋅ 10^5.
Output
Print t lines — the answers to test cases in the order they are given in the input.
The answer to a test case is the string of length n, there the i-th character is equal to 1 if i is a beautiful number and is equal to 0 if i is not a beautiful number.
Example
Input
3
6
4 5 1 3 2 6
5
5 3 1 2 4
4
1 4 3 2
Output
101011
11111
1001
Note
The first test case is described in the problem statement.
In the second test case all numbers from 1 to 5 are beautiful:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 4 we will have a permutation [1, 2] for m = 2;
* if l = 2 and r = 4 we will have a permutation [3, 1, 2] for m = 3;
* if l = 2 and r = 5 we will have a permutation [3, 1, 2, 4] for m = 4;
* if l = 1 and r = 5 we will have a permutation [5, 3, 1, 2, 4] for m = 5.
Submitted Solution:
```
I = lambda:int(input())
ID = lambda:map(int, input().split())
IL = lambda:list(ID())
t = I()
for _ in range(t):
n = I()
a = IL()
#ans = [0]*n
#ans[0] = 1
#ans[n-1] = 1
#p = n-1
p = n+1
i = 0
j = n-1
ans = '1'
while j>i:
if a[i]>a[j]:
if a[i]<p:
p = a[i]
i+=1
else:
if a[j]<p:
p = a[j]
j-=1
#if j - i ==p-1:
#ans[j-i] = 1
if j - i == p -2:
#ans[j-i] = 1
ans+='1'
else:
ans+='0'
print(ans)
#print(ans)
#for k in ans:
#print(k,end='')
``` | instruction | 0 | 4,299 | 12 | 8,598 |
No | output | 1 | 4,299 | 12 | 8,599 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p=[p_1, p_2, …, p_n] of integers from 1 to n. Let's call the number m (1 ≤ m ≤ n) beautiful, if there exists two indices l, r (1 ≤ l ≤ r ≤ n), such that the numbers [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m.
For example, let p = [4, 5, 1, 3, 2, 6]. In this case, the numbers 1, 3, 5, 6 are beautiful and 2, 4 are not. It is because:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 5 we will have a permutation [1, 3, 2] for m = 3;
* if l = 1 and r = 5 we will have a permutation [4, 5, 1, 3, 2] for m = 5;
* if l = 1 and r = 6 we will have a permutation [4, 5, 1, 3, 2, 6] for m = 6;
* it is impossible to take some l and r, such that [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m for m = 2 and for m = 4.
You are given a permutation p=[p_1, p_2, …, p_n]. For all m (1 ≤ m ≤ n) determine if it is a beautiful number or not.
Input
The first line contains the only integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. The next lines contain the description of test cases.
The first line of a test case contains a number n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the given permutation p. The next line contains n integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n, all p_i are different) — the given permutation p.
It is guaranteed, that the sum of n from all test cases in the input doesn't exceed 2 ⋅ 10^5.
Output
Print t lines — the answers to test cases in the order they are given in the input.
The answer to a test case is the string of length n, there the i-th character is equal to 1 if i is a beautiful number and is equal to 0 if i is not a beautiful number.
Example
Input
3
6
4 5 1 3 2 6
5
5 3 1 2 4
4
1 4 3 2
Output
101011
11111
1001
Note
The first test case is described in the problem statement.
In the second test case all numbers from 1 to 5 are beautiful:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 4 we will have a permutation [1, 2] for m = 2;
* if l = 2 and r = 4 we will have a permutation [3, 1, 2] for m = 3;
* if l = 2 and r = 5 we will have a permutation [3, 1, 2, 4] for m = 4;
* if l = 1 and r = 5 we will have a permutation [5, 3, 1, 2, 4] for m = 5.
Submitted Solution:
```
import io,os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
for w in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
l=[0]*n
d={}
for i in range(n):
d[a[i]]=i
num=n
num_list=[]
#inde=a.index(1)
for i in range(1,n+1):
num_list.append(i)
#print(j,i,num)
i=0
j=n-1
l[i]=1
while(j>i and num>0 and len(num_list)>0):
#print("YES")
#print(i,j)
if(num not in a[i:j+1]):
num=max(a[i:j+1])
if(num_list!=[] and num_list[-1]==num):
if(sorted(a[i:j+1])==num_list):
l[num-1]=1
if(d[num]>d[1]):
j=d[num]-1
else:
i=d[num]+1
num-=1
#print("YES1")
else:
if(d[num]>d[1]):
j=d[num]-1
else:
i=d[num]+1
num=max(a[i:j+1])
#print("YES2")
else:
while(len(num_list)>0 and num_list[-1]!=num):
num_list.remove(num_list[-1])
#print("YES3")
#print(i,j,num)
for i in range(n):
print(l[i],end=" ")
print()
#print(num_list)
``` | instruction | 0 | 4,300 | 12 | 8,600 |
No | output | 1 | 4,300 | 12 | 8,601 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p=[p_1, p_2, …, p_n] of integers from 1 to n. Let's call the number m (1 ≤ m ≤ n) beautiful, if there exists two indices l, r (1 ≤ l ≤ r ≤ n), such that the numbers [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m.
For example, let p = [4, 5, 1, 3, 2, 6]. In this case, the numbers 1, 3, 5, 6 are beautiful and 2, 4 are not. It is because:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 5 we will have a permutation [1, 3, 2] for m = 3;
* if l = 1 and r = 5 we will have a permutation [4, 5, 1, 3, 2] for m = 5;
* if l = 1 and r = 6 we will have a permutation [4, 5, 1, 3, 2, 6] for m = 6;
* it is impossible to take some l and r, such that [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m for m = 2 and for m = 4.
You are given a permutation p=[p_1, p_2, …, p_n]. For all m (1 ≤ m ≤ n) determine if it is a beautiful number or not.
Input
The first line contains the only integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. The next lines contain the description of test cases.
The first line of a test case contains a number n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the given permutation p. The next line contains n integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n, all p_i are different) — the given permutation p.
It is guaranteed, that the sum of n from all test cases in the input doesn't exceed 2 ⋅ 10^5.
Output
Print t lines — the answers to test cases in the order they are given in the input.
The answer to a test case is the string of length n, there the i-th character is equal to 1 if i is a beautiful number and is equal to 0 if i is not a beautiful number.
Example
Input
3
6
4 5 1 3 2 6
5
5 3 1 2 4
4
1 4 3 2
Output
101011
11111
1001
Note
The first test case is described in the problem statement.
In the second test case all numbers from 1 to 5 are beautiful:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 4 we will have a permutation [1, 2] for m = 2;
* if l = 2 and r = 4 we will have a permutation [3, 1, 2] for m = 3;
* if l = 2 and r = 5 we will have a permutation [3, 1, 2, 4] for m = 4;
* if l = 1 and r = 5 we will have a permutation [5, 3, 1, 2, 4] for m = 5.
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
A = list(map(int, input().split()))
D = [0 for _ in range(n+1)]
for i in range(n): D[A[i]] = i
if n > 1: print(1, end='')
ini = fin = D[1]
cont = 2
maxi = 1
for i in range(1,n-1):
if fin<D[cont]: fin+=1
if ini>D[cont]: ini-=1
if ini<=D[cont]<=fin: cont+=1
maxi = max(maxi,A[ini], A[fin])
if maxi==i+1: print(1,end='')
else: print(0, end='')
print(1)
``` | instruction | 0 | 4,301 | 12 | 8,602 |
No | output | 1 | 4,301 | 12 | 8,603 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p=[p_1, p_2, …, p_n] of integers from 1 to n. Let's call the number m (1 ≤ m ≤ n) beautiful, if there exists two indices l, r (1 ≤ l ≤ r ≤ n), such that the numbers [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m.
For example, let p = [4, 5, 1, 3, 2, 6]. In this case, the numbers 1, 3, 5, 6 are beautiful and 2, 4 are not. It is because:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 5 we will have a permutation [1, 3, 2] for m = 3;
* if l = 1 and r = 5 we will have a permutation [4, 5, 1, 3, 2] for m = 5;
* if l = 1 and r = 6 we will have a permutation [4, 5, 1, 3, 2, 6] for m = 6;
* it is impossible to take some l and r, such that [p_l, p_{l+1}, …, p_r] is a permutation of numbers 1, 2, …, m for m = 2 and for m = 4.
You are given a permutation p=[p_1, p_2, …, p_n]. For all m (1 ≤ m ≤ n) determine if it is a beautiful number or not.
Input
The first line contains the only integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. The next lines contain the description of test cases.
The first line of a test case contains a number n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the given permutation p. The next line contains n integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n, all p_i are different) — the given permutation p.
It is guaranteed, that the sum of n from all test cases in the input doesn't exceed 2 ⋅ 10^5.
Output
Print t lines — the answers to test cases in the order they are given in the input.
The answer to a test case is the string of length n, there the i-th character is equal to 1 if i is a beautiful number and is equal to 0 if i is not a beautiful number.
Example
Input
3
6
4 5 1 3 2 6
5
5 3 1 2 4
4
1 4 3 2
Output
101011
11111
1001
Note
The first test case is described in the problem statement.
In the second test case all numbers from 1 to 5 are beautiful:
* if l = 3 and r = 3 we will have a permutation [1] for m = 1;
* if l = 3 and r = 4 we will have a permutation [1, 2] for m = 2;
* if l = 2 and r = 4 we will have a permutation [3, 1, 2] for m = 3;
* if l = 2 and r = 5 we will have a permutation [3, 1, 2, 4] for m = 4;
* if l = 1 and r = 5 we will have a permutation [5, 3, 1, 2, 4] for m = 5.
Submitted Solution:
```
for _ in range(int(input())):
a = int(input())
b = list(map(int, input().split()))
c = [0]*a
for i in range(1, a + 1):
flag = False
for j in range(i - a , i + 1):
if j < len(b) - 1 and sum(b[j: j + i]) == i*(i + 1)//2:
flag = True
break
if flag == True:
c[i - 1] = "1"
else:
c[i - 1] = "0"
y = ""
for num in c:
y = y + num
print(y)
``` | instruction | 0 | 4,302 | 12 | 8,604 |
No | output | 1 | 4,302 | 12 | 8,605 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.