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 a correct Python 3 solution for this coding contest problem.
Arithmetic Progressions
An arithmetic progression is a sequence of numbers $a_1, a_2, ..., a_k$ where the difference of consecutive members $a_{i+1} - a_i$ is a constant ($1 \leq i \leq k-1$). For example, the sequence 5, 8, 11, 14, 17 is an arithmetic progression of length 5 with the common difference 3.
In this problem, you are requested to find the longest arithmetic progression which can be formed selecting some numbers from a given set of numbers. For example, if the given set of numbers is {0, 1, 3, 5, 6, 9}, you can form arithmetic progressions such as 0, 3, 6, 9 with the common difference 3, or 9, 5, 1 with the common difference -4. In this case, the progressions 0, 3, 6, 9 and 9, 6, 3, 0 are the longest.
Input
The input consists of a single test case of the following format.
$n$
$v_1$ $v_2$ ... $v_n$
$n$ is the number of elements of the set, which is an integer satisfying $2 \leq n \leq 5000$. Each $v_i$ ($1 \leq i \leq n$) is an element of the set, which is an integer satisfying $0 \leq v_i \leq 10^9$. $v_i$'s are all different, i.e., $v_i \ne v_j$ if $i \ne j$.
Output
Output the length of the longest arithmetic progressions which can be formed selecting some numbers from the given set of numbers.
Sample Input 1
6
0 1 3 5 6 9
Sample Output 1
4
Sample Input 2
7
1 4 7 3 2 6 5
Sample Output 2
7
Sample Input 3
5
1 2 4 8 16
Sample Output 3
2
Example
Input
6
0 1 3 5 6 9
Output
4 | instruction | 0 | 35,922 | 12 | 71,844 |
"Correct Solution:
```
#!/usr/bin/python3
import os
import sys
def main():
N = read_int()
V = read_ints()
print(solve(N, V))
def solve(N, V):
V.sort()
pos = {}
for i, a in enumerate(V):
pos[a] = i
best = 2
done = [[False] * N for _ in range(N)]
for i in range(N):
a = V[i]
for j in range(i + 1, N):
if done[i][j]:
continue
b = V[j]
d = b - a
c = 2
done[i][j] = True
k = j
v = b + d
while v in pos:
done[k][pos[v]] = True
k = pos[v]
c += 1
v += d
best = max(best, c)
return best
###############################################################################
# AUXILIARY FUNCTIONS
DEBUG = 'DEBUG' in os.environ
def inp():
return sys.stdin.readline().rstrip()
def read_int():
return int(inp())
def read_ints():
return [int(e) for e in inp().split()]
def dprint(*value, sep=' ', end='\n'):
if DEBUG:
print(*value, sep=sep, end=end)
if __name__ == '__main__':
main()
``` | output | 1 | 35,922 | 12 | 71,845 |
Provide a correct Python 3 solution for this coding contest problem.
Quick sort is based on the Divide-and-conquer approach. In QuickSort(A, p, r), first, a procedure Partition(A, p, r) divides an array A[p..r] into two subarrays A[p..q-1] and A[q+1..r] such that each element of A[p..q-1] is less than or equal to A[q], which is, inturn, less than or equal to each element of A[q+1..r]. It also computes the index q.
In the conquer processes, the two subarrays A[p..q-1] and A[q+1..r] are sorted by recursive calls of QuickSort(A, p, q-1) and QuickSort(A, q+1, r).
Your task is to read a sequence A and perform the Partition based on the following pseudocode:
Partition(A, p, r)
1 x = A[r]
2 i = p-1
3 for j = p to r-1
4 do if A[j] <= x
5 then i = i+1
6 exchange A[i] and A[j]
7 exchange A[i+1] and A[r]
8 return i+1
Note that, in this algorithm, Partition always selects an element A[r] as a pivot element around which to partition the array A[p..r].
Constraints
* 1 ≤ n ≤ 100,000
* 0 ≤ Ai ≤ 100,000
Input
The first line of the input includes an integer n, the number of elements in the sequence A.
In the second line, Ai (i = 1,2,...,n), elements of the sequence are given separated by space characters.
Output
Print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character. The element which is selected as the pivot of the partition should be indicated by [ ].
Example
Input
12
13 19 9 5 12 8 7 4 21 2 6 11
Output
9 5 8 7 4 2 6 [11] 21 13 19 12 | instruction | 0 | 35,954 | 12 | 71,908 |
"Correct Solution:
```
def partition(A, p, r):
x = A[r]
i = p-1
for j in range(p,r):
if A[j] <= x:
i = i+1
A[i],A[j] = A[j],A[i]
A[i+1],A[r] = A[r],A[i+1]
for j,k in enumerate(A):A[j] = str(k)
A[i+1] = "["+A[i+1]+"]"
return i+1
n = int(input())
A = [int(i) for i in input().split()]
ans = ""
partition(A,0,n-1)
for i in A:ans+=i+" "
print(ans[:-1])
``` | output | 1 | 35,954 | 12 | 71,909 |
Provide a correct Python 3 solution for this coding contest problem.
Quick sort is based on the Divide-and-conquer approach. In QuickSort(A, p, r), first, a procedure Partition(A, p, r) divides an array A[p..r] into two subarrays A[p..q-1] and A[q+1..r] such that each element of A[p..q-1] is less than or equal to A[q], which is, inturn, less than or equal to each element of A[q+1..r]. It also computes the index q.
In the conquer processes, the two subarrays A[p..q-1] and A[q+1..r] are sorted by recursive calls of QuickSort(A, p, q-1) and QuickSort(A, q+1, r).
Your task is to read a sequence A and perform the Partition based on the following pseudocode:
Partition(A, p, r)
1 x = A[r]
2 i = p-1
3 for j = p to r-1
4 do if A[j] <= x
5 then i = i+1
6 exchange A[i] and A[j]
7 exchange A[i+1] and A[r]
8 return i+1
Note that, in this algorithm, Partition always selects an element A[r] as a pivot element around which to partition the array A[p..r].
Constraints
* 1 ≤ n ≤ 100,000
* 0 ≤ Ai ≤ 100,000
Input
The first line of the input includes an integer n, the number of elements in the sequence A.
In the second line, Ai (i = 1,2,...,n), elements of the sequence are given separated by space characters.
Output
Print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character. The element which is selected as the pivot of the partition should be indicated by [ ].
Example
Input
12
13 19 9 5 12 8 7 4 21 2 6 11
Output
9 5 8 7 4 2 6 [11] 21 13 19 12 | instruction | 0 | 35,955 | 12 | 71,910 |
"Correct Solution:
```
# coding: utf-8
# Your code here!
def partition(A,p,r):
x = A[r]
i = p-1
for j in range(p,r):
if A[j] <= x:
i = i + 1
A[i],A[j] = A[j],A[i]
A[i+1],A[r] = A[r],A[i+1]
return i + 1
n = int(input())
A = [int(e) for e in input().split()]
b = partition(A,0,n-1)
A[b] = f"[{A[b]}]"
print(*A)
``` | output | 1 | 35,955 | 12 | 71,911 |
Provide a correct Python 3 solution for this coding contest problem.
Quick sort is based on the Divide-and-conquer approach. In QuickSort(A, p, r), first, a procedure Partition(A, p, r) divides an array A[p..r] into two subarrays A[p..q-1] and A[q+1..r] such that each element of A[p..q-1] is less than or equal to A[q], which is, inturn, less than or equal to each element of A[q+1..r]. It also computes the index q.
In the conquer processes, the two subarrays A[p..q-1] and A[q+1..r] are sorted by recursive calls of QuickSort(A, p, q-1) and QuickSort(A, q+1, r).
Your task is to read a sequence A and perform the Partition based on the following pseudocode:
Partition(A, p, r)
1 x = A[r]
2 i = p-1
3 for j = p to r-1
4 do if A[j] <= x
5 then i = i+1
6 exchange A[i] and A[j]
7 exchange A[i+1] and A[r]
8 return i+1
Note that, in this algorithm, Partition always selects an element A[r] as a pivot element around which to partition the array A[p..r].
Constraints
* 1 ≤ n ≤ 100,000
* 0 ≤ Ai ≤ 100,000
Input
The first line of the input includes an integer n, the number of elements in the sequence A.
In the second line, Ai (i = 1,2,...,n), elements of the sequence are given separated by space characters.
Output
Print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character. The element which is selected as the pivot of the partition should be indicated by [ ].
Example
Input
12
13 19 9 5 12 8 7 4 21 2 6 11
Output
9 5 8 7 4 2 6 [11] 21 13 19 12 | instruction | 0 | 35,956 | 12 | 71,912 |
"Correct Solution:
```
# coding=utf-8
def partition(A, p, r):
x = A[r]
i = p - 1
for j in range(p, r):
if A[j] <= x:
i = i+1
A[i], A[j] = A[j], A[i]
A[i+1], A[r] = A[r], A[i+1]
return i+1
n = int(input())
A = list(map(int, input().split()))
m = partition(A, 0, n-1)
A = list(map(str, A))
A[m] = "[%s]"%(A[m])
print(*A)
``` | output | 1 | 35,956 | 12 | 71,913 |
Provide a correct Python 3 solution for this coding contest problem.
Quick sort is based on the Divide-and-conquer approach. In QuickSort(A, p, r), first, a procedure Partition(A, p, r) divides an array A[p..r] into two subarrays A[p..q-1] and A[q+1..r] such that each element of A[p..q-1] is less than or equal to A[q], which is, inturn, less than or equal to each element of A[q+1..r]. It also computes the index q.
In the conquer processes, the two subarrays A[p..q-1] and A[q+1..r] are sorted by recursive calls of QuickSort(A, p, q-1) and QuickSort(A, q+1, r).
Your task is to read a sequence A and perform the Partition based on the following pseudocode:
Partition(A, p, r)
1 x = A[r]
2 i = p-1
3 for j = p to r-1
4 do if A[j] <= x
5 then i = i+1
6 exchange A[i] and A[j]
7 exchange A[i+1] and A[r]
8 return i+1
Note that, in this algorithm, Partition always selects an element A[r] as a pivot element around which to partition the array A[p..r].
Constraints
* 1 ≤ n ≤ 100,000
* 0 ≤ Ai ≤ 100,000
Input
The first line of the input includes an integer n, the number of elements in the sequence A.
In the second line, Ai (i = 1,2,...,n), elements of the sequence are given separated by space characters.
Output
Print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character. The element which is selected as the pivot of the partition should be indicated by [ ].
Example
Input
12
13 19 9 5 12 8 7 4 21 2 6 11
Output
9 5 8 7 4 2 6 [11] 21 13 19 12 | instruction | 0 | 35,957 | 12 | 71,914 |
"Correct Solution:
```
n=int(input())
nums=list(map(int,input().split()))
def partition(nums,p,r):
i=p-1
x=nums[r]
for k in range(p,r):
if nums[k]<=x:
i+=1
nums[i],nums[k]=nums[k],nums[i]
nums[i+1],nums[r]=nums[r],nums[i+1]
return i+1
i=partition(nums,0,n-1)
nums[i]="["+str(nums[i])+"]"
print(' '.join(map(str,nums)))
``` | output | 1 | 35,957 | 12 | 71,915 |
Provide a correct Python 3 solution for this coding contest problem.
Quick sort is based on the Divide-and-conquer approach. In QuickSort(A, p, r), first, a procedure Partition(A, p, r) divides an array A[p..r] into two subarrays A[p..q-1] and A[q+1..r] such that each element of A[p..q-1] is less than or equal to A[q], which is, inturn, less than or equal to each element of A[q+1..r]. It also computes the index q.
In the conquer processes, the two subarrays A[p..q-1] and A[q+1..r] are sorted by recursive calls of QuickSort(A, p, q-1) and QuickSort(A, q+1, r).
Your task is to read a sequence A and perform the Partition based on the following pseudocode:
Partition(A, p, r)
1 x = A[r]
2 i = p-1
3 for j = p to r-1
4 do if A[j] <= x
5 then i = i+1
6 exchange A[i] and A[j]
7 exchange A[i+1] and A[r]
8 return i+1
Note that, in this algorithm, Partition always selects an element A[r] as a pivot element around which to partition the array A[p..r].
Constraints
* 1 ≤ n ≤ 100,000
* 0 ≤ Ai ≤ 100,000
Input
The first line of the input includes an integer n, the number of elements in the sequence A.
In the second line, Ai (i = 1,2,...,n), elements of the sequence are given separated by space characters.
Output
Print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character. The element which is selected as the pivot of the partition should be indicated by [ ].
Example
Input
12
13 19 9 5 12 8 7 4 21 2 6 11
Output
9 5 8 7 4 2 6 [11] 21 13 19 12 | instruction | 0 | 35,958 | 12 | 71,916 |
"Correct Solution:
```
n = int(input())
A = [int(x) for x in input().split()]
def partition(A, p, r):
x = A[r]
i = p
for j in range(p, r):
if A[j] <= x:
A[i], A[j] = A[j], A[i]
i += 1
A[i], A[r] = A[r], A[i]
return i
r = partition(A, 0, n - 1)
ans = [str(x) for x in A]
ans[r] = '[{}]'.format(ans[r])
print(' '.join(ans))
``` | output | 1 | 35,958 | 12 | 71,917 |
Provide a correct Python 3 solution for this coding contest problem.
Quick sort is based on the Divide-and-conquer approach. In QuickSort(A, p, r), first, a procedure Partition(A, p, r) divides an array A[p..r] into two subarrays A[p..q-1] and A[q+1..r] such that each element of A[p..q-1] is less than or equal to A[q], which is, inturn, less than or equal to each element of A[q+1..r]. It also computes the index q.
In the conquer processes, the two subarrays A[p..q-1] and A[q+1..r] are sorted by recursive calls of QuickSort(A, p, q-1) and QuickSort(A, q+1, r).
Your task is to read a sequence A and perform the Partition based on the following pseudocode:
Partition(A, p, r)
1 x = A[r]
2 i = p-1
3 for j = p to r-1
4 do if A[j] <= x
5 then i = i+1
6 exchange A[i] and A[j]
7 exchange A[i+1] and A[r]
8 return i+1
Note that, in this algorithm, Partition always selects an element A[r] as a pivot element around which to partition the array A[p..r].
Constraints
* 1 ≤ n ≤ 100,000
* 0 ≤ Ai ≤ 100,000
Input
The first line of the input includes an integer n, the number of elements in the sequence A.
In the second line, Ai (i = 1,2,...,n), elements of the sequence are given separated by space characters.
Output
Print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character. The element which is selected as the pivot of the partition should be indicated by [ ].
Example
Input
12
13 19 9 5 12 8 7 4 21 2 6 11
Output
9 5 8 7 4 2 6 [11] 21 13 19 12 | instruction | 0 | 35,959 | 12 | 71,918 |
"Correct Solution:
```
n=int(input())-1
A=list(map(int,input().split()))
i=0
for j in range(n):
if A[j]<=A[-1]:A[i],A[j]=A[j],A[i];i+=1
A[i],A[n]='['+str(A[n])+']',A[i]
print(*A)
``` | output | 1 | 35,959 | 12 | 71,919 |
Provide a correct Python 3 solution for this coding contest problem.
Quick sort is based on the Divide-and-conquer approach. In QuickSort(A, p, r), first, a procedure Partition(A, p, r) divides an array A[p..r] into two subarrays A[p..q-1] and A[q+1..r] such that each element of A[p..q-1] is less than or equal to A[q], which is, inturn, less than or equal to each element of A[q+1..r]. It also computes the index q.
In the conquer processes, the two subarrays A[p..q-1] and A[q+1..r] are sorted by recursive calls of QuickSort(A, p, q-1) and QuickSort(A, q+1, r).
Your task is to read a sequence A and perform the Partition based on the following pseudocode:
Partition(A, p, r)
1 x = A[r]
2 i = p-1
3 for j = p to r-1
4 do if A[j] <= x
5 then i = i+1
6 exchange A[i] and A[j]
7 exchange A[i+1] and A[r]
8 return i+1
Note that, in this algorithm, Partition always selects an element A[r] as a pivot element around which to partition the array A[p..r].
Constraints
* 1 ≤ n ≤ 100,000
* 0 ≤ Ai ≤ 100,000
Input
The first line of the input includes an integer n, the number of elements in the sequence A.
In the second line, Ai (i = 1,2,...,n), elements of the sequence are given separated by space characters.
Output
Print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character. The element which is selected as the pivot of the partition should be indicated by [ ].
Example
Input
12
13 19 9 5 12 8 7 4 21 2 6 11
Output
9 5 8 7 4 2 6 [11] 21 13 19 12 | instruction | 0 | 35,960 | 12 | 71,920 |
"Correct Solution:
```
def partition(A, p, r):
x = A[r]
i = p-1
for j in range(p, r):
if A[j] <= x:
i = i+1
A[i], A[j] = A[j], A[i]
A[r] = "[" + str(A[r]) + "]"
A[i+1] , A[r] = A[r], A[i+1]
return i+1
n = int(input())
A = [int(x) for x in input().split()]
partition(A,0,n-1)
print(*A)
``` | output | 1 | 35,960 | 12 | 71,921 |
Provide a correct Python 3 solution for this coding contest problem.
Quick sort is based on the Divide-and-conquer approach. In QuickSort(A, p, r), first, a procedure Partition(A, p, r) divides an array A[p..r] into two subarrays A[p..q-1] and A[q+1..r] such that each element of A[p..q-1] is less than or equal to A[q], which is, inturn, less than or equal to each element of A[q+1..r]. It also computes the index q.
In the conquer processes, the two subarrays A[p..q-1] and A[q+1..r] are sorted by recursive calls of QuickSort(A, p, q-1) and QuickSort(A, q+1, r).
Your task is to read a sequence A and perform the Partition based on the following pseudocode:
Partition(A, p, r)
1 x = A[r]
2 i = p-1
3 for j = p to r-1
4 do if A[j] <= x
5 then i = i+1
6 exchange A[i] and A[j]
7 exchange A[i+1] and A[r]
8 return i+1
Note that, in this algorithm, Partition always selects an element A[r] as a pivot element around which to partition the array A[p..r].
Constraints
* 1 ≤ n ≤ 100,000
* 0 ≤ Ai ≤ 100,000
Input
The first line of the input includes an integer n, the number of elements in the sequence A.
In the second line, Ai (i = 1,2,...,n), elements of the sequence are given separated by space characters.
Output
Print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character. The element which is selected as the pivot of the partition should be indicated by [ ].
Example
Input
12
13 19 9 5 12 8 7 4 21 2 6 11
Output
9 5 8 7 4 2 6 [11] 21 13 19 12 | instruction | 0 | 35,961 | 12 | 71,922 |
"Correct Solution:
```
def partition(A, p, r):
x = A[r]
i = p - 1
for j in range(p, r):
if A[j] <= x:
i += 1
A[i], A[j] = A[j], A[i]
A[i + 1], A[r] = A[r], A[i + 1]
return i + 1
n = int(input())
A = list(map(int, input().split()))
index = partition(A, 0, n - 1)
A[index] = "[" + str(A[index]) + "]"
A = map(str, A)
print(" ".join(A))
``` | output | 1 | 35,961 | 12 | 71,923 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Quick sort is based on the Divide-and-conquer approach. In QuickSort(A, p, r), first, a procedure Partition(A, p, r) divides an array A[p..r] into two subarrays A[p..q-1] and A[q+1..r] such that each element of A[p..q-1] is less than or equal to A[q], which is, inturn, less than or equal to each element of A[q+1..r]. It also computes the index q.
In the conquer processes, the two subarrays A[p..q-1] and A[q+1..r] are sorted by recursive calls of QuickSort(A, p, q-1) and QuickSort(A, q+1, r).
Your task is to read a sequence A and perform the Partition based on the following pseudocode:
Partition(A, p, r)
1 x = A[r]
2 i = p-1
3 for j = p to r-1
4 do if A[j] <= x
5 then i = i+1
6 exchange A[i] and A[j]
7 exchange A[i+1] and A[r]
8 return i+1
Note that, in this algorithm, Partition always selects an element A[r] as a pivot element around which to partition the array A[p..r].
Constraints
* 1 ≤ n ≤ 100,000
* 0 ≤ Ai ≤ 100,000
Input
The first line of the input includes an integer n, the number of elements in the sequence A.
In the second line, Ai (i = 1,2,...,n), elements of the sequence are given separated by space characters.
Output
Print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character. The element which is selected as the pivot of the partition should be indicated by [ ].
Example
Input
12
13 19 9 5 12 8 7 4 21 2 6 11
Output
9 5 8 7 4 2 6 [11] 21 13 19 12
Submitted Solution:
```
def partition(A, p, r):
x = A[r]
i = p-1
for j in range(p, r):
if A[j] <= x:
i = i+1
A[i],A[j] = A[j],A[i]
A[i+1],A[r] = A[r],A[i+1]
return i+1
r = int(input())
A = list(map(int, input().split()))
p = partition(A, 0, r-1)
A = list(map(str, A))
A[p] = "[%s]"%(A[p])
print(" ".join(A))
``` | instruction | 0 | 35,962 | 12 | 71,924 |
Yes | output | 1 | 35,962 | 12 | 71,925 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Quick sort is based on the Divide-and-conquer approach. In QuickSort(A, p, r), first, a procedure Partition(A, p, r) divides an array A[p..r] into two subarrays A[p..q-1] and A[q+1..r] such that each element of A[p..q-1] is less than or equal to A[q], which is, inturn, less than or equal to each element of A[q+1..r]. It also computes the index q.
In the conquer processes, the two subarrays A[p..q-1] and A[q+1..r] are sorted by recursive calls of QuickSort(A, p, q-1) and QuickSort(A, q+1, r).
Your task is to read a sequence A and perform the Partition based on the following pseudocode:
Partition(A, p, r)
1 x = A[r]
2 i = p-1
3 for j = p to r-1
4 do if A[j] <= x
5 then i = i+1
6 exchange A[i] and A[j]
7 exchange A[i+1] and A[r]
8 return i+1
Note that, in this algorithm, Partition always selects an element A[r] as a pivot element around which to partition the array A[p..r].
Constraints
* 1 ≤ n ≤ 100,000
* 0 ≤ Ai ≤ 100,000
Input
The first line of the input includes an integer n, the number of elements in the sequence A.
In the second line, Ai (i = 1,2,...,n), elements of the sequence are given separated by space characters.
Output
Print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character. The element which is selected as the pivot of the partition should be indicated by [ ].
Example
Input
12
13 19 9 5 12 8 7 4 21 2 6 11
Output
9 5 8 7 4 2 6 [11] 21 13 19 12
Submitted Solution:
```
import sys
def partition(a, p, r):
x = a[r]
i = p - 1
for j in range(p, r):
if a[j] <= x:
i += 1
a[i], a[j] = a[j], a[i]
a[i + 1], a[r] = a[r], a[i + 1]
return i + 1
n = int(sys.stdin.readline())
a = [int(v) for v in sys.stdin.readline().split()]
index = partition(a, 0, n - 1)
print(' '.join(f'[{v}]' if i == index else v
for i, v in enumerate(map(str, a))))
``` | instruction | 0 | 35,963 | 12 | 71,926 |
Yes | output | 1 | 35,963 | 12 | 71,927 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Quick sort is based on the Divide-and-conquer approach. In QuickSort(A, p, r), first, a procedure Partition(A, p, r) divides an array A[p..r] into two subarrays A[p..q-1] and A[q+1..r] such that each element of A[p..q-1] is less than or equal to A[q], which is, inturn, less than or equal to each element of A[q+1..r]. It also computes the index q.
In the conquer processes, the two subarrays A[p..q-1] and A[q+1..r] are sorted by recursive calls of QuickSort(A, p, q-1) and QuickSort(A, q+1, r).
Your task is to read a sequence A and perform the Partition based on the following pseudocode:
Partition(A, p, r)
1 x = A[r]
2 i = p-1
3 for j = p to r-1
4 do if A[j] <= x
5 then i = i+1
6 exchange A[i] and A[j]
7 exchange A[i+1] and A[r]
8 return i+1
Note that, in this algorithm, Partition always selects an element A[r] as a pivot element around which to partition the array A[p..r].
Constraints
* 1 ≤ n ≤ 100,000
* 0 ≤ Ai ≤ 100,000
Input
The first line of the input includes an integer n, the number of elements in the sequence A.
In the second line, Ai (i = 1,2,...,n), elements of the sequence are given separated by space characters.
Output
Print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character. The element which is selected as the pivot of the partition should be indicated by [ ].
Example
Input
12
13 19 9 5 12 8 7 4 21 2 6 11
Output
9 5 8 7 4 2 6 [11] 21 13 19 12
Submitted Solution:
```
def partition(A, p, r):
x = A[r]
i = p - 1
for j in range(p, r):
if A[j] <= x:
i += 1
A[i], A[j] = A[j], A[i]
A[i + 1], A[r] = A[r], A[i + 1]
return i + 1
n = int(input())
A = list(map(int, input().split()))
p = partition(A, 0, n - 1)
A[p] = f"[{A[p]}]"
print(*A)
``` | instruction | 0 | 35,964 | 12 | 71,928 |
Yes | output | 1 | 35,964 | 12 | 71,929 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Quick sort is based on the Divide-and-conquer approach. In QuickSort(A, p, r), first, a procedure Partition(A, p, r) divides an array A[p..r] into two subarrays A[p..q-1] and A[q+1..r] such that each element of A[p..q-1] is less than or equal to A[q], which is, inturn, less than or equal to each element of A[q+1..r]. It also computes the index q.
In the conquer processes, the two subarrays A[p..q-1] and A[q+1..r] are sorted by recursive calls of QuickSort(A, p, q-1) and QuickSort(A, q+1, r).
Your task is to read a sequence A and perform the Partition based on the following pseudocode:
Partition(A, p, r)
1 x = A[r]
2 i = p-1
3 for j = p to r-1
4 do if A[j] <= x
5 then i = i+1
6 exchange A[i] and A[j]
7 exchange A[i+1] and A[r]
8 return i+1
Note that, in this algorithm, Partition always selects an element A[r] as a pivot element around which to partition the array A[p..r].
Constraints
* 1 ≤ n ≤ 100,000
* 0 ≤ Ai ≤ 100,000
Input
The first line of the input includes an integer n, the number of elements in the sequence A.
In the second line, Ai (i = 1,2,...,n), elements of the sequence are given separated by space characters.
Output
Print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character. The element which is selected as the pivot of the partition should be indicated by [ ].
Example
Input
12
13 19 9 5 12 8 7 4 21 2 6 11
Output
9 5 8 7 4 2 6 [11] 21 13 19 12
Submitted Solution:
```
def partition(A, p, r):
x = A[r]
i = p-1
for j in range(p, r):
if A[j] <= x:
i+=1
A[i],A[j]=A[j],A[i]
A[i+1],A[r]=A[r],A[i+1]
return i+1
#input
n=int(input())
data=list(map(int, input().split()))
q=partition(data,0,n-1)
data[q]="["+str(data[q])+"]"
print(*data)
``` | instruction | 0 | 35,965 | 12 | 71,930 |
Yes | output | 1 | 35,965 | 12 | 71,931 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Quick sort is based on the Divide-and-conquer approach. In QuickSort(A, p, r), first, a procedure Partition(A, p, r) divides an array A[p..r] into two subarrays A[p..q-1] and A[q+1..r] such that each element of A[p..q-1] is less than or equal to A[q], which is, inturn, less than or equal to each element of A[q+1..r]. It also computes the index q.
In the conquer processes, the two subarrays A[p..q-1] and A[q+1..r] are sorted by recursive calls of QuickSort(A, p, q-1) and QuickSort(A, q+1, r).
Your task is to read a sequence A and perform the Partition based on the following pseudocode:
Partition(A, p, r)
1 x = A[r]
2 i = p-1
3 for j = p to r-1
4 do if A[j] <= x
5 then i = i+1
6 exchange A[i] and A[j]
7 exchange A[i+1] and A[r]
8 return i+1
Note that, in this algorithm, Partition always selects an element A[r] as a pivot element around which to partition the array A[p..r].
Constraints
* 1 ≤ n ≤ 100,000
* 0 ≤ Ai ≤ 100,000
Input
The first line of the input includes an integer n, the number of elements in the sequence A.
In the second line, Ai (i = 1,2,...,n), elements of the sequence are given separated by space characters.
Output
Print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character. The element which is selected as the pivot of the partition should be indicated by [ ].
Example
Input
12
13 19 9 5 12 8 7 4 21 2 6 11
Output
9 5 8 7 4 2 6 [11] 21 13 19 12
Submitted Solution:
```
def partition(A, p, r):
x = A[r]
i = p - 1
for j in range(p, r):
if A[j] <= x:
i += 1
A[i], A[j] = A[j], A[i]
A[i + 1], A[r] = A[r], A[i + 1]
return i + 1
n = int(input())
A = [int(num) for num in input().split()]
p = 0
r = n
q = partition(A, p, r)
A_str = [str(a) for a in A]
A_str[q] = "[" + A_str[q] + "]"
print(" ".join(A_str))
``` | instruction | 0 | 35,966 | 12 | 71,932 |
No | output | 1 | 35,966 | 12 | 71,933 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Quick sort is based on the Divide-and-conquer approach. In QuickSort(A, p, r), first, a procedure Partition(A, p, r) divides an array A[p..r] into two subarrays A[p..q-1] and A[q+1..r] such that each element of A[p..q-1] is less than or equal to A[q], which is, inturn, less than or equal to each element of A[q+1..r]. It also computes the index q.
In the conquer processes, the two subarrays A[p..q-1] and A[q+1..r] are sorted by recursive calls of QuickSort(A, p, q-1) and QuickSort(A, q+1, r).
Your task is to read a sequence A and perform the Partition based on the following pseudocode:
Partition(A, p, r)
1 x = A[r]
2 i = p-1
3 for j = p to r-1
4 do if A[j] <= x
5 then i = i+1
6 exchange A[i] and A[j]
7 exchange A[i+1] and A[r]
8 return i+1
Note that, in this algorithm, Partition always selects an element A[r] as a pivot element around which to partition the array A[p..r].
Constraints
* 1 ≤ n ≤ 100,000
* 0 ≤ Ai ≤ 100,000
Input
The first line of the input includes an integer n, the number of elements in the sequence A.
In the second line, Ai (i = 1,2,...,n), elements of the sequence are given separated by space characters.
Output
Print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character. The element which is selected as the pivot of the partition should be indicated by [ ].
Example
Input
12
13 19 9 5 12 8 7 4 21 2 6 11
Output
9 5 8 7 4 2 6 [11] 21 13 19 12
Submitted Solution:
```
def partition(a, p, r):
x = a[r]
i = p - 1
for j in range(p, r):
if a[j] <= x:
i = i + 1
a[i], a[j] = a[j], a[i]
a[i+1], a[r] = a[r], a[i+1]
return i+1
n = int(input())
a = list(map(int, input().split()))
m = partition(a, 0, n-1)
a[m] = "[%s]"%(a[m])
print(" ".join(a))
``` | instruction | 0 | 35,967 | 12 | 71,934 |
No | output | 1 | 35,967 | 12 | 71,935 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Quick sort is based on the Divide-and-conquer approach. In QuickSort(A, p, r), first, a procedure Partition(A, p, r) divides an array A[p..r] into two subarrays A[p..q-1] and A[q+1..r] such that each element of A[p..q-1] is less than or equal to A[q], which is, inturn, less than or equal to each element of A[q+1..r]. It also computes the index q.
In the conquer processes, the two subarrays A[p..q-1] and A[q+1..r] are sorted by recursive calls of QuickSort(A, p, q-1) and QuickSort(A, q+1, r).
Your task is to read a sequence A and perform the Partition based on the following pseudocode:
Partition(A, p, r)
1 x = A[r]
2 i = p-1
3 for j = p to r-1
4 do if A[j] <= x
5 then i = i+1
6 exchange A[i] and A[j]
7 exchange A[i+1] and A[r]
8 return i+1
Note that, in this algorithm, Partition always selects an element A[r] as a pivot element around which to partition the array A[p..r].
Constraints
* 1 ≤ n ≤ 100,000
* 0 ≤ Ai ≤ 100,000
Input
The first line of the input includes an integer n, the number of elements in the sequence A.
In the second line, Ai (i = 1,2,...,n), elements of the sequence are given separated by space characters.
Output
Print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character. The element which is selected as the pivot of the partition should be indicated by [ ].
Example
Input
12
13 19 9 5 12 8 7 4 21 2 6 11
Output
9 5 8 7 4 2 6 [11] 21 13 19 12
Submitted Solution:
```
def partition(p, r):
x = A[r]
i = p - 1 # <xの右端
for j in range(p, r):
if A[j] <= x:
i += 1
A_tmp = A[i]
A[i] = A[j]
A[j] = A_tmp
t = A[i+1]
A[i+1] = A[r]
A[r] = t
return i+1
n = int(input())
A = [int(_) for _ in input().split()]
q = partition(0, n-1)
for i in range(n):
if i:
print(" ", end="")
if i == q:
print("[", end="")
print(A[i], end="")
if i == q:
print("]", end="")
``` | instruction | 0 | 35,968 | 12 | 71,936 |
No | output | 1 | 35,968 | 12 | 71,937 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Quick sort is based on the Divide-and-conquer approach. In QuickSort(A, p, r), first, a procedure Partition(A, p, r) divides an array A[p..r] into two subarrays A[p..q-1] and A[q+1..r] such that each element of A[p..q-1] is less than or equal to A[q], which is, inturn, less than or equal to each element of A[q+1..r]. It also computes the index q.
In the conquer processes, the two subarrays A[p..q-1] and A[q+1..r] are sorted by recursive calls of QuickSort(A, p, q-1) and QuickSort(A, q+1, r).
Your task is to read a sequence A and perform the Partition based on the following pseudocode:
Partition(A, p, r)
1 x = A[r]
2 i = p-1
3 for j = p to r-1
4 do if A[j] <= x
5 then i = i+1
6 exchange A[i] and A[j]
7 exchange A[i+1] and A[r]
8 return i+1
Note that, in this algorithm, Partition always selects an element A[r] as a pivot element around which to partition the array A[p..r].
Constraints
* 1 ≤ n ≤ 100,000
* 0 ≤ Ai ≤ 100,000
Input
The first line of the input includes an integer n, the number of elements in the sequence A.
In the second line, Ai (i = 1,2,...,n), elements of the sequence are given separated by space characters.
Output
Print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character. The element which is selected as the pivot of the partition should be indicated by [ ].
Example
Input
12
13 19 9 5 12 8 7 4 21 2 6 11
Output
9 5 8 7 4 2 6 [11] 21 13 19 12
Submitted Solution:
```
n = int(input())
lst_n = list(map(int,input().split()))
x = lst_n[n-1]
left = []
right = []
for num in lst_n:
if num < x:
left.append(str(num))
elif num > x:
right.append(str(num))
print('{} [{}] {}'.format(' '.join(left),str(x),' '.join(right)))
``` | instruction | 0 | 35,969 | 12 | 71,938 |
No | output | 1 | 35,969 | 12 | 71,939 |
Provide tags and a correct Python 2 solution for this coding contest problem.
You are given n pairs of integers (a_1, b_1), (a_2, b_2), …, (a_n, b_n). All of the integers in the pairs are distinct and are in the range from 1 to 2 ⋅ n inclusive.
Let's call a sequence of integers x_1, x_2, …, x_{2k} good if either
* x_1 < x_2 > x_3 < … < x_{2k-2} > x_{2k-1} < x_{2k}, or
* x_1 > x_2 < x_3 > … > x_{2k-2} < x_{2k-1} > x_{2k}.
You need to choose a subset of distinct indices i_1, i_2, …, i_t and their order in a way that if you write down all numbers from the pairs in a single sequence (the sequence would be a_{i_1}, b_{i_1}, a_{i_2}, b_{i_2}, …, a_{i_t}, b_{i_t}), this sequence is good.
What is the largest subset of indices you can choose? You also need to construct the corresponding index sequence i_1, i_2, …, i_t.
Input
The first line contains single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of pairs.
Each of the next n lines contain two numbers — a_i and b_i (1 ≤ a_i, b_i ≤ 2 ⋅ n) — the elements of the pairs.
It is guaranteed that all integers in the pairs are distinct, that is, every integer from 1 to 2 ⋅ n is mentioned exactly once.
Output
In the first line print a single integer t — the number of pairs in the answer.
Then print t distinct integers i_1, i_2, …, i_t — the indexes of pairs in the corresponding order.
Examples
Input
5
1 7
6 4
2 10
9 8
3 5
Output
3
1 5 3
Input
3
5 4
3 2
6 1
Output
3
3 2 1
Note
The final sequence in the first example is 1 < 7 > 3 < 5 > 2 < 10.
The final sequence in the second example is 6 > 1 < 3 > 2 < 5 > 4. | instruction | 0 | 36,077 | 12 | 72,154 |
Tags: greedy, sortings
Correct Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
def in_num():
return int(raw_input())
def in_arr():
return map(int,raw_input().strip())
def pr_num(n):
stdout.write(str(n)+'\n')
def pr_arr(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return map(int,stdin.read().split())
range = xrange # not for python 3.0+
# main code
inp=inp()
n=inp[0]
l1,l2=[],[]
pos=1
for i in range(n):
a,b=inp[pos],inp[pos+1]
pos+=2
if a<b:
#print a,b
l1.append((a,i+1))
if a>b:
#print b,a
l2.append((b,i+1))
if len(l1)>len(l2):
pr_num(len(l1))
l1.sort(reverse=True)
pr_arr(i[1] for i in l1)
else:
l2.sort()
pr_num(len(l2))
pr_arr(i[1] for i in l2)
``` | output | 1 | 36,077 | 12 | 72,155 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n pairs of integers (a_1, b_1), (a_2, b_2), …, (a_n, b_n). All of the integers in the pairs are distinct and are in the range from 1 to 2 ⋅ n inclusive.
Let's call a sequence of integers x_1, x_2, …, x_{2k} good if either
* x_1 < x_2 > x_3 < … < x_{2k-2} > x_{2k-1} < x_{2k}, or
* x_1 > x_2 < x_3 > … > x_{2k-2} < x_{2k-1} > x_{2k}.
You need to choose a subset of distinct indices i_1, i_2, …, i_t and their order in a way that if you write down all numbers from the pairs in a single sequence (the sequence would be a_{i_1}, b_{i_1}, a_{i_2}, b_{i_2}, …, a_{i_t}, b_{i_t}), this sequence is good.
What is the largest subset of indices you can choose? You also need to construct the corresponding index sequence i_1, i_2, …, i_t.
Input
The first line contains single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of pairs.
Each of the next n lines contain two numbers — a_i and b_i (1 ≤ a_i, b_i ≤ 2 ⋅ n) — the elements of the pairs.
It is guaranteed that all integers in the pairs are distinct, that is, every integer from 1 to 2 ⋅ n is mentioned exactly once.
Output
In the first line print a single integer t — the number of pairs in the answer.
Then print t distinct integers i_1, i_2, …, i_t — the indexes of pairs in the corresponding order.
Examples
Input
5
1 7
6 4
2 10
9 8
3 5
Output
3
1 5 3
Input
3
5 4
3 2
6 1
Output
3
3 2 1
Note
The final sequence in the first example is 1 < 7 > 3 < 5 > 2 < 10.
The final sequence in the second example is 6 > 1 < 3 > 2 < 5 > 4. | instruction | 0 | 36,078 | 12 | 72,156 |
Tags: greedy, sortings
Correct Solution:
```
n=int(input())
l1,l2=[],[]
for i in range(n):
a,b=map(int,input().split())
if(a<b):
l1.append([[a,b],i+1])
else:
l2.append([[a,b],i+1])
l1.sort(reverse=True)
l2.sort()
if(len(l1)>len(l2)):
print(len(l1))
for i in l1:
print(i[1],end=' ')
else:
print(len(l2))
for i in l2:
print(i[1],end=' ')
``` | output | 1 | 36,078 | 12 | 72,157 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n pairs of integers (a_1, b_1), (a_2, b_2), …, (a_n, b_n). All of the integers in the pairs are distinct and are in the range from 1 to 2 ⋅ n inclusive.
Let's call a sequence of integers x_1, x_2, …, x_{2k} good if either
* x_1 < x_2 > x_3 < … < x_{2k-2} > x_{2k-1} < x_{2k}, or
* x_1 > x_2 < x_3 > … > x_{2k-2} < x_{2k-1} > x_{2k}.
You need to choose a subset of distinct indices i_1, i_2, …, i_t and their order in a way that if you write down all numbers from the pairs in a single sequence (the sequence would be a_{i_1}, b_{i_1}, a_{i_2}, b_{i_2}, …, a_{i_t}, b_{i_t}), this sequence is good.
What is the largest subset of indices you can choose? You also need to construct the corresponding index sequence i_1, i_2, …, i_t.
Input
The first line contains single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of pairs.
Each of the next n lines contain two numbers — a_i and b_i (1 ≤ a_i, b_i ≤ 2 ⋅ n) — the elements of the pairs.
It is guaranteed that all integers in the pairs are distinct, that is, every integer from 1 to 2 ⋅ n is mentioned exactly once.
Output
In the first line print a single integer t — the number of pairs in the answer.
Then print t distinct integers i_1, i_2, …, i_t — the indexes of pairs in the corresponding order.
Examples
Input
5
1 7
6 4
2 10
9 8
3 5
Output
3
1 5 3
Input
3
5 4
3 2
6 1
Output
3
3 2 1
Note
The final sequence in the first example is 1 < 7 > 3 < 5 > 2 < 10.
The final sequence in the second example is 6 > 1 < 3 > 2 < 5 > 4. | instruction | 0 | 36,079 | 12 | 72,158 |
Tags: greedy, sortings
Correct Solution:
```
n = int(input())
v = []
u = []
for i in range(n):
x = input().split(' ')
a = int(x[0])
b = int(x[1])
if a > b:
v.append((a,b,i + 1))
else:
u.append((a,b,i+1))
'''nr = 1
sol = [str(v[0][2])]
act = v[0][1]
i = 1
n = len(v)
while i < n:
while i < n and v[i][0] < act:
i += 1
if i < n:
nr += 1
sol.append(str(v[i][2]))
act = v[i][1]
i += 1
u = sorted(uv, key = lambda x:x[1])
nr2 = 1
sol2 = [str(u[0][2])]
act = u[0][1]
i = 1
n = len(u)
while i < n:
while i < n and u[i][0] < act:
i += 1
if i < n:
nr2 += 1
sol2.append(str(u[i][2]))
act = u[i][1]
i += 1'''
if len(u) > len(v):
u = sorted(u, key = lambda x:x[1], reverse = True)
print(len(u))
sol = []
for i in range(len(u)):
sol.append(str(u[i][2]))
print(' '.join(sol))
else:
v = sorted(v, key = lambda x:x[1], reverse = False)
print(len(v))
sol = []
for i in range(len(v)):
sol.append(str(v[i][2]))
print(' '.join(sol))
``` | output | 1 | 36,079 | 12 | 72,159 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n pairs of integers (a_1, b_1), (a_2, b_2), …, (a_n, b_n). All of the integers in the pairs are distinct and are in the range from 1 to 2 ⋅ n inclusive.
Let's call a sequence of integers x_1, x_2, …, x_{2k} good if either
* x_1 < x_2 > x_3 < … < x_{2k-2} > x_{2k-1} < x_{2k}, or
* x_1 > x_2 < x_3 > … > x_{2k-2} < x_{2k-1} > x_{2k}.
You need to choose a subset of distinct indices i_1, i_2, …, i_t and their order in a way that if you write down all numbers from the pairs in a single sequence (the sequence would be a_{i_1}, b_{i_1}, a_{i_2}, b_{i_2}, …, a_{i_t}, b_{i_t}), this sequence is good.
What is the largest subset of indices you can choose? You also need to construct the corresponding index sequence i_1, i_2, …, i_t.
Input
The first line contains single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of pairs.
Each of the next n lines contain two numbers — a_i and b_i (1 ≤ a_i, b_i ≤ 2 ⋅ n) — the elements of the pairs.
It is guaranteed that all integers in the pairs are distinct, that is, every integer from 1 to 2 ⋅ n is mentioned exactly once.
Output
In the first line print a single integer t — the number of pairs in the answer.
Then print t distinct integers i_1, i_2, …, i_t — the indexes of pairs in the corresponding order.
Examples
Input
5
1 7
6 4
2 10
9 8
3 5
Output
3
1 5 3
Input
3
5 4
3 2
6 1
Output
3
3 2 1
Note
The final sequence in the first example is 1 < 7 > 3 < 5 > 2 < 10.
The final sequence in the second example is 6 > 1 < 3 > 2 < 5 > 4. | instruction | 0 | 36,080 | 12 | 72,160 |
Tags: greedy, sortings
Correct Solution:
```
from sys import stdin
# stdin=open('input.txt')
def input():
return stdin.readline().strip()
# from sys import stdout
# stdout=open('input.txt',mode='w+')
# def print1(x, end='\n'):
# stdout.write(str(x) +end)
# a, b = map(int, input().split())
# l = list(map(int, input().split()))
# CODE BEGINS HERE.................
import math
n = int(input())
count1 = []
count2 = []
nums = []
for i in range(n):
x, y = map(int, input().split())
if x > y:
count1.append((y, x, i + 1))
elif y > x:
count2.append((y, x, i + 1))
nums.append((y, x, i))
print(max(len(count1), len(count2)))
if len(count1) > len(count2):
count1.sort()
for i in count1:
print(i[2], end = ' ')
print('')
else:
count2.sort(reverse = True)
for i in count2:
print(i[2], end = ' ')
print('')
# CODE ENDS HERE....................
# stdout.close()
``` | output | 1 | 36,080 | 12 | 72,161 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n pairs of integers (a_1, b_1), (a_2, b_2), …, (a_n, b_n). All of the integers in the pairs are distinct and are in the range from 1 to 2 ⋅ n inclusive.
Let's call a sequence of integers x_1, x_2, …, x_{2k} good if either
* x_1 < x_2 > x_3 < … < x_{2k-2} > x_{2k-1} < x_{2k}, or
* x_1 > x_2 < x_3 > … > x_{2k-2} < x_{2k-1} > x_{2k}.
You need to choose a subset of distinct indices i_1, i_2, …, i_t and their order in a way that if you write down all numbers from the pairs in a single sequence (the sequence would be a_{i_1}, b_{i_1}, a_{i_2}, b_{i_2}, …, a_{i_t}, b_{i_t}), this sequence is good.
What is the largest subset of indices you can choose? You also need to construct the corresponding index sequence i_1, i_2, …, i_t.
Input
The first line contains single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of pairs.
Each of the next n lines contain two numbers — a_i and b_i (1 ≤ a_i, b_i ≤ 2 ⋅ n) — the elements of the pairs.
It is guaranteed that all integers in the pairs are distinct, that is, every integer from 1 to 2 ⋅ n is mentioned exactly once.
Output
In the first line print a single integer t — the number of pairs in the answer.
Then print t distinct integers i_1, i_2, …, i_t — the indexes of pairs in the corresponding order.
Examples
Input
5
1 7
6 4
2 10
9 8
3 5
Output
3
1 5 3
Input
3
5 4
3 2
6 1
Output
3
3 2 1
Note
The final sequence in the first example is 1 < 7 > 3 < 5 > 2 < 10.
The final sequence in the second example is 6 > 1 < 3 > 2 < 5 > 4. | instruction | 0 | 36,081 | 12 | 72,162 |
Tags: greedy, sortings
Correct Solution:
```
n = int(input())
a = list()
f = []
for i in range(n):
cur = [list(map(int, input().split())), i + 1]
if cur[0][0] < cur[0][1]:
f.append(cur)
else:
a.append(cur)
if len(f) >= n // 2:
f.sort(key=lambda x: x[0][0], reverse=True)
print(len(f))
ans = ''
for i in f:
ans += str(i[1]) + ' '
print(ans)
else:
a.sort(key=lambda x: x[0][0], reverse=False)
print(len(a))
ans = ''
for i in a:
ans += str(i[1]) + ' '
print(ans)
``` | output | 1 | 36,081 | 12 | 72,163 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n pairs of integers (a_1, b_1), (a_2, b_2), …, (a_n, b_n). All of the integers in the pairs are distinct and are in the range from 1 to 2 ⋅ n inclusive.
Let's call a sequence of integers x_1, x_2, …, x_{2k} good if either
* x_1 < x_2 > x_3 < … < x_{2k-2} > x_{2k-1} < x_{2k}, or
* x_1 > x_2 < x_3 > … > x_{2k-2} < x_{2k-1} > x_{2k}.
You need to choose a subset of distinct indices i_1, i_2, …, i_t and their order in a way that if you write down all numbers from the pairs in a single sequence (the sequence would be a_{i_1}, b_{i_1}, a_{i_2}, b_{i_2}, …, a_{i_t}, b_{i_t}), this sequence is good.
What is the largest subset of indices you can choose? You also need to construct the corresponding index sequence i_1, i_2, …, i_t.
Input
The first line contains single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of pairs.
Each of the next n lines contain two numbers — a_i and b_i (1 ≤ a_i, b_i ≤ 2 ⋅ n) — the elements of the pairs.
It is guaranteed that all integers in the pairs are distinct, that is, every integer from 1 to 2 ⋅ n is mentioned exactly once.
Output
In the first line print a single integer t — the number of pairs in the answer.
Then print t distinct integers i_1, i_2, …, i_t — the indexes of pairs in the corresponding order.
Examples
Input
5
1 7
6 4
2 10
9 8
3 5
Output
3
1 5 3
Input
3
5 4
3 2
6 1
Output
3
3 2 1
Note
The final sequence in the first example is 1 < 7 > 3 < 5 > 2 < 10.
The final sequence in the second example is 6 > 1 < 3 > 2 < 5 > 4. | instruction | 0 | 36,082 | 12 | 72,164 |
Tags: greedy, sortings
Correct Solution:
```
def solve():
N = int(input())
incr = []
decr = []
for i in range(1,N+1):
a, b = map(int, input().split())
if a > b:
decr.append((a,b,i))
else:
incr.append((a,b,i))
result1 = []
result2 = []
if decr:
decr.sort(key = lambda x:x[1])
result1.append(decr[0])
for i in range(1, len(decr)):
a, b, idx = decr[i]
if a > result1[i-1][1]:
result1.append((a,b,idx))
if incr:
incr.sort(key = lambda x:x[1])
incr.reverse()
result2.append(incr[0])
for i in range(1, len(incr)):
a, b, idx = incr[i]
if a < result2[i-1][1]:
result2.append((a,b,idx))
if len(result1) > len(result2):
print (len(result1))
print (' '.join(str(k[2]) for k in result1))
else:
print (len(result2))
print (' '.join(str(k[2]) for k in result2))
if __name__ == "__main__":
solve()
``` | output | 1 | 36,082 | 12 | 72,165 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n pairs of integers (a_1, b_1), (a_2, b_2), …, (a_n, b_n). All of the integers in the pairs are distinct and are in the range from 1 to 2 ⋅ n inclusive.
Let's call a sequence of integers x_1, x_2, …, x_{2k} good if either
* x_1 < x_2 > x_3 < … < x_{2k-2} > x_{2k-1} < x_{2k}, or
* x_1 > x_2 < x_3 > … > x_{2k-2} < x_{2k-1} > x_{2k}.
You need to choose a subset of distinct indices i_1, i_2, …, i_t and their order in a way that if you write down all numbers from the pairs in a single sequence (the sequence would be a_{i_1}, b_{i_1}, a_{i_2}, b_{i_2}, …, a_{i_t}, b_{i_t}), this sequence is good.
What is the largest subset of indices you can choose? You also need to construct the corresponding index sequence i_1, i_2, …, i_t.
Input
The first line contains single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of pairs.
Each of the next n lines contain two numbers — a_i and b_i (1 ≤ a_i, b_i ≤ 2 ⋅ n) — the elements of the pairs.
It is guaranteed that all integers in the pairs are distinct, that is, every integer from 1 to 2 ⋅ n is mentioned exactly once.
Output
In the first line print a single integer t — the number of pairs in the answer.
Then print t distinct integers i_1, i_2, …, i_t — the indexes of pairs in the corresponding order.
Examples
Input
5
1 7
6 4
2 10
9 8
3 5
Output
3
1 5 3
Input
3
5 4
3 2
6 1
Output
3
3 2 1
Note
The final sequence in the first example is 1 < 7 > 3 < 5 > 2 < 10.
The final sequence in the second example is 6 > 1 < 3 > 2 < 5 > 4. | instruction | 0 | 36,083 | 12 | 72,166 |
Tags: greedy, sortings
Correct Solution:
```
from sys import stdin
n=int(stdin.readline().strip())
s=[list(map(int,stdin.readline().strip().split())) for i in range(n)]
s1=[]
s2=[]
for i in range(n):
if s[i][0]>s[i][1]:
s1.append(s[i][::-1]+[i])
if s[i][0]<s[i][1]:
s2.append(s[i][::-1]+[i])
s1.sort()
s2.sort(reverse=True)
ans1=[]
ans2=[]
if len(s1)>0:
ans1=[s1[0]]
if len(s2)>0:
ans2=[s2[0]]
for i in range(len(s1)):
if ans1[-1][0]<s1[i][0]:
ans1.append(s1[i])
for i in range(len(s2)):
if ans2[-1][0]>s2[i][0]:
ans2.append(s2[i])
if len(ans1)>len(ans2):
r=[]
for i in ans1:
r.append(i[2]+1)
print(len(r))
print(*r)
else:
r=[]
for i in ans2:
r.append(i[2]+1)
print(len(r))
print(*r)
``` | output | 1 | 36,083 | 12 | 72,167 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n pairs of integers (a_1, b_1), (a_2, b_2), …, (a_n, b_n). All of the integers in the pairs are distinct and are in the range from 1 to 2 ⋅ n inclusive.
Let's call a sequence of integers x_1, x_2, …, x_{2k} good if either
* x_1 < x_2 > x_3 < … < x_{2k-2} > x_{2k-1} < x_{2k}, or
* x_1 > x_2 < x_3 > … > x_{2k-2} < x_{2k-1} > x_{2k}.
You need to choose a subset of distinct indices i_1, i_2, …, i_t and their order in a way that if you write down all numbers from the pairs in a single sequence (the sequence would be a_{i_1}, b_{i_1}, a_{i_2}, b_{i_2}, …, a_{i_t}, b_{i_t}), this sequence is good.
What is the largest subset of indices you can choose? You also need to construct the corresponding index sequence i_1, i_2, …, i_t.
Input
The first line contains single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of pairs.
Each of the next n lines contain two numbers — a_i and b_i (1 ≤ a_i, b_i ≤ 2 ⋅ n) — the elements of the pairs.
It is guaranteed that all integers in the pairs are distinct, that is, every integer from 1 to 2 ⋅ n is mentioned exactly once.
Output
In the first line print a single integer t — the number of pairs in the answer.
Then print t distinct integers i_1, i_2, …, i_t — the indexes of pairs in the corresponding order.
Examples
Input
5
1 7
6 4
2 10
9 8
3 5
Output
3
1 5 3
Input
3
5 4
3 2
6 1
Output
3
3 2 1
Note
The final sequence in the first example is 1 < 7 > 3 < 5 > 2 < 10.
The final sequence in the second example is 6 > 1 < 3 > 2 < 5 > 4. | instruction | 0 | 36,084 | 12 | 72,168 |
Tags: greedy, sortings
Correct Solution:
```
n=int(input())
group1=[]; group2=[]
for i in range(n):
a=[int(x) for x in input().split()]
if a[0]<a[1]:
group1.append((a,i+1))
else:
group2.append((a,i+1))
answer=[]
if len(group1)>len(group2):
group1.sort(reverse=True)
print(len(group1))
for item in group1:
answer.append(item[1])
else:
group2.sort()
print(len(group2))
for item in group2:
answer.append(item[1])
print(*answer)
``` | output | 1 | 36,084 | 12 | 72,169 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n pairs of integers (a_1, b_1), (a_2, b_2), …, (a_n, b_n). All of the integers in the pairs are distinct and are in the range from 1 to 2 ⋅ n inclusive.
Let's call a sequence of integers x_1, x_2, …, x_{2k} good if either
* x_1 < x_2 > x_3 < … < x_{2k-2} > x_{2k-1} < x_{2k}, or
* x_1 > x_2 < x_3 > … > x_{2k-2} < x_{2k-1} > x_{2k}.
You need to choose a subset of distinct indices i_1, i_2, …, i_t and their order in a way that if you write down all numbers from the pairs in a single sequence (the sequence would be a_{i_1}, b_{i_1}, a_{i_2}, b_{i_2}, …, a_{i_t}, b_{i_t}), this sequence is good.
What is the largest subset of indices you can choose? You also need to construct the corresponding index sequence i_1, i_2, …, i_t.
Input
The first line contains single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of pairs.
Each of the next n lines contain two numbers — a_i and b_i (1 ≤ a_i, b_i ≤ 2 ⋅ n) — the elements of the pairs.
It is guaranteed that all integers in the pairs are distinct, that is, every integer from 1 to 2 ⋅ n is mentioned exactly once.
Output
In the first line print a single integer t — the number of pairs in the answer.
Then print t distinct integers i_1, i_2, …, i_t — the indexes of pairs in the corresponding order.
Examples
Input
5
1 7
6 4
2 10
9 8
3 5
Output
3
1 5 3
Input
3
5 4
3 2
6 1
Output
3
3 2 1
Note
The final sequence in the first example is 1 < 7 > 3 < 5 > 2 < 10.
The final sequence in the second example is 6 > 1 < 3 > 2 < 5 > 4. | instruction | 0 | 36,085 | 12 | 72,170 |
Tags: greedy, sortings
Correct Solution:
```
n=int(input())
l=[]
negative=[]
positive=[]
for i in range(n):
a,b=input().split()
a,b=[int(a),int(b)]
l.append([a,b])
if (b-a)>0:
negative.append([a,b,i])
else:
positive.append([a,b,i])
if len(negative)>len(positive):
print(len(negative))
negative.sort(key=lambda negative: negative[0], reverse=True)
print(' '.join(map(str, [(i[2]+1) for i in negative])))
else:
print(len(positive))
positive.sort(key=lambda positive: positive[0])
print(' '.join(map(str, [(i[2]+1) for i in positive])))
``` | output | 1 | 36,085 | 12 | 72,171 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n pairs of integers (a_1, b_1), (a_2, b_2), …, (a_n, b_n). All of the integers in the pairs are distinct and are in the range from 1 to 2 ⋅ n inclusive.
Let's call a sequence of integers x_1, x_2, …, x_{2k} good if either
* x_1 < x_2 > x_3 < … < x_{2k-2} > x_{2k-1} < x_{2k}, or
* x_1 > x_2 < x_3 > … > x_{2k-2} < x_{2k-1} > x_{2k}.
You need to choose a subset of distinct indices i_1, i_2, …, i_t and their order in a way that if you write down all numbers from the pairs in a single sequence (the sequence would be a_{i_1}, b_{i_1}, a_{i_2}, b_{i_2}, …, a_{i_t}, b_{i_t}), this sequence is good.
What is the largest subset of indices you can choose? You also need to construct the corresponding index sequence i_1, i_2, …, i_t.
Input
The first line contains single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of pairs.
Each of the next n lines contain two numbers — a_i and b_i (1 ≤ a_i, b_i ≤ 2 ⋅ n) — the elements of the pairs.
It is guaranteed that all integers in the pairs are distinct, that is, every integer from 1 to 2 ⋅ n is mentioned exactly once.
Output
In the first line print a single integer t — the number of pairs in the answer.
Then print t distinct integers i_1, i_2, …, i_t — the indexes of pairs in the corresponding order.
Examples
Input
5
1 7
6 4
2 10
9 8
3 5
Output
3
1 5 3
Input
3
5 4
3 2
6 1
Output
3
3 2 1
Note
The final sequence in the first example is 1 < 7 > 3 < 5 > 2 < 10.
The final sequence in the second example is 6 > 1 < 3 > 2 < 5 > 4.
Submitted Solution:
```
n=int(input())
a=[]
b=[]
for i in range(n):
x,y=list(map(int,input().split()))
if x>y:
a.append([x,y,i])
if x<y:
b.append([x,y,i])
a.sort()
b.sort(reverse=True)
if len(a)>len(b):
c=[]
for i in range(len(a)):
c.append(a[i][2]+1)
print(len(c))
print(*c)
else:
c=[]
for i in range(len(b)):
c.append(b[i][2]+1)
print(len(c))
print(*c)
``` | instruction | 0 | 36,086 | 12 | 72,172 |
Yes | output | 1 | 36,086 | 12 | 72,173 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n pairs of integers (a_1, b_1), (a_2, b_2), …, (a_n, b_n). All of the integers in the pairs are distinct and are in the range from 1 to 2 ⋅ n inclusive.
Let's call a sequence of integers x_1, x_2, …, x_{2k} good if either
* x_1 < x_2 > x_3 < … < x_{2k-2} > x_{2k-1} < x_{2k}, or
* x_1 > x_2 < x_3 > … > x_{2k-2} < x_{2k-1} > x_{2k}.
You need to choose a subset of distinct indices i_1, i_2, …, i_t and their order in a way that if you write down all numbers from the pairs in a single sequence (the sequence would be a_{i_1}, b_{i_1}, a_{i_2}, b_{i_2}, …, a_{i_t}, b_{i_t}), this sequence is good.
What is the largest subset of indices you can choose? You also need to construct the corresponding index sequence i_1, i_2, …, i_t.
Input
The first line contains single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of pairs.
Each of the next n lines contain two numbers — a_i and b_i (1 ≤ a_i, b_i ≤ 2 ⋅ n) — the elements of the pairs.
It is guaranteed that all integers in the pairs are distinct, that is, every integer from 1 to 2 ⋅ n is mentioned exactly once.
Output
In the first line print a single integer t — the number of pairs in the answer.
Then print t distinct integers i_1, i_2, …, i_t — the indexes of pairs in the corresponding order.
Examples
Input
5
1 7
6 4
2 10
9 8
3 5
Output
3
1 5 3
Input
3
5 4
3 2
6 1
Output
3
3 2 1
Note
The final sequence in the first example is 1 < 7 > 3 < 5 > 2 < 10.
The final sequence in the second example is 6 > 1 < 3 > 2 < 5 > 4.
Submitted Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
from collections import defaultdict
from itertools import permutations
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now-----------------------------------------------------
n=int(input())
a=list()
b=list()
for i in range (n):
x,y=map(int,input().split())
if y>=x:
a.append((x,y,i+1))
else:
b.append((x,y,i+1))
a.sort(reverse=True)
b.sort()
if len(a)>=len(b):
print(len(a))
for i in range (len(a)):
print(a[i][2],end=' ')
print()
else:
print(len(b))
for i in range (len(b)):
print(b[i][2],end=' ')
print()
``` | instruction | 0 | 36,087 | 12 | 72,174 |
Yes | output | 1 | 36,087 | 12 | 72,175 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n pairs of integers (a_1, b_1), (a_2, b_2), …, (a_n, b_n). All of the integers in the pairs are distinct and are in the range from 1 to 2 ⋅ n inclusive.
Let's call a sequence of integers x_1, x_2, …, x_{2k} good if either
* x_1 < x_2 > x_3 < … < x_{2k-2} > x_{2k-1} < x_{2k}, or
* x_1 > x_2 < x_3 > … > x_{2k-2} < x_{2k-1} > x_{2k}.
You need to choose a subset of distinct indices i_1, i_2, …, i_t and their order in a way that if you write down all numbers from the pairs in a single sequence (the sequence would be a_{i_1}, b_{i_1}, a_{i_2}, b_{i_2}, …, a_{i_t}, b_{i_t}), this sequence is good.
What is the largest subset of indices you can choose? You also need to construct the corresponding index sequence i_1, i_2, …, i_t.
Input
The first line contains single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of pairs.
Each of the next n lines contain two numbers — a_i and b_i (1 ≤ a_i, b_i ≤ 2 ⋅ n) — the elements of the pairs.
It is guaranteed that all integers in the pairs are distinct, that is, every integer from 1 to 2 ⋅ n is mentioned exactly once.
Output
In the first line print a single integer t — the number of pairs in the answer.
Then print t distinct integers i_1, i_2, …, i_t — the indexes of pairs in the corresponding order.
Examples
Input
5
1 7
6 4
2 10
9 8
3 5
Output
3
1 5 3
Input
3
5 4
3 2
6 1
Output
3
3 2 1
Note
The final sequence in the first example is 1 < 7 > 3 < 5 > 2 < 10.
The final sequence in the second example is 6 > 1 < 3 > 2 < 5 > 4.
Submitted Solution:
```
from sys import stdin
from bisect import bisect_left as bl
input=stdin.readline
n=int(input())
a=[]
b=[]
for i in range(n):
c,d=map(int,input().split())
if c<d:
a.append([d,i])
else:
b.append([c,i])
a.sort(reverse=True)
b.sort()
if len(a)>len(b):
print(len(a))
for i in a:
print(i[1]+1,end=' ')
else:
print(len(b))
for i in b:
print(i[1]+1,end=' ')
``` | instruction | 0 | 36,088 | 12 | 72,176 |
Yes | output | 1 | 36,088 | 12 | 72,177 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n pairs of integers (a_1, b_1), (a_2, b_2), …, (a_n, b_n). All of the integers in the pairs are distinct and are in the range from 1 to 2 ⋅ n inclusive.
Let's call a sequence of integers x_1, x_2, …, x_{2k} good if either
* x_1 < x_2 > x_3 < … < x_{2k-2} > x_{2k-1} < x_{2k}, or
* x_1 > x_2 < x_3 > … > x_{2k-2} < x_{2k-1} > x_{2k}.
You need to choose a subset of distinct indices i_1, i_2, …, i_t and their order in a way that if you write down all numbers from the pairs in a single sequence (the sequence would be a_{i_1}, b_{i_1}, a_{i_2}, b_{i_2}, …, a_{i_t}, b_{i_t}), this sequence is good.
What is the largest subset of indices you can choose? You also need to construct the corresponding index sequence i_1, i_2, …, i_t.
Input
The first line contains single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of pairs.
Each of the next n lines contain two numbers — a_i and b_i (1 ≤ a_i, b_i ≤ 2 ⋅ n) — the elements of the pairs.
It is guaranteed that all integers in the pairs are distinct, that is, every integer from 1 to 2 ⋅ n is mentioned exactly once.
Output
In the first line print a single integer t — the number of pairs in the answer.
Then print t distinct integers i_1, i_2, …, i_t — the indexes of pairs in the corresponding order.
Examples
Input
5
1 7
6 4
2 10
9 8
3 5
Output
3
1 5 3
Input
3
5 4
3 2
6 1
Output
3
3 2 1
Note
The final sequence in the first example is 1 < 7 > 3 < 5 > 2 < 10.
The final sequence in the second example is 6 > 1 < 3 > 2 < 5 > 4.
Submitted Solution:
```
import io, os
input = io.StringIO(os.read(0, os.fstat(0).st_size).decode()).readline
n = int(input())
a = []
b = []
for i in range(n):
x, y = map(int, input().split())
x = (x, y, i + 1)
if x[0] > x[1]:
a.append(x)
else:
b.append(x)
#print(b)
if len(a) > len(b):
a.sort(key = lambda x : x[1])
print(len(a))
for c in a:
print(c[2], end = ' ')
else:
b.sort(key = lambda x : -x[0])
#print(b)
print(len(b))
for c in b:
print(c[2], end = ' ')
``` | instruction | 0 | 36,089 | 12 | 72,178 |
Yes | output | 1 | 36,089 | 12 | 72,179 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n pairs of integers (a_1, b_1), (a_2, b_2), …, (a_n, b_n). All of the integers in the pairs are distinct and are in the range from 1 to 2 ⋅ n inclusive.
Let's call a sequence of integers x_1, x_2, …, x_{2k} good if either
* x_1 < x_2 > x_3 < … < x_{2k-2} > x_{2k-1} < x_{2k}, or
* x_1 > x_2 < x_3 > … > x_{2k-2} < x_{2k-1} > x_{2k}.
You need to choose a subset of distinct indices i_1, i_2, …, i_t and their order in a way that if you write down all numbers from the pairs in a single sequence (the sequence would be a_{i_1}, b_{i_1}, a_{i_2}, b_{i_2}, …, a_{i_t}, b_{i_t}), this sequence is good.
What is the largest subset of indices you can choose? You also need to construct the corresponding index sequence i_1, i_2, …, i_t.
Input
The first line contains single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of pairs.
Each of the next n lines contain two numbers — a_i and b_i (1 ≤ a_i, b_i ≤ 2 ⋅ n) — the elements of the pairs.
It is guaranteed that all integers in the pairs are distinct, that is, every integer from 1 to 2 ⋅ n is mentioned exactly once.
Output
In the first line print a single integer t — the number of pairs in the answer.
Then print t distinct integers i_1, i_2, …, i_t — the indexes of pairs in the corresponding order.
Examples
Input
5
1 7
6 4
2 10
9 8
3 5
Output
3
1 5 3
Input
3
5 4
3 2
6 1
Output
3
3 2 1
Note
The final sequence in the first example is 1 < 7 > 3 < 5 > 2 < 10.
The final sequence in the second example is 6 > 1 < 3 > 2 < 5 > 4.
Submitted Solution:
```
t = int(input())
agb = []
bga = []
for tt in range(t):
x, y = input().split()
x, y = int(x), int(y)
if x<y:
bga.append([x, y, tt+1])
elif x>y:
agb.append([x, y, tt+1])
if len(bga)>len(agb):
bga.sort(reverse=True, key=lambda x: x[1])
print(' '.join(map(lambda x: str(x[2]), bga)))
else:
agb.sort(key=lambda x: x[1])
print(' '.join(map(lambda x: str(x[2]), agb)))
``` | instruction | 0 | 36,090 | 12 | 72,180 |
No | output | 1 | 36,090 | 12 | 72,181 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n pairs of integers (a_1, b_1), (a_2, b_2), …, (a_n, b_n). All of the integers in the pairs are distinct and are in the range from 1 to 2 ⋅ n inclusive.
Let's call a sequence of integers x_1, x_2, …, x_{2k} good if either
* x_1 < x_2 > x_3 < … < x_{2k-2} > x_{2k-1} < x_{2k}, or
* x_1 > x_2 < x_3 > … > x_{2k-2} < x_{2k-1} > x_{2k}.
You need to choose a subset of distinct indices i_1, i_2, …, i_t and their order in a way that if you write down all numbers from the pairs in a single sequence (the sequence would be a_{i_1}, b_{i_1}, a_{i_2}, b_{i_2}, …, a_{i_t}, b_{i_t}), this sequence is good.
What is the largest subset of indices you can choose? You also need to construct the corresponding index sequence i_1, i_2, …, i_t.
Input
The first line contains single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of pairs.
Each of the next n lines contain two numbers — a_i and b_i (1 ≤ a_i, b_i ≤ 2 ⋅ n) — the elements of the pairs.
It is guaranteed that all integers in the pairs are distinct, that is, every integer from 1 to 2 ⋅ n is mentioned exactly once.
Output
In the first line print a single integer t — the number of pairs in the answer.
Then print t distinct integers i_1, i_2, …, i_t — the indexes of pairs in the corresponding order.
Examples
Input
5
1 7
6 4
2 10
9 8
3 5
Output
3
1 5 3
Input
3
5 4
3 2
6 1
Output
3
3 2 1
Note
The final sequence in the first example is 1 < 7 > 3 < 5 > 2 < 10.
The final sequence in the second example is 6 > 1 < 3 > 2 < 5 > 4.
Submitted Solution:
```
n = int(input())
a = []
b = []
for i in range(n):
f = list(map(int, input().split())) + [i+1]
if f[0] < f[1]:
a += [f]
else:
b += [f]
a.sort(key = lambda x: x[0])
b.sort(key = lambda x: x[1])
if len(a) < len(b):
a = b
print(len(a))
print(' '.join(str(i[2]) for i in a))
``` | instruction | 0 | 36,091 | 12 | 72,182 |
No | output | 1 | 36,091 | 12 | 72,183 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n pairs of integers (a_1, b_1), (a_2, b_2), …, (a_n, b_n). All of the integers in the pairs are distinct and are in the range from 1 to 2 ⋅ n inclusive.
Let's call a sequence of integers x_1, x_2, …, x_{2k} good if either
* x_1 < x_2 > x_3 < … < x_{2k-2} > x_{2k-1} < x_{2k}, or
* x_1 > x_2 < x_3 > … > x_{2k-2} < x_{2k-1} > x_{2k}.
You need to choose a subset of distinct indices i_1, i_2, …, i_t and their order in a way that if you write down all numbers from the pairs in a single sequence (the sequence would be a_{i_1}, b_{i_1}, a_{i_2}, b_{i_2}, …, a_{i_t}, b_{i_t}), this sequence is good.
What is the largest subset of indices you can choose? You also need to construct the corresponding index sequence i_1, i_2, …, i_t.
Input
The first line contains single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of pairs.
Each of the next n lines contain two numbers — a_i and b_i (1 ≤ a_i, b_i ≤ 2 ⋅ n) — the elements of the pairs.
It is guaranteed that all integers in the pairs are distinct, that is, every integer from 1 to 2 ⋅ n is mentioned exactly once.
Output
In the first line print a single integer t — the number of pairs in the answer.
Then print t distinct integers i_1, i_2, …, i_t — the indexes of pairs in the corresponding order.
Examples
Input
5
1 7
6 4
2 10
9 8
3 5
Output
3
1 5 3
Input
3
5 4
3 2
6 1
Output
3
3 2 1
Note
The final sequence in the first example is 1 < 7 > 3 < 5 > 2 < 10.
The final sequence in the second example is 6 > 1 < 3 > 2 < 5 > 4.
Submitted Solution:
```
import sys
input = sys.stdin.readline
N = int(input())
X = []
Y = []
for i in range(N):
a, b = map(int, input().split())
if a < b:
X.append((a, b, i+1))
else:
Y.append((a, b, i+1))
if len(Y) > len(X):
X = Y
X = sorted(X, key = lambda x: -x[0])
print(len(X))
print(*[x[2] for x in X])
``` | instruction | 0 | 36,092 | 12 | 72,184 |
No | output | 1 | 36,092 | 12 | 72,185 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n pairs of integers (a_1, b_1), (a_2, b_2), …, (a_n, b_n). All of the integers in the pairs are distinct and are in the range from 1 to 2 ⋅ n inclusive.
Let's call a sequence of integers x_1, x_2, …, x_{2k} good if either
* x_1 < x_2 > x_3 < … < x_{2k-2} > x_{2k-1} < x_{2k}, or
* x_1 > x_2 < x_3 > … > x_{2k-2} < x_{2k-1} > x_{2k}.
You need to choose a subset of distinct indices i_1, i_2, …, i_t and their order in a way that if you write down all numbers from the pairs in a single sequence (the sequence would be a_{i_1}, b_{i_1}, a_{i_2}, b_{i_2}, …, a_{i_t}, b_{i_t}), this sequence is good.
What is the largest subset of indices you can choose? You also need to construct the corresponding index sequence i_1, i_2, …, i_t.
Input
The first line contains single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of pairs.
Each of the next n lines contain two numbers — a_i and b_i (1 ≤ a_i, b_i ≤ 2 ⋅ n) — the elements of the pairs.
It is guaranteed that all integers in the pairs are distinct, that is, every integer from 1 to 2 ⋅ n is mentioned exactly once.
Output
In the first line print a single integer t — the number of pairs in the answer.
Then print t distinct integers i_1, i_2, …, i_t — the indexes of pairs in the corresponding order.
Examples
Input
5
1 7
6 4
2 10
9 8
3 5
Output
3
1 5 3
Input
3
5 4
3 2
6 1
Output
3
3 2 1
Note
The final sequence in the first example is 1 < 7 > 3 < 5 > 2 < 10.
The final sequence in the second example is 6 > 1 < 3 > 2 < 5 > 4.
Submitted Solution:
```
def func(i):
return ar[i]
n=int(input())
ar=[[0 for x in range(2)] for y in range(n)]
for i in range(n):
ar[i][0],ar[i][1]=map(int,input().split())
mn=[]
mx=[]
for i in range(n):
if(ar[i][0]<ar[i][1]):
mn.append(i)
else:
mx.append(i)
if(len(mn)>len(mx)):
mn=sorted(mn, key = func)
print(len(mn))
for x in mn:
print (x+1,end=" ")
else:
mx=sorted(mx, key = func)
print(len(mx))
for x in mx:
print (x+1,end=" ")
``` | instruction | 0 | 36,093 | 12 | 72,186 |
No | output | 1 | 36,093 | 12 | 72,187 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
You are given n segments on the coordinate axis OX. Segments can intersect, lie inside each other and even coincide. The i-th segment is [l_i; r_i] (l_i ≤ r_i) and it covers all integer points j such that l_i ≤ j ≤ r_i.
The integer point is called bad if it is covered by strictly more than k segments.
Your task is to remove the minimum number of segments so that there are no bad points at all.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 2 ⋅ 10^5) — the number of segments and the maximum number of segments by which each integer point can be covered.
The next n lines contain segments. The i-th line contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ 2 ⋅ 10^5) — the endpoints of the i-th segment.
Output
In the first line print one integer m (0 ≤ m ≤ n) — the minimum number of segments you need to remove so that there are no bad points.
In the second line print m distinct integers p_1, p_2, ..., p_m (1 ≤ p_i ≤ n) — indices of segments you remove in any order. If there are multiple answers, you can print any of them.
Examples
Input
7 2
11 11
9 11
7 8
8 9
7 8
9 11
7 9
Output
3
4 6 7
Input
5 1
29 30
30 30
29 29
28 30
30 30
Output
3
1 4 5
Input
6 1
2 3
3 3
2 3
2 2
2 3
2 3
Output
4
1 3 5 6 | instruction | 0 | 36,159 | 12 | 72,318 |
Tags: data structures, greedy, sortings
Correct Solution:
```
from heapq import *
def main():
n, k = map(int, input().split())
E = []
opent = {}
for i in range(n):
l, r = map(int, input().split())
E.append([l, 1, i])
E.append([r, -1, i])
opent[i] = r
E.sort(key=lambda x: (x[0], -x[1]))
now_r = []
heapify(now_r)
cnt_delet = 0
ans = []
deleted = set()
for x, t, i in E:
if t == 1:
heappush(now_r, -(opent[i] * 10 ** 6 + i))
else:
if i not in deleted:
cnt_delet += 1
if len(now_r) - cnt_delet > k:
for _ in range(len(now_r) - cnt_delet - k):
nm = heappop(now_r)
ind = (-nm) % 10 ** 6
ans.append(ind + 1)
deleted.add(ind)
print(len(ans))
print(' '.join(list(map(str, ans))))
main()
``` | output | 1 | 36,159 | 12 | 72,319 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
You are given n segments on the coordinate axis OX. Segments can intersect, lie inside each other and even coincide. The i-th segment is [l_i; r_i] (l_i ≤ r_i) and it covers all integer points j such that l_i ≤ j ≤ r_i.
The integer point is called bad if it is covered by strictly more than k segments.
Your task is to remove the minimum number of segments so that there are no bad points at all.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 2 ⋅ 10^5) — the number of segments and the maximum number of segments by which each integer point can be covered.
The next n lines contain segments. The i-th line contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ 2 ⋅ 10^5) — the endpoints of the i-th segment.
Output
In the first line print one integer m (0 ≤ m ≤ n) — the minimum number of segments you need to remove so that there are no bad points.
In the second line print m distinct integers p_1, p_2, ..., p_m (1 ≤ p_i ≤ n) — indices of segments you remove in any order. If there are multiple answers, you can print any of them.
Examples
Input
7 2
11 11
9 11
7 8
8 9
7 8
9 11
7 9
Output
3
4 6 7
Input
5 1
29 30
30 30
29 29
28 30
30 30
Output
3
1 4 5
Input
6 1
2 3
3 3
2 3
2 2
2 3
2 3
Output
4
1 3 5 6 | instruction | 0 | 36,164 | 12 | 72,328 |
Tags: data structures, greedy, sortings
Correct Solution:
```
import sys
from heapq import *
n, k = map(int, input().split())
N = int(2e5+2)
ll = [[] for _ in range(N)]
rr = [[] for _ in range(N)]
vis = [0] * N
for i in range(n):
l, r = map(int, sys.stdin.readline().split())
ll[l].append((-r, i+1))
rr[r].append(i+1)
q = []
ans = []
size = 0
for i in range(1, N):
for j in ll[i]:
heappush(q, j)
size += 1
while size > k:
cur = heappop(q)
while vis[cur[1]]:
cur = heappop(q)
vis[cur[1]] = 1
ans.append(cur[1])
size -= 1
for j in rr[i]:
if not vis[j]:
vis[j] = 1
size -= 1
print(len(ans))
print(*ans)
``` | output | 1 | 36,164 | 12 | 72,329 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of length n consisting of zeros. You perform n actions with this array: during the i-th action, the following sequence of operations appears:
1. Choose the maximum by length subarray (continuous subsegment) consisting only of zeros, among all such segments choose the leftmost one;
2. Let this segment be [l; r]. If r-l+1 is odd (not divisible by 2) then assign (set) a[(l+r)/(2)] := i (where i is the number of the current action), otherwise (if r-l+1 is even) assign (set) a[(l+r-1)/(2)] := i.
Consider the array a of length 5 (initially a=[0, 0, 0, 0, 0]). Then it changes as follows:
1. Firstly, we choose the segment [1; 5] and assign a[3] := 1, so a becomes [0, 0, 1, 0, 0];
2. then we choose the segment [1; 2] and assign a[1] := 2, so a becomes [2, 0, 1, 0, 0];
3. then we choose the segment [4; 5] and assign a[4] := 3, so a becomes [2, 0, 1, 3, 0];
4. then we choose the segment [2; 2] and assign a[2] := 4, so a becomes [2, 4, 1, 3, 0];
5. and at last we choose the segment [5; 5] and assign a[5] := 5, so a becomes [2, 4, 1, 3, 5].
Your task is to find the array a of length n after performing all n actions. Note that the answer exists and unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the array a of length n after performing n actions described in the problem statement. Note that the answer exists and unique.
Example
Input
6
1
2
3
4
5
6
Output
1
1 2
2 1 3
3 1 2 4
2 4 1 3 5
3 4 1 5 2 6 | instruction | 0 | 36,227 | 12 | 72,454 |
Tags: constructive algorithms, data structures, sortings
Correct Solution:
```
def ri(): return int(input())
def ria(): return list(map(int, input().split()))
def ia_to_s(a): return ' '.join([str(s) for s in a])
import heapq
class Range(object):
def __init__(self, left, right):
self.left = left
self.right = right
def __repr__(self):
return f'Range: [{self.left},{self.right})'
def __lt__(self, other):
this_len = self.right-self.left
other_len = other.right-other.left
if this_len == other_len:
return self.left < other.left
else:
return this_len > other_len
def solve(n):
a = [0] * n
ranges = [Range(0, n)]
heapq.heapify(ranges)
iteration = 1
while len(ranges) > 0:
r = heapq.heappop(ranges)
i = (r.left + r.right - 1) // 2
a[i] = iteration
if i > r.left:
heapq.heappush(ranges, Range(r.left,i))
if r.right > (i+1):
heapq.heappush(ranges, Range(i+1, r.right))
iteration += 1
return a
def main():
for _ in range(ri()):
n = ri()
print(ia_to_s(solve(n)))
if __name__ == '__main__':
main()
``` | output | 1 | 36,227 | 12 | 72,455 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of length n consisting of zeros. You perform n actions with this array: during the i-th action, the following sequence of operations appears:
1. Choose the maximum by length subarray (continuous subsegment) consisting only of zeros, among all such segments choose the leftmost one;
2. Let this segment be [l; r]. If r-l+1 is odd (not divisible by 2) then assign (set) a[(l+r)/(2)] := i (where i is the number of the current action), otherwise (if r-l+1 is even) assign (set) a[(l+r-1)/(2)] := i.
Consider the array a of length 5 (initially a=[0, 0, 0, 0, 0]). Then it changes as follows:
1. Firstly, we choose the segment [1; 5] and assign a[3] := 1, so a becomes [0, 0, 1, 0, 0];
2. then we choose the segment [1; 2] and assign a[1] := 2, so a becomes [2, 0, 1, 0, 0];
3. then we choose the segment [4; 5] and assign a[4] := 3, so a becomes [2, 0, 1, 3, 0];
4. then we choose the segment [2; 2] and assign a[2] := 4, so a becomes [2, 4, 1, 3, 0];
5. and at last we choose the segment [5; 5] and assign a[5] := 5, so a becomes [2, 4, 1, 3, 5].
Your task is to find the array a of length n after performing all n actions. Note that the answer exists and unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the array a of length n after performing n actions described in the problem statement. Note that the answer exists and unique.
Example
Input
6
1
2
3
4
5
6
Output
1
1 2
2 1 3
3 1 2 4
2 4 1 3 5
3 4 1 5 2 6 | instruction | 0 | 36,228 | 12 | 72,456 |
Tags: constructive algorithms, data structures, sortings
Correct Solution:
```
import sys
input = sys.stdin.readline
from collections import *
from heapq import *
t = int(input())
for _ in range(t):
n = int(input())
a = [-1]*n
pq = [(n, 0, n-1)]
now = 1
while now<=n:
#print(pq)
_, l, r = heappop(pq)
if (r-l)%2==0:
m = (l+r)//2
else:
m = (l+r-1)//2
a[m] = now
now += 1
heappush(pq, (-(m-l), l, m-1))
heappush(pq, (-(r-m), m+1, r))
print(*a)
``` | output | 1 | 36,228 | 12 | 72,457 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of length n consisting of zeros. You perform n actions with this array: during the i-th action, the following sequence of operations appears:
1. Choose the maximum by length subarray (continuous subsegment) consisting only of zeros, among all such segments choose the leftmost one;
2. Let this segment be [l; r]. If r-l+1 is odd (not divisible by 2) then assign (set) a[(l+r)/(2)] := i (where i is the number of the current action), otherwise (if r-l+1 is even) assign (set) a[(l+r-1)/(2)] := i.
Consider the array a of length 5 (initially a=[0, 0, 0, 0, 0]). Then it changes as follows:
1. Firstly, we choose the segment [1; 5] and assign a[3] := 1, so a becomes [0, 0, 1, 0, 0];
2. then we choose the segment [1; 2] and assign a[1] := 2, so a becomes [2, 0, 1, 0, 0];
3. then we choose the segment [4; 5] and assign a[4] := 3, so a becomes [2, 0, 1, 3, 0];
4. then we choose the segment [2; 2] and assign a[2] := 4, so a becomes [2, 4, 1, 3, 0];
5. and at last we choose the segment [5; 5] and assign a[5] := 5, so a becomes [2, 4, 1, 3, 5].
Your task is to find the array a of length n after performing all n actions. Note that the answer exists and unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the array a of length n after performing n actions described in the problem statement. Note that the answer exists and unique.
Example
Input
6
1
2
3
4
5
6
Output
1
1 2
2 1 3
3 1 2 4
2 4 1 3 5
3 4 1 5 2 6 | instruction | 0 | 36,229 | 12 | 72,458 |
Tags: constructive algorithms, data structures, sortings
Correct Solution:
```
import sys
def answer(n):
ans = [0 for _ in range(n)]
stack = [(0, n-1)]
t_ans = [(0, 0) for _ in range(n)] #contain tuples of (-width, pos) for sorting
while len(stack) > 0:
tup = stack.pop()
l = tup[0]
r = tup[1]
mid = (l+r) // 2
w = -(r-l+1)
t_ans[mid] = ((w, mid))
if (mid-1) >= l:
stack.append((l, mid-1))
if r >= (mid+1):
stack.append((mid+1, r))
t_ans.sort()
for i in range(n):
pos = t_ans[i][1]
ans[pos] = i+1
return ans
def main():
t = int(sys.stdin.readline())
while t:
n = int(sys.stdin.readline())
print(*answer(n))
t -= 1
return
main()
``` | output | 1 | 36,229 | 12 | 72,459 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of length n consisting of zeros. You perform n actions with this array: during the i-th action, the following sequence of operations appears:
1. Choose the maximum by length subarray (continuous subsegment) consisting only of zeros, among all such segments choose the leftmost one;
2. Let this segment be [l; r]. If r-l+1 is odd (not divisible by 2) then assign (set) a[(l+r)/(2)] := i (where i is the number of the current action), otherwise (if r-l+1 is even) assign (set) a[(l+r-1)/(2)] := i.
Consider the array a of length 5 (initially a=[0, 0, 0, 0, 0]). Then it changes as follows:
1. Firstly, we choose the segment [1; 5] and assign a[3] := 1, so a becomes [0, 0, 1, 0, 0];
2. then we choose the segment [1; 2] and assign a[1] := 2, so a becomes [2, 0, 1, 0, 0];
3. then we choose the segment [4; 5] and assign a[4] := 3, so a becomes [2, 0, 1, 3, 0];
4. then we choose the segment [2; 2] and assign a[2] := 4, so a becomes [2, 4, 1, 3, 0];
5. and at last we choose the segment [5; 5] and assign a[5] := 5, so a becomes [2, 4, 1, 3, 5].
Your task is to find the array a of length n after performing all n actions. Note that the answer exists and unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the array a of length n after performing n actions described in the problem statement. Note that the answer exists and unique.
Example
Input
6
1
2
3
4
5
6
Output
1
1 2
2 1 3
3 1 2 4
2 4 1 3 5
3 4 1 5 2 6 | instruction | 0 | 36,230 | 12 | 72,460 |
Tags: constructive algorithms, data structures, sortings
Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
# import time,random,resource
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
mod2 = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)
def IF(c, t, f): return t if c else f
def YES(c): return IF(c, "YES", "NO")
def Yes(c): return IF(c, "Yes", "No")
def main():
t = I()
rr = []
for _ in range(t):
n = I()
t = [0] * n
q = []
heapq.heappush(q, (-n,0,n-1))
qi = 1
while q:
_,l,r = heapq.heappop(q)
m = (l+r) // 2
t[m] = qi
qi += 1
if l < m:
heapq.heappush(q, (-(m-l),l,m-1))
if m < r:
heapq.heappush(q, (-(r-m),m+1,r))
rr.append(JA(t, " "))
return JA(rr, "\n")
print(main())
``` | output | 1 | 36,230 | 12 | 72,461 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of length n consisting of zeros. You perform n actions with this array: during the i-th action, the following sequence of operations appears:
1. Choose the maximum by length subarray (continuous subsegment) consisting only of zeros, among all such segments choose the leftmost one;
2. Let this segment be [l; r]. If r-l+1 is odd (not divisible by 2) then assign (set) a[(l+r)/(2)] := i (where i is the number of the current action), otherwise (if r-l+1 is even) assign (set) a[(l+r-1)/(2)] := i.
Consider the array a of length 5 (initially a=[0, 0, 0, 0, 0]). Then it changes as follows:
1. Firstly, we choose the segment [1; 5] and assign a[3] := 1, so a becomes [0, 0, 1, 0, 0];
2. then we choose the segment [1; 2] and assign a[1] := 2, so a becomes [2, 0, 1, 0, 0];
3. then we choose the segment [4; 5] and assign a[4] := 3, so a becomes [2, 0, 1, 3, 0];
4. then we choose the segment [2; 2] and assign a[2] := 4, so a becomes [2, 4, 1, 3, 0];
5. and at last we choose the segment [5; 5] and assign a[5] := 5, so a becomes [2, 4, 1, 3, 5].
Your task is to find the array a of length n after performing all n actions. Note that the answer exists and unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the array a of length n after performing n actions described in the problem statement. Note that the answer exists and unique.
Example
Input
6
1
2
3
4
5
6
Output
1
1 2
2 1 3
3 1 2 4
2 4 1 3 5
3 4 1 5 2 6 | instruction | 0 | 36,231 | 12 | 72,462 |
Tags: constructive algorithms, data structures, sortings
Correct Solution:
```
from heapq import*
def push(l, start):
if l > 0:
heappush(hp, (-l, start))
for t in range(int(input())):
n = int(input())
a = [0] * n
k = 1
hp = [(-n,0)]
while hp:
l, i = heappop(hp)
l = -l
m = i + (l - 1) // 2
#print('m : ',m,'i :',i,'l : ',l)
a[m] = k
k+=1
push(m-i, i)
push(i+l-m-1, m+1)
print(*a)
``` | output | 1 | 36,231 | 12 | 72,463 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of length n consisting of zeros. You perform n actions with this array: during the i-th action, the following sequence of operations appears:
1. Choose the maximum by length subarray (continuous subsegment) consisting only of zeros, among all such segments choose the leftmost one;
2. Let this segment be [l; r]. If r-l+1 is odd (not divisible by 2) then assign (set) a[(l+r)/(2)] := i (where i is the number of the current action), otherwise (if r-l+1 is even) assign (set) a[(l+r-1)/(2)] := i.
Consider the array a of length 5 (initially a=[0, 0, 0, 0, 0]). Then it changes as follows:
1. Firstly, we choose the segment [1; 5] and assign a[3] := 1, so a becomes [0, 0, 1, 0, 0];
2. then we choose the segment [1; 2] and assign a[1] := 2, so a becomes [2, 0, 1, 0, 0];
3. then we choose the segment [4; 5] and assign a[4] := 3, so a becomes [2, 0, 1, 3, 0];
4. then we choose the segment [2; 2] and assign a[2] := 4, so a becomes [2, 4, 1, 3, 0];
5. and at last we choose the segment [5; 5] and assign a[5] := 5, so a becomes [2, 4, 1, 3, 5].
Your task is to find the array a of length n after performing all n actions. Note that the answer exists and unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the array a of length n after performing n actions described in the problem statement. Note that the answer exists and unique.
Example
Input
6
1
2
3
4
5
6
Output
1
1 2
2 1 3
3 1 2 4
2 4 1 3 5
3 4 1 5 2 6 | instruction | 0 | 36,232 | 12 | 72,464 |
Tags: constructive algorithms, data structures, sortings
Correct Solution:
```
import heapq
def solve():
n = int(input())
cur = 1
a = [0] * n
q = []
heapq.heappush(q, (-n, 0, n))
while q:
_, l, r = heapq.heappop(q)
mid = (l + r - 1) // 2
a[mid] = cur
cur += 1
if l < mid:
heapq.heappush(q, (l - mid, l, mid))
if mid + 1 < r:
heapq.heappush(q, ((mid + 1) - r, mid + 1, r))
print(*a)
t = int(input())
for _ in range(t):
solve()
``` | output | 1 | 36,232 | 12 | 72,465 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of length n consisting of zeros. You perform n actions with this array: during the i-th action, the following sequence of operations appears:
1. Choose the maximum by length subarray (continuous subsegment) consisting only of zeros, among all such segments choose the leftmost one;
2. Let this segment be [l; r]. If r-l+1 is odd (not divisible by 2) then assign (set) a[(l+r)/(2)] := i (where i is the number of the current action), otherwise (if r-l+1 is even) assign (set) a[(l+r-1)/(2)] := i.
Consider the array a of length 5 (initially a=[0, 0, 0, 0, 0]). Then it changes as follows:
1. Firstly, we choose the segment [1; 5] and assign a[3] := 1, so a becomes [0, 0, 1, 0, 0];
2. then we choose the segment [1; 2] and assign a[1] := 2, so a becomes [2, 0, 1, 0, 0];
3. then we choose the segment [4; 5] and assign a[4] := 3, so a becomes [2, 0, 1, 3, 0];
4. then we choose the segment [2; 2] and assign a[2] := 4, so a becomes [2, 4, 1, 3, 0];
5. and at last we choose the segment [5; 5] and assign a[5] := 5, so a becomes [2, 4, 1, 3, 5].
Your task is to find the array a of length n after performing all n actions. Note that the answer exists and unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the array a of length n after performing n actions described in the problem statement. Note that the answer exists and unique.
Example
Input
6
1
2
3
4
5
6
Output
1
1 2
2 1 3
3 1 2 4
2 4 1 3 5
3 4 1 5 2 6 | instruction | 0 | 36,233 | 12 | 72,466 |
Tags: constructive algorithms, data structures, sortings
Correct Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
res = [0]*(n+1)
dp = [[] for _ in range(n+1)]
# print(dp)
dp[n] = [1]
count = 1
for i in range(n,0,-1):
if len(dp[i]) > 0:
s_dp = sorted(dp[i])
# print(i, dp,s_dp)
for k in s_dp:
# print('k=',k,end=' ')
if (i-1)//2 > 0:
dp[(i-1)//2].append(k)
res[k+(i-1)//2] = count
count += 1
dp[i//2].append(k+(i+1)//2)
print(' '.join(list(map(str,res[1:]))))
``` | output | 1 | 36,233 | 12 | 72,467 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of length n consisting of zeros. You perform n actions with this array: during the i-th action, the following sequence of operations appears:
1. Choose the maximum by length subarray (continuous subsegment) consisting only of zeros, among all such segments choose the leftmost one;
2. Let this segment be [l; r]. If r-l+1 is odd (not divisible by 2) then assign (set) a[(l+r)/(2)] := i (where i is the number of the current action), otherwise (if r-l+1 is even) assign (set) a[(l+r-1)/(2)] := i.
Consider the array a of length 5 (initially a=[0, 0, 0, 0, 0]). Then it changes as follows:
1. Firstly, we choose the segment [1; 5] and assign a[3] := 1, so a becomes [0, 0, 1, 0, 0];
2. then we choose the segment [1; 2] and assign a[1] := 2, so a becomes [2, 0, 1, 0, 0];
3. then we choose the segment [4; 5] and assign a[4] := 3, so a becomes [2, 0, 1, 3, 0];
4. then we choose the segment [2; 2] and assign a[2] := 4, so a becomes [2, 4, 1, 3, 0];
5. and at last we choose the segment [5; 5] and assign a[5] := 5, so a becomes [2, 4, 1, 3, 5].
Your task is to find the array a of length n after performing all n actions. Note that the answer exists and unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the array a of length n after performing n actions described in the problem statement. Note that the answer exists and unique.
Example
Input
6
1
2
3
4
5
6
Output
1
1 2
2 1 3
3 1 2 4
2 4 1 3 5
3 4 1 5 2 6 | instruction | 0 | 36,234 | 12 | 72,468 |
Tags: constructive algorithms, data structures, sortings
Correct Solution:
```
import heapq
class Segment:
def __init__(self, li, ri) -> None:
self.size = ri - li + 1
self.li = li
self.ri = ri
def __str__(self) -> str:
return '(' + str(self.size) + ', ' + str(self.li) + ')'
def comparator(s, o):
if o.size > s.size:
return False
if o.size < s.size:
return True
return s.li < o.li
setattr(Segment, "__lt__", comparator)
if __name__ == '__main__':
for _ in range(int(input())):
n = int(input())
arr = [0 for _ in range(n)]
segs = [Segment(1, n)]
for i in range(1, n + 1):
seg = heapq.heappop(segs)
l = seg.size
if l % 2:
mp = ((seg.li + seg.ri) // 2)
else:
mp = ((seg.li + seg.ri - 1) // 2)
arr[mp - 1] = i
if seg.size > 1:
if seg.li < mp:
heapq.heappush(segs, Segment(seg.li, mp - 1))
if seg.ri > mp:
heapq.heappush(segs, Segment(mp + 1, seg.ri))
print(*arr)
``` | output | 1 | 36,234 | 12 | 72,469 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of length n consisting of zeros. You perform n actions with this array: during the i-th action, the following sequence of operations appears:
1. Choose the maximum by length subarray (continuous subsegment) consisting only of zeros, among all such segments choose the leftmost one;
2. Let this segment be [l; r]. If r-l+1 is odd (not divisible by 2) then assign (set) a[(l+r)/(2)] := i (where i is the number of the current action), otherwise (if r-l+1 is even) assign (set) a[(l+r-1)/(2)] := i.
Consider the array a of length 5 (initially a=[0, 0, 0, 0, 0]). Then it changes as follows:
1. Firstly, we choose the segment [1; 5] and assign a[3] := 1, so a becomes [0, 0, 1, 0, 0];
2. then we choose the segment [1; 2] and assign a[1] := 2, so a becomes [2, 0, 1, 0, 0];
3. then we choose the segment [4; 5] and assign a[4] := 3, so a becomes [2, 0, 1, 3, 0];
4. then we choose the segment [2; 2] and assign a[2] := 4, so a becomes [2, 4, 1, 3, 0];
5. and at last we choose the segment [5; 5] and assign a[5] := 5, so a becomes [2, 4, 1, 3, 5].
Your task is to find the array a of length n after performing all n actions. Note that the answer exists and unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the array a of length n after performing n actions described in the problem statement. Note that the answer exists and unique.
Example
Input
6
1
2
3
4
5
6
Output
1
1 2
2 1 3
3 1 2 4
2 4 1 3 5
3 4 1 5 2 6
Submitted Solution:
```
import heapq,sys
# import sys
input = sys.stdin.buffer.readline
for _ in range(int(input())):
n=int(input())
a=[0]*(n)
h=[(-n,(0,n-1))]
i=1
while i<=n:
len, (l,r)=heapq.heappop(h)
mid=(l+r)//2
a[mid]=i
heapq.heappush(h,(-(mid-l),(l,mid-1)))
heapq.heappush(h,(-(r-mid),(mid+1,r)))
i+=1
for i in range(n):
print(a[i],end=' ')
print()
``` | instruction | 0 | 36,235 | 12 | 72,470 |
Yes | output | 1 | 36,235 | 12 | 72,471 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of length n consisting of zeros. You perform n actions with this array: during the i-th action, the following sequence of operations appears:
1. Choose the maximum by length subarray (continuous subsegment) consisting only of zeros, among all such segments choose the leftmost one;
2. Let this segment be [l; r]. If r-l+1 is odd (not divisible by 2) then assign (set) a[(l+r)/(2)] := i (where i is the number of the current action), otherwise (if r-l+1 is even) assign (set) a[(l+r-1)/(2)] := i.
Consider the array a of length 5 (initially a=[0, 0, 0, 0, 0]). Then it changes as follows:
1. Firstly, we choose the segment [1; 5] and assign a[3] := 1, so a becomes [0, 0, 1, 0, 0];
2. then we choose the segment [1; 2] and assign a[1] := 2, so a becomes [2, 0, 1, 0, 0];
3. then we choose the segment [4; 5] and assign a[4] := 3, so a becomes [2, 0, 1, 3, 0];
4. then we choose the segment [2; 2] and assign a[2] := 4, so a becomes [2, 4, 1, 3, 0];
5. and at last we choose the segment [5; 5] and assign a[5] := 5, so a becomes [2, 4, 1, 3, 5].
Your task is to find the array a of length n after performing all n actions. Note that the answer exists and unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the array a of length n after performing n actions described in the problem statement. Note that the answer exists and unique.
Example
Input
6
1
2
3
4
5
6
Output
1
1 2
2 1 3
3 1 2 4
2 4 1 3 5
3 4 1 5 2 6
Submitted Solution:
```
# https://codeforces.com/contest/1353/problem/D
import sys
import os
import heapq
try:
path = "./file/input.txt"
if os.path.exists(path):
sys.stdin = open(path, 'r')
# sys.stdout = open(r"./file/output.txt", 'w')
except:
pass
class Node:
def __init__(self, n, left, right):
self.left = left
self.right = right
self.weight = n - right + left
def __lt__(self, other):
return self.weight < other.weight or (self.weight == other.weight and self.left < other.left)
t = int(input())
for _ in range(t):
n = int(input())
q = []
result = [0] * (n + 1)
heapq.heappush(q, Node(n, 1, n))
index = 1
while True:
if len(q) == 0:
break
node = heapq.heappop(q)
if node is None:
break
if node.left == node.right:
result[node.left] = index
index += 1
else:
middle = int((node.left + node.right) / 2)
result[middle] = index
index += 1
if node.left != middle:
heapq.heappush(q, Node(n, node.left, middle - 1))
heapq.heappush(q, Node(n, middle + 1, node.right))
print(" ".join(str(i) for i in result[1:]))
``` | instruction | 0 | 36,236 | 12 | 72,472 |
Yes | output | 1 | 36,236 | 12 | 72,473 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of length n consisting of zeros. You perform n actions with this array: during the i-th action, the following sequence of operations appears:
1. Choose the maximum by length subarray (continuous subsegment) consisting only of zeros, among all such segments choose the leftmost one;
2. Let this segment be [l; r]. If r-l+1 is odd (not divisible by 2) then assign (set) a[(l+r)/(2)] := i (where i is the number of the current action), otherwise (if r-l+1 is even) assign (set) a[(l+r-1)/(2)] := i.
Consider the array a of length 5 (initially a=[0, 0, 0, 0, 0]). Then it changes as follows:
1. Firstly, we choose the segment [1; 5] and assign a[3] := 1, so a becomes [0, 0, 1, 0, 0];
2. then we choose the segment [1; 2] and assign a[1] := 2, so a becomes [2, 0, 1, 0, 0];
3. then we choose the segment [4; 5] and assign a[4] := 3, so a becomes [2, 0, 1, 3, 0];
4. then we choose the segment [2; 2] and assign a[2] := 4, so a becomes [2, 4, 1, 3, 0];
5. and at last we choose the segment [5; 5] and assign a[5] := 5, so a becomes [2, 4, 1, 3, 5].
Your task is to find the array a of length n after performing all n actions. Note that the answer exists and unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the array a of length n after performing n actions described in the problem statement. Note that the answer exists and unique.
Example
Input
6
1
2
3
4
5
6
Output
1
1 2
2 1 3
3 1 2 4
2 4 1 3 5
3 4 1 5 2 6
Submitted Solution:
```
from heapq import heappush,heapify,heappop
for _ in range(int(input())):
n=int(input());Ans=[0]*(n+1);l=1;r=n;mid=(r+l)//2;Heap=[(l-r,l,r)];heapify(Heap);i=1
while len(Heap)>0:
t=heappop(Heap);l=t[1];r=t[2]
mid=(l+r)//2;Ans[mid]=i;i+=1
if mid!=l:heappush(Heap,(l-mid,l,mid-1))
if mid!=r:heappush(Heap,(mid-r,mid+1,r))
print(*Ans[1:])
``` | instruction | 0 | 36,237 | 12 | 72,474 |
Yes | output | 1 | 36,237 | 12 | 72,475 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of length n consisting of zeros. You perform n actions with this array: during the i-th action, the following sequence of operations appears:
1. Choose the maximum by length subarray (continuous subsegment) consisting only of zeros, among all such segments choose the leftmost one;
2. Let this segment be [l; r]. If r-l+1 is odd (not divisible by 2) then assign (set) a[(l+r)/(2)] := i (where i is the number of the current action), otherwise (if r-l+1 is even) assign (set) a[(l+r-1)/(2)] := i.
Consider the array a of length 5 (initially a=[0, 0, 0, 0, 0]). Then it changes as follows:
1. Firstly, we choose the segment [1; 5] and assign a[3] := 1, so a becomes [0, 0, 1, 0, 0];
2. then we choose the segment [1; 2] and assign a[1] := 2, so a becomes [2, 0, 1, 0, 0];
3. then we choose the segment [4; 5] and assign a[4] := 3, so a becomes [2, 0, 1, 3, 0];
4. then we choose the segment [2; 2] and assign a[2] := 4, so a becomes [2, 4, 1, 3, 0];
5. and at last we choose the segment [5; 5] and assign a[5] := 5, so a becomes [2, 4, 1, 3, 5].
Your task is to find the array a of length n after performing all n actions. Note that the answer exists and unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the array a of length n after performing n actions described in the problem statement. Note that the answer exists and unique.
Example
Input
6
1
2
3
4
5
6
Output
1
1 2
2 1 3
3 1 2 4
2 4 1 3 5
3 4 1 5 2 6
Submitted Solution:
```
from heapq import heappush, heapify, heappop
t=int(input())
for _ in range(t):
n=int(input())
arr=[0]*n
raj=[]
heapify(raj)
heappush(raj,((n*-1,0,(n-1))) )
put=1
while(len(raj)!=0):
x = heappop(raj)
tot=x[0]*-1
l=x[1]
r=x[2]
if(tot%2==0):
mid=(l+r-1)//2
else:
mid=(l+r)//2
arr[mid]=put
put+=1
if(l<=(mid-1)):
heappush(raj, ( ((mid-1)-l+1)*-1,l,(mid-1) ))
if(mid+1<=r):
heappush(raj, ( (r-(mid+1)+1)*-1,mid+1,(r) ))
print(*arr)
``` | instruction | 0 | 36,238 | 12 | 72,476 |
Yes | output | 1 | 36,238 | 12 | 72,477 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of length n consisting of zeros. You perform n actions with this array: during the i-th action, the following sequence of operations appears:
1. Choose the maximum by length subarray (continuous subsegment) consisting only of zeros, among all such segments choose the leftmost one;
2. Let this segment be [l; r]. If r-l+1 is odd (not divisible by 2) then assign (set) a[(l+r)/(2)] := i (where i is the number of the current action), otherwise (if r-l+1 is even) assign (set) a[(l+r-1)/(2)] := i.
Consider the array a of length 5 (initially a=[0, 0, 0, 0, 0]). Then it changes as follows:
1. Firstly, we choose the segment [1; 5] and assign a[3] := 1, so a becomes [0, 0, 1, 0, 0];
2. then we choose the segment [1; 2] and assign a[1] := 2, so a becomes [2, 0, 1, 0, 0];
3. then we choose the segment [4; 5] and assign a[4] := 3, so a becomes [2, 0, 1, 3, 0];
4. then we choose the segment [2; 2] and assign a[2] := 4, so a becomes [2, 4, 1, 3, 0];
5. and at last we choose the segment [5; 5] and assign a[5] := 5, so a becomes [2, 4, 1, 3, 5].
Your task is to find the array a of length n after performing all n actions. Note that the answer exists and unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the array a of length n after performing n actions described in the problem statement. Note that the answer exists and unique.
Example
Input
6
1
2
3
4
5
6
Output
1
1 2
2 1 3
3 1 2 4
2 4 1 3 5
3 4 1 5 2 6
Submitted Solution:
```
def func1(l,r):
if l>r: return
m = (l+r)//2
print(l,r,m)
li1[m] = [l-r,m]
func1(l,m-1)
func1(m+1,r)
a = int(input())
for _ in range(a):
x= int(input())
li1, li2 = [0]*x, [0]*x
func1(0,x-1)
li1.sort()
# print(li1)
i = 0
for j in li1:
#print(j[0],i)
li2[j[1]] = i+1
i += 1
print(*li2)
``` | instruction | 0 | 36,239 | 12 | 72,478 |
No | output | 1 | 36,239 | 12 | 72,479 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of length n consisting of zeros. You perform n actions with this array: during the i-th action, the following sequence of operations appears:
1. Choose the maximum by length subarray (continuous subsegment) consisting only of zeros, among all such segments choose the leftmost one;
2. Let this segment be [l; r]. If r-l+1 is odd (not divisible by 2) then assign (set) a[(l+r)/(2)] := i (where i is the number of the current action), otherwise (if r-l+1 is even) assign (set) a[(l+r-1)/(2)] := i.
Consider the array a of length 5 (initially a=[0, 0, 0, 0, 0]). Then it changes as follows:
1. Firstly, we choose the segment [1; 5] and assign a[3] := 1, so a becomes [0, 0, 1, 0, 0];
2. then we choose the segment [1; 2] and assign a[1] := 2, so a becomes [2, 0, 1, 0, 0];
3. then we choose the segment [4; 5] and assign a[4] := 3, so a becomes [2, 0, 1, 3, 0];
4. then we choose the segment [2; 2] and assign a[2] := 4, so a becomes [2, 4, 1, 3, 0];
5. and at last we choose the segment [5; 5] and assign a[5] := 5, so a becomes [2, 4, 1, 3, 5].
Your task is to find the array a of length n after performing all n actions. Note that the answer exists and unique.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the array a of length n after performing n actions described in the problem statement. Note that the answer exists and unique.
Example
Input
6
1
2
3
4
5
6
Output
1
1 2
2 1 3
3 1 2 4
2 4 1 3 5
3 4 1 5 2 6
Submitted Solution:
```
from queue import PriorityQueue as pq
a=int(input())
for i in range(a):
x=int(input())
ram=pq()
ram.put((-1*x,0,x-1))
ans=[0 for i in range(x)]
count=0
while(count<x):
temp=ram.get()
ans[(abs(temp[1])+temp[2])//2]=count+1
siz=abs(temp[0])
kem=abs(temp[1])
count+=1
if(siz%2==1):
ram.put((-1*(siz//2),-1*temp[1],kem+(siz//2)-1))
ram.put((-1*(siz//2),kem+(siz//2)+1,temp[2]))
else:
ram.put((-1*(siz//2),kem+(siz//2),temp[2]))
if(siz//2>1):
ram.put((-1*((siz//2)-1),-1*temp[1],((kem+temp[2])//2)-1))
print(*ans)
``` | instruction | 0 | 36,240 | 12 | 72,480 |
No | output | 1 | 36,240 | 12 | 72,481 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.