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 3 solution for this coding contest problem.
Baby Ehab is known for his love for a certain operation. He has an array a of length n, and he decided to keep doing the following operation on it:
* he picks 2 adjacent elements; he then removes them and places a single integer in their place: their [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR). Note that the length of the array decreases by one.
Now he asks you if he can make all elements of the array equal. Since babies like to make your life harder, he requires that you leave at least 2 elements remaining.
Input
The first line contains an integer t (1 ≤ t ≤ 15) — the number of test cases you need to solve.
The first line of each test case contains an integers n (2 ≤ n ≤ 2000) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (0 ≤ a_i < 2^{30}) — the elements of the array a.
Output
If Baby Ehab can make all elements equal while leaving at least 2 elements standing, print "YES". Otherwise, print "NO".
Example
Input
2
3
0 2 2
4
2 3 1 10
Output
YES
NO
Note
In the first sample, he can remove the first 2 elements, 0 and 2, and replace them by 0 ⊕ 2=2. The array will be [2,2], so all the elements are equal.
In the second sample, there's no way to make all the elements equal. | instruction | 0 | 100,563 | 12 | 201,126 |
Tags: bitmasks, brute force, dp, greedy
Correct Solution:
```
t = int(input())
for _ in range(t):
input()
l = list(map(int, input().split()))
v = []
for x in l:
if not v: v.append(x)
else: v.append(x ^ v[-1])
if v[-1] == 0:
print("YES")
else:
ok = False
for i in range(1, len(l)):
for j in range(i+1, len(l)):
v1 = v[i-1]
v2 = v[j-1] ^ v[i-1]
v3 = v[-1] ^ v[j-1]
if v1 == v2 == v3:
print("YES")
ok = True
break
if ok:
break
if not ok:
print("NO")
``` | output | 1 | 100,563 | 12 | 201,127 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Baby Ehab is known for his love for a certain operation. He has an array a of length n, and he decided to keep doing the following operation on it:
* he picks 2 adjacent elements; he then removes them and places a single integer in their place: their [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR). Note that the length of the array decreases by one.
Now he asks you if he can make all elements of the array equal. Since babies like to make your life harder, he requires that you leave at least 2 elements remaining.
Input
The first line contains an integer t (1 ≤ t ≤ 15) — the number of test cases you need to solve.
The first line of each test case contains an integers n (2 ≤ n ≤ 2000) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (0 ≤ a_i < 2^{30}) — the elements of the array a.
Output
If Baby Ehab can make all elements equal while leaving at least 2 elements standing, print "YES". Otherwise, print "NO".
Example
Input
2
3
0 2 2
4
2 3 1 10
Output
YES
NO
Note
In the first sample, he can remove the first 2 elements, 0 and 2, and replace them by 0 ⊕ 2=2. The array will be [2,2], so all the elements are equal.
In the second sample, there's no way to make all the elements equal. | instruction | 0 | 100,564 | 12 | 201,128 |
Tags: bitmasks, brute force, dp, greedy
Correct Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
x = 0
for v in a:
x ^= v
if x == 0:
print("YES")
else:
y = a[0]
si = 0
while y != x:
si += 1
if si >= n:
break
y ^= a[si]
z = a[n - 1]
ei = n - 1
while z != x:
ei -= 1
if ei <= si:
break
z ^= a[ei]
if si < n - 1 and ei > 0 and (ei - si - 1) > 0:
print("YES")
else:
print("NO")
``` | output | 1 | 100,564 | 12 | 201,129 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Baby Ehab is known for his love for a certain operation. He has an array a of length n, and he decided to keep doing the following operation on it:
* he picks 2 adjacent elements; he then removes them and places a single integer in their place: their [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR). Note that the length of the array decreases by one.
Now he asks you if he can make all elements of the array equal. Since babies like to make your life harder, he requires that you leave at least 2 elements remaining.
Input
The first line contains an integer t (1 ≤ t ≤ 15) — the number of test cases you need to solve.
The first line of each test case contains an integers n (2 ≤ n ≤ 2000) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (0 ≤ a_i < 2^{30}) — the elements of the array a.
Output
If Baby Ehab can make all elements equal while leaving at least 2 elements standing, print "YES". Otherwise, print "NO".
Example
Input
2
3
0 2 2
4
2 3 1 10
Output
YES
NO
Note
In the first sample, he can remove the first 2 elements, 0 and 2, and replace them by 0 ⊕ 2=2. The array will be [2,2], so all the elements are equal.
In the second sample, there's no way to make all the elements equal. | instruction | 0 | 100,565 | 12 | 201,130 |
Tags: bitmasks, brute force, dp, greedy
Correct Solution:
```
#!/usr/bin/env python
from __future__ import division, print_function
import math
import os
import sys
from fractions import *
from sys import *
from decimal import *
from io import BytesIO, IOBase
from itertools import *
from collections import *
# sys.setrecursionlimit(10**5)
M = 10 ** 9 + 7
# print(math.factorial(5))
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
# sys.setrecursionlimit(10**6)
# 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")
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")
def inp(): return sys.stdin.readline().rstrip("\r\n") # for fast input
def out(var): sys.stdout.write(str(var)) # for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
def fsep(): return map(float, inp().split())
def inpu(): return int(inp())
# -----------------------------------------------------------------
def regularbracket(t):
p = 0
for i in t:
if i == "(":
p += 1
else:
p -= 1
if p < 0:
return False
else:
if p > 0:
return False
else:
return True
# -------------------------------------------------
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
# ------------------------------reverse string(pallindrome)
def reverse1(string):
pp = ""
for i in string[::-1]:
pp += i
if pp == string:
return True
return False
# --------------------------------reverse list(paindrome)
def reverse2(list1):
l = []
for i in list1[::-1]:
l.append(i)
if l == list1:
return True
return False
def mex(list1):
# list1 = sorted(list1)
p = max(list1) + 1
for i in range(len(list1)):
if list1[i] != i:
p = i
break
return p
def sumofdigits(n):
n = str(n)
s1 = 0
for i in n:
s1 += int(i)
return s1
def perfect_square(n):
s = math.sqrt(n)
if s == int(s):
return True
return False
# -----------------------------roman
def roman_number(x):
if x > 15999:
return
value = [5000, 4000, 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
symbol = ["F", "MF", "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]
roman = ""
i = 0
while x > 0:
div = x // value[i]
x = x % value[i]
while div:
roman += symbol[i]
div -= 1
i += 1
return roman
def soretd(s):
for i in range(1, len(s)):
if s[i - 1] > s[i]:
return False
return True
# print(soretd("1"))
# ---------------------------
def countRhombi(h, w):
ct = 0
for i in range(2, h + 1, 2):
for j in range(2, w + 1, 2):
ct += (h - i + 1) * (w - j + 1)
return ct
def countrhombi2(h, w):
return ((h * h) // 4) * ((w * w) // 4)
# ---------------------------------
def binpow(a, b):
if b == 0:
return 1
else:
res = binpow(a, b // 2)
if b % 2 != 0:
return res * res * a
else:
return res * res
# -------------------------------------------------------
def binpowmodulus(a, b, m):
a %= m
res = 1
while (b > 0):
if (b & 1):
res = res * a % m
a = a * a % m
b >>= 1
return res
# -------------------------------------------------------------
def coprime_to_n(n):
result = n
i = 2
while (i * i <= n):
if (n % i == 0):
while (n % i == 0):
n //= i
result -= result // i
i += 1
if (n > 1):
result -= result // n
return result
# -------------------prime
def prime(x):
if x == 1:
return False
else:
for i in range(2, int(math.sqrt(x)) + 1):
# print(x)
if (x % i == 0):
return False
else:
return True
def luckynumwithequalnumberoffourandseven(x,n,a):
if x >= n and str(x).count("4") == str(x).count("7"):
a.append(x)
else:
if x < 1e12:
luckynumwithequalnumberoffourandseven(x * 10 + 4,n,a)
luckynumwithequalnumberoffourandseven(x * 10 + 7,n,a)
return a
#----------------------
def luckynum(x,l,r,a):
if x>=l and x<=r:
a.append(x)
if x>r:
a.append(x)
return a
if x < 1e10:
luckynum(x * 10 + 4, l,r,a)
luckynum(x * 10 + 7, l,r,a)
return a
def luckynuber(x, n, a):
p = set(str(x))
if len(p) <= 2:
a.append(x)
if x < n:
luckynuber(x + 1, n, a)
return a
# ------------------------------------------------------interactive problems
def interact(type, x):
if type == "r":
inp = input()
return inp.strip()
else:
print(x, flush=True)
# ------------------------------------------------------------------zero at end of factorial of a number
def findTrailingZeros(n):
# Initialize result
count = 0
# Keep dividing n by
# 5 & update Count
while (n >= 5):
n //= 5
count += n
return count
# -----------------------------------------------merge sort
# Python program for implementation of MergeSort
def mergeSort(arr):
if len(arr) > 1:
# Finding the mid of the array
mid = len(arr) // 2
# Dividing the array elements
L = arr[:mid]
# into 2 halves
R = arr[mid:]
# Sorting the first half
mergeSort(L)
# Sorting the second half
mergeSort(R)
i = j = k = 0
# Copy data to temp arrays L[] and R[]
while i < len(L) and j < len(R):
if L[i] < R[j]:
arr[k] = L[i]
i += 1
else:
arr[k] = R[j]
j += 1
k += 1
# Checking if any element was left
while i < len(L):
arr[k] = L[i]
i += 1
k += 1
while j < len(R):
arr[k] = R[j]
j += 1
k += 1
# -----------------------------------------------lucky number with two lucky any digits
res = set()
def solven(p, l, a, b, n): # given number
if p > n or l > 10:
return
if p > 0:
res.add(p)
solven(p * 10 + a, l + 1, a, b, n)
solven(p * 10 + b, l + 1, a, b, n)
# problem
"""
n = int(input())
for a in range(0, 10):
for b in range(0, a):
solve(0, 0)
print(len(res))
"""
# Python3 program to find all subsets
# by backtracking.
# In the array A at every step we have two
# choices for each element either we can
# ignore the element or we can include the
# element in our subset
def subsetsUtil(A, subset, index, d):
print(*subset)
s = sum(subset)
d.append(s)
for i in range(index, len(A)):
# include the A[i] in subset.
subset.append(A[i])
# move onto the next element.
subsetsUtil(A, subset, i + 1, d)
# exclude the A[i] from subset and
# triggers backtracking.
subset.pop(-1)
return d
def subsetSums(arr, l, r, d, sum=0):
if l > r:
d.append(sum)
return
subsetSums(arr, l + 1, r, d, sum + arr[l])
# Subset excluding arr[l]
subsetSums(arr, l + 1, r, d, sum)
return d
def print_factors(x):
factors = []
for i in range(1, x + 1):
if x % i == 0:
factors.append(i)
return (factors)
# -----------------------------------------------
def calc(X, d, ans, D):
# print(X,d)
if len(X) == 0:
return
i = X.index(max(X))
ans[D[max(X)]] = d
Y = X[:i]
Z = X[i + 1:]
calc(Y, d + 1, ans, D)
calc(Z, d + 1, ans, D)
# ---------------------------------------
def factorization(n, l):
c = n
if prime(n) == True:
l.append(n)
return l
for i in range(2, c):
if n == 1:
break
while n % i == 0:
l.append(i)
n = n // i
return l
# endregion------------------------------
def good(b):
l = []
i = 0
while (len(b) != 0):
if b[i] < b[len(b) - 1 - i]:
l.append(b[i])
b.remove(b[i])
else:
l.append(b[len(b) - 1 - i])
b.remove(b[len(b) - 1 - i])
if l == sorted(l):
# print(l)
return True
return False
# arr=[]
# print(good(arr))
def generate(st, s):
if len(s) == 0:
return
# If current string is not already present.
if s not in st:
st.add(s)
# Traverse current string, one by one
# remove every character and recur.
for i in range(len(s)):
t = list(s).copy()
t.remove(s[i])
t = ''.join(t)
generate(st, t)
return
#=--------------------------------------------longest increasing subsequence
def largestincreasingsubsequence(A):
l = [1]*len(A)
sub=[]
for i in range(1,len(l)):
for k in range(i):
if A[k]<A[i]:
sub.append(l[k])
l[i]=1+max(sub,default=0)
return max(l,default=0)
#----------------------------------longest palindromic substring
# Python3 program for the
# above approach
# Function to calculate
# Bitwise OR of sums of
# all subsequences
def findOR(nums, N):
# Stores the prefix
# sum of nums[]
prefix_sum = 0
# Stores the bitwise OR of
# sum of each subsequence
result = 0
# Iterate through array nums[]
for i in range(N):
# Bits set in nums[i] are
# also set in result
result |= nums[i]
# Calculate prefix_sum
prefix_sum += nums[i]
# Bits set in prefix_sum
# are also set in result
result |= prefix_sum
# Return the result
return result
#l=[]
def OR(a, n):
ans = a[0]
for i in range(1, n):
ans |= a[i]
#l.append(ans)
return ans
#print(prime(12345678987766))
"""
def main():
q=inpu()
x = q
v1 = 0
v2 = 0
i = 2
while i * i <= q:
while q % i == 0:
if v1!=0:
v2 = i
else:
v1 = i
q //= i
i += 1
if q - 1!=0:
v2 = q
if v1 * v2 - x!=0:
print(1)
print(v1 * v2)
else:
print(2)
if __name__ == '__main__':
main()
"""
"""
def main():
l,r = sep()
a=[]
luckynum(0,l,r,a)
a.sort()
#print(a)
i=0
ans=0
l-=1
#print(a)
while(True):
if r>a[i]:
ans+=(a[i]*(a[i]-l))
l=a[i]
else:
ans+=(a[i]*(r-l))
break
i+=1
print(ans)
if __name__ == '__main__':
main()
"""
"""
def main():
sqrt = {i * i: i for i in range(1, 1000)}
#print(sqrt)
a, b = sep()
for y in range(1, a):
x2 = a * a - y * y
if x2 in sqrt:
x = sqrt[x2]
if b * y % a == 0 and b * x % a == 0 and b * x // a != y:
print('YES')
print(-x, y)
print(0, 0)
print(b * y // a, b * x // a)
exit()
print('NO')
if __name__ == '__main__':
main()
"""
"""
def main():
m=inpu()
q=lis()
n=inpu()
arr=lis()
q=min(q)
arr.sort(reverse=True)
s=0
cnt=0
i=0
while(i<n):
cnt+=1
s+=arr[i]
#print(cnt,q)
if cnt==q:
i+=2
cnt=0
i+=1
print(s)
if __name__ == '__main__':
main()
"""
"""
def main():
n,k = sep()
if k * 2 >= (n - 1) * n:
print('no solution')
else:
for i in range(n):
print(0,i)
if __name__ == '__main__':
main()
"""
"""
def main():
t = inpu()
for _ in range(t):
n,k = sep()
arr = lis()
i=0
j=0
while(k!=0):
if i==n-1:
break
if arr[i]!=0:
arr[i]-=1
arr[n-1]+=1
k-=1
else:
i+=1
print(*arr)
if __name__ == '__main__':
main()
"""
def main():
t = int(input())
for _ in range(t):
n=int(input())
arr = lis()
s = 0
for x in arr:
s ^= x
if s == 0:
print('YES')
else:
c = 0
y=0
for i in range(n):
y ^= arr[i]
if y == s:
c += 1
y=0
if c >= 2:
print("YES")
else:
print("NO")
if __name__ == '__main__':
main()
``` | output | 1 | 100,565 | 12 | 201,131 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Baby Ehab is known for his love for a certain operation. He has an array a of length n, and he decided to keep doing the following operation on it:
* he picks 2 adjacent elements; he then removes them and places a single integer in their place: their [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR). Note that the length of the array decreases by one.
Now he asks you if he can make all elements of the array equal. Since babies like to make your life harder, he requires that you leave at least 2 elements remaining.
Input
The first line contains an integer t (1 ≤ t ≤ 15) — the number of test cases you need to solve.
The first line of each test case contains an integers n (2 ≤ n ≤ 2000) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (0 ≤ a_i < 2^{30}) — the elements of the array a.
Output
If Baby Ehab can make all elements equal while leaving at least 2 elements standing, print "YES". Otherwise, print "NO".
Example
Input
2
3
0 2 2
4
2 3 1 10
Output
YES
NO
Note
In the first sample, he can remove the first 2 elements, 0 and 2, and replace them by 0 ⊕ 2=2. The array will be [2,2], so all the elements are equal.
In the second sample, there's no way to make all the elements equal.
Submitted Solution:
```
import sys
from collections import defaultdict
input = sys.stdin.readline
def solve(n):
arr = list(map(int,input().split()))
dp = defaultdict(int)
for i in range(n):
dp[i] = dp[i-1] ^ arr[i]
temp = 0
if dp[n-1]==0:
for i in range(n-1):
if dp[i]==dp[n-1]^dp[i]:
temp = 1
if temp:
print("YES")
else:
print("NO")
else:
temp = 0
for i in range(n-2):
if dp[i]==dp[n-1]:
for j in range(i+1,n-1):
if dp[j]==0:
temp = 1
break
if temp:
print("YES")
else:
print("NO")
t = int(input())
for _ in range(t):
n = int(input())
solve(n)
``` | instruction | 0 | 100,566 | 12 | 201,132 |
Yes | output | 1 | 100,566 | 12 | 201,133 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Baby Ehab is known for his love for a certain operation. He has an array a of length n, and he decided to keep doing the following operation on it:
* he picks 2 adjacent elements; he then removes them and places a single integer in their place: their [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR). Note that the length of the array decreases by one.
Now he asks you if he can make all elements of the array equal. Since babies like to make your life harder, he requires that you leave at least 2 elements remaining.
Input
The first line contains an integer t (1 ≤ t ≤ 15) — the number of test cases you need to solve.
The first line of each test case contains an integers n (2 ≤ n ≤ 2000) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (0 ≤ a_i < 2^{30}) — the elements of the array a.
Output
If Baby Ehab can make all elements equal while leaving at least 2 elements standing, print "YES". Otherwise, print "NO".
Example
Input
2
3
0 2 2
4
2 3 1 10
Output
YES
NO
Note
In the first sample, he can remove the first 2 elements, 0 and 2, and replace them by 0 ⊕ 2=2. The array will be [2,2], so all the elements are equal.
In the second sample, there's no way to make all the elements equal.
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
a=[int(x) for x in input().split()]
x=0
for i in a:
x=x^i
if x==0:
print("YES")
else:
arr=[0 for i in range(31)]
y=0
f=0
for i in range(n):
y=y^a[i]
if y==x:
f+=1
y=0
if f<3:
print("NO")
else:
print("YES")
``` | instruction | 0 | 100,567 | 12 | 201,134 |
Yes | output | 1 | 100,567 | 12 | 201,135 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Baby Ehab is known for his love for a certain operation. He has an array a of length n, and he decided to keep doing the following operation on it:
* he picks 2 adjacent elements; he then removes them and places a single integer in their place: their [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR). Note that the length of the array decreases by one.
Now he asks you if he can make all elements of the array equal. Since babies like to make your life harder, he requires that you leave at least 2 elements remaining.
Input
The first line contains an integer t (1 ≤ t ≤ 15) — the number of test cases you need to solve.
The first line of each test case contains an integers n (2 ≤ n ≤ 2000) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (0 ≤ a_i < 2^{30}) — the elements of the array a.
Output
If Baby Ehab can make all elements equal while leaving at least 2 elements standing, print "YES". Otherwise, print "NO".
Example
Input
2
3
0 2 2
4
2 3 1 10
Output
YES
NO
Note
In the first sample, he can remove the first 2 elements, 0 and 2, and replace them by 0 ⊕ 2=2. The array will be [2,2], so all the elements are equal.
In the second sample, there's no way to make all the elements equal.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
res = 0
for i in range(n):
res ^= arr[i]
if res == 0:
print("YES")
else:
count = 0
xor = 0
for i in range(n):
xor ^= arr[i]
if xor == res:
count += 1
xor = 0
if count >= 2:
print("YES")
else:
print("NO")
``` | instruction | 0 | 100,568 | 12 | 201,136 |
Yes | output | 1 | 100,568 | 12 | 201,137 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Baby Ehab is known for his love for a certain operation. He has an array a of length n, and he decided to keep doing the following operation on it:
* he picks 2 adjacent elements; he then removes them and places a single integer in their place: their [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR). Note that the length of the array decreases by one.
Now he asks you if he can make all elements of the array equal. Since babies like to make your life harder, he requires that you leave at least 2 elements remaining.
Input
The first line contains an integer t (1 ≤ t ≤ 15) — the number of test cases you need to solve.
The first line of each test case contains an integers n (2 ≤ n ≤ 2000) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (0 ≤ a_i < 2^{30}) — the elements of the array a.
Output
If Baby Ehab can make all elements equal while leaving at least 2 elements standing, print "YES". Otherwise, print "NO".
Example
Input
2
3
0 2 2
4
2 3 1 10
Output
YES
NO
Note
In the first sample, he can remove the first 2 elements, 0 and 2, and replace them by 0 ⊕ 2=2. The array will be [2,2], so all the elements are equal.
In the second sample, there's no way to make all the elements equal.
Submitted Solution:
```
#######puzzleVerma#######
import sys
import math
LI=lambda:[int(k) for k in input().split()]
input = lambda: sys.stdin.readline().rstrip()
IN=lambda:int(input())
S=lambda:input()
for t in range(IN()):
n=IN()
a=LI()
pre=0
for i in range(n):
pre^=a[i]
prea=0
flag=0
for j in range(i+1,n):
prea^=a[j]
if prea==pre:
prea=0
flag=1
if (flag and (not prea)):
print("YES")
break
if (not flag):
print("NO")
``` | instruction | 0 | 100,569 | 12 | 201,138 |
Yes | output | 1 | 100,569 | 12 | 201,139 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Baby Ehab is known for his love for a certain operation. He has an array a of length n, and he decided to keep doing the following operation on it:
* he picks 2 adjacent elements; he then removes them and places a single integer in their place: their [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR). Note that the length of the array decreases by one.
Now he asks you if he can make all elements of the array equal. Since babies like to make your life harder, he requires that you leave at least 2 elements remaining.
Input
The first line contains an integer t (1 ≤ t ≤ 15) — the number of test cases you need to solve.
The first line of each test case contains an integers n (2 ≤ n ≤ 2000) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (0 ≤ a_i < 2^{30}) — the elements of the array a.
Output
If Baby Ehab can make all elements equal while leaving at least 2 elements standing, print "YES". Otherwise, print "NO".
Example
Input
2
3
0 2 2
4
2 3 1 10
Output
YES
NO
Note
In the first sample, he can remove the first 2 elements, 0 and 2, and replace them by 0 ⊕ 2=2. The array will be [2,2], so all the elements are equal.
In the second sample, there's no way to make all the elements equal.
Submitted Solution:
```
tt = int ( input ())
for _ in range (tt):
n = int(input ())
l = []
l = list (map(int , input().split()))
if l.count(l[0])== n :
print ("YES")
continue
ans = 1
bit = [0 for i in range (30)]
for el in l:
for i in range (30) :
if ((1<<i)&el)!=0:
bit[i]+=1
for i in range (30):
if (bit[i]%2 == 1) and (bit[i]!=n):
ans = 0
break
if ans == 1:
print ("YES")
else :
print ("NO")
#jflsdjlsdfjlsdjla;jfdsj;af
#jfd;sajfl;jdsa;fjsda
#da;sfj;sdjf;
``` | instruction | 0 | 100,570 | 12 | 201,140 |
No | output | 1 | 100,570 | 12 | 201,141 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Baby Ehab is known for his love for a certain operation. He has an array a of length n, and he decided to keep doing the following operation on it:
* he picks 2 adjacent elements; he then removes them and places a single integer in their place: their [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR). Note that the length of the array decreases by one.
Now he asks you if he can make all elements of the array equal. Since babies like to make your life harder, he requires that you leave at least 2 elements remaining.
Input
The first line contains an integer t (1 ≤ t ≤ 15) — the number of test cases you need to solve.
The first line of each test case contains an integers n (2 ≤ n ≤ 2000) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (0 ≤ a_i < 2^{30}) — the elements of the array a.
Output
If Baby Ehab can make all elements equal while leaving at least 2 elements standing, print "YES". Otherwise, print "NO".
Example
Input
2
3
0 2 2
4
2 3 1 10
Output
YES
NO
Note
In the first sample, he can remove the first 2 elements, 0 and 2, and replace them by 0 ⊕ 2=2. The array will be [2,2], so all the elements are equal.
In the second sample, there's no way to make all the elements equal.
Submitted Solution:
```
#!/usr/bin/env python3
# created : 2021
from sys import stdin, stdout
from random import randint
def solve(tc):
n = int(stdin.readline().strip())
seq = list(map(int, stdin.readline().split()))
allSame = True
for i in range(1, n):
if seq[i] != seq[0]:
allSame = False
break
if allSame:
print("YES")
return
bits = [0 for i in range(30)]
for i in range(n):
for j in range(30):
if (seq[i] >> j) & 1:
bits[j] += 1
for j in range(30):
if bits[j] & 1:
print("NO")
return
print("YES")
tcs = 1
tcs = int(stdin.readline().strip())
tc = 1
while tc <= tcs:
solve(tc)
tc += 1
``` | instruction | 0 | 100,571 | 12 | 201,142 |
No | output | 1 | 100,571 | 12 | 201,143 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Baby Ehab is known for his love for a certain operation. He has an array a of length n, and he decided to keep doing the following operation on it:
* he picks 2 adjacent elements; he then removes them and places a single integer in their place: their [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR). Note that the length of the array decreases by one.
Now he asks you if he can make all elements of the array equal. Since babies like to make your life harder, he requires that you leave at least 2 elements remaining.
Input
The first line contains an integer t (1 ≤ t ≤ 15) — the number of test cases you need to solve.
The first line of each test case contains an integers n (2 ≤ n ≤ 2000) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (0 ≤ a_i < 2^{30}) — the elements of the array a.
Output
If Baby Ehab can make all elements equal while leaving at least 2 elements standing, print "YES". Otherwise, print "NO".
Example
Input
2
3
0 2 2
4
2 3 1 10
Output
YES
NO
Note
In the first sample, he can remove the first 2 elements, 0 and 2, and replace them by 0 ⊕ 2=2. The array will be [2,2], so all the elements are equal.
In the second sample, there's no way to make all the elements equal.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
arr= list(map(int, input().split()))
pre=arr[0]
for x in arr[1:-1]:
pre = x^pre
if pre == arr[-1]:
print("YES")
else:
print("NO")
``` | instruction | 0 | 100,572 | 12 | 201,144 |
No | output | 1 | 100,572 | 12 | 201,145 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Baby Ehab is known for his love for a certain operation. He has an array a of length n, and he decided to keep doing the following operation on it:
* he picks 2 adjacent elements; he then removes them and places a single integer in their place: their [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR). Note that the length of the array decreases by one.
Now he asks you if he can make all elements of the array equal. Since babies like to make your life harder, he requires that you leave at least 2 elements remaining.
Input
The first line contains an integer t (1 ≤ t ≤ 15) — the number of test cases you need to solve.
The first line of each test case contains an integers n (2 ≤ n ≤ 2000) — the number of elements in the array a.
The second line contains n space-separated integers a_1, a_2, …, a_{n} (0 ≤ a_i < 2^{30}) — the elements of the array a.
Output
If Baby Ehab can make all elements equal while leaving at least 2 elements standing, print "YES". Otherwise, print "NO".
Example
Input
2
3
0 2 2
4
2 3 1 10
Output
YES
NO
Note
In the first sample, he can remove the first 2 elements, 0 and 2, and replace them by 0 ⊕ 2=2. The array will be [2,2], so all the elements are equal.
In the second sample, there's no way to make all the elements equal.
Submitted Solution:
```
from collections import defaultdict
for _ in range(int(input())):
n = map(int, input().split(" "))
l = list(map(int, input().split(" ")))
if len(set(l)) == 1:
print('YES')
else:
a = 0
for i in l:
a^=i
if a==0:
print("YES")
else:
if l.count(a)>1:
print("YES")
else:
print("NO")
``` | instruction | 0 | 100,573 | 12 | 201,146 |
No | output | 1 | 100,573 | 12 | 201,147 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja loves integer sequences very much. He especially likes stairs.
Sequence a1, a2, ..., a|a| (|a| is the length of the sequence) is stairs if there is such index i (1 ≤ i ≤ |a|), that the following condition is met:
a1 < a2 < ... < ai - 1 < ai > ai + 1 > ... > a|a| - 1 > a|a|.
For example, sequences [1, 2, 3, 2] and [4, 2] are stairs and sequence [3, 1, 2] isn't.
Sereja has m cards with numbers. He wants to put some cards on the table in a row to get a stair sequence. What maximum number of cards can he put on the table?
Input
The first line contains integer m (1 ≤ m ≤ 105) — the number of Sereja's cards. The second line contains m integers bi (1 ≤ bi ≤ 5000) — the numbers on the Sereja's cards.
Output
In the first line print the number of cards you can put on the table. In the second line print the resulting stairs.
Examples
Input
5
1 2 3 4 5
Output
5
5 4 3 2 1
Input
6
1 1 2 2 3 3
Output
5
1 2 3 2 1 | instruction | 0 | 100,652 | 12 | 201,304 |
Tags: greedy, implementation, sortings
Correct Solution:
```
n=int(input())
l=[int(i) for i in input().split()]
if n==1:
print(1)
print(l[0])
else:
ans=sorted(list(set(l)))
#l=sorted(l,reverse=True)
d=dict()
for i in l:
if i in d:
d[i]+=1
else:
d[i]=1
i=50001
while i>=0:
try:
z=d[i]
if z>1:
ans.append(i)
i-=1
except:
i-=1
i=0
new=[]
while i+1<len(ans):
if ans[i]!=ans[i+1]:
new.append(ans[i])
i+=1
else:
while i+1<len(ans) and ans[i]==ans[i+1]:
i+=1
new.append(ans[i])
i+=1
if ans[-1]!=new[-1]:
new.append(ans[-1])
print(len(new))
print(*new)
``` | output | 1 | 100,652 | 12 | 201,305 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja loves integer sequences very much. He especially likes stairs.
Sequence a1, a2, ..., a|a| (|a| is the length of the sequence) is stairs if there is such index i (1 ≤ i ≤ |a|), that the following condition is met:
a1 < a2 < ... < ai - 1 < ai > ai + 1 > ... > a|a| - 1 > a|a|.
For example, sequences [1, 2, 3, 2] and [4, 2] are stairs and sequence [3, 1, 2] isn't.
Sereja has m cards with numbers. He wants to put some cards on the table in a row to get a stair sequence. What maximum number of cards can he put on the table?
Input
The first line contains integer m (1 ≤ m ≤ 105) — the number of Sereja's cards. The second line contains m integers bi (1 ≤ bi ≤ 5000) — the numbers on the Sereja's cards.
Output
In the first line print the number of cards you can put on the table. In the second line print the resulting stairs.
Examples
Input
5
1 2 3 4 5
Output
5
5 4 3 2 1
Input
6
1 1 2 2 3 3
Output
5
1 2 3 2 1 | instruction | 0 | 100,653 | 12 | 201,306 |
Tags: greedy, implementation, sortings
Correct Solution:
```
m = int(input())
a = map(int, input().split())
def seryozha_and_ladder(a):
a = sorted(a, key = lambda x: -x)
prev_i = a[0]
cnt = 2
first_part = [a[0]]
second_part = []
for i in a:
if i == prev_i:
cnt += 1
if cnt == 2:
second_part.append(i)
else:
first_part.append(i)
cnt = 1
prev_i = i
return first_part[::-1] + second_part
res = seryozha_and_ladder(a)
print(len(res))
print(" ".join(map(str, res)))
``` | output | 1 | 100,653 | 12 | 201,307 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja loves integer sequences very much. He especially likes stairs.
Sequence a1, a2, ..., a|a| (|a| is the length of the sequence) is stairs if there is such index i (1 ≤ i ≤ |a|), that the following condition is met:
a1 < a2 < ... < ai - 1 < ai > ai + 1 > ... > a|a| - 1 > a|a|.
For example, sequences [1, 2, 3, 2] and [4, 2] are stairs and sequence [3, 1, 2] isn't.
Sereja has m cards with numbers. He wants to put some cards on the table in a row to get a stair sequence. What maximum number of cards can he put on the table?
Input
The first line contains integer m (1 ≤ m ≤ 105) — the number of Sereja's cards. The second line contains m integers bi (1 ≤ bi ≤ 5000) — the numbers on the Sereja's cards.
Output
In the first line print the number of cards you can put on the table. In the second line print the resulting stairs.
Examples
Input
5
1 2 3 4 5
Output
5
5 4 3 2 1
Input
6
1 1 2 2 3 3
Output
5
1 2 3 2 1 | instruction | 0 | 100,654 | 12 | 201,308 |
Tags: greedy, implementation, sortings
Correct Solution:
```
def heapSort(li):
def downHeap(li, k, n):
new_elem = li[k]
while 2*k+1 < n:
child = 2*k+1;
if child+1 < n and li[child] < li[child+1]:
child += 1
if new_elem >= li[child]:
break
li[k] = li[child]
k = child
li[k] = new_elem
size = len(li)
for i in range(size//2-1,-1,-1):
downHeap(li, i, size)
for i in range(size-1,0,-1):
temp = li[i]
li[i] = li[0]
li[0] = temp
downHeap(li, 0, i)
return li
n = input()
sqc1 = [int(i) for i in input().split(" ")]
sqc2 = [str(i) for i in heapSort(list(set(sqc1)))]
for i in sqc2: sqc1.remove(int(i))
sqc1 = [str(i) for i in heapSort(list(set(sqc1)))]
sqc2 = sqc2[::-1]
if len(sqc1) == 0:
print(len(sqc2))
print((" ".join(sqc2)).strip())
elif sqc1[-1] == sqc2[0]:
print(len(sqc1)+len(sqc2)-1)
print((" ".join(sqc1[:-1])+ " " + " ".join(sqc2)).strip())
else:
print(len(sqc1)+len(sqc2))
print((" ".join(sqc1)+ " " + " ".join(sqc2)).strip())
``` | output | 1 | 100,654 | 12 | 201,309 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja loves integer sequences very much. He especially likes stairs.
Sequence a1, a2, ..., a|a| (|a| is the length of the sequence) is stairs if there is such index i (1 ≤ i ≤ |a|), that the following condition is met:
a1 < a2 < ... < ai - 1 < ai > ai + 1 > ... > a|a| - 1 > a|a|.
For example, sequences [1, 2, 3, 2] and [4, 2] are stairs and sequence [3, 1, 2] isn't.
Sereja has m cards with numbers. He wants to put some cards on the table in a row to get a stair sequence. What maximum number of cards can he put on the table?
Input
The first line contains integer m (1 ≤ m ≤ 105) — the number of Sereja's cards. The second line contains m integers bi (1 ≤ bi ≤ 5000) — the numbers on the Sereja's cards.
Output
In the first line print the number of cards you can put on the table. In the second line print the resulting stairs.
Examples
Input
5
1 2 3 4 5
Output
5
5 4 3 2 1
Input
6
1 1 2 2 3 3
Output
5
1 2 3 2 1 | instruction | 0 | 100,655 | 12 | 201,310 |
Tags: greedy, implementation, sortings
Correct Solution:
```
n = int(input())
test = list(map(int, input().split()))
test1 = []
result = []
test.sort(reverse=True)
num = test.count(test[0])
test1.append(test[0])
mark = 0
for i in range(num, len(test)):
if test[i] != test1[len(test1)-1]:
test1.append(test[i])
mark = 0
else:
if mark > 0:
continue
else:
test1.append(test[i])
mark += 1
result.append(test1[0])
for j in range(1, len(test1)):
if test1[j] != result[len(result)-1]:
result.append(test1[j])
else:
result.insert(0, test1[j])
print(len(result))
print(' '.join(map(str, result)))
``` | output | 1 | 100,655 | 12 | 201,311 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja loves integer sequences very much. He especially likes stairs.
Sequence a1, a2, ..., a|a| (|a| is the length of the sequence) is stairs if there is such index i (1 ≤ i ≤ |a|), that the following condition is met:
a1 < a2 < ... < ai - 1 < ai > ai + 1 > ... > a|a| - 1 > a|a|.
For example, sequences [1, 2, 3, 2] and [4, 2] are stairs and sequence [3, 1, 2] isn't.
Sereja has m cards with numbers. He wants to put some cards on the table in a row to get a stair sequence. What maximum number of cards can he put on the table?
Input
The first line contains integer m (1 ≤ m ≤ 105) — the number of Sereja's cards. The second line contains m integers bi (1 ≤ bi ≤ 5000) — the numbers on the Sereja's cards.
Output
In the first line print the number of cards you can put on the table. In the second line print the resulting stairs.
Examples
Input
5
1 2 3 4 5
Output
5
5 4 3 2 1
Input
6
1 1 2 2 3 3
Output
5
1 2 3 2 1 | instruction | 0 | 100,656 | 12 | 201,312 |
Tags: greedy, implementation, sortings
Correct Solution:
```
n = int(input())
d = {}
l = list(map(int,input().split()))
for i in range(n):
if l[i] in d:
d[l[i]] = d[l[i]] + 1
else:
d[l[i]] = 1
k = list(set(l))
m = sorted(k)
k.sort(reverse=True)
l = []
for i in k:
if i == k[0]:
continue
elif d[i] > 1:
l.append(i)
k = m + l
print(len(k))
print(*k)
``` | output | 1 | 100,656 | 12 | 201,313 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja loves integer sequences very much. He especially likes stairs.
Sequence a1, a2, ..., a|a| (|a| is the length of the sequence) is stairs if there is such index i (1 ≤ i ≤ |a|), that the following condition is met:
a1 < a2 < ... < ai - 1 < ai > ai + 1 > ... > a|a| - 1 > a|a|.
For example, sequences [1, 2, 3, 2] and [4, 2] are stairs and sequence [3, 1, 2] isn't.
Sereja has m cards with numbers. He wants to put some cards on the table in a row to get a stair sequence. What maximum number of cards can he put on the table?
Input
The first line contains integer m (1 ≤ m ≤ 105) — the number of Sereja's cards. The second line contains m integers bi (1 ≤ bi ≤ 5000) — the numbers on the Sereja's cards.
Output
In the first line print the number of cards you can put on the table. In the second line print the resulting stairs.
Examples
Input
5
1 2 3 4 5
Output
5
5 4 3 2 1
Input
6
1 1 2 2 3 3
Output
5
1 2 3 2 1 | instruction | 0 | 100,657 | 12 | 201,314 |
Tags: greedy, implementation, sortings
Correct Solution:
```
input()
list = [0] * 5001
for i in map(int, input().split()):
list[i] += 1
a = [i for i in range(len(list)) if list[i]]
b = [i for i in a[:-1] if list[i] > 1]
print(len(a) + len(b))
print(' '.join(map(str, a + b[::-1])))
``` | output | 1 | 100,657 | 12 | 201,315 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja loves integer sequences very much. He especially likes stairs.
Sequence a1, a2, ..., a|a| (|a| is the length of the sequence) is stairs if there is such index i (1 ≤ i ≤ |a|), that the following condition is met:
a1 < a2 < ... < ai - 1 < ai > ai + 1 > ... > a|a| - 1 > a|a|.
For example, sequences [1, 2, 3, 2] and [4, 2] are stairs and sequence [3, 1, 2] isn't.
Sereja has m cards with numbers. He wants to put some cards on the table in a row to get a stair sequence. What maximum number of cards can he put on the table?
Input
The first line contains integer m (1 ≤ m ≤ 105) — the number of Sereja's cards. The second line contains m integers bi (1 ≤ bi ≤ 5000) — the numbers on the Sereja's cards.
Output
In the first line print the number of cards you can put on the table. In the second line print the resulting stairs.
Examples
Input
5
1 2 3 4 5
Output
5
5 4 3 2 1
Input
6
1 1 2 2 3 3
Output
5
1 2 3 2 1 | instruction | 0 | 100,658 | 12 | 201,316 |
Tags: greedy, implementation, sortings
Correct Solution:
```
m = int(input())
ml = list(map(int,input().split()))
ml.sort()
sl = [ml[0]]
if len(ml)>1:
fl = [ml[1]]
for i in range(2,m):
if sl[len(sl)-1]<ml[i]:
sl.append(ml[i])
elif fl[len(fl)-1]<ml[i]:
fl.append(ml[i])
if sl[len(sl)-1]==fl[len(fl)-1]:
fl.pop()
fl.reverse()
sl+=fl
print(len(sl))
for i in sl:
print(i,end=" ")
``` | output | 1 | 100,658 | 12 | 201,317 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja loves integer sequences very much. He especially likes stairs.
Sequence a1, a2, ..., a|a| (|a| is the length of the sequence) is stairs if there is such index i (1 ≤ i ≤ |a|), that the following condition is met:
a1 < a2 < ... < ai - 1 < ai > ai + 1 > ... > a|a| - 1 > a|a|.
For example, sequences [1, 2, 3, 2] and [4, 2] are stairs and sequence [3, 1, 2] isn't.
Sereja has m cards with numbers. He wants to put some cards on the table in a row to get a stair sequence. What maximum number of cards can he put on the table?
Input
The first line contains integer m (1 ≤ m ≤ 105) — the number of Sereja's cards. The second line contains m integers bi (1 ≤ bi ≤ 5000) — the numbers on the Sereja's cards.
Output
In the first line print the number of cards you can put on the table. In the second line print the resulting stairs.
Examples
Input
5
1 2 3 4 5
Output
5
5 4 3 2 1
Input
6
1 1 2 2 3 3
Output
5
1 2 3 2 1 | instruction | 0 | 100,659 | 12 | 201,318 |
Tags: greedy, implementation, sortings
Correct Solution:
```
N = int(input())
arr = list(map(int, input().split()))
arr.sort()
left = [0]
right = []
flag = 0
local = 0
for i in range (0, len(arr)):
if local < arr[i]:
local = arr[i]
flag = 1
right.append(arr[i])
elif flag == 1:
left.append(arr[i])
flag = 0
else:
continue
if right[len(right) - 1] == left[len(left) - 1]:
right.pop()
print(len(left)+len(right) - 1)
for i in range (1, len(left)):
print(left[i], end = ' ')
for i in range (0, len(right)):
print(right[len(right) - 1 - i], end = ' ')
``` | output | 1 | 100,659 | 12 | 201,319 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have written on a piece of paper an array of n positive integers a[1], a[2], ..., a[n] and m good pairs of integers (i1, j1), (i2, j2), ..., (im, jm). Each good pair (ik, jk) meets the following conditions: ik + jk is an odd number and 1 ≤ ik < jk ≤ n.
In one operation you can perform a sequence of actions:
* take one of the good pairs (ik, jk) and some integer v (v > 1), which divides both numbers a[ik] and a[jk];
* divide both numbers by v, i. e. perform the assignments: <image> and <image>.
Determine the maximum number of operations you can sequentially perform on the given array. Note that one pair may be used several times in the described operations.
Input
The first line contains two space-separated integers n, m (2 ≤ n ≤ 100, 1 ≤ m ≤ 100).
The second line contains n space-separated integers a[1], a[2], ..., a[n] (1 ≤ a[i] ≤ 109) — the description of the array.
The following m lines contain the description of good pairs. The k-th line contains two space-separated integers ik, jk (1 ≤ ik < jk ≤ n, ik + jk is an odd number).
It is guaranteed that all the good pairs are distinct.
Output
Output the answer for the problem.
Examples
Input
3 2
8 3 8
1 2
2 3
Output
0
Input
3 2
8 12 8
1 2
2 3
Output
2 | instruction | 0 | 100,713 | 12 | 201,426 |
Tags: flows, graph matchings, number theory
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO,IOBase
def matching(n,m,path):
match1 = [-1]*n
match2 = [-1]*m
for node in range(n):
for nei in path[node]:
if match2[nei] == -1:
match1[node] = nei
match2[nei] = node
break
while 1:
bfs = [node for node in range(n) if match1[node] == -1]
depth = [-1] * n
for node in bfs:
depth[node] = 0
for node in bfs:
for nei in path[node]:
next_node = match2[nei]
if next_node == -1:
break
if depth[next_node] == -1:
depth[next_node] = depth[node] + 1
bfs.append(next_node)
else:
continue
break
else:
break
pointer = [len(c) for c in path]
dfs = [node for node in range(n) if depth[node] == 0]
while dfs:
node = dfs[-1]
while pointer[node]:
pointer[node] -= 1
nei = path[node][pointer[node]]
next_node = match2[nei]
if next_node == -1:
while nei != -1:
node = dfs.pop()
match2[nei], match1[node], nei = node, nei, match1[node]
break
elif depth[node] + 1 == depth[next_node]:
dfs.append(next_node)
break
else:
dfs.pop()
return match1
def fac(x):
ans = []
while not x%2:
x //= 2
ans.append(2)
for i in range(3,int(x**0.5)+1,2):
while not x%i:
x //= i
ans.append(i)
if x != 1:
ans.append(x)
return ans
def main():
n,m = map(int,input().split())
a = list(map(lambda xx:fac(int(xx)),input().split()))
tot = sum(len(a[i]) for i in range(0,n,2))
st,st1 = [0],[0]
for i in range(n):
if not i&1:
st.append(st[-1]+len(a[i]))
else:
st1.append(st1[-1]+len(a[i]))
path = [[] for _ in range(tot)]
for _ in range(m):
u,v = map(lambda xx:int(xx)-1,input().split())
if u&1:
u,v = v,u
for ind,i in enumerate(a[u]):
for ind1,j in enumerate(a[v]):
if i == j:
path[st[u//2]+ind].append(st1[v//2]+ind1)
match = matching(st[-1],st1[-1],path)
print(len(match)-match.count(-1))
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self,file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd,max(os.fstat(self._fd).st_size,BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0,2),self.buffer.write(b),self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd,max(os.fstat(self._fd).st_size,BUFSIZE))
self.newlines = b.count(b"\n")+(not b)
ptr = self.buffer.tell()
self.buffer.seek(0,2),self.buffer.write(b),self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd,self.buffer.getvalue())
self.buffer.truncate(0),self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self,file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s:self.buffer.write(s.encode("ascii"))
self.read = lambda:self.buffer.read().decode("ascii")
self.readline = lambda:self.buffer.readline().decode("ascii")
sys.stdin,sys.stdout = IOWrapper(sys.stdin),IOWrapper(sys.stdout)
input = lambda:sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | output | 1 | 100,713 | 12 | 201,427 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have written on a piece of paper an array of n positive integers a[1], a[2], ..., a[n] and m good pairs of integers (i1, j1), (i2, j2), ..., (im, jm). Each good pair (ik, jk) meets the following conditions: ik + jk is an odd number and 1 ≤ ik < jk ≤ n.
In one operation you can perform a sequence of actions:
* take one of the good pairs (ik, jk) and some integer v (v > 1), which divides both numbers a[ik] and a[jk];
* divide both numbers by v, i. e. perform the assignments: <image> and <image>.
Determine the maximum number of operations you can sequentially perform on the given array. Note that one pair may be used several times in the described operations.
Input
The first line contains two space-separated integers n, m (2 ≤ n ≤ 100, 1 ≤ m ≤ 100).
The second line contains n space-separated integers a[1], a[2], ..., a[n] (1 ≤ a[i] ≤ 109) — the description of the array.
The following m lines contain the description of good pairs. The k-th line contains two space-separated integers ik, jk (1 ≤ ik < jk ≤ n, ik + jk is an odd number).
It is guaranteed that all the good pairs are distinct.
Output
Output the answer for the problem.
Examples
Input
3 2
8 3 8
1 2
2 3
Output
0
Input
3 2
8 12 8
1 2
2 3
Output
2 | instruction | 0 | 100,714 | 12 | 201,428 |
Tags: flows, graph matchings, number theory
Correct Solution:
```
def g(i):
u[i] = 0
for j in p[i]:
if v[j] < 0 or u[v[j]] and g(v[j]):
v[j] = i
return 1
return 0
f = lambda: map(int, input().split())
n, m = f()
s = k = 0
d = [[]]
for i in f():
j = 2
t = []
while j * j <= i:
while i % j == 0:
t.append((j, k))
k += 1
i //= j
j += 1
if i > 1:
t.append((i, k))
k += 1
d.append(t)
p = [[] for i in range(k)]
for q in range(m):
a, b = f()
if b % 2: a, b = b, a
for x, i in d[a]:
for y, j in d[b]:
if x == y: p[i].append(j)
v = [-1] * k
for i in range(k):
u = [1] * k
s += g(i)
print(s)
``` | output | 1 | 100,714 | 12 | 201,429 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have written on a piece of paper an array of n positive integers a[1], a[2], ..., a[n] and m good pairs of integers (i1, j1), (i2, j2), ..., (im, jm). Each good pair (ik, jk) meets the following conditions: ik + jk is an odd number and 1 ≤ ik < jk ≤ n.
In one operation you can perform a sequence of actions:
* take one of the good pairs (ik, jk) and some integer v (v > 1), which divides both numbers a[ik] and a[jk];
* divide both numbers by v, i. e. perform the assignments: <image> and <image>.
Determine the maximum number of operations you can sequentially perform on the given array. Note that one pair may be used several times in the described operations.
Input
The first line contains two space-separated integers n, m (2 ≤ n ≤ 100, 1 ≤ m ≤ 100).
The second line contains n space-separated integers a[1], a[2], ..., a[n] (1 ≤ a[i] ≤ 109) — the description of the array.
The following m lines contain the description of good pairs. The k-th line contains two space-separated integers ik, jk (1 ≤ ik < jk ≤ n, ik + jk is an odd number).
It is guaranteed that all the good pairs are distinct.
Output
Output the answer for the problem.
Examples
Input
3 2
8 3 8
1 2
2 3
Output
0
Input
3 2
8 12 8
1 2
2 3
Output
2
Submitted Solution:
```
def f(a, b):
i = 2
while i != min(a, b) + 1:
if a % i == 0 and b % i == 0:
return i
i += 1
return 0
n, m = map(int, input().split())
a = [int(i) for i in input().split()]
b = [[int(i) for i in input().split()] for j in range(m)]
p = 1
i = 0
c = 0
count = 0
while c != m:
x = f(a[b[i][0] - 1], a[b[i][1] - 1])
if x:
a[b[i][0] - 1] //= x
a[b[i][1] - 1] //= x
count += 1
elif not x:
c += 1
i += 1
if i == m and c != m:
i = 0
c = 0
print(count)
``` | instruction | 0 | 100,716 | 12 | 201,432 |
No | output | 1 | 100,716 | 12 | 201,433 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have written on a piece of paper an array of n positive integers a[1], a[2], ..., a[n] and m good pairs of integers (i1, j1), (i2, j2), ..., (im, jm). Each good pair (ik, jk) meets the following conditions: ik + jk is an odd number and 1 ≤ ik < jk ≤ n.
In one operation you can perform a sequence of actions:
* take one of the good pairs (ik, jk) and some integer v (v > 1), which divides both numbers a[ik] and a[jk];
* divide both numbers by v, i. e. perform the assignments: <image> and <image>.
Determine the maximum number of operations you can sequentially perform on the given array. Note that one pair may be used several times in the described operations.
Input
The first line contains two space-separated integers n, m (2 ≤ n ≤ 100, 1 ≤ m ≤ 100).
The second line contains n space-separated integers a[1], a[2], ..., a[n] (1 ≤ a[i] ≤ 109) — the description of the array.
The following m lines contain the description of good pairs. The k-th line contains two space-separated integers ik, jk (1 ≤ ik < jk ≤ n, ik + jk is an odd number).
It is guaranteed that all the good pairs are distinct.
Output
Output the answer for the problem.
Examples
Input
3 2
8 3 8
1 2
2 3
Output
0
Input
3 2
8 12 8
1 2
2 3
Output
2
Submitted Solution:
```
from math import gcd
import sys
def lcm(a, b):
return ((a*b) // gcd(a, b))
def aze(d):
if d==0:return(0)
ans=0
while d%2==0:
d//=2
ans+=1
i=3
while d!=1:
while d%i==0:
ans+=1
d//=i
i+=2
return(ans)
n,m=map(int,input().split())
a=list(map(int,input().split()))
if n==20 and m==10 and a==[512, 64, 536870912, 256, 1, 262144, 8 ,2097152 ,8192, 524288 ,32, 2 ,16 ,16777216, 524288 ,64, 268435456, 256, 67108864, 131072]:
print(65)
sys.exit()
graph=[[0 for i in range(n+2)] for i in range(n+2)]
for _ in range(m):
i,j=map(int,input().split())
g=gcd(a[i-1],a[j-1])
if i%2==0:
graph[i][j]=g
else:
graph[j][i]=g
for i in range(1,n+1):
if i%2==0:
c=1
for j in range(1,n+2,2):
if graph[i][j]!=0:
c=lcm(c,graph[i][j])
graph[0][i]=c
else:
c=1
for j in range(2,n+2,2):
if graph[j][i]!=0:
c=lcm(c,graph[j][i])
graph[i][n+1]=c
for i in range(n+2):
for j in range(n+2):
graph[i][j]=aze(graph[i][j])
def dfs(s,t):
q=[s]
v=[False for i in range(n+2)]
while q:
x=q.pop()
v[x]=True
if x==t:return(True)
for y in range(n+2):
if v[y] or graph[x][y]==0:continue
parent[y]=x
q.append(y)
return False
inf=float("INF")
parent=[-1 for i in range(n+2)]
def flow(s,t):
flow_ans=0
while dfs(s,t):
flow_path=inf
c=t
while c!=s:
u=parent[c]
flow_path=min(flow_path,graph[u][c])
c=u
c=t
while c!=s:
u=parent[c]
graph[u][c]-=flow_path
graph[c][u]+=flow_path
c=u
flow_ans+=flow_path
return(flow_ans)
print(flow(0,n+1))
``` | instruction | 0 | 100,718 | 12 | 201,436 |
No | output | 1 | 100,718 | 12 | 201,437 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a1, a2, ..., an consisting of n integers, and an integer k. You have to split the array into exactly k non-empty subsegments. You'll then compute the minimum integer on each subsegment, and take the maximum integer over the k obtained minimums. What is the maximum possible integer you can get?
Definitions of subsegment and array splitting are given in notes.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105) — the size of the array a and the number of subsegments you have to split the array to.
The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print single integer — the maximum possible integer you can get if you split the array into k non-empty subsegments and take maximum of minimums on the subsegments.
Examples
Input
5 2
1 2 3 4 5
Output
5
Input
5 1
-4 -5 -3 -2 -1
Output
-5
Note
A subsegment [l, r] (l ≤ r) of array a is the sequence al, al + 1, ..., ar.
Splitting of array a of n elements into k subsegments [l1, r1], [l2, r2], ..., [lk, rk] (l1 = 1, rk = n, li = ri - 1 + 1 for all i > 1) is k sequences (al1, ..., ar1), ..., (alk, ..., ark).
In the first example you should split the array into subsegments [1, 4] and [5, 5] that results in sequences (1, 2, 3, 4) and (5). The minimums are min(1, 2, 3, 4) = 1 and min(5) = 5. The resulting maximum is max(1, 5) = 5. It is obvious that you can't reach greater result.
In the second example the only option you have is to split the array into one subsegment [1, 5], that results in one sequence ( - 4, - 5, - 3, - 2, - 1). The only minimum is min( - 4, - 5, - 3, - 2, - 1) = - 5. The resulting maximum is - 5. | instruction | 0 | 100,854 | 12 | 201,708 |
Tags: greedy
Correct Solution:
```
n, k = map(int, input().split(' '))
arr = list(map(int, input().split(' ')))
if k > 2:
print(sorted(arr)[-1])
elif k == 2:
if arr[0] > arr[-1]:
print(arr[0])
else:
print(arr[-1])
elif k == 1:
print(sorted(arr)[0])
``` | output | 1 | 100,854 | 12 | 201,709 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a1, a2, ..., an consisting of n integers, and an integer k. You have to split the array into exactly k non-empty subsegments. You'll then compute the minimum integer on each subsegment, and take the maximum integer over the k obtained minimums. What is the maximum possible integer you can get?
Definitions of subsegment and array splitting are given in notes.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105) — the size of the array a and the number of subsegments you have to split the array to.
The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print single integer — the maximum possible integer you can get if you split the array into k non-empty subsegments and take maximum of minimums on the subsegments.
Examples
Input
5 2
1 2 3 4 5
Output
5
Input
5 1
-4 -5 -3 -2 -1
Output
-5
Note
A subsegment [l, r] (l ≤ r) of array a is the sequence al, al + 1, ..., ar.
Splitting of array a of n elements into k subsegments [l1, r1], [l2, r2], ..., [lk, rk] (l1 = 1, rk = n, li = ri - 1 + 1 for all i > 1) is k sequences (al1, ..., ar1), ..., (alk, ..., ark).
In the first example you should split the array into subsegments [1, 4] and [5, 5] that results in sequences (1, 2, 3, 4) and (5). The minimums are min(1, 2, 3, 4) = 1 and min(5) = 5. The resulting maximum is max(1, 5) = 5. It is obvious that you can't reach greater result.
In the second example the only option you have is to split the array into one subsegment [1, 5], that results in one sequence ( - 4, - 5, - 3, - 2, - 1). The only minimum is min( - 4, - 5, - 3, - 2, - 1) = - 5. The resulting maximum is - 5. | instruction | 0 | 100,855 | 12 | 201,710 |
Tags: greedy
Correct Solution:
```
n,k=map(int,input().split())
a=list(map(int,input().split()))
if k==1:
print(min(a)) #vibora net - minimum
elif k==2:
if a[0]>=a[n-1]:
print(a[0])
else: # mojno videlit krainiy
print(a[n-1])
elif k%2==1:
print(max(a)) # mojno videlit max v 1[]
else:
print(max(a)) #4 and more k
``` | output | 1 | 100,855 | 12 | 201,711 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a1, a2, ..., an consisting of n integers, and an integer k. You have to split the array into exactly k non-empty subsegments. You'll then compute the minimum integer on each subsegment, and take the maximum integer over the k obtained minimums. What is the maximum possible integer you can get?
Definitions of subsegment and array splitting are given in notes.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105) — the size of the array a and the number of subsegments you have to split the array to.
The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print single integer — the maximum possible integer you can get if you split the array into k non-empty subsegments and take maximum of minimums on the subsegments.
Examples
Input
5 2
1 2 3 4 5
Output
5
Input
5 1
-4 -5 -3 -2 -1
Output
-5
Note
A subsegment [l, r] (l ≤ r) of array a is the sequence al, al + 1, ..., ar.
Splitting of array a of n elements into k subsegments [l1, r1], [l2, r2], ..., [lk, rk] (l1 = 1, rk = n, li = ri - 1 + 1 for all i > 1) is k sequences (al1, ..., ar1), ..., (alk, ..., ark).
In the first example you should split the array into subsegments [1, 4] and [5, 5] that results in sequences (1, 2, 3, 4) and (5). The minimums are min(1, 2, 3, 4) = 1 and min(5) = 5. The resulting maximum is max(1, 5) = 5. It is obvious that you can't reach greater result.
In the second example the only option you have is to split the array into one subsegment [1, 5], that results in one sequence ( - 4, - 5, - 3, - 2, - 1). The only minimum is min( - 4, - 5, - 3, - 2, - 1) = - 5. The resulting maximum is - 5. | instruction | 0 | 100,856 | 12 | 201,712 |
Tags: greedy
Correct Solution:
```
nums = input().split()
nums = [int(x) for x in nums]
other_nums = input().split()
other_nums = [int(x) for x in other_nums]
if nums[1] == 1:
print(min(other_nums))
elif nums[1] == 2:
first = other_nums[0]
last = other_nums[-1]
if first < last:
print(last)
else:
print(first)
elif nums[1] >= 3:
print(max(other_nums))
``` | output | 1 | 100,856 | 12 | 201,713 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a1, a2, ..., an consisting of n integers, and an integer k. You have to split the array into exactly k non-empty subsegments. You'll then compute the minimum integer on each subsegment, and take the maximum integer over the k obtained minimums. What is the maximum possible integer you can get?
Definitions of subsegment and array splitting are given in notes.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105) — the size of the array a and the number of subsegments you have to split the array to.
The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print single integer — the maximum possible integer you can get if you split the array into k non-empty subsegments and take maximum of minimums on the subsegments.
Examples
Input
5 2
1 2 3 4 5
Output
5
Input
5 1
-4 -5 -3 -2 -1
Output
-5
Note
A subsegment [l, r] (l ≤ r) of array a is the sequence al, al + 1, ..., ar.
Splitting of array a of n elements into k subsegments [l1, r1], [l2, r2], ..., [lk, rk] (l1 = 1, rk = n, li = ri - 1 + 1 for all i > 1) is k sequences (al1, ..., ar1), ..., (alk, ..., ark).
In the first example you should split the array into subsegments [1, 4] and [5, 5] that results in sequences (1, 2, 3, 4) and (5). The minimums are min(1, 2, 3, 4) = 1 and min(5) = 5. The resulting maximum is max(1, 5) = 5. It is obvious that you can't reach greater result.
In the second example the only option you have is to split the array into one subsegment [1, 5], that results in one sequence ( - 4, - 5, - 3, - 2, - 1). The only minimum is min( - 4, - 5, - 3, - 2, - 1) = - 5. The resulting maximum is - 5. | instruction | 0 | 100,857 | 12 | 201,714 |
Tags: greedy
Correct Solution:
```
first_line = input().split(" ")
array_size = int(first_line[0])
subsegments = int(first_line[1])
# print(subsegments)
array = input().split(" ")
desired_array = [int(numeric_string) for numeric_string in array]
int_array = [int(numeric_string) for numeric_string in array]
desired_array.sort(reverse=True)
# print(subsegments)
if (subsegments == 1):
print(desired_array[-1])
elif (subsegments >= 3):
print(desired_array[0])
else:
if (int_array[0] > int_array[-1]):
print(int_array[0])
else:
print(int_array[-1])
``` | output | 1 | 100,857 | 12 | 201,715 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a1, a2, ..., an consisting of n integers, and an integer k. You have to split the array into exactly k non-empty subsegments. You'll then compute the minimum integer on each subsegment, and take the maximum integer over the k obtained minimums. What is the maximum possible integer you can get?
Definitions of subsegment and array splitting are given in notes.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105) — the size of the array a and the number of subsegments you have to split the array to.
The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print single integer — the maximum possible integer you can get if you split the array into k non-empty subsegments and take maximum of minimums on the subsegments.
Examples
Input
5 2
1 2 3 4 5
Output
5
Input
5 1
-4 -5 -3 -2 -1
Output
-5
Note
A subsegment [l, r] (l ≤ r) of array a is the sequence al, al + 1, ..., ar.
Splitting of array a of n elements into k subsegments [l1, r1], [l2, r2], ..., [lk, rk] (l1 = 1, rk = n, li = ri - 1 + 1 for all i > 1) is k sequences (al1, ..., ar1), ..., (alk, ..., ark).
In the first example you should split the array into subsegments [1, 4] and [5, 5] that results in sequences (1, 2, 3, 4) and (5). The minimums are min(1, 2, 3, 4) = 1 and min(5) = 5. The resulting maximum is max(1, 5) = 5. It is obvious that you can't reach greater result.
In the second example the only option you have is to split the array into one subsegment [1, 5], that results in one sequence ( - 4, - 5, - 3, - 2, - 1). The only minimum is min( - 4, - 5, - 3, - 2, - 1) = - 5. The resulting maximum is - 5. | instruction | 0 | 100,858 | 12 | 201,716 |
Tags: greedy
Correct Solution:
```
n, k = map(int, input().split())
a = list(map(int, input().split()))
mx = a.index(max(a))
nk = n - k
RL = []
if mx - nk < 0:
st = 0
else:
st = mx - nk
if mx + nk > n - 1:
en = n - 1
else:
en = mx + nk
if k == 1:
print(min(a))
elif k == 2:
print(max(a[0], a[n - 1]))
else:
for i in range(st, mx + 1):
RL.append(a[i])
for j in range(mx, en + 1):
RL.append(a[j])
print(max(RL))
``` | output | 1 | 100,858 | 12 | 201,717 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a1, a2, ..., an consisting of n integers, and an integer k. You have to split the array into exactly k non-empty subsegments. You'll then compute the minimum integer on each subsegment, and take the maximum integer over the k obtained minimums. What is the maximum possible integer you can get?
Definitions of subsegment and array splitting are given in notes.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105) — the size of the array a and the number of subsegments you have to split the array to.
The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print single integer — the maximum possible integer you can get if you split the array into k non-empty subsegments and take maximum of minimums on the subsegments.
Examples
Input
5 2
1 2 3 4 5
Output
5
Input
5 1
-4 -5 -3 -2 -1
Output
-5
Note
A subsegment [l, r] (l ≤ r) of array a is the sequence al, al + 1, ..., ar.
Splitting of array a of n elements into k subsegments [l1, r1], [l2, r2], ..., [lk, rk] (l1 = 1, rk = n, li = ri - 1 + 1 for all i > 1) is k sequences (al1, ..., ar1), ..., (alk, ..., ark).
In the first example you should split the array into subsegments [1, 4] and [5, 5] that results in sequences (1, 2, 3, 4) and (5). The minimums are min(1, 2, 3, 4) = 1 and min(5) = 5. The resulting maximum is max(1, 5) = 5. It is obvious that you can't reach greater result.
In the second example the only option you have is to split the array into one subsegment [1, 5], that results in one sequence ( - 4, - 5, - 3, - 2, - 1). The only minimum is min( - 4, - 5, - 3, - 2, - 1) = - 5. The resulting maximum is - 5. | instruction | 0 | 100,859 | 12 | 201,718 |
Tags: greedy
Correct Solution:
```
n,k=map(int,input().split())
l=list(map(int,input().split()))
M=max(l)
m=min(l)
if k==1:
print(m)
elif k>=3:
print(M)
else:
if l.index(M)==0 or l.index(M)==len(l)-1:
print(M)
else :
if l.index(m)==0:
print(l[len(l)-1])
elif l.index(m)==len(l)-1:
print(l[0])
else :
print(max(l[0],l[len(l)-1]))
``` | output | 1 | 100,859 | 12 | 201,719 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a1, a2, ..., an consisting of n integers, and an integer k. You have to split the array into exactly k non-empty subsegments. You'll then compute the minimum integer on each subsegment, and take the maximum integer over the k obtained minimums. What is the maximum possible integer you can get?
Definitions of subsegment and array splitting are given in notes.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105) — the size of the array a and the number of subsegments you have to split the array to.
The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print single integer — the maximum possible integer you can get if you split the array into k non-empty subsegments and take maximum of minimums on the subsegments.
Examples
Input
5 2
1 2 3 4 5
Output
5
Input
5 1
-4 -5 -3 -2 -1
Output
-5
Note
A subsegment [l, r] (l ≤ r) of array a is the sequence al, al + 1, ..., ar.
Splitting of array a of n elements into k subsegments [l1, r1], [l2, r2], ..., [lk, rk] (l1 = 1, rk = n, li = ri - 1 + 1 for all i > 1) is k sequences (al1, ..., ar1), ..., (alk, ..., ark).
In the first example you should split the array into subsegments [1, 4] and [5, 5] that results in sequences (1, 2, 3, 4) and (5). The minimums are min(1, 2, 3, 4) = 1 and min(5) = 5. The resulting maximum is max(1, 5) = 5. It is obvious that you can't reach greater result.
In the second example the only option you have is to split the array into one subsegment [1, 5], that results in one sequence ( - 4, - 5, - 3, - 2, - 1). The only minimum is min( - 4, - 5, - 3, - 2, - 1) = - 5. The resulting maximum is - 5. | instruction | 0 | 100,860 | 12 | 201,720 |
Tags: greedy
Correct Solution:
```
n , m = map(int , input().split())
li = list(map(int , input().split()))
if m == 1 :
print(min(li))
elif m == 2 :
print(max(li[0], li[-1]))
else:
print(max(li))
``` | output | 1 | 100,860 | 12 | 201,721 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a1, a2, ..., an consisting of n integers, and an integer k. You have to split the array into exactly k non-empty subsegments. You'll then compute the minimum integer on each subsegment, and take the maximum integer over the k obtained minimums. What is the maximum possible integer you can get?
Definitions of subsegment and array splitting are given in notes.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105) — the size of the array a and the number of subsegments you have to split the array to.
The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print single integer — the maximum possible integer you can get if you split the array into k non-empty subsegments and take maximum of minimums on the subsegments.
Examples
Input
5 2
1 2 3 4 5
Output
5
Input
5 1
-4 -5 -3 -2 -1
Output
-5
Note
A subsegment [l, r] (l ≤ r) of array a is the sequence al, al + 1, ..., ar.
Splitting of array a of n elements into k subsegments [l1, r1], [l2, r2], ..., [lk, rk] (l1 = 1, rk = n, li = ri - 1 + 1 for all i > 1) is k sequences (al1, ..., ar1), ..., (alk, ..., ark).
In the first example you should split the array into subsegments [1, 4] and [5, 5] that results in sequences (1, 2, 3, 4) and (5). The minimums are min(1, 2, 3, 4) = 1 and min(5) = 5. The resulting maximum is max(1, 5) = 5. It is obvious that you can't reach greater result.
In the second example the only option you have is to split the array into one subsegment [1, 5], that results in one sequence ( - 4, - 5, - 3, - 2, - 1). The only minimum is min( - 4, - 5, - 3, - 2, - 1) = - 5. The resulting maximum is - 5. | instruction | 0 | 100,861 | 12 | 201,722 |
Tags: greedy
Correct Solution:
```
a, c = map(int,input().split())
N = list(map(int,input().split()))
if c == 2:
print(max(N[-1],N[0]))
elif c > 1:
print(max(N))
else:
print(min(N))
``` | output | 1 | 100,861 | 12 | 201,723 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a1, a2, ..., an consisting of n integers, and an integer k. You have to split the array into exactly k non-empty subsegments. You'll then compute the minimum integer on each subsegment, and take the maximum integer over the k obtained minimums. What is the maximum possible integer you can get?
Definitions of subsegment and array splitting are given in notes.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105) — the size of the array a and the number of subsegments you have to split the array to.
The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print single integer — the maximum possible integer you can get if you split the array into k non-empty subsegments and take maximum of minimums on the subsegments.
Examples
Input
5 2
1 2 3 4 5
Output
5
Input
5 1
-4 -5 -3 -2 -1
Output
-5
Note
A subsegment [l, r] (l ≤ r) of array a is the sequence al, al + 1, ..., ar.
Splitting of array a of n elements into k subsegments [l1, r1], [l2, r2], ..., [lk, rk] (l1 = 1, rk = n, li = ri - 1 + 1 for all i > 1) is k sequences (al1, ..., ar1), ..., (alk, ..., ark).
In the first example you should split the array into subsegments [1, 4] and [5, 5] that results in sequences (1, 2, 3, 4) and (5). The minimums are min(1, 2, 3, 4) = 1 and min(5) = 5. The resulting maximum is max(1, 5) = 5. It is obvious that you can't reach greater result.
In the second example the only option you have is to split the array into one subsegment [1, 5], that results in one sequence ( - 4, - 5, - 3, - 2, - 1). The only minimum is min( - 4, - 5, - 3, - 2, - 1) = - 5. The resulting maximum is - 5.
Submitted Solution:
```
x = list(map(int, input().split()))
n = x[0]
k = x[1]
a = list(map(int, input().split()))
A = max(a)
if k == 1:
ans = min(a)
elif k == 2:
ans = max(a[0], a[-1])
else:
ans = A
print(ans)
``` | instruction | 0 | 100,862 | 12 | 201,724 |
Yes | output | 1 | 100,862 | 12 | 201,725 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a1, a2, ..., an consisting of n integers, and an integer k. You have to split the array into exactly k non-empty subsegments. You'll then compute the minimum integer on each subsegment, and take the maximum integer over the k obtained minimums. What is the maximum possible integer you can get?
Definitions of subsegment and array splitting are given in notes.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105) — the size of the array a and the number of subsegments you have to split the array to.
The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print single integer — the maximum possible integer you can get if you split the array into k non-empty subsegments and take maximum of minimums on the subsegments.
Examples
Input
5 2
1 2 3 4 5
Output
5
Input
5 1
-4 -5 -3 -2 -1
Output
-5
Note
A subsegment [l, r] (l ≤ r) of array a is the sequence al, al + 1, ..., ar.
Splitting of array a of n elements into k subsegments [l1, r1], [l2, r2], ..., [lk, rk] (l1 = 1, rk = n, li = ri - 1 + 1 for all i > 1) is k sequences (al1, ..., ar1), ..., (alk, ..., ark).
In the first example you should split the array into subsegments [1, 4] and [5, 5] that results in sequences (1, 2, 3, 4) and (5). The minimums are min(1, 2, 3, 4) = 1 and min(5) = 5. The resulting maximum is max(1, 5) = 5. It is obvious that you can't reach greater result.
In the second example the only option you have is to split the array into one subsegment [1, 5], that results in one sequence ( - 4, - 5, - 3, - 2, - 1). The only minimum is min( - 4, - 5, - 3, - 2, - 1) = - 5. The resulting maximum is - 5.
Submitted Solution:
```
a = [int(s) for s in input().split()]
b = [int(s) for s in input().split()]
if (a[1] == 1):
minimum = b[0]
for i in range(a[0]):
if (minimum > b[i]):
minimum = b[i]
print(minimum)
elif (a[1] >= 3):
maximum = b[0]
for i in range(a[0]):
if (maximum < b[i]):
maximum = b[i]
print(maximum)
elif (a[1] == 2 and a[0] == 2):
print(max(b[0], b[1]))
else:
print(max(b[0], b[a[0] - 1]))
``` | instruction | 0 | 100,863 | 12 | 201,726 |
Yes | output | 1 | 100,863 | 12 | 201,727 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a1, a2, ..., an consisting of n integers, and an integer k. You have to split the array into exactly k non-empty subsegments. You'll then compute the minimum integer on each subsegment, and take the maximum integer over the k obtained minimums. What is the maximum possible integer you can get?
Definitions of subsegment and array splitting are given in notes.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105) — the size of the array a and the number of subsegments you have to split the array to.
The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print single integer — the maximum possible integer you can get if you split the array into k non-empty subsegments and take maximum of minimums on the subsegments.
Examples
Input
5 2
1 2 3 4 5
Output
5
Input
5 1
-4 -5 -3 -2 -1
Output
-5
Note
A subsegment [l, r] (l ≤ r) of array a is the sequence al, al + 1, ..., ar.
Splitting of array a of n elements into k subsegments [l1, r1], [l2, r2], ..., [lk, rk] (l1 = 1, rk = n, li = ri - 1 + 1 for all i > 1) is k sequences (al1, ..., ar1), ..., (alk, ..., ark).
In the first example you should split the array into subsegments [1, 4] and [5, 5] that results in sequences (1, 2, 3, 4) and (5). The minimums are min(1, 2, 3, 4) = 1 and min(5) = 5. The resulting maximum is max(1, 5) = 5. It is obvious that you can't reach greater result.
In the second example the only option you have is to split the array into one subsegment [1, 5], that results in one sequence ( - 4, - 5, - 3, - 2, - 1). The only minimum is min( - 4, - 5, - 3, - 2, - 1) = - 5. The resulting maximum is - 5.
Submitted Solution:
```
s = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
n = s[0]
k = s[1]
if k == 1:
print(min(a))
elif k == 2:
print(max(a[-1], a[0]))
else:
print(max(a))
``` | instruction | 0 | 100,864 | 12 | 201,728 |
Yes | output | 1 | 100,864 | 12 | 201,729 |
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 a1, a2, ..., an consisting of n integers, and an integer k. You have to split the array into exactly k non-empty subsegments. You'll then compute the minimum integer on each subsegment, and take the maximum integer over the k obtained minimums. What is the maximum possible integer you can get?
Definitions of subsegment and array splitting are given in notes.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105) — the size of the array a and the number of subsegments you have to split the array to.
The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print single integer — the maximum possible integer you can get if you split the array into k non-empty subsegments and take maximum of minimums on the subsegments.
Examples
Input
5 2
1 2 3 4 5
Output
5
Input
5 1
-4 -5 -3 -2 -1
Output
-5
Note
A subsegment [l, r] (l ≤ r) of array a is the sequence al, al + 1, ..., ar.
Splitting of array a of n elements into k subsegments [l1, r1], [l2, r2], ..., [lk, rk] (l1 = 1, rk = n, li = ri - 1 + 1 for all i > 1) is k sequences (al1, ..., ar1), ..., (alk, ..., ark).
In the first example you should split the array into subsegments [1, 4] and [5, 5] that results in sequences (1, 2, 3, 4) and (5). The minimums are min(1, 2, 3, 4) = 1 and min(5) = 5. The resulting maximum is max(1, 5) = 5. It is obvious that you can't reach greater result.
In the second example the only option you have is to split the array into one subsegment [1, 5], that results in one sequence ( - 4, - 5, - 3, - 2, - 1). The only minimum is min( - 4, - 5, - 3, - 2, - 1) = - 5. The resulting maximum is - 5.
Submitted Solution:
```
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
m=0
if k==1:
print(min(a))
elif k>=3:
print(max(a))
else:
print(max(a[0],a[-1]))
``` | instruction | 0 | 100,865 | 12 | 201,730 |
Yes | output | 1 | 100,865 | 12 | 201,731 |
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 a1, a2, ..., an consisting of n integers, and an integer k. You have to split the array into exactly k non-empty subsegments. You'll then compute the minimum integer on each subsegment, and take the maximum integer over the k obtained minimums. What is the maximum possible integer you can get?
Definitions of subsegment and array splitting are given in notes.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105) — the size of the array a and the number of subsegments you have to split the array to.
The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print single integer — the maximum possible integer you can get if you split the array into k non-empty subsegments and take maximum of minimums on the subsegments.
Examples
Input
5 2
1 2 3 4 5
Output
5
Input
5 1
-4 -5 -3 -2 -1
Output
-5
Note
A subsegment [l, r] (l ≤ r) of array a is the sequence al, al + 1, ..., ar.
Splitting of array a of n elements into k subsegments [l1, r1], [l2, r2], ..., [lk, rk] (l1 = 1, rk = n, li = ri - 1 + 1 for all i > 1) is k sequences (al1, ..., ar1), ..., (alk, ..., ark).
In the first example you should split the array into subsegments [1, 4] and [5, 5] that results in sequences (1, 2, 3, 4) and (5). The minimums are min(1, 2, 3, 4) = 1 and min(5) = 5. The resulting maximum is max(1, 5) = 5. It is obvious that you can't reach greater result.
In the second example the only option you have is to split the array into one subsegment [1, 5], that results in one sequence ( - 4, - 5, - 3, - 2, - 1). The only minimum is min( - 4, - 5, - 3, - 2, - 1) = - 5. The resulting maximum is - 5.
Submitted Solution:
```
n, k = map(int, input().split(' '))
inp = input()
if k == 2:
print(max(int(inp[0]), int(inp[-1])))
else:
a = list(map(int, inp.split(' ')))
if k == 1:
print(min(a))
else:
print(max(a))
``` | instruction | 0 | 100,866 | 12 | 201,732 |
No | output | 1 | 100,866 | 12 | 201,733 |
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 a1, a2, ..., an consisting of n integers, and an integer k. You have to split the array into exactly k non-empty subsegments. You'll then compute the minimum integer on each subsegment, and take the maximum integer over the k obtained minimums. What is the maximum possible integer you can get?
Definitions of subsegment and array splitting are given in notes.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105) — the size of the array a and the number of subsegments you have to split the array to.
The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print single integer — the maximum possible integer you can get if you split the array into k non-empty subsegments and take maximum of minimums on the subsegments.
Examples
Input
5 2
1 2 3 4 5
Output
5
Input
5 1
-4 -5 -3 -2 -1
Output
-5
Note
A subsegment [l, r] (l ≤ r) of array a is the sequence al, al + 1, ..., ar.
Splitting of array a of n elements into k subsegments [l1, r1], [l2, r2], ..., [lk, rk] (l1 = 1, rk = n, li = ri - 1 + 1 for all i > 1) is k sequences (al1, ..., ar1), ..., (alk, ..., ark).
In the first example you should split the array into subsegments [1, 4] and [5, 5] that results in sequences (1, 2, 3, 4) and (5). The minimums are min(1, 2, 3, 4) = 1 and min(5) = 5. The resulting maximum is max(1, 5) = 5. It is obvious that you can't reach greater result.
In the second example the only option you have is to split the array into one subsegment [1, 5], that results in one sequence ( - 4, - 5, - 3, - 2, - 1). The only minimum is min( - 4, - 5, - 3, - 2, - 1) = - 5. The resulting maximum is - 5.
Submitted Solution:
```
a,b=map(int,input().split(' '))
arr=list(map(int,input().split(' ')))
m=arr
arr.sort()
if b==1:
print(arr[0])
elif b==2:
print(max(arr[-1],arr[0]))
else:
print(arr[-1])
``` | instruction | 0 | 100,867 | 12 | 201,734 |
No | output | 1 | 100,867 | 12 | 201,735 |
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 a1, a2, ..., an consisting of n integers, and an integer k. You have to split the array into exactly k non-empty subsegments. You'll then compute the minimum integer on each subsegment, and take the maximum integer over the k obtained minimums. What is the maximum possible integer you can get?
Definitions of subsegment and array splitting are given in notes.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105) — the size of the array a and the number of subsegments you have to split the array to.
The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print single integer — the maximum possible integer you can get if you split the array into k non-empty subsegments and take maximum of minimums on the subsegments.
Examples
Input
5 2
1 2 3 4 5
Output
5
Input
5 1
-4 -5 -3 -2 -1
Output
-5
Note
A subsegment [l, r] (l ≤ r) of array a is the sequence al, al + 1, ..., ar.
Splitting of array a of n elements into k subsegments [l1, r1], [l2, r2], ..., [lk, rk] (l1 = 1, rk = n, li = ri - 1 + 1 for all i > 1) is k sequences (al1, ..., ar1), ..., (alk, ..., ark).
In the first example you should split the array into subsegments [1, 4] and [5, 5] that results in sequences (1, 2, 3, 4) and (5). The minimums are min(1, 2, 3, 4) = 1 and min(5) = 5. The resulting maximum is max(1, 5) = 5. It is obvious that you can't reach greater result.
In the second example the only option you have is to split the array into one subsegment [1, 5], that results in one sequence ( - 4, - 5, - 3, - 2, - 1). The only minimum is min( - 4, - 5, - 3, - 2, - 1) = - 5. The resulting maximum is - 5.
Submitted Solution:
```
import sys
def greedy_solution(nums, num_set):
if num_set > 1:
return max(nums)
else:
return min(nums)
def main():
line = sys.stdin.readline().split()
num_int, num_set = int(line[0]), int(line[1])
line = sys.stdin.readline().split()
nums = [int(s) for s in line]
result = greedy_solution(nums, num_set)
sys.stdout.write("{}\n".format(result))
if __name__ == '__main__':
main()
``` | instruction | 0 | 100,868 | 12 | 201,736 |
No | output | 1 | 100,868 | 12 | 201,737 |
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 a1, a2, ..., an consisting of n integers, and an integer k. You have to split the array into exactly k non-empty subsegments. You'll then compute the minimum integer on each subsegment, and take the maximum integer over the k obtained minimums. What is the maximum possible integer you can get?
Definitions of subsegment and array splitting are given in notes.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 105) — the size of the array a and the number of subsegments you have to split the array to.
The second line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109).
Output
Print single integer — the maximum possible integer you can get if you split the array into k non-empty subsegments and take maximum of minimums on the subsegments.
Examples
Input
5 2
1 2 3 4 5
Output
5
Input
5 1
-4 -5 -3 -2 -1
Output
-5
Note
A subsegment [l, r] (l ≤ r) of array a is the sequence al, al + 1, ..., ar.
Splitting of array a of n elements into k subsegments [l1, r1], [l2, r2], ..., [lk, rk] (l1 = 1, rk = n, li = ri - 1 + 1 for all i > 1) is k sequences (al1, ..., ar1), ..., (alk, ..., ark).
In the first example you should split the array into subsegments [1, 4] and [5, 5] that results in sequences (1, 2, 3, 4) and (5). The minimums are min(1, 2, 3, 4) = 1 and min(5) = 5. The resulting maximum is max(1, 5) = 5. It is obvious that you can't reach greater result.
In the second example the only option you have is to split the array into one subsegment [1, 5], that results in one sequence ( - 4, - 5, - 3, - 2, - 1). The only minimum is min( - 4, - 5, - 3, - 2, - 1) = - 5. The resulting maximum is - 5.
Submitted Solution:
```
import sys;
#sys.stdin = open("input.txt", "r");
#sys.stdout = open("output.txt", "w");
def ria():
return [int(x) for x in input().split()];
n, k = (int(x) for x in input().split());
a = ria();
if ( k == 1 ):
ans = min(a);
if ( k == 2 ):
maks = -10000000;
for i in range(n):
if a[i] > maks:
maks = a[i];
pos = i;
if ( pos == 0 or pos == n-1 ):
ans = maks;
else:
ans = max(min(a[0:pos]), min(a[pos+1:n]));
if ( k > 2 ):
ans = max(a);
print(ans);
#sys.stdout.close();
``` | instruction | 0 | 100,869 | 12 | 201,738 |
No | output | 1 | 100,869 | 12 | 201,739 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nikita likes tasks on order statistics, for example, he can easily find the k-th number in increasing order on a segment of an array. But now Nikita wonders how many segments of an array there are such that a given number x is the k-th number in increasing order on this segment. In other words, you should find the number of segments of a given array such that there are exactly k numbers of this segment which are less than x.
Nikita wants to get answer for this question for each k from 0 to n, where n is the size of the array.
Input
The first line contains two integers n and x (1 ≤ n ≤ 2 ⋅ 10^5, -10^9 ≤ x ≤ 10^9).
The second line contains n integers a_1, a_2, …, a_n (-10^9 ≤ a_i ≤ 10^9) — the given array.
Output
Print n+1 integers, where the i-th number is the answer for Nikita's question for k=i-1.
Examples
Input
5 3
1 2 3 4 5
Output
6 5 4 0 0 0
Input
2 6
-5 9
Output
1 2 0
Input
6 99
-1 -1 -1 -1 -1 -1
Output
0 6 5 4 3 2 1 | instruction | 0 | 100,918 | 12 | 201,836 |
Tags: chinese remainder theorem, fft, math
Correct Solution:
```
from math import pi
from cmath import exp
def fft(a, lgN, rot=1): # rot=-1 for ifft
N = 1<<lgN
assert len(a)==N
rev = [0]*N
for i in range(N):
rev[i] = (rev[i>>1]>>1)+(i&1)*(N>>1)
A = [a[rev[i]] for i in range(N)]
h = 1
while h<N:
w_m = exp((0+1j) * rot * (pi / h))
for k in range(0, N, h<<1):
w = 1
for j in range(h):
t = w * A[k+j+h]
A[k+j+h] = A[k+j]-t
A[k+j] = A[k+j]+t
w *= w_m
h = h<<1
return A if rot==1 else [x/N for x in A]
import sys
ints = (int(x) for x in sys.stdin.read().split())
n, x = (next(ints) for i in range(2))
r = [next(ints) for i in range(n)]
ac = [0]*(n+1)
for i in range(n): ac[i+1] = (r[i]<x) + ac[i]
# Multiset addition
min_A, min_B = 0, -ac[-1]
max_A, max_B = ac[-1], 0
N, lgN, m = 1, 0, 2*max(max_A-min_A+1, max_B-min_B+1)
while N<m: N,lgN = N<<1,lgN+1
a, b = [0]*N, [0]*N
for x in ac:
a[x-min_A] += 1
b[-x-min_B] += 1
c = zip(fft(a, lgN), fft(b, lgN))
c = fft([x*y for x,y in c], lgN, rot=-1)
c = [round(x.real) for x in c][-min_A-min_B:][:n+1]
c[0] = sum((x*(x-1))//2 for x in a)
print(*c, *(0 for i in range(n+1-len(c))), flush=True)
``` | output | 1 | 100,918 | 12 | 201,837 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nikita likes tasks on order statistics, for example, he can easily find the k-th number in increasing order on a segment of an array. But now Nikita wonders how many segments of an array there are such that a given number x is the k-th number in increasing order on this segment. In other words, you should find the number of segments of a given array such that there are exactly k numbers of this segment which are less than x.
Nikita wants to get answer for this question for each k from 0 to n, where n is the size of the array.
Input
The first line contains two integers n and x (1 ≤ n ≤ 2 ⋅ 10^5, -10^9 ≤ x ≤ 10^9).
The second line contains n integers a_1, a_2, …, a_n (-10^9 ≤ a_i ≤ 10^9) — the given array.
Output
Print n+1 integers, where the i-th number is the answer for Nikita's question for k=i-1.
Examples
Input
5 3
1 2 3 4 5
Output
6 5 4 0 0 0
Input
2 6
-5 9
Output
1 2 0
Input
6 99
-1 -1 -1 -1 -1 -1
Output
0 6 5 4 3 2 1
Submitted Solution:
```
import sys
from math import pi
from cmath import exp
ints = (int(x) for x in sys.stdin.read().split())
def set_addition(a, b, subtract=False, round_places=None):
m = max(len(a), len(b))
n, k = 1, 0
while n<m: n,k = n<<1,k+1
n <<= 1; k += 1
a = a + [0]*(n-len(a))
b = (b[::-1] if subtract else b) + [0]*(n-len(b))
c = fft([x*y for x,y in zip(fft(a, k), fft(b, k))], k, rot=-1)
c = [round(x.real, round_places) for x in c]
c = c[::-1] if subtract else c
z = -(n//2)-1 if subtract else 0
return {i+z:c[i] for i in range(n) if c[i]}
def fft(a, lgN, rot=1): # rot=-1 for ifft
n = 1<<lgN ; assert len(a)==n
rev = lambda x: sum(((x>>i)&1)<<(lgN-1-i) for i in range(lgN))
A = [a[rev(i)] for i in range(n)]
for h in (1<<s for s in range(lgN)):
w_m = exp((0+1j) * rot * (pi / h))
for k in range(0, n, 2*h):
w = 1
for j in range(h):
t = w * A[k+j+h]
A[k+j+h], A[k+j] = A[k+j]-t, A[k+j]+t
w *= w_m
return A if rot==1 else [x/n for x in A]
n,x = (next(ints) for i in range(2))
a = [next(ints) for i in range(n)]
t = [0]*(n+1)
ac = 0
t[0] += 1
for i in range(n):
ac = (a[i]<x) + ac
t[ac]+=1
while t[-1]==0:
t.pop()
ans = set_addition(t, t, subtract=True)
ans[0] = sum((x*(x-1))//2 for x in t)
print(*(ans.get(i,0) for i in range(n+1)))
``` | instruction | 0 | 100,919 | 12 | 201,838 |
No | output | 1 | 100,919 | 12 | 201,839 |
Provide a correct Python 3 solution for this coding contest problem.
A permutation of N numbers from 1 to N A1, A2, ……, AN is given. You can perform the operation reverse (i, j) to reverse the order of the numbers in the interval [i, j] (1 ≤ i ≤ j ≤ N) for this permutation. For example, if reverse (2, 4) is applied to [1, 2, 3, 4, 5], it becomes [1, 4, 3, 2, 5]. Calculate how many operations you need to do at a minimum to get the permutation sorted in ascending order.
Constraints
* N is an integer
* 2 ≤ N ≤ 10
Input
The input is given in the following format.
> N
> A1 A2 …… AN
>
Output
Print the solution to the problem on one line.
Examples
Input
5
1 4 3 5 2
Output
2
Input
5
3 1 5 2 4
Output
4
Input
3
1 2 3
Output
0
Input
10
3 1 5 2 7 4 9 6 10 8
Output
9 | instruction | 0 | 101,144 | 12 | 202,288 |
"Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**13
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
def f(n):
a = LI()
def search(s,t):
n2 = 4
d = collections.defaultdict(lambda: inf)
d[s] = 0
q = []
heapq.heappush(q, (0, s))
v = collections.defaultdict(bool)
while len(q):
k, u = heapq.heappop(q)
if v[u]:
continue
v[u] = True
if u == t:
return k
vd = k + 1
for i in range(n):
for j in range(i+1,n):
uv = tuple(u[:i] + u[i:j+1][::-1] + u[j+1:])
if v[uv]:
continue
if d[uv] > vd:
d[uv] = vd
if vd < 4:
heapq.heappush(q, (vd, uv))
return d
r1 = search(tuple(a), tuple(range(1,n+1)))
if isinstance(r1, int):
return r1
r2 = search(tuple(range(1,n+1)), tuple(a))
r = n - 1
for k,v in r1.items():
t = v + r2[k]
if r > t:
r = t
return r
while 1:
n = I()
if n == 0:
break
rr.append(f(n))
# print('rr', rr[-1])
break
return '\n'.join(map(str,rr))
print(main())
``` | output | 1 | 101,144 | 12 | 202,289 |
Provide a correct Python 3 solution for this coding contest problem.
A permutation of N numbers from 1 to N A1, A2, ……, AN is given. You can perform the operation reverse (i, j) to reverse the order of the numbers in the interval [i, j] (1 ≤ i ≤ j ≤ N) for this permutation. For example, if reverse (2, 4) is applied to [1, 2, 3, 4, 5], it becomes [1, 4, 3, 2, 5]. Calculate how many operations you need to do at a minimum to get the permutation sorted in ascending order.
Constraints
* N is an integer
* 2 ≤ N ≤ 10
Input
The input is given in the following format.
> N
> A1 A2 …… AN
>
Output
Print the solution to the problem on one line.
Examples
Input
5
1 4 3 5 2
Output
2
Input
5
3 1 5 2 4
Output
4
Input
3
1 2 3
Output
0
Input
10
3 1 5 2 7 4 9 6 10 8
Output
9 | instruction | 0 | 101,145 | 12 | 202,290 |
"Correct Solution:
```
from functools import lru_cache
import sys
from collections import deque
sys.setrecursionlimit(1000000)
sorted_a = ""
m = dict({})
N = int(input())
A = ''.join(list(map(lambda x: str(int(x)-1), input().split())))
sorted_a = ''.join(list(sorted(A)))
q = deque()
q.append((A, 0))
m[A] = 0
while True:
a, x = q.popleft()
if a in m and m[a] < x:
continue
if x == (len(a)-1) // 2:
break;
for i in range(len(a)):
for j in range(i+2, len(a)+1):
next_a = a[:i:] + a[::-1][len(a)-j:len(a)-i:] + a[j::]
if next_a in m:
continue
q.append((next_a, x+1))
m[next_a] = x+1
m2 = dict({})
q = deque()
q.append((sorted_a, 0))
m2[sorted_a] = 0
while True:
a, x = q.popleft()
if a in m2 and m2[a] < x:
continue
if x == (len(a)-1) // 2:
break;
for i in range(len(a)):
for j in range(i+2, len(a)+1):
next_a = a[:i:] + a[::-1][len(a)-j:len(a)-i:] + a[j::]
if next_a in m2:
continue
q.append((next_a, x+1))
m2[next_a] = x+1
ret = sys.maxsize
for a, x in m.items():
if a in m2:
ret = min(ret, x + m2[a])
if ret == sys.maxsize:
print(len(A) - 1)
else:
print(ret)
``` | output | 1 | 101,145 | 12 | 202,291 |
Provide a correct Python 3 solution for this coding contest problem.
A permutation of N numbers from 1 to N A1, A2, ……, AN is given. You can perform the operation reverse (i, j) to reverse the order of the numbers in the interval [i, j] (1 ≤ i ≤ j ≤ N) for this permutation. For example, if reverse (2, 4) is applied to [1, 2, 3, 4, 5], it becomes [1, 4, 3, 2, 5]. Calculate how many operations you need to do at a minimum to get the permutation sorted in ascending order.
Constraints
* N is an integer
* 2 ≤ N ≤ 10
Input
The input is given in the following format.
> N
> A1 A2 …… AN
>
Output
Print the solution to the problem on one line.
Examples
Input
5
1 4 3 5 2
Output
2
Input
5
3 1 5 2 4
Output
4
Input
3
1 2 3
Output
0
Input
10
3 1 5 2 7 4 9 6 10 8
Output
9 | instruction | 0 | 101,146 | 12 | 202,292 |
"Correct Solution:
```
from heapq import heappush, heappop
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
N = int(readline())
INF = 10**9
A = tuple(map(int, readline().split()))
B = tuple(range(1, N+1))
def check(N, A, N1):
que = [(0, A)]
dist = {A: 0}
S = [A]
B = list(A)
for cost in range(N1):
T = []
for v in S:
if dist[v] < cost:
continue
for i in range(N):
B[:] = v
for j in range(i+1, N):
B[i:j+1] = reversed(v[i:j+1])
key = tuple(B)
if cost+1 < dist.get(key, N1+1):
dist[key] = cost+1
T.append(key)
S = T
return dist
D0 = check(N, A, (N-1)//2)
D1 = check(N, B, (N-1)//2)
ans = N-1
for state, v in D0.items():
if state in D1:
ans = min(ans, v + D1[state])
write("%d\n" % ans)
solve()
``` | output | 1 | 101,146 | 12 | 202,293 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation of N numbers from 1 to N A1, A2, ……, AN is given. You can perform the operation reverse (i, j) to reverse the order of the numbers in the interval [i, j] (1 ≤ i ≤ j ≤ N) for this permutation. For example, if reverse (2, 4) is applied to [1, 2, 3, 4, 5], it becomes [1, 4, 3, 2, 5]. Calculate how many operations you need to do at a minimum to get the permutation sorted in ascending order.
Constraints
* N is an integer
* 2 ≤ N ≤ 10
Input
The input is given in the following format.
> N
> A1 A2 …… AN
>
Output
Print the solution to the problem on one line.
Examples
Input
5
1 4 3 5 2
Output
2
Input
5
3 1 5 2 4
Output
4
Input
3
1 2 3
Output
0
Input
10
3 1 5 2 7 4 9 6 10 8
Output
9
Submitted Solution:
```
from functools import lru_cache
import sys
from collections import deque
sys.setrecursionlimit(1000000)
sorted_a = ""
m = dict({})
def dist_a(a):
res = 0
for i, x in enumerate(a):
res += abs(i - int(x))
return res
N = int(input())
A = ''.join(list(map(lambda x: str(int(x)-1), input().split())))
sorted_a = ''.join(list(sorted(A)))
#i = 1
#j = 4
#x = "03214"
#print(A[:i:])
#print(A[::-1][len(A)-j:len(A)-i:])
#print(A[j::])
#print(x[:i:] + x[::-1][len(x)-j:len(x)-i:] + x[j::])
q = deque()
q.append((A, 0))
m[A] = 0
while True:
a, x = q.popleft()
if a in m and m[a] < x:
continue
#if x == 4:
# break;
#print(len(m))
if a == sorted_a:
print(x)
break
d_a = dist_a(a)
for i in range(len(a)):
for j in range(i+2, len(a)+1):
next_a = a[:i:] + a[::-1][len(a)-j:len(a)-i:] + a[j::]
if next_a in m:
continue
if d_a < dist_a(next_a):
continue
q.append((next_a, x+1))
m[next_a] = x+1
#print(reverse_a(A, 0))
``` | instruction | 0 | 101,147 | 12 | 202,294 |
No | output | 1 | 101,147 | 12 | 202,295 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Toad Zitz has an array of integers, each integer is between 0 and m-1 inclusive. The integers are a_1, a_2, …, a_n.
In one operation Zitz can choose an integer k and k indices i_1, i_2, …, i_k such that 1 ≤ i_1 < i_2 < … < i_k ≤ n. He should then change a_{i_j} to ((a_{i_j}+1) mod m) for each chosen integer i_j. The integer m is fixed for all operations and indices.
Here x mod y denotes the remainder of the division of x by y.
Zitz wants to make his array non-decreasing with the minimum number of such operations. Find this minimum number of operations.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 300 000) — the number of integers in the array and the parameter m.
The next line contains n space-separated integers a_1, a_2, …, a_n (0 ≤ a_i < m) — the given array.
Output
Output one integer: the minimum number of described operations Zitz needs to make his array non-decreasing. If no operations required, print 0.
It is easy to see that with enough operations Zitz can always make his array non-decreasing.
Examples
Input
5 3
0 0 0 1 2
Output
0
Input
5 7
0 6 1 3 2
Output
1
Note
In the first example, the array is already non-decreasing, so the answer is 0.
In the second example, you can choose k=2, i_1 = 2, i_2 = 5, the array becomes [0,0,1,3,3]. It is non-decreasing, so the answer is 1. | instruction | 0 | 101,254 | 12 | 202,508 |
Tags: binary search, greedy
Correct Solution:
```
import sys
import math
from itertools import permutations
input = sys.stdin.readline
n,m=map(int,input().split())
def binarySearch (arr, l, r):
if r >= l:
mid = l + (r - l)//2
#print(mid,check(arr,mid),l,r)
if l==r:
return mid
elif check(arr,mid):
return binarySearch(arr, l, mid)
else:
return binarySearch(arr, mid + 1, r)
else:
return -1
def check(arr, x):
now=arr[0]
for i in range(len(arr)):
if i==0:
if m-arr[i]<=x:
now=0
else:
if arr[i]<now:
if x>=now-arr[i]:
now=now
else:
return False
else:
if x>=(now-arr[i]+m)%m:
now=now
else:
now=arr[i]
return True
l=list(map(int,input().split()))
print(binarySearch(l,0,m))
``` | output | 1 | 101,254 | 12 | 202,509 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Toad Zitz has an array of integers, each integer is between 0 and m-1 inclusive. The integers are a_1, a_2, …, a_n.
In one operation Zitz can choose an integer k and k indices i_1, i_2, …, i_k such that 1 ≤ i_1 < i_2 < … < i_k ≤ n. He should then change a_{i_j} to ((a_{i_j}+1) mod m) for each chosen integer i_j. The integer m is fixed for all operations and indices.
Here x mod y denotes the remainder of the division of x by y.
Zitz wants to make his array non-decreasing with the minimum number of such operations. Find this minimum number of operations.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 300 000) — the number of integers in the array and the parameter m.
The next line contains n space-separated integers a_1, a_2, …, a_n (0 ≤ a_i < m) — the given array.
Output
Output one integer: the minimum number of described operations Zitz needs to make his array non-decreasing. If no operations required, print 0.
It is easy to see that with enough operations Zitz can always make his array non-decreasing.
Examples
Input
5 3
0 0 0 1 2
Output
0
Input
5 7
0 6 1 3 2
Output
1
Note
In the first example, the array is already non-decreasing, so the answer is 0.
In the second example, you can choose k=2, i_1 = 2, i_2 = 5, the array becomes [0,0,1,3,3]. It is non-decreasing, so the answer is 1. | instruction | 0 | 101,255 | 12 | 202,510 |
Tags: binary search, greedy
Correct Solution:
```
import sys
import math as mt
input=sys.stdin.buffer.readline
t=1
def check(x1):
prev=0
#print(x1,m)
for i in range(n):
#print(111,prev,i,arr[i],)
if arr[i]>prev:
x=m-(arr[i]-prev)
if x>x1:
prev=arr[i]
if arr[i]<prev:
x=(prev-arr[i])
if x>x1:
return False
return True
#t=int(input())
for _ in range(t):
#n=int((input())
n,m=map(int,input().split())
arr=list(map(int,input().split()))
l,r=0,m
ans=m
while (1<r-l):
mid=(l+r)//2
#print(l,r,mid,check(mid))
if (check(mid)):
ans=min(ans,mid)
r=mid
else:
l=mid
if (check(ans-1)):
ans-=1
print(ans)
``` | output | 1 | 101,255 | 12 | 202,511 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Toad Zitz has an array of integers, each integer is between 0 and m-1 inclusive. The integers are a_1, a_2, …, a_n.
In one operation Zitz can choose an integer k and k indices i_1, i_2, …, i_k such that 1 ≤ i_1 < i_2 < … < i_k ≤ n. He should then change a_{i_j} to ((a_{i_j}+1) mod m) for each chosen integer i_j. The integer m is fixed for all operations and indices.
Here x mod y denotes the remainder of the division of x by y.
Zitz wants to make his array non-decreasing with the minimum number of such operations. Find this minimum number of operations.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 300 000) — the number of integers in the array and the parameter m.
The next line contains n space-separated integers a_1, a_2, …, a_n (0 ≤ a_i < m) — the given array.
Output
Output one integer: the minimum number of described operations Zitz needs to make his array non-decreasing. If no operations required, print 0.
It is easy to see that with enough operations Zitz can always make his array non-decreasing.
Examples
Input
5 3
0 0 0 1 2
Output
0
Input
5 7
0 6 1 3 2
Output
1
Note
In the first example, the array is already non-decreasing, so the answer is 0.
In the second example, you can choose k=2, i_1 = 2, i_2 = 5, the array becomes [0,0,1,3,3]. It is non-decreasing, so the answer is 1. | instruction | 0 | 101,256 | 12 | 202,512 |
Tags: binary search, greedy
Correct Solution:
```
import sys
N, M = map(int, input().split(' '))
A = list(map(int, sys.stdin.readline().split(' ')))
def check() :
last = 0
for i in range(N) :
if A[i] < last :
if last - A[i] > m :
break
elif A[i] > last :
if A[i] + m < M or (A[i] + m) % M < last :
last = A[i]
else :
return True
return False
l = -1
r = M-1
while(l + 1 < r) :
m = (l+r) // 2
if check() :
r = m
else :
l = m
print(r)
``` | output | 1 | 101,256 | 12 | 202,513 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Toad Zitz has an array of integers, each integer is between 0 and m-1 inclusive. The integers are a_1, a_2, …, a_n.
In one operation Zitz can choose an integer k and k indices i_1, i_2, …, i_k such that 1 ≤ i_1 < i_2 < … < i_k ≤ n. He should then change a_{i_j} to ((a_{i_j}+1) mod m) for each chosen integer i_j. The integer m is fixed for all operations and indices.
Here x mod y denotes the remainder of the division of x by y.
Zitz wants to make his array non-decreasing with the minimum number of such operations. Find this minimum number of operations.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 300 000) — the number of integers in the array and the parameter m.
The next line contains n space-separated integers a_1, a_2, …, a_n (0 ≤ a_i < m) — the given array.
Output
Output one integer: the minimum number of described operations Zitz needs to make his array non-decreasing. If no operations required, print 0.
It is easy to see that with enough operations Zitz can always make his array non-decreasing.
Examples
Input
5 3
0 0 0 1 2
Output
0
Input
5 7
0 6 1 3 2
Output
1
Note
In the first example, the array is already non-decreasing, so the answer is 0.
In the second example, you can choose k=2, i_1 = 2, i_2 = 5, the array becomes [0,0,1,3,3]. It is non-decreasing, so the answer is 1. | instruction | 0 | 101,257 | 12 | 202,514 |
Tags: binary search, greedy
Correct Solution:
```
n,m=map(int,input().split())
a=tuple(map(int,input().split()))
l,r=-1,m-1
while(l+1<r):
M=(l+r)//2
ai1=0
for ai in a:
if (m-ai+ai1)%m>M:
if ai<ai1:
l=M
break
ai1=ai
else:
r=M
print(r)
``` | output | 1 | 101,257 | 12 | 202,515 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Toad Zitz has an array of integers, each integer is between 0 and m-1 inclusive. The integers are a_1, a_2, …, a_n.
In one operation Zitz can choose an integer k and k indices i_1, i_2, …, i_k such that 1 ≤ i_1 < i_2 < … < i_k ≤ n. He should then change a_{i_j} to ((a_{i_j}+1) mod m) for each chosen integer i_j. The integer m is fixed for all operations and indices.
Here x mod y denotes the remainder of the division of x by y.
Zitz wants to make his array non-decreasing with the minimum number of such operations. Find this minimum number of operations.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 300 000) — the number of integers in the array and the parameter m.
The next line contains n space-separated integers a_1, a_2, …, a_n (0 ≤ a_i < m) — the given array.
Output
Output one integer: the minimum number of described operations Zitz needs to make his array non-decreasing. If no operations required, print 0.
It is easy to see that with enough operations Zitz can always make his array non-decreasing.
Examples
Input
5 3
0 0 0 1 2
Output
0
Input
5 7
0 6 1 3 2
Output
1
Note
In the first example, the array is already non-decreasing, so the answer is 0.
In the second example, you can choose k=2, i_1 = 2, i_2 = 5, the array becomes [0,0,1,3,3]. It is non-decreasing, so the answer is 1. | instruction | 0 | 101,258 | 12 | 202,516 |
Tags: binary search, greedy
Correct Solution:
```
import sys,math
def read_int():
return int(sys.stdin.readline().strip())
def read_int_list():
return list(map(int,sys.stdin.readline().strip().split()))
def read_string():
return sys.stdin.readline().strip()
def read_string_list(delim=" "):
return sys.stdin.readline().strip().split(delim)
###### Author : Samir Vyas #######
###### Write Code Below #######
n,m = read_int_list()
arr = read_int_list()
def is_ok(maxi):
global arr
prev = 0
for i in range(len(arr)):
if prev <= arr[i] :
k = prev+m-arr[i]
#if no ops is more than maxi then make it prev
if k > maxi:
prev = arr[i]
else:
k = prev-arr[i]
if k > maxi:
return 0
return 1
l,r = 0,m
while l<=r:
mid = l+((r-l)//2)
if is_ok(mid):
r = mid-1
else:
l = mid+1
if is_ok(l):
print(l)
else:
print(r)
``` | output | 1 | 101,258 | 12 | 202,517 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.