message stringlengths 2 433k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p_1, p_2, ..., p_n. A permutation of length n is a sequence such that each integer between 1 and n occurs exactly once in the sequence.
Find the number of pairs of indices (l, r) (1 ≤ l ≤ r ≤ n) such that the value of the median of p_l, p_{l+1}, ..., p_r is exactly the given number m.
The median of a sequence is the value of the element which is in the middle of the sequence after sorting it in non-decreasing order. If the length of the sequence is even, the left of two middle elements is used.
For example, if a=[4, 2, 7, 5] then its median is 4 since after sorting the sequence, it will look like [2, 4, 5, 7] and the left of two middle elements is equal to 4. The median of [7, 1, 2, 9, 6] equals 6 since after sorting, the value 6 will be in the middle of the sequence.
Write a program to find the number of pairs of indices (l, r) (1 ≤ l ≤ r ≤ n) such that the value of the median of p_l, p_{l+1}, ..., p_r is exactly the given number m.
Input
The first line contains integers n and m (1 ≤ n ≤ 2⋅10^5, 1 ≤ m ≤ n) — the length of the given sequence and the required value of the median.
The second line contains a permutation p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). Each integer between 1 and n occurs in p exactly once.
Output
Print the required number.
Examples
Input
5 4
2 4 5 3 1
Output
4
Input
5 5
1 2 3 4 5
Output
1
Input
15 8
1 15 2 14 3 13 4 8 12 5 11 6 10 7 9
Output
48
Note
In the first example, the suitable pairs of indices are: (1, 3), (2, 2), (2, 3) and (2, 4).
Submitted Solution:
```
def ask(x):
s={}
s[0]=1
sum,cnt,res=0,0,0
for i in range(n):
if(a[i]<x):
sum-=1
cnt-=s.get(sum,0)
else:
cnt+=s.get(sum,0)
sum+=1
s[sum]=s.get(sum,0)+1
res+=cnt
return res
n,m=map(int,input().split())
a=list(map(int,input().split()))
print(ask(m)-ask(m+1))
``` | instruction | 0 | 39,595 | 12 | 79,190 |
Yes | output | 1 | 39,595 | 12 | 79,191 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p_1, p_2, ..., p_n. A permutation of length n is a sequence such that each integer between 1 and n occurs exactly once in the sequence.
Find the number of pairs of indices (l, r) (1 ≤ l ≤ r ≤ n) such that the value of the median of p_l, p_{l+1}, ..., p_r is exactly the given number m.
The median of a sequence is the value of the element which is in the middle of the sequence after sorting it in non-decreasing order. If the length of the sequence is even, the left of two middle elements is used.
For example, if a=[4, 2, 7, 5] then its median is 4 since after sorting the sequence, it will look like [2, 4, 5, 7] and the left of two middle elements is equal to 4. The median of [7, 1, 2, 9, 6] equals 6 since after sorting, the value 6 will be in the middle of the sequence.
Write a program to find the number of pairs of indices (l, r) (1 ≤ l ≤ r ≤ n) such that the value of the median of p_l, p_{l+1}, ..., p_r is exactly the given number m.
Input
The first line contains integers n and m (1 ≤ n ≤ 2⋅10^5, 1 ≤ m ≤ n) — the length of the given sequence and the required value of the median.
The second line contains a permutation p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). Each integer between 1 and n occurs in p exactly once.
Output
Print the required number.
Examples
Input
5 4
2 4 5 3 1
Output
4
Input
5 5
1 2 3 4 5
Output
1
Input
15 8
1 15 2 14 3 13 4 8 12 5 11 6 10 7 9
Output
48
Note
In the first example, the suitable pairs of indices are: (1, 3), (2, 2), (2, 3) and (2, 4).
Submitted Solution:
```
n,m=map(int,input().split())
s=list(map(int,input().split()))
ind=s.index(m)
dp=[0 for i in range(n)]
for i in range(n):
if s[i]<m:
dp[i]=dp[i-1]-1
elif s[i]>m:
dp[i]=dp[i-1]+1
d=dict()
for i in range(ind+1,n):
try:
d[dp[i]]+=1
except:
d.update({dp[i]:1})
ans=0
for i in range(ind+1):
x=-dp[i]
try:
ans+=d[x]
except:
True
try:
ans+=d[x+1]
except:
True
if dp[i]==0 or dp[i]==1:
ans+=1
print(ans)
``` | instruction | 0 | 39,596 | 12 | 79,192 |
No | output | 1 | 39,596 | 12 | 79,193 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p_1, p_2, ..., p_n. A permutation of length n is a sequence such that each integer between 1 and n occurs exactly once in the sequence.
Find the number of pairs of indices (l, r) (1 ≤ l ≤ r ≤ n) such that the value of the median of p_l, p_{l+1}, ..., p_r is exactly the given number m.
The median of a sequence is the value of the element which is in the middle of the sequence after sorting it in non-decreasing order. If the length of the sequence is even, the left of two middle elements is used.
For example, if a=[4, 2, 7, 5] then its median is 4 since after sorting the sequence, it will look like [2, 4, 5, 7] and the left of two middle elements is equal to 4. The median of [7, 1, 2, 9, 6] equals 6 since after sorting, the value 6 will be in the middle of the sequence.
Write a program to find the number of pairs of indices (l, r) (1 ≤ l ≤ r ≤ n) such that the value of the median of p_l, p_{l+1}, ..., p_r is exactly the given number m.
Input
The first line contains integers n and m (1 ≤ n ≤ 2⋅10^5, 1 ≤ m ≤ n) — the length of the given sequence and the required value of the median.
The second line contains a permutation p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). Each integer between 1 and n occurs in p exactly once.
Output
Print the required number.
Examples
Input
5 4
2 4 5 3 1
Output
4
Input
5 5
1 2 3 4 5
Output
1
Input
15 8
1 15 2 14 3 13 4 8 12 5 11 6 10 7 9
Output
48
Note
In the first example, the suitable pairs of indices are: (1, 3), (2, 2), (2, 3) and (2, 4).
Submitted Solution:
```
from collections import defaultdict
def main():
n, m = map(int, input().split())
a = list(map(int, input().split()))
hasm = False
d = defaultdict(int)
d[0] = 1
s = 0
res = 0
for i in range(m):
if a[i] > m:
s += 1
if a[i] < m:
s -= 1
if a[i] == m:
hasm = True
if hasm:
res += d[s] + d[s-1]
else:
d[s] += 1
print(res)
if __name__ == '__main__':
main()
``` | instruction | 0 | 39,597 | 12 | 79,194 |
No | output | 1 | 39,597 | 12 | 79,195 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p_1, p_2, ..., p_n. A permutation of length n is a sequence such that each integer between 1 and n occurs exactly once in the sequence.
Find the number of pairs of indices (l, r) (1 ≤ l ≤ r ≤ n) such that the value of the median of p_l, p_{l+1}, ..., p_r is exactly the given number m.
The median of a sequence is the value of the element which is in the middle of the sequence after sorting it in non-decreasing order. If the length of the sequence is even, the left of two middle elements is used.
For example, if a=[4, 2, 7, 5] then its median is 4 since after sorting the sequence, it will look like [2, 4, 5, 7] and the left of two middle elements is equal to 4. The median of [7, 1, 2, 9, 6] equals 6 since after sorting, the value 6 will be in the middle of the sequence.
Write a program to find the number of pairs of indices (l, r) (1 ≤ l ≤ r ≤ n) such that the value of the median of p_l, p_{l+1}, ..., p_r is exactly the given number m.
Input
The first line contains integers n and m (1 ≤ n ≤ 2⋅10^5, 1 ≤ m ≤ n) — the length of the given sequence and the required value of the median.
The second line contains a permutation p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). Each integer between 1 and n occurs in p exactly once.
Output
Print the required number.
Examples
Input
5 4
2 4 5 3 1
Output
4
Input
5 5
1 2 3 4 5
Output
1
Input
15 8
1 15 2 14 3 13 4 8 12 5 11 6 10 7 9
Output
48
Note
In the first example, the suitable pairs of indices are: (1, 3), (2, 2), (2, 3) and (2, 4).
Submitted Solution:
```
n, m = list(map(int,input().split()))
p = list(map(int,input().split()))
mindex = p.index(m)
ldict = {}
rdict = {}
diff = 0
ans = 0
ldict[0] = 1
rdict[0] = 1
for i in range(0,mindex):
if p[i] < m:
diff-=1
else:
diff+=1
if diff in ldict.keys():
ldict[diff] += 1
else:
ldict[diff] = 1
diff = 0
for i in range(mindex+1,n):
if p[i] < m:
diff-=1
else:
diff+=1
if diff in rdict.keys():
rdict[diff] += 1
else:
rdict[diff] = 1
ldictkey = ldict.keys()
for num in ldictkey:
if -num in rdict.keys():
ans += ldict[num] * rdict[-num]
if -num+1 in rdict.keys():
ans += ldict[num] * rdict[-num+1]
print(ans)
``` | instruction | 0 | 39,598 | 12 | 79,196 |
No | output | 1 | 39,598 | 12 | 79,197 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p_1, p_2, ..., p_n. A permutation of length n is a sequence such that each integer between 1 and n occurs exactly once in the sequence.
Find the number of pairs of indices (l, r) (1 ≤ l ≤ r ≤ n) such that the value of the median of p_l, p_{l+1}, ..., p_r is exactly the given number m.
The median of a sequence is the value of the element which is in the middle of the sequence after sorting it in non-decreasing order. If the length of the sequence is even, the left of two middle elements is used.
For example, if a=[4, 2, 7, 5] then its median is 4 since after sorting the sequence, it will look like [2, 4, 5, 7] and the left of two middle elements is equal to 4. The median of [7, 1, 2, 9, 6] equals 6 since after sorting, the value 6 will be in the middle of the sequence.
Write a program to find the number of pairs of indices (l, r) (1 ≤ l ≤ r ≤ n) such that the value of the median of p_l, p_{l+1}, ..., p_r is exactly the given number m.
Input
The first line contains integers n and m (1 ≤ n ≤ 2⋅10^5, 1 ≤ m ≤ n) — the length of the given sequence and the required value of the median.
The second line contains a permutation p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). Each integer between 1 and n occurs in p exactly once.
Output
Print the required number.
Examples
Input
5 4
2 4 5 3 1
Output
4
Input
5 5
1 2 3 4 5
Output
1
Input
15 8
1 15 2 14 3 13 4 8 12 5 11 6 10 7 9
Output
48
Note
In the first example, the suitable pairs of indices are: (1, 3), (2, 2), (2, 3) and (2, 4).
Submitted Solution:
```
n, m = map(int, input().split(' '))
aa = list(map(int, input().split(' ')))
def countMoreLess(vs, value):
#print(vs)
cur = 0
res = { cur: 1 }
for v in vs:
cur += 1 if v > value else -1
res[cur] = res.get(cur, 0) + 1
#print(res)
return res
pos = aa.index(m)
leftCounts = countMoreLess(aa[pos-1::-1], m)
rightCounts = countMoreLess(aa[pos+1:], m)
res = 0
for dif, count in leftCounts.items():
res += count * rightCounts.get(-dif, 0)
res += count * rightCounts.get(-dif+1, 0)
print(res)
``` | instruction | 0 | 39,599 | 12 | 79,198 |
No | output | 1 | 39,599 | 12 | 79,199 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n segments on a number line; each endpoint of every segment has integer coordinates. Some segments can degenerate to points. Segments can intersect with each other, be nested in each other or even coincide.
The intersection of a sequence of segments is such a maximal set of points (not necesserily having integer coordinates) that each point lies within every segment from the sequence. If the resulting set isn't empty, then it always forms some continuous segment. The length of the intersection is the length of the resulting segment or 0 in case the intersection is an empty set.
For example, the intersection of segments [1;5] and [3;10] is [3;5] (length 2), the intersection of segments [1;5] and [5;7] is [5;5] (length 0) and the intersection of segments [1;5] and [6;6] is an empty set (length 0).
Your task is to remove exactly one segment from the given sequence in such a way that the intersection of the remaining (n - 1) segments has the maximal possible length.
Input
The first line contains a single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of segments in the sequence.
Each of the next n lines contains two integers l_i and r_i (0 ≤ l_i ≤ r_i ≤ 10^9) — the description of the i-th segment.
Output
Print a single integer — the maximal possible length of the intersection of (n - 1) remaining segments after you remove exactly one segment from the sequence.
Examples
Input
4
1 3
2 6
0 4
3 3
Output
1
Input
5
2 6
1 3
0 4
1 20
0 4
Output
2
Input
3
4 5
1 2
9 20
Output
0
Input
2
3 10
1 5
Output
7
Note
In the first example you should remove the segment [3;3], the intersection will become [2;3] (length 1). Removing any other segment will result in the intersection [3;3] (length 0).
In the second example you should remove the segment [1;3] or segment [2;6], the intersection will become [2;4] (length 2) or [1;3] (length 2), respectively. Removing any other segment will result in the intersection [2;3] (length 1).
In the third example the intersection will become an empty set no matter the segment you remove.
In the fourth example you will get the intersection [3;10] (length 7) if you remove the segment [1;5] or the intersection [1;5] (length 4) if you remove the segment [3;10]. | instruction | 0 | 39,600 | 12 | 79,200 |
Tags: greedy, math, sortings
Correct Solution:
```
# -*- coding: utf-8 -*-
import sys
from itertools import accumulate
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 10 ** 9 + 7
def compress(S):
zipped, unzipped = {}, {}
for i, a in enumerate(sorted(S)):
zipped[a] = i
unzipped[i] = a
return zipped, unzipped
N = INT()
S = set()
LR = []
for _ in range(N):
l, r = MAP()
S.add(l)
S.add(r)
LR.append((l, r))
zipped, unzipped = compress(S)
M = len(zipped)
for i in range(N):
l, r = LR[i]
LR[i] = (zipped[l], zipped[r])
W = [0] * M
for i in range(M-1):
W[i] = unzipped[i+1] - unzipped[i]
imos = [0] * M
for l, r in LR:
imos[l] += 1
imos[r] -= 1
imos = list(accumulate(imos))
acc1 = [0] * M
acc2 = [0] * M
for i in range(M):
if imos[i] == N:
acc1[i] = W[i]
elif imos[i] == N-1:
acc2[i] = W[i]
acc1 = [0] + list(accumulate(acc1))
acc2 = [0] + list(accumulate(acc2))
ans = 0
for l, r in LR:
seg1 = acc1[r] - acc1[l]
seg2 = acc2[r] - acc2[l]
ans = max(ans, acc2[-1] + seg1 - seg2)
print(ans)
``` | output | 1 | 39,600 | 12 | 79,201 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n segments on a number line; each endpoint of every segment has integer coordinates. Some segments can degenerate to points. Segments can intersect with each other, be nested in each other or even coincide.
The intersection of a sequence of segments is such a maximal set of points (not necesserily having integer coordinates) that each point lies within every segment from the sequence. If the resulting set isn't empty, then it always forms some continuous segment. The length of the intersection is the length of the resulting segment or 0 in case the intersection is an empty set.
For example, the intersection of segments [1;5] and [3;10] is [3;5] (length 2), the intersection of segments [1;5] and [5;7] is [5;5] (length 0) and the intersection of segments [1;5] and [6;6] is an empty set (length 0).
Your task is to remove exactly one segment from the given sequence in such a way that the intersection of the remaining (n - 1) segments has the maximal possible length.
Input
The first line contains a single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of segments in the sequence.
Each of the next n lines contains two integers l_i and r_i (0 ≤ l_i ≤ r_i ≤ 10^9) — the description of the i-th segment.
Output
Print a single integer — the maximal possible length of the intersection of (n - 1) remaining segments after you remove exactly one segment from the sequence.
Examples
Input
4
1 3
2 6
0 4
3 3
Output
1
Input
5
2 6
1 3
0 4
1 20
0 4
Output
2
Input
3
4 5
1 2
9 20
Output
0
Input
2
3 10
1 5
Output
7
Note
In the first example you should remove the segment [3;3], the intersection will become [2;3] (length 1). Removing any other segment will result in the intersection [3;3] (length 0).
In the second example you should remove the segment [1;3] or segment [2;6], the intersection will become [2;4] (length 2) or [1;3] (length 2), respectively. Removing any other segment will result in the intersection [2;3] (length 1).
In the third example the intersection will become an empty set no matter the segment you remove.
In the fourth example you will get the intersection [3;10] (length 7) if you remove the segment [1;5] or the intersection [1;5] (length 4) if you remove the segment [3;10]. | instruction | 0 | 39,601 | 12 | 79,202 |
Tags: greedy, math, sortings
Correct Solution:
```
n = int(input())
ls, rs = [0] * n, [0] * n
for i in range(n):
ls[i], rs[i] = map(int, input().split(' '))
l1 = max(ls)
l1i = ls.index(l1)
l2 = max(ls[:l1i] + ls[l1i+1:])
r1 = min(rs)
r1i = rs.index(r1)
r2 = min(rs[:r1i] + rs[r1i+1:])
res = max(0, r1 - l1)
for i in range(n):
l = l1 if i != l1i else l2
r = r1 if i != r1i else r2
cur = max(0, r - l)
res = max(res, cur)
print(res)
``` | output | 1 | 39,601 | 12 | 79,203 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n segments on a number line; each endpoint of every segment has integer coordinates. Some segments can degenerate to points. Segments can intersect with each other, be nested in each other or even coincide.
The intersection of a sequence of segments is such a maximal set of points (not necesserily having integer coordinates) that each point lies within every segment from the sequence. If the resulting set isn't empty, then it always forms some continuous segment. The length of the intersection is the length of the resulting segment or 0 in case the intersection is an empty set.
For example, the intersection of segments [1;5] and [3;10] is [3;5] (length 2), the intersection of segments [1;5] and [5;7] is [5;5] (length 0) and the intersection of segments [1;5] and [6;6] is an empty set (length 0).
Your task is to remove exactly one segment from the given sequence in such a way that the intersection of the remaining (n - 1) segments has the maximal possible length.
Input
The first line contains a single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of segments in the sequence.
Each of the next n lines contains two integers l_i and r_i (0 ≤ l_i ≤ r_i ≤ 10^9) — the description of the i-th segment.
Output
Print a single integer — the maximal possible length of the intersection of (n - 1) remaining segments after you remove exactly one segment from the sequence.
Examples
Input
4
1 3
2 6
0 4
3 3
Output
1
Input
5
2 6
1 3
0 4
1 20
0 4
Output
2
Input
3
4 5
1 2
9 20
Output
0
Input
2
3 10
1 5
Output
7
Note
In the first example you should remove the segment [3;3], the intersection will become [2;3] (length 1). Removing any other segment will result in the intersection [3;3] (length 0).
In the second example you should remove the segment [1;3] or segment [2;6], the intersection will become [2;4] (length 2) or [1;3] (length 2), respectively. Removing any other segment will result in the intersection [2;3] (length 1).
In the third example the intersection will become an empty set no matter the segment you remove.
In the fourth example you will get the intersection [3;10] (length 7) if you remove the segment [1;5] or the intersection [1;5] (length 4) if you remove the segment [3;10]. | instruction | 0 | 39,602 | 12 | 79,204 |
Tags: greedy, math, sortings
Correct Solution:
```
# import itertools
# import bisect
# import math
from collections import defaultdict
import os
import sys
from io import BytesIO, IOBase
# sys.setrecursionlimit(10 ** 5)
ii = lambda: int(input())
lmii = lambda: list(map(int, input().split()))
slmii = lambda: sorted(map(int, input().split()))
li = lambda: list(input())
mii = lambda: map(int, input().split())
msi = lambda: map(str, input().split())
def gcd(a, b):
if b == 0: return a
return gcd(b, a % b)
def lcm(a, b): return (a * b) // gcd(a, b)
def main():
# for _ in " " * int(input()):
n = ii()
d = defaultdict(int)
ll = defaultdict(list)
rr = defaultdict(list)
llst = []
rlst = []
lst = []
for i in range(n):
l, r = mii()
lst.append([l,r])
llst.append(l)
rlst.append(r)
ll[l].append(r)
rr[r].append(l)
left = max(llst)
right = min(rlst)
lleft = min(ll[left])
lright = max(rr[right])
lst.remove([left,lleft])
pl = max(i[0] for i in lst)
pr = min(i[1] for i in lst)
mx = max(0,pr-pl)
lst.append([left,lleft])
lst.remove([lright,right])
pl = max(i[0] for i in lst)
pr = min(i[1] for i in lst)
print(max(mx, max(0,pr-pl)))
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | output | 1 | 39,602 | 12 | 79,205 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n segments on a number line; each endpoint of every segment has integer coordinates. Some segments can degenerate to points. Segments can intersect with each other, be nested in each other or even coincide.
The intersection of a sequence of segments is such a maximal set of points (not necesserily having integer coordinates) that each point lies within every segment from the sequence. If the resulting set isn't empty, then it always forms some continuous segment. The length of the intersection is the length of the resulting segment or 0 in case the intersection is an empty set.
For example, the intersection of segments [1;5] and [3;10] is [3;5] (length 2), the intersection of segments [1;5] and [5;7] is [5;5] (length 0) and the intersection of segments [1;5] and [6;6] is an empty set (length 0).
Your task is to remove exactly one segment from the given sequence in such a way that the intersection of the remaining (n - 1) segments has the maximal possible length.
Input
The first line contains a single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of segments in the sequence.
Each of the next n lines contains two integers l_i and r_i (0 ≤ l_i ≤ r_i ≤ 10^9) — the description of the i-th segment.
Output
Print a single integer — the maximal possible length of the intersection of (n - 1) remaining segments after you remove exactly one segment from the sequence.
Examples
Input
4
1 3
2 6
0 4
3 3
Output
1
Input
5
2 6
1 3
0 4
1 20
0 4
Output
2
Input
3
4 5
1 2
9 20
Output
0
Input
2
3 10
1 5
Output
7
Note
In the first example you should remove the segment [3;3], the intersection will become [2;3] (length 1). Removing any other segment will result in the intersection [3;3] (length 0).
In the second example you should remove the segment [1;3] or segment [2;6], the intersection will become [2;4] (length 2) or [1;3] (length 2), respectively. Removing any other segment will result in the intersection [2;3] (length 1).
In the third example the intersection will become an empty set no matter the segment you remove.
In the fourth example you will get the intersection [3;10] (length 7) if you remove the segment [1;5] or the intersection [1;5] (length 4) if you remove the segment [3;10]. | instruction | 0 | 39,603 | 12 | 79,206 |
Tags: greedy, math, sortings
Correct Solution:
```
def sol():
n = int(input())
l_list = []
r_list = []
maxl_from_left = [0]
maxl_from_right = [0]
minr_from_left = [2147483647]
minr_from_right = [2147483647]
for i in range(n):
x,y = [int(x) for x in input().split()]
l_list.append(x)
r_list.append(y)
for i in range(n):
maxl_from_left.append(max(maxl_from_left[-1],l_list[i]))
minr_from_left.append(min(minr_from_left[-1],r_list[i]))
for i in range(n-1,-1,-1):
maxl_from_right.append(max(maxl_from_right[-1],l_list[i]))
minr_from_right.append(min(minr_from_right[-1],r_list[i]))
maxl_from_left = maxl_from_left[1:]
minr_from_left = minr_from_left[1:]
maxl_from_right = maxl_from_right[::-1][:-1]
minr_from_right = minr_from_right[::-1][:-1]
ans = 0
for i in range(n):
ll = 0
lr = i-1
rl = i+1
rr = n-1
if ll>lr:
l_part = (-1,2147483647)
else:
l_part = (maxl_from_left[lr], minr_from_left[lr])
if rl>rr:
r_part = (-1, 2147483647)
else:
r_part = (maxl_from_right[rl], minr_from_right[rl])
l = max(l_part[0], r_part[0])
r = min(l_part[1], r_part[1])
ans = max(ans, r-l)
print(ans)
if __name__ == "__main__":
sol()
``` | output | 1 | 39,603 | 12 | 79,207 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n segments on a number line; each endpoint of every segment has integer coordinates. Some segments can degenerate to points. Segments can intersect with each other, be nested in each other or even coincide.
The intersection of a sequence of segments is such a maximal set of points (not necesserily having integer coordinates) that each point lies within every segment from the sequence. If the resulting set isn't empty, then it always forms some continuous segment. The length of the intersection is the length of the resulting segment or 0 in case the intersection is an empty set.
For example, the intersection of segments [1;5] and [3;10] is [3;5] (length 2), the intersection of segments [1;5] and [5;7] is [5;5] (length 0) and the intersection of segments [1;5] and [6;6] is an empty set (length 0).
Your task is to remove exactly one segment from the given sequence in such a way that the intersection of the remaining (n - 1) segments has the maximal possible length.
Input
The first line contains a single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of segments in the sequence.
Each of the next n lines contains two integers l_i and r_i (0 ≤ l_i ≤ r_i ≤ 10^9) — the description of the i-th segment.
Output
Print a single integer — the maximal possible length of the intersection of (n - 1) remaining segments after you remove exactly one segment from the sequence.
Examples
Input
4
1 3
2 6
0 4
3 3
Output
1
Input
5
2 6
1 3
0 4
1 20
0 4
Output
2
Input
3
4 5
1 2
9 20
Output
0
Input
2
3 10
1 5
Output
7
Note
In the first example you should remove the segment [3;3], the intersection will become [2;3] (length 1). Removing any other segment will result in the intersection [3;3] (length 0).
In the second example you should remove the segment [1;3] or segment [2;6], the intersection will become [2;4] (length 2) or [1;3] (length 2), respectively. Removing any other segment will result in the intersection [2;3] (length 1).
In the third example the intersection will become an empty set no matter the segment you remove.
In the fourth example you will get the intersection [3;10] (length 7) if you remove the segment [1;5] or the intersection [1;5] (length 4) if you remove the segment [3;10]. | instruction | 0 | 39,604 | 12 | 79,208 |
Tags: greedy, math, sortings
Correct Solution:
```
from sys import stdin
n = int(stdin.readline())
a = []
max_l = 0
min_r = 10000000000
for i in range(n):
l,r = map(int,stdin.readline().split())
a.append((l,r))
max_l = max(l,max_l)
min_r = min(r, min_r)
l_ans = 10000000000
li = 0
r_ans = 10000000000
ri = 0
for i in range(n):
if a[i][0] == max_l:
if a[i][1]-max_l < l_ans:
l_ans = a[i][1]-max_l
li = i
if a[i][1] == min_r:
if min_r-a[i][0] < r_ans:
r_ans = min_r-a[i][0]
ri = i
max_l = 0
min_r = 10000000000
for i in range(len(a)):
if i == li: continue
max_l = max(a[i][0],max_l)
min_r = min(a[i][1], min_r)
ans=min_r-max_l
max_l = 0
min_r = 10000000000
for i in range(len(a)):
if i == ri: continue
max_l = max(a[i][0],max_l)
min_r = min(a[i][1], min_r)
ans=max(ans,min_r-max_l)
if ans>0:
print(ans)
else:
print('0')
``` | output | 1 | 39,604 | 12 | 79,209 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n segments on a number line; each endpoint of every segment has integer coordinates. Some segments can degenerate to points. Segments can intersect with each other, be nested in each other or even coincide.
The intersection of a sequence of segments is such a maximal set of points (not necesserily having integer coordinates) that each point lies within every segment from the sequence. If the resulting set isn't empty, then it always forms some continuous segment. The length of the intersection is the length of the resulting segment or 0 in case the intersection is an empty set.
For example, the intersection of segments [1;5] and [3;10] is [3;5] (length 2), the intersection of segments [1;5] and [5;7] is [5;5] (length 0) and the intersection of segments [1;5] and [6;6] is an empty set (length 0).
Your task is to remove exactly one segment from the given sequence in such a way that the intersection of the remaining (n - 1) segments has the maximal possible length.
Input
The first line contains a single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of segments in the sequence.
Each of the next n lines contains two integers l_i and r_i (0 ≤ l_i ≤ r_i ≤ 10^9) — the description of the i-th segment.
Output
Print a single integer — the maximal possible length of the intersection of (n - 1) remaining segments after you remove exactly one segment from the sequence.
Examples
Input
4
1 3
2 6
0 4
3 3
Output
1
Input
5
2 6
1 3
0 4
1 20
0 4
Output
2
Input
3
4 5
1 2
9 20
Output
0
Input
2
3 10
1 5
Output
7
Note
In the first example you should remove the segment [3;3], the intersection will become [2;3] (length 1). Removing any other segment will result in the intersection [3;3] (length 0).
In the second example you should remove the segment [1;3] or segment [2;6], the intersection will become [2;4] (length 2) or [1;3] (length 2), respectively. Removing any other segment will result in the intersection [2;3] (length 1).
In the third example the intersection will become an empty set no matter the segment you remove.
In the fourth example you will get the intersection [3;10] (length 7) if you remove the segment [1;5] or the intersection [1;5] (length 4) if you remove the segment [3;10]. | instruction | 0 | 39,605 | 12 | 79,210 |
Tags: greedy, math, sortings
Correct Solution:
```
n = int(input())
l = [0]*n
r = [0]*n
for i in range(n):
l[i], r[i] = map(int,input().split())
pl = [-int(2e9)]*(n+1)
pr = [int(2e9)]*(n+1)
for i in range(n):
pl[i+1] = max(pl[i], l[i])
pr[i+1] = min(pr[i], r[i])
sl = [-int(2e9)]*(n+1)
sr = [int(2e9)]*(n+1)
res = 0
for i in range(n-1,-1,-1):
sl[i] = max(sl[i+1], l[i])
sr[i] = min(sr[i+1], r[i])
ll = max(pl[i], sl[i+1])
rr = min(pr[i], sr[i+1])
res = max(res, rr-ll)
print(res)
``` | output | 1 | 39,605 | 12 | 79,211 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n segments on a number line; each endpoint of every segment has integer coordinates. Some segments can degenerate to points. Segments can intersect with each other, be nested in each other or even coincide.
The intersection of a sequence of segments is such a maximal set of points (not necesserily having integer coordinates) that each point lies within every segment from the sequence. If the resulting set isn't empty, then it always forms some continuous segment. The length of the intersection is the length of the resulting segment or 0 in case the intersection is an empty set.
For example, the intersection of segments [1;5] and [3;10] is [3;5] (length 2), the intersection of segments [1;5] and [5;7] is [5;5] (length 0) and the intersection of segments [1;5] and [6;6] is an empty set (length 0).
Your task is to remove exactly one segment from the given sequence in such a way that the intersection of the remaining (n - 1) segments has the maximal possible length.
Input
The first line contains a single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of segments in the sequence.
Each of the next n lines contains two integers l_i and r_i (0 ≤ l_i ≤ r_i ≤ 10^9) — the description of the i-th segment.
Output
Print a single integer — the maximal possible length of the intersection of (n - 1) remaining segments after you remove exactly one segment from the sequence.
Examples
Input
4
1 3
2 6
0 4
3 3
Output
1
Input
5
2 6
1 3
0 4
1 20
0 4
Output
2
Input
3
4 5
1 2
9 20
Output
0
Input
2
3 10
1 5
Output
7
Note
In the first example you should remove the segment [3;3], the intersection will become [2;3] (length 1). Removing any other segment will result in the intersection [3;3] (length 0).
In the second example you should remove the segment [1;3] or segment [2;6], the intersection will become [2;4] (length 2) or [1;3] (length 2), respectively. Removing any other segment will result in the intersection [2;3] (length 1).
In the third example the intersection will become an empty set no matter the segment you remove.
In the fourth example you will get the intersection [3;10] (length 7) if you remove the segment [1;5] or the intersection [1;5] (length 4) if you remove the segment [3;10]. | instruction | 0 | 39,606 | 12 | 79,212 |
Tags: greedy, math, sortings
Correct Solution:
```
import sys
import math
from collections import defaultdict,deque
input = sys.stdin.readline
def inar():
return [int(el) for el in input().split()]
def main():
t=int(input())
tup=[]
for _ in range(t):
l,r=inar()
tup.append([l,r])
tup.sort()
l=tup[0][0]
r=tup[0][1]
prefix=[[l,r]]
for i in range(1,t):
if l>tup[i][1] or r<tup[i][0]:
prefix.append([-1,-1])
for j in range(i+1,t):
prefix.append([-1, -1])
break
l=max(l,tup[i][0])
r=min(r,tup[i][1])
prefix.append([l,r])
l = tup[-1][0]
r = tup[-1][1]
suffix = []
for i in range(t):
suffix.append([-1,-1])
suffix[-1][0]=l
suffix[-1][1]=r
for i in range(t-2,-1,-1):
if l > tup[i][1] or r < tup[i][0]:
break
l = max(l, tup[i][0])
r = min(r, tup[i][1])
suffix[i][0]=l
suffix[i][1]=r
ans=0
for i in range(t):
if i==0:
ans=max(ans,abs(suffix[i+1][0]-suffix[i+1][1]))
continue
if i==t-1:
ans=max(ans,abs(prefix[i-1][0]-prefix[i-1][1]))
continue
prefix_l=prefix[i-1][0]
prefix_r=prefix[i-1][1]
suffix_l=suffix[i+1][0]
suffix_r=suffix[i+1][1]
l=max(prefix_l,suffix_l)
r=min(prefix_r,suffix_r)
ans=max(ans,max(0,r-l))
print(ans)
if __name__ == '__main__':
main()
``` | output | 1 | 39,606 | 12 | 79,213 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n segments on a number line; each endpoint of every segment has integer coordinates. Some segments can degenerate to points. Segments can intersect with each other, be nested in each other or even coincide.
The intersection of a sequence of segments is such a maximal set of points (not necesserily having integer coordinates) that each point lies within every segment from the sequence. If the resulting set isn't empty, then it always forms some continuous segment. The length of the intersection is the length of the resulting segment or 0 in case the intersection is an empty set.
For example, the intersection of segments [1;5] and [3;10] is [3;5] (length 2), the intersection of segments [1;5] and [5;7] is [5;5] (length 0) and the intersection of segments [1;5] and [6;6] is an empty set (length 0).
Your task is to remove exactly one segment from the given sequence in such a way that the intersection of the remaining (n - 1) segments has the maximal possible length.
Input
The first line contains a single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of segments in the sequence.
Each of the next n lines contains two integers l_i and r_i (0 ≤ l_i ≤ r_i ≤ 10^9) — the description of the i-th segment.
Output
Print a single integer — the maximal possible length of the intersection of (n - 1) remaining segments after you remove exactly one segment from the sequence.
Examples
Input
4
1 3
2 6
0 4
3 3
Output
1
Input
5
2 6
1 3
0 4
1 20
0 4
Output
2
Input
3
4 5
1 2
9 20
Output
0
Input
2
3 10
1 5
Output
7
Note
In the first example you should remove the segment [3;3], the intersection will become [2;3] (length 1). Removing any other segment will result in the intersection [3;3] (length 0).
In the second example you should remove the segment [1;3] or segment [2;6], the intersection will become [2;4] (length 2) or [1;3] (length 2), respectively. Removing any other segment will result in the intersection [2;3] (length 1).
In the third example the intersection will become an empty set no matter the segment you remove.
In the fourth example you will get the intersection [3;10] (length 7) if you remove the segment [1;5] or the intersection [1;5] (length 4) if you remove the segment [3;10]. | instruction | 0 | 39,607 | 12 | 79,214 |
Tags: greedy, math, sortings
Correct Solution:
```
n = int(input())
l = [0] * n
r = [0] * n
for i in range(n):
l[i], r[i] = map(int, input().split())
gr = [[l[i], r[i]] for i in range(n)]
m1, m2 = max(l[0], l[1]), min(l[0], l[1])
for i in range(2, n):
if l[i] > m1:
m1, m2, = l[i], m1
elif l[i] > m2:
m2 = l[i]
for i in range(n):
if gr[i][0] == m1:
gr[i][0] = m2
else:
gr[i][0] = m1
m1, m2 = min(r[0], r[1]), max(r[0], r[1])
for i in range(2, n):
if r[i] < m1:
m1, m2, = r[i], m1
elif r[i] < m2:
m2 = r[i]
for i in range(n):
if gr[i][1] == m1:
gr[i][1] = m2
else:
gr[i][1] = m1
mx = 0
for i in range(n):
mx = max(mx, gr[i][1] - gr[i][0])
print(mx)
``` | output | 1 | 39,607 | 12 | 79,215 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of length n that consists of zeros and ones.
You can perform the following operation multiple times. The operation consists of two steps:
1. Choose three integers 1 ≤ x < y < z ≤ n, that form an arithmetic progression (y - x = z - y).
2. Flip the values a_x, a_y, a_z (i.e. change 1 to 0, change 0 to 1).
Determine if it is possible to make all elements of the array equal to zero. If yes, print the operations that lead the the all-zero state. Your solution should not contain more than (⌊ n/3 ⌋ + 12) operations. Here ⌊ q ⌋ denotes the number q rounded down. We can show that it is possible to make all elements equal to zero in no more than this number of operations whenever it is possible to do so at all.
Input
The first line contains a single integer n (3 ≤ n ≤ 10^5) — the length of the array.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — the elements of the array.
Output
Print "YES" (without quotes) if the answer exists, otherwise print "NO" (without quotes). You can print each letter in any case (upper or lower).
If there is an answer, in the second line print an integer m (0 ≤ m ≤ (⌊ n/3 ⌋ + 12)) — the number of operations in your answer.
After that in (i + 2)-th line print the i-th operations — the integers x_i, y_i, z_i. You can print them in arbitrary order.
Examples
Input
5
1 1 0 1 1
Output
YES
2
1 3 5
2 3 4
Input
3
0 1 0
Output
NO
Note
In the first sample the shown output corresponds to the following solution:
* 1 1 0 1 1 (initial state);
* 0 1 1 1 0 (the flipped positions are the first, the third and the fifth elements);
* 0 0 0 0 0 (the flipped positions are the second, the third and the fourth elements).
Other answers are also possible. In this test the number of operations should not exceed ⌊ 5/3 ⌋ + 12 = 1 + 12 = 13.
In the second sample the only available operation is to flip all the elements. This way it is only possible to obtain the arrays 0 1 0 and 1 0 1, but it is impossible to make all elements equal to zero. | instruction | 0 | 39,632 | 12 | 79,264 |
Tags: constructive algorithms
Correct Solution:
```
l = [((1 << i) | (1 << (i + j)) | (1 << (i + j * 2)), i, j) for i in range(6) for j in range(1, 6) if i + j * 2 < 11]
six = [None] * (1 << 6)
for i in range(len(l)):
for j in range(i + 1, len(l)):
six[(l[i][0] ^ l[j][0]) & 0b111111] = (l[i][1:], l[j][1:])
n = int(input())
s = input().split()
cur = 0
ans = []
while len(s) - cur > 11:
part = int(''.join(s[cur:cur + 6])[::-1], 2)
if not part:
cur += 6
continue
(i, j), (u, v) = six[part]
ans.append((cur + i, cur + i + j, cur + i + j * 2))
ans.append((cur + u, cur + u + v, cur + u + v * 2))
for i in ans[-2:]:
for j in i:
try:
s[j] = {'0': '1', '1': '0'}[s[j]]
except:
print(s[j])
exit()
cur += 6
cur = max(0, min(cur, len(s) - 8))
l = [((1 << i) | (1 << (i + j)) | (1 << (i + j * 2)), i, j) for i in range(len(s) - cur) for j in (1, 3) if i + j * 2 < len(s) - cur]
lt = {1 << i: i for i in range(len(l))}
bit = [[] for _ in range(1 << len(l))]
for i in range(1, 1 << len(l)):
bit[i] = bit[i - (i & -i)][:]
bit[i].append(l[lt[i & -i]])
eight = {}
for b in bit:
res, a = 0, []
for i in b:
res ^= i[0]
a.append(i[1:])
if res in eight and len(eight[res]) <= len(a):
continue
eight[res] = a
part = int(''.join(s[cur:])[::-1], 2)
if part not in eight:
print('NO')
exit()
for u, v in eight[part]:
ans.append((cur + u, cur + u + v, cur + u + v * 2))
for j in ans[-1]:
s[j] = {'0': '1', '1': '0'}[s[j]]
print('YES')
print(len(ans))
for i in ans:
print(*map(lambda x: x + 1, i))
``` | output | 1 | 39,632 | 12 | 79,265 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of length n that consists of zeros and ones.
You can perform the following operation multiple times. The operation consists of two steps:
1. Choose three integers 1 ≤ x < y < z ≤ n, that form an arithmetic progression (y - x = z - y).
2. Flip the values a_x, a_y, a_z (i.e. change 1 to 0, change 0 to 1).
Determine if it is possible to make all elements of the array equal to zero. If yes, print the operations that lead the the all-zero state. Your solution should not contain more than (⌊ n/3 ⌋ + 12) operations. Here ⌊ q ⌋ denotes the number q rounded down. We can show that it is possible to make all elements equal to zero in no more than this number of operations whenever it is possible to do so at all.
Input
The first line contains a single integer n (3 ≤ n ≤ 10^5) — the length of the array.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — the elements of the array.
Output
Print "YES" (without quotes) if the answer exists, otherwise print "NO" (without quotes). You can print each letter in any case (upper or lower).
If there is an answer, in the second line print an integer m (0 ≤ m ≤ (⌊ n/3 ⌋ + 12)) — the number of operations in your answer.
After that in (i + 2)-th line print the i-th operations — the integers x_i, y_i, z_i. You can print them in arbitrary order.
Examples
Input
5
1 1 0 1 1
Output
YES
2
1 3 5
2 3 4
Input
3
0 1 0
Output
NO
Note
In the first sample the shown output corresponds to the following solution:
* 1 1 0 1 1 (initial state);
* 0 1 1 1 0 (the flipped positions are the first, the third and the fifth elements);
* 0 0 0 0 0 (the flipped positions are the second, the third and the fourth elements).
Other answers are also possible. In this test the number of operations should not exceed ⌊ 5/3 ⌋ + 12 = 1 + 12 = 13.
In the second sample the only available operation is to flip all the elements. This way it is only possible to obtain the arrays 0 1 0 and 1 0 1, but it is impossible to make all elements equal to zero. | instruction | 0 | 39,633 | 12 | 79,266 |
Tags: constructive algorithms
Correct Solution:
```
def solve(a):
l = len(a)
d = sum(a[i] * 2 ** i for i in range(l))
if d == 0:
return []
usable = []
if l >= 3:
for i in range(l - 2):
usable.append(0b111 << i)
if l >= 5:
for i in range(l - 4):
usable.append(0b10101 << i)
if l >= 7:
for i in range(l - 6):
usable.append(0b1001001 << i)
ul = len(usable)
best_answer = None
for mask in range(1 << ul):
start = 0
clone = mask
cnt = 0
while clone:
if clone % 2 == 1:
start ^= usable[cnt]
clone //= 2
cnt += 1
if start == d:
answer = []
clone = mask
cnt = 0
while clone:
if clone % 2 == 1:
answer.append([])
used = usable[cnt]
cnt2 = 1
while used:
if used % 2 == 1:
answer[-1].append(cnt2)
cnt2 += 1
used //= 2
clone //= 2
cnt += 1
if best_answer is None or len(best_answer) > len(answer):
best_answer = answer
return best_answer
if __name__ == '__main__':
n = int(input())
a = list(map(int, input().split()))
if len(a) <= 10:
sol = solve(a)
if sol is None:
print("NO")
exit(0)
print("YES")
print(len(sol))
for t in sol:
print(' '.join(map(str, t)))
exit(0)
operations = []
while len(a) > 10:
l = len(a)
last = a[-3:]
if last == [1, 1, 1]:
operations.append([l - 2, l - 1, l])
elif last == [1, 1, 0]:
operations.append([l - 3, l - 2, l - 1])
a[-4] ^= 1
elif last == [1, 0, 1]:
operations.append([l - 4, l - 2, l])
a[-5] ^= 1
elif last == [0, 1, 1]:
nxt = a[-6:-3]
if nxt == [1, 1, 1]:
operations.append([l - 8, l - 4, l])
operations.append([l - 5, l - 3, l - 1])
a[-9] ^= 1
elif nxt == [1, 1, 0]:
operations.append([l - 8, l - 4, l])
operations.append([l - 9, l - 5, l - 1])
a[-9] ^= 1
a[-10] ^= 1
elif nxt == [1, 0, 1]:
operations.append([l - 6, l - 3, l])
operations.append([l - 9, l - 5, l - 1])
a[-7] ^= 1
a[-10] ^= 1
elif nxt == [0, 1, 1]:
operations.append([l - 6, l - 3, l])
operations.append([l - 7, l - 4, l - 1])
a[-7] ^= 1
a[-8] ^= 1
elif nxt == [1, 0, 0]:
operations.append([l - 2, l - 1, l])
operations.append([l - 8, l - 5, l - 2])
a[-9] ^= 1
elif nxt == [0, 1, 0]:
operations.append([l - 2, l - 1, l])
operations.append([l - 6, l - 4, l - 2])
a[-7] ^= 1
elif nxt == [0, 0, 1]:
operations.append([l - 10, l - 5, l])
operations.append([l - 5, l - 3, l - 1])
a[-11] ^= 1
elif nxt == [0, 0, 0]:
operations.append([l - 8, l - 4, l])
operations.append([l - 7, l - 4, l - 1])
a[-9] ^= 1
a[-8] ^= 1
a.pop()
a.pop()
a.pop()
elif last == [1, 0, 0]:
operations.append([l - 4, l - 3, l - 2])
a[-5] ^= 1
a[-4] ^= 1
elif last == [0, 1, 0]:
operations.append([l - 5, l - 3, l - 1])
a[-6] ^= 1
a[-4] ^= 1
elif last == [0, 0, 1]:
operations.append([l - 6, l - 3, l])
a[-7] ^= 1
a[-4] ^= 1
a.pop()
a.pop()
a.pop()
while len(a) < 8:
a.append(0)
sol = solve(a)
print("YES")
sol = operations + sol
print(len(sol))
for t in sol:
print(' '.join(map(str, t)))
``` | output | 1 | 39,633 | 12 | 79,267 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of length n that consists of zeros and ones.
You can perform the following operation multiple times. The operation consists of two steps:
1. Choose three integers 1 ≤ x < y < z ≤ n, that form an arithmetic progression (y - x = z - y).
2. Flip the values a_x, a_y, a_z (i.e. change 1 to 0, change 0 to 1).
Determine if it is possible to make all elements of the array equal to zero. If yes, print the operations that lead the the all-zero state. Your solution should not contain more than (⌊ n/3 ⌋ + 12) operations. Here ⌊ q ⌋ denotes the number q rounded down. We can show that it is possible to make all elements equal to zero in no more than this number of operations whenever it is possible to do so at all.
Input
The first line contains a single integer n (3 ≤ n ≤ 10^5) — the length of the array.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — the elements of the array.
Output
Print "YES" (without quotes) if the answer exists, otherwise print "NO" (without quotes). You can print each letter in any case (upper or lower).
If there is an answer, in the second line print an integer m (0 ≤ m ≤ (⌊ n/3 ⌋ + 12)) — the number of operations in your answer.
After that in (i + 2)-th line print the i-th operations — the integers x_i, y_i, z_i. You can print them in arbitrary order.
Examples
Input
5
1 1 0 1 1
Output
YES
2
1 3 5
2 3 4
Input
3
0 1 0
Output
NO
Note
In the first sample the shown output corresponds to the following solution:
* 1 1 0 1 1 (initial state);
* 0 1 1 1 0 (the flipped positions are the first, the third and the fifth elements);
* 0 0 0 0 0 (the flipped positions are the second, the third and the fourth elements).
Other answers are also possible. In this test the number of operations should not exceed ⌊ 5/3 ⌋ + 12 = 1 + 12 = 13.
In the second sample the only available operation is to flip all the elements. This way it is only possible to obtain the arrays 0 1 0 and 1 0 1, but it is impossible to make all elements equal to zero.
Submitted Solution:
```
def solve(a):
l = len(a)
d = sum(a[i] * 2 ** i for i in range(l))
if d == 0:
return []
usable = []
if l >= 3:
for i in range(l - 2):
usable.append(0b111 << i)
if l >= 5:
for i in range(l - 4):
usable.append(0b10101 << i)
if l >= 7:
for i in range(l - 6):
usable.append(0b1001001 << i)
ul = len(usable)
for mask in range(1 << ul):
start = 0
clone = mask
cnt = 0
while clone:
if clone % 2 == 1:
start ^= usable[cnt]
clone //= 2
cnt += 1
if start == d:
answer = []
clone = mask
cnt = 0
while clone:
if clone % 2 == 1:
answer.append([])
used = usable[cnt]
cnt2 = 1
while used:
if used % 2 == 1:
answer[-1].append(cnt2)
cnt2 += 1
used //= 2
clone //= 2
cnt += 1
return answer
if __name__ == '__main__':
n = int(input())
a = list(map(int, input().split()))
if len(a) <= 10:
sol = solve(a)
if sol is None:
print("NO")
exit(0)
print("YES")
print(len(sol))
for t in sol:
print(' '.join(map(str, t)))
exit(0)
operations = []
while len(a) > 10:
l = len(a)
last = a[-3:]
if last == [1, 1, 1]:
operations.append([l - 2, l - 1, l])
elif last == [1, 1, 0]:
operations.append([l - 3, l - 2, l - 1])
a[-4] ^= 1
elif last == [1, 0, 1]:
operations.append([l - 4, l - 2, l])
a[-5] ^= 1
elif last == [0, 1, 1]:
nxt = a[-6:-3]
if nxt == [1, 1, 1]:
operations.append([l - 8, l - 4, l])
operations.append([l - 5, l - 3, l - 1])
a[-9] ^= 1
elif nxt == [1, 1, 0]:
operations.append([l - 8, l - 4, l])
operations.append([l - 9, l - 5, l - 1])
a[-9] ^= 1
a[-10] ^= 1
elif nxt == [1, 0, 1]:
operations.append([l - 6, l - 3, l])
operations.append([l - 9, l - 5, l - 1])
a[-7] ^= 1
a[-10] ^= 1
elif nxt == [0, 1, 1]:
operations.append([l - 6, l - 3, l])
operations.append([l - 7, l - 4, l - 1])
a[-7] ^= 1
a[-8] ^= 1
elif nxt == [1, 0, 0]:
operations.append([l - 2, l - 1, l])
operations.append([l - 8, l - 5, l - 2])
a[-9] ^= 1
elif nxt == [0, 1, 0]:
operations.append([l - 2, l - 1, l])
operations.append([l - 6, l - 4, l - 2])
a[-7] ^= 1
elif nxt == [0, 0, 1]:
operations.append([l - 10, l - 5, l])
operations.append([l - 5, l - 3, l - 1])
a[-11] ^= 1
elif nxt == [0, 0, 0]:
operations.append([l - 8, l - 4, l])
operations.append([l - 7, l - 4, l - 1])
a[-9] ^= 1
a[-10] ^= 1
a.pop()
a.pop()
a.pop()
elif last == [1, 0, 0]:
operations.append([l - 4, l - 3, l - 2])
a[-5] ^= 1
a[-4] ^= 1
elif last == [0, 1, 0]:
operations.append([l - 5, l - 3, l - 1])
a[-6] ^= 1
a[-4] ^= 1
elif last == [0, 0, 1]:
operations.append([l - 6, l - 3, l])
a[-7] ^= 1
a[-4] ^= 1
a.pop()
a.pop()
a.pop()
while len(a) < 8:
a.append(0)
sol = solve(a)
print("YES")
sol = operations + sol
print(len(sol))
for t in sol:
print(' '.join(map(str, t)))
``` | instruction | 0 | 39,634 | 12 | 79,268 |
No | output | 1 | 39,634 | 12 | 79,269 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a of length n that consists of zeros and ones.
You can perform the following operation multiple times. The operation consists of two steps:
1. Choose three integers 1 ≤ x < y < z ≤ n, that form an arithmetic progression (y - x = z - y).
2. Flip the values a_x, a_y, a_z (i.e. change 1 to 0, change 0 to 1).
Determine if it is possible to make all elements of the array equal to zero. If yes, print the operations that lead the the all-zero state. Your solution should not contain more than (⌊ n/3 ⌋ + 12) operations. Here ⌊ q ⌋ denotes the number q rounded down. We can show that it is possible to make all elements equal to zero in no more than this number of operations whenever it is possible to do so at all.
Input
The first line contains a single integer n (3 ≤ n ≤ 10^5) — the length of the array.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — the elements of the array.
Output
Print "YES" (without quotes) if the answer exists, otherwise print "NO" (without quotes). You can print each letter in any case (upper or lower).
If there is an answer, in the second line print an integer m (0 ≤ m ≤ (⌊ n/3 ⌋ + 12)) — the number of operations in your answer.
After that in (i + 2)-th line print the i-th operations — the integers x_i, y_i, z_i. You can print them in arbitrary order.
Examples
Input
5
1 1 0 1 1
Output
YES
2
1 3 5
2 3 4
Input
3
0 1 0
Output
NO
Note
In the first sample the shown output corresponds to the following solution:
* 1 1 0 1 1 (initial state);
* 0 1 1 1 0 (the flipped positions are the first, the third and the fifth elements);
* 0 0 0 0 0 (the flipped positions are the second, the third and the fourth elements).
Other answers are also possible. In this test the number of operations should not exceed ⌊ 5/3 ⌋ + 12 = 1 + 12 = 13.
In the second sample the only available operation is to flip all the elements. This way it is only possible to obtain the arrays 0 1 0 and 1 0 1, but it is impossible to make all elements equal to zero.
Submitted Solution:
```
def solve(a):
l = len(a)
d = sum(a[i] * 2 ** i for i in range(l))
if d == 0:
return []
usable = []
if l >= 3:
for i in range(l - 2):
usable.append(0b111 << i)
if l >= 5:
for i in range(l - 4):
usable.append(0b10101 << i)
if l >= 7:
for i in range(l - 6):
usable.append(0b1001001 << i)
ul = len(usable)
best_answer = None
for mask in range(1 << ul):
start = 0
clone = mask
cnt = 0
while clone:
if clone % 2 == 1:
start ^= usable[cnt]
clone //= 2
cnt += 1
if start == d:
answer = []
clone = mask
cnt = 0
while clone:
if clone % 2 == 1:
answer.append([])
used = usable[cnt]
cnt2 = 1
while used:
if used % 2 == 1:
answer[-1].append(cnt2)
cnt2 += 1
used //= 2
clone //= 2
cnt += 1
if best_answer is None or len(best_answer) > len(answer):
best_answer = answer
return best_answer
if __name__ == '__main__':
n = int(input())
a = list(map(int, input().split()))
if len(a) <= 10:
sol = solve(a)
if sol is None:
print("NO")
exit(0)
print("YES")
print(len(sol))
for t in sol:
print(' '.join(map(str, t)))
exit(0)
operations = []
while len(a) > 10:
l = len(a)
last = a[-3:]
if last == [1, 1, 1]:
operations.append([l - 2, l - 1, l])
elif last == [1, 1, 0]:
operations.append([l - 3, l - 2, l - 1])
a[-4] ^= 1
elif last == [1, 0, 1]:
operations.append([l - 4, l - 2, l])
a[-5] ^= 1
elif last == [0, 1, 1]:
nxt = a[-6:-3]
if nxt == [1, 1, 1]:
operations.append([l - 8, l - 4, l])
operations.append([l - 5, l - 3, l - 1])
a[-9] ^= 1
elif nxt == [1, 1, 0]:
operations.append([l - 8, l - 4, l])
operations.append([l - 9, l - 5, l - 1])
a[-9] ^= 1
a[-10] ^= 1
elif nxt == [1, 0, 1]:
operations.append([l - 6, l - 3, l])
operations.append([l - 9, l - 5, l - 1])
a[-7] ^= 1
a[-10] ^= 1
elif nxt == [0, 1, 1]:
operations.append([l - 6, l - 3, l])
operations.append([l - 7, l - 4, l - 1])
a[-7] ^= 1
a[-8] ^= 1
elif nxt == [1, 0, 0]:
operations.append([l - 2, l - 1, l])
operations.append([l - 8, l - 5, l - 2])
a[-9] ^= 1
elif nxt == [0, 1, 0]:
operations.append([l - 2, l - 1, l])
operations.append([l - 6, l - 4, l - 2])
a[-7] ^= 1
elif nxt == [0, 0, 1]:
operations.append([l - 10, l - 5, l])
operations.append([l - 5, l - 3, l - 1])
a[-11] ^= 1
elif nxt == [0, 0, 0]:
operations.append([l - 8, l - 4, l])
operations.append([l - 7, l - 4, l - 1])
a[-9] ^= 1
a[-10] ^= 1
a.pop()
a.pop()
a.pop()
elif last == [1, 0, 0]:
operations.append([l - 4, l - 3, l - 2])
a[-5] ^= 1
a[-4] ^= 1
elif last == [0, 1, 0]:
operations.append([l - 5, l - 3, l - 1])
a[-6] ^= 1
a[-4] ^= 1
elif last == [0, 0, 1]:
operations.append([l - 6, l - 3, l])
a[-7] ^= 1
a[-4] ^= 1
a.pop()
a.pop()
a.pop()
while len(a) < 8:
a.append(0)
sol = solve(a)
print("YES")
sol = operations + sol
print(len(sol))
for t in sol:
print(' '.join(map(str, t)))
``` | instruction | 0 | 39,635 | 12 | 79,270 |
No | output | 1 | 39,635 | 12 | 79,271 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two permutations a and b, both consisting of n elements. Permutation of n elements is such a integer sequence that each value from 1 to n appears exactly once in it.
You are asked to perform two types of queries with them:
* 1~l_a~r_a~l_b~r_b — calculate the number of values which appear in both segment [l_a; r_a] of positions in permutation a and segment [l_b; r_b] of positions in permutation b;
* 2~x~y — swap values on positions x and y in permutation b.
Print the answer for each query of the first type.
It is guaranteed that there will be at least one query of the first type in the input.
Input
The first line contains two integers n and m (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5) — the number of elements in both permutations and the number of queries.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — permutation a. It is guaranteed that each value from 1 to n appears in a exactly once.
The third line contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ n) — permutation b. It is guaranteed that each value from 1 to n appears in b exactly once.
Each of the next m lines contains the description of a certain query. These are either:
* 1~l_a~r_a~l_b~r_b (1 ≤ l_a ≤ r_a ≤ n, 1 ≤ l_b ≤ r_b ≤ n);
* 2~x~y (1 ≤ x, y ≤ n, x ≠ y).
Output
Print the answers for the queries of the first type, each answer in the new line — the number of values which appear in both segment [l_a; r_a] of positions in permutation a and segment [l_b; r_b] of positions in permutation b.
Example
Input
6 7
5 1 4 2 3 6
2 5 3 1 4 6
1 1 2 4 5
2 2 4
1 1 2 4 5
1 2 3 3 5
1 1 6 1 2
2 4 1
1 4 4 1 3
Output
1
1
1
2
0
Note
Consider the first query of the first example. Values on positions [1; 2] of a are [5, 1] and values on positions [4; 5] of b are [1, 4]. Only value 1 appears in both segments.
After the first swap (the second query) permutation b becomes [2, 1, 3, 5, 4, 6].
After the second swap (the sixth query) permutation b becomes [5, 1, 3, 2, 4, 6].
Submitted Solution:
```
n,m=map(int,input().split())
a=input().split()
b=input().split()
while m>0:
di=dict()
qu=input().split()
if qu[0]=='1':
aa=int(qu[1])
bb=int(qu[2])
c=int(qu[3])
d=int(qu[4])
for i in range(aa-1,bb):
ind=a[i]
di[ind]=1
c=0
for i in range(c-1,d):
ind=b[i]
if ind in di:
di[ind]+=1
if di[ind]==2:
c+=1
print(c)
else:
x=int(qu[1])
y=int(qu[2])
b[x-1],b[y-1]=b[y-1],b[x-1]
m-=1
``` | instruction | 0 | 39,636 | 12 | 79,272 |
No | output | 1 | 39,636 | 12 | 79,273 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two permutations a and b, both consisting of n elements. Permutation of n elements is such a integer sequence that each value from 1 to n appears exactly once in it.
You are asked to perform two types of queries with them:
* 1~l_a~r_a~l_b~r_b — calculate the number of values which appear in both segment [l_a; r_a] of positions in permutation a and segment [l_b; r_b] of positions in permutation b;
* 2~x~y — swap values on positions x and y in permutation b.
Print the answer for each query of the first type.
It is guaranteed that there will be at least one query of the first type in the input.
Input
The first line contains two integers n and m (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5) — the number of elements in both permutations and the number of queries.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — permutation a. It is guaranteed that each value from 1 to n appears in a exactly once.
The third line contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ n) — permutation b. It is guaranteed that each value from 1 to n appears in b exactly once.
Each of the next m lines contains the description of a certain query. These are either:
* 1~l_a~r_a~l_b~r_b (1 ≤ l_a ≤ r_a ≤ n, 1 ≤ l_b ≤ r_b ≤ n);
* 2~x~y (1 ≤ x, y ≤ n, x ≠ y).
Output
Print the answers for the queries of the first type, each answer in the new line — the number of values which appear in both segment [l_a; r_a] of positions in permutation a and segment [l_b; r_b] of positions in permutation b.
Example
Input
6 7
5 1 4 2 3 6
2 5 3 1 4 6
1 1 2 4 5
2 2 4
1 1 2 4 5
1 2 3 3 5
1 1 6 1 2
2 4 1
1 4 4 1 3
Output
1
1
1
2
0
Note
Consider the first query of the first example. Values on positions [1; 2] of a are [5, 1] and values on positions [4; 5] of b are [1, 4]. Only value 1 appears in both segments.
After the first swap (the second query) permutation b becomes [2, 1, 3, 5, 4, 6].
After the second swap (the sixth query) permutation b becomes [5, 1, 3, 2, 4, 6].
Submitted Solution:
```
# import random as rd
size, queries = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
# a = rd.sample(range(2*(10**5)), 2*(10**5))
# rd.shuffle(a)
# b = rd.sample(range(2*(10**5), 2*(10**5))
# rd.shuffle(b)
# print(set(a).intersection(b))
n_intersec = []
universe = set(range(1, size+1))
for n in range(queries):
nro = 0
rule = list(map(int, input().split()))
if rule[0] == 2:
b[rule[1]-1], b[rule[2]-1] = b[rule[2]-1], b[rule[1]-1]
else:
if rule[1] == 1 and rule[2] == size:
nro = rule[4] - rule[3] + 1
elif rule[3] == 1 and rule[2] == size:
nro = rule[2] - rule[1] + 1
else:
a_slice = set(a[rule[1]-1:rule[2]])
b_slice = set(b[rule[3]-1:rule[4]])
if len(a_slice) >= len(b_slice):
bigger = a_slice
smaller = b_slice
else:
bigger = b_slice
smaller = a_slice
nro = len(smaller) - len(smaller.intersection(universe-bigger))
n_intersec.append(nro)
for i in n_intersec:
print(i)
``` | instruction | 0 | 39,637 | 12 | 79,274 |
No | output | 1 | 39,637 | 12 | 79,275 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two permutations a and b, both consisting of n elements. Permutation of n elements is such a integer sequence that each value from 1 to n appears exactly once in it.
You are asked to perform two types of queries with them:
* 1~l_a~r_a~l_b~r_b — calculate the number of values which appear in both segment [l_a; r_a] of positions in permutation a and segment [l_b; r_b] of positions in permutation b;
* 2~x~y — swap values on positions x and y in permutation b.
Print the answer for each query of the first type.
It is guaranteed that there will be at least one query of the first type in the input.
Input
The first line contains two integers n and m (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5) — the number of elements in both permutations and the number of queries.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — permutation a. It is guaranteed that each value from 1 to n appears in a exactly once.
The third line contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ n) — permutation b. It is guaranteed that each value from 1 to n appears in b exactly once.
Each of the next m lines contains the description of a certain query. These are either:
* 1~l_a~r_a~l_b~r_b (1 ≤ l_a ≤ r_a ≤ n, 1 ≤ l_b ≤ r_b ≤ n);
* 2~x~y (1 ≤ x, y ≤ n, x ≠ y).
Output
Print the answers for the queries of the first type, each answer in the new line — the number of values which appear in both segment [l_a; r_a] of positions in permutation a and segment [l_b; r_b] of positions in permutation b.
Example
Input
6 7
5 1 4 2 3 6
2 5 3 1 4 6
1 1 2 4 5
2 2 4
1 1 2 4 5
1 2 3 3 5
1 1 6 1 2
2 4 1
1 4 4 1 3
Output
1
1
1
2
0
Note
Consider the first query of the first example. Values on positions [1; 2] of a are [5, 1] and values on positions [4; 5] of b are [1, 4]. Only value 1 appears in both segments.
After the first swap (the second query) permutation b becomes [2, 1, 3, 5, 4, 6].
After the second swap (the sixth query) permutation b becomes [5, 1, 3, 2, 4, 6].
Submitted Solution:
```
n,m=map(int,input().split())
a=input().split()
b=input().split()
while m>0:
di=dict()
qu=input().split()
if qu[0]=='1':
aa=int(qu[1])
bb=int(qu[2])
c=int(qu[3])
d=int(qu[4])
for i in range(aa-1,bb):
ind=a[i]
di[ind]=1
cc=0
for i in range(c-1,d):
ind=b[i]
if ind in di:
di[ind]+=1
if di[ind]==2:
c+=1
print(cc)
else:
x=int(qu[1])
y=int(qu[2])
b[x-1],b[y-1]=b[y-1],b[x-1]
m-=1
``` | instruction | 0 | 39,638 | 12 | 79,276 |
No | output | 1 | 39,638 | 12 | 79,277 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two permutations a and b, both consisting of n elements. Permutation of n elements is such a integer sequence that each value from 1 to n appears exactly once in it.
You are asked to perform two types of queries with them:
* 1~l_a~r_a~l_b~r_b — calculate the number of values which appear in both segment [l_a; r_a] of positions in permutation a and segment [l_b; r_b] of positions in permutation b;
* 2~x~y — swap values on positions x and y in permutation b.
Print the answer for each query of the first type.
It is guaranteed that there will be at least one query of the first type in the input.
Input
The first line contains two integers n and m (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5) — the number of elements in both permutations and the number of queries.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — permutation a. It is guaranteed that each value from 1 to n appears in a exactly once.
The third line contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ n) — permutation b. It is guaranteed that each value from 1 to n appears in b exactly once.
Each of the next m lines contains the description of a certain query. These are either:
* 1~l_a~r_a~l_b~r_b (1 ≤ l_a ≤ r_a ≤ n, 1 ≤ l_b ≤ r_b ≤ n);
* 2~x~y (1 ≤ x, y ≤ n, x ≠ y).
Output
Print the answers for the queries of the first type, each answer in the new line — the number of values which appear in both segment [l_a; r_a] of positions in permutation a and segment [l_b; r_b] of positions in permutation b.
Example
Input
6 7
5 1 4 2 3 6
2 5 3 1 4 6
1 1 2 4 5
2 2 4
1 1 2 4 5
1 2 3 3 5
1 1 6 1 2
2 4 1
1 4 4 1 3
Output
1
1
1
2
0
Note
Consider the first query of the first example. Values on positions [1; 2] of a are [5, 1] and values on positions [4; 5] of b are [1, 4]. Only value 1 appears in both segments.
After the first swap (the second query) permutation b becomes [2, 1, 3, 5, 4, 6].
After the second swap (the sixth query) permutation b becomes [5, 1, 3, 2, 4, 6].
Submitted Solution:
```
n,m=map(int,input().split())
a=input().split()
b=input().split()
while m>0:
di=dict()
qu=input().split()
if qu[0]=='1':
aa=int(qu[1])
bb=int(qu[2])
c=int(qu[3])
d=int(qu[4])
for i in range(aa-1,bb):
ind=a[i]
di[ind]=1
c=0
for i in range(c-1,d):
ind=b[i]
if ind in di:
if di[ind]==1:
c+=1
print(c)
else:
x=int(qu[1])
y=int(qu[2])
b[x-1],b[y-1]=b[y-1],b[x-1]
m-=1
``` | instruction | 0 | 39,639 | 12 | 79,278 |
No | output | 1 | 39,639 | 12 | 79,279 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two n × m matrices containing integers. A sequence of integers is strictly increasing if each next number is greater than the previous one. A row is strictly increasing if all numbers from left to right are strictly increasing. A column is strictly increasing if all numbers from top to bottom are strictly increasing. A matrix is increasing if all rows are strictly increasing and all columns are strictly increasing.
For example, the matrix \begin{bmatrix} 9&10&11\\\ 11&12&14\\\ \end{bmatrix} is increasing because each individual row and column is strictly increasing. On the other hand, the matrix \begin{bmatrix} 1&1\\\ 2&3\\\ \end{bmatrix} is not increasing because the first row is not strictly increasing.
Let a position in the i-th row (from top) and j-th column (from left) in a matrix be denoted as (i, j).
In one operation, you can choose any two numbers i and j and swap the number located in (i, j) in the first matrix with the number in (i, j) in the second matrix. In other words, you can swap two numbers in different matrices if they are located in the corresponding positions.
You would like to make both matrices increasing by performing some number of operations (possibly none). Determine if it is possible to do this. If it is, print "Possible", otherwise, print "Impossible".
Input
The first line contains two integers n and m (1 ≤ n,m ≤ 50) — the dimensions of each matrix.
Each of the next n lines contains m integers a_{i1}, a_{i2}, …, a_{im} (1 ≤ a_{ij} ≤ 10^9) — the number located in position (i, j) in the first matrix.
Each of the next n lines contains m integers b_{i1}, b_{i2}, …, b_{im} (1 ≤ b_{ij} ≤ 10^9) — the number located in position (i, j) in the second matrix.
Output
Print a string "Impossible" or "Possible".
Examples
Input
2 2
2 10
11 5
9 4
3 12
Output
Possible
Input
2 3
2 4 5
4 5 6
3 6 7
8 10 11
Output
Possible
Input
3 2
1 3
2 4
5 10
3 1
3 6
4 8
Output
Impossible
Note
The first example, we can do an operation on the top left and bottom right cells of the matrices. The resulting matrices will be \begin{bmatrix} 9&10\\\ 11&12\\\ \end{bmatrix} and \begin{bmatrix} 2&4\\\ 3&5\\\ \end{bmatrix}.
In the second example, we don't need to do any operations.
In the third example, no matter what we swap, we can't fix the first row to be strictly increasing in both matrices. | instruction | 0 | 39,656 | 12 | 79,312 |
Tags: brute force, greedy
Correct Solution:
```
n, m = [int(x) for x in input().split()]
a = []
b =[]
T_F = True
for i in range(n):
a.append([int(x) for x in input().split()])
for i in range(n):
b.append([int(x) for x in input().split()])
for i in range(n):
for j in range(m):
if a[i][j] > b[i][j]:
a[i][j], b[i][j] = b[i][j], a[i][j]
def sort_mat(a):
for i in range(n):
for j in range(m):
if i+1<n:
if a[i][j] >= a[i+1][j]:
return False
if j+1<m:
if a[i][j] >= a[i][j+1]:
return False
return True
if sort_mat(a) and sort_mat(b):
print('Possible')
else:
print('Impossible')
``` | output | 1 | 39,656 | 12 | 79,313 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two n × m matrices containing integers. A sequence of integers is strictly increasing if each next number is greater than the previous one. A row is strictly increasing if all numbers from left to right are strictly increasing. A column is strictly increasing if all numbers from top to bottom are strictly increasing. A matrix is increasing if all rows are strictly increasing and all columns are strictly increasing.
For example, the matrix \begin{bmatrix} 9&10&11\\\ 11&12&14\\\ \end{bmatrix} is increasing because each individual row and column is strictly increasing. On the other hand, the matrix \begin{bmatrix} 1&1\\\ 2&3\\\ \end{bmatrix} is not increasing because the first row is not strictly increasing.
Let a position in the i-th row (from top) and j-th column (from left) in a matrix be denoted as (i, j).
In one operation, you can choose any two numbers i and j and swap the number located in (i, j) in the first matrix with the number in (i, j) in the second matrix. In other words, you can swap two numbers in different matrices if they are located in the corresponding positions.
You would like to make both matrices increasing by performing some number of operations (possibly none). Determine if it is possible to do this. If it is, print "Possible", otherwise, print "Impossible".
Input
The first line contains two integers n and m (1 ≤ n,m ≤ 50) — the dimensions of each matrix.
Each of the next n lines contains m integers a_{i1}, a_{i2}, …, a_{im} (1 ≤ a_{ij} ≤ 10^9) — the number located in position (i, j) in the first matrix.
Each of the next n lines contains m integers b_{i1}, b_{i2}, …, b_{im} (1 ≤ b_{ij} ≤ 10^9) — the number located in position (i, j) in the second matrix.
Output
Print a string "Impossible" or "Possible".
Examples
Input
2 2
2 10
11 5
9 4
3 12
Output
Possible
Input
2 3
2 4 5
4 5 6
3 6 7
8 10 11
Output
Possible
Input
3 2
1 3
2 4
5 10
3 1
3 6
4 8
Output
Impossible
Note
The first example, we can do an operation on the top left and bottom right cells of the matrices. The resulting matrices will be \begin{bmatrix} 9&10\\\ 11&12\\\ \end{bmatrix} and \begin{bmatrix} 2&4\\\ 3&5\\\ \end{bmatrix}.
In the second example, we don't need to do any operations.
In the third example, no matter what we swap, we can't fix the first row to be strictly increasing in both matrices. | instruction | 0 | 39,657 | 12 | 79,314 |
Tags: brute force, greedy
Correct Solution:
```
n,m=[int(x) for x in input().split()]
a=[]
b=[]
for i in range(n):
c=[int(x) for x in input().split()]
a.append(c)
for i in range(n):
c=[int(x) for x in input().split()]
b.append(c)
for i in range(n):
for j in range(m):
x,y=a[i][j],b[i][j]
a[i][j]=min(x,y)
b[i][j]=max(x,y)
if j>0:
if a[i][j]<=a[i][j-1] or b[i][j]<=b[i][j-1]:
print('Impossible')
exit()
if i>0:
if a[i][j]<=a[i-1][j] or b[i][j]<=b[i-1][j]:
print('Impossible')
exit()
print('Possible')
``` | output | 1 | 39,657 | 12 | 79,315 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two n × m matrices containing integers. A sequence of integers is strictly increasing if each next number is greater than the previous one. A row is strictly increasing if all numbers from left to right are strictly increasing. A column is strictly increasing if all numbers from top to bottom are strictly increasing. A matrix is increasing if all rows are strictly increasing and all columns are strictly increasing.
For example, the matrix \begin{bmatrix} 9&10&11\\\ 11&12&14\\\ \end{bmatrix} is increasing because each individual row and column is strictly increasing. On the other hand, the matrix \begin{bmatrix} 1&1\\\ 2&3\\\ \end{bmatrix} is not increasing because the first row is not strictly increasing.
Let a position in the i-th row (from top) and j-th column (from left) in a matrix be denoted as (i, j).
In one operation, you can choose any two numbers i and j and swap the number located in (i, j) in the first matrix with the number in (i, j) in the second matrix. In other words, you can swap two numbers in different matrices if they are located in the corresponding positions.
You would like to make both matrices increasing by performing some number of operations (possibly none). Determine if it is possible to do this. If it is, print "Possible", otherwise, print "Impossible".
Input
The first line contains two integers n and m (1 ≤ n,m ≤ 50) — the dimensions of each matrix.
Each of the next n lines contains m integers a_{i1}, a_{i2}, …, a_{im} (1 ≤ a_{ij} ≤ 10^9) — the number located in position (i, j) in the first matrix.
Each of the next n lines contains m integers b_{i1}, b_{i2}, …, b_{im} (1 ≤ b_{ij} ≤ 10^9) — the number located in position (i, j) in the second matrix.
Output
Print a string "Impossible" or "Possible".
Examples
Input
2 2
2 10
11 5
9 4
3 12
Output
Possible
Input
2 3
2 4 5
4 5 6
3 6 7
8 10 11
Output
Possible
Input
3 2
1 3
2 4
5 10
3 1
3 6
4 8
Output
Impossible
Note
The first example, we can do an operation on the top left and bottom right cells of the matrices. The resulting matrices will be \begin{bmatrix} 9&10\\\ 11&12\\\ \end{bmatrix} and \begin{bmatrix} 2&4\\\ 3&5\\\ \end{bmatrix}.
In the second example, we don't need to do any operations.
In the third example, no matter what we swap, we can't fix the first row to be strictly increasing in both matrices. | instruction | 0 | 39,658 | 12 | 79,316 |
Tags: brute force, greedy
Correct Solution:
```
n ,m = map(int,input().strip().split())
ma1 = []
ma2 = []
for i in range(n):
ma1.append([int(i) for i in input().strip().split()])
for i in range(n):
ma2.append([int(i) for i in input().strip().split()])
def check_row(ma):
for i in range(n):
for j in range(1,m):
if ma[i][j-1] >= ma[i][j]:
return False
return True
def check_col(ma):
for j in range(m):
for i in range(n-1):
if ma[i][j] >= ma[i + 1][j]:
return False
return True
for row in range(n):
for col in range(m):
if ma1[row][col] < ma2[row][col]:
temp = ma2[row][col]
ma2[row][col] = ma1[row][col]
ma1[row][col] = temp
if check_row(ma1) and check_col(ma1) and check_col(ma2) and check_row(ma2):
print("Possible")
else:
print("Impossible")
``` | output | 1 | 39,658 | 12 | 79,317 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two n × m matrices containing integers. A sequence of integers is strictly increasing if each next number is greater than the previous one. A row is strictly increasing if all numbers from left to right are strictly increasing. A column is strictly increasing if all numbers from top to bottom are strictly increasing. A matrix is increasing if all rows are strictly increasing and all columns are strictly increasing.
For example, the matrix \begin{bmatrix} 9&10&11\\\ 11&12&14\\\ \end{bmatrix} is increasing because each individual row and column is strictly increasing. On the other hand, the matrix \begin{bmatrix} 1&1\\\ 2&3\\\ \end{bmatrix} is not increasing because the first row is not strictly increasing.
Let a position in the i-th row (from top) and j-th column (from left) in a matrix be denoted as (i, j).
In one operation, you can choose any two numbers i and j and swap the number located in (i, j) in the first matrix with the number in (i, j) in the second matrix. In other words, you can swap two numbers in different matrices if they are located in the corresponding positions.
You would like to make both matrices increasing by performing some number of operations (possibly none). Determine if it is possible to do this. If it is, print "Possible", otherwise, print "Impossible".
Input
The first line contains two integers n and m (1 ≤ n,m ≤ 50) — the dimensions of each matrix.
Each of the next n lines contains m integers a_{i1}, a_{i2}, …, a_{im} (1 ≤ a_{ij} ≤ 10^9) — the number located in position (i, j) in the first matrix.
Each of the next n lines contains m integers b_{i1}, b_{i2}, …, b_{im} (1 ≤ b_{ij} ≤ 10^9) — the number located in position (i, j) in the second matrix.
Output
Print a string "Impossible" or "Possible".
Examples
Input
2 2
2 10
11 5
9 4
3 12
Output
Possible
Input
2 3
2 4 5
4 5 6
3 6 7
8 10 11
Output
Possible
Input
3 2
1 3
2 4
5 10
3 1
3 6
4 8
Output
Impossible
Note
The first example, we can do an operation on the top left and bottom right cells of the matrices. The resulting matrices will be \begin{bmatrix} 9&10\\\ 11&12\\\ \end{bmatrix} and \begin{bmatrix} 2&4\\\ 3&5\\\ \end{bmatrix}.
In the second example, we don't need to do any operations.
In the third example, no matter what we swap, we can't fix the first row to be strictly increasing in both matrices. | instruction | 0 | 39,659 | 12 | 79,318 |
Tags: brute force, greedy
Correct Solution:
```
from functools import reduce
n,m=list(map(int, input().split(' ')))
def is_rows_asc(lst):
res = True
for i in range(len(lst)):
for j in range(len(lst[i])-1):
if (lst[i][j] >= lst[i][j+1]):
return False
# res &= reduce(lambda x,y: x<y, lst[i])
return res
def is_cols_asc(lst):
res = True
for i in range(len(lst)-1):
for j in range(len(lst[i])):
if (lst[i][j] >= lst[i+1][j]):
return False
# res &= reduce(lambda x,y: x<y, [z[i] for z in lst])
return res
l1=[0 for _ in range(n)]
for i in range(n):
l1[i] = list(map(int, input().split(' ')))
l2=[0 for _ in range(n)]
for i in range(n):
l2[i] = list(map(int, input().split(' ')))
# print(l1)
# print(l2)
for i in range(n):
for j in range(m):
if l1[i][j] > l2[i][j]:
l1[i][j], l2[i][j] = l2[i][j], l1[i][j]
# print('-----------')
# print(l1)
# print(l2)
# print('-----------')
if (is_rows_asc(l1) and is_cols_asc(l1) and is_rows_asc(l2) and is_cols_asc(l2)):
print('Possible')
else:
print('Impossible')
``` | output | 1 | 39,659 | 12 | 79,319 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two n × m matrices containing integers. A sequence of integers is strictly increasing if each next number is greater than the previous one. A row is strictly increasing if all numbers from left to right are strictly increasing. A column is strictly increasing if all numbers from top to bottom are strictly increasing. A matrix is increasing if all rows are strictly increasing and all columns are strictly increasing.
For example, the matrix \begin{bmatrix} 9&10&11\\\ 11&12&14\\\ \end{bmatrix} is increasing because each individual row and column is strictly increasing. On the other hand, the matrix \begin{bmatrix} 1&1\\\ 2&3\\\ \end{bmatrix} is not increasing because the first row is not strictly increasing.
Let a position in the i-th row (from top) and j-th column (from left) in a matrix be denoted as (i, j).
In one operation, you can choose any two numbers i and j and swap the number located in (i, j) in the first matrix with the number in (i, j) in the second matrix. In other words, you can swap two numbers in different matrices if they are located in the corresponding positions.
You would like to make both matrices increasing by performing some number of operations (possibly none). Determine if it is possible to do this. If it is, print "Possible", otherwise, print "Impossible".
Input
The first line contains two integers n and m (1 ≤ n,m ≤ 50) — the dimensions of each matrix.
Each of the next n lines contains m integers a_{i1}, a_{i2}, …, a_{im} (1 ≤ a_{ij} ≤ 10^9) — the number located in position (i, j) in the first matrix.
Each of the next n lines contains m integers b_{i1}, b_{i2}, …, b_{im} (1 ≤ b_{ij} ≤ 10^9) — the number located in position (i, j) in the second matrix.
Output
Print a string "Impossible" or "Possible".
Examples
Input
2 2
2 10
11 5
9 4
3 12
Output
Possible
Input
2 3
2 4 5
4 5 6
3 6 7
8 10 11
Output
Possible
Input
3 2
1 3
2 4
5 10
3 1
3 6
4 8
Output
Impossible
Note
The first example, we can do an operation on the top left and bottom right cells of the matrices. The resulting matrices will be \begin{bmatrix} 9&10\\\ 11&12\\\ \end{bmatrix} and \begin{bmatrix} 2&4\\\ 3&5\\\ \end{bmatrix}.
In the second example, we don't need to do any operations.
In the third example, no matter what we swap, we can't fix the first row to be strictly increasing in both matrices. | instruction | 0 | 39,660 | 12 | 79,320 |
Tags: brute force, greedy
Correct Solution:
```
n,m=map(int,input().split())
mat1=[]
mat2=[]
for i in range(n):
mat1.append(list(map(int,input().split())))
for i in range(n):
mat2.append(list(map(int,input().split())))
for i in range(n):
for j in range(m):
if mat1[i][j]<mat2[i][j]:
mat1[i][j],mat2[i][j]=mat2[i][j],mat1[i][j]
for i in range(n):
for j in range(1,m):
if mat1[i][j]<=mat1[i][j-1]:
print ("Impossible")
exit(0)
if mat2[i][j]<=mat2[i][j-1]:
print ("Impossible")
exit(0)
for i in range(1,n):
for j in range(m):
if mat1[i][j]<=mat1[i-1][j]:
print ("Impossible")
exit(0)
if mat2[i][j]<=mat2[i-1][j]:
print ("Impossible")
exit(0)
print ("Possible")
``` | output | 1 | 39,660 | 12 | 79,321 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two n × m matrices containing integers. A sequence of integers is strictly increasing if each next number is greater than the previous one. A row is strictly increasing if all numbers from left to right are strictly increasing. A column is strictly increasing if all numbers from top to bottom are strictly increasing. A matrix is increasing if all rows are strictly increasing and all columns are strictly increasing.
For example, the matrix \begin{bmatrix} 9&10&11\\\ 11&12&14\\\ \end{bmatrix} is increasing because each individual row and column is strictly increasing. On the other hand, the matrix \begin{bmatrix} 1&1\\\ 2&3\\\ \end{bmatrix} is not increasing because the first row is not strictly increasing.
Let a position in the i-th row (from top) and j-th column (from left) in a matrix be denoted as (i, j).
In one operation, you can choose any two numbers i and j and swap the number located in (i, j) in the first matrix with the number in (i, j) in the second matrix. In other words, you can swap two numbers in different matrices if they are located in the corresponding positions.
You would like to make both matrices increasing by performing some number of operations (possibly none). Determine if it is possible to do this. If it is, print "Possible", otherwise, print "Impossible".
Input
The first line contains two integers n and m (1 ≤ n,m ≤ 50) — the dimensions of each matrix.
Each of the next n lines contains m integers a_{i1}, a_{i2}, …, a_{im} (1 ≤ a_{ij} ≤ 10^9) — the number located in position (i, j) in the first matrix.
Each of the next n lines contains m integers b_{i1}, b_{i2}, …, b_{im} (1 ≤ b_{ij} ≤ 10^9) — the number located in position (i, j) in the second matrix.
Output
Print a string "Impossible" or "Possible".
Examples
Input
2 2
2 10
11 5
9 4
3 12
Output
Possible
Input
2 3
2 4 5
4 5 6
3 6 7
8 10 11
Output
Possible
Input
3 2
1 3
2 4
5 10
3 1
3 6
4 8
Output
Impossible
Note
The first example, we can do an operation on the top left and bottom right cells of the matrices. The resulting matrices will be \begin{bmatrix} 9&10\\\ 11&12\\\ \end{bmatrix} and \begin{bmatrix} 2&4\\\ 3&5\\\ \end{bmatrix}.
In the second example, we don't need to do any operations.
In the third example, no matter what we swap, we can't fix the first row to be strictly increasing in both matrices. | instruction | 0 | 39,661 | 12 | 79,322 |
Tags: brute force, greedy
Correct Solution:
```
n, m = map(int, input().split())
a = [[]] * n
b = [[]] * n
for i in range(n):
a[i] = list(map(int, input().split()))
for i in range(n):
b[i] = list(map(int, input().split()))
#print(a, b)
for i in range(n):
for j in range(m):
prev = a[i][j]
a[i][j] = min(a[i][j], b[i][j])
b[i][j] = max(prev, b[i][j])
for i in range(n):
prev = a[i][0]
for j in range(1, m):
if (a[i][j] <= prev):
print("Impossible")
exit(0)
prev = a[i][j]
for j in range(m):
prev = a[0][j]
for i in range(1, n):
if (a[i][j] <= prev):
print("Impossible")
exit(0)
prev = a[i][j]
for i in range(n):
prev = b[i][0]
for j in range(1, m):
if (b[i][j] <= prev):
print("Impossible")
exit(0)
prev = b[i][j]
for j in range(m):
prev = b[0][j]
for i in range(1, n):
if (b[i][j] <= prev):
print("Impossible")
exit(0)
prev = b[i][j]
print("Possible")
``` | output | 1 | 39,661 | 12 | 79,323 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two n × m matrices containing integers. A sequence of integers is strictly increasing if each next number is greater than the previous one. A row is strictly increasing if all numbers from left to right are strictly increasing. A column is strictly increasing if all numbers from top to bottom are strictly increasing. A matrix is increasing if all rows are strictly increasing and all columns are strictly increasing.
For example, the matrix \begin{bmatrix} 9&10&11\\\ 11&12&14\\\ \end{bmatrix} is increasing because each individual row and column is strictly increasing. On the other hand, the matrix \begin{bmatrix} 1&1\\\ 2&3\\\ \end{bmatrix} is not increasing because the first row is not strictly increasing.
Let a position in the i-th row (from top) and j-th column (from left) in a matrix be denoted as (i, j).
In one operation, you can choose any two numbers i and j and swap the number located in (i, j) in the first matrix with the number in (i, j) in the second matrix. In other words, you can swap two numbers in different matrices if they are located in the corresponding positions.
You would like to make both matrices increasing by performing some number of operations (possibly none). Determine if it is possible to do this. If it is, print "Possible", otherwise, print "Impossible".
Input
The first line contains two integers n and m (1 ≤ n,m ≤ 50) — the dimensions of each matrix.
Each of the next n lines contains m integers a_{i1}, a_{i2}, …, a_{im} (1 ≤ a_{ij} ≤ 10^9) — the number located in position (i, j) in the first matrix.
Each of the next n lines contains m integers b_{i1}, b_{i2}, …, b_{im} (1 ≤ b_{ij} ≤ 10^9) — the number located in position (i, j) in the second matrix.
Output
Print a string "Impossible" or "Possible".
Examples
Input
2 2
2 10
11 5
9 4
3 12
Output
Possible
Input
2 3
2 4 5
4 5 6
3 6 7
8 10 11
Output
Possible
Input
3 2
1 3
2 4
5 10
3 1
3 6
4 8
Output
Impossible
Note
The first example, we can do an operation on the top left and bottom right cells of the matrices. The resulting matrices will be \begin{bmatrix} 9&10\\\ 11&12\\\ \end{bmatrix} and \begin{bmatrix} 2&4\\\ 3&5\\\ \end{bmatrix}.
In the second example, we don't need to do any operations.
In the third example, no matter what we swap, we can't fix the first row to be strictly increasing in both matrices. | instruction | 0 | 39,662 | 12 | 79,324 |
Tags: brute force, greedy
Correct Solution:
```
n,m=map(int,input().split())
ans1=[]
ans2=[]
for i in range(n):
t=list(map(int,input().split()))
ans1.append(t)
for i in range(n):
t=list(map(int,input().split()))
ans2.append(t)
ans3=[[0 for i in range(m)] for i in range(n)]
gns=[[0 for i in range(m)] for i in range(n)]
flag=0
for i in range(n):
for j in range(m):
m1=min(ans1[i][j],ans2[i][j])
m2=max(ans1[i][j],ans2[i][j])
if(i==0):
e1=0
else:
e1=ans3[i-1][j]
if(j==0):
e2=0
else:
e2=ans3[i][j-1]
if(m1>max(e1,e2)):
ans3[i][j]=m1
gns[i][j]=m2
elif(m2>max(e1,e2)):
ans3[i][j]=m2
gns[i][j]=m1
else:
flag=1
break;
for i in range(n):
for j in range(m):
if(i==0):
e1=0
else:
e1=gns[i-1][j]
if(j==0):
e2=0
else:
e2=gns[i][j-1]
if(gns[i][j]<=max(e1,e2)):
flag=1
break;
if(flag==1):
print('Impossible')
else:
print('Possible')
``` | output | 1 | 39,662 | 12 | 79,325 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two n × m matrices containing integers. A sequence of integers is strictly increasing if each next number is greater than the previous one. A row is strictly increasing if all numbers from left to right are strictly increasing. A column is strictly increasing if all numbers from top to bottom are strictly increasing. A matrix is increasing if all rows are strictly increasing and all columns are strictly increasing.
For example, the matrix \begin{bmatrix} 9&10&11\\\ 11&12&14\\\ \end{bmatrix} is increasing because each individual row and column is strictly increasing. On the other hand, the matrix \begin{bmatrix} 1&1\\\ 2&3\\\ \end{bmatrix} is not increasing because the first row is not strictly increasing.
Let a position in the i-th row (from top) and j-th column (from left) in a matrix be denoted as (i, j).
In one operation, you can choose any two numbers i and j and swap the number located in (i, j) in the first matrix with the number in (i, j) in the second matrix. In other words, you can swap two numbers in different matrices if they are located in the corresponding positions.
You would like to make both matrices increasing by performing some number of operations (possibly none). Determine if it is possible to do this. If it is, print "Possible", otherwise, print "Impossible".
Input
The first line contains two integers n and m (1 ≤ n,m ≤ 50) — the dimensions of each matrix.
Each of the next n lines contains m integers a_{i1}, a_{i2}, …, a_{im} (1 ≤ a_{ij} ≤ 10^9) — the number located in position (i, j) in the first matrix.
Each of the next n lines contains m integers b_{i1}, b_{i2}, …, b_{im} (1 ≤ b_{ij} ≤ 10^9) — the number located in position (i, j) in the second matrix.
Output
Print a string "Impossible" or "Possible".
Examples
Input
2 2
2 10
11 5
9 4
3 12
Output
Possible
Input
2 3
2 4 5
4 5 6
3 6 7
8 10 11
Output
Possible
Input
3 2
1 3
2 4
5 10
3 1
3 6
4 8
Output
Impossible
Note
The first example, we can do an operation on the top left and bottom right cells of the matrices. The resulting matrices will be \begin{bmatrix} 9&10\\\ 11&12\\\ \end{bmatrix} and \begin{bmatrix} 2&4\\\ 3&5\\\ \end{bmatrix}.
In the second example, we don't need to do any operations.
In the third example, no matter what we swap, we can't fix the first row to be strictly increasing in both matrices. | instruction | 0 | 39,663 | 12 | 79,326 |
Tags: brute force, greedy
Correct Solution:
```
n, m = map(int, input().split())
matrix1 = []
matrix2 = []
for i in range(n):
matrix1.append([int(z) for z in input().split()])
for i in range(n):
matrix2.append([int(z) for z in input().split()])
#print(matrix1, matrix2)
newmatrix1, newmatrix2 = [], []
for i in range(n):
r1, r2 = [], []
for j in range(m):
r1.append(max(matrix1[i][j], matrix2[i][j]))
r2.append(min(matrix1[i][j], matrix2[i][j]))
newmatrix1.append(r1)
newmatrix2.append(r2)
#print(newmatrix1, newmatrix2)
c1 = 0
for i in range(n):
if newmatrix1[i] == sorted(list(set(newmatrix1[i]))) and newmatrix2[i] == sorted(list(set(newmatrix2[i]))):
c1 += 1
c1 -= 1
c2 = 0
for j in range(m):
col1 = []
col2 = []
for i in range(n):
col1.append(newmatrix1[i][j])
col2.append(newmatrix2[i][j])
if col1 == sorted(list(set(col1))) and col2 == sorted(list(set(col2))):
c2 += 1
c2 -= 1
if c1 == 0 == c2:
print("Possible")
else:
print("Impossible")
``` | output | 1 | 39,663 | 12 | 79,327 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two n × m matrices containing integers. A sequence of integers is strictly increasing if each next number is greater than the previous one. A row is strictly increasing if all numbers from left to right are strictly increasing. A column is strictly increasing if all numbers from top to bottom are strictly increasing. A matrix is increasing if all rows are strictly increasing and all columns are strictly increasing.
For example, the matrix \begin{bmatrix} 9&10&11\\\ 11&12&14\\\ \end{bmatrix} is increasing because each individual row and column is strictly increasing. On the other hand, the matrix \begin{bmatrix} 1&1\\\ 2&3\\\ \end{bmatrix} is not increasing because the first row is not strictly increasing.
Let a position in the i-th row (from top) and j-th column (from left) in a matrix be denoted as (i, j).
In one operation, you can choose any two numbers i and j and swap the number located in (i, j) in the first matrix with the number in (i, j) in the second matrix. In other words, you can swap two numbers in different matrices if they are located in the corresponding positions.
You would like to make both matrices increasing by performing some number of operations (possibly none). Determine if it is possible to do this. If it is, print "Possible", otherwise, print "Impossible".
Input
The first line contains two integers n and m (1 ≤ n,m ≤ 50) — the dimensions of each matrix.
Each of the next n lines contains m integers a_{i1}, a_{i2}, …, a_{im} (1 ≤ a_{ij} ≤ 10^9) — the number located in position (i, j) in the first matrix.
Each of the next n lines contains m integers b_{i1}, b_{i2}, …, b_{im} (1 ≤ b_{ij} ≤ 10^9) — the number located in position (i, j) in the second matrix.
Output
Print a string "Impossible" or "Possible".
Examples
Input
2 2
2 10
11 5
9 4
3 12
Output
Possible
Input
2 3
2 4 5
4 5 6
3 6 7
8 10 11
Output
Possible
Input
3 2
1 3
2 4
5 10
3 1
3 6
4 8
Output
Impossible
Note
The first example, we can do an operation on the top left and bottom right cells of the matrices. The resulting matrices will be \begin{bmatrix} 9&10\\\ 11&12\\\ \end{bmatrix} and \begin{bmatrix} 2&4\\\ 3&5\\\ \end{bmatrix}.
In the second example, we don't need to do any operations.
In the third example, no matter what we swap, we can't fix the first row to be strictly increasing in both matrices.
Submitted Solution:
```
import sys
def swap(row, col, matrix1, matrix2):
old_val = matrix1[row][col]
matrix1[row][col] = matrix2[row][col]
matrix2[row][col] = old_val
def everythingCool(row, col, matrix1, matrix2):
if col != 0 and (matrix1[row][col-1] >= matrix1[row][col] or matrix2[row][col-1] >= matrix2[row][col]):
return False
if row != 0 and (matrix1[row-1][col] >= matrix1[row][col] or matrix2[row-1][col] >= matrix2[row][col]):
return False
return True
def check_row(row, matrix1, matrix2, row_size, col_size):
for col in range(col_size):
if matrix1[row][col] > matrix2[row][col]:
swap(row, col, matrix1, matrix2)
if not(everythingCool(row, col, matrix1, matrix2)):
return False
return True
size = input().split(" ")
row_size = int(size[0])
col_size = int(size[1])
matrix1 = []
matrix2 = []
for i in range(row_size):
line = input().split(" ")
matrix1.append([int(x) for x in line])
for i in range(row_size):
line = input().split(" ")
matrix2.append([int(x) for x in line])
for row in range(row_size):
if not(check_row(row, matrix1, matrix2, row_size, col_size)):
print("Impossible")
sys.exit(0)
print("Possible")
``` | instruction | 0 | 39,664 | 12 | 79,328 |
Yes | output | 1 | 39,664 | 12 | 79,329 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two n × m matrices containing integers. A sequence of integers is strictly increasing if each next number is greater than the previous one. A row is strictly increasing if all numbers from left to right are strictly increasing. A column is strictly increasing if all numbers from top to bottom are strictly increasing. A matrix is increasing if all rows are strictly increasing and all columns are strictly increasing.
For example, the matrix \begin{bmatrix} 9&10&11\\\ 11&12&14\\\ \end{bmatrix} is increasing because each individual row and column is strictly increasing. On the other hand, the matrix \begin{bmatrix} 1&1\\\ 2&3\\\ \end{bmatrix} is not increasing because the first row is not strictly increasing.
Let a position in the i-th row (from top) and j-th column (from left) in a matrix be denoted as (i, j).
In one operation, you can choose any two numbers i and j and swap the number located in (i, j) in the first matrix with the number in (i, j) in the second matrix. In other words, you can swap two numbers in different matrices if they are located in the corresponding positions.
You would like to make both matrices increasing by performing some number of operations (possibly none). Determine if it is possible to do this. If it is, print "Possible", otherwise, print "Impossible".
Input
The first line contains two integers n and m (1 ≤ n,m ≤ 50) — the dimensions of each matrix.
Each of the next n lines contains m integers a_{i1}, a_{i2}, …, a_{im} (1 ≤ a_{ij} ≤ 10^9) — the number located in position (i, j) in the first matrix.
Each of the next n lines contains m integers b_{i1}, b_{i2}, …, b_{im} (1 ≤ b_{ij} ≤ 10^9) — the number located in position (i, j) in the second matrix.
Output
Print a string "Impossible" or "Possible".
Examples
Input
2 2
2 10
11 5
9 4
3 12
Output
Possible
Input
2 3
2 4 5
4 5 6
3 6 7
8 10 11
Output
Possible
Input
3 2
1 3
2 4
5 10
3 1
3 6
4 8
Output
Impossible
Note
The first example, we can do an operation on the top left and bottom right cells of the matrices. The resulting matrices will be \begin{bmatrix} 9&10\\\ 11&12\\\ \end{bmatrix} and \begin{bmatrix} 2&4\\\ 3&5\\\ \end{bmatrix}.
In the second example, we don't need to do any operations.
In the third example, no matter what we swap, we can't fix the first row to be strictly increasing in both matrices.
Submitted Solution:
```
n, m = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
b = [list(map(int, input().split())) for _ in range(n)]
order = lambda x, y: (min(x, y), max(x, y))
for r in range(n):
for c in range(m):
mi, mx = order(a[r][c], b[r][c])
a[r][c], b[r][c] = mi, mx
def ok(w):
for r in range(n):
for c in range(m - 1):
if w[r][c] >= w[r][c + 1]: return False
for c in range(m):
for r in range(n - 1):
if w[r][c] >= w[r + 1][c]: return False
return True
if ok(a) and ok(b):
print('Possible')
else:
print('Impossible')
``` | instruction | 0 | 39,665 | 12 | 79,330 |
Yes | output | 1 | 39,665 | 12 | 79,331 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two n × m matrices containing integers. A sequence of integers is strictly increasing if each next number is greater than the previous one. A row is strictly increasing if all numbers from left to right are strictly increasing. A column is strictly increasing if all numbers from top to bottom are strictly increasing. A matrix is increasing if all rows are strictly increasing and all columns are strictly increasing.
For example, the matrix \begin{bmatrix} 9&10&11\\\ 11&12&14\\\ \end{bmatrix} is increasing because each individual row and column is strictly increasing. On the other hand, the matrix \begin{bmatrix} 1&1\\\ 2&3\\\ \end{bmatrix} is not increasing because the first row is not strictly increasing.
Let a position in the i-th row (from top) and j-th column (from left) in a matrix be denoted as (i, j).
In one operation, you can choose any two numbers i and j and swap the number located in (i, j) in the first matrix with the number in (i, j) in the second matrix. In other words, you can swap two numbers in different matrices if they are located in the corresponding positions.
You would like to make both matrices increasing by performing some number of operations (possibly none). Determine if it is possible to do this. If it is, print "Possible", otherwise, print "Impossible".
Input
The first line contains two integers n and m (1 ≤ n,m ≤ 50) — the dimensions of each matrix.
Each of the next n lines contains m integers a_{i1}, a_{i2}, …, a_{im} (1 ≤ a_{ij} ≤ 10^9) — the number located in position (i, j) in the first matrix.
Each of the next n lines contains m integers b_{i1}, b_{i2}, …, b_{im} (1 ≤ b_{ij} ≤ 10^9) — the number located in position (i, j) in the second matrix.
Output
Print a string "Impossible" or "Possible".
Examples
Input
2 2
2 10
11 5
9 4
3 12
Output
Possible
Input
2 3
2 4 5
4 5 6
3 6 7
8 10 11
Output
Possible
Input
3 2
1 3
2 4
5 10
3 1
3 6
4 8
Output
Impossible
Note
The first example, we can do an operation on the top left and bottom right cells of the matrices. The resulting matrices will be \begin{bmatrix} 9&10\\\ 11&12\\\ \end{bmatrix} and \begin{bmatrix} 2&4\\\ 3&5\\\ \end{bmatrix}.
In the second example, we don't need to do any operations.
In the third example, no matter what we swap, we can't fix the first row to be strictly increasing in both matrices.
Submitted Solution:
```
n, m = map(int, input().split())
M1 = []
M2 = []
for i in range(n):
M1.append(list(map(int, input().split())))
for i in range(n):
M2.append(list(map(int, input().split())))
for i in range(n):
for j in range(m):
M1[i][j], M2[i][j] = min(M1[i][j], M2[i][j]), max(M1[i][j], M2[i][j])
f = 1
for i in range(n):
for j in range(m):
if i > 0 and (M1[i][j] <= M1[i-1][j] or M2[i][j] <= M2[i-1][j]):
f = 0
break
if j > 0 and (M1[i][j] <= M1[i][j-1] or M2[i][j] <= M2[i][j-1]):
f = 0
break
#print(M1)
#print(M2)
if f == 1:
print("Possible")
else:
print("Impossible")
``` | instruction | 0 | 39,666 | 12 | 79,332 |
Yes | output | 1 | 39,666 | 12 | 79,333 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two n × m matrices containing integers. A sequence of integers is strictly increasing if each next number is greater than the previous one. A row is strictly increasing if all numbers from left to right are strictly increasing. A column is strictly increasing if all numbers from top to bottom are strictly increasing. A matrix is increasing if all rows are strictly increasing and all columns are strictly increasing.
For example, the matrix \begin{bmatrix} 9&10&11\\\ 11&12&14\\\ \end{bmatrix} is increasing because each individual row and column is strictly increasing. On the other hand, the matrix \begin{bmatrix} 1&1\\\ 2&3\\\ \end{bmatrix} is not increasing because the first row is not strictly increasing.
Let a position in the i-th row (from top) and j-th column (from left) in a matrix be denoted as (i, j).
In one operation, you can choose any two numbers i and j and swap the number located in (i, j) in the first matrix with the number in (i, j) in the second matrix. In other words, you can swap two numbers in different matrices if they are located in the corresponding positions.
You would like to make both matrices increasing by performing some number of operations (possibly none). Determine if it is possible to do this. If it is, print "Possible", otherwise, print "Impossible".
Input
The first line contains two integers n and m (1 ≤ n,m ≤ 50) — the dimensions of each matrix.
Each of the next n lines contains m integers a_{i1}, a_{i2}, …, a_{im} (1 ≤ a_{ij} ≤ 10^9) — the number located in position (i, j) in the first matrix.
Each of the next n lines contains m integers b_{i1}, b_{i2}, …, b_{im} (1 ≤ b_{ij} ≤ 10^9) — the number located in position (i, j) in the second matrix.
Output
Print a string "Impossible" or "Possible".
Examples
Input
2 2
2 10
11 5
9 4
3 12
Output
Possible
Input
2 3
2 4 5
4 5 6
3 6 7
8 10 11
Output
Possible
Input
3 2
1 3
2 4
5 10
3 1
3 6
4 8
Output
Impossible
Note
The first example, we can do an operation on the top left and bottom right cells of the matrices. The resulting matrices will be \begin{bmatrix} 9&10\\\ 11&12\\\ \end{bmatrix} and \begin{bmatrix} 2&4\\\ 3&5\\\ \end{bmatrix}.
In the second example, we don't need to do any operations.
In the third example, no matter what we swap, we can't fix the first row to be strictly increasing in both matrices.
Submitted Solution:
```
def chek(a):
flag = False
for i in range(1, len(a)):
for j in range(1, len(a[i])):
if a[i][j] <= a[i - 1][j] or a[i][j] <= a[i][j - 1]:
flag = True
if flag:
return False
return True
n, m = map(int, input().split())
a = [list(map(int, input().split())) for i in range(n)]
b = [list(map(int, input().split())) for i in range(n)]
flag = False
a1 = [[-1 for k in range(m + 1)] for l in range(n + 1)]
for k in range(n):
for l in range(m):
a1[k + 1][l + 1] = min(a[k][l], b[k][l])
b1 = [[-1 for k in range(m + 1)] for l in range(n + 1)]
for k in range(n):
for l in range(m):
b1[k + 1][l + 1] = max(b[k][l], a[k][l])
if chek(b1) and chek(a1):
flag = True
if flag:
print("Possible")
else:
print("Impossible")
``` | instruction | 0 | 39,667 | 12 | 79,334 |
Yes | output | 1 | 39,667 | 12 | 79,335 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two n × m matrices containing integers. A sequence of integers is strictly increasing if each next number is greater than the previous one. A row is strictly increasing if all numbers from left to right are strictly increasing. A column is strictly increasing if all numbers from top to bottom are strictly increasing. A matrix is increasing if all rows are strictly increasing and all columns are strictly increasing.
For example, the matrix \begin{bmatrix} 9&10&11\\\ 11&12&14\\\ \end{bmatrix} is increasing because each individual row and column is strictly increasing. On the other hand, the matrix \begin{bmatrix} 1&1\\\ 2&3\\\ \end{bmatrix} is not increasing because the first row is not strictly increasing.
Let a position in the i-th row (from top) and j-th column (from left) in a matrix be denoted as (i, j).
In one operation, you can choose any two numbers i and j and swap the number located in (i, j) in the first matrix with the number in (i, j) in the second matrix. In other words, you can swap two numbers in different matrices if they are located in the corresponding positions.
You would like to make both matrices increasing by performing some number of operations (possibly none). Determine if it is possible to do this. If it is, print "Possible", otherwise, print "Impossible".
Input
The first line contains two integers n and m (1 ≤ n,m ≤ 50) — the dimensions of each matrix.
Each of the next n lines contains m integers a_{i1}, a_{i2}, …, a_{im} (1 ≤ a_{ij} ≤ 10^9) — the number located in position (i, j) in the first matrix.
Each of the next n lines contains m integers b_{i1}, b_{i2}, …, b_{im} (1 ≤ b_{ij} ≤ 10^9) — the number located in position (i, j) in the second matrix.
Output
Print a string "Impossible" or "Possible".
Examples
Input
2 2
2 10
11 5
9 4
3 12
Output
Possible
Input
2 3
2 4 5
4 5 6
3 6 7
8 10 11
Output
Possible
Input
3 2
1 3
2 4
5 10
3 1
3 6
4 8
Output
Impossible
Note
The first example, we can do an operation on the top left and bottom right cells of the matrices. The resulting matrices will be \begin{bmatrix} 9&10\\\ 11&12\\\ \end{bmatrix} and \begin{bmatrix} 2&4\\\ 3&5\\\ \end{bmatrix}.
In the second example, we don't need to do any operations.
In the third example, no matter what we swap, we can't fix the first row to be strictly increasing in both matrices.
Submitted Solution:
```
i=lambda:[*map(int,input().split())]
n,m=i()
a,b=[[i()for _ in range(n)]for _ in[0,1]]
for x in range(n):
for y in range(m):
if a[x][y] > b[x][y]:a[x][y], b[x][y] = b[x][y], a[x][y]
def g(c):
for x in range(n-1):
for y in range(m):
if a[x][y] > a[x+1][y]: return 1
for x in range(n):
for y in range(m-1):
if a[x][y] > a[x][y+1]: return 1
return 0
print('Imp'if(g(a)|g(b))else'P'+'ossible')
``` | instruction | 0 | 39,668 | 12 | 79,336 |
No | output | 1 | 39,668 | 12 | 79,337 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two n × m matrices containing integers. A sequence of integers is strictly increasing if each next number is greater than the previous one. A row is strictly increasing if all numbers from left to right are strictly increasing. A column is strictly increasing if all numbers from top to bottom are strictly increasing. A matrix is increasing if all rows are strictly increasing and all columns are strictly increasing.
For example, the matrix \begin{bmatrix} 9&10&11\\\ 11&12&14\\\ \end{bmatrix} is increasing because each individual row and column is strictly increasing. On the other hand, the matrix \begin{bmatrix} 1&1\\\ 2&3\\\ \end{bmatrix} is not increasing because the first row is not strictly increasing.
Let a position in the i-th row (from top) and j-th column (from left) in a matrix be denoted as (i, j).
In one operation, you can choose any two numbers i and j and swap the number located in (i, j) in the first matrix with the number in (i, j) in the second matrix. In other words, you can swap two numbers in different matrices if they are located in the corresponding positions.
You would like to make both matrices increasing by performing some number of operations (possibly none). Determine if it is possible to do this. If it is, print "Possible", otherwise, print "Impossible".
Input
The first line contains two integers n and m (1 ≤ n,m ≤ 50) — the dimensions of each matrix.
Each of the next n lines contains m integers a_{i1}, a_{i2}, …, a_{im} (1 ≤ a_{ij} ≤ 10^9) — the number located in position (i, j) in the first matrix.
Each of the next n lines contains m integers b_{i1}, b_{i2}, …, b_{im} (1 ≤ b_{ij} ≤ 10^9) — the number located in position (i, j) in the second matrix.
Output
Print a string "Impossible" or "Possible".
Examples
Input
2 2
2 10
11 5
9 4
3 12
Output
Possible
Input
2 3
2 4 5
4 5 6
3 6 7
8 10 11
Output
Possible
Input
3 2
1 3
2 4
5 10
3 1
3 6
4 8
Output
Impossible
Note
The first example, we can do an operation on the top left and bottom right cells of the matrices. The resulting matrices will be \begin{bmatrix} 9&10\\\ 11&12\\\ \end{bmatrix} and \begin{bmatrix} 2&4\\\ 3&5\\\ \end{bmatrix}.
In the second example, we don't need to do any operations.
In the third example, no matter what we swap, we can't fix the first row to be strictly increasing in both matrices.
Submitted Solution:
```
n, m = [int(item) for item in input().split()]
a = []
b = []
for _ in range(n):
a.append([int(item) for item in input().split()])
for _ in range(n):
b.append([int(item) for item in input().split()])
def ok(arr, i, j):
if i == 0 and j == 0:
return True
elif i == 0:
return arr[i][j] > arr[i][j - 1]
elif j == 0:
return arr[i][j] > arr[i - 1][j]
return arr[i][j] > max(arr[i][j - 1], arr[i - 1][j])
def solve():
for i in range(n):
for j in range(m):
if ok(a, i, j) and ok(b, i, j):
continue
a[i][j], b[i][j] = min(b[i][j], a[i][j]), max(b[i][j], a[i][j])
if not ok(a, i, j) or not ok(b, i, j):
return False
return True
print("Possible" if solve() else "Impossible")
``` | instruction | 0 | 39,669 | 12 | 79,338 |
No | output | 1 | 39,669 | 12 | 79,339 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two n × m matrices containing integers. A sequence of integers is strictly increasing if each next number is greater than the previous one. A row is strictly increasing if all numbers from left to right are strictly increasing. A column is strictly increasing if all numbers from top to bottom are strictly increasing. A matrix is increasing if all rows are strictly increasing and all columns are strictly increasing.
For example, the matrix \begin{bmatrix} 9&10&11\\\ 11&12&14\\\ \end{bmatrix} is increasing because each individual row and column is strictly increasing. On the other hand, the matrix \begin{bmatrix} 1&1\\\ 2&3\\\ \end{bmatrix} is not increasing because the first row is not strictly increasing.
Let a position in the i-th row (from top) and j-th column (from left) in a matrix be denoted as (i, j).
In one operation, you can choose any two numbers i and j and swap the number located in (i, j) in the first matrix with the number in (i, j) in the second matrix. In other words, you can swap two numbers in different matrices if they are located in the corresponding positions.
You would like to make both matrices increasing by performing some number of operations (possibly none). Determine if it is possible to do this. If it is, print "Possible", otherwise, print "Impossible".
Input
The first line contains two integers n and m (1 ≤ n,m ≤ 50) — the dimensions of each matrix.
Each of the next n lines contains m integers a_{i1}, a_{i2}, …, a_{im} (1 ≤ a_{ij} ≤ 10^9) — the number located in position (i, j) in the first matrix.
Each of the next n lines contains m integers b_{i1}, b_{i2}, …, b_{im} (1 ≤ b_{ij} ≤ 10^9) — the number located in position (i, j) in the second matrix.
Output
Print a string "Impossible" or "Possible".
Examples
Input
2 2
2 10
11 5
9 4
3 12
Output
Possible
Input
2 3
2 4 5
4 5 6
3 6 7
8 10 11
Output
Possible
Input
3 2
1 3
2 4
5 10
3 1
3 6
4 8
Output
Impossible
Note
The first example, we can do an operation on the top left and bottom right cells of the matrices. The resulting matrices will be \begin{bmatrix} 9&10\\\ 11&12\\\ \end{bmatrix} and \begin{bmatrix} 2&4\\\ 3&5\\\ \end{bmatrix}.
In the second example, we don't need to do any operations.
In the third example, no matter what we swap, we can't fix the first row to be strictly increasing in both matrices.
Submitted Solution:
```
n, m = [int(x) for x in input().split()]
a = []
b =[]
T_F = True
for i in range(n):
a.append([int(x) for x in input().split()])
for i in range(n):
b.append([int(x) for x in input().split()])
for i in range(n):
for j in range(m):
if a[i][j] > b[i][j]:
a[i][j], b[i][j] = b[i][j], a[i][j]
if i-1>=0 and j-1>=0:
if (a[i-1][j-1] >= a[i][j-1] or a[i-1][j-1] >= a[i-1][j]) or (b[i-1][j-1] >= b[i][j-1] or b[i-1][j-1] >= b[i-1][j]):
T_F = False
break
elif T_F:
T_F = True
if T_F:
print('Possible')
else:
print('Impossible')
``` | instruction | 0 | 39,670 | 12 | 79,340 |
No | output | 1 | 39,670 | 12 | 79,341 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two n × m matrices containing integers. A sequence of integers is strictly increasing if each next number is greater than the previous one. A row is strictly increasing if all numbers from left to right are strictly increasing. A column is strictly increasing if all numbers from top to bottom are strictly increasing. A matrix is increasing if all rows are strictly increasing and all columns are strictly increasing.
For example, the matrix \begin{bmatrix} 9&10&11\\\ 11&12&14\\\ \end{bmatrix} is increasing because each individual row and column is strictly increasing. On the other hand, the matrix \begin{bmatrix} 1&1\\\ 2&3\\\ \end{bmatrix} is not increasing because the first row is not strictly increasing.
Let a position in the i-th row (from top) and j-th column (from left) in a matrix be denoted as (i, j).
In one operation, you can choose any two numbers i and j and swap the number located in (i, j) in the first matrix with the number in (i, j) in the second matrix. In other words, you can swap two numbers in different matrices if they are located in the corresponding positions.
You would like to make both matrices increasing by performing some number of operations (possibly none). Determine if it is possible to do this. If it is, print "Possible", otherwise, print "Impossible".
Input
The first line contains two integers n and m (1 ≤ n,m ≤ 50) — the dimensions of each matrix.
Each of the next n lines contains m integers a_{i1}, a_{i2}, …, a_{im} (1 ≤ a_{ij} ≤ 10^9) — the number located in position (i, j) in the first matrix.
Each of the next n lines contains m integers b_{i1}, b_{i2}, …, b_{im} (1 ≤ b_{ij} ≤ 10^9) — the number located in position (i, j) in the second matrix.
Output
Print a string "Impossible" or "Possible".
Examples
Input
2 2
2 10
11 5
9 4
3 12
Output
Possible
Input
2 3
2 4 5
4 5 6
3 6 7
8 10 11
Output
Possible
Input
3 2
1 3
2 4
5 10
3 1
3 6
4 8
Output
Impossible
Note
The first example, we can do an operation on the top left and bottom right cells of the matrices. The resulting matrices will be \begin{bmatrix} 9&10\\\ 11&12\\\ \end{bmatrix} and \begin{bmatrix} 2&4\\\ 3&5\\\ \end{bmatrix}.
In the second example, we don't need to do any operations.
In the third example, no matter what we swap, we can't fix the first row to be strictly increasing in both matrices.
Submitted Solution:
```
n, m = map(int, input().split())
mat1 = []
mat2 = []
for _ in range(n):
inp = list(map(int, input().split()))
mat1.append(inp)
for _ in range(n):
inp = list(map(int, input().split()))
mat2.append(inp)
poss = 1
for i in range(n):
for j in range(m - 1):
if min(mat1[i][j], mat2[i][j]) < min(mat1[i][j + 1], mat2[i][j + 1]):
if max(mat1[i][j], mat2[i][j]) < max(mat1[i][j + 1], mat2[i][j + 1]):
pass
else:
poss = 0
break
else:
poss = 0
break
if poss:
print("Possible")
else:
print("Impossible")
``` | instruction | 0 | 39,671 | 12 | 79,342 |
No | output | 1 | 39,671 | 12 | 79,343 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the easier version of the problem. In this version 1 ≤ n, m ≤ 100. You can hack this problem only if you solve and lock both problems.
You are given a sequence of integers a=[a_1,a_2,...,a_n] of length n. Its subsequence is obtained by removing zero or more elements from the sequence a (they do not necessarily go consecutively). For example, for the sequence a=[11,20,11,33,11,20,11]:
* [11,20,11,33,11,20,11], [11,20,11,33,11,20], [11,11,11,11], [20], [33,20] are subsequences (these are just some of the long list);
* [40], [33,33], [33,20,20], [20,20,11,11] are not subsequences.
Suppose that an additional non-negative integer k (1 ≤ k ≤ n) is given, then the subsequence is called optimal if:
* it has a length of k and the sum of its elements is the maximum possible among all subsequences of length k;
* and among all subsequences of length k that satisfy the previous item, it is lexicographically minimal.
Recall that the sequence b=[b_1, b_2, ..., b_k] is lexicographically smaller than the sequence c=[c_1, c_2, ..., c_k] if the first element (from the left) in which they differ less in the sequence b than in c. Formally: there exists t (1 ≤ t ≤ k) such that b_1=c_1, b_2=c_2, ..., b_{t-1}=c_{t-1} and at the same time b_t<c_t. For example:
* [10, 20, 20] lexicographically less than [10, 21, 1],
* [7, 99, 99] is lexicographically less than [10, 21, 1],
* [10, 21, 0] is lexicographically less than [10, 21, 1].
You are given a sequence of a=[a_1,a_2,...,a_n] and m requests, each consisting of two numbers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j). For each query, print the value that is in the index pos_j of the optimal subsequence of the given sequence a for k=k_j.
For example, if n=4, a=[10,20,30,20], k_j=2, then the optimal subsequence is [20,30] — it is the minimum lexicographically among all subsequences of length 2 with the maximum total sum of items. Thus, the answer to the request k_j=2, pos_j=1 is the number 20, and the answer to the request k_j=2, pos_j=2 is the number 30.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the length of the sequence a.
The second line contains elements of the sequence a: integer numbers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The third line contains an integer m (1 ≤ m ≤ 100) — the number of requests.
The following m lines contain pairs of integers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j) — the requests.
Output
Print m integers r_1, r_2, ..., r_m (1 ≤ r_j ≤ 10^9) one per line: answers to the requests in the order they appear in the input. The value of r_j should be equal to the value contained in the position pos_j of the optimal subsequence for k=k_j.
Examples
Input
3
10 20 10
6
1 1
2 1
2 2
3 1
3 2
3 3
Output
20
10
20
10
20
10
Input
7
1 2 1 3 1 2 1
9
2 1
2 2
3 1
3 2
3 3
1 1
7 1
7 7
7 4
Output
2
3
2
3
2
3
1
1
3
Note
In the first example, for a=[10,20,10] the optimal subsequences are:
* for k=1: [20],
* for k=2: [10,20],
* for k=3: [10,20,10]. | instruction | 0 | 39,720 | 12 | 79,440 |
Tags: data structures, greedy
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
s_a = sorted(a)
m = int(input())
req = []
for _ in range(m):
req.append(list(map(int, input().split())))
d = dict()
for r in req:
if r[0] in d.keys():
print(d[r[0]][r[1] - 1])
else:
del_indx = []
for e in s_a[:n-r[0]]:
for i in reversed(range(n)):
if a[i] == e:
if i not in del_indx:
del_indx.append(i)
break
new_a = []
for i in range(n):
if i not in del_indx:
new_a.append(a[i])
d[r[0]] = new_a
print(d[r[0]][r[1] - 1])
``` | output | 1 | 39,720 | 12 | 79,441 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the easier version of the problem. In this version 1 ≤ n, m ≤ 100. You can hack this problem only if you solve and lock both problems.
You are given a sequence of integers a=[a_1,a_2,...,a_n] of length n. Its subsequence is obtained by removing zero or more elements from the sequence a (they do not necessarily go consecutively). For example, for the sequence a=[11,20,11,33,11,20,11]:
* [11,20,11,33,11,20,11], [11,20,11,33,11,20], [11,11,11,11], [20], [33,20] are subsequences (these are just some of the long list);
* [40], [33,33], [33,20,20], [20,20,11,11] are not subsequences.
Suppose that an additional non-negative integer k (1 ≤ k ≤ n) is given, then the subsequence is called optimal if:
* it has a length of k and the sum of its elements is the maximum possible among all subsequences of length k;
* and among all subsequences of length k that satisfy the previous item, it is lexicographically minimal.
Recall that the sequence b=[b_1, b_2, ..., b_k] is lexicographically smaller than the sequence c=[c_1, c_2, ..., c_k] if the first element (from the left) in which they differ less in the sequence b than in c. Formally: there exists t (1 ≤ t ≤ k) such that b_1=c_1, b_2=c_2, ..., b_{t-1}=c_{t-1} and at the same time b_t<c_t. For example:
* [10, 20, 20] lexicographically less than [10, 21, 1],
* [7, 99, 99] is lexicographically less than [10, 21, 1],
* [10, 21, 0] is lexicographically less than [10, 21, 1].
You are given a sequence of a=[a_1,a_2,...,a_n] and m requests, each consisting of two numbers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j). For each query, print the value that is in the index pos_j of the optimal subsequence of the given sequence a for k=k_j.
For example, if n=4, a=[10,20,30,20], k_j=2, then the optimal subsequence is [20,30] — it is the minimum lexicographically among all subsequences of length 2 with the maximum total sum of items. Thus, the answer to the request k_j=2, pos_j=1 is the number 20, and the answer to the request k_j=2, pos_j=2 is the number 30.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the length of the sequence a.
The second line contains elements of the sequence a: integer numbers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The third line contains an integer m (1 ≤ m ≤ 100) — the number of requests.
The following m lines contain pairs of integers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j) — the requests.
Output
Print m integers r_1, r_2, ..., r_m (1 ≤ r_j ≤ 10^9) one per line: answers to the requests in the order they appear in the input. The value of r_j should be equal to the value contained in the position pos_j of the optimal subsequence for k=k_j.
Examples
Input
3
10 20 10
6
1 1
2 1
2 2
3 1
3 2
3 3
Output
20
10
20
10
20
10
Input
7
1 2 1 3 1 2 1
9
2 1
2 2
3 1
3 2
3 3
1 1
7 1
7 7
7 4
Output
2
3
2
3
2
3
1
1
3
Note
In the first example, for a=[10,20,10] the optimal subsequences are:
* for k=1: [20],
* for k=2: [10,20],
* for k=3: [10,20,10]. | instruction | 0 | 39,721 | 12 | 79,442 |
Tags: data structures, greedy
Correct Solution:
```
import copy
b=[]
a=[]
rezult=''
n=int(input())
a=list(map(int,input().split()))
m=int(input())
for i in range(1,m+1):
k,pos=map(int,input().split())
b=copy.deepcopy(a)
b.reverse()
for j in range(1,n-k+1):
b.remove(min(b))
b.reverse()
rezult=rezult+'\n'+str(b[pos-1])
print(rezult)
``` | output | 1 | 39,721 | 12 | 79,443 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the easier version of the problem. In this version 1 ≤ n, m ≤ 100. You can hack this problem only if you solve and lock both problems.
You are given a sequence of integers a=[a_1,a_2,...,a_n] of length n. Its subsequence is obtained by removing zero or more elements from the sequence a (they do not necessarily go consecutively). For example, for the sequence a=[11,20,11,33,11,20,11]:
* [11,20,11,33,11,20,11], [11,20,11,33,11,20], [11,11,11,11], [20], [33,20] are subsequences (these are just some of the long list);
* [40], [33,33], [33,20,20], [20,20,11,11] are not subsequences.
Suppose that an additional non-negative integer k (1 ≤ k ≤ n) is given, then the subsequence is called optimal if:
* it has a length of k and the sum of its elements is the maximum possible among all subsequences of length k;
* and among all subsequences of length k that satisfy the previous item, it is lexicographically minimal.
Recall that the sequence b=[b_1, b_2, ..., b_k] is lexicographically smaller than the sequence c=[c_1, c_2, ..., c_k] if the first element (from the left) in which they differ less in the sequence b than in c. Formally: there exists t (1 ≤ t ≤ k) such that b_1=c_1, b_2=c_2, ..., b_{t-1}=c_{t-1} and at the same time b_t<c_t. For example:
* [10, 20, 20] lexicographically less than [10, 21, 1],
* [7, 99, 99] is lexicographically less than [10, 21, 1],
* [10, 21, 0] is lexicographically less than [10, 21, 1].
You are given a sequence of a=[a_1,a_2,...,a_n] and m requests, each consisting of two numbers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j). For each query, print the value that is in the index pos_j of the optimal subsequence of the given sequence a for k=k_j.
For example, if n=4, a=[10,20,30,20], k_j=2, then the optimal subsequence is [20,30] — it is the minimum lexicographically among all subsequences of length 2 with the maximum total sum of items. Thus, the answer to the request k_j=2, pos_j=1 is the number 20, and the answer to the request k_j=2, pos_j=2 is the number 30.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the length of the sequence a.
The second line contains elements of the sequence a: integer numbers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The third line contains an integer m (1 ≤ m ≤ 100) — the number of requests.
The following m lines contain pairs of integers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j) — the requests.
Output
Print m integers r_1, r_2, ..., r_m (1 ≤ r_j ≤ 10^9) one per line: answers to the requests in the order they appear in the input. The value of r_j should be equal to the value contained in the position pos_j of the optimal subsequence for k=k_j.
Examples
Input
3
10 20 10
6
1 1
2 1
2 2
3 1
3 2
3 3
Output
20
10
20
10
20
10
Input
7
1 2 1 3 1 2 1
9
2 1
2 2
3 1
3 2
3 3
1 1
7 1
7 7
7 4
Output
2
3
2
3
2
3
1
1
3
Note
In the first example, for a=[10,20,10] the optimal subsequences are:
* for k=1: [20],
* for k=2: [10,20],
* for k=3: [10,20,10]. | instruction | 0 | 39,722 | 12 | 79,444 |
Tags: data structures, greedy
Correct Solution:
```
n=int(input())
a=[int(i) for i in input().split()]
copy1=a[:]
a.sort()
m=int(input())
for i in range(m):
k,pos=map(int,input().split())
ans=[-1]
copy=a[-k:]
for i in copy1:
if i in copy:
copy.pop(copy.index(i))
ans.append(i)
print(ans[pos])
``` | output | 1 | 39,722 | 12 | 79,445 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the easier version of the problem. In this version 1 ≤ n, m ≤ 100. You can hack this problem only if you solve and lock both problems.
You are given a sequence of integers a=[a_1,a_2,...,a_n] of length n. Its subsequence is obtained by removing zero or more elements from the sequence a (they do not necessarily go consecutively). For example, for the sequence a=[11,20,11,33,11,20,11]:
* [11,20,11,33,11,20,11], [11,20,11,33,11,20], [11,11,11,11], [20], [33,20] are subsequences (these are just some of the long list);
* [40], [33,33], [33,20,20], [20,20,11,11] are not subsequences.
Suppose that an additional non-negative integer k (1 ≤ k ≤ n) is given, then the subsequence is called optimal if:
* it has a length of k and the sum of its elements is the maximum possible among all subsequences of length k;
* and among all subsequences of length k that satisfy the previous item, it is lexicographically minimal.
Recall that the sequence b=[b_1, b_2, ..., b_k] is lexicographically smaller than the sequence c=[c_1, c_2, ..., c_k] if the first element (from the left) in which they differ less in the sequence b than in c. Formally: there exists t (1 ≤ t ≤ k) such that b_1=c_1, b_2=c_2, ..., b_{t-1}=c_{t-1} and at the same time b_t<c_t. For example:
* [10, 20, 20] lexicographically less than [10, 21, 1],
* [7, 99, 99] is lexicographically less than [10, 21, 1],
* [10, 21, 0] is lexicographically less than [10, 21, 1].
You are given a sequence of a=[a_1,a_2,...,a_n] and m requests, each consisting of two numbers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j). For each query, print the value that is in the index pos_j of the optimal subsequence of the given sequence a for k=k_j.
For example, if n=4, a=[10,20,30,20], k_j=2, then the optimal subsequence is [20,30] — it is the minimum lexicographically among all subsequences of length 2 with the maximum total sum of items. Thus, the answer to the request k_j=2, pos_j=1 is the number 20, and the answer to the request k_j=2, pos_j=2 is the number 30.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the length of the sequence a.
The second line contains elements of the sequence a: integer numbers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The third line contains an integer m (1 ≤ m ≤ 100) — the number of requests.
The following m lines contain pairs of integers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j) — the requests.
Output
Print m integers r_1, r_2, ..., r_m (1 ≤ r_j ≤ 10^9) one per line: answers to the requests in the order they appear in the input. The value of r_j should be equal to the value contained in the position pos_j of the optimal subsequence for k=k_j.
Examples
Input
3
10 20 10
6
1 1
2 1
2 2
3 1
3 2
3 3
Output
20
10
20
10
20
10
Input
7
1 2 1 3 1 2 1
9
2 1
2 2
3 1
3 2
3 3
1 1
7 1
7 7
7 4
Output
2
3
2
3
2
3
1
1
3
Note
In the first example, for a=[10,20,10] the optimal subsequences are:
* for k=1: [20],
* for k=2: [10,20],
* for k=3: [10,20,10]. | instruction | 0 | 39,723 | 12 | 79,446 |
Tags: data structures, greedy
Correct Solution:
```
n=int(input())
s=sorted([[v,-i] for i,v in enumerate(map(int,input().split()))])
for _ in range(int(input())):
k,i=map(int,input().split())
ans=sorted(s[-k:],key=lambda x:-x[1])
print(ans[i-1][0])
``` | output | 1 | 39,723 | 12 | 79,447 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the easier version of the problem. In this version 1 ≤ n, m ≤ 100. You can hack this problem only if you solve and lock both problems.
You are given a sequence of integers a=[a_1,a_2,...,a_n] of length n. Its subsequence is obtained by removing zero or more elements from the sequence a (they do not necessarily go consecutively). For example, for the sequence a=[11,20,11,33,11,20,11]:
* [11,20,11,33,11,20,11], [11,20,11,33,11,20], [11,11,11,11], [20], [33,20] are subsequences (these are just some of the long list);
* [40], [33,33], [33,20,20], [20,20,11,11] are not subsequences.
Suppose that an additional non-negative integer k (1 ≤ k ≤ n) is given, then the subsequence is called optimal if:
* it has a length of k and the sum of its elements is the maximum possible among all subsequences of length k;
* and among all subsequences of length k that satisfy the previous item, it is lexicographically minimal.
Recall that the sequence b=[b_1, b_2, ..., b_k] is lexicographically smaller than the sequence c=[c_1, c_2, ..., c_k] if the first element (from the left) in which they differ less in the sequence b than in c. Formally: there exists t (1 ≤ t ≤ k) such that b_1=c_1, b_2=c_2, ..., b_{t-1}=c_{t-1} and at the same time b_t<c_t. For example:
* [10, 20, 20] lexicographically less than [10, 21, 1],
* [7, 99, 99] is lexicographically less than [10, 21, 1],
* [10, 21, 0] is lexicographically less than [10, 21, 1].
You are given a sequence of a=[a_1,a_2,...,a_n] and m requests, each consisting of two numbers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j). For each query, print the value that is in the index pos_j of the optimal subsequence of the given sequence a for k=k_j.
For example, if n=4, a=[10,20,30,20], k_j=2, then the optimal subsequence is [20,30] — it is the minimum lexicographically among all subsequences of length 2 with the maximum total sum of items. Thus, the answer to the request k_j=2, pos_j=1 is the number 20, and the answer to the request k_j=2, pos_j=2 is the number 30.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the length of the sequence a.
The second line contains elements of the sequence a: integer numbers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The third line contains an integer m (1 ≤ m ≤ 100) — the number of requests.
The following m lines contain pairs of integers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j) — the requests.
Output
Print m integers r_1, r_2, ..., r_m (1 ≤ r_j ≤ 10^9) one per line: answers to the requests in the order they appear in the input. The value of r_j should be equal to the value contained in the position pos_j of the optimal subsequence for k=k_j.
Examples
Input
3
10 20 10
6
1 1
2 1
2 2
3 1
3 2
3 3
Output
20
10
20
10
20
10
Input
7
1 2 1 3 1 2 1
9
2 1
2 2
3 1
3 2
3 3
1 1
7 1
7 7
7 4
Output
2
3
2
3
2
3
1
1
3
Note
In the first example, for a=[10,20,10] the optimal subsequences are:
* for k=1: [20],
* for k=2: [10,20],
* for k=3: [10,20,10]. | instruction | 0 | 39,724 | 12 | 79,448 |
Tags: data structures, greedy
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
b=[a]
for x in range(n-1):
b.append([])
m=min(a)
y=len(a)-1
while y>=0 and a[y]!=m:
b[-1].append(a[y])
y-=1
y-=1
while y>=0:
b[-1].append(a[y])
y-=1
a=b[-1][::-1]
m=int(input())
for x in range(m):
k,l=map(int,input().split())
if k<n:
k=n-(k-1)-1
l=len(b[k])-(l-1)-1
print(b[k][l])
else:
print(b[0][l-1])
``` | output | 1 | 39,724 | 12 | 79,449 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the easier version of the problem. In this version 1 ≤ n, m ≤ 100. You can hack this problem only if you solve and lock both problems.
You are given a sequence of integers a=[a_1,a_2,...,a_n] of length n. Its subsequence is obtained by removing zero or more elements from the sequence a (they do not necessarily go consecutively). For example, for the sequence a=[11,20,11,33,11,20,11]:
* [11,20,11,33,11,20,11], [11,20,11,33,11,20], [11,11,11,11], [20], [33,20] are subsequences (these are just some of the long list);
* [40], [33,33], [33,20,20], [20,20,11,11] are not subsequences.
Suppose that an additional non-negative integer k (1 ≤ k ≤ n) is given, then the subsequence is called optimal if:
* it has a length of k and the sum of its elements is the maximum possible among all subsequences of length k;
* and among all subsequences of length k that satisfy the previous item, it is lexicographically minimal.
Recall that the sequence b=[b_1, b_2, ..., b_k] is lexicographically smaller than the sequence c=[c_1, c_2, ..., c_k] if the first element (from the left) in which they differ less in the sequence b than in c. Formally: there exists t (1 ≤ t ≤ k) such that b_1=c_1, b_2=c_2, ..., b_{t-1}=c_{t-1} and at the same time b_t<c_t. For example:
* [10, 20, 20] lexicographically less than [10, 21, 1],
* [7, 99, 99] is lexicographically less than [10, 21, 1],
* [10, 21, 0] is lexicographically less than [10, 21, 1].
You are given a sequence of a=[a_1,a_2,...,a_n] and m requests, each consisting of two numbers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j). For each query, print the value that is in the index pos_j of the optimal subsequence of the given sequence a for k=k_j.
For example, if n=4, a=[10,20,30,20], k_j=2, then the optimal subsequence is [20,30] — it is the minimum lexicographically among all subsequences of length 2 with the maximum total sum of items. Thus, the answer to the request k_j=2, pos_j=1 is the number 20, and the answer to the request k_j=2, pos_j=2 is the number 30.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the length of the sequence a.
The second line contains elements of the sequence a: integer numbers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The third line contains an integer m (1 ≤ m ≤ 100) — the number of requests.
The following m lines contain pairs of integers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j) — the requests.
Output
Print m integers r_1, r_2, ..., r_m (1 ≤ r_j ≤ 10^9) one per line: answers to the requests in the order they appear in the input. The value of r_j should be equal to the value contained in the position pos_j of the optimal subsequence for k=k_j.
Examples
Input
3
10 20 10
6
1 1
2 1
2 2
3 1
3 2
3 3
Output
20
10
20
10
20
10
Input
7
1 2 1 3 1 2 1
9
2 1
2 2
3 1
3 2
3 3
1 1
7 1
7 7
7 4
Output
2
3
2
3
2
3
1
1
3
Note
In the first example, for a=[10,20,10] the optimal subsequences are:
* for k=1: [20],
* for k=2: [10,20],
* for k=3: [10,20,10]. | instruction | 0 | 39,725 | 12 | 79,450 |
Tags: data structures, greedy
Correct Solution:
```
import sys
def main():
n = int(input())
al = [[int(x),n-i] for i,x in enumerate(input().split())]
al.sort()
al.reverse()
arr = [[[]for i in range(n)]for i in range(n)]
for i in range(1,n+1):
for j in range(i-1,n):
arr[j][n-al[i-1][1]] = al[i-1][0]
for i in range(n):
arr[i] = list(filter(None, arr[i]))
q = int(input())
for _ in range(q):
k,ind = map(int,input().split())
print(arr[k-1][ind-1])
main()
``` | output | 1 | 39,725 | 12 | 79,451 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the easier version of the problem. In this version 1 ≤ n, m ≤ 100. You can hack this problem only if you solve and lock both problems.
You are given a sequence of integers a=[a_1,a_2,...,a_n] of length n. Its subsequence is obtained by removing zero or more elements from the sequence a (they do not necessarily go consecutively). For example, for the sequence a=[11,20,11,33,11,20,11]:
* [11,20,11,33,11,20,11], [11,20,11,33,11,20], [11,11,11,11], [20], [33,20] are subsequences (these are just some of the long list);
* [40], [33,33], [33,20,20], [20,20,11,11] are not subsequences.
Suppose that an additional non-negative integer k (1 ≤ k ≤ n) is given, then the subsequence is called optimal if:
* it has a length of k and the sum of its elements is the maximum possible among all subsequences of length k;
* and among all subsequences of length k that satisfy the previous item, it is lexicographically minimal.
Recall that the sequence b=[b_1, b_2, ..., b_k] is lexicographically smaller than the sequence c=[c_1, c_2, ..., c_k] if the first element (from the left) in which they differ less in the sequence b than in c. Formally: there exists t (1 ≤ t ≤ k) such that b_1=c_1, b_2=c_2, ..., b_{t-1}=c_{t-1} and at the same time b_t<c_t. For example:
* [10, 20, 20] lexicographically less than [10, 21, 1],
* [7, 99, 99] is lexicographically less than [10, 21, 1],
* [10, 21, 0] is lexicographically less than [10, 21, 1].
You are given a sequence of a=[a_1,a_2,...,a_n] and m requests, each consisting of two numbers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j). For each query, print the value that is in the index pos_j of the optimal subsequence of the given sequence a for k=k_j.
For example, if n=4, a=[10,20,30,20], k_j=2, then the optimal subsequence is [20,30] — it is the minimum lexicographically among all subsequences of length 2 with the maximum total sum of items. Thus, the answer to the request k_j=2, pos_j=1 is the number 20, and the answer to the request k_j=2, pos_j=2 is the number 30.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the length of the sequence a.
The second line contains elements of the sequence a: integer numbers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The third line contains an integer m (1 ≤ m ≤ 100) — the number of requests.
The following m lines contain pairs of integers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j) — the requests.
Output
Print m integers r_1, r_2, ..., r_m (1 ≤ r_j ≤ 10^9) one per line: answers to the requests in the order they appear in the input. The value of r_j should be equal to the value contained in the position pos_j of the optimal subsequence for k=k_j.
Examples
Input
3
10 20 10
6
1 1
2 1
2 2
3 1
3 2
3 3
Output
20
10
20
10
20
10
Input
7
1 2 1 3 1 2 1
9
2 1
2 2
3 1
3 2
3 3
1 1
7 1
7 7
7 4
Output
2
3
2
3
2
3
1
1
3
Note
In the first example, for a=[10,20,10] the optimal subsequences are:
* for k=1: [20],
* for k=2: [10,20],
* for k=3: [10,20,10]. | instruction | 0 | 39,726 | 12 | 79,452 |
Tags: data structures, greedy
Correct Solution:
```
"""
Author - Satwik Tiwari .
18th Feb , 2021 - Thursday
"""
#===============================================================================================
#importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from functools import cmp_to_key
# from itertools import *
from heapq import *
from math import gcd, factorial,floor,ceil,sqrt,log2
from copy import deepcopy
from collections import deque
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
#==============================================================================================
#fast I/O region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
#===============================================================================================
#some shortcuts
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def testcase(t):
for pp in range(t):
solve(pp)
def google(p):
print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(x, y, p) :
y%=(p-1) #not so sure about this. used when y>p-1. if p is prime.
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) : # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def ncr(n,r): return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
inf = pow(10,20)
mod = 10**9+7
#===============================================================================================
# code here ;))
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(bit[:idx]) <= k"""
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
def printpref(self):
out = []
for i in range(1,len(self.bit) + 1):
out.append(self.query(i))
print(out)
"""
ask query(i+1) ---->>> 1 indexed based
update(i,x) --->>> 0indexed based
"""
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
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):
"""Build a fenwick tree instance."""
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):
"""Update `fen_tree[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):
"""Return `sum(_fen_tree[: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):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_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):
"""Delete value at the given `(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):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
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):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
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):
"""Add `value` to sorted list."""
_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):
"""Remove `value` from sorted list if it is a member."""
_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):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
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):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_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 an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
def solve(case):
n = int(inp())
a = lis()
queries = []
m = int(inp())
for i in range(m):
k,pos = sep()
queries.append((k,pos,i))
queries.sort()
b = sorted(a)[::-1]
ind = {}
for i in range(n):
if(a[i] not in ind):
ind[a[i]] = deque([i])
else:
ind[a[i]].append(i)
# currind = 0
# bit = FenwickTree([0]*(len(a) + 10))
# ans = [-1]*m
# for k,pos,where in queries:
# while(currind < k):
# print(b[currind],'========')
# bit.update(ind[b[currind]].popleft(),1)
# currind+=1
# print(where,'==',bit.findkth(pos-1),pos)
# ans[where] = (bit.findkth(pos-1) + 1)
# print(bit.printpref())
#
# for i in ans:
# print(a[i])
sl = SortedList()
currind = 0
ans = [-1]*m
for k,pos,where in queries:
while(currind < k):
sl.add(ind[b[currind]].popleft())
currind += 1
ans[where] = a[sl[pos-1]]
for i in ans:
print(i)
testcase(1)
# testcase(int(inp()))
``` | output | 1 | 39,726 | 12 | 79,453 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is the easier version of the problem. In this version 1 ≤ n, m ≤ 100. You can hack this problem only if you solve and lock both problems.
You are given a sequence of integers a=[a_1,a_2,...,a_n] of length n. Its subsequence is obtained by removing zero or more elements from the sequence a (they do not necessarily go consecutively). For example, for the sequence a=[11,20,11,33,11,20,11]:
* [11,20,11,33,11,20,11], [11,20,11,33,11,20], [11,11,11,11], [20], [33,20] are subsequences (these are just some of the long list);
* [40], [33,33], [33,20,20], [20,20,11,11] are not subsequences.
Suppose that an additional non-negative integer k (1 ≤ k ≤ n) is given, then the subsequence is called optimal if:
* it has a length of k and the sum of its elements is the maximum possible among all subsequences of length k;
* and among all subsequences of length k that satisfy the previous item, it is lexicographically minimal.
Recall that the sequence b=[b_1, b_2, ..., b_k] is lexicographically smaller than the sequence c=[c_1, c_2, ..., c_k] if the first element (from the left) in which they differ less in the sequence b than in c. Formally: there exists t (1 ≤ t ≤ k) such that b_1=c_1, b_2=c_2, ..., b_{t-1}=c_{t-1} and at the same time b_t<c_t. For example:
* [10, 20, 20] lexicographically less than [10, 21, 1],
* [7, 99, 99] is lexicographically less than [10, 21, 1],
* [10, 21, 0] is lexicographically less than [10, 21, 1].
You are given a sequence of a=[a_1,a_2,...,a_n] and m requests, each consisting of two numbers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j). For each query, print the value that is in the index pos_j of the optimal subsequence of the given sequence a for k=k_j.
For example, if n=4, a=[10,20,30,20], k_j=2, then the optimal subsequence is [20,30] — it is the minimum lexicographically among all subsequences of length 2 with the maximum total sum of items. Thus, the answer to the request k_j=2, pos_j=1 is the number 20, and the answer to the request k_j=2, pos_j=2 is the number 30.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the length of the sequence a.
The second line contains elements of the sequence a: integer numbers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The third line contains an integer m (1 ≤ m ≤ 100) — the number of requests.
The following m lines contain pairs of integers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j) — the requests.
Output
Print m integers r_1, r_2, ..., r_m (1 ≤ r_j ≤ 10^9) one per line: answers to the requests in the order they appear in the input. The value of r_j should be equal to the value contained in the position pos_j of the optimal subsequence for k=k_j.
Examples
Input
3
10 20 10
6
1 1
2 1
2 2
3 1
3 2
3 3
Output
20
10
20
10
20
10
Input
7
1 2 1 3 1 2 1
9
2 1
2 2
3 1
3 2
3 3
1 1
7 1
7 7
7 4
Output
2
3
2
3
2
3
1
1
3
Note
In the first example, for a=[10,20,10] the optimal subsequences are:
* for k=1: [20],
* for k=2: [10,20],
* for k=3: [10,20,10]. | instruction | 0 | 39,727 | 12 | 79,454 |
Tags: data structures, greedy
Correct Solution:
```
WIDTH = 10
def index_tree(n):
levels = [ [1]*n ]
size = WIDTH
while size < n:
m, r = n // size, n % size
levels.append( [size]*m + ([r] if r > 0 else []) )
size *= WIDTH
return levels
def dec_index(levels, i):
for level in levels:
level[i] -= 1
i //= WIDTH
def find_pos(levels, pos):
i, l = 0, len(levels) - 1
total = 0
while True:
level = levels[l]
while total + level[i] < pos:
total += level[i]
i += 1
if l == 0: return i
i *= WIDTH
l -= 1
import sys
def main():
## INPUT
numbers = [int(x) for x in sys.stdin.read().split()]
n = numbers[0]
sequence = numbers[1:n+1]
m = numbers[n+1]
queries = {}
for i in range(n+2, n+2 + 2*m, 2):
k, pos = numbers[i], numbers[i+1]
if k in queries: queries[k][pos] = None
else: queries[k] = { pos: None }
## WORK
sequence1 = sorted([ (s,-i) for i,s in enumerate(sequence) ])
tree = index_tree(n)
size = n
for _, neg_i in sequence1:
if size in queries:
for pos in queries[size]:
queries[size][pos] = find_pos(tree, pos)
dec_index(tree, -neg_i)
size -= 1
## PRINT
for i in range(n+2, n+2 + 2*m, 2):
k, pos = numbers[i], numbers[i+1]
print(sequence[ queries[k][pos] ])
main()
``` | output | 1 | 39,727 | 12 | 79,455 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the easier version of the problem. In this version 1 ≤ n, m ≤ 100. You can hack this problem only if you solve and lock both problems.
You are given a sequence of integers a=[a_1,a_2,...,a_n] of length n. Its subsequence is obtained by removing zero or more elements from the sequence a (they do not necessarily go consecutively). For example, for the sequence a=[11,20,11,33,11,20,11]:
* [11,20,11,33,11,20,11], [11,20,11,33,11,20], [11,11,11,11], [20], [33,20] are subsequences (these are just some of the long list);
* [40], [33,33], [33,20,20], [20,20,11,11] are not subsequences.
Suppose that an additional non-negative integer k (1 ≤ k ≤ n) is given, then the subsequence is called optimal if:
* it has a length of k and the sum of its elements is the maximum possible among all subsequences of length k;
* and among all subsequences of length k that satisfy the previous item, it is lexicographically minimal.
Recall that the sequence b=[b_1, b_2, ..., b_k] is lexicographically smaller than the sequence c=[c_1, c_2, ..., c_k] if the first element (from the left) in which they differ less in the sequence b than in c. Formally: there exists t (1 ≤ t ≤ k) such that b_1=c_1, b_2=c_2, ..., b_{t-1}=c_{t-1} and at the same time b_t<c_t. For example:
* [10, 20, 20] lexicographically less than [10, 21, 1],
* [7, 99, 99] is lexicographically less than [10, 21, 1],
* [10, 21, 0] is lexicographically less than [10, 21, 1].
You are given a sequence of a=[a_1,a_2,...,a_n] and m requests, each consisting of two numbers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j). For each query, print the value that is in the index pos_j of the optimal subsequence of the given sequence a for k=k_j.
For example, if n=4, a=[10,20,30,20], k_j=2, then the optimal subsequence is [20,30] — it is the minimum lexicographically among all subsequences of length 2 with the maximum total sum of items. Thus, the answer to the request k_j=2, pos_j=1 is the number 20, and the answer to the request k_j=2, pos_j=2 is the number 30.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the length of the sequence a.
The second line contains elements of the sequence a: integer numbers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The third line contains an integer m (1 ≤ m ≤ 100) — the number of requests.
The following m lines contain pairs of integers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j) — the requests.
Output
Print m integers r_1, r_2, ..., r_m (1 ≤ r_j ≤ 10^9) one per line: answers to the requests in the order they appear in the input. The value of r_j should be equal to the value contained in the position pos_j of the optimal subsequence for k=k_j.
Examples
Input
3
10 20 10
6
1 1
2 1
2 2
3 1
3 2
3 3
Output
20
10
20
10
20
10
Input
7
1 2 1 3 1 2 1
9
2 1
2 2
3 1
3 2
3 3
1 1
7 1
7 7
7 4
Output
2
3
2
3
2
3
1
1
3
Note
In the first example, for a=[10,20,10] the optimal subsequences are:
* for k=1: [20],
* for k=2: [10,20],
* for k=3: [10,20,10].
Submitted Solution:
```
def get_index(lt, vec):
max_el = 0
pos = None
for i in range(len(vec)):
if i not in lt:
if max_el < vec[i]:
max_el = vec[i]
pos = i
return pos
n = int(input())
vec = [int(x) for x in input().split()]
lst = [[vec.index(max(vec))]]
for i in range(n-1):
lt = list(lst[i])
ind = get_index(lt, vec)
lt.append(ind)
lst.append(lt)
for l in lst:
l.sort()
m = int(input())
for i in range(m):
k, pos = [int(x) for x in input().split()]
print(vec[lst[k-1][pos-1]])
``` | instruction | 0 | 39,728 | 12 | 79,456 |
Yes | output | 1 | 39,728 | 12 | 79,457 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the easier version of the problem. In this version 1 ≤ n, m ≤ 100. You can hack this problem only if you solve and lock both problems.
You are given a sequence of integers a=[a_1,a_2,...,a_n] of length n. Its subsequence is obtained by removing zero or more elements from the sequence a (they do not necessarily go consecutively). For example, for the sequence a=[11,20,11,33,11,20,11]:
* [11,20,11,33,11,20,11], [11,20,11,33,11,20], [11,11,11,11], [20], [33,20] are subsequences (these are just some of the long list);
* [40], [33,33], [33,20,20], [20,20,11,11] are not subsequences.
Suppose that an additional non-negative integer k (1 ≤ k ≤ n) is given, then the subsequence is called optimal if:
* it has a length of k and the sum of its elements is the maximum possible among all subsequences of length k;
* and among all subsequences of length k that satisfy the previous item, it is lexicographically minimal.
Recall that the sequence b=[b_1, b_2, ..., b_k] is lexicographically smaller than the sequence c=[c_1, c_2, ..., c_k] if the first element (from the left) in which they differ less in the sequence b than in c. Formally: there exists t (1 ≤ t ≤ k) such that b_1=c_1, b_2=c_2, ..., b_{t-1}=c_{t-1} and at the same time b_t<c_t. For example:
* [10, 20, 20] lexicographically less than [10, 21, 1],
* [7, 99, 99] is lexicographically less than [10, 21, 1],
* [10, 21, 0] is lexicographically less than [10, 21, 1].
You are given a sequence of a=[a_1,a_2,...,a_n] and m requests, each consisting of two numbers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j). For each query, print the value that is in the index pos_j of the optimal subsequence of the given sequence a for k=k_j.
For example, if n=4, a=[10,20,30,20], k_j=2, then the optimal subsequence is [20,30] — it is the minimum lexicographically among all subsequences of length 2 with the maximum total sum of items. Thus, the answer to the request k_j=2, pos_j=1 is the number 20, and the answer to the request k_j=2, pos_j=2 is the number 30.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the length of the sequence a.
The second line contains elements of the sequence a: integer numbers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The third line contains an integer m (1 ≤ m ≤ 100) — the number of requests.
The following m lines contain pairs of integers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j) — the requests.
Output
Print m integers r_1, r_2, ..., r_m (1 ≤ r_j ≤ 10^9) one per line: answers to the requests in the order they appear in the input. The value of r_j should be equal to the value contained in the position pos_j of the optimal subsequence for k=k_j.
Examples
Input
3
10 20 10
6
1 1
2 1
2 2
3 1
3 2
3 3
Output
20
10
20
10
20
10
Input
7
1 2 1 3 1 2 1
9
2 1
2 2
3 1
3 2
3 3
1 1
7 1
7 7
7 4
Output
2
3
2
3
2
3
1
1
3
Note
In the first example, for a=[10,20,10] the optimal subsequences are:
* for k=1: [20],
* for k=2: [10,20],
* for k=3: [10,20,10].
Submitted Solution:
```
import sys
# from math
import bisect
import heapq
# from collections import deque
# from types import GeneratorType
# def bootstrap(func, stack=[]):
# def wrapped_function(*args, **kwargs):
# if stack:
# return func(*args, **kwargs)
# else:
# call = func(*args, **kwargs)
# while True:
# if type(call) is GeneratorType:
# stack.append(call)
# call = next(call)
# else:
# stack.pop()
# if not stack:
# break
# call = stack[-1].send(call)
# return call
# return wrapped_function
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 10**9+7
n = int(ri())
ar = Ri()
arr= [(ar[i],i) for i in range(n)]
arr.sort(key = lambda x: -x[0])
for _ in range(int(ri())):
a,b = Ri()
temp = []
for i in range(a):
temp.append(arr[i][1])
temp.sort()
print(ar[temp[b-1]])
``` | instruction | 0 | 39,729 | 12 | 79,458 |
Yes | output | 1 | 39,729 | 12 | 79,459 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the easier version of the problem. In this version 1 ≤ n, m ≤ 100. You can hack this problem only if you solve and lock both problems.
You are given a sequence of integers a=[a_1,a_2,...,a_n] of length n. Its subsequence is obtained by removing zero or more elements from the sequence a (they do not necessarily go consecutively). For example, for the sequence a=[11,20,11,33,11,20,11]:
* [11,20,11,33,11,20,11], [11,20,11,33,11,20], [11,11,11,11], [20], [33,20] are subsequences (these are just some of the long list);
* [40], [33,33], [33,20,20], [20,20,11,11] are not subsequences.
Suppose that an additional non-negative integer k (1 ≤ k ≤ n) is given, then the subsequence is called optimal if:
* it has a length of k and the sum of its elements is the maximum possible among all subsequences of length k;
* and among all subsequences of length k that satisfy the previous item, it is lexicographically minimal.
Recall that the sequence b=[b_1, b_2, ..., b_k] is lexicographically smaller than the sequence c=[c_1, c_2, ..., c_k] if the first element (from the left) in which they differ less in the sequence b than in c. Formally: there exists t (1 ≤ t ≤ k) such that b_1=c_1, b_2=c_2, ..., b_{t-1}=c_{t-1} and at the same time b_t<c_t. For example:
* [10, 20, 20] lexicographically less than [10, 21, 1],
* [7, 99, 99] is lexicographically less than [10, 21, 1],
* [10, 21, 0] is lexicographically less than [10, 21, 1].
You are given a sequence of a=[a_1,a_2,...,a_n] and m requests, each consisting of two numbers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j). For each query, print the value that is in the index pos_j of the optimal subsequence of the given sequence a for k=k_j.
For example, if n=4, a=[10,20,30,20], k_j=2, then the optimal subsequence is [20,30] — it is the minimum lexicographically among all subsequences of length 2 with the maximum total sum of items. Thus, the answer to the request k_j=2, pos_j=1 is the number 20, and the answer to the request k_j=2, pos_j=2 is the number 30.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the length of the sequence a.
The second line contains elements of the sequence a: integer numbers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The third line contains an integer m (1 ≤ m ≤ 100) — the number of requests.
The following m lines contain pairs of integers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j) — the requests.
Output
Print m integers r_1, r_2, ..., r_m (1 ≤ r_j ≤ 10^9) one per line: answers to the requests in the order they appear in the input. The value of r_j should be equal to the value contained in the position pos_j of the optimal subsequence for k=k_j.
Examples
Input
3
10 20 10
6
1 1
2 1
2 2
3 1
3 2
3 3
Output
20
10
20
10
20
10
Input
7
1 2 1 3 1 2 1
9
2 1
2 2
3 1
3 2
3 3
1 1
7 1
7 7
7 4
Output
2
3
2
3
2
3
1
1
3
Note
In the first example, for a=[10,20,10] the optimal subsequences are:
* for k=1: [20],
* for k=2: [10,20],
* for k=3: [10,20,10].
Submitted Solution:
```
test_case = """7
1 2 1 3 1 2 1
9
2 1
2 2
3 1
3 2
3 3
1 1
7 1
7 7
7 4"""
length = int(input())
a = [int(x) for x in input().split()]
l = []
for x in range(length):
l.append([a[x], x+1])
ll = sorted(l, key = lambda y: (y[0], -y[1]))
t = int(input())
for _ in range(t):
k, p = [int(x) for x in input().split()]
###########wrong#k = length-k-1 #index start, considering index from 0 for python
#print(ll[length-k:])
ans = ll[length-k:]
final = sorted(ans, key = lambda y: (y[1]))
#print(final, p-1)
print(final[p-1][0])
``` | instruction | 0 | 39,730 | 12 | 79,460 |
Yes | output | 1 | 39,730 | 12 | 79,461 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the easier version of the problem. In this version 1 ≤ n, m ≤ 100. You can hack this problem only if you solve and lock both problems.
You are given a sequence of integers a=[a_1,a_2,...,a_n] of length n. Its subsequence is obtained by removing zero or more elements from the sequence a (they do not necessarily go consecutively). For example, for the sequence a=[11,20,11,33,11,20,11]:
* [11,20,11,33,11,20,11], [11,20,11,33,11,20], [11,11,11,11], [20], [33,20] are subsequences (these are just some of the long list);
* [40], [33,33], [33,20,20], [20,20,11,11] are not subsequences.
Suppose that an additional non-negative integer k (1 ≤ k ≤ n) is given, then the subsequence is called optimal if:
* it has a length of k and the sum of its elements is the maximum possible among all subsequences of length k;
* and among all subsequences of length k that satisfy the previous item, it is lexicographically minimal.
Recall that the sequence b=[b_1, b_2, ..., b_k] is lexicographically smaller than the sequence c=[c_1, c_2, ..., c_k] if the first element (from the left) in which they differ less in the sequence b than in c. Formally: there exists t (1 ≤ t ≤ k) such that b_1=c_1, b_2=c_2, ..., b_{t-1}=c_{t-1} and at the same time b_t<c_t. For example:
* [10, 20, 20] lexicographically less than [10, 21, 1],
* [7, 99, 99] is lexicographically less than [10, 21, 1],
* [10, 21, 0] is lexicographically less than [10, 21, 1].
You are given a sequence of a=[a_1,a_2,...,a_n] and m requests, each consisting of two numbers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j). For each query, print the value that is in the index pos_j of the optimal subsequence of the given sequence a for k=k_j.
For example, if n=4, a=[10,20,30,20], k_j=2, then the optimal subsequence is [20,30] — it is the minimum lexicographically among all subsequences of length 2 with the maximum total sum of items. Thus, the answer to the request k_j=2, pos_j=1 is the number 20, and the answer to the request k_j=2, pos_j=2 is the number 30.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the length of the sequence a.
The second line contains elements of the sequence a: integer numbers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The third line contains an integer m (1 ≤ m ≤ 100) — the number of requests.
The following m lines contain pairs of integers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j) — the requests.
Output
Print m integers r_1, r_2, ..., r_m (1 ≤ r_j ≤ 10^9) one per line: answers to the requests in the order they appear in the input. The value of r_j should be equal to the value contained in the position pos_j of the optimal subsequence for k=k_j.
Examples
Input
3
10 20 10
6
1 1
2 1
2 2
3 1
3 2
3 3
Output
20
10
20
10
20
10
Input
7
1 2 1 3 1 2 1
9
2 1
2 2
3 1
3 2
3 3
1 1
7 1
7 7
7 4
Output
2
3
2
3
2
3
1
1
3
Note
In the first example, for a=[10,20,10] the optimal subsequences are:
* for k=1: [20],
* for k=2: [10,20],
* for k=3: [10,20,10].
Submitted Solution:
```
import copy
a=[]
ai=[]
otv=''
n=int(input())
a=list(map(int,input().split()))
m=int(input())
for i in range(1,m+1):
#print(ai)
#print(a,'kkkk')
ai=copy.deepcopy(a)
ai.reverse()
#print(ai)
k,pos=map(int,input().split())
for j in range(1,n-k+1):
#print(min(ai))
ai.remove(min(ai))
ai.reverse()
otv=otv+'\n'+str(ai[pos-1])
print(otv)
``` | instruction | 0 | 39,731 | 12 | 79,462 |
Yes | output | 1 | 39,731 | 12 | 79,463 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the easier version of the problem. In this version 1 ≤ n, m ≤ 100. You can hack this problem only if you solve and lock both problems.
You are given a sequence of integers a=[a_1,a_2,...,a_n] of length n. Its subsequence is obtained by removing zero or more elements from the sequence a (they do not necessarily go consecutively). For example, for the sequence a=[11,20,11,33,11,20,11]:
* [11,20,11,33,11,20,11], [11,20,11,33,11,20], [11,11,11,11], [20], [33,20] are subsequences (these are just some of the long list);
* [40], [33,33], [33,20,20], [20,20,11,11] are not subsequences.
Suppose that an additional non-negative integer k (1 ≤ k ≤ n) is given, then the subsequence is called optimal if:
* it has a length of k and the sum of its elements is the maximum possible among all subsequences of length k;
* and among all subsequences of length k that satisfy the previous item, it is lexicographically minimal.
Recall that the sequence b=[b_1, b_2, ..., b_k] is lexicographically smaller than the sequence c=[c_1, c_2, ..., c_k] if the first element (from the left) in which they differ less in the sequence b than in c. Formally: there exists t (1 ≤ t ≤ k) such that b_1=c_1, b_2=c_2, ..., b_{t-1}=c_{t-1} and at the same time b_t<c_t. For example:
* [10, 20, 20] lexicographically less than [10, 21, 1],
* [7, 99, 99] is lexicographically less than [10, 21, 1],
* [10, 21, 0] is lexicographically less than [10, 21, 1].
You are given a sequence of a=[a_1,a_2,...,a_n] and m requests, each consisting of two numbers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j). For each query, print the value that is in the index pos_j of the optimal subsequence of the given sequence a for k=k_j.
For example, if n=4, a=[10,20,30,20], k_j=2, then the optimal subsequence is [20,30] — it is the minimum lexicographically among all subsequences of length 2 with the maximum total sum of items. Thus, the answer to the request k_j=2, pos_j=1 is the number 20, and the answer to the request k_j=2, pos_j=2 is the number 30.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the length of the sequence a.
The second line contains elements of the sequence a: integer numbers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The third line contains an integer m (1 ≤ m ≤ 100) — the number of requests.
The following m lines contain pairs of integers k_j and pos_j (1 ≤ k ≤ n, 1 ≤ pos_j ≤ k_j) — the requests.
Output
Print m integers r_1, r_2, ..., r_m (1 ≤ r_j ≤ 10^9) one per line: answers to the requests in the order they appear in the input. The value of r_j should be equal to the value contained in the position pos_j of the optimal subsequence for k=k_j.
Examples
Input
3
10 20 10
6
1 1
2 1
2 2
3 1
3 2
3 3
Output
20
10
20
10
20
10
Input
7
1 2 1 3 1 2 1
9
2 1
2 2
3 1
3 2
3 3
1 1
7 1
7 7
7 4
Output
2
3
2
3
2
3
1
1
3
Note
In the first example, for a=[10,20,10] the optimal subsequences are:
* for k=1: [20],
* for k=2: [10,20],
* for k=3: [10,20,10].
Submitted Solution:
```
def mergesort(l, r, arr, pos):
if r - l == 1:
return arr, pos
m = (l + r) // 2
arr, pos = mergesort(l, m, arr, pos)
arr, pos = mergesort(m, r, arr, pos)
c = [0 for i in range(r)]
d = [0 for i in range(r)]
poi_a = l
poi_b = m
for i in range(l, r):
if poi_a == m:
c[i] = arr[poi_b]
d[i] = pos[poi_b]
poi_b += 1
elif poi_b == r:
c[i] = arr[poi_a]
d[i] = pos[poi_a]
poi_a += 1
elif a[poi_a] > arr[poi_b]:
c[i] = arr[poi_a]
d[i] = pos[poi_a]
poi_a += 1
else:
c[i] = arr[poi_b]
d[i] = pos[poi_b]
poi_b += 1
for i in range(l, r):
arr[i] = c[i]
pos[i] = d[i]
return arr, pos
n = int(input())
a = list(map(int, input().split()))
p = [i for i in range(n)]
temp = a[:]
a, p = mergesort(0, n, a, p)
pref = []
i = 0
while i < n:
j = i + 1
if j < n and a[i] == a[j]:
j += 1
pref.append([i, j])
i = j
for m in range(int(input())):
k, pos = map(int, input().split())
for t in range(len(pref)):
if pref[t][0] <= k - 1 < pref[t][1]:
i = pref[t][0]
j = pref[t][1]
l = k - i + 1
m = sorted(p[i:j])
res = sorted(m[:l] + p[:i])
print(temp[res[pos - 1]])
``` | instruction | 0 | 39,732 | 12 | 79,464 |
No | output | 1 | 39,732 | 12 | 79,465 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.