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 an array a consisting of n elements. The imbalance value of some subsegment of this array is the difference between the maximum and minimum element from this segment. The imbalance value of the array is the sum of imbalance values of all subsegments of this array.
For example, the imbalance value of array [1, 4, 1] is 9, because there are 6 different subsegments of this array:
* [1] (from index 1 to index 1), imbalance value is 0;
* [1, 4] (from index 1 to index 2), imbalance value is 3;
* [1, 4, 1] (from index 1 to index 3), imbalance value is 3;
* [4] (from index 2 to index 2), imbalance value is 0;
* [4, 1] (from index 2 to index 3), imbalance value is 3;
* [1] (from index 3 to index 3), imbalance value is 0;
You have to determine the imbalance value of the array a.
Input
The first line contains one integer n (1 ≤ n ≤ 106) — size of the array a.
The second line contains n integers a1, a2... an (1 ≤ ai ≤ 106) — elements of the array.
Output
Print one integer — the imbalance value of a.
Example
Input
3
1 4 1
Output
9
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
def findMinimumL(a):
A = [-1]*len(a)
for i,x in enumerate(a):
j = i - 1
while j != -1 and a[j] > a[i]:
j = A[j]
A[i] = j
return A
def findMaximumL(a):
A = [-1]*len(a)
for i,x in enumerate(a):
j = i - 1
while j != -1 and a[j] < a[i]:
j = A[j]
A[i] = j
return A
def findMinimumR(a):
A = [-1]*len(a)
for i in range(len(a) - 1,-1,-1):
j = i + 1
while j != len(a) and a[j] >= a[i]:
j = A[j]
A[i] = j
return A
def findMaximumR(a):
A = [-1]*len(a)
for i in range(len(a) - 1,-1,-1):
j = i + 1
while j != len(a) and a[j] <= a[i]:
j = A[j]
A[i] = j
return A
def minimumSum():
L,R = findMinimumL(a), findMinimumR(a)
ans = 0
for i,x in enumerate(a):
ans += (i - L[i])*(R[i] - i)*x
return ans
def maximumSums():
L,R = findMaximumL(a), findMaximumR(a)
ans = 0
for i,x in enumerate(a):
ans += (i - L[i])*(R[i] - i)*x
return ans
print(maximumSums() - minimumSum())
``` | instruction | 0 | 56,860 | 12 | 113,720 |
Yes | output | 1 | 56,860 | 12 | 113,721 |
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 consisting of n elements. The imbalance value of some subsegment of this array is the difference between the maximum and minimum element from this segment. The imbalance value of the array is the sum of imbalance values of all subsegments of this array.
For example, the imbalance value of array [1, 4, 1] is 9, because there are 6 different subsegments of this array:
* [1] (from index 1 to index 1), imbalance value is 0;
* [1, 4] (from index 1 to index 2), imbalance value is 3;
* [1, 4, 1] (from index 1 to index 3), imbalance value is 3;
* [4] (from index 2 to index 2), imbalance value is 0;
* [4, 1] (from index 2 to index 3), imbalance value is 3;
* [1] (from index 3 to index 3), imbalance value is 0;
You have to determine the imbalance value of the array a.
Input
The first line contains one integer n (1 ≤ n ≤ 106) — size of the array a.
The second line contains n integers a1, a2... an (1 ≤ ai ≤ 106) — elements of the array.
Output
Print one integer — the imbalance value of a.
Example
Input
3
1 4 1
Output
9
Submitted Solution:
```
raw=input().split()
arr=[int(i) for i in raw]
i=2
imb=0
while i<=len(arr):
j=0
while j+i<=len(arr):
M=max(arr[j:j+i])
m=min(arr[j:j+i])
imb+=(M-m)
j+=1
i+=1
print(imb)
``` | instruction | 0 | 56,861 | 12 | 113,722 |
No | output | 1 | 56,861 | 12 | 113,723 |
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 consisting of n elements. The imbalance value of some subsegment of this array is the difference between the maximum and minimum element from this segment. The imbalance value of the array is the sum of imbalance values of all subsegments of this array.
For example, the imbalance value of array [1, 4, 1] is 9, because there are 6 different subsegments of this array:
* [1] (from index 1 to index 1), imbalance value is 0;
* [1, 4] (from index 1 to index 2), imbalance value is 3;
* [1, 4, 1] (from index 1 to index 3), imbalance value is 3;
* [4] (from index 2 to index 2), imbalance value is 0;
* [4, 1] (from index 2 to index 3), imbalance value is 3;
* [1] (from index 3 to index 3), imbalance value is 0;
You have to determine the imbalance value of the array a.
Input
The first line contains one integer n (1 ≤ n ≤ 106) — size of the array a.
The second line contains n integers a1, a2... an (1 ≤ ai ≤ 106) — elements of the array.
Output
Print one integer — the imbalance value of a.
Example
Input
3
1 4 1
Output
9
Submitted Solution:
```
s=input()
mina=c=0
for i in range(len(s)):
if ord(s[i])>=97:
mina=min(c+1,mina)
c+=1
else:
mina=min(mina+1,c)
print(mina)
``` | instruction | 0 | 56,862 | 12 | 113,724 |
No | output | 1 | 56,862 | 12 | 113,725 |
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 consisting of n elements. The imbalance value of some subsegment of this array is the difference between the maximum and minimum element from this segment. The imbalance value of the array is the sum of imbalance values of all subsegments of this array.
For example, the imbalance value of array [1, 4, 1] is 9, because there are 6 different subsegments of this array:
* [1] (from index 1 to index 1), imbalance value is 0;
* [1, 4] (from index 1 to index 2), imbalance value is 3;
* [1, 4, 1] (from index 1 to index 3), imbalance value is 3;
* [4] (from index 2 to index 2), imbalance value is 0;
* [4, 1] (from index 2 to index 3), imbalance value is 3;
* [1] (from index 3 to index 3), imbalance value is 0;
You have to determine the imbalance value of the array a.
Input
The first line contains one integer n (1 ≤ n ≤ 106) — size of the array a.
The second line contains n integers a1, a2... an (1 ≤ ai ≤ 106) — elements of the array.
Output
Print one integer — the imbalance value of a.
Example
Input
3
1 4 1
Output
9
Submitted Solution:
```
n=int(input())
A=list(map(int,input().split()))
L=[0]*1000000
ps=[0]*1000001
for i in range(n):
L[A[i]-1]+=1
for i in range(1000000):
ps[i+1]=ps[i]+L[i]
mins=0
maxs=0
for i in range(1000000):
maxs+=ps[i]*L[i]
mins+=(ps[1000000]-ps[i+1])*L[i]
print(maxs-mins)
``` | instruction | 0 | 56,863 | 12 | 113,726 |
No | output | 1 | 56,863 | 12 | 113,727 |
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 consisting of n elements. The imbalance value of some subsegment of this array is the difference between the maximum and minimum element from this segment. The imbalance value of the array is the sum of imbalance values of all subsegments of this array.
For example, the imbalance value of array [1, 4, 1] is 9, because there are 6 different subsegments of this array:
* [1] (from index 1 to index 1), imbalance value is 0;
* [1, 4] (from index 1 to index 2), imbalance value is 3;
* [1, 4, 1] (from index 1 to index 3), imbalance value is 3;
* [4] (from index 2 to index 2), imbalance value is 0;
* [4, 1] (from index 2 to index 3), imbalance value is 3;
* [1] (from index 3 to index 3), imbalance value is 0;
You have to determine the imbalance value of the array a.
Input
The first line contains one integer n (1 ≤ n ≤ 106) — size of the array a.
The second line contains n integers a1, a2... an (1 ≤ ai ≤ 106) — elements of the array.
Output
Print one integer — the imbalance value of a.
Example
Input
3
1 4 1
Output
9
Submitted Solution:
```
n = int(input())
# arr = []
# for i in range(n):
# arr.append(int(input()))
arr = input().split()
for i in range(n):
arr[i] = int(arr[i])
print(arr)
# n = 4
# arr = [1, 2, 3, 4]
max_min = []
inbalance_value = 0
if n >= 2:
for i in range(n-1):
maxnum = max(arr[i], arr[i+1])
minnum = min(arr[i], arr[i+1])
max_min.append((maxnum, minnum))
inbalance_value += (maxnum-minnum)
if n >= 3:
for i in range(2, n, 1):
for j in range(n-i):
(a, b) = max_min[j]
maxnum = max(a, arr[j+i])
minnum = min(b, arr[j+i])
max_min[j] = (maxnum, minnum)
inbalance_value += (maxnum-minnum)
print (inbalance_value)
``` | instruction | 0 | 56,864 | 12 | 113,728 |
No | output | 1 | 56,864 | 12 | 113,729 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Today at the lesson Vitya learned a very interesting function — mex. Mex of a sequence of numbers is the minimum non-negative number that is not present in the sequence as element. For example, mex([4, 33, 0, 1, 1, 5]) = 2 and mex([1, 2, 3]) = 0.
Vitya quickly understood all tasks of the teacher, but can you do the same?
You are given an array consisting of n non-negative integers, and m queries. Each query is characterized by one number x and consists of the following consecutive steps:
* Perform the bitwise addition operation modulo 2 (xor) of each array element with the number x.
* Find mex of the resulting array.
Note that after each query the array changes.
Input
First line contains two integer numbers n and m (1 ≤ n, m ≤ 3·105) — number of elements in array and number of queries.
Next line contains n integer numbers ai (0 ≤ ai ≤ 3·105) — elements of then array.
Each of next m lines contains query — one integer number x (0 ≤ x ≤ 3·105).
Output
For each query print the answer on a separate line.
Examples
Input
2 2
1 3
1
3
Output
1
0
Input
4 3
0 1 5 6
1
2
4
Output
2
0
0
Input
5 4
0 1 5 6 7
1
1
4
5
Output
2
2
0
2 | instruction | 0 | 56,865 | 12 | 113,730 |
Tags: binary search, data structures
Correct Solution:
```
# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------- fast io --------------------
class Trie:
class Node:
def __init__(self, char: bool = False):
self.char = char
self.children = []
self.counter = 1
def __init__(self):
self.root = Trie.Node()
def add(self, word):
node = self.root
for char in word:
found_in_child = False
for child in node.children:
if child.char == char:
child.counter += 1
node = child
found_in_child = True
break
if not found_in_child:
new_node = Trie.Node(char)
node.children.append(new_node)
node = new_node
def query(self, prefix, root=None):
if not root: root = self.root
node = root
if not root.children:
return 0
prefix = [prefix]
for char in prefix:
char_not_found = True
for child in node.children:
if child.char == char:
char_not_found = False
node = child
break
if char_not_found:
return 0
return node
n, m = map(int, input().split())
a = list(map(int, input().split()))
tr = Trie()
st = set()
for i in a:
if i in st:continue
else:st.add(i)
x = bin(i)[2:]
x = "0"*(20 - len(x)) + x
x = [True if k == "1" else False for k in x]
tr.add(x)
def f(x):
x = bin(x)[2:]
x = "0" * (20 - len(x)) + x
x = [True if k == "1" else False for k in x]
node = tr.root
ans = 0
for i in range(20):
cur = x[i]
next = tr.query(cur, node)
if next and next.counter == 2**(19-i):
node = tr.query(not cur, node)
ans += 2**(19-i)
else:
node = next
return ans
cur = -1
for _ in range(m):
if cur == -1:
cur = int(input())
else:
cur = cur ^ int(input())
print(f(cur))
``` | output | 1 | 56,865 | 12 | 113,731 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today at the lesson Vitya learned a very interesting function — mex. Mex of a sequence of numbers is the minimum non-negative number that is not present in the sequence as element. For example, mex([4, 33, 0, 1, 1, 5]) = 2 and mex([1, 2, 3]) = 0.
Vitya quickly understood all tasks of the teacher, but can you do the same?
You are given an array consisting of n non-negative integers, and m queries. Each query is characterized by one number x and consists of the following consecutive steps:
* Perform the bitwise addition operation modulo 2 (xor) of each array element with the number x.
* Find mex of the resulting array.
Note that after each query the array changes.
Input
First line contains two integer numbers n and m (1 ≤ n, m ≤ 3·105) — number of elements in array and number of queries.
Next line contains n integer numbers ai (0 ≤ ai ≤ 3·105) — elements of then array.
Each of next m lines contains query — one integer number x (0 ≤ x ≤ 3·105).
Output
For each query print the answer on a separate line.
Examples
Input
2 2
1 3
1
3
Output
1
0
Input
4 3
0 1 5 6
1
2
4
Output
2
0
0
Input
5 4
0 1 5 6 7
1
1
4
5
Output
2
2
0
2
Submitted Solution:
```
n,m = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
queries = []
for i in range(m):
queries.append(int(input()))
for query in queries:
arr = [e^query for e in arr]
arr.sort()
minimum = 0
i=0
while (minimum==arr[i]):
i += 1
minimum += 1
print(minimum)
``` | instruction | 0 | 56,866 | 12 | 113,732 |
No | output | 1 | 56,866 | 12 | 113,733 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today at the lesson Vitya learned a very interesting function — mex. Mex of a sequence of numbers is the minimum non-negative number that is not present in the sequence as element. For example, mex([4, 33, 0, 1, 1, 5]) = 2 and mex([1, 2, 3]) = 0.
Vitya quickly understood all tasks of the teacher, but can you do the same?
You are given an array consisting of n non-negative integers, and m queries. Each query is characterized by one number x and consists of the following consecutive steps:
* Perform the bitwise addition operation modulo 2 (xor) of each array element with the number x.
* Find mex of the resulting array.
Note that after each query the array changes.
Input
First line contains two integer numbers n and m (1 ≤ n, m ≤ 3·105) — number of elements in array and number of queries.
Next line contains n integer numbers ai (0 ≤ ai ≤ 3·105) — elements of then array.
Each of next m lines contains query — one integer number x (0 ≤ x ≤ 3·105).
Output
For each query print the answer on a separate line.
Examples
Input
2 2
1 3
1
3
Output
1
0
Input
4 3
0 1 5 6
1
2
4
Output
2
0
0
Input
5 4
0 1 5 6 7
1
1
4
5
Output
2
2
0
2
Submitted Solution:
```
# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------- fast io --------------------
class Trie:
class Node:
def __init__(self, char: bool = False):
self.char = char
self.children = []
self.counter = 1
def __init__(self):
self.root = Trie.Node()
def add(self, word):
node = self.root
for char in word:
found_in_child = False
for child in node.children:
if child.char == char:
child.counter += 1
node = child
found_in_child = True
break
if not found_in_child:
new_node = Trie.Node(char)
node.children.append(new_node)
node = new_node
def query(self, prefix, root=None):
if not root: root = self.root
node = root
if not root.children:
return 0
prefix = [prefix]
for char in prefix:
char_not_found = True
for child in node.children:
if child.char == char:
char_not_found = False
node = child
break
if char_not_found:
return 0
return node
n, m = map(int, input().split())
a = list(map(int, input().split()))
tr = Trie()
for i in a:
x = bin(i)[2:]
x = "0"*(20 - len(x)) + x
x = [True if k == "1" else False for k in x]
tr.add(x)
def f(x):
x = bin(x)[2:]
x = "0" * (20 - len(x)) + x
x = [True if k == "1" else False for k in x]
node = tr.root
ans = 0
for i in range(20):
cur = x[i]
next = tr.query(cur, node)
if next and next.counter == 2**(19-i):
node = tr.query(not cur, node)
ans += 2**(19-i)
else:
node = next
return ans
cur = -1
for _ in range(m):
if cur == -1:
cur = int(input())
else:
cur = cur ^ int(input())
print(f(cur))
``` | instruction | 0 | 56,867 | 12 | 113,734 |
No | output | 1 | 56,867 | 12 | 113,735 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today at the lesson Vitya learned a very interesting function — mex. Mex of a sequence of numbers is the minimum non-negative number that is not present in the sequence as element. For example, mex([4, 33, 0, 1, 1, 5]) = 2 and mex([1, 2, 3]) = 0.
Vitya quickly understood all tasks of the teacher, but can you do the same?
You are given an array consisting of n non-negative integers, and m queries. Each query is characterized by one number x and consists of the following consecutive steps:
* Perform the bitwise addition operation modulo 2 (xor) of each array element with the number x.
* Find mex of the resulting array.
Note that after each query the array changes.
Input
First line contains two integer numbers n and m (1 ≤ n, m ≤ 3·105) — number of elements in array and number of queries.
Next line contains n integer numbers ai (0 ≤ ai ≤ 3·105) — elements of then array.
Each of next m lines contains query — one integer number x (0 ≤ x ≤ 3·105).
Output
For each query print the answer on a separate line.
Examples
Input
2 2
1 3
1
3
Output
1
0
Input
4 3
0 1 5 6
1
2
4
Output
2
0
0
Input
5 4
0 1 5 6 7
1
1
4
5
Output
2
2
0
2
Submitted Solution:
```
# Enter your code here. Read input from STDIN. Print output to STDOUT# ===============================================================================================
# importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import ceil, floor
from copy import *
from collections import deque, defaultdict
from collections import Counter as counter # Counter(list) return a dict with {key: count}
from itertools import combinations # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
from itertools import permutations as permutate
from bisect import bisect_left as bl
from operator import *
# If the element is already present in the list,
# the left most position where element has to be inserted is returned.
from bisect import bisect_right as br
from bisect import bisect
# If the element is already present in the list,
# the right most position where element has to be inserted is returned
# ==============================================================================================
# fast I/O region
BUFSIZE = 8192
from sys import stderr
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 ####
###########################
# Sorted list
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))
# ===============================================================================================
# some shortcuts
mod = 1000000007
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 fsep(): return map(float, inp().split())
def nextline(): out("\n") # as stdout.write always print sring.
def testcase(t):
for p in range(t):
solve()
def pow(x, y, p):
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
from functools import reduce
def factors(n):
return set(reduce(list.__add__,
([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
def gcd(a, b):
if a == b: return a
while b > 0: a, b = b, a % b
return a
# discrete binary search
# minimise:
# def search():
# l = 0
# r = 10 ** 15
#
# for i in range(200):
# if isvalid(l):
# return l
# if l == r:
# return l
# m = (l + r) // 2
# if isvalid(m) and not isvalid(m - 1):
# return m
# if isvalid(m):
# r = m + 1
# else:
# l = m
# return m
# maximise:
# def search():
# l = 0
# r = 10 ** 15
#
# for i in range(200):
# # print(l,r)
# if isvalid(r):
# return r
# if l == r:
# return l
# m = (l + r) // 2
# if isvalid(m) and not isvalid(m + 1):
# return m
# if isvalid(m):
# l = m
# else:
# r = m - 1
# return m
##############Find sum of product of subsets of size k in a array
# ar=[0,1,2,3]
# k=3
# n=len(ar)-1
# dp=[0]*(n+1)
# dp[0]=1
# for pos in range(1,n+1):
# dp[pos]=0
# l=max(1,k+pos-n-1)
# for j in range(min(pos,k),l-1,-1):
# dp[j]=dp[j]+ar[pos]*dp[j-1]
# print(dp[k])
def prefix_sum(ar): # [1,2,3,4]->[1,3,6,10]
return list(accumulate(ar))
def suffix_sum(ar): # [1,2,3,4]->[10,9,7,4]
return list(accumulate(ar[::-1]))[::-1]
def N():
return int(inp())
dx = [0, 0, 1, -1]
dy = [1, -1, 0, 0]
def YES():
print("YES")
def NO():
print("NO")
def Yes():
print("Yes")
def No():
print("No")
# =========================================================================================
from collections import defaultdict
def numberOfSetBits(i):
i = i - ((i >> 1) & 0x55555555)
i = (i & 0x33333333) + ((i >> 2) & 0x33333333)
return (((i + (i >> 4) & 0xF0F0F0F) * 0x1010101) & 0xffffffff) >> 24
class MergeFind:
def __init__(self, n):
self.parent = list(range(n))
self.size = [1] * n
self.num_sets = n
# self.lista = [[_] for _ in range(n)]
def find(self, a):
to_update = []
while a != self.parent[a]:
to_update.append(a)
a = self.parent[a]
for b in to_update:
self.parent[b] = a
return self.parent[a]
def merge(self, a, b):
a = self.find(a)
b = self.find(b)
if a == b:
return
self.num_sets -= 1
self.parent[a] = b
self.size[b] += self.size[a]
# self.lista[a] += self.lista[b]
# self.lista[b] = []
def set_size(self, a):
return self.size[self.find(a)]
def __len__(self):
return self.num_sets
def lcm(a, b):
return abs((a // gcd(a, b)) * b)
#
# # to find factorial and ncr
# tot = 400005
# mod = 10 ** 9 + 7
# fac = [1, 1]
# finv = [1, 1]
# inv = [0, 1]
#
# for i in range(2, tot + 1):
# fac.append((fac[-1] * i) % mod)
# inv.append(mod - (inv[mod % i] * (mod // i) % mod))
# finv.append(finv[-1] * inv[-1] % mod)
#
#
# def comb(n, r):
# if n < r:
# return 0
# else:
# return fac[n] * (finv[r] * finv[n - r] % mod) % mod
def solve():
class Binary_trie():
def __init__(self, tot=3000005, m=20): # tot=nlog(n) n= Max(ar),self.m=log(n)
self.trie = [[0] * 2 for _ in range(tot)]
self.tot = tot
self.m = m
self.ptr = 2
def insert(self, num):
cur = 1
for i in range(self.m, -1, -1):
if self.trie[cur][(num >> i) & 1] == 0:
self.trie[cur][(num >> i) & 1] = self.ptr
self.ptr += 1
cur = self.trie[cur][(num >> i) & 1]
def min_xor(self, num):
cur = 1
ans = 0
for i in range(self.m, -1, -1):
bit = (num >> i) & 1
if (self.trie[cur][bit]):
cur = self.trie[cur][bit]
else:
cur = self.trie[cur][bit ^ 1]
ans |= (1 << i)
return ans
n, q = sep()
s = set(lis())
bt = Binary_trie()
for i in range(300001):
if i not in s:
bt.insert(i)
cur = 0
for i in range(q):
x = N()
cur ^= x
print(bt.min_xor(cur))
solve()
# testcase(int(inp()))
``` | instruction | 0 | 56,868 | 12 | 113,736 |
No | output | 1 | 56,868 | 12 | 113,737 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today at the lesson Vitya learned a very interesting function — mex. Mex of a sequence of numbers is the minimum non-negative number that is not present in the sequence as element. For example, mex([4, 33, 0, 1, 1, 5]) = 2 and mex([1, 2, 3]) = 0.
Vitya quickly understood all tasks of the teacher, but can you do the same?
You are given an array consisting of n non-negative integers, and m queries. Each query is characterized by one number x and consists of the following consecutive steps:
* Perform the bitwise addition operation modulo 2 (xor) of each array element with the number x.
* Find mex of the resulting array.
Note that after each query the array changes.
Input
First line contains two integer numbers n and m (1 ≤ n, m ≤ 3·105) — number of elements in array and number of queries.
Next line contains n integer numbers ai (0 ≤ ai ≤ 3·105) — elements of then array.
Each of next m lines contains query — one integer number x (0 ≤ x ≤ 3·105).
Output
For each query print the answer on a separate line.
Examples
Input
2 2
1 3
1
3
Output
1
0
Input
4 3
0 1 5 6
1
2
4
Output
2
0
0
Input
5 4
0 1 5 6 7
1
1
4
5
Output
2
2
0
2
Submitted Solution:
```
class MinSegTree:
def __init__(self, inf, data=None, size=None):
if data is None and size is None:
raise Exception('data and size both cannot be None simultaneously')
if size is None:
size = len(data)
depth = (size-1).bit_length()
self.size = 1 << depth
self.inf = inf
if data is None:
self.data = [inf]*(2*self.size)
else:
self.data = [inf]*self.size + data + [inf]*(self.size-size)
for d in reversed(range(self.depth)):
t = 1 << d
for i in range(t, 2*t):
self.data[i] = min(self.data[2*i],self.data[2*i+1])
def _min_interval(self, a, b):
result = self.inf
a += self.size
b += self.size
while a < b:
if a & 1:
result = min(result,self.data[a])
a += 1
if b & 1:
b -= 1
result = min(result,self.data[b])
a >>= 1
b >>= 1
return result
def _set_val(self, a, val):
a += self.size
while self.data[a] != val and a > 0:
self.data[a] = val
val = min(val,self.data[a^1])
a >>= 1
def __getitem__(self, i):
if isinstance(i, slice):
return self._min_interval(
0 if i.start is None else i.start,
self.size if i.stop is None else i.stop)
elif isinstance(i, int):
return self.data[i+self.size]
def __setitem__(self, i, x):
self._set_val(i,x)
def __iter__(self):
return iter(self.data[self.size:])
n,m = map(int,input().split())
A = list(map(int,input().split()))
D = max(A).bit_length()
l = 2**D
F = [True]*(2*l)
for a in A:
F[l+a] = False
for d in reversed(range(D)):
t = 1 << d
for i in range(t,2*t):
F[i] = F[2*i] or F[2*i+1]
def search(x):
t = 1
for d in reversed(range(D)):
s = (x >> d) & 1
a,b = 2*t+s,2*t+(1-s)
t = a if F[a] else b
return t - l
x = 0
for i in range(m):
x ^= int(input())
print(search(x)^x)
``` | instruction | 0 | 56,869 | 12 | 113,738 |
No | output | 1 | 56,869 | 12 | 113,739 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of size n, and q queries to it. There are queries of two types:
* 1 li ri — perform a cyclic shift of the segment [li, ri] to the right. That is, for every x such that li ≤ x < ri new value of ax + 1 becomes equal to old value of ax, and new value of ali becomes equal to old value of ari;
* 2 li ri — reverse the segment [li, ri].
There are m important indices in the array b1, b2, ..., bm. For each i such that 1 ≤ i ≤ m you have to output the number that will have index bi in the array after all queries are performed.
Input
The first line contains three integer numbers n, q and m (1 ≤ n, q ≤ 2·105, 1 ≤ m ≤ 100).
The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 109).
Then q lines follow. i-th of them contains three integer numbers ti, li, ri, where ti is the type of i-th query, and [li, ri] is the segment where this query is performed (1 ≤ ti ≤ 2, 1 ≤ li ≤ ri ≤ n).
The last line contains m integer numbers b1, b2, ..., bm (1 ≤ bi ≤ n) — important indices of the array.
Output
Print m numbers, i-th of which is equal to the number at index bi after all queries are done.
Example
Input
6 3 5
1 2 3 4 5 6
2 1 3
2 3 6
1 1 6
2 2 1 5 3
Output
3 3 1 5 2 | instruction | 0 | 56,870 | 12 | 113,740 |
Tags: data structures, implementation
Correct Solution:
```
import sys
import math
from collections import defaultdict,deque
def get(ind ,arr):
n = len(arr)
for i in range(n):
t,l,r = arr[i]
if t == 1:
if l <= ind <= r:
if ind == l:
ind = r
else:
ind -= 1
continue
if t == 2:
if l <=ind <= r:
ind = (r - ind + l)
continue
return ind
n,q,m = map(int,sys.stdin.readline().split())
arr = list(map(int,sys.stdin.readline().split()))
l = []
for i in range(q):
a,b,c = map(int,sys.stdin.readline().split())
l.append([a,b,c])
l.reverse()
b = list(map(int,sys.stdin.readline().split()))
ans = []
for i in range(m):
x = get(b[i],l)
ans.append(arr[x -1])
print(*ans)
``` | output | 1 | 56,870 | 12 | 113,741 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of size n, and q queries to it. There are queries of two types:
* 1 li ri — perform a cyclic shift of the segment [li, ri] to the right. That is, for every x such that li ≤ x < ri new value of ax + 1 becomes equal to old value of ax, and new value of ali becomes equal to old value of ari;
* 2 li ri — reverse the segment [li, ri].
There are m important indices in the array b1, b2, ..., bm. For each i such that 1 ≤ i ≤ m you have to output the number that will have index bi in the array after all queries are performed.
Input
The first line contains three integer numbers n, q and m (1 ≤ n, q ≤ 2·105, 1 ≤ m ≤ 100).
The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 109).
Then q lines follow. i-th of them contains three integer numbers ti, li, ri, where ti is the type of i-th query, and [li, ri] is the segment where this query is performed (1 ≤ ti ≤ 2, 1 ≤ li ≤ ri ≤ n).
The last line contains m integer numbers b1, b2, ..., bm (1 ≤ bi ≤ n) — important indices of the array.
Output
Print m numbers, i-th of which is equal to the number at index bi after all queries are done.
Example
Input
6 3 5
1 2 3 4 5 6
2 1 3
2 3 6
1 1 6
2 2 1 5 3
Output
3 3 1 5 2 | instruction | 0 | 56,871 | 12 | 113,742 |
Tags: data structures, implementation
Correct Solution:
```
n,q,m=map(int,input().split())
a=list(map(int,input().split()))
qq=list(list(map(int,input().split())) for i in range(q))
qq=list(reversed(qq))
b=list(map(int,input().split()))
for qt, l, r in qq:
if qt == 1:
for i in range(m):
if l <= b[i] <= r:
b[i] = r if b[i] == l else b[i]-1
else:
for i in range(m):
if l <= b[i] <= r:
b[i] = r - (b[i] - l)
print(*(a[i-1] for i in b))
``` | output | 1 | 56,871 | 12 | 113,743 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of size n, and q queries to it. There are queries of two types:
* 1 li ri — perform a cyclic shift of the segment [li, ri] to the right. That is, for every x such that li ≤ x < ri new value of ax + 1 becomes equal to old value of ax, and new value of ali becomes equal to old value of ari;
* 2 li ri — reverse the segment [li, ri].
There are m important indices in the array b1, b2, ..., bm. For each i such that 1 ≤ i ≤ m you have to output the number that will have index bi in the array after all queries are performed.
Input
The first line contains three integer numbers n, q and m (1 ≤ n, q ≤ 2·105, 1 ≤ m ≤ 100).
The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 109).
Then q lines follow. i-th of them contains three integer numbers ti, li, ri, where ti is the type of i-th query, and [li, ri] is the segment where this query is performed (1 ≤ ti ≤ 2, 1 ≤ li ≤ ri ≤ n).
The last line contains m integer numbers b1, b2, ..., bm (1 ≤ bi ≤ n) — important indices of the array.
Output
Print m numbers, i-th of which is equal to the number at index bi after all queries are done.
Example
Input
6 3 5
1 2 3 4 5 6
2 1 3
2 3 6
1 1 6
2 2 1 5 3
Output
3 3 1 5 2 | instruction | 0 | 56,872 | 12 | 113,744 |
Tags: data structures, implementation
Correct Solution:
```
import sys
f = lambda: list(map(int, sys.stdin.readline().split()))
q = f()[1]
a = f()
d = [f() for i in range(q)][::-1]
for k in f():
for t, l, r in d:
if l <= k <= r: k = l + r - k if t == 2 else r if k == l else k - 1
print(a[k - 1])
``` | output | 1 | 56,872 | 12 | 113,745 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of size n, and q queries to it. There are queries of two types:
* 1 li ri — perform a cyclic shift of the segment [li, ri] to the right. That is, for every x such that li ≤ x < ri new value of ax + 1 becomes equal to old value of ax, and new value of ali becomes equal to old value of ari;
* 2 li ri — reverse the segment [li, ri].
There are m important indices in the array b1, b2, ..., bm. For each i such that 1 ≤ i ≤ m you have to output the number that will have index bi in the array after all queries are performed.
Input
The first line contains three integer numbers n, q and m (1 ≤ n, q ≤ 2·105, 1 ≤ m ≤ 100).
The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 109).
Then q lines follow. i-th of them contains three integer numbers ti, li, ri, where ti is the type of i-th query, and [li, ri] is the segment where this query is performed (1 ≤ ti ≤ 2, 1 ≤ li ≤ ri ≤ n).
The last line contains m integer numbers b1, b2, ..., bm (1 ≤ bi ≤ n) — important indices of the array.
Output
Print m numbers, i-th of which is equal to the number at index bi after all queries are done.
Example
Input
6 3 5
1 2 3 4 5 6
2 1 3
2 3 6
1 1 6
2 2 1 5 3
Output
3 3 1 5 2 | instruction | 0 | 56,873 | 12 | 113,746 |
Tags: data structures, implementation
Correct Solution:
```
import sys
n, q, m = map(int, sys.stdin.buffer.readline().decode('utf-8').split())
a = list(map(int, sys.stdin.buffer.readline().decode('utf-8').split()))
query = [list(map(int, sys.stdin.buffer.readline().decode('utf-8').split()))
for _ in range(q)]
b = list(map(int, sys.stdin.buffer.readline().decode('utf-8').split()))
for qt, l, r in reversed(query):
if qt == 1:
for i in range(m):
if l <= b[i] <= r:
b[i] = r if b[i] == l else b[i]-1
else:
for i in range(m):
if l <= b[i] <= r:
b[i] = r - (b[i] - l)
print(*(a[i-1] for i in b))
``` | output | 1 | 56,873 | 12 | 113,747 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of size n, and q queries to it. There are queries of two types:
* 1 li ri — perform a cyclic shift of the segment [li, ri] to the right. That is, for every x such that li ≤ x < ri new value of ax + 1 becomes equal to old value of ax, and new value of ali becomes equal to old value of ari;
* 2 li ri — reverse the segment [li, ri].
There are m important indices in the array b1, b2, ..., bm. For each i such that 1 ≤ i ≤ m you have to output the number that will have index bi in the array after all queries are performed.
Input
The first line contains three integer numbers n, q and m (1 ≤ n, q ≤ 2·105, 1 ≤ m ≤ 100).
The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 109).
Then q lines follow. i-th of them contains three integer numbers ti, li, ri, where ti is the type of i-th query, and [li, ri] is the segment where this query is performed (1 ≤ ti ≤ 2, 1 ≤ li ≤ ri ≤ n).
The last line contains m integer numbers b1, b2, ..., bm (1 ≤ bi ≤ n) — important indices of the array.
Output
Print m numbers, i-th of which is equal to the number at index bi after all queries are done.
Example
Input
6 3 5
1 2 3 4 5 6
2 1 3
2 3 6
1 1 6
2 2 1 5 3
Output
3 3 1 5 2 | instruction | 0 | 56,874 | 12 | 113,748 |
Tags: data structures, implementation
Correct Solution:
```
# https://codeforces.com/contest/863/problem/D
from sys import stdin, stdout
input = stdin.readline
print = stdout.write
# solve the reversed problem
n, q, m = map(int, input().split())
a = list(map(int, input().split()))
ops = [list(map(int, input().split())) for _ in range(q)]
b = list(map(int, input().split()))
def solve(index, ops):
def _solve(index, op):
t, l, r = op
if index < l or index > r:
return index
if t == 1:
if index == l:
return r
else:
return index - 1
else:
return l + r - index
for op in ops[::-1]:
index = _solve(index, op)
return index
b = list(map(lambda x: solve(x, ops), b))
for i in b:
print(str(a[i-1])+" ")
# Cartesian tree:
# https://codeforces.com/contest/863/submission/30693678
``` | output | 1 | 56,874 | 12 | 113,749 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of size n, and q queries to it. There are queries of two types:
* 1 li ri — perform a cyclic shift of the segment [li, ri] to the right. That is, for every x such that li ≤ x < ri new value of ax + 1 becomes equal to old value of ax, and new value of ali becomes equal to old value of ari;
* 2 li ri — reverse the segment [li, ri].
There are m important indices in the array b1, b2, ..., bm. For each i such that 1 ≤ i ≤ m you have to output the number that will have index bi in the array after all queries are performed.
Input
The first line contains three integer numbers n, q and m (1 ≤ n, q ≤ 2·105, 1 ≤ m ≤ 100).
The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 109).
Then q lines follow. i-th of them contains three integer numbers ti, li, ri, where ti is the type of i-th query, and [li, ri] is the segment where this query is performed (1 ≤ ti ≤ 2, 1 ≤ li ≤ ri ≤ n).
The last line contains m integer numbers b1, b2, ..., bm (1 ≤ bi ≤ n) — important indices of the array.
Output
Print m numbers, i-th of which is equal to the number at index bi after all queries are done.
Example
Input
6 3 5
1 2 3 4 5 6
2 1 3
2 3 6
1 1 6
2 2 1 5 3
Output
3 3 1 5 2 | instruction | 0 | 56,875 | 12 | 113,750 |
Tags: data structures, implementation
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
n,q,m=map(int,input().split())
b=list(map(int,input().split()))
query=[]
for j in range(q):
t,l,r=map(int,input().split())
query.append([t,l,r])
query.reverse()
ind=list(map(int,input().split()))
ans=[]
j=0
while(j<m):
curr=ind[j]
i=0
while(i<q):
t,l,r=query[i][0],query[i][1],query[i][2]
if curr in range(l,r+1):
if t==1:
if curr==l:
curr=r
else:
curr=curr-1
else:
curr=r+l-curr
i+=1
ans.append(b[curr-1])
j+=1
print(*ans)
``` | output | 1 | 56,875 | 12 | 113,751 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of size n, and q queries to it. There are queries of two types:
* 1 li ri — perform a cyclic shift of the segment [li, ri] to the right. That is, for every x such that li ≤ x < ri new value of ax + 1 becomes equal to old value of ax, and new value of ali becomes equal to old value of ari;
* 2 li ri — reverse the segment [li, ri].
There are m important indices in the array b1, b2, ..., bm. For each i such that 1 ≤ i ≤ m you have to output the number that will have index bi in the array after all queries are performed.
Input
The first line contains three integer numbers n, q and m (1 ≤ n, q ≤ 2·105, 1 ≤ m ≤ 100).
The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 109).
Then q lines follow. i-th of them contains three integer numbers ti, li, ri, where ti is the type of i-th query, and [li, ri] is the segment where this query is performed (1 ≤ ti ≤ 2, 1 ≤ li ≤ ri ≤ n).
The last line contains m integer numbers b1, b2, ..., bm (1 ≤ bi ≤ n) — important indices of the array.
Output
Print m numbers, i-th of which is equal to the number at index bi after all queries are done.
Example
Input
6 3 5
1 2 3 4 5 6
2 1 3
2 3 6
1 1 6
2 2 1 5 3
Output
3 3 1 5 2 | instruction | 0 | 56,876 | 12 | 113,752 |
Tags: data structures, implementation
Correct Solution:
```
import sys
#Library Info(ACL for Python/Pypy) -> https://github.com/not522/ac-library-python
def input():
return sys.stdin.readline().rstrip()
DXY = [(0, -1), (1, 0), (0, 1), (-1, 0)] # L,D,R,Uの順番
def main():
n, q, m = map(int, input().split())
a = list(map(int, input().split()))
query = [tuple(map(int, input().split())) for i in range(q)]
indices = list(map(int, input().split()))
for t,l,r in query[::-1]:
if t == 1:
for i,idx in enumerate(indices):
if l <= idx <= r:
if idx > l:
indices[i] = idx - 1
else:
indices[i] = r
else:
for i,idx in enumerate(indices):
if l <= idx <= r:
indices[i] = l + r - idx
ans = [a[idx - 1] for idx in indices]
print(*ans)
return 0
if __name__ == "__main__":
main()
``` | output | 1 | 56,876 | 12 | 113,753 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a of size n, and q queries to it. There are queries of two types:
* 1 li ri — perform a cyclic shift of the segment [li, ri] to the right. That is, for every x such that li ≤ x < ri new value of ax + 1 becomes equal to old value of ax, and new value of ali becomes equal to old value of ari;
* 2 li ri — reverse the segment [li, ri].
There are m important indices in the array b1, b2, ..., bm. For each i such that 1 ≤ i ≤ m you have to output the number that will have index bi in the array after all queries are performed.
Input
The first line contains three integer numbers n, q and m (1 ≤ n, q ≤ 2·105, 1 ≤ m ≤ 100).
The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 109).
Then q lines follow. i-th of them contains three integer numbers ti, li, ri, where ti is the type of i-th query, and [li, ri] is the segment where this query is performed (1 ≤ ti ≤ 2, 1 ≤ li ≤ ri ≤ n).
The last line contains m integer numbers b1, b2, ..., bm (1 ≤ bi ≤ n) — important indices of the array.
Output
Print m numbers, i-th of which is equal to the number at index bi after all queries are done.
Example
Input
6 3 5
1 2 3 4 5 6
2 1 3
2 3 6
1 1 6
2 2 1 5 3
Output
3 3 1 5 2 | instruction | 0 | 56,877 | 12 | 113,754 |
Tags: data structures, implementation
Correct Solution:
```
n,q,m=map(int,input().split())
a=list(map(int,input().split()))
qq=list(list(map(int,input().split())) for i in range(q))
qq=list(reversed(qq))
b=list(map(int,input().split()))
for i in range(q):
l=qq[i][1]
r=qq[i][2]
if(qq[i][0]==1):
for j in range(m):
if(b[j]<l or b[j]>r):
continue;
if(b[j]==l):
b[j]=r
else:
b[j]=b[j]-1
else:
for j in range(m):
if(b[j]<l or b[j]>r):
continue;
b[j]=l+r-b[j]
for i in range(m):
if(i!=m-1):
print(a[b[i]-1],end=' ')
else:
print(a[b[i]-1])
``` | output | 1 | 56,877 | 12 | 113,755 |
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 size n, and q queries to it. There are queries of two types:
* 1 li ri — perform a cyclic shift of the segment [li, ri] to the right. That is, for every x such that li ≤ x < ri new value of ax + 1 becomes equal to old value of ax, and new value of ali becomes equal to old value of ari;
* 2 li ri — reverse the segment [li, ri].
There are m important indices in the array b1, b2, ..., bm. For each i such that 1 ≤ i ≤ m you have to output the number that will have index bi in the array after all queries are performed.
Input
The first line contains three integer numbers n, q and m (1 ≤ n, q ≤ 2·105, 1 ≤ m ≤ 100).
The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 109).
Then q lines follow. i-th of them contains three integer numbers ti, li, ri, where ti is the type of i-th query, and [li, ri] is the segment where this query is performed (1 ≤ ti ≤ 2, 1 ≤ li ≤ ri ≤ n).
The last line contains m integer numbers b1, b2, ..., bm (1 ≤ bi ≤ n) — important indices of the array.
Output
Print m numbers, i-th of which is equal to the number at index bi after all queries are done.
Example
Input
6 3 5
1 2 3 4 5 6
2 1 3
2 3 6
1 1 6
2 2 1 5 3
Output
3 3 1 5 2
Submitted Solution:
```
n,q,m = map(int, input().split())
data = list(map(int, input().split()))
query=[]
for s in range(q):
temp = list(map(int, input().split()))
query.append((temp[0],temp[1],temp[2]))
b = list(map(int, input().split()))
for x in b:
for t,l,r in query[::-1]:
print(t)
print(l)
print(r)
``` | instruction | 0 | 56,878 | 12 | 113,756 |
No | output | 1 | 56,878 | 12 | 113,757 |
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 size n, and q queries to it. There are queries of two types:
* 1 li ri — perform a cyclic shift of the segment [li, ri] to the right. That is, for every x such that li ≤ x < ri new value of ax + 1 becomes equal to old value of ax, and new value of ali becomes equal to old value of ari;
* 2 li ri — reverse the segment [li, ri].
There are m important indices in the array b1, b2, ..., bm. For each i such that 1 ≤ i ≤ m you have to output the number that will have index bi in the array after all queries are performed.
Input
The first line contains three integer numbers n, q and m (1 ≤ n, q ≤ 2·105, 1 ≤ m ≤ 100).
The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 109).
Then q lines follow. i-th of them contains three integer numbers ti, li, ri, where ti is the type of i-th query, and [li, ri] is the segment where this query is performed (1 ≤ ti ≤ 2, 1 ≤ li ≤ ri ≤ n).
The last line contains m integer numbers b1, b2, ..., bm (1 ≤ bi ≤ n) — important indices of the array.
Output
Print m numbers, i-th of which is equal to the number at index bi after all queries are done.
Example
Input
6 3 5
1 2 3 4 5 6
2 1 3
2 3 6
1 1 6
2 2 1 5 3
Output
3 3 1 5 2
Submitted Solution:
```
n,q,m = map(int, input().split())
data = list(map(int, input().split()))
query=[]
for s in range(q):
temp = list(map(int, input().split()))
query.append((temp[0],temp[1],temp[2]))
print(query)
``` | instruction | 0 | 56,879 | 12 | 113,758 |
No | output | 1 | 56,879 | 12 | 113,759 |
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 size n, and q queries to it. There are queries of two types:
* 1 li ri — perform a cyclic shift of the segment [li, ri] to the right. That is, for every x such that li ≤ x < ri new value of ax + 1 becomes equal to old value of ax, and new value of ali becomes equal to old value of ari;
* 2 li ri — reverse the segment [li, ri].
There are m important indices in the array b1, b2, ..., bm. For each i such that 1 ≤ i ≤ m you have to output the number that will have index bi in the array after all queries are performed.
Input
The first line contains three integer numbers n, q and m (1 ≤ n, q ≤ 2·105, 1 ≤ m ≤ 100).
The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 109).
Then q lines follow. i-th of them contains three integer numbers ti, li, ri, where ti is the type of i-th query, and [li, ri] is the segment where this query is performed (1 ≤ ti ≤ 2, 1 ≤ li ≤ ri ≤ n).
The last line contains m integer numbers b1, b2, ..., bm (1 ≤ bi ≤ n) — important indices of the array.
Output
Print m numbers, i-th of which is equal to the number at index bi after all queries are done.
Example
Input
6 3 5
1 2 3 4 5 6
2 1 3
2 3 6
1 1 6
2 2 1 5 3
Output
3 3 1 5 2
Submitted Solution:
```
a=[];d=[];i=0;t=();p1=0;p2=0;k=[0];m=[]
nqm=[];j=0;c=0
nqm.append(input().split())
for j in range(3):
nqm[i][j] = int(nqm[i][j])
a.append(input().split())
j=0
a=a[j]
for j in range(nqm[0][0]):
a[j] = int(a[j])
i=0
while i<nqm[0][1]:
i=i+1
nqm.append(input().split())
nqm[i][0] = int(nqm[i][0])
nqm[i][1] = int(nqm[i][1])-1
nqm[i][2] = int(nqm[i][2])-1
p2=int(nqm[i][2])
p1=int(nqm[i][1])
d = a[p1:p2 + 1]
j = 0
while j < p2 - p1 + 1:
a.pop(p1)
j = j + 1
j = 0
if nqm[i][0] == 1:
k[0] = d[len(d) - 1]
while j < len(d) - 1:
k.append(d[j])
j = j + 1
d = k
j = 0
if nqm[i][0] == 2:
d = d[::-1];
while j < p2 - p1 + 1:
a.insert(p1 + j, d[j])
j = j + 1
j=0
m.append(input().split())
m=m[j]
while j<len(m):
m[j] = int(m[j])
m[j]=a[m[j]]
j=j+1
j=0
print(m)
``` | instruction | 0 | 56,880 | 12 | 113,760 |
No | output | 1 | 56,880 | 12 | 113,761 |
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 size n, and q queries to it. There are queries of two types:
* 1 li ri — perform a cyclic shift of the segment [li, ri] to the right. That is, for every x such that li ≤ x < ri new value of ax + 1 becomes equal to old value of ax, and new value of ali becomes equal to old value of ari;
* 2 li ri — reverse the segment [li, ri].
There are m important indices in the array b1, b2, ..., bm. For each i such that 1 ≤ i ≤ m you have to output the number that will have index bi in the array after all queries are performed.
Input
The first line contains three integer numbers n, q and m (1 ≤ n, q ≤ 2·105, 1 ≤ m ≤ 100).
The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 109).
Then q lines follow. i-th of them contains three integer numbers ti, li, ri, where ti is the type of i-th query, and [li, ri] is the segment where this query is performed (1 ≤ ti ≤ 2, 1 ≤ li ≤ ri ≤ n).
The last line contains m integer numbers b1, b2, ..., bm (1 ≤ bi ≤ n) — important indices of the array.
Output
Print m numbers, i-th of which is equal to the number at index bi after all queries are done.
Example
Input
6 3 5
1 2 3 4 5 6
2 1 3
2 3 6
1 1 6
2 2 1 5 3
Output
3 3 1 5 2
Submitted Solution:
```
n,q,m = map(int,input().split(' '))
a = list(map(int,input().split(' ')))
for i in range(q):
t,l,r = map(int,input().split(' '))
if t == 1:
y = a[r-1]
for j in range(r-1,l-1,-1):
a[j] = a[j-1]
a[l-1] = y
print(' '.join(map(str,a)))
else:
for j in range((r-l+1) // 2):
a[l+j-1],a[r-j-1] = a[r-j-1],a[l+j-1]
print(' '.join(map(str,a)))
b = list(map(int,input().split(' ')))
c=[]
for i in b:
c.append(a[i-1])
print(' '.join(map(str,c)))
``` | instruction | 0 | 56,881 | 12 | 113,762 |
No | output | 1 | 56,881 | 12 | 113,763 |
Provide a correct Python 3 solution for this coding contest problem.
Given are a sequence of N positive integers A_1, A_2, \ldots, A_N, and a positive integer K.
Find the number of non-empty contiguous subsequences in A such that the remainder when dividing the sum of its elements by K is equal to the number of its elements. We consider two subsequences different if they are taken from different positions, even if they are equal sequences.
Constraints
* All values in input are integers.
* 1 \leq N \leq 2\times 10^5
* 1 \leq K \leq 10^9
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N K
A_1 A_2 \cdots A_N
Output
Print the number of subsequences that satisfy the condition.
Examples
Input
5 4
1 4 2 3 5
Output
4
Input
8 4
4 2 4 2 4 2 4 2
Output
7
Input
10 7
14 15 92 65 35 89 79 32 38 46
Output
8 | instruction | 0 | 56,945 | 12 | 113,890 |
"Correct Solution:
```
from collections import deque
from collections import defaultdict
def p_e():
n, k = map(int, input().split())
a = [0] + list(map(int, input().split()))
for i in range(n):
a[i + 1] = (a[i + 1] + a[i] - 1) % k
d = defaultdict(int)
d[0] = 1
q = deque()
ans = 0
for i in range(1, n + 1):
if i - k >= 0:
d[a[i - k]] -= 1
ans += d[a[i]]
d[a[i]] += 1
print(ans)
p_e()
``` | output | 1 | 56,945 | 12 | 113,891 |
Provide a correct Python 3 solution for this coding contest problem.
We have a permutation p = {p_1,\ p_2,\ ...,\ p_n} of {1,\ 2,\ ...,\ n}.
Print the number of elements p_i (1 < i < n) that satisfy the following condition:
* p_i is the second smallest number among the three numbers p_{i - 1}, p_i, and p_{i + 1}.
Constraints
* All values in input are integers.
* 3 \leq n \leq 20
* p is a permutation of {1,\ 2,\ ...,\ n}.
Input
Input is given from Standard Input in the following format:
n
p_1 p_2 ... p_n
Output
Print the number of elements p_i (1 < i < n) that satisfy the condition.
Examples
Input
5
1 3 5 4 2
Output
2
Input
9
9 6 3 2 5 8 7 4 1
Output
5 | instruction | 0 | 56,960 | 12 | 113,920 |
"Correct Solution:
```
n=int(input())
p=list(map(int,input().split()))
k=0
for i in range(n-2):
if p[i+2]<p[i+1]<p[i] or p[i+2]>p[i+1]>p[i]:
k+=1
print(k)
``` | output | 1 | 56,960 | 12 | 113,921 |
Provide a correct Python 3 solution for this coding contest problem.
We have a permutation p = {p_1,\ p_2,\ ...,\ p_n} of {1,\ 2,\ ...,\ n}.
Print the number of elements p_i (1 < i < n) that satisfy the following condition:
* p_i is the second smallest number among the three numbers p_{i - 1}, p_i, and p_{i + 1}.
Constraints
* All values in input are integers.
* 3 \leq n \leq 20
* p is a permutation of {1,\ 2,\ ...,\ n}.
Input
Input is given from Standard Input in the following format:
n
p_1 p_2 ... p_n
Output
Print the number of elements p_i (1 < i < n) that satisfy the condition.
Examples
Input
5
1 3 5 4 2
Output
2
Input
9
9 6 3 2 5 8 7 4 1
Output
5 | instruction | 0 | 56,961 | 12 | 113,922 |
"Correct Solution:
```
n = int(input())
p = list(map(int, input().split(' ')))
c = 0
for i in range(1, n-1):
c += 1 if (p[i-1]-p[i])*(p[i+1]-p[i]) < 0 else 0
print(c)
``` | output | 1 | 56,961 | 12 | 113,923 |
Provide a correct Python 3 solution for this coding contest problem.
We have a permutation p = {p_1,\ p_2,\ ...,\ p_n} of {1,\ 2,\ ...,\ n}.
Print the number of elements p_i (1 < i < n) that satisfy the following condition:
* p_i is the second smallest number among the three numbers p_{i - 1}, p_i, and p_{i + 1}.
Constraints
* All values in input are integers.
* 3 \leq n \leq 20
* p is a permutation of {1,\ 2,\ ...,\ n}.
Input
Input is given from Standard Input in the following format:
n
p_1 p_2 ... p_n
Output
Print the number of elements p_i (1 < i < n) that satisfy the condition.
Examples
Input
5
1 3 5 4 2
Output
2
Input
9
9 6 3 2 5 8 7 4 1
Output
5 | instruction | 0 | 56,962 | 12 | 113,924 |
"Correct Solution:
```
n=int(input())
p=list(map(int,input().split()))
result=0
for i in range(1,n-1):
if sorted(p[i-1:i+2])[1]==p[i]:
result+=1
print(result)
``` | output | 1 | 56,962 | 12 | 113,925 |
Provide a correct Python 3 solution for this coding contest problem.
We have a permutation p = {p_1,\ p_2,\ ...,\ p_n} of {1,\ 2,\ ...,\ n}.
Print the number of elements p_i (1 < i < n) that satisfy the following condition:
* p_i is the second smallest number among the three numbers p_{i - 1}, p_i, and p_{i + 1}.
Constraints
* All values in input are integers.
* 3 \leq n \leq 20
* p is a permutation of {1,\ 2,\ ...,\ n}.
Input
Input is given from Standard Input in the following format:
n
p_1 p_2 ... p_n
Output
Print the number of elements p_i (1 < i < n) that satisfy the condition.
Examples
Input
5
1 3 5 4 2
Output
2
Input
9
9 6 3 2 5 8 7 4 1
Output
5 | instruction | 0 | 56,963 | 12 | 113,926 |
"Correct Solution:
```
n=int(input())
l=list(int(i) for i in input().split())
a=0
for i in range(n-2):
if sorted(l[i:i+3])[1]==l[i+1]:
a+=1
print(a)
``` | output | 1 | 56,963 | 12 | 113,927 |
Provide a correct Python 3 solution for this coding contest problem.
We have a permutation p = {p_1,\ p_2,\ ...,\ p_n} of {1,\ 2,\ ...,\ n}.
Print the number of elements p_i (1 < i < n) that satisfy the following condition:
* p_i is the second smallest number among the three numbers p_{i - 1}, p_i, and p_{i + 1}.
Constraints
* All values in input are integers.
* 3 \leq n \leq 20
* p is a permutation of {1,\ 2,\ ...,\ n}.
Input
Input is given from Standard Input in the following format:
n
p_1 p_2 ... p_n
Output
Print the number of elements p_i (1 < i < n) that satisfy the condition.
Examples
Input
5
1 3 5 4 2
Output
2
Input
9
9 6 3 2 5 8 7 4 1
Output
5 | instruction | 0 | 56,964 | 12 | 113,928 |
"Correct Solution:
```
n = int(input())
A = list(map(int, input().split()))
t = 0
for i in range(n-2):
if A[i:i+3][1] == sorted(A[i:i+3])[1]:
t += 1
print(t)
``` | output | 1 | 56,964 | 12 | 113,929 |
Provide a correct Python 3 solution for this coding contest problem.
We have a permutation p = {p_1,\ p_2,\ ...,\ p_n} of {1,\ 2,\ ...,\ n}.
Print the number of elements p_i (1 < i < n) that satisfy the following condition:
* p_i is the second smallest number among the three numbers p_{i - 1}, p_i, and p_{i + 1}.
Constraints
* All values in input are integers.
* 3 \leq n \leq 20
* p is a permutation of {1,\ 2,\ ...,\ n}.
Input
Input is given from Standard Input in the following format:
n
p_1 p_2 ... p_n
Output
Print the number of elements p_i (1 < i < n) that satisfy the condition.
Examples
Input
5
1 3 5 4 2
Output
2
Input
9
9 6 3 2 5 8 7 4 1
Output
5 | instruction | 0 | 56,965 | 12 | 113,930 |
"Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
h=0
for i in range(n-2):
if a[i]<a[i+1]<a[i+2] or a[i]>a[i+1]>a[i+2]:
h+=1
print(h)
``` | output | 1 | 56,965 | 12 | 113,931 |
Provide a correct Python 3 solution for this coding contest problem.
We have a permutation p = {p_1,\ p_2,\ ...,\ p_n} of {1,\ 2,\ ...,\ n}.
Print the number of elements p_i (1 < i < n) that satisfy the following condition:
* p_i is the second smallest number among the three numbers p_{i - 1}, p_i, and p_{i + 1}.
Constraints
* All values in input are integers.
* 3 \leq n \leq 20
* p is a permutation of {1,\ 2,\ ...,\ n}.
Input
Input is given from Standard Input in the following format:
n
p_1 p_2 ... p_n
Output
Print the number of elements p_i (1 < i < n) that satisfy the condition.
Examples
Input
5
1 3 5 4 2
Output
2
Input
9
9 6 3 2 5 8 7 4 1
Output
5 | instruction | 0 | 56,966 | 12 | 113,932 |
"Correct Solution:
```
input()
p = list(map(int, input().split()))
print(sum(pi < pj < pk or pk < pj < pi for pi, pj, pk in zip(p, p[1:], p[2:])))
``` | output | 1 | 56,966 | 12 | 113,933 |
Provide a correct Python 3 solution for this coding contest problem.
We have a permutation p = {p_1,\ p_2,\ ...,\ p_n} of {1,\ 2,\ ...,\ n}.
Print the number of elements p_i (1 < i < n) that satisfy the following condition:
* p_i is the second smallest number among the three numbers p_{i - 1}, p_i, and p_{i + 1}.
Constraints
* All values in input are integers.
* 3 \leq n \leq 20
* p is a permutation of {1,\ 2,\ ...,\ n}.
Input
Input is given from Standard Input in the following format:
n
p_1 p_2 ... p_n
Output
Print the number of elements p_i (1 < i < n) that satisfy the condition.
Examples
Input
5
1 3 5 4 2
Output
2
Input
9
9 6 3 2 5 8 7 4 1
Output
5 | instruction | 0 | 56,967 | 12 | 113,934 |
"Correct Solution:
```
n = int(input())
p = [int(i) for i in input().split()]
print(sum(sorted(p[i:i + 3])[1] == p[i + 1] for i in range(n - 2)))
``` | output | 1 | 56,967 | 12 | 113,935 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an array A of length N. Your task is to divide it into several contiguous subarrays. Here, all subarrays obtained must be sorted in either non-decreasing or non-increasing order. At least how many subarrays do you need to divide A into?
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9
* Each A_i is an integer.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible number of subarrays after division of A.
Examples
Input
6
1 2 3 2 2 1
Output
2
Input
9
1 2 1 2 1 2 1 2 1
Output
5
Input
7
1 2 3 2 1 999999999 1000000000
Output
3 | instruction | 0 | 57,037 | 12 | 114,074 |
"Correct Solution:
```
N = int(input())
ans = 1
A = list(map(int, input().split()))
prev = A[0]
trend = 0
for a in A[1:]:
if (a - prev) * trend < 0:
ans += 1
trend = 0
elif trend == 0:
if a - prev > 0:
trend = 1
elif a - prev < 0:
trend = -1
prev = a
print(ans)
``` | output | 1 | 57,037 | 12 | 114,075 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an array A of length N. Your task is to divide it into several contiguous subarrays. Here, all subarrays obtained must be sorted in either non-decreasing or non-increasing order. At least how many subarrays do you need to divide A into?
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9
* Each A_i is an integer.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible number of subarrays after division of A.
Examples
Input
6
1 2 3 2 2 1
Output
2
Input
9
1 2 1 2 1 2 1 2 1
Output
5
Input
7
1 2 3 2 1 999999999 1000000000
Output
3 | instruction | 0 | 57,038 | 12 | 114,076 |
"Correct Solution:
```
n = int(input())
a = list(map(int,input().split()))
x = 0
cnt = 1
for i in range(1,n):
temp = a[i] - a[i-1]
if x == 0:
x = temp
elif x * temp<0:
cnt += 1
x =0
print(cnt)
``` | output | 1 | 57,038 | 12 | 114,077 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an array A of length N. Your task is to divide it into several contiguous subarrays. Here, all subarrays obtained must be sorted in either non-decreasing or non-increasing order. At least how many subarrays do you need to divide A into?
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9
* Each A_i is an integer.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible number of subarrays after division of A.
Examples
Input
6
1 2 3 2 2 1
Output
2
Input
9
1 2 1 2 1 2 1 2 1
Output
5
Input
7
1 2 3 2 1 999999999 1000000000
Output
3 | instruction | 0 | 57,039 | 12 | 114,078 |
"Correct Solution:
```
n = int(input())
a = list(map(int,input().split()))
c = 1
d = 0
for i in range(n-1):
if a[i] == a[i+1]:
pass
elif a[i] < a[i+1]:
if d < 0:
d = 0
c += 1
else:
d += 1
else:
if d > 0:
d = 0
c += 1
else:
d -= 1
print(c)
``` | output | 1 | 57,039 | 12 | 114,079 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an array A of length N. Your task is to divide it into several contiguous subarrays. Here, all subarrays obtained must be sorted in either non-decreasing or non-increasing order. At least how many subarrays do you need to divide A into?
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9
* Each A_i is an integer.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible number of subarrays after division of A.
Examples
Input
6
1 2 3 2 2 1
Output
2
Input
9
1 2 1 2 1 2 1 2 1
Output
5
Input
7
1 2 3 2 1 999999999 1000000000
Output
3 | instruction | 0 | 57,040 | 12 | 114,080 |
"Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
cnt = 1
b = [0] + a
c = [(i-j)//abs(i-j) for i, j in zip(a, b) if i != j]
del c[0]
if c:
mae=c[0]
d=iter(c)
for x in d:
if x != mae:
cnt += 1
try:
mae = d.__next__()
except StopIteration:
break
print(cnt)
``` | output | 1 | 57,040 | 12 | 114,081 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an array A of length N. Your task is to divide it into several contiguous subarrays. Here, all subarrays obtained must be sorted in either non-decreasing or non-increasing order. At least how many subarrays do you need to divide A into?
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9
* Each A_i is an integer.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible number of subarrays after division of A.
Examples
Input
6
1 2 3 2 2 1
Output
2
Input
9
1 2 1 2 1 2 1 2 1
Output
5
Input
7
1 2 3 2 1 999999999 1000000000
Output
3 | instruction | 0 | 57,041 | 12 | 114,082 |
"Correct Solution:
```
n = int(input())
a = list(map(int,input().split()))
mode = 0
ans = 1
for i in range(1,n):
d = a[i]-a[i-1]
if mode == 0:
mode = d
continue
if mode>0:
if d<0:
ans += 1
mode = 0
elif mode<0:
if d>0:
ans += 1
mode = 0
print(ans)
``` | output | 1 | 57,041 | 12 | 114,083 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an array A of length N. Your task is to divide it into several contiguous subarrays. Here, all subarrays obtained must be sorted in either non-decreasing or non-increasing order. At least how many subarrays do you need to divide A into?
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9
* Each A_i is an integer.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible number of subarrays after division of A.
Examples
Input
6
1 2 3 2 2 1
Output
2
Input
9
1 2 1 2 1 2 1 2 1
Output
5
Input
7
1 2 3 2 1 999999999 1000000000
Output
3 | instruction | 0 | 57,042 | 12 | 114,084 |
"Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
j=0
ans=1
for i in range(n-1):
if j==0 and a[i]<a[i+1]:
j=1
elif j==0 and a[i]>a[i+1]:
j=-1
elif j*(a[i+1]-a[i])<0:
j=0
ans +=1
print(ans)
``` | output | 1 | 57,042 | 12 | 114,085 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an array A of length N. Your task is to divide it into several contiguous subarrays. Here, all subarrays obtained must be sorted in either non-decreasing or non-increasing order. At least how many subarrays do you need to divide A into?
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9
* Each A_i is an integer.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible number of subarrays after division of A.
Examples
Input
6
1 2 3 2 2 1
Output
2
Input
9
1 2 1 2 1 2 1 2 1
Output
5
Input
7
1 2 3 2 1 999999999 1000000000
Output
3 | instruction | 0 | 57,043 | 12 | 114,086 |
"Correct Solution:
```
N = int(input())
A = list(map(int, input().split()))
p = 0
m = 0
cnt = 0
for i in range(N-1):
if(A[i] < A[i+1]):
p = 1
elif(A[i] == A[i+1]):
continue
else:
m = 1
if(p == m == 1):
cnt += 1
p = 0
m = 0
print(cnt+1)
``` | output | 1 | 57,043 | 12 | 114,087 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an array A of length N. Your task is to divide it into several contiguous subarrays. Here, all subarrays obtained must be sorted in either non-decreasing or non-increasing order. At least how many subarrays do you need to divide A into?
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9
* Each A_i is an integer.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible number of subarrays after division of A.
Examples
Input
6
1 2 3 2 2 1
Output
2
Input
9
1 2 1 2 1 2 1 2 1
Output
5
Input
7
1 2 3 2 1 999999999 1000000000
Output
3 | instruction | 0 | 57,044 | 12 | 114,088 |
"Correct Solution:
```
N = int(input())
src = list(map(int,input().split()))
asc = None
ans = 1
for i in range(N-1):
d = src[i+1] - src[i]
if d == 0: continue
if asc is None:
asc = d > 0
elif (asc and d < 0) or (not asc and d > 0):
ans += 1
asc = None
print(ans)
``` | output | 1 | 57,044 | 12 | 114,089 |
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. Your task is to divide it into several contiguous subarrays. Here, all subarrays obtained must be sorted in either non-decreasing or non-increasing order. At least how many subarrays do you need to divide A into?
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9
* Each A_i is an integer.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible number of subarrays after division of A.
Examples
Input
6
1 2 3 2 2 1
Output
2
Input
9
1 2 1 2 1 2 1 2 1
Output
5
Input
7
1 2 3 2 1 999999999 1000000000
Output
3
Submitted Solution:
```
n = int(input()); a = list(map(int, input().split())); b = -1; x = 1
for i in range(n-1):
if b == 0:
if a[i] > a[i+1]: b = -1; x += 1
elif b == 1:
if a[i] < a[i+1]: b = -1; x += 1
else:
if a[i] < a[i+1]: b = 0
elif a[i] > a[i+1]: b = 1
print(x)
``` | instruction | 0 | 57,045 | 12 | 114,090 |
Yes | output | 1 | 57,045 | 12 | 114,091 |
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. Your task is to divide it into several contiguous subarrays. Here, all subarrays obtained must be sorted in either non-decreasing or non-increasing order. At least how many subarrays do you need to divide A into?
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9
* Each A_i is an integer.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible number of subarrays after division of A.
Examples
Input
6
1 2 3 2 2 1
Output
2
Input
9
1 2 1 2 1 2 1 2 1
Output
5
Input
7
1 2 3 2 1 999999999 1000000000
Output
3
Submitted Solution:
```
N = int(input())
As = list(map(int, input().split()))
r = 0
mode = "0"
for i in range(1, N):
if mode == "-" and As[i] > As[i-1]:
r += 1
mode = "0"
elif mode == "+" and As[i] < As[i-1]:
r += 1
mode = "0"
elif As[i] < As[i-1]:
mode = "-"
elif As[i] > As[i-1]:
mode = "+"
r += 1
print(r)
``` | instruction | 0 | 57,046 | 12 | 114,092 |
Yes | output | 1 | 57,046 | 12 | 114,093 |
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. Your task is to divide it into several contiguous subarrays. Here, all subarrays obtained must be sorted in either non-decreasing or non-increasing order. At least how many subarrays do you need to divide A into?
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9
* Each A_i is an integer.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible number of subarrays after division of A.
Examples
Input
6
1 2 3 2 2 1
Output
2
Input
9
1 2 1 2 1 2 1 2 1
Output
5
Input
7
1 2 3 2 1 999999999 1000000000
Output
3
Submitted Solution:
```
n = int(input())
A = list(map(int, input().split()))
ans = 1
up = dn = False
pre = A[0]
for a in A[1:]:
if pre < a:
up = True
elif pre > a:
dn = True
if up and dn:
ans += 1
up = dn = False
pre = a
print(ans)
``` | instruction | 0 | 57,047 | 12 | 114,094 |
Yes | output | 1 | 57,047 | 12 | 114,095 |
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. Your task is to divide it into several contiguous subarrays. Here, all subarrays obtained must be sorted in either non-decreasing or non-increasing order. At least how many subarrays do you need to divide A into?
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9
* Each A_i is an integer.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible number of subarrays after division of A.
Examples
Input
6
1 2 3 2 2 1
Output
2
Input
9
1 2 1 2 1 2 1 2 1
Output
5
Input
7
1 2 3 2 1 999999999 1000000000
Output
3
Submitted Solution:
```
N = int(input())
A = list(map(int, input().split()))
cnt = 1
status = 0
for i in range(N-1):
if A[i] > A[i+1]:
if status == 0: status = 1
elif status == -1:
status = 0
cnt += 1
elif A[i] < A[i+1]:
if status == 0: status = -1
elif status == 1:
status = 0
cnt += 1
print(cnt)
``` | instruction | 0 | 57,048 | 12 | 114,096 |
Yes | output | 1 | 57,048 | 12 | 114,097 |
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. Your task is to divide it into several contiguous subarrays. Here, all subarrays obtained must be sorted in either non-decreasing or non-increasing order. At least how many subarrays do you need to divide A into?
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9
* Each A_i is an integer.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible number of subarrays after division of A.
Examples
Input
6
1 2 3 2 2 1
Output
2
Input
9
1 2 1 2 1 2 1 2 1
Output
5
Input
7
1 2 3 2 1 999999999 1000000000
Output
3
Submitted Solution:
```
import sys
input = lambda : sys.stdin.readline().rstrip()
n = int(input())
a = list(map(int, input().split()))
a_ = []
for i in a:
if not a_:
a_.append(i)
elif i != a_[-1]:
a_.append(i)
cnt = 0
flag = 0
if len(a_) == 1 or len(a_) == 2:
print(1)
sys.exit()
for i in range(n - 1):
if flag == 0:
if a[i + 1] - a[i] > 0:
flag = 1
else:
flag = -1
continue
if flag == 1 and a[i + 1] - a[i] < 0:
cnt += 1
flag = 0
elif flag == -1 and a[i + 1] - a[i] > 0:
cnt += 1
flag = 0
print(cnt + 1)
``` | instruction | 0 | 57,049 | 12 | 114,098 |
No | output | 1 | 57,049 | 12 | 114,099 |
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. Your task is to divide it into several contiguous subarrays. Here, all subarrays obtained must be sorted in either non-decreasing or non-increasing order. At least how many subarrays do you need to divide A into?
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9
* Each A_i is an integer.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible number of subarrays after division of A.
Examples
Input
6
1 2 3 2 2 1
Output
2
Input
9
1 2 1 2 1 2 1 2 1
Output
5
Input
7
1 2 3 2 1 999999999 1000000000
Output
3
Submitted Solution:
```
# input
n = int(input())
A = list(map(int, input().split()))
ans = 1
i = 1
while i < n - 1:
if (A[i - 1] - A[i]) * (A[i] - A[i + 1]) < 0:
ans += 1
i += 2
else:
i += 1
print(ans)
``` | instruction | 0 | 57,050 | 12 | 114,100 |
No | output | 1 | 57,050 | 12 | 114,101 |
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. Your task is to divide it into several contiguous subarrays. Here, all subarrays obtained must be sorted in either non-decreasing or non-increasing order. At least how many subarrays do you need to divide A into?
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9
* Each A_i is an integer.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible number of subarrays after division of A.
Examples
Input
6
1 2 3 2 2 1
Output
2
Input
9
1 2 1 2 1 2 1 2 1
Output
5
Input
7
1 2 3 2 1 999999999 1000000000
Output
3
Submitted Solution:
```
N = int(input())
A = list(map(int, input().split()))
up = True
down = True
Pass = False
c = 0
for i in range(N-1):
if Pass:
if i == N-2:
c += 1
Pass = False
continue
if up and A[i] > A[i+1]:
c += 1
if i == N-2:
break
if A[i+1] < A[i+2]:
Pass = True
up = True
down = False
else:
up = False
down = True
elif down and A[i] < A[i+1]:
c += 1
if i == N-2:
break
if A[i+1] > A[i+2]:
Pass = True
up = False
down = True
else:
up = True
down = False
print(c)
``` | instruction | 0 | 57,051 | 12 | 114,102 |
No | output | 1 | 57,051 | 12 | 114,103 |
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. Your task is to divide it into several contiguous subarrays. Here, all subarrays obtained must be sorted in either non-decreasing or non-increasing order. At least how many subarrays do you need to divide A into?
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9
* Each A_i is an integer.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the minimum possible number of subarrays after division of A.
Examples
Input
6
1 2 3 2 2 1
Output
2
Input
9
1 2 1 2 1 2 1 2 1
Output
5
Input
7
1 2 3 2 1 999999999 1000000000
Output
3
Submitted Solution:
```
N = int(input())
A = [int(_) for _ in input().split()]
def solve(N, A):
if N <= 2:
return 1
s = 0
result = 1
i = 0
while i < N-1:
r = A[i+1] - A[i]
if (r > 0 and s < 0) or (r < 0 and s > 0):
result += 1
s = 0
else:
s = r
i += 1
return result
print(min(solve(N, A), solve(N, A[::-1])))
``` | instruction | 0 | 57,052 | 12 | 114,104 |
No | output | 1 | 57,052 | 12 | 114,105 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two arrays of integers a_1,…,a_n and b_1,…,b_m.
Your task is to find a non-empty array c_1,…,c_k that is a subsequence of a_1,…,a_n, and also a subsequence of b_1,…,b_m. If there are multiple answers, find one of the smallest possible length. If there are still multiple of the smallest possible length, find any. If there are no such arrays, you should report about it.
A sequence a is a subsequence of a sequence b if a can be obtained from b by deletion of several (possibly, zero) elements. For example, [3,1] is a subsequence of [3,2,1] and [4,3,1], but not a subsequence of [1,3,3,7] and [3,10,4].
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains two integers n and m (1≤ n,m≤ 1000) — the lengths of the two arrays.
The second line of each test case contains n integers a_1,…,a_n (1≤ a_i≤ 1000) — the elements of the first array.
The third line of each test case contains m integers b_1,…,b_m (1≤ b_i≤ 1000) — the elements of the second array.
It is guaranteed that the sum of n and the sum of m across all test cases does not exceed 1000 (∑_{i=1}^t n_i, ∑_{i=1}^t m_i≤ 1000).
Output
For each test case, output "YES" if a solution exists, or "NO" otherwise.
If the answer is "YES", on the next line output an integer k (1≤ k≤ 1000) — the length of the array, followed by k integers c_1,…,c_k (1≤ c_i≤ 1000) — the elements of the array.
If there are multiple solutions with the smallest possible k, output any.
Example
Input
5
4 5
10 8 6 4
1 2 3 4 5
1 1
3
3
1 1
3
2
5 3
1000 2 2 2 3
3 1 5
5 5
1 2 3 4 5
1 2 3 4 5
Output
YES
1 4
YES
1 3
NO
YES
1 3
YES
1 2
Note
In the first test case, [4] is a subsequence of [10, 8, 6, 4] and [1, 2, 3, 4, 5]. This array has length 1, it is the smallest possible length of a subsequence of both a and b.
In the third test case, no non-empty subsequences of both [3] and [2] exist, so the answer is "NO". | instruction | 0 | 57,286 | 12 | 114,572 |
Tags: brute force
Correct Solution:
```
R=lambda:{*map(int,input().split())}
t,=R()
for _ in[0]*t:R();s=R()&R();print(f'YES 1 {s.pop()}'if s else'NO')
``` | output | 1 | 57,286 | 12 | 114,573 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two arrays of integers a_1,…,a_n and b_1,…,b_m.
Your task is to find a non-empty array c_1,…,c_k that is a subsequence of a_1,…,a_n, and also a subsequence of b_1,…,b_m. If there are multiple answers, find one of the smallest possible length. If there are still multiple of the smallest possible length, find any. If there are no such arrays, you should report about it.
A sequence a is a subsequence of a sequence b if a can be obtained from b by deletion of several (possibly, zero) elements. For example, [3,1] is a subsequence of [3,2,1] and [4,3,1], but not a subsequence of [1,3,3,7] and [3,10,4].
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains two integers n and m (1≤ n,m≤ 1000) — the lengths of the two arrays.
The second line of each test case contains n integers a_1,…,a_n (1≤ a_i≤ 1000) — the elements of the first array.
The third line of each test case contains m integers b_1,…,b_m (1≤ b_i≤ 1000) — the elements of the second array.
It is guaranteed that the sum of n and the sum of m across all test cases does not exceed 1000 (∑_{i=1}^t n_i, ∑_{i=1}^t m_i≤ 1000).
Output
For each test case, output "YES" if a solution exists, or "NO" otherwise.
If the answer is "YES", on the next line output an integer k (1≤ k≤ 1000) — the length of the array, followed by k integers c_1,…,c_k (1≤ c_i≤ 1000) — the elements of the array.
If there are multiple solutions with the smallest possible k, output any.
Example
Input
5
4 5
10 8 6 4
1 2 3 4 5
1 1
3
3
1 1
3
2
5 3
1000 2 2 2 3
3 1 5
5 5
1 2 3 4 5
1 2 3 4 5
Output
YES
1 4
YES
1 3
NO
YES
1 3
YES
1 2
Note
In the first test case, [4] is a subsequence of [10, 8, 6, 4] and [1, 2, 3, 4, 5]. This array has length 1, it is the smallest possible length of a subsequence of both a and b.
In the third test case, no non-empty subsequences of both [3] and [2] exist, so the answer is "NO". | instruction | 0 | 57,287 | 12 | 114,574 |
Tags: brute force
Correct Solution:
```
for t in range(int(input())):
n,m=input().split()
n=int(n)
m=int(m)
a=[]
a=list(map(int,input().split()))
b=[]
b=list(map(int,input().split()))
flag=0
for each in a:
if each in b:
print("YES")
print("1",each)
flag=1
break
if flag==0:
print("NO")
``` | output | 1 | 57,287 | 12 | 114,575 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two arrays of integers a_1,…,a_n and b_1,…,b_m.
Your task is to find a non-empty array c_1,…,c_k that is a subsequence of a_1,…,a_n, and also a subsequence of b_1,…,b_m. If there are multiple answers, find one of the smallest possible length. If there are still multiple of the smallest possible length, find any. If there are no such arrays, you should report about it.
A sequence a is a subsequence of a sequence b if a can be obtained from b by deletion of several (possibly, zero) elements. For example, [3,1] is a subsequence of [3,2,1] and [4,3,1], but not a subsequence of [1,3,3,7] and [3,10,4].
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains two integers n and m (1≤ n,m≤ 1000) — the lengths of the two arrays.
The second line of each test case contains n integers a_1,…,a_n (1≤ a_i≤ 1000) — the elements of the first array.
The third line of each test case contains m integers b_1,…,b_m (1≤ b_i≤ 1000) — the elements of the second array.
It is guaranteed that the sum of n and the sum of m across all test cases does not exceed 1000 (∑_{i=1}^t n_i, ∑_{i=1}^t m_i≤ 1000).
Output
For each test case, output "YES" if a solution exists, or "NO" otherwise.
If the answer is "YES", on the next line output an integer k (1≤ k≤ 1000) — the length of the array, followed by k integers c_1,…,c_k (1≤ c_i≤ 1000) — the elements of the array.
If there are multiple solutions with the smallest possible k, output any.
Example
Input
5
4 5
10 8 6 4
1 2 3 4 5
1 1
3
3
1 1
3
2
5 3
1000 2 2 2 3
3 1 5
5 5
1 2 3 4 5
1 2 3 4 5
Output
YES
1 4
YES
1 3
NO
YES
1 3
YES
1 2
Note
In the first test case, [4] is a subsequence of [10, 8, 6, 4] and [1, 2, 3, 4, 5]. This array has length 1, it is the smallest possible length of a subsequence of both a and b.
In the third test case, no non-empty subsequences of both [3] and [2] exist, so the answer is "NO". | instruction | 0 | 57,288 | 12 | 114,576 |
Tags: brute force
Correct Solution:
```
for _ in range(int(input())):
n,m = map(int,input().split())
x = list(map(int,input().split()))
y = list(map(int,input().split()))
f= False
for i in x:
if i in y:
print("YES")
print(1,i)
f=True
break
if not f:
print("NO")
``` | output | 1 | 57,288 | 12 | 114,577 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.