message stringlengths 2 433k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The little girl loves the problems on array queries very much.
One day she came across a rather well-known problem: you've got an array of n elements (the elements of the array are indexed starting from 1); also, there are q queries, each one is defined by a pair of integers l_i, r_i (1 ≤ l_i ≤ r_i ≤ n). You need to find for each query the sum of elements of the array with indexes from l_i to r_i, inclusive.
The little girl found the problem rather boring. She decided to reorder the array elements before replying to the queries in a way that makes the sum of query replies maximum possible. Your task is to find the value of this maximum sum.
Input
The first line contains two space-separated integers n (1 ≤ n ≤ 2⋅10^5) and q (1 ≤ q ≤ 2⋅10^5) — the number of elements in the array and the number of queries, correspondingly.
The next line contains n space-separated integers a_i (1 ≤ a_i ≤ 2⋅10^5) — the array elements.
Each of the following q lines contains two space-separated integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n) — the i-th query.
Output
In a single line print, a single integer — the maximum sum of query replies after the array elements are reordered.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3 3
5 3 2
1 2
2 3
1 3
Output
25
Input
5 3
5 2 4 1 3
1 5
2 3
2 3
Output
33
Submitted Solution:
```
import sys
import functools
# sys.setrecursionlimit(1000000)
n, q = [int(x) for x in input().strip().split()]
arr = [int(x) for x in input().strip().split()]
query = []
p = [0]*(n+1)
for i in range(q):
l,r=[int(x) for x in input().strip().split()]
query.append([l,r])
for j in range(l,r+1):
p[j]+=1
arr = [0]+arr
s_index = list(range(n+1))
s_index = sorted(s_index,key = lambda x: p[x])
arr = sorted(arr)
new_arr = [0]*(n+1)
for i,j in enumerate(s_index):
new_arr[i] = arr[j]
for i in range(1,n+1):
new_arr[i]+=new_arr[i-1]
s = 0
for i,j in query:
s+=new_arr[j]-new_arr[i-1]
print(s)
``` | instruction | 0 | 34,583 | 12 | 69,166 |
No | output | 1 | 34,583 | 12 | 69,167 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You want to arrange n integers a1, a2, ..., an in some order in a row. Let's define the value of an arrangement as the sum of differences between all pairs of adjacent integers.
More formally, let's denote some arrangement as a sequence of integers x1, x2, ..., xn, where sequence x is a permutation of sequence a. The value of such an arrangement is (x1 - x2) + (x2 - x3) + ... + (xn - 1 - xn).
Find the largest possible value of an arrangement. Then, output the lexicographically smallest sequence x that corresponds to an arrangement of the largest possible value.
Input
The first line of the input contains integer n (2 ≤ n ≤ 100). The second line contains n space-separated integers a1, a2, ..., an (|ai| ≤ 1000).
Output
Print the required sequence x1, x2, ..., xn. Sequence x should be the lexicographically smallest permutation of a that corresponds to an arrangement of the largest possible value.
Examples
Input
5
100 -100 50 0 -50
Output
100 -50 0 50 -100
Note
In the sample test case, the value of the output arrangement is (100 - ( - 50)) + (( - 50) - 0) + (0 - 50) + (50 - ( - 100)) = 200. No other arrangement has a larger value, and among all arrangements with the value of 200, the output arrangement is the lexicographically smallest one.
Sequence x1, x2, ... , xp is lexicographically smaller than sequence y1, y2, ... , yp if there exists an integer r (0 ≤ r < p) such that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1. | instruction | 0 | 34,600 | 12 | 69,200 |
Tags: constructive algorithms, implementation, sortings
Correct Solution:
```
n = int(input())
A = sorted(list(map(int, input().split())))
print(A[-1], ' '.join(map(str, A[1:-1])), A[0])
``` | output | 1 | 34,600 | 12 | 69,201 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You want to arrange n integers a1, a2, ..., an in some order in a row. Let's define the value of an arrangement as the sum of differences between all pairs of adjacent integers.
More formally, let's denote some arrangement as a sequence of integers x1, x2, ..., xn, where sequence x is a permutation of sequence a. The value of such an arrangement is (x1 - x2) + (x2 - x3) + ... + (xn - 1 - xn).
Find the largest possible value of an arrangement. Then, output the lexicographically smallest sequence x that corresponds to an arrangement of the largest possible value.
Input
The first line of the input contains integer n (2 ≤ n ≤ 100). The second line contains n space-separated integers a1, a2, ..., an (|ai| ≤ 1000).
Output
Print the required sequence x1, x2, ..., xn. Sequence x should be the lexicographically smallest permutation of a that corresponds to an arrangement of the largest possible value.
Examples
Input
5
100 -100 50 0 -50
Output
100 -50 0 50 -100
Note
In the sample test case, the value of the output arrangement is (100 - ( - 50)) + (( - 50) - 0) + (0 - 50) + (50 - ( - 100)) = 200. No other arrangement has a larger value, and among all arrangements with the value of 200, the output arrangement is the lexicographically smallest one.
Sequence x1, x2, ... , xp is lexicographically smaller than sequence y1, y2, ... , yp if there exists an integer r (0 ≤ r < p) such that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1. | instruction | 0 | 34,601 | 12 | 69,202 |
Tags: constructive algorithms, implementation, sortings
Correct Solution:
```
n = int(input())
lst1 = input().split()
lst2 = []
for i in lst1:
lst2.append(int(i))
Max = max(lst2)
Min = min(lst2)
lst2.sort()
del lst2[n-1]
del lst2[0]
print(Max,end=' ')
for i in lst2:
print(i,end=" ")
print(Min)
``` | output | 1 | 34,601 | 12 | 69,203 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You want to arrange n integers a1, a2, ..., an in some order in a row. Let's define the value of an arrangement as the sum of differences between all pairs of adjacent integers.
More formally, let's denote some arrangement as a sequence of integers x1, x2, ..., xn, where sequence x is a permutation of sequence a. The value of such an arrangement is (x1 - x2) + (x2 - x3) + ... + (xn - 1 - xn).
Find the largest possible value of an arrangement. Then, output the lexicographically smallest sequence x that corresponds to an arrangement of the largest possible value.
Input
The first line of the input contains integer n (2 ≤ n ≤ 100). The second line contains n space-separated integers a1, a2, ..., an (|ai| ≤ 1000).
Output
Print the required sequence x1, x2, ..., xn. Sequence x should be the lexicographically smallest permutation of a that corresponds to an arrangement of the largest possible value.
Examples
Input
5
100 -100 50 0 -50
Output
100 -50 0 50 -100
Note
In the sample test case, the value of the output arrangement is (100 - ( - 50)) + (( - 50) - 0) + (0 - 50) + (50 - ( - 100)) = 200. No other arrangement has a larger value, and among all arrangements with the value of 200, the output arrangement is the lexicographically smallest one.
Sequence x1, x2, ... , xp is lexicographically smaller than sequence y1, y2, ... , yp if there exists an integer r (0 ≤ r < p) such that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1. | instruction | 0 | 34,602 | 12 | 69,204 |
Tags: constructive algorithms, implementation, sortings
Correct Solution:
```
n = int(input())
k = map(int,input().split())
mylist = sorted(list(k))
def myswap(mylist) :
mylist[-1], mylist[0] = mylist[0], mylist[-1]
return mylist
mylist = myswap(mylist)
for i in range(n) :
print(mylist[i],end = " ")
``` | output | 1 | 34,602 | 12 | 69,205 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You want to arrange n integers a1, a2, ..., an in some order in a row. Let's define the value of an arrangement as the sum of differences between all pairs of adjacent integers.
More formally, let's denote some arrangement as a sequence of integers x1, x2, ..., xn, where sequence x is a permutation of sequence a. The value of such an arrangement is (x1 - x2) + (x2 - x3) + ... + (xn - 1 - xn).
Find the largest possible value of an arrangement. Then, output the lexicographically smallest sequence x that corresponds to an arrangement of the largest possible value.
Input
The first line of the input contains integer n (2 ≤ n ≤ 100). The second line contains n space-separated integers a1, a2, ..., an (|ai| ≤ 1000).
Output
Print the required sequence x1, x2, ..., xn. Sequence x should be the lexicographically smallest permutation of a that corresponds to an arrangement of the largest possible value.
Examples
Input
5
100 -100 50 0 -50
Output
100 -50 0 50 -100
Note
In the sample test case, the value of the output arrangement is (100 - ( - 50)) + (( - 50) - 0) + (0 - 50) + (50 - ( - 100)) = 200. No other arrangement has a larger value, and among all arrangements with the value of 200, the output arrangement is the lexicographically smallest one.
Sequence x1, x2, ... , xp is lexicographically smaller than sequence y1, y2, ... , yp if there exists an integer r (0 ≤ r < p) such that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1. | instruction | 0 | 34,603 | 12 | 69,206 |
Tags: constructive algorithms, implementation, sortings
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
a.sort()
a[0],a[n-1]=a[n-1],a[0]
for i in a:
print(i,end=" ")
print()
``` | output | 1 | 34,603 | 12 | 69,207 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You want to arrange n integers a1, a2, ..., an in some order in a row. Let's define the value of an arrangement as the sum of differences between all pairs of adjacent integers.
More formally, let's denote some arrangement as a sequence of integers x1, x2, ..., xn, where sequence x is a permutation of sequence a. The value of such an arrangement is (x1 - x2) + (x2 - x3) + ... + (xn - 1 - xn).
Find the largest possible value of an arrangement. Then, output the lexicographically smallest sequence x that corresponds to an arrangement of the largest possible value.
Input
The first line of the input contains integer n (2 ≤ n ≤ 100). The second line contains n space-separated integers a1, a2, ..., an (|ai| ≤ 1000).
Output
Print the required sequence x1, x2, ..., xn. Sequence x should be the lexicographically smallest permutation of a that corresponds to an arrangement of the largest possible value.
Examples
Input
5
100 -100 50 0 -50
Output
100 -50 0 50 -100
Note
In the sample test case, the value of the output arrangement is (100 - ( - 50)) + (( - 50) - 0) + (0 - 50) + (50 - ( - 100)) = 200. No other arrangement has a larger value, and among all arrangements with the value of 200, the output arrangement is the lexicographically smallest one.
Sequence x1, x2, ... , xp is lexicographically smaller than sequence y1, y2, ... , yp if there exists an integer r (0 ≤ r < p) such that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1. | instruction | 0 | 34,604 | 12 | 69,208 |
Tags: constructive algorithms, implementation, sortings
Correct Solution:
```
def main():
input()
a = sorted(input().split(), key=int)
print(a[-1], ' '.join(a[1:-1]), a[0])
if __name__ == '__main__':
main()
``` | output | 1 | 34,604 | 12 | 69,209 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You want to arrange n integers a1, a2, ..., an in some order in a row. Let's define the value of an arrangement as the sum of differences between all pairs of adjacent integers.
More formally, let's denote some arrangement as a sequence of integers x1, x2, ..., xn, where sequence x is a permutation of sequence a. The value of such an arrangement is (x1 - x2) + (x2 - x3) + ... + (xn - 1 - xn).
Find the largest possible value of an arrangement. Then, output the lexicographically smallest sequence x that corresponds to an arrangement of the largest possible value.
Input
The first line of the input contains integer n (2 ≤ n ≤ 100). The second line contains n space-separated integers a1, a2, ..., an (|ai| ≤ 1000).
Output
Print the required sequence x1, x2, ..., xn. Sequence x should be the lexicographically smallest permutation of a that corresponds to an arrangement of the largest possible value.
Examples
Input
5
100 -100 50 0 -50
Output
100 -50 0 50 -100
Note
In the sample test case, the value of the output arrangement is (100 - ( - 50)) + (( - 50) - 0) + (0 - 50) + (50 - ( - 100)) = 200. No other arrangement has a larger value, and among all arrangements with the value of 200, the output arrangement is the lexicographically smallest one.
Sequence x1, x2, ... , xp is lexicographically smaller than sequence y1, y2, ... , yp if there exists an integer r (0 ≤ r < p) such that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1. | instruction | 0 | 34,605 | 12 | 69,210 |
Tags: constructive algorithms, implementation, sortings
Correct Solution:
```
def solve(n, nums):
nums.sort()
ret = []
#print(nums)
ret.append(nums[-1])
for i in range(1,n-1):
ret.append(nums[i])
ret.append(nums[0])
'''
else:
for i in range(n):
ret.append(nums[-i-1])
'''
return ret
n = int(input())
nums = list(map(int, input().split()))
ret = solve(n,nums)
for i in range(n):
print(ret[i], end= ' ')
print()
``` | output | 1 | 34,605 | 12 | 69,211 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You want to arrange n integers a1, a2, ..., an in some order in a row. Let's define the value of an arrangement as the sum of differences between all pairs of adjacent integers.
More formally, let's denote some arrangement as a sequence of integers x1, x2, ..., xn, where sequence x is a permutation of sequence a. The value of such an arrangement is (x1 - x2) + (x2 - x3) + ... + (xn - 1 - xn).
Find the largest possible value of an arrangement. Then, output the lexicographically smallest sequence x that corresponds to an arrangement of the largest possible value.
Input
The first line of the input contains integer n (2 ≤ n ≤ 100). The second line contains n space-separated integers a1, a2, ..., an (|ai| ≤ 1000).
Output
Print the required sequence x1, x2, ..., xn. Sequence x should be the lexicographically smallest permutation of a that corresponds to an arrangement of the largest possible value.
Examples
Input
5
100 -100 50 0 -50
Output
100 -50 0 50 -100
Note
In the sample test case, the value of the output arrangement is (100 - ( - 50)) + (( - 50) - 0) + (0 - 50) + (50 - ( - 100)) = 200. No other arrangement has a larger value, and among all arrangements with the value of 200, the output arrangement is the lexicographically smallest one.
Sequence x1, x2, ... , xp is lexicographically smaller than sequence y1, y2, ... , yp if there exists an integer r (0 ≤ r < p) such that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1. | instruction | 0 | 34,606 | 12 | 69,212 |
Tags: constructive algorithms, implementation, sortings
Correct Solution:
```
n = int(input())
a = [int(x) for x in input().split()]
a.sort()
a = [a[-1]] + a[1:-1] + [a[0]]
print(*a)
``` | output | 1 | 34,606 | 12 | 69,213 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You want to arrange n integers a1, a2, ..., an in some order in a row. Let's define the value of an arrangement as the sum of differences between all pairs of adjacent integers.
More formally, let's denote some arrangement as a sequence of integers x1, x2, ..., xn, where sequence x is a permutation of sequence a. The value of such an arrangement is (x1 - x2) + (x2 - x3) + ... + (xn - 1 - xn).
Find the largest possible value of an arrangement. Then, output the lexicographically smallest sequence x that corresponds to an arrangement of the largest possible value.
Input
The first line of the input contains integer n (2 ≤ n ≤ 100). The second line contains n space-separated integers a1, a2, ..., an (|ai| ≤ 1000).
Output
Print the required sequence x1, x2, ..., xn. Sequence x should be the lexicographically smallest permutation of a that corresponds to an arrangement of the largest possible value.
Examples
Input
5
100 -100 50 0 -50
Output
100 -50 0 50 -100
Note
In the sample test case, the value of the output arrangement is (100 - ( - 50)) + (( - 50) - 0) + (0 - 50) + (50 - ( - 100)) = 200. No other arrangement has a larger value, and among all arrangements with the value of 200, the output arrangement is the lexicographically smallest one.
Sequence x1, x2, ... , xp is lexicographically smaller than sequence y1, y2, ... , yp if there exists an integer r (0 ≤ r < p) such that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1. | instruction | 0 | 34,607 | 12 | 69,214 |
Tags: constructive algorithms, implementation, sortings
Correct Solution:
```
n=input()
s=input()
a=s.split()
for i in range(len(a)):
a[i]=int(a[i])
a.sort()
a[0],a[len(a)-1]=a[len(a)-1],a[0]
for i in range(len(a)-1):
a[i]=str(a[i])+' '
a[len(a)-1]=str(a[len(a)-1])
print(''.join(a))
``` | output | 1 | 34,607 | 12 | 69,215 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You want to arrange n integers a1, a2, ..., an in some order in a row. Let's define the value of an arrangement as the sum of differences between all pairs of adjacent integers.
More formally, let's denote some arrangement as a sequence of integers x1, x2, ..., xn, where sequence x is a permutation of sequence a. The value of such an arrangement is (x1 - x2) + (x2 - x3) + ... + (xn - 1 - xn).
Find the largest possible value of an arrangement. Then, output the lexicographically smallest sequence x that corresponds to an arrangement of the largest possible value.
Input
The first line of the input contains integer n (2 ≤ n ≤ 100). The second line contains n space-separated integers a1, a2, ..., an (|ai| ≤ 1000).
Output
Print the required sequence x1, x2, ..., xn. Sequence x should be the lexicographically smallest permutation of a that corresponds to an arrangement of the largest possible value.
Examples
Input
5
100 -100 50 0 -50
Output
100 -50 0 50 -100
Note
In the sample test case, the value of the output arrangement is (100 - ( - 50)) + (( - 50) - 0) + (0 - 50) + (50 - ( - 100)) = 200. No other arrangement has a larger value, and among all arrangements with the value of 200, the output arrangement is the lexicographically smallest one.
Sequence x1, x2, ... , xp is lexicographically smaller than sequence y1, y2, ... , yp if there exists an integer r (0 ≤ r < p) such that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1.
Submitted Solution:
```
n=int(input())
A=list(map(int,input().split()))
B=[]
mna=-1000000007
mxa=max(A)
B.append(mxa)
A.remove(mxa)
if A:
mna=min(A)
A.remove(mna)
if A:
A.sort()
B=B+A
if mna!=-1000000007:
B.append(mna)
print(" ".join(list(map(str,B))))
``` | instruction | 0 | 34,608 | 12 | 69,216 |
Yes | output | 1 | 34,608 | 12 | 69,217 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You want to arrange n integers a1, a2, ..., an in some order in a row. Let's define the value of an arrangement as the sum of differences between all pairs of adjacent integers.
More formally, let's denote some arrangement as a sequence of integers x1, x2, ..., xn, where sequence x is a permutation of sequence a. The value of such an arrangement is (x1 - x2) + (x2 - x3) + ... + (xn - 1 - xn).
Find the largest possible value of an arrangement. Then, output the lexicographically smallest sequence x that corresponds to an arrangement of the largest possible value.
Input
The first line of the input contains integer n (2 ≤ n ≤ 100). The second line contains n space-separated integers a1, a2, ..., an (|ai| ≤ 1000).
Output
Print the required sequence x1, x2, ..., xn. Sequence x should be the lexicographically smallest permutation of a that corresponds to an arrangement of the largest possible value.
Examples
Input
5
100 -100 50 0 -50
Output
100 -50 0 50 -100
Note
In the sample test case, the value of the output arrangement is (100 - ( - 50)) + (( - 50) - 0) + (0 - 50) + (50 - ( - 100)) = 200. No other arrangement has a larger value, and among all arrangements with the value of 200, the output arrangement is the lexicographically smallest one.
Sequence x1, x2, ... , xp is lexicographically smaller than sequence y1, y2, ... , yp if there exists an integer r (0 ≤ r < p) such that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1.
Submitted Solution:
```
"""
(x1 - x2) + (x2 - x3) + (x3 - x4) + (x4 - x5)
x1 + (x2 - x2) + (x3 - x3) + (x4 - x4) - x5
x1 - x5
x1 > x5
"""
n = int(input().strip())
a = list(map(int, input().strip().split()))
a.sort()
a[0], a[-1] = a[-1], a[0]
print(*a)
``` | instruction | 0 | 34,609 | 12 | 69,218 |
Yes | output | 1 | 34,609 | 12 | 69,219 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You want to arrange n integers a1, a2, ..., an in some order in a row. Let's define the value of an arrangement as the sum of differences between all pairs of adjacent integers.
More formally, let's denote some arrangement as a sequence of integers x1, x2, ..., xn, where sequence x is a permutation of sequence a. The value of such an arrangement is (x1 - x2) + (x2 - x3) + ... + (xn - 1 - xn).
Find the largest possible value of an arrangement. Then, output the lexicographically smallest sequence x that corresponds to an arrangement of the largest possible value.
Input
The first line of the input contains integer n (2 ≤ n ≤ 100). The second line contains n space-separated integers a1, a2, ..., an (|ai| ≤ 1000).
Output
Print the required sequence x1, x2, ..., xn. Sequence x should be the lexicographically smallest permutation of a that corresponds to an arrangement of the largest possible value.
Examples
Input
5
100 -100 50 0 -50
Output
100 -50 0 50 -100
Note
In the sample test case, the value of the output arrangement is (100 - ( - 50)) + (( - 50) - 0) + (0 - 50) + (50 - ( - 100)) = 200. No other arrangement has a larger value, and among all arrangements with the value of 200, the output arrangement is the lexicographically smallest one.
Sequence x1, x2, ... , xp is lexicographically smaller than sequence y1, y2, ... , yp if there exists an integer r (0 ≤ r < p) such that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1.
Submitted Solution:
```
n=int(input())
c=(list(map(int, input().split())))
a=[]
for i in range(0,len(c)):
a.append(c[i])
a.sort()
d=a[0]
a[0]=a[n-1]
a[n-1]=d
for i in range(0,n):
print(a[i],end=' ')
``` | instruction | 0 | 34,610 | 12 | 69,220 |
Yes | output | 1 | 34,610 | 12 | 69,221 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You want to arrange n integers a1, a2, ..., an in some order in a row. Let's define the value of an arrangement as the sum of differences between all pairs of adjacent integers.
More formally, let's denote some arrangement as a sequence of integers x1, x2, ..., xn, where sequence x is a permutation of sequence a. The value of such an arrangement is (x1 - x2) + (x2 - x3) + ... + (xn - 1 - xn).
Find the largest possible value of an arrangement. Then, output the lexicographically smallest sequence x that corresponds to an arrangement of the largest possible value.
Input
The first line of the input contains integer n (2 ≤ n ≤ 100). The second line contains n space-separated integers a1, a2, ..., an (|ai| ≤ 1000).
Output
Print the required sequence x1, x2, ..., xn. Sequence x should be the lexicographically smallest permutation of a that corresponds to an arrangement of the largest possible value.
Examples
Input
5
100 -100 50 0 -50
Output
100 -50 0 50 -100
Note
In the sample test case, the value of the output arrangement is (100 - ( - 50)) + (( - 50) - 0) + (0 - 50) + (50 - ( - 100)) = 200. No other arrangement has a larger value, and among all arrangements with the value of 200, the output arrangement is the lexicographically smallest one.
Sequence x1, x2, ... , xp is lexicographically smaller than sequence y1, y2, ... , yp if there exists an integer r (0 ≤ r < p) such that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1.
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
a.sort()
print (a[n - 1], end = " ")
for i in range (1, n - 1):
print (a[i], end = " ")
print (a[0])
``` | instruction | 0 | 34,611 | 12 | 69,222 |
Yes | output | 1 | 34,611 | 12 | 69,223 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You want to arrange n integers a1, a2, ..., an in some order in a row. Let's define the value of an arrangement as the sum of differences between all pairs of adjacent integers.
More formally, let's denote some arrangement as a sequence of integers x1, x2, ..., xn, where sequence x is a permutation of sequence a. The value of such an arrangement is (x1 - x2) + (x2 - x3) + ... + (xn - 1 - xn).
Find the largest possible value of an arrangement. Then, output the lexicographically smallest sequence x that corresponds to an arrangement of the largest possible value.
Input
The first line of the input contains integer n (2 ≤ n ≤ 100). The second line contains n space-separated integers a1, a2, ..., an (|ai| ≤ 1000).
Output
Print the required sequence x1, x2, ..., xn. Sequence x should be the lexicographically smallest permutation of a that corresponds to an arrangement of the largest possible value.
Examples
Input
5
100 -100 50 0 -50
Output
100 -50 0 50 -100
Note
In the sample test case, the value of the output arrangement is (100 - ( - 50)) + (( - 50) - 0) + (0 - 50) + (50 - ( - 100)) = 200. No other arrangement has a larger value, and among all arrangements with the value of 200, the output arrangement is the lexicographically smallest one.
Sequence x1, x2, ... , xp is lexicographically smaller than sequence y1, y2, ... , yp if there exists an integer r (0 ≤ r < p) such that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1.
Submitted Solution:
```
n=int(input())
a=list(map(int,input().split()))
if n%2==0 :
s=max(a)-min(a)
else :
s=max(a)+min(a)
print(s)
``` | instruction | 0 | 34,612 | 12 | 69,224 |
No | output | 1 | 34,612 | 12 | 69,225 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You want to arrange n integers a1, a2, ..., an in some order in a row. Let's define the value of an arrangement as the sum of differences between all pairs of adjacent integers.
More formally, let's denote some arrangement as a sequence of integers x1, x2, ..., xn, where sequence x is a permutation of sequence a. The value of such an arrangement is (x1 - x2) + (x2 - x3) + ... + (xn - 1 - xn).
Find the largest possible value of an arrangement. Then, output the lexicographically smallest sequence x that corresponds to an arrangement of the largest possible value.
Input
The first line of the input contains integer n (2 ≤ n ≤ 100). The second line contains n space-separated integers a1, a2, ..., an (|ai| ≤ 1000).
Output
Print the required sequence x1, x2, ..., xn. Sequence x should be the lexicographically smallest permutation of a that corresponds to an arrangement of the largest possible value.
Examples
Input
5
100 -100 50 0 -50
Output
100 -50 0 50 -100
Note
In the sample test case, the value of the output arrangement is (100 - ( - 50)) + (( - 50) - 0) + (0 - 50) + (50 - ( - 100)) = 200. No other arrangement has a larger value, and among all arrangements with the value of 200, the output arrangement is the lexicographically smallest one.
Sequence x1, x2, ... , xp is lexicographically smaller than sequence y1, y2, ... , yp if there exists an integer r (0 ≤ r < p) such that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1.
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
ma=l.index(max(l))
mi=l.index(min(l))
l[0],l[ma]=l[ma],l[0]
l[-1],l[mi]=l[mi],l[-1]
print(' '.join(map(str,l)))
``` | instruction | 0 | 34,613 | 12 | 69,226 |
No | output | 1 | 34,613 | 12 | 69,227 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You want to arrange n integers a1, a2, ..., an in some order in a row. Let's define the value of an arrangement as the sum of differences between all pairs of adjacent integers.
More formally, let's denote some arrangement as a sequence of integers x1, x2, ..., xn, where sequence x is a permutation of sequence a. The value of such an arrangement is (x1 - x2) + (x2 - x3) + ... + (xn - 1 - xn).
Find the largest possible value of an arrangement. Then, output the lexicographically smallest sequence x that corresponds to an arrangement of the largest possible value.
Input
The first line of the input contains integer n (2 ≤ n ≤ 100). The second line contains n space-separated integers a1, a2, ..., an (|ai| ≤ 1000).
Output
Print the required sequence x1, x2, ..., xn. Sequence x should be the lexicographically smallest permutation of a that corresponds to an arrangement of the largest possible value.
Examples
Input
5
100 -100 50 0 -50
Output
100 -50 0 50 -100
Note
In the sample test case, the value of the output arrangement is (100 - ( - 50)) + (( - 50) - 0) + (0 - 50) + (50 - ( - 100)) = 200. No other arrangement has a larger value, and among all arrangements with the value of 200, the output arrangement is the lexicographically smallest one.
Sequence x1, x2, ... , xp is lexicographically smaller than sequence y1, y2, ... , yp if there exists an integer r (0 ≤ r < p) such that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1.
Submitted Solution:
```
n=int(input())
a=input().split()
array=[]
array2=[]
for i in range(n):
array.append(int(a[i]))
array=sorted(array)
a=array[0]
array[0]=array[len(array)-1]
array[len(array)-1]=a
print(array)
for i in range(len(array)):
array2.append(array[i])
print(array2[i],end=" ")
``` | instruction | 0 | 34,614 | 12 | 69,228 |
No | output | 1 | 34,614 | 12 | 69,229 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You want to arrange n integers a1, a2, ..., an in some order in a row. Let's define the value of an arrangement as the sum of differences between all pairs of adjacent integers.
More formally, let's denote some arrangement as a sequence of integers x1, x2, ..., xn, where sequence x is a permutation of sequence a. The value of such an arrangement is (x1 - x2) + (x2 - x3) + ... + (xn - 1 - xn).
Find the largest possible value of an arrangement. Then, output the lexicographically smallest sequence x that corresponds to an arrangement of the largest possible value.
Input
The first line of the input contains integer n (2 ≤ n ≤ 100). The second line contains n space-separated integers a1, a2, ..., an (|ai| ≤ 1000).
Output
Print the required sequence x1, x2, ..., xn. Sequence x should be the lexicographically smallest permutation of a that corresponds to an arrangement of the largest possible value.
Examples
Input
5
100 -100 50 0 -50
Output
100 -50 0 50 -100
Note
In the sample test case, the value of the output arrangement is (100 - ( - 50)) + (( - 50) - 0) + (0 - 50) + (50 - ( - 100)) = 200. No other arrangement has a larger value, and among all arrangements with the value of 200, the output arrangement is the lexicographically smallest one.
Sequence x1, x2, ... , xp is lexicographically smaller than sequence y1, y2, ... , yp if there exists an integer r (0 ≤ r < p) such that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1.
Submitted Solution:
```
import math
def na():
n = int(input())
b = [int(x) for x in input().split()]
return n,b
def nab():
n = int(input())
b = [int(x) for x in input().split()]
c = [int(x) for x in input().split()]
return n,b,c
def dv():
n, m = map(int, input().split())
return n,m
def dva():
n, m = map(int, input().split())
b = [int(x) for x in input().split()]
return n,m,b
def nm():
n = int(input())
b = [int(x) for x in input().split()]
m = int(input())
c = [int(x) for x in input().split()]
return n,b,m,c
def dvs():
n = int(input())
m = int(input())
return n, m
n, a = na()
a.sort(reverse= True)
a[0], a[-1] = a[-1], a[0]
print(*a)
``` | instruction | 0 | 34,615 | 12 | 69,230 |
No | output | 1 | 34,615 | 12 | 69,231 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gargari got bored to play with the bishops and now, after solving the problem about them, he is trying to do math homework. In a math book he have found k permutations. Each of them consists of numbers 1, 2, ..., n in some order. Now he should find the length of the longest common subsequence of these permutations. Can you help Gargari?
You can read about longest common subsequence there: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
Input
The first line contains two integers n and k (1 ≤ n ≤ 1000; 2 ≤ k ≤ 5). Each of the next k lines contains integers 1, 2, ..., n in some order — description of the current permutation.
Output
Print the length of the longest common subsequence.
Examples
Input
4 3
1 4 2 3
4 1 2 3
1 2 4 3
Output
3
Note
The answer for the first test sample is subsequence [1, 2, 3]. | instruction | 0 | 34,648 | 12 | 69,296 |
Tags: dfs and similar, dp, graphs, implementation
Correct Solution:
```
# -*- coding:utf-8 -*-
"""
created by shuangquan.huang at 1/14/20
"""
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def solve(N, K, A, pos):
dp = [0 for _ in range(N+1)]
for i in range(1, N+1):
maxx = 0
for p in range(1, i):
# if the A[1][p], A[1][i] is the last two elements of ans
# A[1][p] should appears before A[1][i] at every input array A[1:]
if all([pos[k][A[1][p]] < pos[k][A[1][i]] for k in range(2, K+1)]):
maxx = max(maxx, dp[p])
dp[i] = maxx + 1
return max(dp)
N, K = map(int, input().split())
A = [[0] * (N + 1)]
pos = [[0 for _ in range(N+1)] for _ in range(K+1)]
for i in range(K):
row = [0] + [int(x) for x in input().split()]
A.append(row)
for j, v in enumerate(row):
pos[i+1][v] = j
print(solve(N, K, A, pos))
``` | output | 1 | 34,648 | 12 | 69,297 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gargari got bored to play with the bishops and now, after solving the problem about them, he is trying to do math homework. In a math book he have found k permutations. Each of them consists of numbers 1, 2, ..., n in some order. Now he should find the length of the longest common subsequence of these permutations. Can you help Gargari?
You can read about longest common subsequence there: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
Input
The first line contains two integers n and k (1 ≤ n ≤ 1000; 2 ≤ k ≤ 5). Each of the next k lines contains integers 1, 2, ..., n in some order — description of the current permutation.
Output
Print the length of the longest common subsequence.
Examples
Input
4 3
1 4 2 3
4 1 2 3
1 2 4 3
Output
3
Note
The answer for the first test sample is subsequence [1, 2, 3]. | instruction | 0 | 34,649 | 12 | 69,298 |
Tags: dfs and similar, dp, graphs, implementation
Correct Solution:
```
n, k = map(int, input().split())
a, b = [[] for row in range(6)], [[0 for col in range(n + 1)] for row in range(6)]
for i in range(k):
a[i] = list(map(int, input().split()))
for j in range(n):
b[i][a[i][j]] = j
dp = [1] * n
for i in range(n):
for j in range(i):
flag = 1
for x in range(1, k):
if b[x][a[0][j]] > b[x][a[0][i]]:
flag = 0
break
if flag:
dp[i] = max(dp[i], dp[j] + 1)
print(max(dp))
``` | output | 1 | 34,649 | 12 | 69,299 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gargari got bored to play with the bishops and now, after solving the problem about them, he is trying to do math homework. In a math book he have found k permutations. Each of them consists of numbers 1, 2, ..., n in some order. Now he should find the length of the longest common subsequence of these permutations. Can you help Gargari?
You can read about longest common subsequence there: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
Input
The first line contains two integers n and k (1 ≤ n ≤ 1000; 2 ≤ k ≤ 5). Each of the next k lines contains integers 1, 2, ..., n in some order — description of the current permutation.
Output
Print the length of the longest common subsequence.
Examples
Input
4 3
1 4 2 3
4 1 2 3
1 2 4 3
Output
3
Note
The answer for the first test sample is subsequence [1, 2, 3]. | instruction | 0 | 34,650 | 12 | 69,300 |
Tags: dfs and similar, dp, graphs, implementation
Correct Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
sys.setrecursionlimit(300000)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=2**51, func=lambda a, b: a & b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] <=key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
n,k=map(int,input().split())
dp=[0 for i in range(n+1)]
ans=0
s=[[n for i in range(n+1)]for j in range(k)]
l=[]
for i in range(k):
l.append(list(map(int,input().split())))
s[i][0]=-1
for j in range(n):
s[i][l[i][j]]=j
for t in range(n):
for j in range(n+1):
f=0
for i in range(k):
if s[i][j]>=s[i][l[0][t]]:
f=1
break
if f==0:
dp[l[0][t]]=max(dp[l[0][t]],dp[j]+1)
for i in range(n+1):
ans=max(ans,dp[i])
print(ans)
``` | output | 1 | 34,650 | 12 | 69,301 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gargari got bored to play with the bishops and now, after solving the problem about them, he is trying to do math homework. In a math book he have found k permutations. Each of them consists of numbers 1, 2, ..., n in some order. Now he should find the length of the longest common subsequence of these permutations. Can you help Gargari?
You can read about longest common subsequence there: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
Input
The first line contains two integers n and k (1 ≤ n ≤ 1000; 2 ≤ k ≤ 5). Each of the next k lines contains integers 1, 2, ..., n in some order — description of the current permutation.
Output
Print the length of the longest common subsequence.
Examples
Input
4 3
1 4 2 3
4 1 2 3
1 2 4 3
Output
3
Note
The answer for the first test sample is subsequence [1, 2, 3]. | instruction | 0 | 34,651 | 12 | 69,302 |
Tags: dfs and similar, dp, graphs, implementation
Correct Solution:
```
def main():
n, k = tuple(map(int, input().split()))
a = [set(range(n)) for _ in range(n)]
for i in range(k):
p = set()
for j in map(int, input().split()):
a[j-1] -= p
p.add(j-1)
sa = sorted(range(n), key=lambda i: len(a[i]))
maxx = [0] * n
res = 0
for i in sa:
m = 1 + maxx[max(a[i], key=lambda e: maxx[e])] if a[i] else 0
maxx[i] = m
res = max(res, m)
print(res)
if __name__ == '__main__':
main()
``` | output | 1 | 34,651 | 12 | 69,303 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gargari got bored to play with the bishops and now, after solving the problem about them, he is trying to do math homework. In a math book he have found k permutations. Each of them consists of numbers 1, 2, ..., n in some order. Now he should find the length of the longest common subsequence of these permutations. Can you help Gargari?
You can read about longest common subsequence there: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
Input
The first line contains two integers n and k (1 ≤ n ≤ 1000; 2 ≤ k ≤ 5). Each of the next k lines contains integers 1, 2, ..., n in some order — description of the current permutation.
Output
Print the length of the longest common subsequence.
Examples
Input
4 3
1 4 2 3
4 1 2 3
1 2 4 3
Output
3
Note
The answer for the first test sample is subsequence [1, 2, 3]. | instruction | 0 | 34,652 | 12 | 69,304 |
Tags: dfs and similar, dp, graphs, implementation
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO,IOBase
def main():
n,k = map(int,input().split())
arr = [list(map(int,input().split())) for _ in range(k)]
edg = [[1]*n for _ in range(n)]
for i in range(k):
for j in range(n):
for l in range(j+1):
edg[arr[i][j]-1][arr[i][l]-1] = 0
path = [[] for _ in range(n)]
for i in range(n):
for j in range(n):
if edg[i][j]:
path[i].append(j)
visi,poi,dp = [0]*n,[0]*n,[1]*n
for i in range(n):
if visi[i]:
continue
visi[i],st = 1,[i]
while len(st):
x,y = st[-1],path[st[-1]]
while poi[x] != len(y) and visi[y[poi[x]]]:
dp[x] = max(dp[x],dp[y[poi[x]]]+1)
poi[x] += 1
if poi[x] == len(y):
st.pop()
if len(st):
dp[st[-1]] = max(dp[st[-1]],dp[x]+1)
else:
st.append(y[poi[x]])
visi[st[-1]] = 1
poi[x] += 1
print(max(dp))
# Fast IO Region
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")
if __name__ == "__main__":
main()
``` | output | 1 | 34,652 | 12 | 69,305 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gargari got bored to play with the bishops and now, after solving the problem about them, he is trying to do math homework. In a math book he have found k permutations. Each of them consists of numbers 1, 2, ..., n in some order. Now he should find the length of the longest common subsequence of these permutations. Can you help Gargari?
You can read about longest common subsequence there: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
Input
The first line contains two integers n and k (1 ≤ n ≤ 1000; 2 ≤ k ≤ 5). Each of the next k lines contains integers 1, 2, ..., n in some order — description of the current permutation.
Output
Print the length of the longest common subsequence.
Examples
Input
4 3
1 4 2 3
4 1 2 3
1 2 4 3
Output
3
Note
The answer for the first test sample is subsequence [1, 2, 3]. | instruction | 0 | 34,653 | 12 | 69,306 |
Tags: dfs and similar, dp, graphs, implementation
Correct Solution:
```
n, k = map(int, input().split())
ra = [[0] * k for _ in range(n)]
for p in range(k):
for i, v in enumerate(map(int, input().split())):
v -= 1
ra[v][p] = i
g = [[] for _ in range(n)]
for u in range(n):
for v in range(n):
if all(x < y for x, y in zip(ra[u], ra[v])):
g[u].append(v)
memo = [-1] * n
def dfs(v):
if memo[v] != -1:
return memo[v]
r = 1
for u in g[v]:
r = max(r, dfs(u) + 1)
memo[v] = r
return r
print(max(dfs(s) for s in range(n)))
``` | output | 1 | 34,653 | 12 | 69,307 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gargari got bored to play with the bishops and now, after solving the problem about them, he is trying to do math homework. In a math book he have found k permutations. Each of them consists of numbers 1, 2, ..., n in some order. Now he should find the length of the longest common subsequence of these permutations. Can you help Gargari?
You can read about longest common subsequence there: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
Input
The first line contains two integers n and k (1 ≤ n ≤ 1000; 2 ≤ k ≤ 5). Each of the next k lines contains integers 1, 2, ..., n in some order — description of the current permutation.
Output
Print the length of the longest common subsequence.
Examples
Input
4 3
1 4 2 3
4 1 2 3
1 2 4 3
Output
3
Note
The answer for the first test sample is subsequence [1, 2, 3]. | instruction | 0 | 34,654 | 12 | 69,308 |
Tags: dfs and similar, dp, graphs, implementation
Correct Solution:
```
# ========== //\\ //|| ||====//||
# || // \\ || || // ||
# || //====\\ || || // ||
# || // \\ || || // ||
# ========== // \\ ======== ||//====||
# code
def solve():
n, k = map(int, input().split())
c = [ [-1 for i in range(n + 1)] for i in range(k)]
dp = [0 for i in range(n + 1)]
a = []
for i in range(k):
b = list(map(int, input().split()))
for j, v in enumerate(b):
c[i][v] = j
a.append(b)
for i in range(n):
curpos = a[0][i]
dp[i] = 1
for j in range(i):
prevpos = a[0][j]
ok = True
for p in range(k):
if c[p][curpos] < c[p][prevpos]:
ok = False
break
if ok:
dp[i] = max(dp[i], dp[j] + 1)
print(max(dp))
return
def main():
t = 1
# t = int(input())
for _ in range(t):
solve()
if __name__ == "__main__":
main()
``` | output | 1 | 34,654 | 12 | 69,309 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gargari got bored to play with the bishops and now, after solving the problem about them, he is trying to do math homework. In a math book he have found k permutations. Each of them consists of numbers 1, 2, ..., n in some order. Now he should find the length of the longest common subsequence of these permutations. Can you help Gargari?
You can read about longest common subsequence there: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
Input
The first line contains two integers n and k (1 ≤ n ≤ 1000; 2 ≤ k ≤ 5). Each of the next k lines contains integers 1, 2, ..., n in some order — description of the current permutation.
Output
Print the length of the longest common subsequence.
Examples
Input
4 3
1 4 2 3
4 1 2 3
1 2 4 3
Output
3
Note
The answer for the first test sample is subsequence [1, 2, 3]. | instruction | 0 | 34,655 | 12 | 69,310 |
Tags: dfs and similar, dp, graphs, implementation
Correct Solution:
```
from sys import stdin, stdout, setrecursionlimit
input = stdin.readline
# import string
# characters = string.ascii_lowercase
# digits = string.digits
# setrecursionlimit(int(1e6))
# dir = [-1,0,1,0,-1]
# moves = 'NESW'
inf = float('inf')
from functools import cmp_to_key
from collections import defaultdict as dd
from collections import Counter, deque
from heapq import *
import math
from math import floor, ceil, sqrt
def geti(): return map(int, input().strip().split())
def getl(): return list(map(int, input().strip().split()))
def getis(): return map(str, input().strip().split())
def getls(): return list(map(str, input().strip().split()))
def gets(): return input().strip()
def geta(): return int(input())
def print_s(s): stdout.write(s+'\n')
def solve():
n, k = geti()
mat = []
pos = [[-1]*(n+1) for _ in range(k)]
for i in range(k):
mat.append(getl())
for j in range(n):
pos[i][mat[-1][j]] = j
dp = [1]*n
for i in range(n):
for j in range(i):
for now in range(k):
if pos[now][mat[0][i]] <= pos[now][mat[0][j]]:
break
else:
dp[i] = max(dp[i], dp[j] + 1)
# print(i, dp)
ans = max(dp)
print(ans)
if __name__=='__main__':
solve()
``` | output | 1 | 34,655 | 12 | 69,311 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gargari got bored to play with the bishops and now, after solving the problem about them, he is trying to do math homework. In a math book he have found k permutations. Each of them consists of numbers 1, 2, ..., n in some order. Now he should find the length of the longest common subsequence of these permutations. Can you help Gargari?
You can read about longest common subsequence there: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
Input
The first line contains two integers n and k (1 ≤ n ≤ 1000; 2 ≤ k ≤ 5). Each of the next k lines contains integers 1, 2, ..., n in some order — description of the current permutation.
Output
Print the length of the longest common subsequence.
Examples
Input
4 3
1 4 2 3
4 1 2 3
1 2 4 3
Output
3
Note
The answer for the first test sample is subsequence [1, 2, 3].
Submitted Solution:
```
# -*- coding:utf-8 -*-
"""
created by shuangquan.huang at 1/14/20
"""
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
memo = [0 for _ in range(1005)]
def longestpath(start, graph):
if memo[start] > 0:
return memo[start]
l = 0
for v in graph[start]:
l = max(longestpath(v, graph), l)
memo[start] = l + 1
return l + 1
def solve_graph(N, K, A, pos):
# for each u, v if u appears before v in every array, add a link u->v
g = collections.defaultdict(list)
d = [0 for _ in range(N+1)]
for u in range(1, N+1):
for v in range(1, N+1):
if all([pos[k][u] < pos[k][v] for k in range(1, K+1)]):
g[u].append(v)
d[v] += 1
# then find the longest path
ans = 0
for u in range(1, N+1):
if d[u] == 0:
ans = max(ans, longestpath(u, g))
return ans
def solve(N, K, A, pos):
dp = [0 for _ in range(N+1)]
for i in range(1, N+1):
maxx = 0
for p in range(1, i):
# if the A[1][p], A[1][i] is the last two elements of ans
# A[1][p] should appears before A[1][i] at every input array A[1:]
if all([pos[k][A[1][p]] < pos[k][A[1][i]] for k in range(2, K+1)]):
maxx = max(maxx, dp[p])
dp[i] = maxx + 1
return max(dp)
N, K = map(int, input().split())
A = [[0] * (N + 1)]
pos = [[0 for _ in range(N+1)] for _ in range(K+1)]
for i in range(K):
row = [0] + [int(x) for x in input().split()]
A.append(row)
for j, v in enumerate(row):
pos[i+1][v] = j
print(solve_graph(N, K, A, pos))
``` | instruction | 0 | 34,656 | 12 | 69,312 |
Yes | output | 1 | 34,656 | 12 | 69,313 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gargari got bored to play with the bishops and now, after solving the problem about them, he is trying to do math homework. In a math book he have found k permutations. Each of them consists of numbers 1, 2, ..., n in some order. Now he should find the length of the longest common subsequence of these permutations. Can you help Gargari?
You can read about longest common subsequence there: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
Input
The first line contains two integers n and k (1 ≤ n ≤ 1000; 2 ≤ k ≤ 5). Each of the next k lines contains integers 1, 2, ..., n in some order — description of the current permutation.
Output
Print the length of the longest common subsequence.
Examples
Input
4 3
1 4 2 3
4 1 2 3
1 2 4 3
Output
3
Note
The answer for the first test sample is subsequence [1, 2, 3].
Submitted Solution:
```
# Author : nitish420 --------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
def main():
n,k=map(int,input().split())
arr=[list(map(lambda x:int(x)-1,input().split())) for _ in range(k)]
pos=[[0 for _ in range(n)] for _ in range(k)]
for i in range(k):
for j in range(n):
pos[i][arr[i][j]]=j
dp=[0]*(n+1)
ans=0
for i in range(n):
mx=0
for j in range(i):
for z in range(1,k):
if pos[z][arr[0][j]]<pos[z][arr[0][i]]:
if z==k-1 and dp[j]>mx:
mx=dp[j]
else:
break
dp[i]=mx+1
ans=max(ans,dp[i])
print(ans)
#----------------------------------------------------------------------------------------
# region fastio
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')
# endregion
if __name__ == '__main__':
main()
``` | instruction | 0 | 34,657 | 12 | 69,314 |
Yes | output | 1 | 34,657 | 12 | 69,315 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gargari got bored to play with the bishops and now, after solving the problem about them, he is trying to do math homework. In a math book he have found k permutations. Each of them consists of numbers 1, 2, ..., n in some order. Now he should find the length of the longest common subsequence of these permutations. Can you help Gargari?
You can read about longest common subsequence there: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
Input
The first line contains two integers n and k (1 ≤ n ≤ 1000; 2 ≤ k ≤ 5). Each of the next k lines contains integers 1, 2, ..., n in some order — description of the current permutation.
Output
Print the length of the longest common subsequence.
Examples
Input
4 3
1 4 2 3
4 1 2 3
1 2 4 3
Output
3
Note
The answer for the first test sample is subsequence [1, 2, 3].
Submitted Solution:
```
import sys
input=sys.stdin.readline
n,k=map(int,input().split())
a=[list(map(int,input().split())) for i in range(k)]
g=[[] for i in range(n+1)]
for i in range(n):
x=a[0][i]
s=set(a[0][i+1:])
for j in range(k):
idx=a[j].index(x)
s1=set(a[j][idx+1:])
s=s&s1
for y in s:
g[x].append(y)
dist=[-1]*(n+1)
def dfs(ver):
if dist[ver]!=-1:
return dist[ver]
res=0
for to in g[ver]:
res=max(res,dfs(to)+1)
dist[ver]=res
return res
MAX=max(dfs(i) for i in range(1,n+1))
print(MAX+1)
``` | instruction | 0 | 34,658 | 12 | 69,316 |
Yes | output | 1 | 34,658 | 12 | 69,317 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gargari got bored to play with the bishops and now, after solving the problem about them, he is trying to do math homework. In a math book he have found k permutations. Each of them consists of numbers 1, 2, ..., n in some order. Now he should find the length of the longest common subsequence of these permutations. Can you help Gargari?
You can read about longest common subsequence there: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
Input
The first line contains two integers n and k (1 ≤ n ≤ 1000; 2 ≤ k ≤ 5). Each of the next k lines contains integers 1, 2, ..., n in some order — description of the current permutation.
Output
Print the length of the longest common subsequence.
Examples
Input
4 3
1 4 2 3
4 1 2 3
1 2 4 3
Output
3
Note
The answer for the first test sample is subsequence [1, 2, 3].
Submitted Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
import sys
from io import BytesIO, IOBase
def main():
n,k=map(int,input().split())
a=[list(map(lambda x:int(x)-1,input().split())) for _ in range(k)]
b=[[0]*n for _ in range(k)]
for i in range(k):
for j in range(n):
b[i][a[i][j]]=j
dp=[[0]*n for _ in range(k)]
for i in range(n-1,-1,-1):
for j in range(k):
maa,ele=0,a[j][i]
for m in range(k):
if b[m][ele] < i:
break
else:
for l in range(b[j][ele]+1,n):
ma=0
for m in range(k):
if b[m][ele]>b[m][a[j][l]]:
break
ma=max(ma,dp[m][b[m][a[j][l]]])
else:
maa=max(maa,ma)
dp[j][i]=maa+1
print(max(max(i) for i in dp))
# region fastio
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")
if __name__ == "__main__":
main()
``` | instruction | 0 | 34,659 | 12 | 69,318 |
Yes | output | 1 | 34,659 | 12 | 69,319 |
Evaluate the correctness of the submitted Python 2 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gargari got bored to play with the bishops and now, after solving the problem about them, he is trying to do math homework. In a math book he have found k permutations. Each of them consists of numbers 1, 2, ..., n in some order. Now he should find the length of the longest common subsequence of these permutations. Can you help Gargari?
You can read about longest common subsequence there: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
Input
The first line contains two integers n and k (1 ≤ n ≤ 1000; 2 ≤ k ≤ 5). Each of the next k lines contains integers 1, 2, ..., n in some order — description of the current permutation.
Output
Print the length of the longest common subsequence.
Examples
Input
4 3
1 4 2 3
4 1 2 3
1 2 4 3
Output
3
Note
The answer for the first test sample is subsequence [1, 2, 3].
Submitted Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
from fractions import gcd
raw_input = stdin.readline
pr = stdout.write
mod=10**9+7
def ni():
return int(raw_input())
def li():
return map(int,raw_input().split())
def pn(n):
stdout.write(str(n)+'\n')
def pa(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+
n,k=li()
d=defaultdict(list)
for i in range(k):
tp=li()
for j in range(n):
d[tp[j]].append(j)
d=d.values()
d.sort()
dp=[1]*(n+1)
for i in range(n):
for j in range(i):
f=0
for k1 in range(k):
if d[i][k1]<d[j][k1]:
f=1
break
if not f:
dp[i]=max(dp[i],dp[j]+1)
pn(max(dp))
``` | instruction | 0 | 34,660 | 12 | 69,320 |
Yes | output | 1 | 34,660 | 12 | 69,321 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gargari got bored to play with the bishops and now, after solving the problem about them, he is trying to do math homework. In a math book he have found k permutations. Each of them consists of numbers 1, 2, ..., n in some order. Now he should find the length of the longest common subsequence of these permutations. Can you help Gargari?
You can read about longest common subsequence there: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
Input
The first line contains two integers n and k (1 ≤ n ≤ 1000; 2 ≤ k ≤ 5). Each of the next k lines contains integers 1, 2, ..., n in some order — description of the current permutation.
Output
Print the length of the longest common subsequence.
Examples
Input
4 3
1 4 2 3
4 1 2 3
1 2 4 3
Output
3
Note
The answer for the first test sample is subsequence [1, 2, 3].
Submitted Solution:
```
n, k = map(int, input().split())
a, b = [[] for row in range(6)], [[0 for col in range(n + 1)] for row in range(6)]
for i in range(k):
a[i] = list(map(int, input().split()))
for j in range(n):
b[i][a[i][j]] = j
if n == 64:
print(a[2])
print(a[3])
dp = [1] * n
for i in range(n):
for j in range(i):
flag = 1
for x in range(1, k):
if b[x][a[0][j]] > b[x][a[0][i]]:
flag = 0
break
if flag:
dp[i] = max(dp[i], dp[j] + 1)
print(dp[n - 1])
``` | instruction | 0 | 34,661 | 12 | 69,322 |
No | output | 1 | 34,661 | 12 | 69,323 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gargari got bored to play with the bishops and now, after solving the problem about them, he is trying to do math homework. In a math book he have found k permutations. Each of them consists of numbers 1, 2, ..., n in some order. Now he should find the length of the longest common subsequence of these permutations. Can you help Gargari?
You can read about longest common subsequence there: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
Input
The first line contains two integers n and k (1 ≤ n ≤ 1000; 2 ≤ k ≤ 5). Each of the next k lines contains integers 1, 2, ..., n in some order — description of the current permutation.
Output
Print the length of the longest common subsequence.
Examples
Input
4 3
1 4 2 3
4 1 2 3
1 2 4 3
Output
3
Note
The answer for the first test sample is subsequence [1, 2, 3].
Submitted Solution:
```
def lcs(a, b):
lengths = [[0 for j in range(len(b)+1)] for i in range(len(a)+1)]
# row 0 and column 0 are initialized to 0 already
for i, x in enumerate(a):
for j, y in enumerate(b):
if x == y:
lengths[i+1][j+1] = lengths[i][j] + 1
else:
lengths[i+1][j+1] = \
max(lengths[i+1][j], lengths[i][j+1])
# read the substring out from the matrix
result = ""
x, y = len(a), len(b)
while x != 0 and y != 0:
if lengths[x][y] == lengths[x-1][y]:
x -= 1
elif lengths[x][y] == lengths[x][y-1]:
y -= 1
else:
assert a[x-1] == b[y-1]
result = a[x-1] + result
x -= 1
y -= 1
return result
finallcs = ''
a, b = map(int, input().split(' '))
sa = input().split(' ')
sa2 = ''
for i in range(len(sa)):
sa2 += sa[i]
finallcs = sa2
for i in range(b-1):
sa = input().split(' ')
sa2 = ''
for i in range(len(sa)):
sa2 += sa[i]
finallcs = lcs(finallcs, sa2)
print(len(finallcs))
``` | instruction | 0 | 34,662 | 12 | 69,324 |
No | output | 1 | 34,662 | 12 | 69,325 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gargari got bored to play with the bishops and now, after solving the problem about them, he is trying to do math homework. In a math book he have found k permutations. Each of them consists of numbers 1, 2, ..., n in some order. Now he should find the length of the longest common subsequence of these permutations. Can you help Gargari?
You can read about longest common subsequence there: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
Input
The first line contains two integers n and k (1 ≤ n ≤ 1000; 2 ≤ k ≤ 5). Each of the next k lines contains integers 1, 2, ..., n in some order — description of the current permutation.
Output
Print the length of the longest common subsequence.
Examples
Input
4 3
1 4 2 3
4 1 2 3
1 2 4 3
Output
3
Note
The answer for the first test sample is subsequence [1, 2, 3].
Submitted Solution:
```
cols , rows = map(int , input().split())
a= [list(map(int,input().split())) for _ in range(rows)]
n = 1;m=0
for i in range(rows):
for j in range(cols-1):
if a[i][j]<a[i][j+1]:
n+=1
else : n =0
m = max(n,m)
n = 1
print(m)
``` | instruction | 0 | 34,663 | 12 | 69,326 |
No | output | 1 | 34,663 | 12 | 69,327 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gargari got bored to play with the bishops and now, after solving the problem about them, he is trying to do math homework. In a math book he have found k permutations. Each of them consists of numbers 1, 2, ..., n in some order. Now he should find the length of the longest common subsequence of these permutations. Can you help Gargari?
You can read about longest common subsequence there: https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
Input
The first line contains two integers n and k (1 ≤ n ≤ 1000; 2 ≤ k ≤ 5). Each of the next k lines contains integers 1, 2, ..., n in some order — description of the current permutation.
Output
Print the length of the longest common subsequence.
Examples
Input
4 3
1 4 2 3
4 1 2 3
1 2 4 3
Output
3
Note
The answer for the first test sample is subsequence [1, 2, 3].
Submitted Solution:
```
n, k = map(int, input().split())
mz = 0
for i in range(k):
a = [int(x) for x in input().split()]
z = 0
for j in range(1, n):
if a[j] > a[j-1]:
z += 1
if z+1 > mz:
mz = z+1
print(mz)
``` | instruction | 0 | 34,664 | 12 | 69,328 |
No | output | 1 | 34,664 | 12 | 69,329 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Consider a sequence [a1, a2, ... , an]. Define its prefix product sequence <image>.
Now given n, find a permutation of [1, 2, ..., n], such that its prefix product sequence is a permutation of [0, 1, ..., n - 1].
Input
The only input line contains an integer n (1 ≤ n ≤ 105).
Output
In the first output line, print "YES" if such sequence exists, or print "NO" if no such sequence exists.
If any solution exists, you should output n more lines. i-th line contains only an integer ai. The elements of the sequence should be different positive integers no larger than n.
If there are multiple solutions, you are allowed to print any of them.
Examples
Input
7
Output
YES
1
4
3
6
5
2
7
Input
6
Output
NO
Note
For the second sample, there are no valid sequences. | instruction | 0 | 34,665 | 12 | 69,330 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
n = int(input())
if n == 4:
print ("YES\n1 3 2 4")
elif [i for i in range(2,n) if n%i==0]:
print("NO")
else:
print("YES\n1 %s"%(" ".join(str((pow(x+1,n-2,n)*(x+2))%n or n) for x in range(n-1))))
``` | output | 1 | 34,665 | 12 | 69,331 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Consider a sequence [a1, a2, ... , an]. Define its prefix product sequence <image>.
Now given n, find a permutation of [1, 2, ..., n], such that its prefix product sequence is a permutation of [0, 1, ..., n - 1].
Input
The only input line contains an integer n (1 ≤ n ≤ 105).
Output
In the first output line, print "YES" if such sequence exists, or print "NO" if no such sequence exists.
If any solution exists, you should output n more lines. i-th line contains only an integer ai. The elements of the sequence should be different positive integers no larger than n.
If there are multiple solutions, you are allowed to print any of them.
Examples
Input
7
Output
YES
1
4
3
6
5
2
7
Input
6
Output
NO
Note
For the second sample, there are no valid sequences. | instruction | 0 | 34,666 | 12 | 69,332 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
import math
import sys
input = sys.stdin.readline
n = int(input())
def isPrime(n):
for i in range(2, n):
if n % i == 0:
return False
return True
if isPrime(n):
print('YES')
print('\n'.join(list(map(str, [1] + [i * pow(i - 1, n - 2, n) % n for i in range(2, n)] + [n]))[:n]))
elif n == 4:
print('YES')
print('\n'.join(map(str, [1, 3, 2, 4])))
else:
print('NO')
``` | output | 1 | 34,666 | 12 | 69,333 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Consider a sequence [a1, a2, ... , an]. Define its prefix product sequence <image>.
Now given n, find a permutation of [1, 2, ..., n], such that its prefix product sequence is a permutation of [0, 1, ..., n - 1].
Input
The only input line contains an integer n (1 ≤ n ≤ 105).
Output
In the first output line, print "YES" if such sequence exists, or print "NO" if no such sequence exists.
If any solution exists, you should output n more lines. i-th line contains only an integer ai. The elements of the sequence should be different positive integers no larger than n.
If there are multiple solutions, you are allowed to print any of them.
Examples
Input
7
Output
YES
1
4
3
6
5
2
7
Input
6
Output
NO
Note
For the second sample, there are no valid sequences. | instruction | 0 | 34,667 | 12 | 69,334 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
n = int(input())
if n == 4:
print ("YES\n1 3 2 4")
elif [i for i in range(2,n) if n%i==0]:
print("NO")
else:
print("YES\n1 %s"%(" ".join(str((pow(x+1,n-2,n)*(x+2))%n or n) for x in range(n-1))))
# Made By Mostafa_Khaled
``` | output | 1 | 34,667 | 12 | 69,335 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Consider a sequence [a1, a2, ... , an]. Define its prefix product sequence <image>.
Now given n, find a permutation of [1, 2, ..., n], such that its prefix product sequence is a permutation of [0, 1, ..., n - 1].
Input
The only input line contains an integer n (1 ≤ n ≤ 105).
Output
In the first output line, print "YES" if such sequence exists, or print "NO" if no such sequence exists.
If any solution exists, you should output n more lines. i-th line contains only an integer ai. The elements of the sequence should be different positive integers no larger than n.
If there are multiple solutions, you are allowed to print any of them.
Examples
Input
7
Output
YES
1
4
3
6
5
2
7
Input
6
Output
NO
Note
For the second sample, there are no valid sequences. | instruction | 0 | 34,668 | 12 | 69,336 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
n = int(input())
if n == 1:
print('YES\n1')
exit(0)
if n == 4:
print('YES\n1 3 2 4')
exit(0)
for p in range(2, int(n ** 0.5) + 1):
if n % p == 0:
print('NO')
exit(0)
print('YES')
print(1)
for j in range(2, n):
print(j * pow(j - 1, n - 2, n) % n)
print(n)
``` | output | 1 | 34,668 | 12 | 69,337 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Consider a sequence [a1, a2, ... , an]. Define its prefix product sequence <image>.
Now given n, find a permutation of [1, 2, ..., n], such that its prefix product sequence is a permutation of [0, 1, ..., n - 1].
Input
The only input line contains an integer n (1 ≤ n ≤ 105).
Output
In the first output line, print "YES" if such sequence exists, or print "NO" if no such sequence exists.
If any solution exists, you should output n more lines. i-th line contains only an integer ai. The elements of the sequence should be different positive integers no larger than n.
If there are multiple solutions, you are allowed to print any of them.
Examples
Input
7
Output
YES
1
4
3
6
5
2
7
Input
6
Output
NO
Note
For the second sample, there are no valid sequences. | instruction | 0 | 34,669 | 12 | 69,338 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
#In The Nam Of GOd
n=int(input());
if(n==1):
print("YES",1);
exit();
if(n==2):
print("YES",1,2,sep="\n");
exit();
if(n==4):
print("YES",1,3,2,4,sep="\n");
exit();
for i in range(2,n):
if n%i==0:
print("NO");
exit();
print("YES",1,sep="\n");
for i in range (2,n):
print((i*pow(i-1,n-2,n))%n);
print(n);
``` | output | 1 | 34,669 | 12 | 69,339 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Consider a sequence [a1, a2, ... , an]. Define its prefix product sequence <image>.
Now given n, find a permutation of [1, 2, ..., n], such that its prefix product sequence is a permutation of [0, 1, ..., n - 1].
Input
The only input line contains an integer n (1 ≤ n ≤ 105).
Output
In the first output line, print "YES" if such sequence exists, or print "NO" if no such sequence exists.
If any solution exists, you should output n more lines. i-th line contains only an integer ai. The elements of the sequence should be different positive integers no larger than n.
If there are multiple solutions, you are allowed to print any of them.
Examples
Input
7
Output
YES
1
4
3
6
5
2
7
Input
6
Output
NO
Note
For the second sample, there are no valid sequences. | instruction | 0 | 34,670 | 12 | 69,340 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
import math
import sys
input = sys.stdin.readline
n = int(input())
if math.factorial(n - 1) % n == n - 1:
print('YES')
print('\n'.join(list(map(str, [1] + [i * pow(i - 1, n - 2, n) % n for i in range(2, n)] + [n]))[:n]))
elif n == 4:
print('YES')
print('\n'.join(map(str, [1, 3, 2, 4])))
else:
print('NO')
``` | output | 1 | 34,670 | 12 | 69,341 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Consider a sequence [a1, a2, ... , an]. Define its prefix product sequence <image>.
Now given n, find a permutation of [1, 2, ..., n], such that its prefix product sequence is a permutation of [0, 1, ..., n - 1].
Input
The only input line contains an integer n (1 ≤ n ≤ 105).
Output
In the first output line, print "YES" if such sequence exists, or print "NO" if no such sequence exists.
If any solution exists, you should output n more lines. i-th line contains only an integer ai. The elements of the sequence should be different positive integers no larger than n.
If there are multiple solutions, you are allowed to print any of them.
Examples
Input
7
Output
YES
1
4
3
6
5
2
7
Input
6
Output
NO
Note
For the second sample, there are no valid sequences. | instruction | 0 | 34,671 | 12 | 69,342 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
n=int(input());
if(n==1):
print("YES",1);
elif(n==2):
print("YES",1,2,sep="\n");
elif(n==4):
print("YES",1,3,2,4,sep="\n");
else:
for i in range(2,n):
if n%i==0:
print("NO");
exit();
print("YES",1,sep="\n");
for i in range (2,n):
print((i*pow(i-1,n-2,n))%n);
print(n);
``` | output | 1 | 34,671 | 12 | 69,343 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Consider a sequence [a1, a2, ... , an]. Define its prefix product sequence <image>.
Now given n, find a permutation of [1, 2, ..., n], such that its prefix product sequence is a permutation of [0, 1, ..., n - 1].
Input
The only input line contains an integer n (1 ≤ n ≤ 105).
Output
In the first output line, print "YES" if such sequence exists, or print "NO" if no such sequence exists.
If any solution exists, you should output n more lines. i-th line contains only an integer ai. The elements of the sequence should be different positive integers no larger than n.
If there are multiple solutions, you are allowed to print any of them.
Examples
Input
7
Output
YES
1
4
3
6
5
2
7
Input
6
Output
NO
Note
For the second sample, there are no valid sequences. | instruction | 0 | 34,672 | 12 | 69,344 |
Tags: constructive algorithms, math, number theory
Correct Solution:
```
def comp(x):
for i in range(2, x):
if x % i == 0:
return True
return False
N = int(input())
if N == 4:
print('YES', '1', '3', '2', '4', sep = '\n')
elif comp(N):
print('NO')
else:
print('YES', '1', sep = '\n')
if N > 1:
for i in range(2, N):
print((i - 1) * pow(i, N - 2, N) % N)
print(N)
``` | output | 1 | 34,672 | 12 | 69,345 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Consider a sequence [a1, a2, ... , an]. Define its prefix product sequence <image>.
Now given n, find a permutation of [1, 2, ..., n], such that its prefix product sequence is a permutation of [0, 1, ..., n - 1].
Input
The only input line contains an integer n (1 ≤ n ≤ 105).
Output
In the first output line, print "YES" if such sequence exists, or print "NO" if no such sequence exists.
If any solution exists, you should output n more lines. i-th line contains only an integer ai. The elements of the sequence should be different positive integers no larger than n.
If there are multiple solutions, you are allowed to print any of them.
Examples
Input
7
Output
YES
1
4
3
6
5
2
7
Input
6
Output
NO
Note
For the second sample, there are no valid sequences.
Submitted Solution:
```
from math import *
import time
def isPrime(x):
if(x<=1):
return False
elif(x==2):
return True
elif(x%2==0):
return False
for i in range (2, x, 2):
if(i*i>x):
break
if(x%i==0):
return False
return True
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, x, y = egcd(b % a, a)
return (g, y - (b // a) * x, x)
def zadatak(n):
#start=time.time()
rjesenje=[]
ostatak=1
ostatakProsli=1
umnozak=1
x=1
if(isPrime(n)==False and n!=4 and n!=1):
print("NO")
return False
if(n==1):
rjesenje.append(1)
else:
while(True):
a,b,c=egcd(ostatakProsli,n)
b*=ostatak
b%=n
if(b==0):
b=n
rjesenje.append(b)
umnozak*=b
if(ostatak==0):
break
ostatakProsli=ostatak
ostatak+=2
if(ostatak>=n and ostatak%2==1):
ostatak=2
if(ostatak>n):
break
elif(ostatak>=n and ostatak%2==0):
ostatak=0
#rjesenje[n//2]=n-1
#end=time.time()
#print(end-start)
print("YES")
for i in range(len(rjesenje)):
print(rjesenje[i])
n=int(input())
zadatak(n)
``` | instruction | 0 | 34,677 | 12 | 69,354 |
No | output | 1 | 34,677 | 12 | 69,355 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Pussycat Sonya has an array consisting of n positive integers. There are 2n possible subsequences of the array. For each subsequence she counts the minimum number of operations to make all its elements equal. Each operation must be one of two:
* Choose some element of the subsequence and multiply it by some prime number.
* Choose some element of the subsequence and divide it by some prime number. The chosen element must be divisible by the chosen prime number.
What is the sum of minimum number of operations for all 2n possible subsequences? Find and print this sum modulo 109 + 7.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 300 000) — the size of the array.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 300 000) — elements of the array.
Output
Print the sum of minimum number of operation for all possible subsequences of the given array modulo 109 + 7.
Examples
Input
3
60 60 40
Output
6
Input
4
1 2 3 4
Output
24
Note
In the first sample, there are 8 possible subsequences: (60, 60, 40), (60, 60), (60, 40), (60, 40), (60), (60), (40) and () (empty subsequence).
For a subsequence (60, 60, 40) we can make all elements equal by two operations — divide 40 by 2 to get 20, and then multiply 20 by 3 to get 60. It's impossible to achieve the goal using less operations and thus we add 2 to the answer.
There are two subsequences equal to (60, 40) and for each of them the also need to make at least 2 operations.
In each of other subsequences all numbers are already equal, so we need 0 operations for each of them. The sum is equal to 2 + 2 + 2 = 6.
Submitted Solution:
```
x=int(input(""))
array=input("").split(' ')
array=[int(x) for x in array]
total=0
newestghf=1
bub=0.5*x
for i in range (1,max(array)):
for k in range (0,x):
if (array[k]%i==0):
total=total+1
if (total>=bub):
newestghf=i
total=0
print(newestghf)
``` | instruction | 0 | 34,764 | 12 | 69,528 |
No | output | 1 | 34,764 | 12 | 69,529 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Pussycat Sonya has an array consisting of n positive integers. There are 2n possible subsequences of the array. For each subsequence she counts the minimum number of operations to make all its elements equal. Each operation must be one of two:
* Choose some element of the subsequence and multiply it by some prime number.
* Choose some element of the subsequence and divide it by some prime number. The chosen element must be divisible by the chosen prime number.
What is the sum of minimum number of operations for all 2n possible subsequences? Find and print this sum modulo 109 + 7.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 300 000) — the size of the array.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ 300 000) — elements of the array.
Output
Print the sum of minimum number of operation for all possible subsequences of the given array modulo 109 + 7.
Examples
Input
3
60 60 40
Output
6
Input
4
1 2 3 4
Output
24
Note
In the first sample, there are 8 possible subsequences: (60, 60, 40), (60, 60), (60, 40), (60, 40), (60), (60), (40) and () (empty subsequence).
For a subsequence (60, 60, 40) we can make all elements equal by two operations — divide 40 by 2 to get 20, and then multiply 20 by 3 to get 60. It's impossible to achieve the goal using less operations and thus we add 2 to the answer.
There are two subsequences equal to (60, 40) and for each of them the also need to make at least 2 operations.
In each of other subsequences all numbers are already equal, so we need 0 operations for each of them. The sum is equal to 2 + 2 + 2 = 6.
Submitted Solution:
```
#http://codeforces.com/problemset/problem/653/G
import itertools as itertools
import fractions as fractions
def powerset(iterable):
output = []
for i in range(len(iterable)+1):
holder1 = itertools.combinations(iterable, i)
for x in holder1:
holder2 = list(x)
#print(holder2)
# if holder2 not in output:
output.append(holder2) #can have duplicate sequences
return output
def importantsets(some_list):
new_set = []
ops = 0
# print(some_set)
for x in some_list:
#print(x_set)
if len(x) == 0 or len(set(x)) == 1:
#no numbers in set
#1 number in set
#all numbers are the same in set
ops += 0 #no operations needed
else:
new_set.append(x)
return new_set
def reduceset(iset):
#reduce the set size by one and count operations
i_list = list(iset)
print(i_list)
if __name__ == '__main__':
qty = int(input())
#print(qty)
num_array = [int(x) for x in input().split()]
#print(num_array)
#num_array = [40, 60, 40]
ops = 0
pset = powerset(num_array)
iset = importantsets(pset)
#print("These are the important sets %s" %iset)
ops = 0
for x1_set in iset:
#print(list(set(x1_set)))
x_set2 = list(set(x1_set))
#print(x_set2)
while len(x_set2) > 1:
GCD = x_set2[0]
for i in range(len(x_set2)):
GCD = fractions.gcd(GCD, x_set2[i])
#print(GCD)
x_set2_red = sorted([x / GCD for x in x_set2])
ops += 1
#print(x_set2_red)
if fractions.gcd(x_set2_red[0],x_set2_red[1]) == 1:
#if firs two values are prime
#remove one and continue
x_set2.pop(0)
ops+=1
print(ops)
#reduceset(GCD_array)
# for mults in GCD_array:
``` | instruction | 0 | 34,765 | 12 | 69,530 |
No | output | 1 | 34,765 | 12 | 69,531 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice is a beginner composer and now she is ready to create another masterpiece. And not even the single one but two at the same time!
Alice has a sheet with n notes written on it. She wants to take two such non-empty non-intersecting subsequences that both of them form a melody and sum of their lengths is maximal.
Subsequence is a sequence that can be derived from another sequence by deleting some elements without changing the order of the remaining elements.
Subsequence forms a melody when each two adjacent notes either differs by 1 or are congruent modulo 7.
You should write a program which will calculate maximum sum of lengths of such two non-empty non-intersecting subsequences that both of them form a melody.
Input
The first line contains one integer number n (2 ≤ n ≤ 5000).
The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 105) — notes written on a sheet.
Output
Print maximum sum of lengths of such two non-empty non-intersecting subsequences that both of them form a melody.
Examples
Input
4
1 2 4 5
Output
4
Input
6
62 22 60 61 48 49
Output
5
Note
In the first example subsequences [1, 2] and [4, 5] give length 4 in total.
In the second example subsequences [62, 48, 49] and [60, 61] give length 5 in total. If you choose subsequence [62, 61] in the first place then the second melody will have maximum length 2, that gives the result of 4, which is not maximal. | instruction | 0 | 34,830 | 12 | 69,660 |
Tags: dp, flows
Correct Solution:
```
import sys
n = int(input()) + 1
a = [0] + list(map(int, input().split()))
mod7 = [x % 7 for x in a]
dp = [[0]*n for _ in range(n)]
maxnum = [0]*(10**5+10)
ans = 0
for i in range(n):
maxmod = [0]*7
for j in range(n):
maxnum[a[j]] = 0
for j in range(i):
maxnum[a[j]] = max(maxnum[a[j]], dp[j][i])
maxmod[mod7[j]] = max(maxmod[mod7[j]], dp[j][i])
for j in range(i+1, n):
dp[i][j] = max(
maxnum[a[j]-1],
maxnum[a[j]+1],
maxmod[mod7[j]],
dp[0][i]
) + 1
maxnum[a[j]] = max(maxnum[a[j]], dp[i][j])
maxmod[mod7[j]] = max(maxmod[mod7[j]], dp[i][j])
ans = max(ans, dp[i][j])
print(ans)
``` | output | 1 | 34,830 | 12 | 69,661 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice is a beginner composer and now she is ready to create another masterpiece. And not even the single one but two at the same time!
Alice has a sheet with n notes written on it. She wants to take two such non-empty non-intersecting subsequences that both of them form a melody and sum of their lengths is maximal.
Subsequence is a sequence that can be derived from another sequence by deleting some elements without changing the order of the remaining elements.
Subsequence forms a melody when each two adjacent notes either differs by 1 or are congruent modulo 7.
You should write a program which will calculate maximum sum of lengths of such two non-empty non-intersecting subsequences that both of them form a melody.
Input
The first line contains one integer number n (2 ≤ n ≤ 5000).
The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 105) — notes written on a sheet.
Output
Print maximum sum of lengths of such two non-empty non-intersecting subsequences that both of them form a melody.
Examples
Input
4
1 2 4 5
Output
4
Input
6
62 22 60 61 48 49
Output
5
Note
In the first example subsequences [1, 2] and [4, 5] give length 4 in total.
In the second example subsequences [62, 48, 49] and [60, 61] give length 5 in total. If you choose subsequence [62, 61] in the first place then the second melody will have maximum length 2, that gives the result of 4, which is not maximal. | instruction | 0 | 34,831 | 12 | 69,662 |
Tags: dp, flows
Correct Solution:
```
import sys
def solve():
n = int(sys.stdin.readline())
a = [0] + [int(i) for i in sys.stdin.readline().split()]
dp = [[0]*(n + 1) for i in range(n + 1)]
ans = 0
maxnum = [0] * (10**5 + 2)
maxmod = [0] * 7
for y in range(n + 1):
maxmod = [0] * 7
for ai in a:
maxnum[ai] = 0
for i in range(y):
maxmod[a[i] % 7] = max(maxmod[a[i] % 7], dp[i][y])
maxnum[a[i]] = max(maxnum[a[i]], dp[i][y])
for x in range(y + 1, n + 1):
dp[x][y] = max(maxmod[a[x] % 7], maxnum[a[x] + 1], maxnum[a[x] - 1], dp[0][y]) + 1
dp[y][x] = dp[x][y]
maxmod[a[x] % 7] = max(maxmod[a[x] % 7], dp[x][y])
maxnum[a[x]] = max(maxnum[a[x]], dp[x][y])
ans = max(ans, dp[x][y])
print(ans)
if __name__ == '__main__':
solve()
``` | output | 1 | 34,831 | 12 | 69,663 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice is a beginner composer and now she is ready to create another masterpiece. And not even the single one but two at the same time!
Alice has a sheet with n notes written on it. She wants to take two such non-empty non-intersecting subsequences that both of them form a melody and sum of their lengths is maximal.
Subsequence is a sequence that can be derived from another sequence by deleting some elements without changing the order of the remaining elements.
Subsequence forms a melody when each two adjacent notes either differs by 1 or are congruent modulo 7.
You should write a program which will calculate maximum sum of lengths of such two non-empty non-intersecting subsequences that both of them form a melody.
Input
The first line contains one integer number n (2 ≤ n ≤ 5000).
The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 105) — notes written on a sheet.
Output
Print maximum sum of lengths of such two non-empty non-intersecting subsequences that both of them form a melody.
Examples
Input
4
1 2 4 5
Output
4
Input
6
62 22 60 61 48 49
Output
5
Note
In the first example subsequences [1, 2] and [4, 5] give length 4 in total.
In the second example subsequences [62, 48, 49] and [60, 61] give length 5 in total. If you choose subsequence [62, 61] in the first place then the second melody will have maximum length 2, that gives the result of 4, which is not maximal.
Submitted Solution:
```
import sys
n = int(input()) + 1
a = [0] + list(map(int, input().split()))
mod7 = [x % 7 for x in a]
dp = [[0]*n for _ in range(n)]
maxnum = [0]*(10**5+10)
ans = 0
for i in range(n):
maxmod = [0]*7
for j in range(i, n):
maxnum[a[j]] = 0
for j in range(i):
maxnum[a[j]] = max(maxnum[a[j]], dp[j][i])
maxmod[mod7[j]] = max(maxmod[mod7[j]], dp[j][i])
for j in range(i+1, n):
dp[i][j] = max(
maxnum[a[j]-1],
maxnum[a[j]+1],
maxmod[mod7[j]],
dp[0][i]
) + 1
maxnum[a[j]] = max(maxnum[a[j]], dp[i][j])
maxmod[mod7[j]] = max(maxmod[mod7[j]], dp[i][j])
ans = max(ans, dp[i][j])
print(ans)
``` | instruction | 0 | 34,832 | 12 | 69,664 |
No | output | 1 | 34,832 | 12 | 69,665 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice is a beginner composer and now she is ready to create another masterpiece. And not even the single one but two at the same time!
Alice has a sheet with n notes written on it. She wants to take two such non-empty non-intersecting subsequences that both of them form a melody and sum of their lengths is maximal.
Subsequence is a sequence that can be derived from another sequence by deleting some elements without changing the order of the remaining elements.
Subsequence forms a melody when each two adjacent notes either differs by 1 or are congruent modulo 7.
You should write a program which will calculate maximum sum of lengths of such two non-empty non-intersecting subsequences that both of them form a melody.
Input
The first line contains one integer number n (2 ≤ n ≤ 5000).
The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 105) — notes written on a sheet.
Output
Print maximum sum of lengths of such two non-empty non-intersecting subsequences that both of them form a melody.
Examples
Input
4
1 2 4 5
Output
4
Input
6
62 22 60 61 48 49
Output
5
Note
In the first example subsequences [1, 2] and [4, 5] give length 4 in total.
In the second example subsequences [62, 48, 49] and [60, 61] give length 5 in total. If you choose subsequence [62, 61] in the first place then the second melody will have maximum length 2, that gives the result of 4, which is not maximal.
Submitted Solution:
```
import sys
n = int(input()) + 1
a = [0] + list(map(int, input().split()))
mod7 = [x % 7 for x in a]
dp = [[0]*n for _ in range(n)]
maxnum = [0]*(10**5+10)
ans = 0
for i in range(n):
maxmod = [0]*7
for j in range(i):
maxnum[a[j]] = max(maxnum[a[j]], dp[j][i])
maxmod[mod7[j]] = max(maxmod[mod7[j]], dp[j][i])
for j in range(i+1, n):
dp[i][j] = max(
maxnum[a[j]-1],
maxnum[a[j]+1],
maxmod[mod7[j]],
dp[0][i]
) + 1
maxnum[a[j]] = max(maxnum[a[j]], dp[i][j])
maxmod[mod7[j]] = max(maxmod[mod7[j]], dp[i][j])
ans = max(ans, dp[i][j])
for j in range(i, n):
maxnum[a[j]] = 0
print(ans)
``` | instruction | 0 | 34,833 | 12 | 69,666 |
No | output | 1 | 34,833 | 12 | 69,667 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice is a beginner composer and now she is ready to create another masterpiece. And not even the single one but two at the same time!
Alice has a sheet with n notes written on it. She wants to take two such non-empty non-intersecting subsequences that both of them form a melody and sum of their lengths is maximal.
Subsequence is a sequence that can be derived from another sequence by deleting some elements without changing the order of the remaining elements.
Subsequence forms a melody when each two adjacent notes either differs by 1 or are congruent modulo 7.
You should write a program which will calculate maximum sum of lengths of such two non-empty non-intersecting subsequences that both of them form a melody.
Input
The first line contains one integer number n (2 ≤ n ≤ 5000).
The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 105) — notes written on a sheet.
Output
Print maximum sum of lengths of such two non-empty non-intersecting subsequences that both of them form a melody.
Examples
Input
4
1 2 4 5
Output
4
Input
6
62 22 60 61 48 49
Output
5
Note
In the first example subsequences [1, 2] and [4, 5] give length 4 in total.
In the second example subsequences [62, 48, 49] and [60, 61] give length 5 in total. If you choose subsequence [62, 61] in the first place then the second melody will have maximum length 2, that gives the result of 4, which is not maximal.
Submitted Solution:
```
import sys
n = int(input()) + 1
a = [0] + list(map(int, input().split()))
mod7 = [x % 7 for x in a]
inf = 10**9
next_i = [[[inf]*3 for _ in range(n+1)] for _ in range(n+1)]
for j in range(n-1, -1, -1):
next_i[0][j] = [j]*3
for i in range(1, n):
next_i[i][j][0] = j if a[i]-1 == a[j] else next_i[i][j+1][0]
next_i[i][j][1] = j if a[i]+1 == a[j] else next_i[i][j+1][1]
next_i[i][j][2] = j if mod7[i] == mod7[j] else next_i[i][j+1][2]
dp = [[0]*n for _ in range(n)]
for j in range(1, n-1):
for k in range(3):
if next_i[j][j+1][k] != inf:
dp[0][next_i[j][j+1][k]] = max(
dp[0][next_i[j][j+1][k]], dp[0][j]+1
)
for k in range(j+1, n):
dp[j][k] = max(dp[j][k], dp[0][j]+1)
for i in range(1, n):
for j in range(i+1, n):
for k in range(3):
if next_i[i][j+1][k] != inf:
dp[j][next_i[i][j+1][k]] = max(
dp[j][next_i[i][j+1][k]],
dp[i][j]+1
)
if next_i[j][j+1][k] != inf:
dp[i][next_i[j][j+1][k]] = max(
dp[i][next_i[j][j+1][k]],
dp[i][j]+1
)
print(max(max(row[1:]) for row in dp[1:]))
``` | instruction | 0 | 34,834 | 12 | 69,668 |
No | output | 1 | 34,834 | 12 | 69,669 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.