message stringlengths 2 39.6k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 219 108k | cluster float64 11 11 | __index_level_0__ int64 438 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
So you decided to hold a contest on Codeforces. You prepared the problems: statements, solutions, checkers, validators, tests... Suddenly, your coordinator asks you to change all your tests to multiple testcases in the easiest problem!
Initially, each test in that problem is just an array. The maximum size of an array is k. For simplicity, the contents of arrays don't matter. You have n tests β the i-th test is an array of size m_i (1 β€ m_i β€ k).
Your coordinator asks you to distribute all of your arrays into multiple testcases. Each testcase can include multiple arrays. However, each testcase should include no more than c_1 arrays of size greater than or equal to 1 (β₯ 1), no more than c_2 arrays of size greater than or equal to 2, ..., no more than c_k arrays of size greater than or equal to k. Also, c_1 β₯ c_2 β₯ ... β₯ c_k.
So now your goal is to create the new testcases in such a way that:
* each of the initial arrays appears in exactly one testcase;
* for each testcase the given conditions hold;
* the number of testcases is minimum possible.
Print the minimum possible number of testcases you can achieve and the sizes of arrays included in each testcase.
Input
The first line contains two integers n and k (1 β€ n, k β€ 2 β
10^5) β the number of initial tests and the limit for the size of each array.
The second line contains n integers m_1, m_2, ..., m_n (1 β€ m_i β€ k) β the sizes of the arrays in the original tests.
The third line contains k integers c_1, c_2, ..., c_k (n β₯ c_1 β₯ c_2 β₯ ... β₯ c_k β₯ 1); c_i is the maximum number of arrays of size greater than or equal to i you can have in a single testcase.
Output
In the first line print a single integer ans (1 β€ ans β€ n) β the minimum number of testcases you can achieve.
Each of the next ans lines should contain the description of a testcase in the following format:
t a_1 a_2 ... a_{t} (1 β€ tβ€ n) β the testcase includes t arrays, a_i is the size of the i-th array in that testcase.
Each of the initial arrays should appear in exactly one testcase. In particular, it implies that the sum of t over all ans testcases should be equal to n.
Note that the answer always exists due to c_k β₯ 1 (and therefore c_1 β₯ 1).
If there are multiple answers, you can output any one of them.
Examples
Input
4 3
1 2 2 3
4 1 1
Output
3
1 2
2 1 3
1 2
Input
6 10
5 8 1 10 8 7
6 6 4 4 3 2 2 2 1 1
Output
2
3 8 5 7
3 10 8 1
Input
5 1
1 1 1 1 1
5
Output
1
5 1 1 1 1 1
Input
5 1
1 1 1 1 1
1
Output
5
1 1
1 1
1 1
1 1
1 1
Note
In the first example there is no way to distribute the tests into less than 3 testcases. The given answer satisfies the conditions: each of the testcases includes no more than 4 arrays of size greater than or equal to 1 and no more than 1 array of sizes greater than or equal to 2 and 3.
Note that there are multiple valid answers for this test. For example, testcases with sizes [[2], [1, 2], [3]] would also be correct.
However, testcases with sizes [[1, 2], [2, 3]] would be incorrect because there are 2 arrays of size greater than or equal to 2 in the second testcase.
Note the difference between the third and the fourth examples. You can include up to 5 arrays of size greater than or equal to 1 in the third example, so you can put all arrays into a single testcase. And you can have only up to 1 array in the fourth example. Thus, every array should be included in a separate testcase. | instruction | 0 | 43,113 | 11 | 86,226 |
Tags: binary search, constructive algorithms, data structures, greedy, sortings, two pointers
Correct Solution:
```
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def main():
inf=10**9
n,k=MI()
mm=LI()
cc=[-1]+LI()
cnt=[0]*(k+1)
for m in mm:cnt[m]+=1
for i in range(k-1,0,-1):cnt[i]+=cnt[i+1]
#print(cc)
#print(cnt)
mx=0
for ct,c in zip(cnt[1:],cc[1:]):
mx=max(mx,(ct+c-1)//c)
print(mx)
ans=[[] for _ in range(mx)]
mm.sort()
for i,m in enumerate(mm):
ans[i%mx].append(m)
for row in ans:
print(len(row),*row)
main()
``` | output | 1 | 43,113 | 11 | 86,227 |
Provide tags and a correct Python 3 solution for this coding contest problem.
So you decided to hold a contest on Codeforces. You prepared the problems: statements, solutions, checkers, validators, tests... Suddenly, your coordinator asks you to change all your tests to multiple testcases in the easiest problem!
Initially, each test in that problem is just an array. The maximum size of an array is k. For simplicity, the contents of arrays don't matter. You have n tests β the i-th test is an array of size m_i (1 β€ m_i β€ k).
Your coordinator asks you to distribute all of your arrays into multiple testcases. Each testcase can include multiple arrays. However, each testcase should include no more than c_1 arrays of size greater than or equal to 1 (β₯ 1), no more than c_2 arrays of size greater than or equal to 2, ..., no more than c_k arrays of size greater than or equal to k. Also, c_1 β₯ c_2 β₯ ... β₯ c_k.
So now your goal is to create the new testcases in such a way that:
* each of the initial arrays appears in exactly one testcase;
* for each testcase the given conditions hold;
* the number of testcases is minimum possible.
Print the minimum possible number of testcases you can achieve and the sizes of arrays included in each testcase.
Input
The first line contains two integers n and k (1 β€ n, k β€ 2 β
10^5) β the number of initial tests and the limit for the size of each array.
The second line contains n integers m_1, m_2, ..., m_n (1 β€ m_i β€ k) β the sizes of the arrays in the original tests.
The third line contains k integers c_1, c_2, ..., c_k (n β₯ c_1 β₯ c_2 β₯ ... β₯ c_k β₯ 1); c_i is the maximum number of arrays of size greater than or equal to i you can have in a single testcase.
Output
In the first line print a single integer ans (1 β€ ans β€ n) β the minimum number of testcases you can achieve.
Each of the next ans lines should contain the description of a testcase in the following format:
t a_1 a_2 ... a_{t} (1 β€ tβ€ n) β the testcase includes t arrays, a_i is the size of the i-th array in that testcase.
Each of the initial arrays should appear in exactly one testcase. In particular, it implies that the sum of t over all ans testcases should be equal to n.
Note that the answer always exists due to c_k β₯ 1 (and therefore c_1 β₯ 1).
If there are multiple answers, you can output any one of them.
Examples
Input
4 3
1 2 2 3
4 1 1
Output
3
1 2
2 1 3
1 2
Input
6 10
5 8 1 10 8 7
6 6 4 4 3 2 2 2 1 1
Output
2
3 8 5 7
3 10 8 1
Input
5 1
1 1 1 1 1
5
Output
1
5 1 1 1 1 1
Input
5 1
1 1 1 1 1
1
Output
5
1 1
1 1
1 1
1 1
1 1
Note
In the first example there is no way to distribute the tests into less than 3 testcases. The given answer satisfies the conditions: each of the testcases includes no more than 4 arrays of size greater than or equal to 1 and no more than 1 array of sizes greater than or equal to 2 and 3.
Note that there are multiple valid answers for this test. For example, testcases with sizes [[2], [1, 2], [3]] would also be correct.
However, testcases with sizes [[1, 2], [2, 3]] would be incorrect because there are 2 arrays of size greater than or equal to 2 in the second testcase.
Note the difference between the third and the fourth examples. You can include up to 5 arrays of size greater than or equal to 1 in the third example, so you can put all arrays into a single testcase. And you can have only up to 1 array in the fourth example. Thus, every array should be included in a separate testcase. | instruction | 0 | 43,114 | 11 | 86,228 |
Tags: binary search, constructive algorithms, data structures, greedy, sortings, two pointers
Correct Solution:
```
import heapq
line = input()
n, k = (int(i) for i in line.split(' '))
line = input()
num = [int(i) for i in line.split(' ')]
line = input()
c = [int(i) for i in line.split(' ')]
memo = [(c[-1], 999999999)]
pre = c[-1]
for i in range(k - 2, -1, -1):
if c[i] == pre: continue
memo.append((c[i] - pre, i + 2))
pre = c[i]
num.sort(reverse=True)
heap, res = [], []
for i in num:
if not heap or memo[heap[0][0]][1] <= i:
heapq.heappush(heap, [0, 0, len(res)])
res.append([])
heap[0][1] += 1
res[heap[0][2]].append(i)
if heap[0][1] == memo[heap[0][0]][0]:
x = heapq.heappop(heap)
x[0] += 1
x[1] = 0
if x[0] != len(memo):
heapq.heappush(heap, x)
print(len(res))
for i in res:
print(len(i), end=' ')
for j in i:
print(j, end=' ')
print()
``` | output | 1 | 43,114 | 11 | 86,229 |
Provide tags and a correct Python 3 solution for this coding contest problem.
So you decided to hold a contest on Codeforces. You prepared the problems: statements, solutions, checkers, validators, tests... Suddenly, your coordinator asks you to change all your tests to multiple testcases in the easiest problem!
Initially, each test in that problem is just an array. The maximum size of an array is k. For simplicity, the contents of arrays don't matter. You have n tests β the i-th test is an array of size m_i (1 β€ m_i β€ k).
Your coordinator asks you to distribute all of your arrays into multiple testcases. Each testcase can include multiple arrays. However, each testcase should include no more than c_1 arrays of size greater than or equal to 1 (β₯ 1), no more than c_2 arrays of size greater than or equal to 2, ..., no more than c_k arrays of size greater than or equal to k. Also, c_1 β₯ c_2 β₯ ... β₯ c_k.
So now your goal is to create the new testcases in such a way that:
* each of the initial arrays appears in exactly one testcase;
* for each testcase the given conditions hold;
* the number of testcases is minimum possible.
Print the minimum possible number of testcases you can achieve and the sizes of arrays included in each testcase.
Input
The first line contains two integers n and k (1 β€ n, k β€ 2 β
10^5) β the number of initial tests and the limit for the size of each array.
The second line contains n integers m_1, m_2, ..., m_n (1 β€ m_i β€ k) β the sizes of the arrays in the original tests.
The third line contains k integers c_1, c_2, ..., c_k (n β₯ c_1 β₯ c_2 β₯ ... β₯ c_k β₯ 1); c_i is the maximum number of arrays of size greater than or equal to i you can have in a single testcase.
Output
In the first line print a single integer ans (1 β€ ans β€ n) β the minimum number of testcases you can achieve.
Each of the next ans lines should contain the description of a testcase in the following format:
t a_1 a_2 ... a_{t} (1 β€ tβ€ n) β the testcase includes t arrays, a_i is the size of the i-th array in that testcase.
Each of the initial arrays should appear in exactly one testcase. In particular, it implies that the sum of t over all ans testcases should be equal to n.
Note that the answer always exists due to c_k β₯ 1 (and therefore c_1 β₯ 1).
If there are multiple answers, you can output any one of them.
Examples
Input
4 3
1 2 2 3
4 1 1
Output
3
1 2
2 1 3
1 2
Input
6 10
5 8 1 10 8 7
6 6 4 4 3 2 2 2 1 1
Output
2
3 8 5 7
3 10 8 1
Input
5 1
1 1 1 1 1
5
Output
1
5 1 1 1 1 1
Input
5 1
1 1 1 1 1
1
Output
5
1 1
1 1
1 1
1 1
1 1
Note
In the first example there is no way to distribute the tests into less than 3 testcases. The given answer satisfies the conditions: each of the testcases includes no more than 4 arrays of size greater than or equal to 1 and no more than 1 array of sizes greater than or equal to 2 and 3.
Note that there are multiple valid answers for this test. For example, testcases with sizes [[2], [1, 2], [3]] would also be correct.
However, testcases with sizes [[1, 2], [2, 3]] would be incorrect because there are 2 arrays of size greater than or equal to 2 in the second testcase.
Note the difference between the third and the fourth examples. You can include up to 5 arrays of size greater than or equal to 1 in the third example, so you can put all arrays into a single testcase. And you can have only up to 1 array in the fourth example. Thus, every array should be included in a separate testcase. | instruction | 0 | 43,115 | 11 | 86,230 |
Tags: binary search, constructive algorithms, data structures, greedy, sortings, two pointers
Correct Solution:
```
from collections import defaultdict
n, k = [int(i) for i in input().split()]
m = sorted([int(i) for i in input().split()])
c = [int(i) for i in input().split()]
m_count= defaultdict(int)
for i in m:
m_count[i] += 1
for i in range(k,0,-1):
m_count[i-1] += m_count[i]
cell_needed = max([(m_count[i+1] + c[i] - 1 )//c[i] for i in range(k)])
ans = [[] for i in range(cell_needed)]
counter = 0
for i in m:
ans[counter].append(i)
counter += 1
counter %= cell_needed
print(cell_needed)
for i in range(cell_needed):
print(len(ans[i]), *ans[i])
``` | output | 1 | 43,115 | 11 | 86,231 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
So you decided to hold a contest on Codeforces. You prepared the problems: statements, solutions, checkers, validators, tests... Suddenly, your coordinator asks you to change all your tests to multiple testcases in the easiest problem!
Initially, each test in that problem is just an array. The maximum size of an array is k. For simplicity, the contents of arrays don't matter. You have n tests β the i-th test is an array of size m_i (1 β€ m_i β€ k).
Your coordinator asks you to distribute all of your arrays into multiple testcases. Each testcase can include multiple arrays. However, each testcase should include no more than c_1 arrays of size greater than or equal to 1 (β₯ 1), no more than c_2 arrays of size greater than or equal to 2, ..., no more than c_k arrays of size greater than or equal to k. Also, c_1 β₯ c_2 β₯ ... β₯ c_k.
So now your goal is to create the new testcases in such a way that:
* each of the initial arrays appears in exactly one testcase;
* for each testcase the given conditions hold;
* the number of testcases is minimum possible.
Print the minimum possible number of testcases you can achieve and the sizes of arrays included in each testcase.
Input
The first line contains two integers n and k (1 β€ n, k β€ 2 β
10^5) β the number of initial tests and the limit for the size of each array.
The second line contains n integers m_1, m_2, ..., m_n (1 β€ m_i β€ k) β the sizes of the arrays in the original tests.
The third line contains k integers c_1, c_2, ..., c_k (n β₯ c_1 β₯ c_2 β₯ ... β₯ c_k β₯ 1); c_i is the maximum number of arrays of size greater than or equal to i you can have in a single testcase.
Output
In the first line print a single integer ans (1 β€ ans β€ n) β the minimum number of testcases you can achieve.
Each of the next ans lines should contain the description of a testcase in the following format:
t a_1 a_2 ... a_{t} (1 β€ tβ€ n) β the testcase includes t arrays, a_i is the size of the i-th array in that testcase.
Each of the initial arrays should appear in exactly one testcase. In particular, it implies that the sum of t over all ans testcases should be equal to n.
Note that the answer always exists due to c_k β₯ 1 (and therefore c_1 β₯ 1).
If there are multiple answers, you can output any one of them.
Examples
Input
4 3
1 2 2 3
4 1 1
Output
3
1 2
2 1 3
1 2
Input
6 10
5 8 1 10 8 7
6 6 4 4 3 2 2 2 1 1
Output
2
3 8 5 7
3 10 8 1
Input
5 1
1 1 1 1 1
5
Output
1
5 1 1 1 1 1
Input
5 1
1 1 1 1 1
1
Output
5
1 1
1 1
1 1
1 1
1 1
Note
In the first example there is no way to distribute the tests into less than 3 testcases. The given answer satisfies the conditions: each of the testcases includes no more than 4 arrays of size greater than or equal to 1 and no more than 1 array of sizes greater than or equal to 2 and 3.
Note that there are multiple valid answers for this test. For example, testcases with sizes [[2], [1, 2], [3]] would also be correct.
However, testcases with sizes [[1, 2], [2, 3]] would be incorrect because there are 2 arrays of size greater than or equal to 2 in the second testcase.
Note the difference between the third and the fourth examples. You can include up to 5 arrays of size greater than or equal to 1 in the third example, so you can put all arrays into a single testcase. And you can have only up to 1 array in the fourth example. Thus, every array should be included in a separate testcase.
Submitted Solution:
```
import math
n, k = list(map(int, input().split()))
m = list(map(int, input().split()))
c = list(map(int, input().split()))
c = [0] + c
num_of_m = {}
m_cum = {}
for i in range(k):
num_of_m[i + 1] = 0
for i in range(len(m)):
num_of_m[m[i]] += 1
temp = 0
for i in range(k,0,-1):
temp += num_of_m[i]
m_cum[i] = temp
ans = 0
for i in range(1,k+1,1):
ans = max(ans, math.ceil(m_cum[i]/c[i]))
multiple_test_cases = []
for i in range(ans):
multiple_test_cases.append([])
m.sort(reverse=True)
for i in range(len(m)):
multiple_test_cases[i % ans].append(m[i])
print(len(multiple_test_cases))
for i in range(len(multiple_test_cases)):
print(len(multiple_test_cases[i]), end=" ")
for j in range(len(multiple_test_cases[i])):
print(multiple_test_cases[i][j], end = " ")
print()
``` | instruction | 0 | 43,116 | 11 | 86,232 |
Yes | output | 1 | 43,116 | 11 | 86,233 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
So you decided to hold a contest on Codeforces. You prepared the problems: statements, solutions, checkers, validators, tests... Suddenly, your coordinator asks you to change all your tests to multiple testcases in the easiest problem!
Initially, each test in that problem is just an array. The maximum size of an array is k. For simplicity, the contents of arrays don't matter. You have n tests β the i-th test is an array of size m_i (1 β€ m_i β€ k).
Your coordinator asks you to distribute all of your arrays into multiple testcases. Each testcase can include multiple arrays. However, each testcase should include no more than c_1 arrays of size greater than or equal to 1 (β₯ 1), no more than c_2 arrays of size greater than or equal to 2, ..., no more than c_k arrays of size greater than or equal to k. Also, c_1 β₯ c_2 β₯ ... β₯ c_k.
So now your goal is to create the new testcases in such a way that:
* each of the initial arrays appears in exactly one testcase;
* for each testcase the given conditions hold;
* the number of testcases is minimum possible.
Print the minimum possible number of testcases you can achieve and the sizes of arrays included in each testcase.
Input
The first line contains two integers n and k (1 β€ n, k β€ 2 β
10^5) β the number of initial tests and the limit for the size of each array.
The second line contains n integers m_1, m_2, ..., m_n (1 β€ m_i β€ k) β the sizes of the arrays in the original tests.
The third line contains k integers c_1, c_2, ..., c_k (n β₯ c_1 β₯ c_2 β₯ ... β₯ c_k β₯ 1); c_i is the maximum number of arrays of size greater than or equal to i you can have in a single testcase.
Output
In the first line print a single integer ans (1 β€ ans β€ n) β the minimum number of testcases you can achieve.
Each of the next ans lines should contain the description of a testcase in the following format:
t a_1 a_2 ... a_{t} (1 β€ tβ€ n) β the testcase includes t arrays, a_i is the size of the i-th array in that testcase.
Each of the initial arrays should appear in exactly one testcase. In particular, it implies that the sum of t over all ans testcases should be equal to n.
Note that the answer always exists due to c_k β₯ 1 (and therefore c_1 β₯ 1).
If there are multiple answers, you can output any one of them.
Examples
Input
4 3
1 2 2 3
4 1 1
Output
3
1 2
2 1 3
1 2
Input
6 10
5 8 1 10 8 7
6 6 4 4 3 2 2 2 1 1
Output
2
3 8 5 7
3 10 8 1
Input
5 1
1 1 1 1 1
5
Output
1
5 1 1 1 1 1
Input
5 1
1 1 1 1 1
1
Output
5
1 1
1 1
1 1
1 1
1 1
Note
In the first example there is no way to distribute the tests into less than 3 testcases. The given answer satisfies the conditions: each of the testcases includes no more than 4 arrays of size greater than or equal to 1 and no more than 1 array of sizes greater than or equal to 2 and 3.
Note that there are multiple valid answers for this test. For example, testcases with sizes [[2], [1, 2], [3]] would also be correct.
However, testcases with sizes [[1, 2], [2, 3]] would be incorrect because there are 2 arrays of size greater than or equal to 2 in the second testcase.
Note the difference between the third and the fourth examples. You can include up to 5 arrays of size greater than or equal to 1 in the third example, so you can put all arrays into a single testcase. And you can have only up to 1 array in the fourth example. Thus, every array should be included in a separate testcase.
Submitted Solution:
```
'''
Auther: ghoshashis545 Ashis Ghosh
College: jalpaiguri Govt Enggineerin College
Date:26/04/2020
'''
from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
from itertools import permutations
from datetime import datetime
from math import ceil,sqrt,log,gcd
def ii():return int(input())
def si():return input()
def mi():return map(int,input().split())
def li():return list(mi())
abc='abcdefghijklmnopqrstuvwxyz'
abd={'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod=1000000007
#mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def powmod(a,b):
a%=mod
if(a==0):
return 0
res=1
while(b>0):
if(b&1):
res=(res*a)%mod
a=(a*a)%mod
b>>=1
return res
def main():
n,k=mi()
a=li()
c=li()
a.sort()
i=0
pos=[0]*(k+1)
m=[0]*(k+1)
for i in a:
m[i]+=1
pos[k]=m[k]
for i in range(k-1,0,-1):
pos[i]=pos[i+1]+m[i]
ans=0
for i in range(1,k+1):
ans=max(ans,ceil(pos[i]/c[i-1]))
print(ans)
a.sort()
res=[[] for i in range(ans)]
for i in range(n):
res[i%ans].append(a[i])
for i in res:
print(len(i),end=" ")
print(*i)
if __name__ == "__main__":
main()
``` | instruction | 0 | 43,117 | 11 | 86,234 |
Yes | output | 1 | 43,117 | 11 | 86,235 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
So you decided to hold a contest on Codeforces. You prepared the problems: statements, solutions, checkers, validators, tests... Suddenly, your coordinator asks you to change all your tests to multiple testcases in the easiest problem!
Initially, each test in that problem is just an array. The maximum size of an array is k. For simplicity, the contents of arrays don't matter. You have n tests β the i-th test is an array of size m_i (1 β€ m_i β€ k).
Your coordinator asks you to distribute all of your arrays into multiple testcases. Each testcase can include multiple arrays. However, each testcase should include no more than c_1 arrays of size greater than or equal to 1 (β₯ 1), no more than c_2 arrays of size greater than or equal to 2, ..., no more than c_k arrays of size greater than or equal to k. Also, c_1 β₯ c_2 β₯ ... β₯ c_k.
So now your goal is to create the new testcases in such a way that:
* each of the initial arrays appears in exactly one testcase;
* for each testcase the given conditions hold;
* the number of testcases is minimum possible.
Print the minimum possible number of testcases you can achieve and the sizes of arrays included in each testcase.
Input
The first line contains two integers n and k (1 β€ n, k β€ 2 β
10^5) β the number of initial tests and the limit for the size of each array.
The second line contains n integers m_1, m_2, ..., m_n (1 β€ m_i β€ k) β the sizes of the arrays in the original tests.
The third line contains k integers c_1, c_2, ..., c_k (n β₯ c_1 β₯ c_2 β₯ ... β₯ c_k β₯ 1); c_i is the maximum number of arrays of size greater than or equal to i you can have in a single testcase.
Output
In the first line print a single integer ans (1 β€ ans β€ n) β the minimum number of testcases you can achieve.
Each of the next ans lines should contain the description of a testcase in the following format:
t a_1 a_2 ... a_{t} (1 β€ tβ€ n) β the testcase includes t arrays, a_i is the size of the i-th array in that testcase.
Each of the initial arrays should appear in exactly one testcase. In particular, it implies that the sum of t over all ans testcases should be equal to n.
Note that the answer always exists due to c_k β₯ 1 (and therefore c_1 β₯ 1).
If there are multiple answers, you can output any one of them.
Examples
Input
4 3
1 2 2 3
4 1 1
Output
3
1 2
2 1 3
1 2
Input
6 10
5 8 1 10 8 7
6 6 4 4 3 2 2 2 1 1
Output
2
3 8 5 7
3 10 8 1
Input
5 1
1 1 1 1 1
5
Output
1
5 1 1 1 1 1
Input
5 1
1 1 1 1 1
1
Output
5
1 1
1 1
1 1
1 1
1 1
Note
In the first example there is no way to distribute the tests into less than 3 testcases. The given answer satisfies the conditions: each of the testcases includes no more than 4 arrays of size greater than or equal to 1 and no more than 1 array of sizes greater than or equal to 2 and 3.
Note that there are multiple valid answers for this test. For example, testcases with sizes [[2], [1, 2], [3]] would also be correct.
However, testcases with sizes [[1, 2], [2, 3]] would be incorrect because there are 2 arrays of size greater than or equal to 2 in the second testcase.
Note the difference between the third and the fourth examples. You can include up to 5 arrays of size greater than or equal to 1 in the third example, so you can put all arrays into a single testcase. And you can have only up to 1 array in the fourth example. Thus, every array should be included in a separate testcase.
Submitted Solution:
```
import io
import os
from collections import Counter, defaultdict, deque
def solve(N, K, M, C):
testcases = []
lens = []
M.sort(reverse=True)
for x in M:
# Everything assigned so far counts towards constraint
allowed = C[x - 1]
if False:
for i, tc in enumerate(testcases):
if len(tc) < allowed:
tc.append(x)
lens[i] += 1
break
else:
testcases.append([x])
lens.append(1)
assert all(x == len(y) for x, y in zip(lens, testcases))
else:
# lens is decreasing
# Add to first index where lens[i] < allowed
lo = 0
hi = len(lens) - 1
if not lens or lens[hi] >= allowed:
# nothing will work
testcases.append([x])
lens.append(1)
else:
if lens[lo] >= allowed:
assert lens[hi] < allowed
while hi - lo > 1:
mid = (lo + hi) // 2
if lens[mid] < allowed:
hi = mid
else:
lo = mid
assert lens[lo] >= allowed
assert lens[hi] < allowed
else:
hi = lo
testcases[hi].append(x)
lens[hi] += 1
return (
str(len(testcases))
+ "\n"
+ "\n".join(str(len(ans)) + " " + " ".join(map(str, ans)) for ans in testcases)
)
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
N, K = [int(x) for x in input().split()]
M = [int(x) for x in input().split()]
C = [int(x) for x in input().split()]
ans = solve(N, K, M, C)
print(ans)
``` | instruction | 0 | 43,118 | 11 | 86,236 |
Yes | output | 1 | 43,118 | 11 | 86,237 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
So you decided to hold a contest on Codeforces. You prepared the problems: statements, solutions, checkers, validators, tests... Suddenly, your coordinator asks you to change all your tests to multiple testcases in the easiest problem!
Initially, each test in that problem is just an array. The maximum size of an array is k. For simplicity, the contents of arrays don't matter. You have n tests β the i-th test is an array of size m_i (1 β€ m_i β€ k).
Your coordinator asks you to distribute all of your arrays into multiple testcases. Each testcase can include multiple arrays. However, each testcase should include no more than c_1 arrays of size greater than or equal to 1 (β₯ 1), no more than c_2 arrays of size greater than or equal to 2, ..., no more than c_k arrays of size greater than or equal to k. Also, c_1 β₯ c_2 β₯ ... β₯ c_k.
So now your goal is to create the new testcases in such a way that:
* each of the initial arrays appears in exactly one testcase;
* for each testcase the given conditions hold;
* the number of testcases is minimum possible.
Print the minimum possible number of testcases you can achieve and the sizes of arrays included in each testcase.
Input
The first line contains two integers n and k (1 β€ n, k β€ 2 β
10^5) β the number of initial tests and the limit for the size of each array.
The second line contains n integers m_1, m_2, ..., m_n (1 β€ m_i β€ k) β the sizes of the arrays in the original tests.
The third line contains k integers c_1, c_2, ..., c_k (n β₯ c_1 β₯ c_2 β₯ ... β₯ c_k β₯ 1); c_i is the maximum number of arrays of size greater than or equal to i you can have in a single testcase.
Output
In the first line print a single integer ans (1 β€ ans β€ n) β the minimum number of testcases you can achieve.
Each of the next ans lines should contain the description of a testcase in the following format:
t a_1 a_2 ... a_{t} (1 β€ tβ€ n) β the testcase includes t arrays, a_i is the size of the i-th array in that testcase.
Each of the initial arrays should appear in exactly one testcase. In particular, it implies that the sum of t over all ans testcases should be equal to n.
Note that the answer always exists due to c_k β₯ 1 (and therefore c_1 β₯ 1).
If there are multiple answers, you can output any one of them.
Examples
Input
4 3
1 2 2 3
4 1 1
Output
3
1 2
2 1 3
1 2
Input
6 10
5 8 1 10 8 7
6 6 4 4 3 2 2 2 1 1
Output
2
3 8 5 7
3 10 8 1
Input
5 1
1 1 1 1 1
5
Output
1
5 1 1 1 1 1
Input
5 1
1 1 1 1 1
1
Output
5
1 1
1 1
1 1
1 1
1 1
Note
In the first example there is no way to distribute the tests into less than 3 testcases. The given answer satisfies the conditions: each of the testcases includes no more than 4 arrays of size greater than or equal to 1 and no more than 1 array of sizes greater than or equal to 2 and 3.
Note that there are multiple valid answers for this test. For example, testcases with sizes [[2], [1, 2], [3]] would also be correct.
However, testcases with sizes [[1, 2], [2, 3]] would be incorrect because there are 2 arrays of size greater than or equal to 2 in the second testcase.
Note the difference between the third and the fourth examples. You can include up to 5 arrays of size greater than or equal to 1 in the third example, so you can put all arrays into a single testcase. And you can have only up to 1 array in the fourth example. Thus, every array should be included in a separate testcase.
Submitted Solution:
```
# region fastio # from https://codeforces.com/contest/1333/submission/75948789
import sys, io, os
BUFSIZE = 8192
class FastIO(io.IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = io.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(io.IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
def main():
from bisect import bisect_left as bl, bisect_right as br, insort
import sys,io,os
import heapq
from collections import defaultdict as dd, deque
data = input
def mdata() : return list(map(int,data().split()))
out = sys.stdout.write
# sys.setrecursionlimit(100000)
INF=int(1e9)
n,k = mdata()
M = mdata()
C = mdata()
M.sort()
d1=[0]*n
d2=[0]*n
ans=[]
n1=n-1
m=INF
while n1>=0:
s=bl(d1,C[M[n1]-1])-1
d2[n1]=s
d1[s]+=1
m=min(m,s)
n1-=1
ans=[[] for i in range(n-m)]
for i in range(n):
ans[n-1-d2[i]].append(str(M[i]))
for i in range(len(ans)):
ans[i]=str(len(ans[i]))+' '+' '.join(ans[i])
print(str(len(ans)))
print('\n'.join(ans))
if __name__ == '__main__':
main()
``` | instruction | 0 | 43,119 | 11 | 86,238 |
Yes | output | 1 | 43,119 | 11 | 86,239 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
So you decided to hold a contest on Codeforces. You prepared the problems: statements, solutions, checkers, validators, tests... Suddenly, your coordinator asks you to change all your tests to multiple testcases in the easiest problem!
Initially, each test in that problem is just an array. The maximum size of an array is k. For simplicity, the contents of arrays don't matter. You have n tests β the i-th test is an array of size m_i (1 β€ m_i β€ k).
Your coordinator asks you to distribute all of your arrays into multiple testcases. Each testcase can include multiple arrays. However, each testcase should include no more than c_1 arrays of size greater than or equal to 1 (β₯ 1), no more than c_2 arrays of size greater than or equal to 2, ..., no more than c_k arrays of size greater than or equal to k. Also, c_1 β₯ c_2 β₯ ... β₯ c_k.
So now your goal is to create the new testcases in such a way that:
* each of the initial arrays appears in exactly one testcase;
* for each testcase the given conditions hold;
* the number of testcases is minimum possible.
Print the minimum possible number of testcases you can achieve and the sizes of arrays included in each testcase.
Input
The first line contains two integers n and k (1 β€ n, k β€ 2 β
10^5) β the number of initial tests and the limit for the size of each array.
The second line contains n integers m_1, m_2, ..., m_n (1 β€ m_i β€ k) β the sizes of the arrays in the original tests.
The third line contains k integers c_1, c_2, ..., c_k (n β₯ c_1 β₯ c_2 β₯ ... β₯ c_k β₯ 1); c_i is the maximum number of arrays of size greater than or equal to i you can have in a single testcase.
Output
In the first line print a single integer ans (1 β€ ans β€ n) β the minimum number of testcases you can achieve.
Each of the next ans lines should contain the description of a testcase in the following format:
t a_1 a_2 ... a_{t} (1 β€ tβ€ n) β the testcase includes t arrays, a_i is the size of the i-th array in that testcase.
Each of the initial arrays should appear in exactly one testcase. In particular, it implies that the sum of t over all ans testcases should be equal to n.
Note that the answer always exists due to c_k β₯ 1 (and therefore c_1 β₯ 1).
If there are multiple answers, you can output any one of them.
Examples
Input
4 3
1 2 2 3
4 1 1
Output
3
1 2
2 1 3
1 2
Input
6 10
5 8 1 10 8 7
6 6 4 4 3 2 2 2 1 1
Output
2
3 8 5 7
3 10 8 1
Input
5 1
1 1 1 1 1
5
Output
1
5 1 1 1 1 1
Input
5 1
1 1 1 1 1
1
Output
5
1 1
1 1
1 1
1 1
1 1
Note
In the first example there is no way to distribute the tests into less than 3 testcases. The given answer satisfies the conditions: each of the testcases includes no more than 4 arrays of size greater than or equal to 1 and no more than 1 array of sizes greater than or equal to 2 and 3.
Note that there are multiple valid answers for this test. For example, testcases with sizes [[2], [1, 2], [3]] would also be correct.
However, testcases with sizes [[1, 2], [2, 3]] would be incorrect because there are 2 arrays of size greater than or equal to 2 in the second testcase.
Note the difference between the third and the fourth examples. You can include up to 5 arrays of size greater than or equal to 1 in the third example, so you can put all arrays into a single testcase. And you can have only up to 1 array in the fourth example. Thus, every array should be included in a separate testcase.
Submitted Solution:
```
from sys import stdin, stdout
[n, k] = [int(x) for x in stdin.readline().split()]
m = [int(x) for x in stdin.readline().split()]
k = [int(x) for x in stdin.readline().split()]
m.sort()
summ = 0
minRes = 0
res = []
for i in range(n):
res.append([])
for x in m[::-1]:
summ += 1
count = summ // k[x - 1] + (1 if summ % k[x - 1] else 0)
maxminRes = max(minRes, count)
if (maxminRes > minRes):
minRes = maxminRes
res[minRes - 1].append(str(x))
else:
res[0].append(str(x))
stdout.write(str(minRes) + "\n")
for i in range(minRes):
stdout.write(str(len(res[i])) + ' ' + ' '.join(res[i]) + "\n")
``` | instruction | 0 | 43,120 | 11 | 86,240 |
No | output | 1 | 43,120 | 11 | 86,241 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
So you decided to hold a contest on Codeforces. You prepared the problems: statements, solutions, checkers, validators, tests... Suddenly, your coordinator asks you to change all your tests to multiple testcases in the easiest problem!
Initially, each test in that problem is just an array. The maximum size of an array is k. For simplicity, the contents of arrays don't matter. You have n tests β the i-th test is an array of size m_i (1 β€ m_i β€ k).
Your coordinator asks you to distribute all of your arrays into multiple testcases. Each testcase can include multiple arrays. However, each testcase should include no more than c_1 arrays of size greater than or equal to 1 (β₯ 1), no more than c_2 arrays of size greater than or equal to 2, ..., no more than c_k arrays of size greater than or equal to k. Also, c_1 β₯ c_2 β₯ ... β₯ c_k.
So now your goal is to create the new testcases in such a way that:
* each of the initial arrays appears in exactly one testcase;
* for each testcase the given conditions hold;
* the number of testcases is minimum possible.
Print the minimum possible number of testcases you can achieve and the sizes of arrays included in each testcase.
Input
The first line contains two integers n and k (1 β€ n, k β€ 2 β
10^5) β the number of initial tests and the limit for the size of each array.
The second line contains n integers m_1, m_2, ..., m_n (1 β€ m_i β€ k) β the sizes of the arrays in the original tests.
The third line contains k integers c_1, c_2, ..., c_k (n β₯ c_1 β₯ c_2 β₯ ... β₯ c_k β₯ 1); c_i is the maximum number of arrays of size greater than or equal to i you can have in a single testcase.
Output
In the first line print a single integer ans (1 β€ ans β€ n) β the minimum number of testcases you can achieve.
Each of the next ans lines should contain the description of a testcase in the following format:
t a_1 a_2 ... a_{t} (1 β€ tβ€ n) β the testcase includes t arrays, a_i is the size of the i-th array in that testcase.
Each of the initial arrays should appear in exactly one testcase. In particular, it implies that the sum of t over all ans testcases should be equal to n.
Note that the answer always exists due to c_k β₯ 1 (and therefore c_1 β₯ 1).
If there are multiple answers, you can output any one of them.
Examples
Input
4 3
1 2 2 3
4 1 1
Output
3
1 2
2 1 3
1 2
Input
6 10
5 8 1 10 8 7
6 6 4 4 3 2 2 2 1 1
Output
2
3 8 5 7
3 10 8 1
Input
5 1
1 1 1 1 1
5
Output
1
5 1 1 1 1 1
Input
5 1
1 1 1 1 1
1
Output
5
1 1
1 1
1 1
1 1
1 1
Note
In the first example there is no way to distribute the tests into less than 3 testcases. The given answer satisfies the conditions: each of the testcases includes no more than 4 arrays of size greater than or equal to 1 and no more than 1 array of sizes greater than or equal to 2 and 3.
Note that there are multiple valid answers for this test. For example, testcases with sizes [[2], [1, 2], [3]] would also be correct.
However, testcases with sizes [[1, 2], [2, 3]] would be incorrect because there are 2 arrays of size greater than or equal to 2 in the second testcase.
Note the difference between the third and the fourth examples. You can include up to 5 arrays of size greater than or equal to 1 in the third example, so you can put all arrays into a single testcase. And you can have only up to 1 array in the fourth example. Thus, every array should be included in a separate testcase.
Submitted Solution:
```
import sys
from collections import defaultdict
def possible(num,c,suf):
n=len(c)
for i in range(n):
c[i]*=num
#print(c,'c',num,'num')
for i in range(n):
if c[i]<suf[i]:
#print(num,'num')
for i in range(n):
c[i]//=num
return False
for i in range(n):
c[i]//=num
return True
n,k=map(int,sys.stdin.readline().split())
m=list(map(int,sys.stdin.readline().split()))
c=list(map(int,sys.stdin.readline().split()))
l=[0 for _ in range(k+1)]
m.sort()
for i in range(n-1,-1,-1):
l[m[i]]+=1
s=0
suf=[0 for _ in range(k)]
for i in range(k,0,-1):
s+=l[i]
suf[i-1]=s
#print(m,'m')
#print(suf,'suf')
low=1
high=10
ans=10
while low<=high:
mid=(low+high)//2
if possible(mid,c,suf):
ans=min(ans,mid)
high=mid-1
else:
low=mid+1
#print(ans)
res=[[] for i in range(ans)]
ind=n-1
count=[0 for i in range(ans)]
cur=0
while ind>=0:
res[cur].append(m[ind])
count[cur]+=1
cur+=1
cur%=ans
ind-=1
print(ans)
for i in range(ans):
print(count[i],end=' ')
print(' '.join(str(x) for x in res[i]))
``` | instruction | 0 | 43,121 | 11 | 86,242 |
No | output | 1 | 43,121 | 11 | 86,243 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
So you decided to hold a contest on Codeforces. You prepared the problems: statements, solutions, checkers, validators, tests... Suddenly, your coordinator asks you to change all your tests to multiple testcases in the easiest problem!
Initially, each test in that problem is just an array. The maximum size of an array is k. For simplicity, the contents of arrays don't matter. You have n tests β the i-th test is an array of size m_i (1 β€ m_i β€ k).
Your coordinator asks you to distribute all of your arrays into multiple testcases. Each testcase can include multiple arrays. However, each testcase should include no more than c_1 arrays of size greater than or equal to 1 (β₯ 1), no more than c_2 arrays of size greater than or equal to 2, ..., no more than c_k arrays of size greater than or equal to k. Also, c_1 β₯ c_2 β₯ ... β₯ c_k.
So now your goal is to create the new testcases in such a way that:
* each of the initial arrays appears in exactly one testcase;
* for each testcase the given conditions hold;
* the number of testcases is minimum possible.
Print the minimum possible number of testcases you can achieve and the sizes of arrays included in each testcase.
Input
The first line contains two integers n and k (1 β€ n, k β€ 2 β
10^5) β the number of initial tests and the limit for the size of each array.
The second line contains n integers m_1, m_2, ..., m_n (1 β€ m_i β€ k) β the sizes of the arrays in the original tests.
The third line contains k integers c_1, c_2, ..., c_k (n β₯ c_1 β₯ c_2 β₯ ... β₯ c_k β₯ 1); c_i is the maximum number of arrays of size greater than or equal to i you can have in a single testcase.
Output
In the first line print a single integer ans (1 β€ ans β€ n) β the minimum number of testcases you can achieve.
Each of the next ans lines should contain the description of a testcase in the following format:
t a_1 a_2 ... a_{t} (1 β€ tβ€ n) β the testcase includes t arrays, a_i is the size of the i-th array in that testcase.
Each of the initial arrays should appear in exactly one testcase. In particular, it implies that the sum of t over all ans testcases should be equal to n.
Note that the answer always exists due to c_k β₯ 1 (and therefore c_1 β₯ 1).
If there are multiple answers, you can output any one of them.
Examples
Input
4 3
1 2 2 3
4 1 1
Output
3
1 2
2 1 3
1 2
Input
6 10
5 8 1 10 8 7
6 6 4 4 3 2 2 2 1 1
Output
2
3 8 5 7
3 10 8 1
Input
5 1
1 1 1 1 1
5
Output
1
5 1 1 1 1 1
Input
5 1
1 1 1 1 1
1
Output
5
1 1
1 1
1 1
1 1
1 1
Note
In the first example there is no way to distribute the tests into less than 3 testcases. The given answer satisfies the conditions: each of the testcases includes no more than 4 arrays of size greater than or equal to 1 and no more than 1 array of sizes greater than or equal to 2 and 3.
Note that there are multiple valid answers for this test. For example, testcases with sizes [[2], [1, 2], [3]] would also be correct.
However, testcases with sizes [[1, 2], [2, 3]] would be incorrect because there are 2 arrays of size greater than or equal to 2 in the second testcase.
Note the difference between the third and the fourth examples. You can include up to 5 arrays of size greater than or equal to 1 in the third example, so you can put all arrays into a single testcase. And you can have only up to 1 array in the fourth example. Thus, every array should be included in a separate testcase.
Submitted Solution:
```
n,k = map(int,input().split())
m = list(map(int,input().split()))
c = list(map(int,input().split()))
a = []
m.sort()
s = 0
x = k
cc = 0
while len(m) > 0:
b = [m[-1]]
s = 1
x = m[-1]
m.pop()
i = len(m) - 1
while len(m) > 0 and c[m[i] - 1] - s > 0:
x = m[i]
m.pop(i)
s += 1
b.append(x)
if i == len(m):
i -= 1
if i == -1:
break
while c[m[i] - 1] - s == 0 and i > -1:
i -= 1
a.append(b)
print(len(a))
for i in range(len(a)):
print(len(a[i]), *a[i])
``` | instruction | 0 | 43,122 | 11 | 86,244 |
No | output | 1 | 43,122 | 11 | 86,245 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
So you decided to hold a contest on Codeforces. You prepared the problems: statements, solutions, checkers, validators, tests... Suddenly, your coordinator asks you to change all your tests to multiple testcases in the easiest problem!
Initially, each test in that problem is just an array. The maximum size of an array is k. For simplicity, the contents of arrays don't matter. You have n tests β the i-th test is an array of size m_i (1 β€ m_i β€ k).
Your coordinator asks you to distribute all of your arrays into multiple testcases. Each testcase can include multiple arrays. However, each testcase should include no more than c_1 arrays of size greater than or equal to 1 (β₯ 1), no more than c_2 arrays of size greater than or equal to 2, ..., no more than c_k arrays of size greater than or equal to k. Also, c_1 β₯ c_2 β₯ ... β₯ c_k.
So now your goal is to create the new testcases in such a way that:
* each of the initial arrays appears in exactly one testcase;
* for each testcase the given conditions hold;
* the number of testcases is minimum possible.
Print the minimum possible number of testcases you can achieve and the sizes of arrays included in each testcase.
Input
The first line contains two integers n and k (1 β€ n, k β€ 2 β
10^5) β the number of initial tests and the limit for the size of each array.
The second line contains n integers m_1, m_2, ..., m_n (1 β€ m_i β€ k) β the sizes of the arrays in the original tests.
The third line contains k integers c_1, c_2, ..., c_k (n β₯ c_1 β₯ c_2 β₯ ... β₯ c_k β₯ 1); c_i is the maximum number of arrays of size greater than or equal to i you can have in a single testcase.
Output
In the first line print a single integer ans (1 β€ ans β€ n) β the minimum number of testcases you can achieve.
Each of the next ans lines should contain the description of a testcase in the following format:
t a_1 a_2 ... a_{t} (1 β€ tβ€ n) β the testcase includes t arrays, a_i is the size of the i-th array in that testcase.
Each of the initial arrays should appear in exactly one testcase. In particular, it implies that the sum of t over all ans testcases should be equal to n.
Note that the answer always exists due to c_k β₯ 1 (and therefore c_1 β₯ 1).
If there are multiple answers, you can output any one of them.
Examples
Input
4 3
1 2 2 3
4 1 1
Output
3
1 2
2 1 3
1 2
Input
6 10
5 8 1 10 8 7
6 6 4 4 3 2 2 2 1 1
Output
2
3 8 5 7
3 10 8 1
Input
5 1
1 1 1 1 1
5
Output
1
5 1 1 1 1 1
Input
5 1
1 1 1 1 1
1
Output
5
1 1
1 1
1 1
1 1
1 1
Note
In the first example there is no way to distribute the tests into less than 3 testcases. The given answer satisfies the conditions: each of the testcases includes no more than 4 arrays of size greater than or equal to 1 and no more than 1 array of sizes greater than or equal to 2 and 3.
Note that there are multiple valid answers for this test. For example, testcases with sizes [[2], [1, 2], [3]] would also be correct.
However, testcases with sizes [[1, 2], [2, 3]] would be incorrect because there are 2 arrays of size greater than or equal to 2 in the second testcase.
Note the difference between the third and the fourth examples. You can include up to 5 arrays of size greater than or equal to 1 in the third example, so you can put all arrays into a single testcase. And you can have only up to 1 array in the fourth example. Thus, every array should be included in a separate testcase.
Submitted Solution:
```
n,k=map(int,input().split())
m=list(map(int,input().split()))
c=list(map(int,input().split()))
freq={}
for i in m:
if freq.get(i,0)==0:
freq[i]=1
else:
freq[i]+=1
length={}
for i in range(1,n+1):
length[i]=-1
length1={}
for i in range(1,n+1):
length1[i]=-1
m1=sorted(list(set(m)))
ans=[[]for i in range(n+1)]
for i in m1:
for j in range(1,n+1):
if length[j]==-1 and freq[i]>0:
ans[j].append(i)
length[j]=c[i-1]-1
length1[j]=c[i-1]-1
freq[i]-=1
elif length[j]>0 and freq[i]>0 and length1[j]>0:
ans[j].append(i)
freq[i]-=1
length1[j]=min(c[i-1]-1,length1[j]-1)
if freq[i]==0:
break
cnt=0
for i in range(1,n+1):
if len(ans[i])>0:
cnt+=1
else:
break
print(cnt)
for i in range(1,n+1):
if len(ans[i])>0:
print(len(ans[i]),*ans[i])
else:
break
``` | instruction | 0 | 43,123 | 11 | 86,246 |
No | output | 1 | 43,123 | 11 | 86,247 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of integers a_1,a_2,β¦,a_n. Find the maximum possible value of a_ia_ja_ka_la_t among all five indices (i, j, k, l, t) (i<j<k<l<t).
Input
The input consists of multiple test cases. The first line contains an integer t (1β€ tβ€ 2 β
10^4) β the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (5β€ nβ€ 10^5) β the size of the array.
The second line of each test case contains n integers a_1,a_2,β¦,a_n (-3Γ 10^3β€ a_iβ€ 3Γ 10^3) β given array.
It's guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print one integer β the answer to the problem.
Example
Input
4
5
-1 -2 -3 -4 -5
6
-1 -2 -3 1 2 -1
6
-1 0 0 0 -1 -1
6
-9 -7 -5 -3 -2 1
Output
-120
12
0
945
Note
In the first test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)β
(-2) β
(-3)β
(-4)β
(-5)=-120.
In the second test case, choosing a_1,a_2,a_3,a_5,a_6 is a best choice: (-1)β
(-2) β
(-3)β
2β
(-1)=12.
In the third test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)β
0β
0β
0β
(-1)=0.
In the fourth test case, choosing a_1,a_2,a_3,a_4,a_6 is a best choice: (-9)β
(-7) β
(-5)β
(-3)β
1=945.
Submitted Solution:
```
from sys import stdin, stdout
from math import inf
def calc(lst, beg=0, used=0, to_use=5, v=1):
if used == to_use: return v
if beg == len(lst): return -inf
vs = []
for i in range(beg, len(lst)):
vs.append(calc(lst, i+1, used+1, to_use, v*lst[i]))
return max(vs)
for _ in range(0, int(stdin.readline())):
n = int(stdin.readline())
a = []
b = []
for e in map(int, stdin.readline().split()):
if e >= 0:
a.append(e)
else:
b.append(e)
a.sort(reverse=True)
b.sort()
pd = 1
if len(a) > 0:
pd = calc(a[:5]+b[:5])
else:
for e in b[len(b)-5:]:
pd *= e
stdout.write(f"{pd}\n")
``` | instruction | 0 | 43,148 | 11 | 86,296 |
Yes | output | 1 | 43,148 | 11 | 86,297 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of integers a_1,a_2,β¦,a_n. Find the maximum possible value of a_ia_ja_ka_la_t among all five indices (i, j, k, l, t) (i<j<k<l<t).
Input
The input consists of multiple test cases. The first line contains an integer t (1β€ tβ€ 2 β
10^4) β the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (5β€ nβ€ 10^5) β the size of the array.
The second line of each test case contains n integers a_1,a_2,β¦,a_n (-3Γ 10^3β€ a_iβ€ 3Γ 10^3) β given array.
It's guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print one integer β the answer to the problem.
Example
Input
4
5
-1 -2 -3 -4 -5
6
-1 -2 -3 1 2 -1
6
-1 0 0 0 -1 -1
6
-9 -7 -5 -3 -2 1
Output
-120
12
0
945
Note
In the first test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)β
(-2) β
(-3)β
(-4)β
(-5)=-120.
In the second test case, choosing a_1,a_2,a_3,a_5,a_6 is a best choice: (-1)β
(-2) β
(-3)β
2β
(-1)=12.
In the third test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)β
0β
0β
0β
(-1)=0.
In the fourth test case, choosing a_1,a_2,a_3,a_4,a_6 is a best choice: (-9)β
(-7) β
(-5)β
(-3)β
1=945.
Submitted Solution:
```
t = int(input())
for tt in range(t):
n = int(input())
numbers = [int(x) for x in input().split()]
N = []
P = []
Z = False
# Build N, P and Z
for x in numbers:
if x > 0:
P.append(x)
elif x < 0:
N.append(x)
else:
# x must be 0.
Z = True
# Sort the arrays, this takes O(n log n) time.
P.sort()
N.sort()
# -10**18 is chosen because it's smaller than the smallest possible
# answer of the problem (since the numbers are between -3000 and +3000)
ans = -10**18
# Try all the cases
if Z:
ans = max(ans, 0)
if len(P) >= 5:
ans = max(ans, P[-5]*P[-4]*P[-3]*P[-2]*P[-1])
if len(P) >= 4 and len(N) >= 1:
ans = max(ans, N[-1]*P[0]*P[1]*P[2]*P[3])
if len(P) >= 3 and len(N) >= 2:
ans = max(ans, P[-3]*P[-2]*P[-1]*N[0]*N[1])
if len(P) >= 2 and len(N) >= 3:
ans = max(ans, N[-3]*N[-2]*N[-1]*P[0]*P[1])
if len(P) >= 1 and len(N) >= 4:
ans = max(ans, P[-1]*N[0]*N[1]*N[2]*N[3])
if len(N) >= 5:
ans = max(ans, N[-5]*N[-4]*N[-3]*N[-2]*N[-1])
print(ans)
``` | instruction | 0 | 43,149 | 11 | 86,298 |
Yes | output | 1 | 43,149 | 11 | 86,299 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of integers a_1,a_2,β¦,a_n. Find the maximum possible value of a_ia_ja_ka_la_t among all five indices (i, j, k, l, t) (i<j<k<l<t).
Input
The input consists of multiple test cases. The first line contains an integer t (1β€ tβ€ 2 β
10^4) β the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (5β€ nβ€ 10^5) β the size of the array.
The second line of each test case contains n integers a_1,a_2,β¦,a_n (-3Γ 10^3β€ a_iβ€ 3Γ 10^3) β given array.
It's guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print one integer β the answer to the problem.
Example
Input
4
5
-1 -2 -3 -4 -5
6
-1 -2 -3 1 2 -1
6
-1 0 0 0 -1 -1
6
-9 -7 -5 -3 -2 1
Output
-120
12
0
945
Note
In the first test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)β
(-2) β
(-3)β
(-4)β
(-5)=-120.
In the second test case, choosing a_1,a_2,a_3,a_5,a_6 is a best choice: (-1)β
(-2) β
(-3)β
2β
(-1)=12.
In the third test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)β
0β
0β
0β
(-1)=0.
In the fourth test case, choosing a_1,a_2,a_3,a_4,a_6 is a best choice: (-9)β
(-7) β
(-5)β
(-3)β
1=945.
Submitted Solution:
```
from collections import Counter
t = int(input())
for i in range(t):
n = input()
nums = list(map(int, input().split()))
a = [i for i in nums if i > 0]
b = [-i for i in nums if i < 0]
a.sort(reverse=True)
b.sort(reverse=True)
zero = 0 in nums
if len(a)+len(b) < 5:
print(0)
continue
ans = -1e20
for left in range(6):
try:
right = 5-left
cur = 1
for j in range(left):
cur *= a[j]
for j in range(right):
cur *= -b[j]
# print(cur)
if ans < cur:
ans = cur
except:
pass
for left in range(6):
try:
right = 5-left
cur = 1
for j in range(left):
cur *= a[-j-1]
for j in range(right):
cur *= -b[-j-1]
# print(cur)
if ans < cur:
ans = cur
except:
pass
if ans < 0 and zero:
print(0)
else:
print(ans)
``` | instruction | 0 | 43,150 | 11 | 86,300 |
Yes | output | 1 | 43,150 | 11 | 86,301 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of integers a_1,a_2,β¦,a_n. Find the maximum possible value of a_ia_ja_ka_la_t among all five indices (i, j, k, l, t) (i<j<k<l<t).
Input
The input consists of multiple test cases. The first line contains an integer t (1β€ tβ€ 2 β
10^4) β the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (5β€ nβ€ 10^5) β the size of the array.
The second line of each test case contains n integers a_1,a_2,β¦,a_n (-3Γ 10^3β€ a_iβ€ 3Γ 10^3) β given array.
It's guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print one integer β the answer to the problem.
Example
Input
4
5
-1 -2 -3 -4 -5
6
-1 -2 -3 1 2 -1
6
-1 0 0 0 -1 -1
6
-9 -7 -5 -3 -2 1
Output
-120
12
0
945
Note
In the first test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)β
(-2) β
(-3)β
(-4)β
(-5)=-120.
In the second test case, choosing a_1,a_2,a_3,a_5,a_6 is a best choice: (-1)β
(-2) β
(-3)β
2β
(-1)=12.
In the third test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)β
0β
0β
0β
(-1)=0.
In the fourth test case, choosing a_1,a_2,a_3,a_4,a_6 is a best choice: (-9)β
(-7) β
(-5)β
(-3)β
1=945.
Submitted Solution:
```
import sys
from decimal import Decimal
from collections import defaultdict as dc
#input=sys.stdin.readline
import math
from bisect import bisect_left, bisect_right
for _ in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
l.sort()
if l[-1]==0:
print(0)
elif l[-1]<0:
x=1
c=0
for i in range(n-1,-1,-1):
if c>=5:
break
else:
x*=l[i]
c+=1
#x*=l[-1]
print(x)
else:
i=0
j=n-1
x=1
x*=l[j]
j-=1
c=0
while(c<2 and i<=j):
a=l[i]*l[i+1]
b=l[j]*l[j-1]
if a>b:
x*=a
i+=2
else:
x*=b
j-=2
c+=1
print(x)
``` | instruction | 0 | 43,151 | 11 | 86,302 |
Yes | output | 1 | 43,151 | 11 | 86,303 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of integers a_1,a_2,β¦,a_n. Find the maximum possible value of a_ia_ja_ka_la_t among all five indices (i, j, k, l, t) (i<j<k<l<t).
Input
The input consists of multiple test cases. The first line contains an integer t (1β€ tβ€ 2 β
10^4) β the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (5β€ nβ€ 10^5) β the size of the array.
The second line of each test case contains n integers a_1,a_2,β¦,a_n (-3Γ 10^3β€ a_iβ€ 3Γ 10^3) β given array.
It's guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print one integer β the answer to the problem.
Example
Input
4
5
-1 -2 -3 -4 -5
6
-1 -2 -3 1 2 -1
6
-1 0 0 0 -1 -1
6
-9 -7 -5 -3 -2 1
Output
-120
12
0
945
Note
In the first test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)β
(-2) β
(-3)β
(-4)β
(-5)=-120.
In the second test case, choosing a_1,a_2,a_3,a_5,a_6 is a best choice: (-1)β
(-2) β
(-3)β
2β
(-1)=12.
In the third test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)β
0β
0β
0β
(-1)=0.
In the fourth test case, choosing a_1,a_2,a_3,a_4,a_6 is a best choice: (-9)β
(-7) β
(-5)β
(-3)β
1=945.
Submitted Solution:
```
"""
NTC here
"""
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
def product_rg(arr, ch):
if len(arr)>=ch:
ans = 1
for i in range(ch):
ans *= arr[-i-1]
else:
ans = 0
# print(arr, ch, ans)
return ans
def product_rg_start(arr, ch):
if len(arr)>=ch:
ans = 1
for i in range(ch):
ans *= arr[i]
else:
ans = 0
# print(arr, ch, ans)
return ans
def main():
T = iin()
while T:
T-=1
n = iin()
a = lin()
pv, nv = [], []
for i in a:
if i>0:
pv.append(i)
if i<0:
nv.append(i)
pv.sort()
nv.sort(reverse=True)
# zeros their
if len(pv)+len(nv)<5:
print(0)
continue
ans = - 10**20
# normal ans
ans = max(ans, product_rg(a, 5))
# Postive - Negative
# 5 - 0
if len(pv)>=5 and len(nv)>=0:
ans = max(ans, product_rg(pv, 5)*product_rg(nv, 0))
# 3 - 2
if len(pv)>=3 and len(nv)>=2:
ans = max(ans, product_rg(pv, 3)*product_rg(nv, 2))
# 1 - 4
if len(pv)>=1 and len(nv)>=4:
ans = max(ans, product_rg(pv, 1)*product_rg(nv, 4))
# all negative
# 0-5
if len(nv)>=5 and len(pv)>=0:
ans = max(ans, product_rg_start(nv, 5)*product_rg_start(pv, 0))
# 2-3
if len(nv)>=3 and len(pv)>=2:
ans = max(ans, product_rg_start(nv, 3)*product_rg_start(pv, 2))
# 4-1
if len(nv)>=1 and len(pv)>=4:
ans = max(ans, product_rg_start(nv, 1)*product_rg_start(pv, 4))
# print
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")
def iin(): return int(input())
def lin(): return list(map(int, input().split()))
# endregion
if __name__ == "__main__":
main()
``` | instruction | 0 | 43,152 | 11 | 86,304 |
No | output | 1 | 43,152 | 11 | 86,305 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of integers a_1,a_2,β¦,a_n. Find the maximum possible value of a_ia_ja_ka_la_t among all five indices (i, j, k, l, t) (i<j<k<l<t).
Input
The input consists of multiple test cases. The first line contains an integer t (1β€ tβ€ 2 β
10^4) β the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (5β€ nβ€ 10^5) β the size of the array.
The second line of each test case contains n integers a_1,a_2,β¦,a_n (-3Γ 10^3β€ a_iβ€ 3Γ 10^3) β given array.
It's guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print one integer β the answer to the problem.
Example
Input
4
5
-1 -2 -3 -4 -5
6
-1 -2 -3 1 2 -1
6
-1 0 0 0 -1 -1
6
-9 -7 -5 -3 -2 1
Output
-120
12
0
945
Note
In the first test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)β
(-2) β
(-3)β
(-4)β
(-5)=-120.
In the second test case, choosing a_1,a_2,a_3,a_5,a_6 is a best choice: (-1)β
(-2) β
(-3)β
2β
(-1)=12.
In the third test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)β
0β
0β
0β
(-1)=0.
In the fourth test case, choosing a_1,a_2,a_3,a_4,a_6 is a best choice: (-9)β
(-7) β
(-5)β
(-3)β
1=945.
Submitted Solution:
```
import math
# def mySort(n):
# return (math.abs(n))
n = int(input())
for i in range(n):
m = int(input())
inp = [int(x) for x in input().split()]
if m == 5:
print(inp[0]*inp[1]*inp[2]*inp[3]*inp[4])
else:
inp.append(0)
# absarr = inp.sort(key, reverse=True)
inp.sort()
numNeg = inp.index(0)
inp.remove(0)
maxEl = inp[len(inp) - 1]
inp.remove(maxEl)
temp = []
for i in range(min(int(numNeg/2),2)):
temp.append(inp[2*i]*inp[2*i+1])
for i in range(min(int((m-numNeg-1)/2),2)):
temp.append(inp[m-2-2*i]*inp[m-3-2*i])
temp.sort(reverse=True)
print(maxEl * temp[0] * temp[1])
``` | instruction | 0 | 43,153 | 11 | 86,306 |
No | output | 1 | 43,153 | 11 | 86,307 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of integers a_1,a_2,β¦,a_n. Find the maximum possible value of a_ia_ja_ka_la_t among all five indices (i, j, k, l, t) (i<j<k<l<t).
Input
The input consists of multiple test cases. The first line contains an integer t (1β€ tβ€ 2 β
10^4) β the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (5β€ nβ€ 10^5) β the size of the array.
The second line of each test case contains n integers a_1,a_2,β¦,a_n (-3Γ 10^3β€ a_iβ€ 3Γ 10^3) β given array.
It's guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print one integer β the answer to the problem.
Example
Input
4
5
-1 -2 -3 -4 -5
6
-1 -2 -3 1 2 -1
6
-1 0 0 0 -1 -1
6
-9 -7 -5 -3 -2 1
Output
-120
12
0
945
Note
In the first test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)β
(-2) β
(-3)β
(-4)β
(-5)=-120.
In the second test case, choosing a_1,a_2,a_3,a_5,a_6 is a best choice: (-1)β
(-2) β
(-3)β
2β
(-1)=12.
In the third test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)β
0β
0β
0β
(-1)=0.
In the fourth test case, choosing a_1,a_2,a_3,a_4,a_6 is a best choice: (-9)β
(-7) β
(-5)β
(-3)β
1=945.
Submitted Solution:
```
from functools import reduce
for _ in range(int(input())):
N = int(input())
X = sorted(list(map(int, input().split())))
if X[-1] == 0:
print(0)
elif X[-1] < 0:
print(reduce(lambda i, j: i * j, X[::-1][:5]))
else:
Positive, Negative = [], []
P, N = 0, 0
for i in X:
if i > 0:
Positive.append(i)
P += 1
if i < 0:
Negative.append(abs(i))
N += 1
if N + P < 5 or (N+P==5 and N==1):
print(0)
else:
Positive = sorted(Positive, reverse=True)
Negative = sorted(Negative, reverse=True)
Sum = Positive[-1]
Answers = []
for i in range(len(Positive) // 2):
Answers.append(Positive[i * 2] * Positive[i * 2 + 1])
for i in range(len(Negative) // 2):
Answers.append(Negative[i * 2] * Negative[i * 2 + 1])
Answers = sorted(Answers, reverse=True)
print(Sum * Answers[0] * Answers[1])
# Let's see who is the best !!!
# ravenS_The_Best
``` | instruction | 0 | 43,154 | 11 | 86,308 |
No | output | 1 | 43,154 | 11 | 86,309 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of integers a_1,a_2,β¦,a_n. Find the maximum possible value of a_ia_ja_ka_la_t among all five indices (i, j, k, l, t) (i<j<k<l<t).
Input
The input consists of multiple test cases. The first line contains an integer t (1β€ tβ€ 2 β
10^4) β the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (5β€ nβ€ 10^5) β the size of the array.
The second line of each test case contains n integers a_1,a_2,β¦,a_n (-3Γ 10^3β€ a_iβ€ 3Γ 10^3) β given array.
It's guaranteed that the sum of n over all test cases does not exceed 2β
10^5.
Output
For each test case, print one integer β the answer to the problem.
Example
Input
4
5
-1 -2 -3 -4 -5
6
-1 -2 -3 1 2 -1
6
-1 0 0 0 -1 -1
6
-9 -7 -5 -3 -2 1
Output
-120
12
0
945
Note
In the first test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)β
(-2) β
(-3)β
(-4)β
(-5)=-120.
In the second test case, choosing a_1,a_2,a_3,a_5,a_6 is a best choice: (-1)β
(-2) β
(-3)β
2β
(-1)=12.
In the third test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)β
0β
0β
0β
(-1)=0.
In the fourth test case, choosing a_1,a_2,a_3,a_4,a_6 is a best choice: (-9)β
(-7) β
(-5)β
(-3)β
1=945.
Submitted Solution:
```
from math import prod
t = int(input())
for i in range(t):
n = int(input())
a = list(map(int, input().split()))
a.sort()
b = []
if len(a) > 5:
for j in range(5):
if abs(a[0]) > abs(a[-1]):
b.append(a[0])
a.remove(a[0])
else:
b.append(a[-1])
a.remove(a[-1])
counter = 0
if 0 not in b:
for j in b:
if j < 0:
counter += 1
if counter % 2 == 0:
print(prod(b))
else:
b.sort()
if counter < 5:
if abs(a[0]) > abs(a[-1]):
if a[0] > 0:
for j in reversed(range(5)):
if b[j] < 0:
b.remove(b[j])
b.append(a[0])
if a[0] < 0:
for j in range(5):
if b[j] > 0:
b.remove(b[j])
b.append(a[0])
if a[0] == 0:
b.append(0)
else:
if a[-1] > 0:
for j in reversed(range(5)):
if b[j] < 0:
b.remove(b[j])
b.append(a[-1])
if a[-1] < 0:
for j in range(5):
if b[j] > 0:
b.remove(b[j])
b.append(a[-1])
if a[-1] == 0:
b.append(0)
print(prod(b))
if counter == 5:
if a[-1] >= 0:
b.remove(max(b))
b.append(a[-1])
print(prod(b))
else:
for j in b:
a.append(j)
a.sort()
print(a[-1] * a[-2] * a[-3] * a[-4] * a[-5])
else:
print(0)
else:
print(prod(a))
``` | instruction | 0 | 43,155 | 11 | 86,310 |
No | output | 1 | 43,155 | 11 | 86,311 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Little Elephant loves playing with arrays. He has array a, consisting of n positive integers, indexed from 1 to n. Let's denote the number with index i as ai.
Additionally the Little Elephant has m queries to the array, each query is characterised by a pair of integers lj and rj (1 β€ lj β€ rj β€ n). For each query lj, rj the Little Elephant has to count, how many numbers x exist, such that number x occurs exactly x times among numbers alj, alj + 1, ..., arj.
Help the Little Elephant to count the answers to all queries.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 105) β the size of array a and the number of queries to it. The next line contains n space-separated positive integers a1, a2, ..., an (1 β€ ai β€ 109). Next m lines contain descriptions of queries, one per line. The j-th of these lines contains the description of the j-th query as two space-separated integers lj and rj (1 β€ lj β€ rj β€ n).
Output
In m lines print m integers β the answers to the queries. The j-th line should contain the answer to the j-th query.
Examples
Input
7 2
3 1 2 2 3 3 7
1 7
3 4
Output
3
1
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
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")
#######################################
from collections import defaultdict as dd
from math import ceil
n,m=map(int,input().split())
l=list(map(int,input().split()))
l1=[]
for i in range(m):
x,y=map(int,input().split())
l1.append([x,y,i])
l1.sort(key=lambda x:x[1])
x=ceil(n**0.5)
c=[dd(int) for i in range(n//x+1)]
for i in range(0,n,x):
for j in range(min(x,n-i)):
c[i//x][l[i+j]]+=1
a1=(l1[0][0]-1)//x
a2=(l1[0][1]-1)//x
b1=(l1[0][0]-1)%x
b2=(l1[0][1]-1)%x
d=dd(int)
for i in range(a1+1,a2):
for j in c[i]:
d[j]+=c[i][j]
for i in range(a1*x+b1,min(a1*x+x,n)):
d[l[i]]+=1
for i in range(a2*x,min(a2*x+b2+1,n)):
d[l[i]]+=1
ans=[0]*m
for i in d:
if d[i]==i:
ans[l1[0][2]]+=1
for i in range(1,m):
a3=(l1[i][0]-1)//x
a4=(l1[i][1]-1)//x
b3=(l1[i][0]-1)%x
b4=(l1[i][1]-1)%x
if a1<a3:
for j in range(a1+1,a3):
for k in c[j]:
d[k]-=c[j][k]
for j in range(a1*x+b1,min(a1*x+x,n)):
d[l[j]]-=1
for j in range(a3*x,min(a3*x+b3,n)):
d[l[j]]-=1
elif a1==a3:
if b1<b3:
for j in range(a1*x+b1,a1*x+b3):
d[l[j]]-=1
else:
for j in range(a1*x+b3,a1*x+b1):
d[l[j]]+=1
else:
for j in range(a3+1,a1):
for k in c[j]:
d[k]+=c[j][k]
for j in range(a1*x,a1*x+b1):
d[l[j]]+=1
for j in range(a3*x+b3,a3*x+x):
d[l[j]]+=1
for j in range(a2+1,a4):
for k in c[j]:
d[k]+=c[j][k]
for j in range(a4*x,min(a4*x+b4+1,n)):
d[l[j]]+=1
for j in range(a2*x+b2+1,min(a2*x+x,n)):
d[l[j]]+=1
for j in d:
if d[j]==j:
ans[l1[i][2]]+=1
a1,a2,b1,b2=a3,a4,b3,b4
for i in ans:
print(i)
``` | instruction | 0 | 43,266 | 11 | 86,532 |
No | output | 1 | 43,266 | 11 | 86,533 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Little Elephant loves playing with arrays. He has array a, consisting of n positive integers, indexed from 1 to n. Let's denote the number with index i as ai.
Additionally the Little Elephant has m queries to the array, each query is characterised by a pair of integers lj and rj (1 β€ lj β€ rj β€ n). For each query lj, rj the Little Elephant has to count, how many numbers x exist, such that number x occurs exactly x times among numbers alj, alj + 1, ..., arj.
Help the Little Elephant to count the answers to all queries.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 105) β the size of array a and the number of queries to it. The next line contains n space-separated positive integers a1, a2, ..., an (1 β€ ai β€ 109). Next m lines contain descriptions of queries, one per line. The j-th of these lines contains the description of the j-th query as two space-separated integers lj and rj (1 β€ lj β€ rj β€ n).
Output
In m lines print m integers β the answers to the queries. The j-th line should contain the answer to the j-th query.
Examples
Input
7 2
3 1 2 2 3 3 7
1 7
3 4
Output
3
1
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
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")
#######################################
class query():
global z
def __init__(self,l,r,i):
self.lb=(l-1)//z
self.l=l
self.r=r
self.ind=i
def __gt__(a,b):
if a.lb<b.lb:
True
elif a.lb==b.lb:
if a.lb%2 and a.r<b.r:
return True
elif a.lb%2==0 and a.r>b.r:
return True
else:
return False
else:
return False
n,m=map(int,input().split())
a=list(map(int,input().split()))
for i in range(n):
if a[i]>n:
a[i]=-1
l1=[]
z=int(n**0.5)
for i in range(m):
x,y=map(int,input().split())
l1.append(query(x,y,i))
l1.sort()
for i in l1:
print(i.l,i.r)
d=[0]*(n+2)
l=1
r=0
ans=0
fans=[0]*m
for i in l1:
while r<i.r:
r+=1
if d[a[r-1]]==a[r-1]:
ans-=1
d[a[r-1]]+=1
if d[a[r-1]]==a[r-1]:
ans+=1
while l>i.l:
l-=1
if d[a[l-1]]==a[l-1]:
ans-=1
d[a[l-1]]+=1
if d[a[l-1]]==a[l-1]:
ans+=1
while l<i.l:
if d[a[l-1]]==a[l-1]:
ans-=1
d[a[l-1]]-=1
if d[a[l-1]]==a[l-1]:
ans+=1
l+=1
while r>i.r:
if d[a[r-1]]==a[r-1]:
ans-=1
d[a[r-1]]-=1
if d[a[r-1]]==a[r-1]:
ans+=1
r-=1
fans[i.ind]=ans
for i in fans:
print(i)
``` | instruction | 0 | 43,267 | 11 | 86,534 |
No | output | 1 | 43,267 | 11 | 86,535 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Parmida is a clever girl and she wants to participate in Olympiads this year. Of course she wants her partner to be clever too (although he's not)! Parmida has prepared the following test problem for Pashmak.
There is a sequence a that consists of n integers a1, a2, ..., an. Let's denote f(l, r, x) the number of indices k such that: l β€ k β€ r and ak = x. His task is to calculate the number of pairs of indicies i, j (1 β€ i < j β€ n) such that f(1, i, ai) > f(j, n, aj).
Help Pashmak with the test.
Input
The first line of the input contains an integer n (1 β€ n β€ 106). The second line contains n space-separated integers a1, a2, ..., an (1 β€ ai β€ 109).
Output
Print a single integer β the answer to the problem.
Examples
Input
7
1 2 1 1 2 2 1
Output
8
Input
3
1 1 1
Output
1
Input
5
1 2 3 4 5
Output
0
Submitted Solution:
```
# 459D
import sys
from collections import Counter
class BIT():
def __init__(self, n):
self.n = n
self.tree = [0] * n
def _F(self, i):
return i & (i + 1)
def _getSum(self, r):
'''
sum on interval [0, r]
'''
result = 0
while r >= 0:
result += self.tree[r]
r = self._F(r) - 1
return result
def getSum(self, l, r):
'''
sum on interval [l, r]
'''
return self._getSum(r) - self._getSum(l - 1)
def _H(self, i):
return i | (i + 1)
def add(self, i, value=1):
while i < self.n:
self.tree[i] += value
i = self._H(i)
# inf = open('input.txt', 'r')
# reader = (line.rstrip() for line in inf)
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
n = int(input())
a = list(map(int, input().split()))
# inf.close()
freq = BIT(n+1)
f_left = [0] * n
f_right = [0] * n
ctr = Counter()
for i, val in enumerate(a):
ctr[val] += 1
f_left[i] = ctr[val]
for i in range(n):
val = a[i]
f_right[i] = ctr[val] - f_left[i] + 1
for f_r in f_right:
freq.add(f_r, 1)
ans = 0
for i, f_l in enumerate(f_left):
f_r = f_right[i]
freq.add(f_r, -1)
ans += freq.getSum(1, f_l-1)
print(ans)
``` | instruction | 0 | 43,352 | 11 | 86,704 |
Yes | output | 1 | 43,352 | 11 | 86,705 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Parmida is a clever girl and she wants to participate in Olympiads this year. Of course she wants her partner to be clever too (although he's not)! Parmida has prepared the following test problem for Pashmak.
There is a sequence a that consists of n integers a1, a2, ..., an. Let's denote f(l, r, x) the number of indices k such that: l β€ k β€ r and ak = x. His task is to calculate the number of pairs of indicies i, j (1 β€ i < j β€ n) such that f(1, i, ai) > f(j, n, aj).
Help Pashmak with the test.
Input
The first line of the input contains an integer n (1 β€ n β€ 106). The second line contains n space-separated integers a1, a2, ..., an (1 β€ ai β€ 109).
Output
Print a single integer β the answer to the problem.
Examples
Input
7
1 2 1 1 2 2 1
Output
8
Input
3
1 1 1
Output
1
Input
5
1 2 3 4 5
Output
0
Submitted Solution:
```
#!/usr/bin/env python3
# from typing import *
import sys
import io
import math
import collections
import decimal
import itertools
import bisect
import heapq
def input():
return sys.stdin.readline()[:-1]
# sys.setrecursionlimit(1000000)
# _INPUT = """7
# 1 2 1 1 2 2 1
# """
# sys.stdin = io.StringIO(_INPUT)
class BIT:
"""
Binary Indexed Tree (Fenwick Tree), 1-indexed
"""
def __init__(self, n):
"""
Parameters
----------
n : int
θ¦η΄ ζ°γindex γ― 0..n γ«γͺγγ
"""
self.size = n
self.data = [0] * (n+1)
# self.depth = n.bit_length()
def add(self, i, x):
while i <= self.size:
self.data[i] += x
i += i & -i
def get_sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= i & -i
return s
N = int(input())
A = list(map(int, input().split()))
N1 = 2 ** (N-1).bit_length()
Dat = [0] * (2*N1)
D = {a: i for i, a in enumerate(sorted(set(A)))}
B = [D[a] for a in A]
Count1 = [0] * N
T1 = [list() for _ in range(N)]
for i in range(N):
v = Count1[B[i]]
T1[v].append(i)
Count1[B[i]] += 1
Count2 = [0] * N
T2 = [list() for _ in range(N)]
for i in reversed(range(N)):
v = Count2[B[i]]
T2[v].append(i)
Count2[B[i]] += 1
ans = 0
bit = BIT(N)
for i in range(1, N):
for k in T2[i-1]:
bit.add(N-k, 1)
# add(k, 1)
for l in T1[i]:
n = bit.get_sum(N-1-l)
# n = query(l+1, N)
ans += n
print(ans)
``` | instruction | 0 | 43,353 | 11 | 86,706 |
Yes | output | 1 | 43,353 | 11 | 86,707 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Parmida is a clever girl and she wants to participate in Olympiads this year. Of course she wants her partner to be clever too (although he's not)! Parmida has prepared the following test problem for Pashmak.
There is a sequence a that consists of n integers a1, a2, ..., an. Let's denote f(l, r, x) the number of indices k such that: l β€ k β€ r and ak = x. His task is to calculate the number of pairs of indicies i, j (1 β€ i < j β€ n) such that f(1, i, ai) > f(j, n, aj).
Help Pashmak with the test.
Input
The first line of the input contains an integer n (1 β€ n β€ 106). The second line contains n space-separated integers a1, a2, ..., an (1 β€ ai β€ 109).
Output
Print a single integer β the answer to the problem.
Examples
Input
7
1 2 1 1 2 2 1
Output
8
Input
3
1 1 1
Output
1
Input
5
1 2 3 4 5
Output
0
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = 'x' in file.mode or 'r' not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b'\n') + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode('ascii'))
self.read = lambda: self.buffer.read().decode('ascii')
self.readline = lambda: self.buffer.readline().decode('ascii')
def inp():
return sys.stdin.readline().rstrip()
def mpint():
return map(int, inp().split(' '))
def itg():
return int(inp())
# ############################## import
class FenwickTree:
def __init__(self, x=[]):
""" transform list into BIT """
self.bit = x
for i in range(len(x)):
j = i | (i + 1)
if j < len(x):
x[j] += x[i]
def update(self, idx, x):
""" updates bit[idx] += x """
while idx < len(self.bit):
self.bit[idx] += x
idx |= idx + 1
def query(self, end):
""" calc sum(bit[:end]) """
x = 0
while end:
x += self.bit[end - 1]
end &= end - 1
return x
def findkth(self, k):
"""
Find largest idx such that sum(x[:idx]) <= k
all of the element in x have to be non-negative
"""
idx = -1
for d in reversed(range(len(self.bit).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(self.bit) and k >= self.bit[right_idx]:
idx = right_idx
k -= self.bit[idx]
return idx + 1
# ############################## main
from collections import Counter
def solve():
n = itg()
arr = tuple(mpint())
pre, suf = Counter(), Counter(arr)
fi = [0] * n
fj = [0] * n
for i, a in enumerate(arr):
pre[a] += 1
fi[i] = pre[a]
fj[i] = suf[a]
suf[a] -= 1
bit = FenwickTree([0] * (n + 1))
ans = 0
for i in reversed(range(n)):
ans += bit.query(fi[i])
bit.update(fj[i], 1)
return ans
def main():
# solve()
print(solve())
# for _ in range(itg()):
# print(solve())
# solve()
# print("yes" if solve() else "no")
# print("YES" if solve() else "NO")
DEBUG = 0
URL = 'https://codeforces.com/contest/459/problem/D'
if __name__ == '__main__':
if DEBUG == 1:
import requests # ImportError: cannot import name 'md5' from 'sys' (unknown location)
from ACgenerator.Y_Test_Case_Runner import TestCaseRunner
runner = TestCaseRunner(main, URL)
inp = runner.input_stream
print = runner.output_stream
runner.checking()
elif DEBUG == 2:
main()
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
main()
# Please check!
``` | instruction | 0 | 43,354 | 11 | 86,708 |
Yes | output | 1 | 43,354 | 11 | 86,709 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Parmida is a clever girl and she wants to participate in Olympiads this year. Of course she wants her partner to be clever too (although he's not)! Parmida has prepared the following test problem for Pashmak.
There is a sequence a that consists of n integers a1, a2, ..., an. Let's denote f(l, r, x) the number of indices k such that: l β€ k β€ r and ak = x. His task is to calculate the number of pairs of indicies i, j (1 β€ i < j β€ n) such that f(1, i, ai) > f(j, n, aj).
Help Pashmak with the test.
Input
The first line of the input contains an integer n (1 β€ n β€ 106). The second line contains n space-separated integers a1, a2, ..., an (1 β€ ai β€ 109).
Output
Print a single integer β the answer to the problem.
Examples
Input
7
1 2 1 1 2 2 1
Output
8
Input
3
1 1 1
Output
1
Input
5
1 2 3 4 5
Output
0
Submitted Solution:
```
from sys import *
class SortedList:
def __init__(self, iterable=None, _load=200):
if iterable is None:
iterable = []
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
return self._len
def __getitem__(self, index):
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
return (value for _list in self._lists for value in _list)
def __reversed__(self):
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
return 'SortedList({0})'.format(list(self))
n=int(stdin.readline())
a=list(map(int,stdin.readline().split()))
d={}
x=0
for i in range(n):
if a[i] not in d:
d[a[i]]=x
x+=1
for i in range(n):
a[i]=d[a[i]]
cnt=[0]*x
left=[0]*n
right=[0]*n
for i in range(n):
cnt[a[i]]+=1
left[i]=cnt[a[i]]
for i in range(x):
cnt[i]=0
for i in range(n-1,-1,-1):
cnt[a[i]]+=1
right[i]=cnt[a[i]]
arr=SortedList(left)
ans=0
for i in range(n-1,0,-1):
arr.discard(left[i])
pos=arr.bisect_right(right[i])
ans+=len(arr)-pos
stdout.write(str(ans)+"\n")
``` | instruction | 0 | 43,355 | 11 | 86,710 |
Yes | output | 1 | 43,355 | 11 | 86,711 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Parmida is a clever girl and she wants to participate in Olympiads this year. Of course she wants her partner to be clever too (although he's not)! Parmida has prepared the following test problem for Pashmak.
There is a sequence a that consists of n integers a1, a2, ..., an. Let's denote f(l, r, x) the number of indices k such that: l β€ k β€ r and ak = x. His task is to calculate the number of pairs of indicies i, j (1 β€ i < j β€ n) such that f(1, i, ai) > f(j, n, aj).
Help Pashmak with the test.
Input
The first line of the input contains an integer n (1 β€ n β€ 106). The second line contains n space-separated integers a1, a2, ..., an (1 β€ ai β€ 109).
Output
Print a single integer β the answer to the problem.
Examples
Input
7
1 2 1 1 2 2 1
Output
8
Input
3
1 1 1
Output
1
Input
5
1 2 3 4 5
Output
0
Submitted Solution:
```
n = int(input())
from collections import defaultdict
arr = list(map(int,input().split()))
l = [0 for _ in range(n)]
r = [0 for _ in range(n)]
d = defaultdict(int)
for i in range(n):
d[arr[i]] += 1
l[i] = d[arr[i]]
d.clear()
for i in range(n-1,-1,-1):
d[arr[i]] += 1
r[i] = d[arr[i]]
ans = 0
for i in range(n):
j = n-1
count = 0
while r[j] < l[i] and j>i:
j -= 1
count+=1
ans += count
print(ans)
``` | instruction | 0 | 43,356 | 11 | 86,712 |
No | output | 1 | 43,356 | 11 | 86,713 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Parmida is a clever girl and she wants to participate in Olympiads this year. Of course she wants her partner to be clever too (although he's not)! Parmida has prepared the following test problem for Pashmak.
There is a sequence a that consists of n integers a1, a2, ..., an. Let's denote f(l, r, x) the number of indices k such that: l β€ k β€ r and ak = x. His task is to calculate the number of pairs of indicies i, j (1 β€ i < j β€ n) such that f(1, i, ai) > f(j, n, aj).
Help Pashmak with the test.
Input
The first line of the input contains an integer n (1 β€ n β€ 106). The second line contains n space-separated integers a1, a2, ..., an (1 β€ ai β€ 109).
Output
Print a single integer β the answer to the problem.
Examples
Input
7
1 2 1 1 2 2 1
Output
8
Input
3
1 1 1
Output
1
Input
5
1 2 3 4 5
Output
0
Submitted Solution:
```
n = int(input())
l = [int(j) for j in input().split()]
d = dict()
pre = []
for i in range(n):
if l[i] in d:
d[l[i]]+=1
else:
d[l[i]]=1
pre.append(d[l[i]])
suf = [0 for i in range(n)]
d = dict()
for i in range(n-1, -1, -1):
if l[i] in d:
d[l[i]]+=1
else:
d[l[i]]=1
suf[i] = d[l[i]]
def update(bit, index, val):
n = len(bit)
while(index<n):
bit[index]+=val
index += index&(-1*index)
def getsum(bit, index):
n = len(bit)
ans = 0
while(index>0):
ans+=bit[index]
index -= index&(-1*index)
return ans
# arr = [3, 6, 2, 4, 1, 7]
n = len(pre)
# print(pre, suf)
bit = [0]*(max(pre)+1)
inv_ct = 0
for i in range(n-1, -1, -1):
# index = pre[i]
inv_ct += getsum(bit, suf[i]-1)
update(bit, pre[i], 1)
# print(inv_ct, bit)
print(inv_ct)
# print(pre, suf)
# for i in range(n):
# val = pre[i]
``` | instruction | 0 | 43,357 | 11 | 86,714 |
No | output | 1 | 43,357 | 11 | 86,715 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Parmida is a clever girl and she wants to participate in Olympiads this year. Of course she wants her partner to be clever too (although he's not)! Parmida has prepared the following test problem for Pashmak.
There is a sequence a that consists of n integers a1, a2, ..., an. Let's denote f(l, r, x) the number of indices k such that: l β€ k β€ r and ak = x. His task is to calculate the number of pairs of indicies i, j (1 β€ i < j β€ n) such that f(1, i, ai) > f(j, n, aj).
Help Pashmak with the test.
Input
The first line of the input contains an integer n (1 β€ n β€ 106). The second line contains n space-separated integers a1, a2, ..., an (1 β€ ai β€ 109).
Output
Print a single integer β the answer to the problem.
Examples
Input
7
1 2 1 1 2 2 1
Output
8
Input
3
1 1 1
Output
1
Input
5
1 2 3 4 5
Output
0
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = 'x' in file.mode or 'r' not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b'\n') + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode('ascii'))
self.read = lambda: self.buffer.read().decode('ascii')
self.readline = lambda: self.buffer.readline().decode('ascii')
def inp():
return sys.stdin.readline().rstrip()
def mpint():
return map(int, inp().split(' '))
def itg():
return int(inp())
# ############################## import
def discrete_binary_search(func, lo, hi):
while lo < hi:
mi = lo + hi >> 1
if func(mi):
hi = mi
else:
lo = mi + 1
return lo
def pair_bisect_calculator(length, func, check=False, distinct=True):
"""
O(nlogn)
calculate the number of pairs (i, j) such that
0 <= i < j < length if distinct is True
0 <= i <= j < length if distinct is False
and func(i, j) is True
The func must be able to bisection
i.e. if func(i, j) is True, func(i, j+1) must to be True
if check: O(n^2)
check if the result is same as the answer with brute-force
"""
result = 0
for i in range(length):
bound = discrete_binary_search(lambda x: func(i, x), i, length)
result += length - bound
if bound == i and distinct:
result -= 1
if check:
ans = 0
for i in range(length):
for j in range(i, length):
if i == j and distinct:
continue
ans += func(i, j)
assert result == ans, "expected: %d, got %d" % (ans, result)
return result
# ############################## main
from collections import Counter
def solve():
n = itg()
arr = tuple(mpint())
pre, suf = Counter(), Counter(arr)
fi = [0] * n
fj = [0] * n
for i, a in enumerate(arr):
pre[a] += 1
fj[i] = suf[a]
suf[a] -= 1
fi[i] = pre[a]
def f(i, j):
return fi[i] > fj[j]
return pair_bisect_calculator(n, f)
def main():
# solve()
print(solve())
# for _ in range(itg()):
# print(solve())
# solve()
# print("yes" if solve() else "no")
# print("YES" if solve() else "NO")
DEBUG = 0
URL = 'https://codeforces.com/contest/459/problem/D'
if __name__ == '__main__':
if DEBUG == 1:
import requests # ImportError: cannot import name 'md5' from 'sys' (unknown location)
from ACgenerator.Y_Test_Case_Runner import TestCaseRunner
runner = TestCaseRunner(main, URL)
inp = runner.input_stream
print = runner.output_stream
runner.checking()
elif DEBUG == 2:
main()
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
main()
# Please check!
``` | instruction | 0 | 43,358 | 11 | 86,716 |
No | output | 1 | 43,358 | 11 | 86,717 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Parmida is a clever girl and she wants to participate in Olympiads this year. Of course she wants her partner to be clever too (although he's not)! Parmida has prepared the following test problem for Pashmak.
There is a sequence a that consists of n integers a1, a2, ..., an. Let's denote f(l, r, x) the number of indices k such that: l β€ k β€ r and ak = x. His task is to calculate the number of pairs of indicies i, j (1 β€ i < j β€ n) such that f(1, i, ai) > f(j, n, aj).
Help Pashmak with the test.
Input
The first line of the input contains an integer n (1 β€ n β€ 106). The second line contains n space-separated integers a1, a2, ..., an (1 β€ ai β€ 109).
Output
Print a single integer β the answer to the problem.
Examples
Input
7
1 2 1 1 2 2 1
Output
8
Input
3
1 1 1
Output
1
Input
5
1 2 3 4 5
Output
0
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = 'x' in file.mode or 'r' not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b'\n') + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode('ascii'))
self.read = lambda: self.buffer.read().decode('ascii')
self.readline = lambda: self.buffer.readline().decode('ascii')
def inp():
return sys.stdin.readline().rstrip()
def mpint():
return map(int, inp().split(' '))
def itg():
return int(inp())
# ############################## import
def discrete_binary_search(func, lo, hi):
while lo < hi:
mi = lo + hi >> 1
if func(mi):
hi = mi
else:
lo = mi + 1
return lo
def pair_bisect_calculator(length, func, check=False, distinct=True):
"""
O(nlogn)
calculate the number of pairs (i, j) such that
0 <= i < j < length if distinct is True
0 <= i <= j < length if distinct is False
and func(i, j) is True
The func must be able to bisection
i.e. if func(i, j) is True, func(i, j+1) must to be True
if check: O(n^2)
check if the result is same as the answer with brute-force
"""
result = 0
for i in range(length):
bound = discrete_binary_search(lambda x: func(i, x), i, length)
result += length - bound
if bound == i and distinct:
result -= 1
if check:
ans = 0
for i in range(length):
for j in range(i, length):
if i == j and distinct:
continue
ans += func(i, j)
assert result == ans, "expected: %d, got %d" % (ans, result)
return result
# ############################## main
from collections import Counter
def solve():
n = itg()
arr = tuple(mpint())
pre, suf = Counter(), Counter(arr)
fi = [0] * n
fj = [0] * n
for i, a in enumerate(arr):
pre[a] += 1
fj[i] = suf[a]
suf[a] -= 1
fi[i] = pre[a]
data = [(0, i, -fi[i]) for i in range(n)] + [(1, j, -fj[j]) for j in range(n)]
data.sort()
def f(i, j):
return data[i][0] < data[j][0] and data[i][1] < data[j][1] and data[i][2] < data[j][2]
return pair_bisect_calculator(n << 1, f)
def main():
# solve()
print(solve())
# for _ in range(itg()):
# print(solve())
# solve()
# print("yes" if solve() else "no")
# print("YES" if solve() else "NO")
DEBUG = 0
URL = 'https://codeforces.com/contest/459/problem/D'
if __name__ == '__main__':
if DEBUG == 1:
import requests # ImportError: cannot import name 'md5' from 'sys' (unknown location)
from ACgenerator.Y_Test_Case_Runner import TestCaseRunner
runner = TestCaseRunner(main, URL)
inp = runner.input_stream
print = runner.output_stream
runner.checking()
elif DEBUG == 2:
main()
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
main()
# Please check!
``` | instruction | 0 | 43,359 | 11 | 86,718 |
No | output | 1 | 43,359 | 11 | 86,719 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n problems prepared for the next Codeforces round. They are arranged in ascending order by their difficulty, and no two problems have the same difficulty. Moreover, there are m pairs of similar problems. Authors want to split problems between two division according to the following rules:
* Problemset of each division should be non-empty.
* Each problem should be used in exactly one division (yes, it is unusual requirement).
* Each problem used in division 1 should be harder than any problem used in division 2.
* If two problems are similar, they should be used in different divisions.
Your goal is count the number of ways to split problem between two divisions and satisfy all the rules. Two ways to split problems are considered to be different if there is at least one problem that belongs to division 1 in one of them and to division 2 in the other.
Note, that the relation of similarity is not transitive. That is, if problem i is similar to problem j and problem j is similar to problem k, it doesn't follow that i is similar to k.
Input
The first line of the input contains two integers n and m (2 β€ n β€ 100 000, 0 β€ m β€ 100 000) β the number of problems prepared for the round and the number of pairs of similar problems, respectively.
Each of the following m lines contains a pair of similar problems ui and vi (1 β€ ui, vi β€ n, ui β vi). It's guaranteed, that no pair of problems meets twice in the input.
Output
Print one integer β the number of ways to split problems in two divisions.
Examples
Input
5 2
1 4
5 2
Output
2
Input
3 3
1 2
2 3
1 3
Output
0
Input
3 2
3 1
3 2
Output
1
Note
In the first sample, problems 1 and 2 should be used in division 2, while problems 4 and 5 in division 1. Problem 3 may be used either in division 1 or in division 2.
In the second sample, all pairs of problems are similar and there is no way to split problem between two divisions without breaking any rules.
Third sample reminds you that the similarity relation is not transitive. Problem 3 is similar to both 1 and 2, but 1 is not similar to 2, so they may be used together. | instruction | 0 | 43,428 | 11 | 86,856 |
Tags: greedy, implementation
Correct Solution:
```
import sys
sys.stderr = sys.stdout
def division(n, m, S):
u0 = 1
v0 = n
for u, v in S:
if v < u:
u, v = v, u
u0 = max(u0, u)
v0 = min(v0, v)
if u0 >= v0:
return 0
return v0 - u0
def main():
n, m = readinti()
S = readinttl(m)
print(division(n, m, S))
##########
def readint():
return int(input())
def readinti():
return map(int, input().split())
def readintt():
return tuple(readinti())
def readintl():
return list(readinti())
def readinttl(k):
return [readintt() for _ in range(k)]
def readintll(k):
return [readintl() for _ in range(k)]
def log(*args, **kwargs):
print(*args, **kwargs, file=sys.__stderr__)
if __name__ == '__main__':
main()
``` | output | 1 | 43,428 | 11 | 86,857 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n problems prepared for the next Codeforces round. They are arranged in ascending order by their difficulty, and no two problems have the same difficulty. Moreover, there are m pairs of similar problems. Authors want to split problems between two division according to the following rules:
* Problemset of each division should be non-empty.
* Each problem should be used in exactly one division (yes, it is unusual requirement).
* Each problem used in division 1 should be harder than any problem used in division 2.
* If two problems are similar, they should be used in different divisions.
Your goal is count the number of ways to split problem between two divisions and satisfy all the rules. Two ways to split problems are considered to be different if there is at least one problem that belongs to division 1 in one of them and to division 2 in the other.
Note, that the relation of similarity is not transitive. That is, if problem i is similar to problem j and problem j is similar to problem k, it doesn't follow that i is similar to k.
Input
The first line of the input contains two integers n and m (2 β€ n β€ 100 000, 0 β€ m β€ 100 000) β the number of problems prepared for the round and the number of pairs of similar problems, respectively.
Each of the following m lines contains a pair of similar problems ui and vi (1 β€ ui, vi β€ n, ui β vi). It's guaranteed, that no pair of problems meets twice in the input.
Output
Print one integer β the number of ways to split problems in two divisions.
Examples
Input
5 2
1 4
5 2
Output
2
Input
3 3
1 2
2 3
1 3
Output
0
Input
3 2
3 1
3 2
Output
1
Note
In the first sample, problems 1 and 2 should be used in division 2, while problems 4 and 5 in division 1. Problem 3 may be used either in division 1 or in division 2.
In the second sample, all pairs of problems are similar and there is no way to split problem between two divisions without breaking any rules.
Third sample reminds you that the similarity relation is not transitive. Problem 3 is similar to both 1 and 2, but 1 is not similar to 2, so they may be used together. | instruction | 0 | 43,429 | 11 | 86,858 |
Tags: greedy, implementation
Correct Solution:
```
nm=input().split()
n=int(nm[0])
m=int(nm[1])
if m==0:
print (n-1)
else:
i=0
d1=[]
d2=[]
while i<m:
uv=input().split()
u=int(uv[0])
v=int(uv[1])
d1.append(max(u,v))
d2.append(min(u,v))
i+=1
x=min(d1)
y=max(d2)
if x<=y:
print(0)
else:
print(x-y)
``` | output | 1 | 43,429 | 11 | 86,859 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n problems prepared for the next Codeforces round. They are arranged in ascending order by their difficulty, and no two problems have the same difficulty. Moreover, there are m pairs of similar problems. Authors want to split problems between two division according to the following rules:
* Problemset of each division should be non-empty.
* Each problem should be used in exactly one division (yes, it is unusual requirement).
* Each problem used in division 1 should be harder than any problem used in division 2.
* If two problems are similar, they should be used in different divisions.
Your goal is count the number of ways to split problem between two divisions and satisfy all the rules. Two ways to split problems are considered to be different if there is at least one problem that belongs to division 1 in one of them and to division 2 in the other.
Note, that the relation of similarity is not transitive. That is, if problem i is similar to problem j and problem j is similar to problem k, it doesn't follow that i is similar to k.
Input
The first line of the input contains two integers n and m (2 β€ n β€ 100 000, 0 β€ m β€ 100 000) β the number of problems prepared for the round and the number of pairs of similar problems, respectively.
Each of the following m lines contains a pair of similar problems ui and vi (1 β€ ui, vi β€ n, ui β vi). It's guaranteed, that no pair of problems meets twice in the input.
Output
Print one integer β the number of ways to split problems in two divisions.
Examples
Input
5 2
1 4
5 2
Output
2
Input
3 3
1 2
2 3
1 3
Output
0
Input
3 2
3 1
3 2
Output
1
Note
In the first sample, problems 1 and 2 should be used in division 2, while problems 4 and 5 in division 1. Problem 3 may be used either in division 1 or in division 2.
In the second sample, all pairs of problems are similar and there is no way to split problem between two divisions without breaking any rules.
Third sample reminds you that the similarity relation is not transitive. Problem 3 is similar to both 1 and 2, but 1 is not similar to 2, so they may be used together. | instruction | 0 | 43,430 | 11 | 86,860 |
Tags: greedy, implementation
Correct Solution:
```
def readInts(): return map(int, input().split())
n, m = readInts()
lo = 1
hi = n
for _ in range(m):
a, b = readInts()
lo = max ( lo, min(a,b) )
hi = min ( hi, max(a,b) )
print( max(0, hi-lo) )
``` | output | 1 | 43,430 | 11 | 86,861 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n problems prepared for the next Codeforces round. They are arranged in ascending order by their difficulty, and no two problems have the same difficulty. Moreover, there are m pairs of similar problems. Authors want to split problems between two division according to the following rules:
* Problemset of each division should be non-empty.
* Each problem should be used in exactly one division (yes, it is unusual requirement).
* Each problem used in division 1 should be harder than any problem used in division 2.
* If two problems are similar, they should be used in different divisions.
Your goal is count the number of ways to split problem between two divisions and satisfy all the rules. Two ways to split problems are considered to be different if there is at least one problem that belongs to division 1 in one of them and to division 2 in the other.
Note, that the relation of similarity is not transitive. That is, if problem i is similar to problem j and problem j is similar to problem k, it doesn't follow that i is similar to k.
Input
The first line of the input contains two integers n and m (2 β€ n β€ 100 000, 0 β€ m β€ 100 000) β the number of problems prepared for the round and the number of pairs of similar problems, respectively.
Each of the following m lines contains a pair of similar problems ui and vi (1 β€ ui, vi β€ n, ui β vi). It's guaranteed, that no pair of problems meets twice in the input.
Output
Print one integer β the number of ways to split problems in two divisions.
Examples
Input
5 2
1 4
5 2
Output
2
Input
3 3
1 2
2 3
1 3
Output
0
Input
3 2
3 1
3 2
Output
1
Note
In the first sample, problems 1 and 2 should be used in division 2, while problems 4 and 5 in division 1. Problem 3 may be used either in division 1 or in division 2.
In the second sample, all pairs of problems are similar and there is no way to split problem between two divisions without breaking any rules.
Third sample reminds you that the similarity relation is not transitive. Problem 3 is similar to both 1 and 2, but 1 is not similar to 2, so they may be used together. | instruction | 0 | 43,431 | 11 | 86,862 |
Tags: greedy, implementation
Correct Solution:
```
n, m = map(int, input().split())
count = [0] * n
for i in range(m):
a, b = map(int, input().split())
low, high = min(a, b) - 1, max(a, b) - 1
count[low] += 1
count[high] -= 1
cur, res = 0, 0
for i in range(n - 1):
cur += count[i]
if cur == m: res += 1
print(res)
``` | output | 1 | 43,431 | 11 | 86,863 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n problems prepared for the next Codeforces round. They are arranged in ascending order by their difficulty, and no two problems have the same difficulty. Moreover, there are m pairs of similar problems. Authors want to split problems between two division according to the following rules:
* Problemset of each division should be non-empty.
* Each problem should be used in exactly one division (yes, it is unusual requirement).
* Each problem used in division 1 should be harder than any problem used in division 2.
* If two problems are similar, they should be used in different divisions.
Your goal is count the number of ways to split problem between two divisions and satisfy all the rules. Two ways to split problems are considered to be different if there is at least one problem that belongs to division 1 in one of them and to division 2 in the other.
Note, that the relation of similarity is not transitive. That is, if problem i is similar to problem j and problem j is similar to problem k, it doesn't follow that i is similar to k.
Input
The first line of the input contains two integers n and m (2 β€ n β€ 100 000, 0 β€ m β€ 100 000) β the number of problems prepared for the round and the number of pairs of similar problems, respectively.
Each of the following m lines contains a pair of similar problems ui and vi (1 β€ ui, vi β€ n, ui β vi). It's guaranteed, that no pair of problems meets twice in the input.
Output
Print one integer β the number of ways to split problems in two divisions.
Examples
Input
5 2
1 4
5 2
Output
2
Input
3 3
1 2
2 3
1 3
Output
0
Input
3 2
3 1
3 2
Output
1
Note
In the first sample, problems 1 and 2 should be used in division 2, while problems 4 and 5 in division 1. Problem 3 may be used either in division 1 or in division 2.
In the second sample, all pairs of problems are similar and there is no way to split problem between two divisions without breaking any rules.
Third sample reminds you that the similarity relation is not transitive. Problem 3 is similar to both 1 and 2, but 1 is not similar to 2, so they may be used together. | instruction | 0 | 43,432 | 11 | 86,864 |
Tags: greedy, implementation
Correct Solution:
```
a,b=map(int,input().split())
l,r=0,a;ans=1
z=[0]*(a+1)
for _ in " "*b:
u,v=sorted(map(int,input().split()))
if z[u]==2 or z[v]==1:ans=0
elif z[u]!=0 and z[v]!=0 and z[u]==z[v]:ans=0
else:
z[u]=1;z[v]=2
if u>=r:ans=0
if v<=l:ans=0
l=max(l,u);r=min(r,v)
if ans==0:print(ans)
elif l==0 and r==a:print(a-1)
else:print(r-l)
``` | output | 1 | 43,432 | 11 | 86,865 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n problems prepared for the next Codeforces round. They are arranged in ascending order by their difficulty, and no two problems have the same difficulty. Moreover, there are m pairs of similar problems. Authors want to split problems between two division according to the following rules:
* Problemset of each division should be non-empty.
* Each problem should be used in exactly one division (yes, it is unusual requirement).
* Each problem used in division 1 should be harder than any problem used in division 2.
* If two problems are similar, they should be used in different divisions.
Your goal is count the number of ways to split problem between two divisions and satisfy all the rules. Two ways to split problems are considered to be different if there is at least one problem that belongs to division 1 in one of them and to division 2 in the other.
Note, that the relation of similarity is not transitive. That is, if problem i is similar to problem j and problem j is similar to problem k, it doesn't follow that i is similar to k.
Input
The first line of the input contains two integers n and m (2 β€ n β€ 100 000, 0 β€ m β€ 100 000) β the number of problems prepared for the round and the number of pairs of similar problems, respectively.
Each of the following m lines contains a pair of similar problems ui and vi (1 β€ ui, vi β€ n, ui β vi). It's guaranteed, that no pair of problems meets twice in the input.
Output
Print one integer β the number of ways to split problems in two divisions.
Examples
Input
5 2
1 4
5 2
Output
2
Input
3 3
1 2
2 3
1 3
Output
0
Input
3 2
3 1
3 2
Output
1
Note
In the first sample, problems 1 and 2 should be used in division 2, while problems 4 and 5 in division 1. Problem 3 may be used either in division 1 or in division 2.
In the second sample, all pairs of problems are similar and there is no way to split problem between two divisions without breaking any rules.
Third sample reminds you that the similarity relation is not transitive. Problem 3 is similar to both 1 and 2, but 1 is not similar to 2, so they may be used together. | instruction | 0 | 43,433 | 11 | 86,866 |
Tags: greedy, implementation
Correct Solution:
```
n, m = map(int,input().split())
l, r = 1, n
for i in range(m):
x, y = map( int, input().split() )
if x > y: x, y = y, x
l, r = max(x,l),min(y,r)
if r - l < 0: l,r=0,0
print(r - l)
``` | output | 1 | 43,433 | 11 | 86,867 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n problems prepared for the next Codeforces round. They are arranged in ascending order by their difficulty, and no two problems have the same difficulty. Moreover, there are m pairs of similar problems. Authors want to split problems between two division according to the following rules:
* Problemset of each division should be non-empty.
* Each problem should be used in exactly one division (yes, it is unusual requirement).
* Each problem used in division 1 should be harder than any problem used in division 2.
* If two problems are similar, they should be used in different divisions.
Your goal is count the number of ways to split problem between two divisions and satisfy all the rules. Two ways to split problems are considered to be different if there is at least one problem that belongs to division 1 in one of them and to division 2 in the other.
Note, that the relation of similarity is not transitive. That is, if problem i is similar to problem j and problem j is similar to problem k, it doesn't follow that i is similar to k.
Input
The first line of the input contains two integers n and m (2 β€ n β€ 100 000, 0 β€ m β€ 100 000) β the number of problems prepared for the round and the number of pairs of similar problems, respectively.
Each of the following m lines contains a pair of similar problems ui and vi (1 β€ ui, vi β€ n, ui β vi). It's guaranteed, that no pair of problems meets twice in the input.
Output
Print one integer β the number of ways to split problems in two divisions.
Examples
Input
5 2
1 4
5 2
Output
2
Input
3 3
1 2
2 3
1 3
Output
0
Input
3 2
3 1
3 2
Output
1
Note
In the first sample, problems 1 and 2 should be used in division 2, while problems 4 and 5 in division 1. Problem 3 may be used either in division 1 or in division 2.
In the second sample, all pairs of problems are similar and there is no way to split problem between two divisions without breaking any rules.
Third sample reminds you that the similarity relation is not transitive. Problem 3 is similar to both 1 and 2, but 1 is not similar to 2, so they may be used together. | instruction | 0 | 43,434 | 11 | 86,868 |
Tags: greedy, implementation
Correct Solution:
```
n, m = list(map(int, input().split()))
A, B = 1, n
for _ in range(m):
u, v = list(map(int, input().split()))
if u > v:
u, v = v, u
A = max(A, u)
B = min(B, v)
print(max(B-A, 0))
``` | output | 1 | 43,434 | 11 | 86,869 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n problems prepared for the next Codeforces round. They are arranged in ascending order by their difficulty, and no two problems have the same difficulty. Moreover, there are m pairs of similar problems. Authors want to split problems between two division according to the following rules:
* Problemset of each division should be non-empty.
* Each problem should be used in exactly one division (yes, it is unusual requirement).
* Each problem used in division 1 should be harder than any problem used in division 2.
* If two problems are similar, they should be used in different divisions.
Your goal is count the number of ways to split problem between two divisions and satisfy all the rules. Two ways to split problems are considered to be different if there is at least one problem that belongs to division 1 in one of them and to division 2 in the other.
Note, that the relation of similarity is not transitive. That is, if problem i is similar to problem j and problem j is similar to problem k, it doesn't follow that i is similar to k.
Input
The first line of the input contains two integers n and m (2 β€ n β€ 100 000, 0 β€ m β€ 100 000) β the number of problems prepared for the round and the number of pairs of similar problems, respectively.
Each of the following m lines contains a pair of similar problems ui and vi (1 β€ ui, vi β€ n, ui β vi). It's guaranteed, that no pair of problems meets twice in the input.
Output
Print one integer β the number of ways to split problems in two divisions.
Examples
Input
5 2
1 4
5 2
Output
2
Input
3 3
1 2
2 3
1 3
Output
0
Input
3 2
3 1
3 2
Output
1
Note
In the first sample, problems 1 and 2 should be used in division 2, while problems 4 and 5 in division 1. Problem 3 may be used either in division 1 or in division 2.
In the second sample, all pairs of problems are similar and there is no way to split problem between two divisions without breaking any rules.
Third sample reminds you that the similarity relation is not transitive. Problem 3 is similar to both 1 and 2, but 1 is not similar to 2, so they may be used together. | instruction | 0 | 43,435 | 11 | 86,870 |
Tags: greedy, implementation
Correct Solution:
```
n,m = map(int,input().split())
#a = [1]*n
i,j = 2,n
for k in range(m):
x,y = map(int,input().split())
if x>y:x,y = y,x
i,j = max(i,x+1), min(j,y)
#print(j-i+1)
print(max(j-i+1,0))
``` | output | 1 | 43,435 | 11 | 86,871 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n problems prepared for the next Codeforces round. They are arranged in ascending order by their difficulty, and no two problems have the same difficulty. Moreover, there are m pairs of similar problems. Authors want to split problems between two division according to the following rules:
* Problemset of each division should be non-empty.
* Each problem should be used in exactly one division (yes, it is unusual requirement).
* Each problem used in division 1 should be harder than any problem used in division 2.
* If two problems are similar, they should be used in different divisions.
Your goal is count the number of ways to split problem between two divisions and satisfy all the rules. Two ways to split problems are considered to be different if there is at least one problem that belongs to division 1 in one of them and to division 2 in the other.
Note, that the relation of similarity is not transitive. That is, if problem i is similar to problem j and problem j is similar to problem k, it doesn't follow that i is similar to k.
Input
The first line of the input contains two integers n and m (2 β€ n β€ 100 000, 0 β€ m β€ 100 000) β the number of problems prepared for the round and the number of pairs of similar problems, respectively.
Each of the following m lines contains a pair of similar problems ui and vi (1 β€ ui, vi β€ n, ui β vi). It's guaranteed, that no pair of problems meets twice in the input.
Output
Print one integer β the number of ways to split problems in two divisions.
Examples
Input
5 2
1 4
5 2
Output
2
Input
3 3
1 2
2 3
1 3
Output
0
Input
3 2
3 1
3 2
Output
1
Note
In the first sample, problems 1 and 2 should be used in division 2, while problems 4 and 5 in division 1. Problem 3 may be used either in division 1 or in division 2.
In the second sample, all pairs of problems are similar and there is no way to split problem between two divisions without breaking any rules.
Third sample reminds you that the similarity relation is not transitive. Problem 3 is similar to both 1 and 2, but 1 is not similar to 2, so they may be used together.
Submitted Solution:
```
n, m = map(int, input().split())
uv = []
for i in range(m):
mapp = list(map(int, input().split()))
mapp.sort()
uv.append(mapp)
all_tasks = [1, n]
for s in uv:
all_tasks = [max(all_tasks[0], s[0]), min(all_tasks[1], s[1])]
if all_tasks[1] - all_tasks[0] + 1 < 2:
print(0)
else:
print(all_tasks[1] - all_tasks[0])
``` | instruction | 0 | 43,436 | 11 | 86,872 |
Yes | output | 1 | 43,436 | 11 | 86,873 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n problems prepared for the next Codeforces round. They are arranged in ascending order by their difficulty, and no two problems have the same difficulty. Moreover, there are m pairs of similar problems. Authors want to split problems between two division according to the following rules:
* Problemset of each division should be non-empty.
* Each problem should be used in exactly one division (yes, it is unusual requirement).
* Each problem used in division 1 should be harder than any problem used in division 2.
* If two problems are similar, they should be used in different divisions.
Your goal is count the number of ways to split problem between two divisions and satisfy all the rules. Two ways to split problems are considered to be different if there is at least one problem that belongs to division 1 in one of them and to division 2 in the other.
Note, that the relation of similarity is not transitive. That is, if problem i is similar to problem j and problem j is similar to problem k, it doesn't follow that i is similar to k.
Input
The first line of the input contains two integers n and m (2 β€ n β€ 100 000, 0 β€ m β€ 100 000) β the number of problems prepared for the round and the number of pairs of similar problems, respectively.
Each of the following m lines contains a pair of similar problems ui and vi (1 β€ ui, vi β€ n, ui β vi). It's guaranteed, that no pair of problems meets twice in the input.
Output
Print one integer β the number of ways to split problems in two divisions.
Examples
Input
5 2
1 4
5 2
Output
2
Input
3 3
1 2
2 3
1 3
Output
0
Input
3 2
3 1
3 2
Output
1
Note
In the first sample, problems 1 and 2 should be used in division 2, while problems 4 and 5 in division 1. Problem 3 may be used either in division 1 or in division 2.
In the second sample, all pairs of problems are similar and there is no way to split problem between two divisions without breaking any rules.
Third sample reminds you that the similarity relation is not transitive. Problem 3 is similar to both 1 and 2, but 1 is not similar to 2, so they may be used together.
Submitted Solution:
```
from collections import deque
def bfs(i, G, V):
V[i] = 1
Q = deque([i])
while Q:
u = Q.popleft()
for v in G[u]:
if not V[v]:
V[v] = 1 if V[u] == 2 else 2
Q.append(v)
else:
if V[v] == V[u]:
return False
return True
n, m = map(int, input().split())
G = [[] for _ in range(n+1)]
I = []
possible = True
for i in range(m):
u, v = map(int, input().split())
G[u].append(v)
G[v].append(u)
I.append(u)
I.append(v)
I.sort()
V = [0 for _ in range(n+1)]
for i in I:
if not V[i]:
possible = bfs(i, G, V)
if not possible:
print(0)
break
if possible:
m1, m2 = 1, n
for i in range(1, n+1):
if V[i] == 1:
m1 = i
elif V[i] == 2 and m2 == n:
m2 = i
if m2 < m1:
print(0)
else:
print(m2-m1)
``` | instruction | 0 | 43,437 | 11 | 86,874 |
Yes | output | 1 | 43,437 | 11 | 86,875 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n problems prepared for the next Codeforces round. They are arranged in ascending order by their difficulty, and no two problems have the same difficulty. Moreover, there are m pairs of similar problems. Authors want to split problems between two division according to the following rules:
* Problemset of each division should be non-empty.
* Each problem should be used in exactly one division (yes, it is unusual requirement).
* Each problem used in division 1 should be harder than any problem used in division 2.
* If two problems are similar, they should be used in different divisions.
Your goal is count the number of ways to split problem between two divisions and satisfy all the rules. Two ways to split problems are considered to be different if there is at least one problem that belongs to division 1 in one of them and to division 2 in the other.
Note, that the relation of similarity is not transitive. That is, if problem i is similar to problem j and problem j is similar to problem k, it doesn't follow that i is similar to k.
Input
The first line of the input contains two integers n and m (2 β€ n β€ 100 000, 0 β€ m β€ 100 000) β the number of problems prepared for the round and the number of pairs of similar problems, respectively.
Each of the following m lines contains a pair of similar problems ui and vi (1 β€ ui, vi β€ n, ui β vi). It's guaranteed, that no pair of problems meets twice in the input.
Output
Print one integer β the number of ways to split problems in two divisions.
Examples
Input
5 2
1 4
5 2
Output
2
Input
3 3
1 2
2 3
1 3
Output
0
Input
3 2
3 1
3 2
Output
1
Note
In the first sample, problems 1 and 2 should be used in division 2, while problems 4 and 5 in division 1. Problem 3 may be used either in division 1 or in division 2.
In the second sample, all pairs of problems are similar and there is no way to split problem between two divisions without breaking any rules.
Third sample reminds you that the similarity relation is not transitive. Problem 3 is similar to both 1 and 2, but 1 is not similar to 2, so they may be used together.
Submitted Solution:
```
(total, similar) = (int(_) for _ in input().split())
first = set()
second = set()
for _ in range(similar):
(x, y) = (int(_) for _ in input().split())
first.add(max(x, y))
second.add(min(x, y))
if first & second:
print(0)
else:
if not first:
first = {total}
if not second:
second = {1}
print(max(min(first)-max(second), 0))
``` | instruction | 0 | 43,438 | 11 | 86,876 |
Yes | output | 1 | 43,438 | 11 | 86,877 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n problems prepared for the next Codeforces round. They are arranged in ascending order by their difficulty, and no two problems have the same difficulty. Moreover, there are m pairs of similar problems. Authors want to split problems between two division according to the following rules:
* Problemset of each division should be non-empty.
* Each problem should be used in exactly one division (yes, it is unusual requirement).
* Each problem used in division 1 should be harder than any problem used in division 2.
* If two problems are similar, they should be used in different divisions.
Your goal is count the number of ways to split problem between two divisions and satisfy all the rules. Two ways to split problems are considered to be different if there is at least one problem that belongs to division 1 in one of them and to division 2 in the other.
Note, that the relation of similarity is not transitive. That is, if problem i is similar to problem j and problem j is similar to problem k, it doesn't follow that i is similar to k.
Input
The first line of the input contains two integers n and m (2 β€ n β€ 100 000, 0 β€ m β€ 100 000) β the number of problems prepared for the round and the number of pairs of similar problems, respectively.
Each of the following m lines contains a pair of similar problems ui and vi (1 β€ ui, vi β€ n, ui β vi). It's guaranteed, that no pair of problems meets twice in the input.
Output
Print one integer β the number of ways to split problems in two divisions.
Examples
Input
5 2
1 4
5 2
Output
2
Input
3 3
1 2
2 3
1 3
Output
0
Input
3 2
3 1
3 2
Output
1
Note
In the first sample, problems 1 and 2 should be used in division 2, while problems 4 and 5 in division 1. Problem 3 may be used either in division 1 or in division 2.
In the second sample, all pairs of problems are similar and there is no way to split problem between two divisions without breaking any rules.
Third sample reminds you that the similarity relation is not transitive. Problem 3 is similar to both 1 and 2, but 1 is not similar to 2, so they may be used together.
Submitted Solution:
```
'''
Created on May 8, 2016
@author: Md. Rezwanul Haque
'''
'''def main():
n,m = map(int,input().split())
lo, hi = 1, n
for _ in range(m):
u,v = map(int,input().split())
if u>v :
if lo<v:
lo = v
if hi>u:
hi = u
elif v>u:
if lo<u:
lo = u
if hi>v:
hi = v
print( max(hi - lo , 0))
if __name__ == '__main__':
main()
'''
n, m = map(int,input().split())
i, j = 2,n
for k in range(m):
x,y = map(int,input().split())
if x>y:
x,y = y,x
i, j = max(i,x + 1), min(j,y)
print(max(j-i+1,0))
``` | instruction | 0 | 43,439 | 11 | 86,878 |
Yes | output | 1 | 43,439 | 11 | 86,879 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n problems prepared for the next Codeforces round. They are arranged in ascending order by their difficulty, and no two problems have the same difficulty. Moreover, there are m pairs of similar problems. Authors want to split problems between two division according to the following rules:
* Problemset of each division should be non-empty.
* Each problem should be used in exactly one division (yes, it is unusual requirement).
* Each problem used in division 1 should be harder than any problem used in division 2.
* If two problems are similar, they should be used in different divisions.
Your goal is count the number of ways to split problem between two divisions and satisfy all the rules. Two ways to split problems are considered to be different if there is at least one problem that belongs to division 1 in one of them and to division 2 in the other.
Note, that the relation of similarity is not transitive. That is, if problem i is similar to problem j and problem j is similar to problem k, it doesn't follow that i is similar to k.
Input
The first line of the input contains two integers n and m (2 β€ n β€ 100 000, 0 β€ m β€ 100 000) β the number of problems prepared for the round and the number of pairs of similar problems, respectively.
Each of the following m lines contains a pair of similar problems ui and vi (1 β€ ui, vi β€ n, ui β vi). It's guaranteed, that no pair of problems meets twice in the input.
Output
Print one integer β the number of ways to split problems in two divisions.
Examples
Input
5 2
1 4
5 2
Output
2
Input
3 3
1 2
2 3
1 3
Output
0
Input
3 2
3 1
3 2
Output
1
Note
In the first sample, problems 1 and 2 should be used in division 2, while problems 4 and 5 in division 1. Problem 3 may be used either in division 1 or in division 2.
In the second sample, all pairs of problems are similar and there is no way to split problem between two divisions without breaking any rules.
Third sample reminds you that the similarity relation is not transitive. Problem 3 is similar to both 1 and 2, but 1 is not similar to 2, so they may be used together.
Submitted Solution:
```
inp = input().split()
n,m = int(inp[0]),int(inp[1])
if n==2:
print(1)
exit(0)
n+=1
if n%2 == 1:
_n = n//2+1
__n = _n
else:
_n = n//2
__n = _n+1
a = [[] for _ in range(n)]
def sameDiv(u,v):
return ((u>0 and u<__n and v>0 and v<__n) or (u>=__n and u<n and v>=__n and v<n)) and (u!=_n and v!=_n)
for i in range(m):
inp = input().split()
u,v = int(inp[0]),int(inp[1])
if sameDiv(u,v):
print(0)
exit(0)
a[u].append(v)
a[v].append(u)
for i in range(_n):
for j in a[i]:
if j>0 and j<_n:
print(0)
exit(0)
for i in range(__n,n):
for j in a[i]:
if j<n and j>=__n:
print(0)
exit(0)
if n%2==1:
print(1)
exit(0)
similarTo = 0
ans = 2
for i in a[_n]:
if (i in range(_n)) and similarTo != 1: similarTo+=1
if (i in range(__n,n)) and similarTo != 2: similarTo+=2
if similarTo == 3: break
if similarTo == 3: ans=0
elif similarTo == 1 or similarTo == 2: ans = 1
print(ans)
``` | instruction | 0 | 43,440 | 11 | 86,880 |
No | output | 1 | 43,440 | 11 | 86,881 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n problems prepared for the next Codeforces round. They are arranged in ascending order by their difficulty, and no two problems have the same difficulty. Moreover, there are m pairs of similar problems. Authors want to split problems between two division according to the following rules:
* Problemset of each division should be non-empty.
* Each problem should be used in exactly one division (yes, it is unusual requirement).
* Each problem used in division 1 should be harder than any problem used in division 2.
* If two problems are similar, they should be used in different divisions.
Your goal is count the number of ways to split problem between two divisions and satisfy all the rules. Two ways to split problems are considered to be different if there is at least one problem that belongs to division 1 in one of them and to division 2 in the other.
Note, that the relation of similarity is not transitive. That is, if problem i is similar to problem j and problem j is similar to problem k, it doesn't follow that i is similar to k.
Input
The first line of the input contains two integers n and m (2 β€ n β€ 100 000, 0 β€ m β€ 100 000) β the number of problems prepared for the round and the number of pairs of similar problems, respectively.
Each of the following m lines contains a pair of similar problems ui and vi (1 β€ ui, vi β€ n, ui β vi). It's guaranteed, that no pair of problems meets twice in the input.
Output
Print one integer β the number of ways to split problems in two divisions.
Examples
Input
5 2
1 4
5 2
Output
2
Input
3 3
1 2
2 3
1 3
Output
0
Input
3 2
3 1
3 2
Output
1
Note
In the first sample, problems 1 and 2 should be used in division 2, while problems 4 and 5 in division 1. Problem 3 may be used either in division 1 or in division 2.
In the second sample, all pairs of problems are similar and there is no way to split problem between two divisions without breaking any rules.
Third sample reminds you that the similarity relation is not transitive. Problem 3 is similar to both 1 and 2, but 1 is not similar to 2, so they may be used together.
Submitted Solution:
```
n, m = list(map(int, input().split()))
A, B = 0, n-1
for _ in range(m):
u, v = list(map(int, input().split()))
if u > v:
u, v = v, u
A = max(A, u)
B = min(B, v)
print(max(B-A, 0))
``` | instruction | 0 | 43,441 | 11 | 86,882 |
No | output | 1 | 43,441 | 11 | 86,883 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n problems prepared for the next Codeforces round. They are arranged in ascending order by their difficulty, and no two problems have the same difficulty. Moreover, there are m pairs of similar problems. Authors want to split problems between two division according to the following rules:
* Problemset of each division should be non-empty.
* Each problem should be used in exactly one division (yes, it is unusual requirement).
* Each problem used in division 1 should be harder than any problem used in division 2.
* If two problems are similar, they should be used in different divisions.
Your goal is count the number of ways to split problem between two divisions and satisfy all the rules. Two ways to split problems are considered to be different if there is at least one problem that belongs to division 1 in one of them and to division 2 in the other.
Note, that the relation of similarity is not transitive. That is, if problem i is similar to problem j and problem j is similar to problem k, it doesn't follow that i is similar to k.
Input
The first line of the input contains two integers n and m (2 β€ n β€ 100 000, 0 β€ m β€ 100 000) β the number of problems prepared for the round and the number of pairs of similar problems, respectively.
Each of the following m lines contains a pair of similar problems ui and vi (1 β€ ui, vi β€ n, ui β vi). It's guaranteed, that no pair of problems meets twice in the input.
Output
Print one integer β the number of ways to split problems in two divisions.
Examples
Input
5 2
1 4
5 2
Output
2
Input
3 3
1 2
2 3
1 3
Output
0
Input
3 2
3 1
3 2
Output
1
Note
In the first sample, problems 1 and 2 should be used in division 2, while problems 4 and 5 in division 1. Problem 3 may be used either in division 1 or in division 2.
In the second sample, all pairs of problems are similar and there is no way to split problem between two divisions without breaking any rules.
Third sample reminds you that the similarity relation is not transitive. Problem 3 is similar to both 1 and 2, but 1 is not similar to 2, so they may be used together.
Submitted Solution:
```
def start() :
a = input().split()
n = int(a[0])
p = int(a[1])
small1 = n
large2 = 0
arr = []
for i in range(0, n):
arr.append(0)
pairs = []
for i in range(0, p):
pairs.append(input().split())
if(n<2):
print("0")
for i in range(0, p):
s = pairs[i]
a1 = int(s[0])
a2 = int(s[1])
if(a1>a2):
if(arr[a1-1]==2):
print("0")
return
else:
arr[a1-1] = 1
if(small1>a1):
small1 = a1
if(arr[a2-1]==1):
print("0")
return
else:
arr[a2-1] = 2
if(large2<a2):
large2 = a2
else:
if(arr[a1-1]==1):
print("0")
return
else:
arr[a1-1] = 2
if(large2<a1):
large2 = a1
if(arr[a2-1]==2):
print("0")
return
else:
arr[a2-1] = 1
if(small1>a2):
small1 = a2
if(small1<=large2):
print("0")
return
w = 1
for i in range(0, n):
if(arr[i]==0):
if(small1>(i+1)):
if(large2<(i+1)):
w += 1
if(p==0):
w -= 2
print(str(w))
return
start()
``` | instruction | 0 | 43,442 | 11 | 86,884 |
No | output | 1 | 43,442 | 11 | 86,885 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n problems prepared for the next Codeforces round. They are arranged in ascending order by their difficulty, and no two problems have the same difficulty. Moreover, there are m pairs of similar problems. Authors want to split problems between two division according to the following rules:
* Problemset of each division should be non-empty.
* Each problem should be used in exactly one division (yes, it is unusual requirement).
* Each problem used in division 1 should be harder than any problem used in division 2.
* If two problems are similar, they should be used in different divisions.
Your goal is count the number of ways to split problem between two divisions and satisfy all the rules. Two ways to split problems are considered to be different if there is at least one problem that belongs to division 1 in one of them and to division 2 in the other.
Note, that the relation of similarity is not transitive. That is, if problem i is similar to problem j and problem j is similar to problem k, it doesn't follow that i is similar to k.
Input
The first line of the input contains two integers n and m (2 β€ n β€ 100 000, 0 β€ m β€ 100 000) β the number of problems prepared for the round and the number of pairs of similar problems, respectively.
Each of the following m lines contains a pair of similar problems ui and vi (1 β€ ui, vi β€ n, ui β vi). It's guaranteed, that no pair of problems meets twice in the input.
Output
Print one integer β the number of ways to split problems in two divisions.
Examples
Input
5 2
1 4
5 2
Output
2
Input
3 3
1 2
2 3
1 3
Output
0
Input
3 2
3 1
3 2
Output
1
Note
In the first sample, problems 1 and 2 should be used in division 2, while problems 4 and 5 in division 1. Problem 3 may be used either in division 1 or in division 2.
In the second sample, all pairs of problems are similar and there is no way to split problem between two divisions without breaking any rules.
Third sample reminds you that the similarity relation is not transitive. Problem 3 is similar to both 1 and 2, but 1 is not similar to 2, so they may be used together.
Submitted Solution:
```
v = input()
print(v)
``` | instruction | 0 | 43,443 | 11 | 86,886 |
No | output | 1 | 43,443 | 11 | 86,887 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A robot, a wall, and a goal are installed on the board, and a program that describes the behavior pattern of the robot is given.
The given program is represented by the following EBNF.
Program: = {statement};
Statement: = if statement | while statement | action statement;
if statement: = "[", condition, program, "]";
while statement: = "{", condition, program, "}";
Action statement: = "^" | "v" | "<" | ">";
Condition: = ["~"], "N" | "E" | "S" | "W" | "C" | "T";
A "program" consists of 0 or more "sentences", and if there is one or more sentences, the sentences are executed one by one in order from the first sentence. A "statement" is one of an "action statement", an "if statement", and a "while statement". The "action statement" is one of "^", "v", "<", ">", and the following actions are executed respectively.
* "^": Advance
* "v": Retreat
* "<": Rotate 90 degrees to the left
* ">": Rotate 90 degrees to the right
The "if statement" is an arrangement of "[", "condition", "program", "]" in order, and is executed by the following procedure.
1. Determine if the content of the "condition" is true
2. If the judgment is true, execute the contents of the "program" and end the processing of this if statement.
3. If the judgment is false, the processing of this if statement ends.
A "while statement" is an arrangement of "{", "condition", "program", and "}" in order, and is executed by the following procedure.
1. Determine if the content of the "condition" is true
2. If the judgment is true, execute the contents of "Program" and return to 1.
3. If the judgment is false, the processing of this while statement ends.
The "condition" is one of "N", "E", "S", "W", "C", "T", and can be prefixed with "~". Each description represents the following boolean values.
* If "~" is added at the beginning, the boolean value is reversed.
* N: True if facing north, false otherwise
* E: True if facing east, false otherwise
* S: True if facing south, false otherwise
* W: True if facing west, false otherwise
* C: True if there is a wall in front of you, false otherwise
* T: Always true
It is assumed that the robot is initially facing north. Robots cannot pass through walls and can only move empty squares. If the program tries to perform an action that passes over a wall, the robot will not move and will stay in place. Finally, when the robot reaches the goal, it interrupts all the programs that are being executed, even if they remain, and stops the operation.
At this time, I would like to know how long it will take for the robot to reach the goal. Since the robot can execute condition judgment and program loading at a very high speed, it is only the "action statement" that determines the actual operation time. Therefore, please tell me how many times this robot executes the "motion statement" before reaching the goal.
It is considered that the "action statement" has been executed even if the action of the "action statement" is not actually performed when trying to execute an action that passes over the wall.
Constraints
* 1 β€ H, W β€ 50
* 1 β€ s number of characters β€ 1,000
* ai, j is one of ".", "#", "S", "g"
* "s" and "g" appear only once each
* If i = 1 or i = H or j = 1 or j = W, then ai, j = "#" (the outer circumference of the board is guaranteed to be surrounded by a wall)
* The program given as s is syntactically correct
Input
The input is given in the following format.
H W
a1,1a1,2 ... a1, W
a2,1a2,2 ... a2, W
:::
aH, 1aH, 2 ... aH, W
s
H is the height of the board and W is the width of the board.
Next, the state of the board viewed from directly above is given. The top, bottom, left, and right of this board correspond to north, south, west, and east, respectively. Ai and j, which represent the state of each cell, are one of the following characters.
* "s": Robot (robot initial position. This square is guaranteed to have no walls)
* "g": Goal
* "#": Wall (Robots cannot move on the wall)
* ".": An empty square
The program given to the robot is input as a character string in s.
Output
If you can reach it, output "the number of" action statements "executed before reaching it". If you cannot reach it, output "-1". In addition, when trying to execute an action that passes over a wall, " Note that even if the action of the "action statement" is not performed, it is considered that the "action statement" has been executed (input example 1).
Examples
Input
5 3
###
#g#
#.#
#s#
###
^<^<vv
Output
5
Input
5 3
g#
.#
s#
^<^<vv
Output
5
Input
5 7
.#g..#
.###.#
s....#
{T{~C^}<}
Output
17
Input
5 7
.#g..#
.###.#
s....#
{T{~C^}>}
Output
-1
Submitted Solution:
```
def parse_prog(prog, pointer, level, code):
while True:
pointer, code = parse_sent(prog, pointer, level, code)
if pointer == len(prog):break
if prog[pointer] in ("]", "}"):break
return pointer + 1, code
def parse_sent(prog, pointer, level, code):
head = prog[pointer]
if head == "[":
pointer, code = parse_if(prog, pointer, level, code)
elif head == "{":
pointer, code = parse_while(prog, pointer, level, code)
else:
pointer, code = parse_behave(prog, pointer, level, code)
return pointer, code
def parse_if(prog, pointer, level, code):
pointer += 1
head = prog[pointer]
cond, pointer = parse_cond(prog, pointer)
code += (" " * level + "if ({}):\n").format(cond)
pointer, code = parse_prog(prog, pointer, level + 1, code)
return pointer, code
def parse_cond(prog, pointer):
head = prog[pointer]
if head == "~":
cond = prog[pointer:pointer+2]
pointer += 2
else:
cond = prog[pointer:pointer+1]
pointer += 1
cond = cond_convert(cond)
return cond, pointer
def parse_while(prog, pointer, level, code):
pointer += 1
cond, pointer = parse_cond(prog, pointer)
tab0 = " " * level
tab1 = tab0 + " "
tab2 = tab1 + " "
code += tab0 + "STATUS += 1\n"
code += tab0 + "while ({}):\n".format(cond)
code += tab1 + "if (STATUS, DIRECT, X, Y) in DIC:\n"
code += tab2 + "print(-1)\n"
code += tab2 + "return -1\n"
code += tab1 + "else:\n"
code += tab2 + "DIC[(STATUS, DIRECT, X, Y)] = True\n"
pointer, code = parse_prog(prog, pointer, level + 1, code)
code += (" " * level + "STATUS -= 1" + "\n")
return pointer, code
def parse_behave(prog, pointer, level, code):
behave = prog[pointer]
behave = convert_behave(behave, level)
code += behave
return pointer + 1, code
def cond_convert(cond):
if cond == "~T":return "False"
if cond == "T": return "True"
ret = ""
if cond[0] == "~":ret += "not "
if cond[-1] in ("N", "E", "S", "W"):
return ret + ("DIRECT == {}").format(cond[-1])
if cond[-1] == "C":
return ret + "FRONT == \"#\""
if cond[-1] == "T":
return ret + "True"
def convert_behave(behave, level):
tab = " " * level
tab2 = tab + " "
ret = ""
ret += tab + "if (X, Y) == (GX, GY):"
ret += "\n" + tab2 + "print(CNT)"
ret += "\n" + tab2 + "return CNT"
if behave == "^":
ret += "\n" + tab + "DX, DY = VEC[DIRECT]"
ret += "\n" + tab + "NX, NY = X + DX, Y + DY"
ret += "\n" + tab + "if MP[NY][NX] != \"#\":"
ret += "\n" + tab2 + "X, Y = NX, NY"
ret += "\n" + tab2 + "FRONT = MP[NY + DY][NX + DX]"
if behave == "v":
ret += "\n" + tab + "DX, DY = VEC[DIRECT]"
ret += "\n" + tab + "NX, NY = X - DX, Y - DY"
ret += "\n" + tab + "if MP[NY][NX] != \"#\":"
ret += "\n" + tab2 + "X, Y = NX, NY"
ret += "\n" + tab2 + "FRONT = MP[NY + DY][NX + DX]"
if behave == ">":
ret += "\n" + tab + "DIRECT = (DIRECT + 1) % 4"
ret += "\n" + tab + "DX, DY = VEC[DIRECT]"
ret += "\n" + tab + "FRONT = MP[Y + DY][X + DX]"
if behave == "<":
ret += "\n" + tab + "DIRECT = (DIRECT - 1) % 4"
ret += "\n" + tab + "DX, DY = VEC[DIRECT]"
ret += "\n" + tab + "FRONT = MP[Y + DY][X + DX]"
ret += "\n" + tab + "CNT += 1\n"
return ret
h, w = map(int, input().split())
MP = [input() for _ in range(h)]
for y in range(h):
for x in range(w):
if MP[y][x] == "s":
X, Y = x, y
FRONT = MP[y - 1][x]
if MP[y][x] == "g":
GX, GY = x, y
DIC = {}
VEC = ((0, -1), (1, 0), (0, 1), (-1, 0))
DIRECT = 0
STATUS = 0
CNT = 0
PROGRAM = "def main(MP, X, Y, GX, GY, FRONT, DIC, VEC, DIRECT, STATUS, CNT):\n" + parse_prog(input(), 0, 1, "")[1] + "main(MP, X, Y, GX, GY, FRONT, DIC, VEC, DIRECT, STATUS, CNT)"
exec(PROGRAM)
``` | instruction | 0 | 43,769 | 11 | 87,538 |
No | output | 1 | 43,769 | 11 | 87,539 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya has come to the math exam and wants to solve as many problems as possible. He prepared and carefully studied the rules by which the exam passes.
The exam consists of n problems that can be solved in T minutes. Thus, the exam begins at time 0 and ends at time T. Petya can leave the exam at any integer time from 0 to T, inclusive.
All problems are divided into two types:
* easy problems β Petya takes exactly a minutes to solve any easy problem;
* hard problems β Petya takes exactly b minutes (b > a) to solve any hard problem.
Thus, if Petya starts solving an easy problem at time x, then it will be solved at time x+a. Similarly, if at a time x Petya starts to solve a hard problem, then it will be solved at time x+b.
For every problem, Petya knows if it is easy or hard. Also, for each problem is determined time t_i (0 β€ t_i β€ T) at which it will become mandatory (required). If Petya leaves the exam at time s and there is such a problem i that t_i β€ s and he didn't solve it, then he will receive 0 points for the whole exam. Otherwise (i.e if he has solved all such problems for which t_i β€ s) he will receive a number of points equal to the number of solved problems. Note that leaving at time s Petya can have both "mandatory" and "non-mandatory" problems solved.
For example, if n=2, T=5, a=2, b=3, the first problem is hard and t_1=3 and the second problem is easy and t_2=2. Then:
* if he leaves at time s=0, then he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=1, he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=2, then he can get a 1 point by solving the problem with the number 2 (it must be solved in the range from 0 to 2);
* if he leaves at time s=3, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=4, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=5, then he can get 2 points by solving all problems.
Thus, the answer to this test is 2.
Help Petya to determine the maximal number of points that he can receive, before leaving the exam.
Input
The first line contains the integer m (1 β€ m β€ 10^4) β the number of test cases in the test.
The next lines contain a description of m test cases.
The first line of each test case contains four integers n, T, a, b (2 β€ n β€ 2β
10^5, 1 β€ T β€ 10^9, 1 β€ a < b β€ 10^9) β the number of problems, minutes given for the exam and the time to solve an easy and hard problem, respectively.
The second line of each test case contains n numbers 0 or 1, separated by single space: the i-th number means the type of the i-th problem. A value of 0 means that the problem is easy, and a value of 1 that the problem is hard.
The third line of each test case contains n integers t_i (0 β€ t_i β€ T), where the i-th number means the time at which the i-th problem will become mandatory.
It is guaranteed that the sum of n for all test cases does not exceed 2β
10^5.
Output
Print the answers to m test cases. For each set, print a single integer β maximal number of points that he can receive, before leaving the exam.
Example
Input
10
3 5 1 3
0 0 1
2 1 4
2 5 2 3
1 0
3 2
1 20 2 4
0
16
6 20 2 5
1 1 0 1 0 0
0 8 2 9 11 6
4 16 3 6
1 0 1 1
8 3 5 6
6 20 3 6
0 1 0 0 1 0
20 11 3 20 16 17
7 17 1 6
1 1 0 1 0 0 0
1 7 0 11 10 15 10
6 17 2 6
0 0 1 0 0 1
7 6 3 7 10 12
5 17 2 5
1 1 1 1 0
17 11 10 6 4
1 1 1 2
0
1
Output
3
2
1
0
1
4
0
1
2
1
Submitted Solution:
```
from sys import stdin
from bisect import bisect_right as leqcount
def input():
return stdin.readline()[:-1]
def intput():
return int(input())
def sinput():
return input().split()
def intsput():
return map(int, sinput())
debugging = 0
def dprint(*args):
if debugging:
print(*args)
else:
pass
# Code
m = intput()
for _ in range(m):
n, T, a, b = intsput()
ishard = list(intsput())
ti = list(intsput())
easy = []
hard = []
for i in range(n):
if ishard[i]:
hard.append(ti[i])
else:
easy.append(ti[i])
ti.sort()
easy.sort()
hard.sort()
dprint(T)
dprint(a, b)
dprint(easy, hard)
dprint()
best = 0
table = {}
searchset = set(ti)
searchset.add(T)
for limitseed in searchset:
for limit in (limitseed, limitseed - 1):
easycnt = leqcount(easy, limit)
hardcnt = leqcount(hard, limit)
reqtime = easycnt * a + hardcnt * b
if reqtime <= limit:
sqeeze = min((limit - reqtime) // a, len(easy) - easycnt)
easycnt += sqeeze
reqtime += sqeeze * a
sqeeze = min((limit - reqtime) // b, len(hard) - hardcnt)
hardcnt += sqeeze
reqtime += sqeeze * b
table[limit] = easycnt + hardcnt
best = max(best, table[limit])
dprint(limit, ':', table[limit], '(', reqtime, ')')
print(best)
dprint()
``` | instruction | 0 | 43,970 | 11 | 87,940 |
Yes | output | 1 | 43,970 | 11 | 87,941 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya has come to the math exam and wants to solve as many problems as possible. He prepared and carefully studied the rules by which the exam passes.
The exam consists of n problems that can be solved in T minutes. Thus, the exam begins at time 0 and ends at time T. Petya can leave the exam at any integer time from 0 to T, inclusive.
All problems are divided into two types:
* easy problems β Petya takes exactly a minutes to solve any easy problem;
* hard problems β Petya takes exactly b minutes (b > a) to solve any hard problem.
Thus, if Petya starts solving an easy problem at time x, then it will be solved at time x+a. Similarly, if at a time x Petya starts to solve a hard problem, then it will be solved at time x+b.
For every problem, Petya knows if it is easy or hard. Also, for each problem is determined time t_i (0 β€ t_i β€ T) at which it will become mandatory (required). If Petya leaves the exam at time s and there is such a problem i that t_i β€ s and he didn't solve it, then he will receive 0 points for the whole exam. Otherwise (i.e if he has solved all such problems for which t_i β€ s) he will receive a number of points equal to the number of solved problems. Note that leaving at time s Petya can have both "mandatory" and "non-mandatory" problems solved.
For example, if n=2, T=5, a=2, b=3, the first problem is hard and t_1=3 and the second problem is easy and t_2=2. Then:
* if he leaves at time s=0, then he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=1, he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=2, then he can get a 1 point by solving the problem with the number 2 (it must be solved in the range from 0 to 2);
* if he leaves at time s=3, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=4, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=5, then he can get 2 points by solving all problems.
Thus, the answer to this test is 2.
Help Petya to determine the maximal number of points that he can receive, before leaving the exam.
Input
The first line contains the integer m (1 β€ m β€ 10^4) β the number of test cases in the test.
The next lines contain a description of m test cases.
The first line of each test case contains four integers n, T, a, b (2 β€ n β€ 2β
10^5, 1 β€ T β€ 10^9, 1 β€ a < b β€ 10^9) β the number of problems, minutes given for the exam and the time to solve an easy and hard problem, respectively.
The second line of each test case contains n numbers 0 or 1, separated by single space: the i-th number means the type of the i-th problem. A value of 0 means that the problem is easy, and a value of 1 that the problem is hard.
The third line of each test case contains n integers t_i (0 β€ t_i β€ T), where the i-th number means the time at which the i-th problem will become mandatory.
It is guaranteed that the sum of n for all test cases does not exceed 2β
10^5.
Output
Print the answers to m test cases. For each set, print a single integer β maximal number of points that he can receive, before leaving the exam.
Example
Input
10
3 5 1 3
0 0 1
2 1 4
2 5 2 3
1 0
3 2
1 20 2 4
0
16
6 20 2 5
1 1 0 1 0 0
0 8 2 9 11 6
4 16 3 6
1 0 1 1
8 3 5 6
6 20 3 6
0 1 0 0 1 0
20 11 3 20 16 17
7 17 1 6
1 1 0 1 0 0 0
1 7 0 11 10 15 10
6 17 2 6
0 0 1 0 0 1
7 6 3 7 10 12
5 17 2 5
1 1 1 1 0
17 11 10 6 4
1 1 1 2
0
1
Output
3
2
1
0
1
4
0
1
2
1
Submitted Solution:
```
import sys
import math
from collections import defaultdict,Counter
# input=sys.stdin.readline
# def print(x):
# sys.stdout.write(str(x)+"\n")
import os
import sys
from io import BytesIO, IOBase
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")
# sys.stdout=open("CP2/output.txt",'w')
# sys.stdin=open("CP2/input.txt",'r')
# mod=pow(10,9)+7
m=int(input())
for i in range(m):
time=[0,0]
n,T,time[0],time[1]=map(int,input().split())
d=[0,0]
c=list(map(int,input().split()))
t=list(map(int,input().split()))
l=[]
for j in range(n):
l.append([t[j],c[j]])
d[c[j]]+=1
l.sort()
# print(l)
# print(pre)
ans=0
l.append([T+1,0])
pre=0
for j in range(n+1):
if j!=n:
d[l[j][1]]-=1
if pre<l[j][0]:
cur=j
left=l[j][0]-1-pre
sml=left//time[0]
# print(d)
if sml>=d[0]:
cur+=d[0]
left-=time[0]*d[0]
big=left//time[1]
cur+=min(d[1],big)
else:
cur+=sml
ans=max(ans,cur)
pre+=time[l[j][1]]
print(ans)
``` | instruction | 0 | 43,971 | 11 | 87,942 |
Yes | output | 1 | 43,971 | 11 | 87,943 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya has come to the math exam and wants to solve as many problems as possible. He prepared and carefully studied the rules by which the exam passes.
The exam consists of n problems that can be solved in T minutes. Thus, the exam begins at time 0 and ends at time T. Petya can leave the exam at any integer time from 0 to T, inclusive.
All problems are divided into two types:
* easy problems β Petya takes exactly a minutes to solve any easy problem;
* hard problems β Petya takes exactly b minutes (b > a) to solve any hard problem.
Thus, if Petya starts solving an easy problem at time x, then it will be solved at time x+a. Similarly, if at a time x Petya starts to solve a hard problem, then it will be solved at time x+b.
For every problem, Petya knows if it is easy or hard. Also, for each problem is determined time t_i (0 β€ t_i β€ T) at which it will become mandatory (required). If Petya leaves the exam at time s and there is such a problem i that t_i β€ s and he didn't solve it, then he will receive 0 points for the whole exam. Otherwise (i.e if he has solved all such problems for which t_i β€ s) he will receive a number of points equal to the number of solved problems. Note that leaving at time s Petya can have both "mandatory" and "non-mandatory" problems solved.
For example, if n=2, T=5, a=2, b=3, the first problem is hard and t_1=3 and the second problem is easy and t_2=2. Then:
* if he leaves at time s=0, then he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=1, he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=2, then he can get a 1 point by solving the problem with the number 2 (it must be solved in the range from 0 to 2);
* if he leaves at time s=3, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=4, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=5, then he can get 2 points by solving all problems.
Thus, the answer to this test is 2.
Help Petya to determine the maximal number of points that he can receive, before leaving the exam.
Input
The first line contains the integer m (1 β€ m β€ 10^4) β the number of test cases in the test.
The next lines contain a description of m test cases.
The first line of each test case contains four integers n, T, a, b (2 β€ n β€ 2β
10^5, 1 β€ T β€ 10^9, 1 β€ a < b β€ 10^9) β the number of problems, minutes given for the exam and the time to solve an easy and hard problem, respectively.
The second line of each test case contains n numbers 0 or 1, separated by single space: the i-th number means the type of the i-th problem. A value of 0 means that the problem is easy, and a value of 1 that the problem is hard.
The third line of each test case contains n integers t_i (0 β€ t_i β€ T), where the i-th number means the time at which the i-th problem will become mandatory.
It is guaranteed that the sum of n for all test cases does not exceed 2β
10^5.
Output
Print the answers to m test cases. For each set, print a single integer β maximal number of points that he can receive, before leaving the exam.
Example
Input
10
3 5 1 3
0 0 1
2 1 4
2 5 2 3
1 0
3 2
1 20 2 4
0
16
6 20 2 5
1 1 0 1 0 0
0 8 2 9 11 6
4 16 3 6
1 0 1 1
8 3 5 6
6 20 3 6
0 1 0 0 1 0
20 11 3 20 16 17
7 17 1 6
1 1 0 1 0 0 0
1 7 0 11 10 15 10
6 17 2 6
0 0 1 0 0 1
7 6 3 7 10 12
5 17 2 5
1 1 1 1 0
17 11 10 6 4
1 1 1 2
0
1
Output
3
2
1
0
1
4
0
1
2
1
Submitted Solution:
```
"""t=int(input())
for _ in range(t):
n,T,a,b=map(int,input().split())
h1=[int(x) for x in input().split()]
h2=[int(x) for x in input().split()]
h=sorted(zip(h2,h1))
#print(h)
ans=max(0,min((h[0][0]-1)//a,h1.count(0)))
tot=0
c=0
for i in range(0,len(h)):
if(h[i][0]<=tot):
if(h[i][1]==1):
tot+=b
else:
tot+=a
else:
ans=max(ans,c)
c+=1
if(h[i][1]==1):
tot+=b
else:
tot+=a
if(tot<=T):
ans=max(ans,c)
print(ans)"""
t=int(input())
for _ in range(t):
n,T,a,b=map(int,input().split())
h1=[int(x) for x in input().split()]
h2=[int(x) for x in input().split()]
h1.append(0)
h2.append(T+1)
h=sorted(zip(h2,h1))
c0=h1.count(0)-1
c1=h1.count(1)
ans=0
ptr=0
man=0
c=0
for i in range(0,len(h)):
brk=h[i][0]-1
ex=max(0,brk-man)
ex_task=0
t1=min(c0,(ex//a))
ex-=t1*a
t2=min(c1,(ex//b))
ex-=t2*b
ex_task+=t1+t2
if(brk>=man):
ans=max(ans,ex_task+i)
if(h[i][1]==1):
man+=b
c1-=1
else:
man+=a
c0-=1
print(ans)
``` | instruction | 0 | 43,972 | 11 | 87,944 |
Yes | output | 1 | 43,972 | 11 | 87,945 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya has come to the math exam and wants to solve as many problems as possible. He prepared and carefully studied the rules by which the exam passes.
The exam consists of n problems that can be solved in T minutes. Thus, the exam begins at time 0 and ends at time T. Petya can leave the exam at any integer time from 0 to T, inclusive.
All problems are divided into two types:
* easy problems β Petya takes exactly a minutes to solve any easy problem;
* hard problems β Petya takes exactly b minutes (b > a) to solve any hard problem.
Thus, if Petya starts solving an easy problem at time x, then it will be solved at time x+a. Similarly, if at a time x Petya starts to solve a hard problem, then it will be solved at time x+b.
For every problem, Petya knows if it is easy or hard. Also, for each problem is determined time t_i (0 β€ t_i β€ T) at which it will become mandatory (required). If Petya leaves the exam at time s and there is such a problem i that t_i β€ s and he didn't solve it, then he will receive 0 points for the whole exam. Otherwise (i.e if he has solved all such problems for which t_i β€ s) he will receive a number of points equal to the number of solved problems. Note that leaving at time s Petya can have both "mandatory" and "non-mandatory" problems solved.
For example, if n=2, T=5, a=2, b=3, the first problem is hard and t_1=3 and the second problem is easy and t_2=2. Then:
* if he leaves at time s=0, then he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=1, he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=2, then he can get a 1 point by solving the problem with the number 2 (it must be solved in the range from 0 to 2);
* if he leaves at time s=3, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=4, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=5, then he can get 2 points by solving all problems.
Thus, the answer to this test is 2.
Help Petya to determine the maximal number of points that he can receive, before leaving the exam.
Input
The first line contains the integer m (1 β€ m β€ 10^4) β the number of test cases in the test.
The next lines contain a description of m test cases.
The first line of each test case contains four integers n, T, a, b (2 β€ n β€ 2β
10^5, 1 β€ T β€ 10^9, 1 β€ a < b β€ 10^9) β the number of problems, minutes given for the exam and the time to solve an easy and hard problem, respectively.
The second line of each test case contains n numbers 0 or 1, separated by single space: the i-th number means the type of the i-th problem. A value of 0 means that the problem is easy, and a value of 1 that the problem is hard.
The third line of each test case contains n integers t_i (0 β€ t_i β€ T), where the i-th number means the time at which the i-th problem will become mandatory.
It is guaranteed that the sum of n for all test cases does not exceed 2β
10^5.
Output
Print the answers to m test cases. For each set, print a single integer β maximal number of points that he can receive, before leaving the exam.
Example
Input
10
3 5 1 3
0 0 1
2 1 4
2 5 2 3
1 0
3 2
1 20 2 4
0
16
6 20 2 5
1 1 0 1 0 0
0 8 2 9 11 6
4 16 3 6
1 0 1 1
8 3 5 6
6 20 3 6
0 1 0 0 1 0
20 11 3 20 16 17
7 17 1 6
1 1 0 1 0 0 0
1 7 0 11 10 15 10
6 17 2 6
0 0 1 0 0 1
7 6 3 7 10 12
5 17 2 5
1 1 1 1 0
17 11 10 6 4
1 1 1 2
0
1
Output
3
2
1
0
1
4
0
1
2
1
Submitted Solution:
```
import sys
input=sys.stdin.readline
t=int(input())
for i in range(t):
n,T,a,b=map(int,input().split())
level=[int(i) for i in input().split()]
time=[int(i) for i in input().split()]
diff=zip(time,level)
diff=sorted(diff)
#print(diff)
easy=level.count(0)
hard=n-easy
if (easy*a+hard*b)<=T:
print(n)
else:
time=0
question=0
last=0
hard1=0
for i in range(len(diff)):
#print('tdql',time,diff[i][0],question,last)
if diff[i][0]>time:
#print('lq',last,question)
#question=max(last,question)
new_time=(diff[i][0]-1-time)//a
#print('new_time',new_time)
new_time=min(new_time,easy)
#print('nq',new_time+last,question)
question=max(question,new_time+last)
if diff[i][1]==0 :
time+=a
easy-=1
last+=1
elif diff[i][1]==1 :
time+=b
last+=1
print(question)
``` | instruction | 0 | 43,973 | 11 | 87,946 |
Yes | output | 1 | 43,973 | 11 | 87,947 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.