message stringlengths 2 433k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 2 solution for this coding contest problem.
You are given a sequence of n integers a_1, a_2, ..., a_n. Let us call an index j (2 ≤ j ≤ {{n-1}}) a hill if a_j > a_{{j+1}} and a_j > a_{{j-1}}; and let us call it a valley if a_j < a_{{j+1}} and a_j < a_{{j-1}}.
Let us define the intimidation value of a sequence as the sum of the number of hills and the number of valleys in the sequence. You can change exactly one integer in the sequence to any number that you want, or let the sequence remain unchanged. What is the minimum intimidation value that you can achieve?
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 3⋅10^5).
The second line of each test case contains n space-separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 3⋅10^5.
Output
For each test case, print a single integer — the minimum intimidation value that you can achieve.
Example
Input
4
3
1 5 3
5
2 2 2 2 2
6
1 6 2 5 2 10
5
1 6 2 5 1
Output
0
0
1
0
Note
In the first test case, changing a_2 to 2 results in no hills and no valleys.
In the second test case, the best answer is just to leave the array as it is.
In the third test case, changing a_3 to 6 results in only one valley (at the index 5).
In the fourth test case, changing a_3 to 6 results in no hills and no valleys. | instruction | 0 | 74,385 | 12 | 148,770 |
Tags: brute force, implementation
Correct Solution:
```
""" Python 3 compatibility tools. """
from __future__ import division, print_function
import itertools
import sys
import os
from io import BytesIO
from atexit import register
if sys.version_info[0] < 3:
input = raw_input
range = xrange
filter = itertools.ifilter
map = itertools.imap
zip = itertools.izip
def gcd(x, y):
""" greatest common divisor of x and y """
while y:
x, y = y, x % y
return x
sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
sys.stdout = BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
input = lambda: sys.stdin.readline().rstrip('\r\n')
# import sys
# input=sys.stdin.readline
def isHV(i):
if i <= 0 or i >= n - 1:
return 0
if l[i - 1] < l[i] and l[i] > l[i + 1]:
return 1
if l[i - 1] > l[i] and l[i] < l[i + 1]:
return 1
return 0
cases = int(input())
for _ in range(cases):
n = int(input())
l = list(map(int, input().split()))
count = 0
for i in range(n):
count += isHV(i + 1)
minCount = count
# print(count)
for i in range(1, n - 1):
temp = l[i]
prevI = count - isHV(i - 1) - isHV(i) - isHV(i + 1)
l[i] = l[i - 1]
adjI = isHV(i + 1)
l[i] = l[i + 1]
adjI = min(adjI, isHV(i - 1))
l[i] = temp
minCount = min(minCount, prevI + adjI)
# print(prevI, adjI)
print(minCount)
``` | output | 1 | 74,385 | 12 | 148,771 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of n integers a_1, a_2, ..., a_n. Let us call an index j (2 ≤ j ≤ {{n-1}}) a hill if a_j > a_{{j+1}} and a_j > a_{{j-1}}; and let us call it a valley if a_j < a_{{j+1}} and a_j < a_{{j-1}}.
Let us define the intimidation value of a sequence as the sum of the number of hills and the number of valleys in the sequence. You can change exactly one integer in the sequence to any number that you want, or let the sequence remain unchanged. What is the minimum intimidation value that you can achieve?
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 3⋅10^5).
The second line of each test case contains n space-separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 3⋅10^5.
Output
For each test case, print a single integer — the minimum intimidation value that you can achieve.
Example
Input
4
3
1 5 3
5
2 2 2 2 2
6
1 6 2 5 2 10
5
1 6 2 5 1
Output
0
0
1
0
Note
In the first test case, changing a_2 to 2 results in no hills and no valleys.
In the second test case, the best answer is just to leave the array as it is.
In the third test case, changing a_3 to 6 results in only one valley (at the index 5).
In the fourth test case, changing a_3 to 6 results in no hills and no valleys. | instruction | 0 | 74,386 | 12 | 148,772 |
Tags: brute force, implementation
Correct Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
#import threading
from collections import defaultdict
#threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
#sys.setrecursionlimit(300000)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=300006, func=lambda a, b: min(a , b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b:a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] <key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
class TrieNode:
def __init__(self):
self.children = [None] * 26
self.isEndOfWord = False
class Trie:
def __init__(self):
self.root = self.getNode()
def getNode(self):
return TrieNode()
def _charToIndex(self, ch):
return ord(ch) - ord('a')
def insert(self, key):
pCrawl = self.root
length = len(key)
for level in range(length):
index = self._charToIndex(key[level])
if not pCrawl.children[index]:
pCrawl.children[index] = self.getNode()
pCrawl = pCrawl.children[index]
pCrawl.isEndOfWord = True
def search(self, key):
pCrawl = self.root
length = len(key)
for level in range(length):
index = self._charToIndex(key[level])
if not pCrawl.children[index]:
return False
pCrawl = pCrawl.children[index]
return pCrawl != None and pCrawl.isEndOfWord
#-----------------------------------------trie---------------------------------
class Node:
def __init__(self, data):
self.data = data
self.height=0
self.left = None # left node for 0
self.right = None # right node for 1
class BinaryTrie:
def __init__(self):
self.root = Node(0)
def insert(self, pre_xor):
self.temp = self.root
for i in range(31, -1, -1):
val = pre_xor & (1 << i)
if val==0:
if not self.temp.right:
self.temp.right = Node(0)
self.temp = self.temp.right
elif val>=1:
if not self.temp.left:
self.temp.left = Node(0)
self.temp = self.temp.left
def do(self,temp):
if not temp:
return 0
ter=temp
temp.height=self.do(ter.left)+self.do(ter.right)
if temp.height==0:
temp.height+=1
return temp.height
def query(self, xor):
self.temp = self.root
cur=0
i=31
while(i>-1):
val = xor & (1 << i)
if not self.temp:
return cur
if val>=1:
self.opp = self.temp.right
if self.temp.left:
self.temp = self.temp.left
else:
return cur
else:
self.opp=self.temp.left
if self.temp.right:
self.temp = self.temp.right
else:
return cur
if self.temp.height==pow(2,i):
cur+=1<<(i)
self.temp=self.opp
i-=1
return cur
#-------------------------bin trie-------------------------------------------
for ik in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
ans=0
f=0
l1=[0]*n
cur=0
def check(i):
if i==0 or i==n-1:
return 0
if l[i] < l[i - 1] and l[i] < l[i + 1]:
return 1
if l[i] > l[i - 1] and l[i] > l[i + 1]:
return 1
return 0
last=0
for i in range(1,n-1):
t=l[i]
if l[i]<l[i-1] and l[i]<l[i+1]:
a=1+check(i+1)+last
l[i]=l[i-1]
b=check(i+1)
l[i]=l[i+1]
c=check(i-1)
cur=max(cur,a-b,a-c,0)
ans+=1
last=1
elif l[i]>l[i-1] and l[i]>l[i+1]:
a = 1 + check(i + 1) + last
l[i] = l[i - 1]
b = check(i + 1)
l[i] = l[i + 1]
c = check(i - 1)
cur = max(cur, a-b, a - c, 0)
ans += 1
last=1
else:
last=0
l[i]=t
print(max(0,ans-cur))
``` | output | 1 | 74,386 | 12 | 148,773 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of n integers a_1, a_2, ..., a_n. Let us call an index j (2 ≤ j ≤ {{n-1}}) a hill if a_j > a_{{j+1}} and a_j > a_{{j-1}}; and let us call it a valley if a_j < a_{{j+1}} and a_j < a_{{j-1}}.
Let us define the intimidation value of a sequence as the sum of the number of hills and the number of valleys in the sequence. You can change exactly one integer in the sequence to any number that you want, or let the sequence remain unchanged. What is the minimum intimidation value that you can achieve?
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 3⋅10^5).
The second line of each test case contains n space-separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 3⋅10^5.
Output
For each test case, print a single integer — the minimum intimidation value that you can achieve.
Example
Input
4
3
1 5 3
5
2 2 2 2 2
6
1 6 2 5 2 10
5
1 6 2 5 1
Output
0
0
1
0
Note
In the first test case, changing a_2 to 2 results in no hills and no valleys.
In the second test case, the best answer is just to leave the array as it is.
In the third test case, changing a_3 to 6 results in only one valley (at the index 5).
In the fourth test case, changing a_3 to 6 results in no hills and no valleys. | instruction | 0 | 74,387 | 12 | 148,774 |
Tags: brute force, implementation
Correct Solution:
```
import io
import os
from collections import Counter, defaultdict, deque
def solve(N, A):
score = [0] * N
for i in range(1, N - 1):
s = 0
if A[i - 1] < A[i] > A[i + 1]:
s += 1
if A[i - 1] > A[i] < A[i + 1]:
s += 1
score[i] = s
total = sum(score)
best = total
for i in range(N):
cand = []
if i >= 1:
cand.append(A[i - 1] - 1)
cand.append(A[i - 1])
cand.append(A[i - 1] + 1)
if i < N - 1:
cand.append(A[i + 1] - 1)
cand.append(A[i + 1])
cand.append(A[i + 1] + 1)
for c in cand:
s = total
if i >= 2:
if A[i - 2] < A[i - 1] > c:
s += 1
if A[i - 2] > A[i - 1] < c:
s += 1
s -= score[i - 1]
if 1 <= i < N - 1:
if A[i - 1] < c > A[i + 1]:
s += 1
if A[i - 1] > c < A[i + 1]:
s += 1
s -= score[i]
if i < N - 2:
if c < A[i + 1] > A[i + 2]:
s += 1
if c > A[i + 1] < A[i + 2]:
s += 1
s -= score[i + 1]
best = min(best, s)
return best
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
TC = int(input())
for tc in range(1, TC + 1):
(N,) = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
ans = solve(N, A)
print(ans)
``` | output | 1 | 74,387 | 12 | 148,775 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of n integers a_1, a_2, ..., a_n. Let us call an index j (2 ≤ j ≤ {{n-1}}) a hill if a_j > a_{{j+1}} and a_j > a_{{j-1}}; and let us call it a valley if a_j < a_{{j+1}} and a_j < a_{{j-1}}.
Let us define the intimidation value of a sequence as the sum of the number of hills and the number of valleys in the sequence. You can change exactly one integer in the sequence to any number that you want, or let the sequence remain unchanged. What is the minimum intimidation value that you can achieve?
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 3⋅10^5).
The second line of each test case contains n space-separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 3⋅10^5.
Output
For each test case, print a single integer — the minimum intimidation value that you can achieve.
Example
Input
4
3
1 5 3
5
2 2 2 2 2
6
1 6 2 5 2 10
5
1 6 2 5 1
Output
0
0
1
0
Note
In the first test case, changing a_2 to 2 results in no hills and no valleys.
In the second test case, the best answer is just to leave the array as it is.
In the third test case, changing a_3 to 6 results in only one valley (at the index 5).
In the fourth test case, changing a_3 to 6 results in no hills and no valleys. | instruction | 0 | 74,388 | 12 | 148,776 |
Tags: brute force, implementation
Correct Solution:
```
import typing
import sys
import math
import collections
import bisect
import itertools
import heapq
import decimal
import copy
import operator
# sys.setrecursionlimit(10000001)
INF = 10 ** 20
MOD = 10 ** 9 + 7
# MOD = 998244353
# buffer.readline()
def ni(): return int(sys.stdin.readline())
def ns(): return map(int, sys.stdin.readline().split())
def na(): return list(map(int, sys.stdin.readline().split()))
def na1(): return list(map(lambda x: int(x)-1, sys.stdin.readline().split()))
# ===CODE===
def main():
t = ni()
o = []
for ti in range(t):
n = ni()
a = na()
if n <= 2:
o.append(0)
continue
total = 0
res = [0 for _ in range(n)]
for i in range(1, n-1):
if a[i-1] < a[i] and a[i] > a[i+1]:
res[i] = 1
total += 1
if a[i-1] > a[i] and a[i] < a[i+1]:
res[i] = 1
total += 1
def check(idx, cai):
cnt = 0
tmp = a[idx]
a[idx] = cai
for i in range(max(1, idx-1), min(n-1, idx+2)):
if a[i-1] < a[i] and a[i] > a[i+1]:
cnt += 1
if a[i-1] > a[i] and a[i] < a[i+1]:
cnt += 1
a[idx] = tmp
return cnt
ans = total
mx = 0
for i in range(1, n-1):
c = 0
for j in range(i-1, i+2):
if res[j]:
c += 1
tc1 = c-check(i, a[i-1])
tc2 = c-check(i, a[i+1])
mx = max(mx, tc1, tc2)
o.append(ans-mx)
for oi in o:
print(oi)
if __name__ == '__main__':
main()
``` | output | 1 | 74,388 | 12 | 148,777 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of n integers a_1, a_2, ..., a_n. Let us call an index j (2 ≤ j ≤ {{n-1}}) a hill if a_j > a_{{j+1}} and a_j > a_{{j-1}}; and let us call it a valley if a_j < a_{{j+1}} and a_j < a_{{j-1}}.
Let us define the intimidation value of a sequence as the sum of the number of hills and the number of valleys in the sequence. You can change exactly one integer in the sequence to any number that you want, or let the sequence remain unchanged. What is the minimum intimidation value that you can achieve?
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 3⋅10^5).
The second line of each test case contains n space-separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 3⋅10^5.
Output
For each test case, print a single integer — the minimum intimidation value that you can achieve.
Example
Input
4
3
1 5 3
5
2 2 2 2 2
6
1 6 2 5 2 10
5
1 6 2 5 1
Output
0
0
1
0
Note
In the first test case, changing a_2 to 2 results in no hills and no valleys.
In the second test case, the best answer is just to leave the array as it is.
In the third test case, changing a_3 to 6 results in only one valley (at the index 5).
In the fourth test case, changing a_3 to 6 results in no hills and no valleys. | instruction | 0 | 74,389 | 12 | 148,778 |
Tags: brute force, implementation
Correct Solution:
```
def hv_test(a,b,c):
if (a < b > c) or (a > b < c):
return True
else:
return False
t = int(input())
for _ in range(t):
n = int(input())
arr = list(map(lambda x : int(x), input().split()))
##precompute hill/valley info
is_hv = [0]*n
ans = 0
if n > 2:
i=1
##count hill and valley count
while i < n-1:
#hill or valley
if hv_test(arr[i-1], arr[i], arr[i+1]):
is_hv[i] = 1
ans += 1
i+=1
total = ans
#print('total', total)
##now substitute arr[i] to either arr[i-1] or arr[i+1] and update the calculation..
i=1
while i < n - 1:
#print('i = ', i, ', arr[i] = ', arr[i])
ans1 = total
ans2 = total
if is_hv[i]:
# case-1
tmp = 1
x = arr[i - 1]
i-=1
if i-1 >= 0:
t1 = is_hv[i]
t2 = hv_test(arr[i - 1], arr[i], x)
#print('case-1 [i-1]', t1,t2)
if t1 and not t2:
tmp += 1
elif not t1 and t2:
tmp -= 1
i+=2
if i+1 <n:
t1 = is_hv[i]
t2 = hv_test(x, arr[i], arr[i + 1])
#print('case-1 [i+1]', t1, t2)
if t1 and not t2:
tmp += 1
elif not t1 and t2:
tmp -= 1
i-=1
ans1 = min(ans1, total-tmp)
#print('ans1=', ans1)
# case-2
tmp = 1
x = arr[i + 1]
i -= 1
if i-1 >= 0:
t1 = is_hv[i]
t2 = hv_test(arr[i - 1], arr[i], x)
#print('case-1 [i-1]', t1,t2)
if t1 and not t2:
tmp += 1
elif not t1 and t2:
tmp -= 1
i+=2
if i+1 <n:
t1 = is_hv[i]
t2 = hv_test(x, arr[i], arr[i + 1])
#print('case-1 [i+1]', t1, t2)
if t1 and not t2:
tmp += 1
elif not t1 and t2:
tmp -= 1
i -= 1
ans2 = min(ans2, total - tmp)
#print('ans2=', ans2)
ans = min(ans, ans1, ans2)
i+=1
print(ans)
``` | output | 1 | 74,389 | 12 | 148,779 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of n integers a_1, a_2, ..., a_n. Let us call an index j (2 ≤ j ≤ {{n-1}}) a hill if a_j > a_{{j+1}} and a_j > a_{{j-1}}; and let us call it a valley if a_j < a_{{j+1}} and a_j < a_{{j-1}}.
Let us define the intimidation value of a sequence as the sum of the number of hills and the number of valleys in the sequence. You can change exactly one integer in the sequence to any number that you want, or let the sequence remain unchanged. What is the minimum intimidation value that you can achieve?
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 3⋅10^5).
The second line of each test case contains n space-separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 3⋅10^5.
Output
For each test case, print a single integer — the minimum intimidation value that you can achieve.
Example
Input
4
3
1 5 3
5
2 2 2 2 2
6
1 6 2 5 2 10
5
1 6 2 5 1
Output
0
0
1
0
Note
In the first test case, changing a_2 to 2 results in no hills and no valleys.
In the second test case, the best answer is just to leave the array as it is.
In the third test case, changing a_3 to 6 results in only one valley (at the index 5).
In the fourth test case, changing a_3 to 6 results in no hills and no valleys. | instruction | 0 | 74,390 | 12 | 148,780 |
Tags: brute force, implementation
Correct Solution:
```
for i in range(int(input())):
n=int(input())
arr = list(map(int, input().split()))
ans=0
c=0
ma=0
for i in range(1,n-1):
c=arr[i]
cntn=0
for j in range(max(1,i-1),min(i+2,n-1)):
if arr[j - 1] > arr[j] and arr[j + 1] > arr[j]:
cntn += 1
elif arr[j - 1] < arr[j] and arr[j] > arr[j + 1]:
cntn += 1
if arr[i - 1] > arr[i] and arr[i + 1] > arr[i]:
ans+=1
arr[i]=max(arr[i-1],arr[i+1])
elif arr[i - 1] < arr[i] and arr[i] > arr[i + 1]:
ans+=1
arr[i] = min(arr[i - 1], arr[i + 1])
cnt=0
for j in range(max(1,i-1),min(i+2,n-1)):
if arr[j - 1] > arr[j] and arr[j + 1] > arr[j]:
cnt += 1
elif arr[j - 1] < arr[j] and arr[j] > arr[j + 1]:
cnt += 1
arr[i]=c
ma=max(ma,cntn-cnt)
c=arr[i]
cntn=0
for j in range(max(1,i-1),min(i+2,n-1)):
if arr[j - 1] > arr[j] and arr[j + 1] > arr[j]:
cntn += 1
elif arr[j - 1] < arr[j] and arr[j] > arr[j + 1]:
cntn += 1
if arr[i - 1] > arr[i] and arr[i + 1] > arr[i]:
arr[i]=min(arr[i-1],arr[i+1])
elif arr[i - 1] < arr[i] and arr[i] > arr[i + 1]:
arr[i] = max(arr[i - 1], arr[i + 1])
cnt=0
for j in range(max(1,i-1),min(i+2,n-1)):
if arr[j - 1] > arr[j] and arr[j + 1] > arr[j]:
cnt += 1
elif arr[j - 1] < arr[j] and arr[j] > arr[j + 1]:
cnt += 1
arr[i]=c
ma=max(ma,cntn-cnt)
print(ans-ma)
``` | output | 1 | 74,390 | 12 | 148,781 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of n integers a_1, a_2, ..., a_n. Let us call an index j (2 ≤ j ≤ {{n-1}}) a hill if a_j > a_{{j+1}} and a_j > a_{{j-1}}; and let us call it a valley if a_j < a_{{j+1}} and a_j < a_{{j-1}}.
Let us define the intimidation value of a sequence as the sum of the number of hills and the number of valleys in the sequence. You can change exactly one integer in the sequence to any number that you want, or let the sequence remain unchanged. What is the minimum intimidation value that you can achieve?
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 3⋅10^5).
The second line of each test case contains n space-separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 3⋅10^5.
Output
For each test case, print a single integer — the minimum intimidation value that you can achieve.
Example
Input
4
3
1 5 3
5
2 2 2 2 2
6
1 6 2 5 2 10
5
1 6 2 5 1
Output
0
0
1
0
Note
In the first test case, changing a_2 to 2 results in no hills and no valleys.
In the second test case, the best answer is just to leave the array as it is.
In the third test case, changing a_3 to 6 results in only one valley (at the index 5).
In the fourth test case, changing a_3 to 6 results in no hills and no valleys. | instruction | 0 | 74,391 | 12 | 148,782 |
Tags: brute force, implementation
Correct Solution:
```
import sys
import math
from collections import defaultdict,Counter
# input=sys.stdin.readline
# def print(x):
# sys.stdout.write(str(x)+"\n")
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# sys.stdout=open("CP2/output.txt",'w')
# sys.stdin=open("CP2/input.txt",'r')
# mod=pow(10,9)+7
t=int(input())
for i in range(t):
n=int(input())
a=list(map(int,input().split()))
tot=0
ma=0
for j in range(1,n-1):
if a[j]>a[j-1] and a[j]>a[j+1]:
tot+=1
ans1=0
ans2=0
cur=1
if j-1>0:
if a[j-1]<a[j-2]:
cur+=1
if a[j-1]>a[j-2] and a[j-1]>a[j+1]:
ans2+=1
elif a[j-1]<a[j-2] and a[j-1]<a[j+1]:
ans2+=1
if j+2<n:
if a[j+1]<a[j+2]:
cur+=1
if a[j+1]>a[j-1] and a[j+1]>a[j+2]:
ans1+=1
elif a[j+1]<a[j-1] and a[j+1]<a[j+2]:
ans1+=1
ma=max(ma,cur-min(ans1,ans2))
elif a[j]<a[j-1] and a[j]<a[j+1]:
tot+=1
ans1=0
ans2=0
cur=1
if j-1>0:
if a[j-1]>a[j-2]:
cur+=1
if a[j-1]>a[j-2] and a[j-1]>a[j+1]:
ans2+=1
elif a[j-1]<a[j-2] and a[j-1]<a[j+1]:
ans2+=1
if j+2<n:
if a[j+1]>a[j+2]:
cur+=1
if a[j+1]>a[j-1] and a[j+1]>a[j+2]:
ans1+=1
elif a[j+1]<a[j-1] and a[j+1]<a[j+2]:
ans1+=1
ma=max(ma,cur-min(ans1,ans2))
print(tot-ma)
``` | output | 1 | 74,391 | 12 | 148,783 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of n integers a_1, a_2, ..., a_n. Let us call an index j (2 ≤ j ≤ {{n-1}}) a hill if a_j > a_{{j+1}} and a_j > a_{{j-1}}; and let us call it a valley if a_j < a_{{j+1}} and a_j < a_{{j-1}}.
Let us define the intimidation value of a sequence as the sum of the number of hills and the number of valleys in the sequence. You can change exactly one integer in the sequence to any number that you want, or let the sequence remain unchanged. What is the minimum intimidation value that you can achieve?
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 3⋅10^5).
The second line of each test case contains n space-separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 3⋅10^5.
Output
For each test case, print a single integer — the minimum intimidation value that you can achieve.
Example
Input
4
3
1 5 3
5
2 2 2 2 2
6
1 6 2 5 2 10
5
1 6 2 5 1
Output
0
0
1
0
Note
In the first test case, changing a_2 to 2 results in no hills and no valleys.
In the second test case, the best answer is just to leave the array as it is.
In the third test case, changing a_3 to 6 results in only one valley (at the index 5).
In the fourth test case, changing a_3 to 6 results in no hills and no valleys. | instruction | 0 | 74,392 | 12 | 148,784 |
Tags: brute force, 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')
def inp():
return sys.stdin.readline().rstrip()
def mpint():
return map(int, inp().split(' '))
def itg():
return int(inp())
# ############################## import
# ############################## main
def solve():
n = itg()
a = tuple(mpint())
if n <= 2:
return 0
b = [0] * n
for i in range(1, n - 1):
if a[i - 1] < a[i] > a[i + 1]:
b[i] = 1
elif a[i - 1] > a[i] < a[i + 1]:
b[i] = 1
s = sum(b)
ans = min(s - b[1], s - b[-2]) # modify a[0] or a[-1]
# try to modify a[i] -> a[i-1] or a[i+1]
for i in range(1, n - 1):
# a[i] -> a[i-1]
# so a[i-1] and a[i] is good
# now consider a[i+1]
ans2 = s - b[i] - b[i - 1]
if i + 1 != n - 1:
ans2 -= b[i + 1]
if a[i - 1] < a[i + 1] > a[i + 2] or a[i - 1] > a[i + 1] < a[i + 2]:
ans2 += 1
ans = min(ans, ans2)
# similarly for a[i] -> a[i+1]
ans2 = s - b[i] - b[i + 1]
if i - 1:
ans2 -= b[i - 1]
if a[i - 2] < a[i - 1] > a[i + 1] or a[i - 2] > a[i - 1] < a[i + 1]:
ans2 += 1
ans = min(ans, ans2)
return ans
def main():
# solve()
# print(solve())
for _ in range(itg()):
print(solve())
# solve()
# print("yes" if solve() else "no")
# print("YES" if solve() else "NO")
DEBUG = 0
URL = 'https://codeforces.com/contest/1467/problem/B'
if __name__ == '__main__':
# 0: normal, 1: runner, 2: interactive, 3: debug
if DEBUG == 1:
import requests
from ACgenerator.Y_Test_Case_Runner import TestCaseRunner
runner = TestCaseRunner(main, URL)
inp = runner.input_stream
print = runner.output_stream
runner.checking()
else:
if DEBUG != 3:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
if DEBUG:
_print = print
def print(*args, **kwargs):
_print(*args, **kwargs)
sys.stdout.flush()
main()
# Please check!
``` | output | 1 | 74,392 | 12 | 148,785 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of n integers a_1, a_2, ..., a_n. Let us call an index j (2 ≤ j ≤ {{n-1}}) a hill if a_j > a_{{j+1}} and a_j > a_{{j-1}}; and let us call it a valley if a_j < a_{{j+1}} and a_j < a_{{j-1}}.
Let us define the intimidation value of a sequence as the sum of the number of hills and the number of valleys in the sequence. You can change exactly one integer in the sequence to any number that you want, or let the sequence remain unchanged. What is the minimum intimidation value that you can achieve?
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 3⋅10^5).
The second line of each test case contains n space-separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 3⋅10^5.
Output
For each test case, print a single integer — the minimum intimidation value that you can achieve.
Example
Input
4
3
1 5 3
5
2 2 2 2 2
6
1 6 2 5 2 10
5
1 6 2 5 1
Output
0
0
1
0
Note
In the first test case, changing a_2 to 2 results in no hills and no valleys.
In the second test case, the best answer is just to leave the array as it is.
In the third test case, changing a_3 to 6 results in only one valley (at the index 5).
In the fourth test case, changing a_3 to 6 results in no hills and no valleys. | instruction | 0 | 74,393 | 12 | 148,786 |
Tags: brute force, implementation
Correct Solution:
```
from pprint import pprint
import sys
input = sys.stdin.readline
def do():
n = int(input())
buf = list(map(int, input().split()))
dat = [-1] * (n + 4)
for i in range(n):
dat[i+2] = buf[i]
dat[0] = dat[1] = buf[0]
dat[n+2] = dat[n+3] = buf[n-1]
cnt = 0
if n in [1, 2, 3]:
print(0)
return
# count
for i in range(3, n +1):
if dat[i - 1] < dat[i] and dat[i] > dat[i + 1]:
cnt += 1
continue
if dat[i - 1] > dat[i] and dat[i] < dat[i + 1]:
cnt += 1
continue
m = 0
# print(dat)
plist = [0, 0, 0, 0, 0]
for i in range(3, n +1):
#print(i)
plist[0] = dat[i - 2]
plist[1] = dat[i - 1]
plist[2] = dat[i]
plist[3] = dat[i + 1]
plist[4] = dat[i + 2]
t = 0
if (plist[0] < plist[1] and plist[1] > plist[2]) or (plist[0] > plist[1] and plist[1] < plist[2]):
t += 1
if (plist[1] < plist[2] and plist[2] > plist[3]) or (plist[1] > plist[2] and plist[2] < plist[3]):
t += 1
if (plist[2] < plist[3] and plist[3] > plist[4]) or (plist[2] > plist[3] and plist[3] < plist[4]):
t += 1
orig= t
plist[2] = dat[i - 1]
t = 0
if (plist[0] < plist[1] and plist[1] > plist[2]) or (plist[0] > plist[1] and plist[1] < plist[2]):
t += 1
if (plist[1] < plist[2] and plist[2] > plist[3]) or (plist[1] > plist[2] and plist[2] < plist[3]):
t += 1
if (plist[2] < plist[3] and plist[3] > plist[4]) or (plist[2] > plist[3] and plist[3] < plist[4]):
t += 1
m = max(m, orig - t)
plist[2] = dat[i + 1]
t = 0
if (plist[0] < plist[1] and plist[1] > plist[2]) or (plist[0] > plist[1] and plist[1] < plist[2]):
t += 1
if (plist[1] < plist[2] and plist[2] > plist[3]) or (plist[1] > plist[2] and plist[2] < plist[3]):
t += 1
if (plist[2] < plist[3] and plist[3] > plist[4]) or (plist[2] > plist[3] and plist[3] < plist[4]):
t += 1
m = max(m, orig - t)
print(cnt - m)
q = int(input())
for _ in range(q):
do()
``` | output | 1 | 74,393 | 12 | 148,787 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence of n integers a_1, a_2, ..., a_n. Let us call an index j (2 ≤ j ≤ {{n-1}}) a hill if a_j > a_{{j+1}} and a_j > a_{{j-1}}; and let us call it a valley if a_j < a_{{j+1}} and a_j < a_{{j-1}}.
Let us define the intimidation value of a sequence as the sum of the number of hills and the number of valleys in the sequence. You can change exactly one integer in the sequence to any number that you want, or let the sequence remain unchanged. What is the minimum intimidation value that you can achieve?
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 3⋅10^5).
The second line of each test case contains n space-separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 3⋅10^5.
Output
For each test case, print a single integer — the minimum intimidation value that you can achieve.
Example
Input
4
3
1 5 3
5
2 2 2 2 2
6
1 6 2 5 2 10
5
1 6 2 5 1
Output
0
0
1
0
Note
In the first test case, changing a_2 to 2 results in no hills and no valleys.
In the second test case, the best answer is just to leave the array as it is.
In the third test case, changing a_3 to 6 results in only one valley (at the index 5).
In the fourth test case, changing a_3 to 6 results in no hills and no valleys.
Submitted Solution:
```
#from sys import stdin,stdout
#input=stdin.readline
#import math,bisect
#from itertools import permutations
#from collections import Counter
def hv(l,i):
if l[i]>l[i-1] and l[i]>l[i+1]:
return 1
elif l[i]<l[i-1] and l[i]<l[i+1]:
return 1
else:
return 0
for _ in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
if n<=4:
print(0)
else:
l1=[]
l1.append(0)
for i in range(1,n-1):
l1.append(hv(l,i))
l1.append(0)
ans=n
#print(l1)
s=l1.count(1)
ans=min(ans,s-(l1[0]+l1[1]+l1[2]))
for i in range(2,n-2):
old=l[i]
l[i]=l[i-1]
a1=max(0,hv(l,i-1))
a2=max(0,hv(l,i))
a3=max(0,hv(l,i+1))
a=a1+a2+a3
#print(a1,a2,a3)
ans=min(ans,s-(l1[i-1]+l1[i]+l1[i+1]-a))
l[i]=l[i+1]
a1=max(0,hv(l,i-1))
a2=max(0,hv(l,i))
a3=max(0,hv(l,i+1))
a=a1+a2+a3
#print(a1,a2,a3)
ans=min(ans,s-(l1[i-1]+l1[i]+l1[i+1]-a))
#print(ans)
l[i]=old
ans=min(ans,s-(l1[n-1]+l1[n-2]+l1[n-3]))
print(ans)
``` | instruction | 0 | 74,395 | 12 | 148,790 |
Yes | output | 1 | 74,395 | 12 | 148,791 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence of n integers a_1, a_2, ..., a_n. Let us call an index j (2 ≤ j ≤ {{n-1}}) a hill if a_j > a_{{j+1}} and a_j > a_{{j-1}}; and let us call it a valley if a_j < a_{{j+1}} and a_j < a_{{j-1}}.
Let us define the intimidation value of a sequence as the sum of the number of hills and the number of valleys in the sequence. You can change exactly one integer in the sequence to any number that you want, or let the sequence remain unchanged. What is the minimum intimidation value that you can achieve?
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 3⋅10^5).
The second line of each test case contains n space-separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 3⋅10^5.
Output
For each test case, print a single integer — the minimum intimidation value that you can achieve.
Example
Input
4
3
1 5 3
5
2 2 2 2 2
6
1 6 2 5 2 10
5
1 6 2 5 1
Output
0
0
1
0
Note
In the first test case, changing a_2 to 2 results in no hills and no valleys.
In the second test case, the best answer is just to leave the array as it is.
In the third test case, changing a_3 to 6 results in only one valley (at the index 5).
In the fourth test case, changing a_3 to 6 results in no hills and no valleys.
Submitted Solution:
```
# cook your code here
# cook your dish here
import os,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)
try:sys.stdin,sys.stdout=open('in.txt','r'),open('out.txt','w')
except:pass
ii1=lambda:int(sys.stdin.readline().strip()) # for interger
is1=lambda:sys.stdin.readline().strip() # for str
iia=lambda:list(map(int,sys.stdin.readline().strip().split())) # for List[int]
isa=lambda:sys.stdin.readline().strip().split() # for List[str]
mod=int(1e9 + 7);from collections import *;from math import *
# abc = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
# sys.setrecursionlimit(500000)
# from collections import defaultdict as dd
from functools import lru_cache
###################### Start Here ######################
R = range
def main():
n = ii1();arr = iia()
def check(i):return +(0<i<n-1 and (arr[i-1]<arr[i]>arr[i+1] or arr[i-1]>arr[i]<arr[i+1]))
ans = [check(i) for i in range(n)]
ans.append(0)
diff = 0
for i in R(n):
temp = arr[i] # to store the actual value of the array
me = ans[i]
prev = ans[i+1] + ans[i-1] + ans[i] # no of hill and vally before we change the arr[i]
if i:#i > 0
arr[i] = arr[i-1]
diff = min(diff,check(i+1)-prev)
if i+1<n:# i is not last one
arr[i] = arr[i+1]
diff = min(diff,check(i-1)-prev)
arr[i] = temp
print(sum(ans)+diff)
if __name__ == '__main__':
for _ in range(ii1()):
main()
``` | instruction | 0 | 74,397 | 12 | 148,794 |
Yes | output | 1 | 74,397 | 12 | 148,795 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Baby Badawy's first words were "AND 0 SUM BIG", so he decided to solve the following problem. Given two integers n and k, count the number of arrays of length n such that:
* all its elements are integers between 0 and 2^k-1 (inclusive);
* the [bitwise AND](https://en.wikipedia.org/wiki/Bitwise_operation#AND) of all its elements is 0;
* the sum of its elements is as large as possible.
Since the answer can be very large, print its remainder when divided by 10^9+7.
Input
The first line contains an integer t (1 ≤ t ≤ 10) — the number of test cases you need to solve.
Each test case consists of a line containing two integers n and k (1 ≤ n ≤ 10^{5}, 1 ≤ k ≤ 20).
Output
For each test case, print the number of arrays satisfying the conditions. Since the answer can be very large, print its remainder when divided by 10^9+7.
Example
Input
2
2 2
100000 20
Output
4
226732710
Note
In the first example, the 4 arrays are:
* [3,0],
* [0,3],
* [1,2],
* [2,1]. | instruction | 0 | 74,418 | 12 | 148,836 |
Tags: bitmasks, combinatorics, math
Correct Solution:
```
import os,sys
from io import BytesIO, IOBase
from collections import deque, Counter,defaultdict as dft
from heapq import heappop ,heappush
from math import log,sqrt,factorial,cos,tan,sin,radians,log2,ceil,floor,gcd
from bisect import bisect,bisect_left,bisect_right
from decimal import *
import sys,threading
from itertools import permutations, combinations
from copy import deepcopy
input = sys.stdin.readline
ii = lambda: int(input())
si = lambda: input().rstrip()
mp = lambda: map(int, input().split())
ms= lambda: map(str,input().strip().split(" "))
ml = lambda: list(mp())
mf = lambda: map(float, input().split())
alphs = "abcdefghijklmnopqrstuvwxyz"
def solve():
n,k=mp()
mxn=10**9 + 7
print(pow(n,k,mxn))
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
tc=1
tc = ii()
for i in range(tc):
solve()
``` | output | 1 | 74,418 | 12 | 148,837 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Baby Badawy's first words were "AND 0 SUM BIG", so he decided to solve the following problem. Given two integers n and k, count the number of arrays of length n such that:
* all its elements are integers between 0 and 2^k-1 (inclusive);
* the [bitwise AND](https://en.wikipedia.org/wiki/Bitwise_operation#AND) of all its elements is 0;
* the sum of its elements is as large as possible.
Since the answer can be very large, print its remainder when divided by 10^9+7.
Input
The first line contains an integer t (1 ≤ t ≤ 10) — the number of test cases you need to solve.
Each test case consists of a line containing two integers n and k (1 ≤ n ≤ 10^{5}, 1 ≤ k ≤ 20).
Output
For each test case, print the number of arrays satisfying the conditions. Since the answer can be very large, print its remainder when divided by 10^9+7.
Example
Input
2
2 2
100000 20
Output
4
226732710
Note
In the first example, the 4 arrays are:
* [3,0],
* [0,3],
* [1,2],
* [2,1]. | instruction | 0 | 74,419 | 12 | 148,838 |
Tags: bitmasks, combinatorics, math
Correct Solution:
```
for _ in range(int(input())):
n,k = map(int,input().split())
a = pow(n,k,pow(10,9)+7)
if n==1:
a = 1
a = a%(pow(10,9)+7)
print(a)
``` | output | 1 | 74,419 | 12 | 148,839 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Baby Badawy's first words were "AND 0 SUM BIG", so he decided to solve the following problem. Given two integers n and k, count the number of arrays of length n such that:
* all its elements are integers between 0 and 2^k-1 (inclusive);
* the [bitwise AND](https://en.wikipedia.org/wiki/Bitwise_operation#AND) of all its elements is 0;
* the sum of its elements is as large as possible.
Since the answer can be very large, print its remainder when divided by 10^9+7.
Input
The first line contains an integer t (1 ≤ t ≤ 10) — the number of test cases you need to solve.
Each test case consists of a line containing two integers n and k (1 ≤ n ≤ 10^{5}, 1 ≤ k ≤ 20).
Output
For each test case, print the number of arrays satisfying the conditions. Since the answer can be very large, print its remainder when divided by 10^9+7.
Example
Input
2
2 2
100000 20
Output
4
226732710
Note
In the first example, the 4 arrays are:
* [3,0],
* [0,3],
* [1,2],
* [2,1]. | instruction | 0 | 74,420 | 12 | 148,840 |
Tags: bitmasks, combinatorics, math
Correct Solution:
```
#pyrival orz
import os
import sys
import math
from io import BytesIO, IOBase
input = sys.stdin.readline
############ ---- Input Functions ---- ############
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
############ ---- Dijkstra with path ---- ############
def dijkstra(start, distance, path, n):
# requires n == number of vertices in graph,
# adj == adjacency list with weight of graph
visited = [False for _ in range(n)] # To keep track of vertices that are visited
distance[start] = 0 # distance of start node from itself is 0
for i in range(n):
v = -1 # Initialize v == vertex from which its neighboring vertices' distance will be calculated
for j in range(n):
# If it has not been visited and has the lowest distance from start
if not visited[v] and (v == -1 or distance[j] < distance[v]):
v = j
if distance[v] == math.inf:
break
visited[v] = True # Mark as visited
for edge in adj[v]:
destination = edge[0] # Neighbor of the vertex
weight = edge[1] # Its corresponding weight
if distance[v] + weight < distance[destination]: # If its distance is less than the stored distance
distance[destination] = distance[v] + weight # Update the distance
path[destination] = v # Update the path
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a%b)
def lcm(a, b):
return (a*b)//gcd(a, b)
def ncr(n, r):
return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))
def npr(n, r):
return math.factorial(n)//math.factorial(n-r)
def seive(n):
primes = [True]*(n+1)
ans = []
for i in range(2, n):
if not primes[i]:
continue
j = 2*i
while j <= n:
primes[j] = False
j += i
for p in range(2, n+1):
if primes[p]:
ans += [p]
return ans
def factors(n):
factors = []
x = 1
while x*x <= n:
if n % x == 0:
if n // x == x:
factors.append(x)
else:
factors.append(x)
factors.append(n//x)
x += 1
return factors
# Functions: list of factors, seive of primes, gcd of two numbers,
# lcm of two numbers, npr, ncr
def main():
try:
mod = 10**9 + 7
for _ in range(inp()):
n, k = invr()
ans = 1
for i in range(k):
ans *= n
ans %= mod
print(ans)
except Exception as e:
print(e)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
``` | output | 1 | 74,420 | 12 | 148,841 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Baby Badawy's first words were "AND 0 SUM BIG", so he decided to solve the following problem. Given two integers n and k, count the number of arrays of length n such that:
* all its elements are integers between 0 and 2^k-1 (inclusive);
* the [bitwise AND](https://en.wikipedia.org/wiki/Bitwise_operation#AND) of all its elements is 0;
* the sum of its elements is as large as possible.
Since the answer can be very large, print its remainder when divided by 10^9+7.
Input
The first line contains an integer t (1 ≤ t ≤ 10) — the number of test cases you need to solve.
Each test case consists of a line containing two integers n and k (1 ≤ n ≤ 10^{5}, 1 ≤ k ≤ 20).
Output
For each test case, print the number of arrays satisfying the conditions. Since the answer can be very large, print its remainder when divided by 10^9+7.
Example
Input
2
2 2
100000 20
Output
4
226732710
Note
In the first example, the 4 arrays are:
* [3,0],
* [0,3],
* [1,2],
* [2,1]. | instruction | 0 | 74,421 | 12 | 148,842 |
Tags: bitmasks, combinatorics, math
Correct Solution:
```
for s in[*open(0)][1:]:print(pow(*map(int,s.split()),10**9+7))
``` | output | 1 | 74,421 | 12 | 148,843 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Baby Badawy's first words were "AND 0 SUM BIG", so he decided to solve the following problem. Given two integers n and k, count the number of arrays of length n such that:
* all its elements are integers between 0 and 2^k-1 (inclusive);
* the [bitwise AND](https://en.wikipedia.org/wiki/Bitwise_operation#AND) of all its elements is 0;
* the sum of its elements is as large as possible.
Since the answer can be very large, print its remainder when divided by 10^9+7.
Input
The first line contains an integer t (1 ≤ t ≤ 10) — the number of test cases you need to solve.
Each test case consists of a line containing two integers n and k (1 ≤ n ≤ 10^{5}, 1 ≤ k ≤ 20).
Output
For each test case, print the number of arrays satisfying the conditions. Since the answer can be very large, print its remainder when divided by 10^9+7.
Example
Input
2
2 2
100000 20
Output
4
226732710
Note
In the first example, the 4 arrays are:
* [3,0],
* [0,3],
* [1,2],
* [2,1]. | instruction | 0 | 74,422 | 12 | 148,844 |
Tags: bitmasks, combinatorics, math
Correct Solution:
```
for _ in range(int(input())):
n,k = map(int,input().split())
m = 1000000007
x = n**k % m
print(x)
``` | output | 1 | 74,422 | 12 | 148,845 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Baby Badawy's first words were "AND 0 SUM BIG", so he decided to solve the following problem. Given two integers n and k, count the number of arrays of length n such that:
* all its elements are integers between 0 and 2^k-1 (inclusive);
* the [bitwise AND](https://en.wikipedia.org/wiki/Bitwise_operation#AND) of all its elements is 0;
* the sum of its elements is as large as possible.
Since the answer can be very large, print its remainder when divided by 10^9+7.
Input
The first line contains an integer t (1 ≤ t ≤ 10) — the number of test cases you need to solve.
Each test case consists of a line containing two integers n and k (1 ≤ n ≤ 10^{5}, 1 ≤ k ≤ 20).
Output
For each test case, print the number of arrays satisfying the conditions. Since the answer can be very large, print its remainder when divided by 10^9+7.
Example
Input
2
2 2
100000 20
Output
4
226732710
Note
In the first example, the 4 arrays are:
* [3,0],
* [0,3],
* [1,2],
* [2,1]. | instruction | 0 | 74,423 | 12 | 148,846 |
Tags: bitmasks, combinatorics, math
Correct Solution:
```
t=int(input())
for i in range(t):
n,k=map(int,input().split())
print((n**k)%(10**9+7))
``` | output | 1 | 74,423 | 12 | 148,847 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Baby Badawy's first words were "AND 0 SUM BIG", so he decided to solve the following problem. Given two integers n and k, count the number of arrays of length n such that:
* all its elements are integers between 0 and 2^k-1 (inclusive);
* the [bitwise AND](https://en.wikipedia.org/wiki/Bitwise_operation#AND) of all its elements is 0;
* the sum of its elements is as large as possible.
Since the answer can be very large, print its remainder when divided by 10^9+7.
Input
The first line contains an integer t (1 ≤ t ≤ 10) — the number of test cases you need to solve.
Each test case consists of a line containing two integers n and k (1 ≤ n ≤ 10^{5}, 1 ≤ k ≤ 20).
Output
For each test case, print the number of arrays satisfying the conditions. Since the answer can be very large, print its remainder when divided by 10^9+7.
Example
Input
2
2 2
100000 20
Output
4
226732710
Note
In the first example, the 4 arrays are:
* [3,0],
* [0,3],
* [1,2],
* [2,1]. | instruction | 0 | 74,424 | 12 | 148,848 |
Tags: bitmasks, combinatorics, math
Correct Solution:
```
t = int(input())
MOD = 10 ** 9 + 7
for _ in range(t):
n, k = map(int, input().split())
print(pow(n,k,MOD))
``` | output | 1 | 74,424 | 12 | 148,849 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Baby Badawy's first words were "AND 0 SUM BIG", so he decided to solve the following problem. Given two integers n and k, count the number of arrays of length n such that:
* all its elements are integers between 0 and 2^k-1 (inclusive);
* the [bitwise AND](https://en.wikipedia.org/wiki/Bitwise_operation#AND) of all its elements is 0;
* the sum of its elements is as large as possible.
Since the answer can be very large, print its remainder when divided by 10^9+7.
Input
The first line contains an integer t (1 ≤ t ≤ 10) — the number of test cases you need to solve.
Each test case consists of a line containing two integers n and k (1 ≤ n ≤ 10^{5}, 1 ≤ k ≤ 20).
Output
For each test case, print the number of arrays satisfying the conditions. Since the answer can be very large, print its remainder when divided by 10^9+7.
Example
Input
2
2 2
100000 20
Output
4
226732710
Note
In the first example, the 4 arrays are:
* [3,0],
* [0,3],
* [1,2],
* [2,1]. | instruction | 0 | 74,425 | 12 | 148,850 |
Tags: bitmasks, combinatorics, math
Correct Solution:
```
from sys import stdin
input = stdin.readline
from heapq import heapify,heappush,heappop,heappushpop
from collections import defaultdict as dd, deque as dq,Counter as C
from math import factorial as f ,ceil,gcd,sqrt,log
from bisect import bisect_left as bl ,bisect_right as br
from itertools import combinations as c,permutations as p
from math import factorial as f ,ceil,gcd,sqrt,log
mi = lambda : map(int,input().split())
ii = lambda: int(input())
li = lambda : list(map(int,input().split()))
mati = lambda r : [ li() for _ in range(r)]
lcm = lambda a,b : (a*b)//gcd(a,b)
def solve():
MOD=10**9+7
n,k=mi()
ans=1
while(k):
if k%2==1:
ans*=n
n=(n**2)%MOD
k//=2
print(ans%MOD)
for _ in range(ii()):
solve()
``` | output | 1 | 74,425 | 12 | 148,851 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a_1, a_2, ..., a_n consisting of n distinct integers. Count the number of pairs of indices (i, j) such that i < j and a_i ⋅ a_j = i + j.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t cases follow.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^5) — the length of array a.
The second line of each test case contains n space separated integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 2 ⋅ n) — the array a. It is guaranteed that all elements are distinct.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output the number of pairs of indices (i, j) such that i < j and a_i ⋅ a_j = i + j.
Example
Input
3
2
3 1
3
6 1 5
5
3 1 5 9 2
Output
1
1
3
Note
For the first test case, the only pair that satisfies the constraints is (1, 2), as a_1 ⋅ a_2 = 1 + 2 = 3
For the second test case, the only pair that satisfies the constraints is (2, 3).
For the third test case, the pairs that satisfy the constraints are (1, 2), (1, 5), and (2, 3). | instruction | 0 | 74,434 | 12 | 148,868 |
Tags: brute force, implementation, math, number theory
Correct Solution:
```
t=int(input())
for _ in range(t):
n=int(input())
temp=0
x=list(map(int,input().split()))
for i in range(n):
for j in range(x[i]-i-2,n,x[i]):
if(i<j and (x[i]*x[j])==i+j+2):
temp+=1
print(temp)
``` | output | 1 | 74,434 | 12 | 148,869 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a_1, a_2, ..., a_n consisting of n distinct integers. Count the number of pairs of indices (i, j) such that i < j and a_i ⋅ a_j = i + j.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t cases follow.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^5) — the length of array a.
The second line of each test case contains n space separated integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 2 ⋅ n) — the array a. It is guaranteed that all elements are distinct.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output the number of pairs of indices (i, j) such that i < j and a_i ⋅ a_j = i + j.
Example
Input
3
2
3 1
3
6 1 5
5
3 1 5 9 2
Output
1
1
3
Note
For the first test case, the only pair that satisfies the constraints is (1, 2), as a_1 ⋅ a_2 = 1 + 2 = 3
For the second test case, the only pair that satisfies the constraints is (2, 3).
For the third test case, the pairs that satisfy the constraints are (1, 2), (1, 5), and (2, 3). | instruction | 0 | 74,435 | 12 | 148,870 |
Tags: brute force, implementation, math, number theory
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
'''n,k = map(int,input().split())'''
l = list(map(int,input().split()))
dp = [-1]*(2*n + 1)
for i in range(n):
dp[l[i]] = i+1
ans = 0
for i in range(n):
for j in range(1,(2*n - 1)//l[i]+1):
if i+1+dp[j] == l[i]*j and i+1!=dp[j] and dp[j]!=-1:
ans+=1
print(ans//2)
``` | output | 1 | 74,435 | 12 | 148,871 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a_1, a_2, ..., a_n consisting of n distinct integers. Count the number of pairs of indices (i, j) such that i < j and a_i ⋅ a_j = i + j.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t cases follow.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^5) — the length of array a.
The second line of each test case contains n space separated integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 2 ⋅ n) — the array a. It is guaranteed that all elements are distinct.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output the number of pairs of indices (i, j) such that i < j and a_i ⋅ a_j = i + j.
Example
Input
3
2
3 1
3
6 1 5
5
3 1 5 9 2
Output
1
1
3
Note
For the first test case, the only pair that satisfies the constraints is (1, 2), as a_1 ⋅ a_2 = 1 + 2 = 3
For the second test case, the only pair that satisfies the constraints is (2, 3).
For the third test case, the pairs that satisfy the constraints are (1, 2), (1, 5), and (2, 3). | instruction | 0 | 74,436 | 12 | 148,872 |
Tags: brute force, implementation, math, number theory
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
a = list(map(int,input().strip().split()))
c=0
for i in range(n-1):
for j in range(a[i]-i-2,n,a[i]):
if a[j]*a[i]==i+j+2 and j>i:
c+=1
print(c)
``` | output | 1 | 74,436 | 12 | 148,873 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a_1, a_2, ..., a_n consisting of n distinct integers. Count the number of pairs of indices (i, j) such that i < j and a_i ⋅ a_j = i + j.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t cases follow.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^5) — the length of array a.
The second line of each test case contains n space separated integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 2 ⋅ n) — the array a. It is guaranteed that all elements are distinct.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output the number of pairs of indices (i, j) such that i < j and a_i ⋅ a_j = i + j.
Example
Input
3
2
3 1
3
6 1 5
5
3 1 5 9 2
Output
1
1
3
Note
For the first test case, the only pair that satisfies the constraints is (1, 2), as a_1 ⋅ a_2 = 1 + 2 = 3
For the second test case, the only pair that satisfies the constraints is (2, 3).
For the third test case, the pairs that satisfy the constraints are (1, 2), (1, 5), and (2, 3). | instruction | 0 | 74,437 | 12 | 148,874 |
Tags: brute force, implementation, math, number theory
Correct Solution:
```
n = int(input())
for m in range(n):
x = int(input())
l = list(map(int, input().split()))
k = 0
for i in range(1, x):
b = -i%l[i-1]
for j in range (b, x + 1, l[i-1]):
if (l[i-1]*l[j-1]==i+j and j > i):
k = k+1
print(k)
``` | output | 1 | 74,437 | 12 | 148,875 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a_1, a_2, ..., a_n consisting of n distinct integers. Count the number of pairs of indices (i, j) such that i < j and a_i ⋅ a_j = i + j.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t cases follow.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^5) — the length of array a.
The second line of each test case contains n space separated integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 2 ⋅ n) — the array a. It is guaranteed that all elements are distinct.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output the number of pairs of indices (i, j) such that i < j and a_i ⋅ a_j = i + j.
Example
Input
3
2
3 1
3
6 1 5
5
3 1 5 9 2
Output
1
1
3
Note
For the first test case, the only pair that satisfies the constraints is (1, 2), as a_1 ⋅ a_2 = 1 + 2 = 3
For the second test case, the only pair that satisfies the constraints is (2, 3).
For the third test case, the pairs that satisfy the constraints are (1, 2), (1, 5), and (2, 3). | instruction | 0 | 74,438 | 12 | 148,876 |
Tags: brute force, implementation, math, number theory
Correct Solution:
```
def getPairs(arr, n):
ans = 0
for i in range(1, n + 1):
temp = arr[i] - i
while temp <= n:
if temp <= i:
temp += arr[i]
continue
if arr[i] * arr[temp] == i + temp:
ans += 1
temp += arr[i]
return ans
if __name__ == '__main__':
N = int(input())
for i in range(N):
n = int(input())
arr = [0] + list(map(int, input().rstrip().split()))
# a = list(map(int, input().split()))
print(getPairs(arr, n))
``` | output | 1 | 74,438 | 12 | 148,877 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a_1, a_2, ..., a_n consisting of n distinct integers. Count the number of pairs of indices (i, j) such that i < j and a_i ⋅ a_j = i + j.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t cases follow.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^5) — the length of array a.
The second line of each test case contains n space separated integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 2 ⋅ n) — the array a. It is guaranteed that all elements are distinct.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output the number of pairs of indices (i, j) such that i < j and a_i ⋅ a_j = i + j.
Example
Input
3
2
3 1
3
6 1 5
5
3 1 5 9 2
Output
1
1
3
Note
For the first test case, the only pair that satisfies the constraints is (1, 2), as a_1 ⋅ a_2 = 1 + 2 = 3
For the second test case, the only pair that satisfies the constraints is (2, 3).
For the third test case, the pairs that satisfy the constraints are (1, 2), (1, 5), and (2, 3). | instruction | 0 | 74,439 | 12 | 148,878 |
Tags: brute force, implementation, math, number theory
Correct Solution:
```
def fast3():
import os, sys, atexit
from io import BytesIO
sys.stdout = BytesIO()
_write = sys.stdout.write
sys.stdout.write = lambda s: _write(s.encode())
atexit.register(lambda: os.write(1, sys.stdout.getvalue()))
return BytesIO(os.read(0, os.fstat(0).st_size)).readline
input = fast3()
for _ in range(int(input())):
n, a = int(input()), [int(x) for x in input().split()]
ans, mem = 0, [0] * (2 * n + 1)
for i in range(n):
mem[a[i]] = i + 1
for i in range(n):
cur = 1
while a[i] * cur <= n * 2:
ans += (cur != a[i] and mem[cur] and cur * a[i] == mem[cur] + mem[a[i]])
cur += 1
print(ans >> 1)
``` | output | 1 | 74,439 | 12 | 148,879 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a_1, a_2, ..., a_n consisting of n distinct integers. Count the number of pairs of indices (i, j) such that i < j and a_i ⋅ a_j = i + j.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t cases follow.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^5) — the length of array a.
The second line of each test case contains n space separated integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 2 ⋅ n) — the array a. It is guaranteed that all elements are distinct.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output the number of pairs of indices (i, j) such that i < j and a_i ⋅ a_j = i + j.
Example
Input
3
2
3 1
3
6 1 5
5
3 1 5 9 2
Output
1
1
3
Note
For the first test case, the only pair that satisfies the constraints is (1, 2), as a_1 ⋅ a_2 = 1 + 2 = 3
For the second test case, the only pair that satisfies the constraints is (2, 3).
For the third test case, the pairs that satisfy the constraints are (1, 2), (1, 5), and (2, 3). | instruction | 0 | 74,440 | 12 | 148,880 |
Tags: brute force, implementation, math, number theory
Correct Solution:
```
def func():
count = 0
# print(a)
for i in range(1, n+1):
for j in range(a[i]-i, n+1, a[i]):
if j < 0:
continue
if i + j == a[i] * a[j] and i < j:
count += 1
print(count)
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
a.insert(0, -10**7)
func()
``` | output | 1 | 74,440 | 12 | 148,881 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a_1, a_2, ..., a_n consisting of n distinct integers. Count the number of pairs of indices (i, j) such that i < j and a_i ⋅ a_j = i + j.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t cases follow.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^5) — the length of array a.
The second line of each test case contains n space separated integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 2 ⋅ n) — the array a. It is guaranteed that all elements are distinct.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output the number of pairs of indices (i, j) such that i < j and a_i ⋅ a_j = i + j.
Example
Input
3
2
3 1
3
6 1 5
5
3 1 5 9 2
Output
1
1
3
Note
For the first test case, the only pair that satisfies the constraints is (1, 2), as a_1 ⋅ a_2 = 1 + 2 = 3
For the second test case, the only pair that satisfies the constraints is (2, 3).
For the third test case, the pairs that satisfy the constraints are (1, 2), (1, 5), and (2, 3). | instruction | 0 | 74,441 | 12 | 148,882 |
Tags: brute force, implementation, math, number theory
Correct Solution:
```
from sys import path_hooks, stdin, stdout
from collections import Counter,deque
import math
from copy import deepcopy
import random
import heapq
from itertools import permutations, product, repeat
from time import time
from bisect import bisect_left
from bisect import bisect_right
from re import A, findall
from fractions import Fraction
from typing import DefaultDict
def mapinput():
return map(int, stdin.readline().split())
def strinput():
return stdin.readline().strip()
def listinput():
return list(map(int,stdin.readline().split()))
def intinput():
return int(stdin.readline().strip())
# int(stdin.readline().strip())
# stdin.readline().strip()
# list(map(int,stdin.readline().split()))
# map(int,stdin.readline().split())
'''
n = int(stdin.readline())
s = stdin.readline().strip()
n, k = map(int, stdin.readline().split())
arn = list(map(int, stdin.readline().split()))
'''
def gcd(a,b):
if(b==0):
return a
else:
return gcd(b,a%b)
def SieveOfEratosthenes(n):
prime = [True for i in range(n + 1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * 2, n + 1, p):
prime[i] = False
p += 1
prime[0]= False
prime[1]= False
ans = []
for p in range(n + 1):
if prime[p]:
ans.append(p)
return ans
# t = time()
# primes = SieveOfEratosthenes(5000002)
# spprime = set([2,3,5,7])
# for i in primes:
# if i//10 in spprime:
# spprime.add(i)
# spprime = list(spprime)
# spprime.sort()
#print(time() - t)
spprime = [2, 3, 5, 7, 23, 29, 31, 37, 53, 59, 71, 73, 79, 233, 239, 293, 311, 313, 317, 373, 379, 593, 599, 719, 733, 739, 797, 2333, 2339, 2393, 2399, 2939, 3119, 3137, 3733, 3739, 3793, 3797, 5939, 7193, 7331, 7333, 7393, 23333, 23339, 23399, 23993, 29399, 31193, 31379, 37337, 37339, 37397, 59393, 59399, 71933, 73331, 73939, 233993, 239933, 293999, 373379, 373393, 593933, 593993, 719333, 739391, 739393, 739397, 739399, 2339933, 2399333, 2939999, 3733799]
spprimeset = set(spprime)
coprime1 = {6: 100003, 5: 10007, 4: 1009, 3: 101, 2: 11, 1: 2, 7: 1000003, 8: 10000019, 9: 100000007}
coprime2 = {8:10000169,9:100000049,7:1000033,6:100019,5:10009,4:1013,3:103,2:13,1:3}
def writ(ss):
stdout.write(str(ss) + "\n")
mod = (10 **9) + 7
def binaryr(arr,point,target):
low = 0
high = point
while low <= high:
mid = (low+high)//2
if arr[mid] == target:
return mid
elif arr[mid] < target:
low = mid + 1
else:
high = mid - 1
return low
def binaryl(arr,point,target):
low = 0
high = point
while low <= high:
mid = (low+high)//2
if arr[mid] == target:
return mid
elif arr[mid] < target:
low = mid + 1
else:
high = mid - 1
return high
def sump(n):
return (n * (n+1)) // 2
#print(spprime)
for test in range(intinput()):
def solve():
n = intinput()
arr =listinput()
d = {}
for i in range(n):
d[arr[i]] = i + 1
arr.sort()
ans = 0
for i in range(n):
e = arr[i]
for j in range(i+1, n):
if e * arr[j] == d[e] + d[arr[j]]:
ans += 1
if e * arr[j] > 2 * n:
break
print(ans)
solve()
``` | output | 1 | 74,441 | 12 | 148,883 |
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_1, a_2, ..., a_n consisting of n distinct integers. Count the number of pairs of indices (i, j) such that i < j and a_i ⋅ a_j = i + j.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t cases follow.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^5) — the length of array a.
The second line of each test case contains n space separated integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 2 ⋅ n) — the array a. It is guaranteed that all elements are distinct.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output the number of pairs of indices (i, j) such that i < j and a_i ⋅ a_j = i + j.
Example
Input
3
2
3 1
3
6 1 5
5
3 1 5 9 2
Output
1
1
3
Note
For the first test case, the only pair that satisfies the constraints is (1, 2), as a_1 ⋅ a_2 = 1 + 2 = 3
For the second test case, the only pair that satisfies the constraints is (2, 3).
For the third test case, the pairs that satisfy the constraints are (1, 2), (1, 5), and (2, 3).
Submitted Solution:
```
import sys
input = sys.stdin.readline
tt = int(input())
for mmm in range(tt):
ans = 0
n = int(input())
n = 2*n - 1
nums = list(map(int, input().split()))
nums = [[nums[i], i+1] for i in range(len(nums))]
nums.sort(key= lambda x: x[0])
for i in range(len(nums)):
for j in range(i+1, len(nums)):
val = nums[i][0]*nums[j][0]
if val > n:
break
#print(val, nums[i][1] + nums[j][1])
if val == nums[i][1] + nums[j][1]:
ans += 1
print(ans)
'''
3
2
3 1
3
6 1 5
5
3 1 5 9 2
'''
``` | instruction | 0 | 74,445 | 12 | 148,890 |
Yes | output | 1 | 74,445 | 12 | 148,891 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Find an n × n matrix with different numbers from 1 to n2, so the sum in each row, column and both main diagonals are odd.
Input
The only line contains odd integer n (1 ≤ n ≤ 49).
Output
Print n lines with n integers. All the integers should be different and from 1 to n2. The sum in each row, column and both main diagonals should be odd.
Examples
Input
1
Output
1
Input
3
Output
2 1 4
3 5 7
6 9 8 | instruction | 0 | 74,626 | 12 | 149,252 |
Tags: constructive algorithms, math
Correct Solution:
```
from math import *
n = int(input())
nn = 1
nc = 2
a = []
for i in range(n):
a.append([0] * n)
for q in range(n):
#print(i, q, (n - 1) // 2 - i + (n - 1) // 2 - q)
if abs((n - 1) // 2 - i) + abs((n - 1) // 2 - q) <= (n - 1) // 2:
a[i][q] = nn
nn += 2
else:
a[i][q] = nc
nc += 2
for i in range(n):
print(*a[i])
``` | output | 1 | 74,626 | 12 | 149,253 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Find an n × n matrix with different numbers from 1 to n2, so the sum in each row, column and both main diagonals are odd.
Input
The only line contains odd integer n (1 ≤ n ≤ 49).
Output
Print n lines with n integers. All the integers should be different and from 1 to n2. The sum in each row, column and both main diagonals should be odd.
Examples
Input
1
Output
1
Input
3
Output
2 1 4
3 5 7
6 9 8 | instruction | 0 | 74,627 | 12 | 149,254 |
Tags: constructive algorithms, math
Correct Solution:
```
n = int(input())
it = n//2
n1,n2 = 1,2
for i in range(n):
for j in range(n):
if j >= it and j <= n-it-1:
print(n1,end = ' ')
n1+=2;
else:
print(n2, end = ' ')
n2+=2
if i < n/2-1:
it-=1
else:
it+=1
print()
"""
for i in A:
for j in i:
print(j,end = ' ')
print()
"""
``` | output | 1 | 74,627 | 12 | 149,255 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Find an n × n matrix with different numbers from 1 to n2, so the sum in each row, column and both main diagonals are odd.
Input
The only line contains odd integer n (1 ≤ n ≤ 49).
Output
Print n lines with n integers. All the integers should be different and from 1 to n2. The sum in each row, column and both main diagonals should be odd.
Examples
Input
1
Output
1
Input
3
Output
2 1 4
3 5 7
6 9 8 | instruction | 0 | 74,628 | 12 | 149,256 |
Tags: constructive algorithms, math
Correct Solution:
```
n=int(input())
a=[i for i in range(1,n*n+1)]
even=[]
odd=[]
for x in a:
if x%2==0:
even.append(x)
else:
odd.append(x)
c=1
for i in range(n):
si=(n-c)//2
ei=si+c-1
for j in range(n):
if j>=si and j<=ei:
print(odd[0],end=" ")
odd.pop(0)
else:
print(even[0],end=" ")
even.pop(0)
print()
if i>=n//2:
c-=2
else:
c+=2
"""
e e o e e
e o o o e
o o o o o
e o o o e
e e o e e
"""
``` | output | 1 | 74,628 | 12 | 149,257 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Find an n × n matrix with different numbers from 1 to n2, so the sum in each row, column and both main diagonals are odd.
Input
The only line contains odd integer n (1 ≤ n ≤ 49).
Output
Print n lines with n integers. All the integers should be different and from 1 to n2. The sum in each row, column and both main diagonals should be odd.
Examples
Input
1
Output
1
Input
3
Output
2 1 4
3 5 7
6 9 8 | instruction | 0 | 74,630 | 12 | 149,260 |
Tags: constructive algorithms, math
Correct Solution:
```
n = int(input())
mat = [["-1"]*n for a in range(n)]
mat[0][n//2]="1"
pos = [0, n//2]
for num in range(2, n**2+1):
if pos[0]-1<0 and pos[1]+1>=n:
pos[0]+=1
elif pos[0]-1<0:
pos[0]=n-1
pos[1]+=1
elif pos[1]+1>=n:
pos[0]-=1
pos[1]=0
else:
pos[0]-=1
pos[1]+=1
if mat[pos[0]][pos[1]]!="-1":
pos[0]+=2
pos[1]-=1
if mat[pos[0]][pos[1]]=="-1":
mat[pos[0]][pos[1]] = str(num)
for a in range(n):
print(" ".join(mat[a]))
``` | output | 1 | 74,630 | 12 | 149,261 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Find an n × n matrix with different numbers from 1 to n2, so the sum in each row, column and both main diagonals are odd.
Input
The only line contains odd integer n (1 ≤ n ≤ 49).
Output
Print n lines with n integers. All the integers should be different and from 1 to n2. The sum in each row, column and both main diagonals should be odd.
Examples
Input
1
Output
1
Input
3
Output
2 1 4
3 5 7
6 9 8 | instruction | 0 | 74,632 | 12 | 149,264 |
Tags: constructive algorithms, math
Correct Solution:
```
n=int(input())
magic=int((n-1)/2)
x = []
for t in range(magic, -1, -1):
x.append(t*'*'+'D'*(n-2*t)+t*'*')
for u in range(1, magic+1):
x.append(u*'*'+'D'*(n-2*u)+u*'*')
no = 1
ne = 2
for i in range(n):
for j in range(n):
if (x[i][j] == 'D'):
print(no, end = ' ')
no += 2
else:
print(ne, end = ' ')
ne += 2
print()
``` | output | 1 | 74,632 | 12 | 149,265 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Find an n × n matrix with different numbers from 1 to n2, so the sum in each row, column and both main diagonals are odd.
Input
The only line contains odd integer n (1 ≤ n ≤ 49).
Output
Print n lines with n integers. All the integers should be different and from 1 to n2. The sum in each row, column and both main diagonals should be odd.
Examples
Input
1
Output
1
Input
3
Output
2 1 4
3 5 7
6 9 8 | instruction | 0 | 74,633 | 12 | 149,266 |
Tags: constructive algorithms, math
Correct Solution:
```
n = int( input() )
h = (n-1)//2
A = [[ 0 for c in range(n)] for r in range(n) ]
for r in range(n):
for c in range(n):
A[ (r+c-h)%n ][ (r-c+h)%n ] = r*n+c+1
for r in range(n):
print(' '.join( '{:d}'.format(x) for x in A[r] ))
``` | output | 1 | 74,633 | 12 | 149,267 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of n integers a1... an. The cost of a subsegment is the number of unordered pairs of distinct indices within the subsegment that contain equal elements. Split the given array into k non-intersecting non-empty subsegments so that the sum of their costs is minimum possible. Each element should be present in exactly one subsegment.
Input
The first line contains two integers n and k (2 ≤ n ≤ 105, 2 ≤ k ≤ min (n, 20)) — the length of the array and the number of segments you need to split the array into.
The next line contains n integers a1, a2, ..., an (1 ≤ ai ≤ n) — the elements of the array.
Output
Print single integer: the minimum possible total cost of resulting subsegments.
Examples
Input
7 3
1 1 3 3 3 2 1
Output
1
Input
10 2
1 2 1 2 1 2 1 2 1 2
Output
8
Input
13 3
1 2 2 2 1 2 1 1 1 2 2 1 1
Output
9
Note
In the first example it's optimal to split the sequence into the following three subsegments: [1], [1, 3], [3, 3, 2, 1]. The costs are 0, 0 and 1, thus the answer is 1.
In the second example it's optimal to split the sequence in two equal halves. The cost for each half is 4.
In the third example it's optimal to split the sequence in the following way: [1, 2, 2, 2, 1], [2, 1, 1, 1, 2], [2, 1, 1]. The costs are 4, 4, 1. | instruction | 0 | 74,702 | 12 | 149,404 |
Tags: divide and conquer, dp
Correct Solution:
```
import sys
input = sys.stdin.readline
n, m = map(int, input().split())
a = [0]+list(map(int, input().split()))
buc = [0]*(n+1)
dp_p = [n*(n-1)//2]*(n+1)
dp_c = [0]*(n+1)
dp_p[0] = 0
buc[a[1]] = 1
L = R = 1
ans = 0
def cal(l, r):
global L, R, ans
while L < l:
ans += 1-buc[a[L]]
buc[a[L]] -= 1
L += 1
while L > l:
L -= 1
ans += buc[a[L]]
buc[a[L]] += 1
while R < r:
R += 1
ans += buc[a[R]]
buc[a[R]] += 1
while R > r:
ans += 1-buc[a[R]]
buc[a[R]] -= 1
R -= 1
def solve(lb, rb, l, r):
global ans, L
if lb > rb or l > r:
return
mid = (l+r)//2
d = 0
res = 9223372036854775807
cal(lb, mid)
for i in range(lb, rb+1):
ans += 1-buc[a[L]]
buc[a[L]] -= 1
L += 1
if res > dp_p[i]+ans:
res = dp_p[i]+ans
d = i
dp_c[mid] = res
solve(lb, d, l, mid-1)
solve(d, rb, mid+1, r)
for cur in range(1, m+1):
solve(0, n-1, 1, n)
dp_p, dp_c = dp_c, dp_p
print(dp_p[n])
``` | output | 1 | 74,702 | 12 | 149,405 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of n integers a1... an. The cost of a subsegment is the number of unordered pairs of distinct indices within the subsegment that contain equal elements. Split the given array into k non-intersecting non-empty subsegments so that the sum of their costs is minimum possible. Each element should be present in exactly one subsegment.
Input
The first line contains two integers n and k (2 ≤ n ≤ 105, 2 ≤ k ≤ min (n, 20)) — the length of the array and the number of segments you need to split the array into.
The next line contains n integers a1, a2, ..., an (1 ≤ ai ≤ n) — the elements of the array.
Output
Print single integer: the minimum possible total cost of resulting subsegments.
Examples
Input
7 3
1 1 3 3 3 2 1
Output
1
Input
10 2
1 2 1 2 1 2 1 2 1 2
Output
8
Input
13 3
1 2 2 2 1 2 1 1 1 2 2 1 1
Output
9
Note
In the first example it's optimal to split the sequence into the following three subsegments: [1], [1, 3], [3, 3, 2, 1]. The costs are 0, 0 and 1, thus the answer is 1.
In the second example it's optimal to split the sequence in two equal halves. The cost for each half is 4.
In the third example it's optimal to split the sequence in the following way: [1, 2, 2, 2, 1], [2, 1, 1, 1, 2], [2, 1, 1]. The costs are 4, 4, 1.
Submitted Solution:
```
from sys import stdin, stdout
import copy
def sectionScore(countDict):
score = 0
for i in countDict.keys():
score+=countDict[i]*(countDict[i]-1)//2
return score
n,k = map(int,stdin.readline().rstrip().split())
a = list(map(int,stdin.readline().rstrip().split()))
nList = []
nCount = []
for i in range(k):
nList.append([a[i]])
nCount.append({})
nCount[i][a[i]]=1
for i in range(k,n):
nList[k-1].append(a[i])
if a[i] not in nCount[k-1]:
nCount[k-1][a[i]]=0
nCount[k-1][a[i]]+=1
moved=True
sec = k-1
while moved and sec>0:
moved=False
currentScore = 0
bestScore=0
bestMove = 0
tCount1 = copy.copy(nCount[sec])
tCount2 = copy.copy(nCount[sec-1])
for j in range(len(nList[sec])-1):
x = nList[sec][j]
currentScore-=(tCount1[x]-1)
if x not in tCount2:
tCount2[x]=0
currentScore+=tCount2[x]
tCount1[x]-=1
tCount2[x]+=1
if currentScore<=bestScore:
bestMove = j+1
bestScore = currentScore
moved=True
for j in range(bestMove):
x = nList[sec].pop(0)
nCount[sec][x]-=1
if x not in nCount[sec-1]:
nCount[sec-1][x]=0
nCount[sec-1][x]+=1
nList[sec-1].append(x)
sec-=1
totalScore=0
for i in range(k):
totalScore+=sectionScore(nCount[i])
print(totalScore)
``` | instruction | 0 | 74,703 | 12 | 149,406 |
No | output | 1 | 74,703 | 12 | 149,407 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of n integers a1... an. The cost of a subsegment is the number of unordered pairs of distinct indices within the subsegment that contain equal elements. Split the given array into k non-intersecting non-empty subsegments so that the sum of their costs is minimum possible. Each element should be present in exactly one subsegment.
Input
The first line contains two integers n and k (2 ≤ n ≤ 105, 2 ≤ k ≤ min (n, 20)) — the length of the array and the number of segments you need to split the array into.
The next line contains n integers a1, a2, ..., an (1 ≤ ai ≤ n) — the elements of the array.
Output
Print single integer: the minimum possible total cost of resulting subsegments.
Examples
Input
7 3
1 1 3 3 3 2 1
Output
1
Input
10 2
1 2 1 2 1 2 1 2 1 2
Output
8
Input
13 3
1 2 2 2 1 2 1 1 1 2 2 1 1
Output
9
Note
In the first example it's optimal to split the sequence into the following three subsegments: [1], [1, 3], [3, 3, 2, 1]. The costs are 0, 0 and 1, thus the answer is 1.
In the second example it's optimal to split the sequence in two equal halves. The cost for each half is 4.
In the third example it's optimal to split the sequence in the following way: [1, 2, 2, 2, 1], [2, 1, 1, 1, 2], [2, 1, 1]. The costs are 4, 4, 1.
Submitted Solution:
```
import sys
input = sys.stdin.readline
n, m = map(int, input().split())
a = [0]+list(map(int, input().split()))
buc = [0]*(n+1)
dp_p = [0x3f3f3f3f]*(n+1)
dp_c = [0]*(n+1)
dp_p[0] = 0
buc[a[1]] = 1
L = R = 1
ans = 0
def cal(l, r):
global L, R, ans
while L < l:
ans += 1-buc[a[L]]
buc[a[L]] -= 1
L += 1
while L > l:
L -= 1
ans += buc[a[L]]
buc[a[L]] += 1
while R < r:
R += 1
ans += buc[a[R]]
buc[a[R]] += 1
while R > r:
ans += 1-buc[a[R]]
buc[a[R]] -= 1
R -= 1
def solve(lb, rb, l, r):
global ans, L
if lb > rb or l > r:
return
mid = (l+r)//2
d = 0
res = 9223372036854775807
cal(lb, mid)
for i in range(lb, rb+1):
ans += 1-buc[a[L]]
buc[a[L]] -= 1
L += 1
if res > dp_p[i]+ans:
res = dp_p[i]+ans
d = i
dp_c[mid] = res
solve(lb, d, l, mid-1)
solve(d, rb, mid+1, r)
for cur in range(1, m+1):
solve(0, n-1, 1, n)
dp_p, dp_c = dp_c, dp_p
print(dp_p[n])
``` | instruction | 0 | 74,704 | 12 | 149,408 |
No | output | 1 | 74,704 | 12 | 149,409 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of n integers a1... an. The cost of a subsegment is the number of unordered pairs of distinct indices within the subsegment that contain equal elements. Split the given array into k non-intersecting non-empty subsegments so that the sum of their costs is minimum possible. Each element should be present in exactly one subsegment.
Input
The first line contains two integers n and k (2 ≤ n ≤ 105, 2 ≤ k ≤ min (n, 20)) — the length of the array and the number of segments you need to split the array into.
The next line contains n integers a1, a2, ..., an (1 ≤ ai ≤ n) — the elements of the array.
Output
Print single integer: the minimum possible total cost of resulting subsegments.
Examples
Input
7 3
1 1 3 3 3 2 1
Output
1
Input
10 2
1 2 1 2 1 2 1 2 1 2
Output
8
Input
13 3
1 2 2 2 1 2 1 1 1 2 2 1 1
Output
9
Note
In the first example it's optimal to split the sequence into the following three subsegments: [1], [1, 3], [3, 3, 2, 1]. The costs are 0, 0 and 1, thus the answer is 1.
In the second example it's optimal to split the sequence in two equal halves. The cost for each half is 4.
In the third example it's optimal to split the sequence in the following way: [1, 2, 2, 2, 1], [2, 1, 1, 1, 2], [2, 1, 1]. The costs are 4, 4, 1.
Submitted Solution:
```
import sys
input = sys.stdin.readline
n, m = map(int, input().split())
a = [0]+list(map(int, input().split()))
buc = [0]*(n+1)
dp_p = [0x3f3f3f3f]*(n+1)
dp_c = [0]*(n+1)
dp_p[0] = 0
buc[a[1]] = 1
L = R = 1
ans = 0
if n >= 100000:
exit(0)
def cal(l, r):
global L, R, ans
while L < l:
ans += 1-buc[a[L]]
buc[a[L]] -= 1
L += 1
while L > l:
L -= 1
ans += buc[a[L]]
buc[a[L]] += 1
while R < r:
R += 1
ans += buc[a[R]]
buc[a[R]] += 1
while R > r:
ans += 1-buc[a[R]]
buc[a[R]] -= 1
R -= 1
def solve(lb, rb, l, r):
if lb > rb or l > r:
return
mid = (l+r)//2
d = 0
res = 9223372036854775807
for i in range(lb, rb+1):
cal(i+1, mid)
if res > dp_p[i]+ans:
res = dp_p[i]+ans
d = i
dp_c[mid] = res
solve(lb, d, l, mid-1)
solve(d, rb, mid+1, r)
for cur in range(1, m+1):
solve(0, n-1, 1, n)
dp_p, dp_c = dp_c, dp_p
print(dp_p[n])
``` | instruction | 0 | 74,705 | 12 | 149,410 |
No | output | 1 | 74,705 | 12 | 149,411 |
Provide a correct Python 3 solution for this coding contest problem.
Your task is to implement a double linked list.
Write a program which performs the following operations:
* insert x: insert an element with key x into the front of the list.
* delete x: delete the first element which has the key of x from the list. If there is not such element, you need not do anything.
* deleteFirst: delete the first element from the list.
* deleteLast: delete the last element from the list.
Notes
Template in C -->
Constraints
* The number of operations ≤ 2,000,000
* The number of delete operations ≤ 20
* 0 ≤ value of a key ≤ 109
* The number of elements in the list does not exceed 106
* For a delete, deleteFirst or deleteLast operation, there is at least one element in the list.
Input
The input is given in the following format:
n
command1
command2
...
commandn
In the first line, the number of operations n is given. In the following n lines, the above mentioned operations are given in the following format:
* insert x
* delete x
* deleteFirst
* deleteLast
Output
Print all the element (key) in the list after the given operations. Two consequtive keys should be separated by a single space.
Examples
Input
7
insert 5
insert 2
insert 3
insert 1
delete 3
insert 6
delete 5
Output
6 1 2
Input
9
insert 5
insert 2
insert 3
insert 1
delete 3
insert 6
delete 5
deleteFirst
deleteLast
Output
1 | instruction | 0 | 74,940 | 12 | 149,880 |
"Correct Solution:
```
from collections import deque
queue=deque()
n=int(input())
for _ in range(n):
command=input().split()
if command[0]=="insert":
queue.appendleft(command[1])
if command[0]=="delete":
try:
queue.remove(command[1])
except:
pass
if command[0]=="deleteFirst":
queue.popleft()
if command[0]=="deleteLast":
queue.pop()
print(*queue)
``` | output | 1 | 74,940 | 12 | 149,881 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of n integers 1, 2, ..., n (a permutation is an array where each element from 1 to n occurs exactly once).
Let's call some subsegment p[l, r] of this permutation special if p_l + p_r = max _{i = l}^{r} p_i. Please calculate the number of special subsegments.
Input
The first line contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5).
The second line contains n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). All these integers are pairwise distinct.
Output
Print the number of special subsegments of the given permutation.
Examples
Input
5
3 4 1 5 2
Output
2
Input
3
1 3 2
Output
1
Note
Special subsegments in the first example are [1, 5] and [1, 3].
The only special subsegment in the second example is [1, 3]. | instruction | 0 | 75,047 | 12 | 150,094 |
Tags: data structures, divide and conquer, dsu, two pointers
Correct Solution:
```
mod = 1000000007
eps = 10**-9
def main():
import sys
input = sys.stdin.readline
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
def lower_bound(self, w):
if w <= 0:
return 0
x = 0
k = 1 << (self.size.bit_length() - 1)
while k:
if x + k <= self.size and self.tree[x + k] < w:
w -= self.tree[x + k]
x += k
k >>= 1
return x + 1
N = int(input())
P = list(map(int, input().split()))
idx = [0] * (N+1)
for i, p in enumerate(P):
idx[p] = i+1
bit = Bit(N)
ans = 0
for p in range(N, 0, -1):
i = idx[p]
k = bit.sum(i)
r = bit.lower_bound(k+1)
l = bit.lower_bound(k)
nl = i - l - 1
nr = r - i - 1
if nl < nr:
for j in range(l+1, i):
q = P[j-1]
if i < idx[p - q] < r:
ans += 1
else:
for j in range(i+1, r):
q = P[j-1]
if l < idx[p - q] < i:
ans += 1
bit.add(i, 1)
#print(l, r)
print(ans)
if __name__ == '__main__':
main()
``` | output | 1 | 75,047 | 12 | 150,095 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of n integers 1, 2, ..., n (a permutation is an array where each element from 1 to n occurs exactly once).
Let's call some subsegment p[l, r] of this permutation special if p_l + p_r = max _{i = l}^{r} p_i. Please calculate the number of special subsegments.
Input
The first line contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5).
The second line contains n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). All these integers are pairwise distinct.
Output
Print the number of special subsegments of the given permutation.
Examples
Input
5
3 4 1 5 2
Output
2
Input
3
1 3 2
Output
1
Note
Special subsegments in the first example are [1, 5] and [1, 3].
The only special subsegment in the second example is [1, 3]. | instruction | 0 | 75,048 | 12 | 150,096 |
Tags: data structures, divide and conquer, dsu, two pointers
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
if a==[i+1 for i in range(n)]:exit(print(0))
if a==[i+1 for i in range(n)][::-1]:exit(print(0))
p=[0]*(n+1)
p[0]=-1
for i in range(n):p[a[i]]=i
num=2**(n-1).bit_length()
def segfunc(x,y):
if a[x]<a[y]:return y
else:return x
seg=[0]*(2*num-1)
for i in range(n):seg[i+num-1]=i
for i in range(num-2,-1,-1):seg[i]=segfunc(seg[2*i+1],seg[2*i+2])
def update(i,x):
i+=num-1;seg[i]=x
while i:i=(i-1)//2;seg[i]=segfunc(seg[i*2+1],seg[i*2+2])
def query(l,r):
l+=num-1;r+=num-2
if l==r:return seg[l]
s=seg[l];l+=1
while r-l>1:
if ~l%2:s=segfunc(seg[l],s)
if r%2:s=segfunc(seg[r],s);r-=1
l//=2;r=(r-1)//2
if l==r:return segfunc(s,seg[l])
return segfunc(s,segfunc(seg[l],seg[r]))
def f(l,r):
if r-l<2:return 0
maxi=query(l,r+1)
ma=a[maxi]
ans=f(l,maxi-1)+f(maxi+1,r)
if maxi-l<r-maxi:
for i in range(l,maxi):
if maxi<p[ma-a[i]]<=r:ans+=1
else:
for i in range(maxi+1,r+1):
if l<=p[ma-a[i]]<maxi:ans+=1
return ans
print(f(0,n-1))
``` | output | 1 | 75,048 | 12 | 150,097 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of n integers 1, 2, ..., n (a permutation is an array where each element from 1 to n occurs exactly once).
Let's call some subsegment p[l, r] of this permutation special if p_l + p_r = max _{i = l}^{r} p_i. Please calculate the number of special subsegments.
Input
The first line contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5).
The second line contains n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). All these integers are pairwise distinct.
Output
Print the number of special subsegments of the given permutation.
Examples
Input
5
3 4 1 5 2
Output
2
Input
3
1 3 2
Output
1
Note
Special subsegments in the first example are [1, 5] and [1, 3].
The only special subsegment in the second example is [1, 3]. | instruction | 0 | 75,049 | 12 | 150,098 |
Tags: data structures, divide and conquer, dsu, two pointers
Correct Solution:
```
n=int(input())
a=[int(x) for x in input().split()]
def Count_Segment(a,n):
ans=0
upto=[0]*(n+1)
for i in range(1,n-1):
if a[i]>a[i-1] and a[i]>a[i+1]:
curr=a[i]
j=i-1
while j>=0 and a[j]<curr:
upto[a[j]]=curr
j-=1
j=i+1
while j<n and a[j]<curr:
if upto[curr-a[j]]==curr:
ans+=1
j+=1
return ans
print(Count_Segment(a,n))
``` | output | 1 | 75,049 | 12 | 150,099 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of n integers 1, 2, ..., n (a permutation is an array where each element from 1 to n occurs exactly once).
Let's call some subsegment p[l, r] of this permutation special if p_l + p_r = max _{i = l}^{r} p_i. Please calculate the number of special subsegments.
Input
The first line contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5).
The second line contains n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). All these integers are pairwise distinct.
Output
Print the number of special subsegments of the given permutation.
Examples
Input
5
3 4 1 5 2
Output
2
Input
3
1 3 2
Output
1
Note
Special subsegments in the first example are [1, 5] and [1, 3].
The only special subsegment in the second example is [1, 3]. | instruction | 0 | 75,050 | 12 | 150,100 |
Tags: data structures, divide and conquer, dsu, two pointers
Correct Solution:
```
import sys; input = sys.stdin.readline
import heapq as hq
n = int(input())
a = list(map(int, input().split()))
place = [0]*(n+1)
for i in range(n):
place[a[i]] = i
par = [-1]*n
nums = [{} for i in range(n)]
def find(x):
if x == par[x]: return x
par[x] = find(par[x])
return par[x]
def comb(x, y):
x, y = find(x), find(y)
if len(nums[x]) < len(nums[y]):
x, y = y, x
par[y] = x
for num in nums[y]: nums[x][num] = 1
a.sort()
ans = 0
for x in a:
cur = place[x]
par[cur] = cur
nums[cur][x] = 1
if cur-1 >= 0 and cur+1 < n and par[cur-1] != -1 and par[cur+1] != -1:
l, r = find(cur-1), find(cur+1)
l, r = nums[l], nums[r]
r_list = []
for num in sorted(r.keys()): r_list.append(num)
p2 = len(r_list) - 1
for num in sorted(l.keys()):
while p2 >= 0 and num + r_list[p2] > x:
p2 -= 1
ans += p2 >= 0 and num + r_list[p2] == x
if cur-1 >= 0 and par[cur-1] != -1:
comb(cur-1, cur)
if cur+1 < n and par[cur+1] != -1:
comb(cur+1, cur)
print(ans)
``` | output | 1 | 75,050 | 12 | 150,101 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of n integers 1, 2, ..., n (a permutation is an array where each element from 1 to n occurs exactly once).
Let's call some subsegment p[l, r] of this permutation special if p_l + p_r = max _{i = l}^{r} p_i. Please calculate the number of special subsegments.
Input
The first line contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5).
The second line contains n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). All these integers are pairwise distinct.
Output
Print the number of special subsegments of the given permutation.
Examples
Input
5
3 4 1 5 2
Output
2
Input
3
1 3 2
Output
1
Note
Special subsegments in the first example are [1, 5] and [1, 3].
The only special subsegment in the second example is [1, 3]. | instruction | 0 | 75,051 | 12 | 150,102 |
Tags: data structures, divide and conquer, dsu, two pointers
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
p = list(range(n + 1))
s = [set() for i in range(n + 1)]
def find(x):
if p[x] != x:
p[x] = find(p[x])
return p[x]
def union(x, y, cur):
x, y = find(x), find(y)
r = 0
if len(s[x]) < len(s[y]):
x, y = y, x
for k in s[y]:
r += cur - k in s[x]
s[x] |= s[y]
s[x].add(cur)
p[y] = x
return r
print(sum(union(i, i + 1, a[i]) for i in sorted(range(n), key=lambda i: a[i])))
``` | output | 1 | 75,051 | 12 | 150,103 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of n integers 1, 2, ..., n (a permutation is an array where each element from 1 to n occurs exactly once).
Let's call some subsegment p[l, r] of this permutation special if p_l + p_r = max _{i = l}^{r} p_i. Please calculate the number of special subsegments.
Input
The first line contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5).
The second line contains n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). All these integers are pairwise distinct.
Output
Print the number of special subsegments of the given permutation.
Examples
Input
5
3 4 1 5 2
Output
2
Input
3
1 3 2
Output
1
Note
Special subsegments in the first example are [1, 5] and [1, 3].
The only special subsegment in the second example is [1, 3]. | instruction | 0 | 75,052 | 12 | 150,104 |
Tags: data structures, divide and conquer, dsu, two pointers
Correct Solution:
```
n=int(input())
ns=[int(x) for x in input().split()]
# n=200000
# ns=[x+1 for x in range(n)]
"""
st=[[ns[i]]for i in range(n)]
for l in range(1,20):
for i in range(0,n+10,2**l):
if i+2**(l-1)<len(st):
st[i].append(max(st[i][-1],st[i+2**(l-1)][-1]))
def get_sum(l,r):
ans,i=st[l][0],1
while l+2**i<=r and i<len(st[l]):
ans=st[l][i]
i+=1
rr=l+2**(i-1)-1
if rr>=r:
return ans
else:
return max(ans,get_sum(rr+1,r))
"""
# print(time.time()-tm)
# import random as rd
#
# n=10000
# s=set()
# ns=[]
# for i in range(n):
# s.add(i+1)
# for i in range(n):
# x=rd.sample(s,1)
# ns.append(x[0])
# s.remove(x[0])
# print(ns)
# quit()
# ns=[5, 8, 4, 1, 6, 7, 2, 3]
# n=len(ns)
maxx=max(ns)+10
lst=[None]*n
nxt=[None]*n
tmp=[(-1,maxx)]
mp=[False]*n
wh=[None]*(n+1)
for i in range(n):
c=ns[i]
while tmp[-1][1]<=c:
tmp.pop()
lst[i]=tmp[-1][0]
tmp.append((i,c))
tmp=[(n,maxx)]
for i in range(n):
i=n-i-1
c=ns[i]
while tmp[-1][1]<=c:
tmp.pop()
nxt[i]=tmp[-1][0]
tmp.append((i,c))
lm={}
for i in range(n):
lm[(lst[i]+1,nxt[i]-1)]=ns[i]
# print(lm)
for i in range(n):
wh[ns[i]]=i
def check(i,m,lm):
f=ns[m]-ns[i]
f=wh[f]
if lm[0]<=f<=lm[1]:
return True
return False
# print(wh)
ans=0
rec=[(0,n-1)]
def get():
if len(rec)==0:
return False
l,r=rec.pop()
if r-l+1<=2:
return True
global ans
x=lm[(l,r)]
lc=wh[x]
if lc<(l+r)//2:
for i in range(l,lc):
c=ns[i]
c=ns[lc]-c
c=wh[c]
if lc<=c<=r:
ans+=1
else:
for i in range(lc+1,r+1):
c=ns[i]
c=ns[lc]-c
c=wh[c]
if l<=c<=lc:
ans+=1
rec.append((l,lc-1))
rec.append((lc+1,r))
while len(rec)>0:
get()
print(ans)
quit()
get(0,n-1)
print(ans)
quit()
x=n
while x>=1:
lc=wh[x]
mp[lc]=True
l,r=lc-1,lc+1
while l>lst[lc] and (not mp[l]) :
l-=1
while r<nxt[lc] and (not mp[r]):
r+=1
if lc-l<r-lc:
for i in range(l+1,lc):
if check(i,lc,(lc+1,r-1)):
ans+=1
else:
for i in range(lc+1,r):
if check(i,lc,(l+1,lc-1)):
ans+=1
x-=1
print(ans)
#
# # print(lst)
# # print(nxt)
#
# def std(n,ns):
# ans=0
# for i in range(n):
# for j in range(i,n):
# if max(ns[i:j+1])==ns[i]+ns[j]:
# ans+=1
# return ans
# print(ns)
# print(std(n,ns))
#
# if ans==std(n,ns):
# print('True')
# else:
# print('False')
``` | output | 1 | 75,052 | 12 | 150,105 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of n integers 1, 2, ..., n (a permutation is an array where each element from 1 to n occurs exactly once).
Let's call some subsegment p[l, r] of this permutation special if p_l + p_r = max _{i = l}^{r} p_i. Please calculate the number of special subsegments.
Input
The first line contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5).
The second line contains n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). All these integers are pairwise distinct.
Output
Print the number of special subsegments of the given permutation.
Examples
Input
5
3 4 1 5 2
Output
2
Input
3
1 3 2
Output
1
Note
Special subsegments in the first example are [1, 5] and [1, 3].
The only special subsegment in the second example is [1, 3]. | instruction | 0 | 75,053 | 12 | 150,106 |
Tags: data structures, divide and conquer, dsu, two pointers
Correct Solution:
```
from collections import deque
from sys import stdin
def inv(perm):
invp = [None] * len(perm)
for i, p in enumerate(perm):
invp[p] = i
return invp
def main():
n = int(stdin.readline())
p = [int(x) - 1 for x in stdin.readline().split()]
invp = inv(p)
# Build auxiliary arrays
nexL = [None] * n
nexR = [None] * n
q = deque()
for i in range(0, n):
while q and p[q[-1]] <= p[i]:
q.pop()
nexL[i] = -1 if not q else q[-1]
q.append(i)
q.clear()
for i in range(n - 1, -1, -1):
while q and p[q[-1]] <= p[i]:
q.pop()
nexR[i] = n if not q else q[-1]
q.append(i)
# Solve
res = 0
for i in range(0, n):
if i - nexL[i] < nexR[i] - i:
for j in range(nexL[i] + 1, i):
x = p[i] - p[j] - 1
res += int(x >= 0 and i < invp[x] <= nexR[i])
else:
for j in range(i + 1, nexR[i]):
x = p[i] - p[j] - 1
res += int(x >= 0 and nexL[i] <= invp[x] < i)
print(res)
main()
``` | output | 1 | 75,053 | 12 | 150,107 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of n integers 1, 2, ..., n (a permutation is an array where each element from 1 to n occurs exactly once).
Let's call some subsegment p[l, r] of this permutation special if p_l + p_r = max _{i = l}^{r} p_i. Please calculate the number of special subsegments.
Input
The first line contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5).
The second line contains n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). All these integers are pairwise distinct.
Output
Print the number of special subsegments of the given permutation.
Examples
Input
5
3 4 1 5 2
Output
2
Input
3
1 3 2
Output
1
Note
Special subsegments in the first example are [1, 5] and [1, 3].
The only special subsegment in the second example is [1, 3]. | instruction | 0 | 75,054 | 12 | 150,108 |
Tags: data structures, divide and conquer, dsu, two pointers
Correct Solution:
```
def Count_Segment(a,n):
ans=0
upto=[False]*(n+1)
for i in range(1,n-1):
if a[i]>a[i-1] and a[i]>a[i+1]:
curr=a[i]
j=i-1
while j>=0 and a[j]<curr:
upto[a[j]]=curr
j-=1
j=i+1
while j<n and a[j]<curr:
if upto[curr-a[j]]==curr:
ans+=1
j+=1
return ans
n=int(input())
a=list(map(int,input().split( )))
print(Count_Segment(a,n))
``` | output | 1 | 75,054 | 12 | 150,109 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p of n integers 1, 2, ..., n (a permutation is an array where each element from 1 to n occurs exactly once).
Let's call some subsegment p[l, r] of this permutation special if p_l + p_r = max _{i = l}^{r} p_i. Please calculate the number of special subsegments.
Input
The first line contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5).
The second line contains n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). All these integers are pairwise distinct.
Output
Print the number of special subsegments of the given permutation.
Examples
Input
5
3 4 1 5 2
Output
2
Input
3
1 3 2
Output
1
Note
Special subsegments in the first example are [1, 5] and [1, 3].
The only special subsegment in the second example is [1, 3].
Submitted Solution:
```
import io, os
input = io.StringIO(os.read(0, os.fstat(0).st_size).decode()).readline
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
n = ii()
a = li()
p = list(range(n + 1))
s = [set() for i in range(n + 1)]
idx = list(range(n))
idx.sort(key=lambda i: a[i])
def find(x):
if p[x] != x:
p[x] = find(p[x])
return p[x]
def union(x, y, cur):
x, y = find(x), find(y)
assert x != y
r = 0
if len(s[x]) < len(s[y]):
x, y = y, x
for k in s[y]:
r += cur - k in s[x]
s[x] |= s[y]
s[x].add(cur)
p[y] = x
return r
ans = 0
for i in idx:
ans += union(i, i + 1, a[i])
print(ans)
``` | instruction | 0 | 75,055 | 12 | 150,110 |
Yes | output | 1 | 75,055 | 12 | 150,111 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p of n integers 1, 2, ..., n (a permutation is an array where each element from 1 to n occurs exactly once).
Let's call some subsegment p[l, r] of this permutation special if p_l + p_r = max _{i = l}^{r} p_i. Please calculate the number of special subsegments.
Input
The first line contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5).
The second line contains n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). All these integers are pairwise distinct.
Output
Print the number of special subsegments of the given permutation.
Examples
Input
5
3 4 1 5 2
Output
2
Input
3
1 3 2
Output
1
Note
Special subsegments in the first example are [1, 5] and [1, 3].
The only special subsegment in the second example is [1, 3].
Submitted Solution:
```
n = int(input())
a = list(map(int,input().split()))
dc = {a[i]:i for i in range(n)}
stack = []
mxr = [n]*(n+1)
mxl = [-1]*(n+1)
for i,x in enumerate(a):
if i == 0:
stack.append(x)
continue
while stack and stack[-1] < x:
y = stack.pop()
mxr[y] = i
stack.append(x)
stack = []
for i,x in enumerate(a[::-1]):
i = n-1-i
if i == n-1:
stack.append(x)
continue
while stack and stack[-1] < x:
y = stack.pop()
mxl[y] = i
stack.append(x)
ans = 0
for i in range(n,0,-1):
idx = dc[i]
l = mxl[i]
r = mxr[i]
if idx-l-1 > r-idx-1:
for j in range(idx+1,r):
if l < dc[i-a[j]] < idx:
ans += 1
else:
for j in range(idx-1,l,-1):
if idx < dc[i-a[j]] < r:
ans += 1
print(ans)
``` | instruction | 0 | 75,056 | 12 | 150,112 |
Yes | output | 1 | 75,056 | 12 | 150,113 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p of n integers 1, 2, ..., n (a permutation is an array where each element from 1 to n occurs exactly once).
Let's call some subsegment p[l, r] of this permutation special if p_l + p_r = max _{i = l}^{r} p_i. Please calculate the number of special subsegments.
Input
The first line contains one integer n (3 ≤ n ≤ 2 ⋅ 10^5).
The second line contains n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). All these integers are pairwise distinct.
Output
Print the number of special subsegments of the given permutation.
Examples
Input
5
3 4 1 5 2
Output
2
Input
3
1 3 2
Output
1
Note
Special subsegments in the first example are [1, 5] and [1, 3].
The only special subsegment in the second example is [1, 3].
Submitted Solution:
```
import sys; input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
place = [0]*(n+1)
for i in range(n):
place[a[i]] = i
par = [-1]*n
nums = [[] for i in range(n)]
def find(x):
if x == par[x]: return x
par[x] = find(par[x])
return par[x]
def comb(x, y):
x, y = find(x), find(y)
if len(nums[x]) < len(nums[y]):
x, y = y, x
par[y] = x
new = []
py = 0
n, m = len(nums[x]), len(nums[y])
for i in range(n):
while py < m and nums[y][py] < nums[x][i]:
new.append(nums[y][py])
py += 1
new.append(nums[x][i])
nums[x] = new
nums[y].clear()
a.sort()
ans = 0
for x in a:
cur = place[x]
par[cur] = cur
nums[cur].append(x)
if cur-1 >= 0 and cur+1 < n and par[cur-1] != -1 and par[cur+1] != -1:
l, r = find(cur-1), find(cur+1)
l, r = nums[l], nums[r]
p2 = len(r) - 1
for num in l:
while p2 >= 0 and num + r[p2] > x:
p2 -= 1
ans += p2 >= 0 and num + r[p2] == x
if cur-1 >= 0 and par[cur-1] != -1:
comb(cur-1, cur)
if cur+1 < n and par[cur+1] != -1:
comb(cur+1, cur)
print(ans)
``` | instruction | 0 | 75,057 | 12 | 150,114 |
No | output | 1 | 75,057 | 12 | 150,115 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.