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.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10. | instruction | 0 | 77,001 | 12 | 154,002 |
Tags: brute force, dp
Correct Solution:
```
import os,io
from sys import stdout
import collections
# import random
# import math
# from operator import itemgetter
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
# from collections import Counter
# from decimal import Decimal
# import heapq
# from functools import lru_cache
# import sys
# import threading
# sys.setrecursionlimit(10**6)
# threading.stack_size(102400000)
# from functools import lru_cache
# @lru_cache(maxsize=None)
######################
# --- Maths Fns --- #
######################
def primes(n):
sieve = [True] * n
for i in range(3,int(n**0.5)+1,2):
if sieve[i]:
sieve[i*i::2*i]=[False]*((n-i*i-1)//(2*i)+1)
return [2] + [i for i in range(3,n,2) if sieve[i]]
def binomial_coefficient(n, k):
if 0 <= k <= n:
ntok = 1
ktok = 1
for t in range(1, min(k, n - k) + 1):
ntok *= n
ktok *= t
n -= 1
return ntok // ktok
else:
return 0
def powerOfK(k, max):
if k == 1:
return [1]
if k == -1:
return [-1, 1]
result = []
n = 1
while n <= max:
result.append(n)
n *= k
return result
def divisors(n):
i = 1
result = []
while i*i <= n:
if n%i == 0:
if n/i == i:
result.append(i)
else:
result.append(i)
result.append(n/i)
i+=1
return result
# @lru_cache(maxsize=None)
def digitsSum(n):
if n == 0:
return 0
r = 0
while n > 0:
r += n % 10
n //= 10
return r
######################
# ---- GRID Fns ---- #
######################
def isValid(i, j, n, m):
return i >= 0 and i < n and j >= 0 and j < m
def print_grid(grid):
for line in grid:
print(" ".join(map(str,line)))
######################
# ---- MISC Fns ---- #
######################
def kadane(a,size):
max_so_far = 0
max_ending_here = 0
for i in range(0, size):
max_ending_here = max_ending_here + a[i]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if max_ending_here < 0:
max_ending_here = 0
return max_so_far
def prefixSum(arr):
for i in range(1, len(arr)):
arr[i] = arr[i] + arr[i-1]
return arr
def ceil(n, d):
if n % d == 0:
return n // d
else:
return (n // d) + 1
# INPUTS --------------------------
# s = input().decode('utf-8').strip()
# n = int(input())
# l = list(map(int, input().split()))
# t = int(input())
# for _ in range(t):
# for _ in range(t):
def solve(arr1, arr2, p, t):
if not len(arr1) or not len(arr2):
return 1
i, j = 0, 0
cnt = 1
# p = arr1[0]
# t = True
while i < len(arr1) and j < len(arr2):
if t:
while j < len(arr2) and arr2[j] <= p:
j += 1
if j < len(arr2):
p = arr2[j]
t = not t
cnt += 1
else:
while i < len(arr1) and arr1[i] <= p:
i += 1
if i < len(arr1):
p = arr1[i]
t = not t
cnt += 1
if t and j < len(arr2):
while j < len(arr2) and arr2[j] <= p:
j += 1
if j < len(arr2):
p = arr2[j]
t = not t
cnt += 1
elif not t and i < len(arr1):
while i < len(arr1) and arr1[i] <= p:
i += 1
if i < len(arr1):
p = arr1[i]
t = not t
cnt += 1
return cnt
n = int(input())
l = list(map(int, input().split()))
if n <= 2:
print(n)
exit()
best = 0
m = collections.defaultdict(list)
for i, v in enumerate(l):
m[v].append(i)
keys = list(m.keys())
for i in range(len(keys)):
for j in range(i+1, len(keys)):
arr1 = m[keys[i]]
arr2 = m[keys[j]]
if len(arr1) + len(arr2) <= best:
continue
r = solve(arr1, arr2, arr1[0], True)
best = max(r, best)
r2 = solve(arr1, arr2, arr2[0], False)
best = max(r2, best)
best = max(best, len(arr1))
best = max(best, len(arr2))
print(best)
``` | output | 1 | 77,001 | 12 | 154,003 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10. | instruction | 0 | 77,002 | 12 | 154,004 |
Tags: brute force, dp
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
from collections import defaultdict
def main():
n = int(input())
b = list(map(int,input().split()))
ls = defaultdict(lambda:-1)
dp = [[1]*n for _ in range(n)]
# next ; index
for i in range(n):
for j in range(n):
z = ls[b[j]]
if z != -1:
dp[i][j] = dp[z][i]+1
ls[b[i]] = i
print(max(map(max,dp)))
# 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 | 77,002 | 12 | 154,005 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10. | instruction | 0 | 77,003 | 12 | 154,006 |
Tags: brute force, dp
Correct Solution:
```
n = int(input())
ls = list(map(int, input().split()))
dp = [[1 for i in range(n)] for j in range(n)]
laspos = [None] * (max(ls) + 1)
for i in range(n):
for j in range(i):
if laspos[ls[i]] is not None:
dp[i][j] = 1 + dp[j][laspos[ls[i]]]
else:
dp[i][j] += 1
laspos[ls[j]] = j
mx = -100000
for i in range(n):
for j in range(n):
mx = max(dp[i][j], mx)
print(mx)
``` | output | 1 | 77,003 | 12 | 154,007 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10. | instruction | 0 | 77,004 | 12 | 154,008 |
Tags: brute force, dp
Correct Solution:
```
d, n, t = 0, int(input()), list(map(int, input().split()))
p = {a: 0 for a in set(t)}
for i in range(n):
a = t[i]
if not a in p: continue
p.pop(a)
s = t.count(a) - 1
if 2 * s < d: continue
if s > d: d = s
k = i + 1
for j in range(k, n):
if t[j] == a:
for b in set(t[k: j]):
if b in p: p[b] += 2
k = j + 1
for b in set(t[k: n]):
if b in p: p[b] += 1
for b in p:
if p[b] > d: d = p[b]
p[b] = 0
print(d + 1)
# Made By Mostafa_Khaled
``` | output | 1 | 77,004 | 12 | 154,009 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10. | instruction | 0 | 77,005 | 12 | 154,010 |
Tags: brute force, dp
Correct Solution:
```
d, n, t = 0, int(input()), list(map(int, input().split()))
p = {a: 0 for a in set(t)}
for i in range(n):
a = t[i]
if not a in p: continue
p.pop(a)
s = t.count(a) - 1
if 2 * s < d: continue
if s > d: d = s
k = i + 1
for j in range(k, n):
if t[j] == a:
for b in set(t[k: j]):
if b in p: p[b] += 2
k = j + 1
for b in set(t[k: n]):
if b in p: p[b] += 1
for b in p:
if p[b] > d: d = p[b]
p[b] = 0
print(d + 1)
``` | output | 1 | 77,005 | 12 | 154,011 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10. | instruction | 0 | 77,006 | 12 | 154,012 |
Tags: brute force, dp
Correct Solution:
```
n=int(input())
b=list(map(int,input().split()))
dp=[[1]*n for i in range(n)]
d,k={},0
for i in range(n):
if b[i] not in d:
d[b[i]]=k
k+=1
b[i]=d[b[i]]
d.clear()
for i in range(n):
for j in range(i):
dp[i][b[j]]=max(1+dp[j][b[i]],dp[i][b[j]])
ans=0
for l in dp:
ans=max(ans,max(l))
print(ans)
``` | output | 1 | 77,006 | 12 | 154,013 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10. | instruction | 0 | 77,007 | 12 | 154,014 |
Tags: brute force, dp
Correct Solution:
```
import sys
input = sys.stdin.readline
#for _ in range(int(input())):
n=int(input())
ans=1
arr=[int(x) for x in input().split()]
for i in range(n):
temp=set()
d={}
#ans=0
for j in range(i+1,n):
if arr[j]==arr[i]:
temp=set()
else:
if arr[j] not in temp:
if arr[j] in d:
d[arr[j]]+=1
else:
d[arr[j]]=1
temp.add(arr[j])
number=-1
maxi=-1
#print(d,temp)
for i in d:
if maxi<d[i]:
number=i
maxi=d[i]
#print(number,maxi)
if number in temp:
ans=max(ans,2*maxi)
else:
ans=max(ans,2*maxi+1)
d={}
for i in arr:
if i in d:
d[i]+=1
else:
d[i]=1
for i in d:
ans=max(ans,d[i])
print(ans)
``` | output | 1 | 77,007 | 12 | 154,015 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10.
Submitted Solution:
```
def function(n , array):
grid = [ {} for i in range(n)]
if(n <= 2):
print(n)
return
global_max = -10
for i in range(n - 2, -1, -1):
for j in range(i + 1, n):
diff = array[i] - array[j]
max_val = 1
if((-diff) in grid[j].keys()):
max_val = max(grid[j][(-diff)] + 1, max_val)
if(diff in grid[i].keys()):
max_val = max(max_val, grid[i][diff])
grid[i][diff] = max_val
else:
grid[i][diff] = max_val
global_max = max(global_max, max_val)
print(global_max + 1)
n = int(input())
array = [ int(x) for x in input().split() ]
function(n, array)
``` | instruction | 0 | 77,008 | 12 | 154,016 |
Yes | output | 1 | 77,008 | 12 | 154,017 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10.
Submitted Solution:
```
#!/usr/bin/env python3
import io
import os
import sys
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def printd(*args, **kwargs):
# print(*args, **kwargs, file=sys.stderr)
print(*args, **kwargs)
pass
def get_str():
return input().decode().strip()
def rint():
return map(int, input().split())
def oint():
return int(input())
n = oint()
b = list(rint())
index_dict = dict()
for i in range(n):
if b[i] in index_dict:
index_dict[b[i]].append(i)
else:
index_dict[b[i]] = [i]
index = []
for i in index_dict:
index.append(index_dict[i])
max_cnt = 0
for i in range(len(index)):
il = index[i]
for j in range(len(index)):
jl = index[j]
if i == j:
max_cnt = max(max_cnt, len(index[i]))
continue
ci, cj, cnt = 0, 0, 1
ij = 'i'
while ci != len(il) and cj != len(jl):
if ij == 'i':
if jl[cj] > il[ci]:
cnt += 1
ij = 'j'
else:
cj += 1
else:
if jl[cj] < il[ci]:
cnt += 1
ij = 'i'
else:
ci += 1
max_cnt = max(max_cnt, cnt)
print(max_cnt)
``` | instruction | 0 | 77,009 | 12 | 154,018 |
Yes | output | 1 | 77,009 | 12 | 154,019 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10.
Submitted Solution:
```
from sys import stdin,stdout
nmbr = lambda: int(stdin.readline())
lst = lambda: list(map(int,input().split()))
def fn(a):
mp={}
b=[]
cnt=0
for v in a:
if v in mp:b+=[mp[v]]
else:
b+=[cnt]
mp[v]=cnt
cnt+=1
return b
for i in range(1):#nmbr()):
n=nmbr()
a=fn(lst())
N=max(a)+1;ans=1
dp=[[1 for _ in range(N)]for j in range(n)]
for i in range(1,n):
for j in range(i):
dp[i][a[j]]=1+dp[j][a[i]]
ans=max(ans,dp[i][a[j]])
# print(*dp,sep='\n')
print(ans)
``` | instruction | 0 | 77,010 | 12 | 154,020 |
Yes | output | 1 | 77,010 | 12 | 154,021 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10.
Submitted Solution:
```
def get_len(a, b):
if a[0]>=b[0]:
c = a
a = b
b = c
i = 0
j = 0
res = 2
while i<len(a) and j<len(b):
while a[i]<=b[j]:
i+=1
if i==len(a):
break
if i==len(a):
break
res+=1
while a[i]>=b[j]:
j+=1
if j==len(b):
break
if j==len(b):
break
res+=1
return res
n = int(input())
a = [int(e) for e in input().split()]
d = dict()
keys = []
for i in range(len(a)):
x = a[i]
if x in d:
d[x].append(i)
else:
d[x] = [i]
keys.append(x)
ans = 0
for i in range(len(keys)):
x = keys[i]
for j in range(i+1, len(keys)):
y = keys[j]
if x==y:
continue
i1 = 0
j1 = 0
#print("___")
#print(d[x], d[y])
xi = get_len(d[x], d[y])
#print(xi)
ans = max(ans, xi)
ans1 = [len(d[e]) for e in d]
ans = max(ans, max(ans1))
print(ans)
# 3 1 3 1 3
``` | instruction | 0 | 77,011 | 12 | 154,022 |
Yes | output | 1 | 77,011 | 12 | 154,023 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10.
Submitted Solution:
```
n = int(input())
ls = list(map(int, input().split()))
dp = [[1 for i in range(n)] for j in range(n)]
laspos = [None] * (max(ls)+1)
for i in range(n):
for j in range(i):
laspos[ls[j]] = j
if j == 0:
dp[i][j] += 1
continue
if laspos[ls[i]] is not None:
dp[i][j] = 1 + dp[j][laspos[ls[i]]]
mx = -100000
for i in range(n):
for j in range(n):
mx = max(dp[i][j], mx)
print(mx)
``` | instruction | 0 | 77,012 | 12 | 154,024 |
No | output | 1 | 77,012 | 12 | 154,025 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10.
Submitted Solution:
```
# Author : nitish420 --------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
# mod=10**9+7
# sys.setrecursionlimit(10**6)
# mxm=sys.maxsize
# from functools import lru_cache
from collections import defaultdict
def main():
n=int(input())
b=list(map(int,input().split()))
q=defaultdict(lambda : set([0]))
dp=[0]*(n)
dp[0]=1
for i in range(1,n):
for j in range(i):
if dp[i]<=2:
dp[i]=2
q[i].add(b[j]-b[i])
temp=(b[i]-b[j])*(pow(-1,dp[j]%2))
if temp in q[j]:
if dp[j]+1>dp[i]:
dp[i]=dp[j]+1
q[i]=set([temp])
elif dp[j]+1==dp[i]:
q[i].add(temp)
# print(*dp)
# print(dp[35])
# print(*q)
# print(q)
print(max(dp))
# print(b)
# 42
# 68 35 1 70 25 79 59 63 65 6 46 82 28 62 92 96 43 28 37 92 5 3 54 93 83 22 17 19 96 48 27 72 39 70 13 68 100 36 95 4 12 23
# 8
# 437 392 605 903 154 293 383 422
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = 'x' in file.mode or 'r' not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b'\n') + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode('ascii'))
self.read = lambda: self.buffer.read().decode('ascii')
self.readline = lambda: self.buffer.readline().decode('ascii')
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')
# endregion
if __name__ == '__main__':
main()
``` | instruction | 0 | 77,013 | 12 | 154,026 |
No | output | 1 | 77,013 | 12 | 154,027 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10.
Submitted Solution:
```
import sys
input = sys.stdin.readline
#for _ in range(int(input())):
n=int(input())
ans=1
arr=[int(x) for x in input().split()]
for i in range(n):
temp=set()
d={}
#ans=0
for j in range(i+1,n):
if arr[j]==arr[i]:
temp=set()
else:
if arr[j] not in temp:
if arr[j] in d:
d[arr[j]]+=1
else:
d[arr[j]]=1
temp.add(arr[j])
number=-1
maxi=-1
#print(d,temp)
for i in d:
if maxi<d[i]:
number=i
maxi=d[i]
#print(number,maxi)
if number in temp:
ans=max(ans,2*maxi)
else:
ans=max(ans,2*maxi+1)
print(ans)
``` | instruction | 0 | 77,014 | 12 | 154,028 |
No | output | 1 | 77,014 | 12 | 154,029 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10.
Submitted Solution:
```
n = int(input())
s = list(map(int, input().split()))
dp = [{x: 1 for x in s} for _ in range(n)]
mx = 1
for i in range(1, n):
for j in range(i-1, -1, -1):
if s[i] == s[j]: continue
dp[i][s[j]] = max(dp[i][s[j]], dp[j][s[i]] + 1)
mx = max(mx, dp[i][s[j]])
print(mx)
``` | instruction | 0 | 77,015 | 12 | 154,030 |
No | output | 1 | 77,015 | 12 | 154,031 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got an array, consisting of n integers a1, a2, ..., an. Also, you've got m queries, the i-th query is described by two integers li, ri. Numbers li, ri define a subsegment of the original array, that is, the sequence of numbers ali, ali + 1, ali + 2, ..., ari. For each query you should check whether the corresponding segment is a ladder.
A ladder is a sequence of integers b1, b2, ..., bk, such that it first doesn't decrease, then doesn't increase. In other words, there is such integer x (1 ≤ x ≤ k), that the following inequation fulfills: b1 ≤ b2 ≤ ... ≤ bx ≥ bx + 1 ≥ bx + 2... ≥ bk. Note that the non-decreasing and the non-increasing sequences are also considered ladders.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of array elements and the number of queries. The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109), where number ai stands for the i-th array element.
The following m lines contain the description of the queries. The i-th line contains the description of the i-th query, consisting of two integers li, ri (1 ≤ li ≤ ri ≤ n) — the boundaries of the subsegment of the initial array.
The numbers in the lines are separated by single spaces.
Output
Print m lines, in the i-th line print word "Yes" (without the quotes), if the subsegment that corresponds to the i-th query is the ladder, or word "No" (without the quotes) otherwise.
Examples
Input
8 6
1 2 1 3 3 5 2 1
1 3
2 3
2 4
8 8
1 4
5 8
Output
Yes
Yes
No
Yes
No
Yes | instruction | 0 | 77,016 | 12 | 154,032 |
Tags: dp, implementation, two pointers
Correct Solution:
```
import sys
n,m=map(int,sys.stdin.readline().split())
M=[m]
A=list(map(int,sys.stdin.readline().split()))
L=[0]*n
inc=False
dec=False
def ALLYes():
Ans=""
for i in range(M[0]):
Ans+="Yes\n"
sys.stdout.write(Ans)
return
for i in range(1,n):
if(A[i]>A[i-1]):
L[i]=1
inc=True
elif(A[i]==A[i-1]):
L[i]=0
else:
L[i]=-1
dec=True
if(inc==False or dec==False):
ALLYes()
else:
neg=L.index(-1)
pos=L.index(1)
First=[-1]*n
for i in range(2,n):
if(L[i]==0):
x=max(neg,pos)
if(x<=i):
First[i]=x
elif(min(neg,pos)<=i):
First[i]=min(neg,pos)
else:
First[i]=-1
if(L[i]==1):
if(neg>i):
First[i]=-1
else:
First[i]=neg
pos=i
if(L[i]==-1):
if(pos>i):
First[i]=-1
else:
First[i]=pos
neg=i
Ans=""
for i in range(m):
l,r=map(int,sys.stdin.readline().split())
r-=1
if(r-l<1):
Ans+="Yes\n"
continue
if(L[r]==0):
r=First[r]
if(r<1):
Ans+="Yes\n"
continue
if(L[r]==1):
r=First[r]
if(r<l):
Ans+="Yes\n"
continue
else:
Ans+="No\n"
continue
elif(L[r]==-1):
r=First[r]
if(r<l):
Ans+="Yes\n"
continue
r=First[r]
if(r<l):
Ans+="Yes\n"
continue
else:
Ans+="No\n"
continue
sys.stdout.write(Ans)
``` | output | 1 | 77,016 | 12 | 154,033 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got an array, consisting of n integers a1, a2, ..., an. Also, you've got m queries, the i-th query is described by two integers li, ri. Numbers li, ri define a subsegment of the original array, that is, the sequence of numbers ali, ali + 1, ali + 2, ..., ari. For each query you should check whether the corresponding segment is a ladder.
A ladder is a sequence of integers b1, b2, ..., bk, such that it first doesn't decrease, then doesn't increase. In other words, there is such integer x (1 ≤ x ≤ k), that the following inequation fulfills: b1 ≤ b2 ≤ ... ≤ bx ≥ bx + 1 ≥ bx + 2... ≥ bk. Note that the non-decreasing and the non-increasing sequences are also considered ladders.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of array elements and the number of queries. The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109), where number ai stands for the i-th array element.
The following m lines contain the description of the queries. The i-th line contains the description of the i-th query, consisting of two integers li, ri (1 ≤ li ≤ ri ≤ n) — the boundaries of the subsegment of the initial array.
The numbers in the lines are separated by single spaces.
Output
Print m lines, in the i-th line print word "Yes" (without the quotes), if the subsegment that corresponds to the i-th query is the ladder, or word "No" (without the quotes) otherwise.
Examples
Input
8 6
1 2 1 3 3 5 2 1
1 3
2 3
2 4
8 8
1 4
5 8
Output
Yes
Yes
No
Yes
No
Yes | instruction | 0 | 77,017 | 12 | 154,034 |
Tags: dp, implementation, two pointers
Correct Solution:
```
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
# from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
import copy
import time
starttime = time.time()
mod = int(pow(10, 9) + 7)
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
def L(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]
try:
# sys.setrecursionlimit(int(pow(10,6)))
sys.stdin = open("input.txt", "r")
# sys.stdout = open("../output.txt", "w")
except:
pass
n,m=L()
dp=[0 for i in range(100100)]
ap=[0 for i in range(100100)]
def solve(ar):
for i in range(n-1,0,-1):
if(ar[i]>=ar[i+1]):
dp[i]=dp[i+1]+1
for i in range(n-1,0,-1):
if(ar[i]<=ar[i+1]):
ap[i]=ap[i+1]+1
ar=L()
ar.insert(0,0)
solve(ar)
for i in range(m):
l,r=L()
x=l+ap[l]+dp[l+ap[l]]
if(x>=r):
print("Yes")
else:
print("No")
endtime = time.time()
# print(f"Runtime of the program is {endtime - starttime}")
``` | output | 1 | 77,017 | 12 | 154,035 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got an array, consisting of n integers a1, a2, ..., an. Also, you've got m queries, the i-th query is described by two integers li, ri. Numbers li, ri define a subsegment of the original array, that is, the sequence of numbers ali, ali + 1, ali + 2, ..., ari. For each query you should check whether the corresponding segment is a ladder.
A ladder is a sequence of integers b1, b2, ..., bk, such that it first doesn't decrease, then doesn't increase. In other words, there is such integer x (1 ≤ x ≤ k), that the following inequation fulfills: b1 ≤ b2 ≤ ... ≤ bx ≥ bx + 1 ≥ bx + 2... ≥ bk. Note that the non-decreasing and the non-increasing sequences are also considered ladders.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of array elements and the number of queries. The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109), where number ai stands for the i-th array element.
The following m lines contain the description of the queries. The i-th line contains the description of the i-th query, consisting of two integers li, ri (1 ≤ li ≤ ri ≤ n) — the boundaries of the subsegment of the initial array.
The numbers in the lines are separated by single spaces.
Output
Print m lines, in the i-th line print word "Yes" (without the quotes), if the subsegment that corresponds to the i-th query is the ladder, or word "No" (without the quotes) otherwise.
Examples
Input
8 6
1 2 1 3 3 5 2 1
1 3
2 3
2 4
8 8
1 4
5 8
Output
Yes
Yes
No
Yes
No
Yes | instruction | 0 | 77,018 | 12 | 154,036 |
Tags: dp, implementation, two pointers
Correct Solution:
```
n, m = map(int, input().split())
arr = list(map(int, input().split()))
up = [i for i in range(n)]
down = [i for i in range(n)]
for i in range(1, n):
if arr[i-1] <= arr[i]:
up[i] = up[i-1]
if arr[i-1] >= arr[i]:
down[i] = down[i-1]
all_res = []
seg = list(tuple(map(int, input().split()) for _ in range(m)))
for l, r in seg:
if l - 1 >= up[down[r - 1]]:
all_res.append('Yes')
else:
all_res.append('No')
print('\n'.join(all_res))
``` | output | 1 | 77,018 | 12 | 154,037 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got an array, consisting of n integers a1, a2, ..., an. Also, you've got m queries, the i-th query is described by two integers li, ri. Numbers li, ri define a subsegment of the original array, that is, the sequence of numbers ali, ali + 1, ali + 2, ..., ari. For each query you should check whether the corresponding segment is a ladder.
A ladder is a sequence of integers b1, b2, ..., bk, such that it first doesn't decrease, then doesn't increase. In other words, there is such integer x (1 ≤ x ≤ k), that the following inequation fulfills: b1 ≤ b2 ≤ ... ≤ bx ≥ bx + 1 ≥ bx + 2... ≥ bk. Note that the non-decreasing and the non-increasing sequences are also considered ladders.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of array elements and the number of queries. The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109), where number ai stands for the i-th array element.
The following m lines contain the description of the queries. The i-th line contains the description of the i-th query, consisting of two integers li, ri (1 ≤ li ≤ ri ≤ n) — the boundaries of the subsegment of the initial array.
The numbers in the lines are separated by single spaces.
Output
Print m lines, in the i-th line print word "Yes" (without the quotes), if the subsegment that corresponds to the i-th query is the ladder, or word "No" (without the quotes) otherwise.
Examples
Input
8 6
1 2 1 3 3 5 2 1
1 3
2 3
2 4
8 8
1 4
5 8
Output
Yes
Yes
No
Yes
No
Yes | instruction | 0 | 77,019 | 12 | 154,038 |
Tags: dp, implementation, two pointers
Correct Solution:
```
import sys
import math as mt
import bisect
input=sys.stdin.buffer.readline
#t=int(input())
t=1
for __ in range(t):
#n=int(input())
n,m=map(int,input().split())
l=list(map(int,input().split()))
l.insert(0,0)
ri=[0]*(n+1)
ri[n]=n
for i in range(n-1,0,-1):
if l[i]<=l[i+1]:
ri[i]=ri[i+1]
else:
ri[i]=i
le=[0]*(n+1)
le[1]=1
for i in range(2,n+1):
if l[i-1]>=l[i]:
le[i]=le[i-1]
else:
le[i]=i
for j in range(m):
a,b=map(int,input().split())
if ri[a]>=le[b]:
print("Yes")
else:
print("No")
``` | output | 1 | 77,019 | 12 | 154,039 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got an array, consisting of n integers a1, a2, ..., an. Also, you've got m queries, the i-th query is described by two integers li, ri. Numbers li, ri define a subsegment of the original array, that is, the sequence of numbers ali, ali + 1, ali + 2, ..., ari. For each query you should check whether the corresponding segment is a ladder.
A ladder is a sequence of integers b1, b2, ..., bk, such that it first doesn't decrease, then doesn't increase. In other words, there is such integer x (1 ≤ x ≤ k), that the following inequation fulfills: b1 ≤ b2 ≤ ... ≤ bx ≥ bx + 1 ≥ bx + 2... ≥ bk. Note that the non-decreasing and the non-increasing sequences are also considered ladders.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of array elements and the number of queries. The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109), where number ai stands for the i-th array element.
The following m lines contain the description of the queries. The i-th line contains the description of the i-th query, consisting of two integers li, ri (1 ≤ li ≤ ri ≤ n) — the boundaries of the subsegment of the initial array.
The numbers in the lines are separated by single spaces.
Output
Print m lines, in the i-th line print word "Yes" (without the quotes), if the subsegment that corresponds to the i-th query is the ladder, or word "No" (without the quotes) otherwise.
Examples
Input
8 6
1 2 1 3 3 5 2 1
1 3
2 3
2 4
8 8
1 4
5 8
Output
Yes
Yes
No
Yes
No
Yes | instruction | 0 | 77,020 | 12 | 154,040 |
Tags: dp, implementation, two pointers
Correct Solution:
```
'''input
8 6
1 2 1 3 3 5 2 1
1 3
2 3
2 4
8 8
1 4
5 8
'''
from sys import stdin
import sys
import copy
sys.setrecursionlimit(15000)
def create_dp(arr, n):
dp1 = [-1] * n
dp1[-1] = n - 1
for i in range(n - 2, -1, -1):
if arr[i] <= arr[i + 1]:
dp1[i] = dp1[i + 1]
else:
dp1[i] = i
dp2 = [-1] * n
dp2[-1] = n - 1
for i in range(n - 2, -1, -1):
if arr[i] >= arr[i + 1]:
dp2[i] = dp2[i + 1]
else:
dp2[i] = i
return dp1, dp2
# main starts
n, m = list(map(int, stdin.readline().split()))
arr = list(map(int, stdin.readline().split()))
dp1, dp2 = create_dp(arr, n)
for _ in range(m):
l, r = list(map(int, stdin.readline().split()))
if dp2[dp1[l - 1]] >= r - 1:
print("Yes")
else:
print("No")
``` | output | 1 | 77,020 | 12 | 154,041 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got an array, consisting of n integers a1, a2, ..., an. Also, you've got m queries, the i-th query is described by two integers li, ri. Numbers li, ri define a subsegment of the original array, that is, the sequence of numbers ali, ali + 1, ali + 2, ..., ari. For each query you should check whether the corresponding segment is a ladder.
A ladder is a sequence of integers b1, b2, ..., bk, such that it first doesn't decrease, then doesn't increase. In other words, there is such integer x (1 ≤ x ≤ k), that the following inequation fulfills: b1 ≤ b2 ≤ ... ≤ bx ≥ bx + 1 ≥ bx + 2... ≥ bk. Note that the non-decreasing and the non-increasing sequences are also considered ladders.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of array elements and the number of queries. The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109), where number ai stands for the i-th array element.
The following m lines contain the description of the queries. The i-th line contains the description of the i-th query, consisting of two integers li, ri (1 ≤ li ≤ ri ≤ n) — the boundaries of the subsegment of the initial array.
The numbers in the lines are separated by single spaces.
Output
Print m lines, in the i-th line print word "Yes" (without the quotes), if the subsegment that corresponds to the i-th query is the ladder, or word "No" (without the quotes) otherwise.
Examples
Input
8 6
1 2 1 3 3 5 2 1
1 3
2 3
2 4
8 8
1 4
5 8
Output
Yes
Yes
No
Yes
No
Yes | instruction | 0 | 77,021 | 12 | 154,042 |
Tags: dp, implementation, two pointers
Correct Solution:
```
import traceback
import math
from collections import defaultdict
from functools import lru_cache
if __name__ == '__main__':
n, m = map(int, input().split())
arr = list(map(int, input().split()))
increase = [-1] * n
decrease = [-1] * n
tmp = n - 1
for i in range(n - 1, -1, -1):
if i != n - 1:
if arr[i] > arr[i + 1]:
tmp = i
increase[i] = tmp
tmp = 0
for i in range(n):
if i != 0:
if arr[i - 1] < arr[i]:
tmp = i
decrease[i] = tmp
# print(increase)
# print(decrease)
result = []
for i in range(m):
a, b = map(int, input().split())
a -= 1
b -= 1
# print(a, b, increase[a], decrease[b])
result.append("Yes\n" if increase[a] >= decrease[b] else "No\n")
print("".join(result))
``` | output | 1 | 77,021 | 12 | 154,043 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got an array, consisting of n integers a1, a2, ..., an. Also, you've got m queries, the i-th query is described by two integers li, ri. Numbers li, ri define a subsegment of the original array, that is, the sequence of numbers ali, ali + 1, ali + 2, ..., ari. For each query you should check whether the corresponding segment is a ladder.
A ladder is a sequence of integers b1, b2, ..., bk, such that it first doesn't decrease, then doesn't increase. In other words, there is such integer x (1 ≤ x ≤ k), that the following inequation fulfills: b1 ≤ b2 ≤ ... ≤ bx ≥ bx + 1 ≥ bx + 2... ≥ bk. Note that the non-decreasing and the non-increasing sequences are also considered ladders.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of array elements and the number of queries. The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109), where number ai stands for the i-th array element.
The following m lines contain the description of the queries. The i-th line contains the description of the i-th query, consisting of two integers li, ri (1 ≤ li ≤ ri ≤ n) — the boundaries of the subsegment of the initial array.
The numbers in the lines are separated by single spaces.
Output
Print m lines, in the i-th line print word "Yes" (without the quotes), if the subsegment that corresponds to the i-th query is the ladder, or word "No" (without the quotes) otherwise.
Examples
Input
8 6
1 2 1 3 3 5 2 1
1 3
2 3
2 4
8 8
1 4
5 8
Output
Yes
Yes
No
Yes
No
Yes | instruction | 0 | 77,022 | 12 | 154,044 |
Tags: dp, implementation, two pointers
Correct Solution:
```
M = lambda: map(int, input().split())
L = lambda: list(map(int, input().split()))
I = lambda: int(input())
n, k = M()
t = [0] + L()
a, b = list(range(n + 1)), list(range(n + 1))
for i in range(n, 1, -1):
if t[i] >= t[i - 1]: a[i - 1] = a[i]
if t[i] <= t[i - 1]: b[i - 1] = b[i]
p = ['No'] * k
for i in range(k):
x, y = M()
if b[a[x]] >= y: p[i] = 'Yes'
print('\n'.join(p))
``` | output | 1 | 77,022 | 12 | 154,045 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got an array, consisting of n integers a1, a2, ..., an. Also, you've got m queries, the i-th query is described by two integers li, ri. Numbers li, ri define a subsegment of the original array, that is, the sequence of numbers ali, ali + 1, ali + 2, ..., ari. For each query you should check whether the corresponding segment is a ladder.
A ladder is a sequence of integers b1, b2, ..., bk, such that it first doesn't decrease, then doesn't increase. In other words, there is such integer x (1 ≤ x ≤ k), that the following inequation fulfills: b1 ≤ b2 ≤ ... ≤ bx ≥ bx + 1 ≥ bx + 2... ≥ bk. Note that the non-decreasing and the non-increasing sequences are also considered ladders.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of array elements and the number of queries. The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109), where number ai stands for the i-th array element.
The following m lines contain the description of the queries. The i-th line contains the description of the i-th query, consisting of two integers li, ri (1 ≤ li ≤ ri ≤ n) — the boundaries of the subsegment of the initial array.
The numbers in the lines are separated by single spaces.
Output
Print m lines, in the i-th line print word "Yes" (without the quotes), if the subsegment that corresponds to the i-th query is the ladder, or word "No" (without the quotes) otherwise.
Examples
Input
8 6
1 2 1 3 3 5 2 1
1 3
2 3
2 4
8 8
1 4
5 8
Output
Yes
Yes
No
Yes
No
Yes | instruction | 0 | 77,023 | 12 | 154,046 |
Tags: dp, implementation, two pointers
Correct Solution:
```
import sys
n,m=map(int,sys.stdin.readline().split())
L=list(map(int,sys.stdin.readline().split()))
R=[0]*n
K=[0]*n
p=0
for i in range(1,n):
if(L[i]<L[i-1]):
for j in range(p,i):
R[j]=i
p=i
for j in range(p,n):
R[j]=n
p=0
for i in range(1,n):
if(L[i]>L[i-1]):
for j in range(p,i):
K[j]=i
p=i
for j in range(p,n):
K[j]=n
for i in range(m):
x,y=map(int,sys.stdin.readline().split())
x-=1
y-=1
r=R[x]
if(r>=y):
sys.stdout.write("Yes\n")
continue
e=K[r]
if(e>y):
sys.stdout.write("Yes\n")
continue
sys.stdout.write("No\n")
# Made By Mostafa_Khaled
``` | output | 1 | 77,023 | 12 | 154,047 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got an array, consisting of n integers a1, a2, ..., an. Also, you've got m queries, the i-th query is described by two integers li, ri. Numbers li, ri define a subsegment of the original array, that is, the sequence of numbers ali, ali + 1, ali + 2, ..., ari. For each query you should check whether the corresponding segment is a ladder.
A ladder is a sequence of integers b1, b2, ..., bk, such that it first doesn't decrease, then doesn't increase. In other words, there is such integer x (1 ≤ x ≤ k), that the following inequation fulfills: b1 ≤ b2 ≤ ... ≤ bx ≥ bx + 1 ≥ bx + 2... ≥ bk. Note that the non-decreasing and the non-increasing sequences are also considered ladders.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of array elements and the number of queries. The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109), where number ai stands for the i-th array element.
The following m lines contain the description of the queries. The i-th line contains the description of the i-th query, consisting of two integers li, ri (1 ≤ li ≤ ri ≤ n) — the boundaries of the subsegment of the initial array.
The numbers in the lines are separated by single spaces.
Output
Print m lines, in the i-th line print word "Yes" (without the quotes), if the subsegment that corresponds to the i-th query is the ladder, or word "No" (without the quotes) otherwise.
Examples
Input
8 6
1 2 1 3 3 5 2 1
1 3
2 3
2 4
8 8
1 4
5 8
Output
Yes
Yes
No
Yes
No
Yes
Submitted Solution:
```
from sys import stdin
input = stdin.readline
[n, q] = [int(item) for item in input().split(' ')]
arr = [int(item) for item in input().split(' ')]
queries = [[int(item) for item in input().split(' ')] for i in range(q)]
b = [1]
for i in range(1, n):
b.append((b[-1] + 1) if arr[i] <= arr[i - 1] else 1)
c = [1]
for i in reversed(range(n - 1)):
c.append(c[-1] + 1 if arr[i] <= arr[i + 1] else 1)
c = [item for item in reversed(c)]
for query in queries:
(x, y) = query
x -= 1
y -= 1
print('Yes' if (x + c[x] > y) or (y - b[y] < x) or (x + c[x] > y - b[y]) else 'No')
"""
5 1
1 3 3 2 2
1 4
5 1
1 2 2 1 1
1 4
5 1
2 2 1 1 2
1 5
"""
``` | instruction | 0 | 77,024 | 12 | 154,048 |
Yes | output | 1 | 77,024 | 12 | 154,049 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got an array, consisting of n integers a1, a2, ..., an. Also, you've got m queries, the i-th query is described by two integers li, ri. Numbers li, ri define a subsegment of the original array, that is, the sequence of numbers ali, ali + 1, ali + 2, ..., ari. For each query you should check whether the corresponding segment is a ladder.
A ladder is a sequence of integers b1, b2, ..., bk, such that it first doesn't decrease, then doesn't increase. In other words, there is such integer x (1 ≤ x ≤ k), that the following inequation fulfills: b1 ≤ b2 ≤ ... ≤ bx ≥ bx + 1 ≥ bx + 2... ≥ bk. Note that the non-decreasing and the non-increasing sequences are also considered ladders.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of array elements and the number of queries. The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109), where number ai stands for the i-th array element.
The following m lines contain the description of the queries. The i-th line contains the description of the i-th query, consisting of two integers li, ri (1 ≤ li ≤ ri ≤ n) — the boundaries of the subsegment of the initial array.
The numbers in the lines are separated by single spaces.
Output
Print m lines, in the i-th line print word "Yes" (without the quotes), if the subsegment that corresponds to the i-th query is the ladder, or word "No" (without the quotes) otherwise.
Examples
Input
8 6
1 2 1 3 3 5 2 1
1 3
2 3
2 4
8 8
1 4
5 8
Output
Yes
Yes
No
Yes
No
Yes
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
import math
def main():
pass
# 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")
import os
import sys
from io import BytesIO, IOBase
def main():
pass
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
n,m=map(int,input().split())
l=list(map(int,input().split()))
ia=[0]*n
db=[0]*n
db[0]=0
for i in range(1,n):
if(l[i]<=l[i-1]):
db[i]=db[i-1]
else:
db[i]=i
ia[n-1]=n-1
for i in range(n-2,-1,-1):
if(l[i]<=l[i+1]):
ia[i]=ia[i+1]
else:
ia[i]=i
for i in range(m):
a,b=map(int,input().split())
a-=1
b-=1
if(ia[a]>=db[b]):
print("Yes")
else:
print("No")
``` | instruction | 0 | 77,025 | 12 | 154,050 |
Yes | output | 1 | 77,025 | 12 | 154,051 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got an array, consisting of n integers a1, a2, ..., an. Also, you've got m queries, the i-th query is described by two integers li, ri. Numbers li, ri define a subsegment of the original array, that is, the sequence of numbers ali, ali + 1, ali + 2, ..., ari. For each query you should check whether the corresponding segment is a ladder.
A ladder is a sequence of integers b1, b2, ..., bk, such that it first doesn't decrease, then doesn't increase. In other words, there is such integer x (1 ≤ x ≤ k), that the following inequation fulfills: b1 ≤ b2 ≤ ... ≤ bx ≥ bx + 1 ≥ bx + 2... ≥ bk. Note that the non-decreasing and the non-increasing sequences are also considered ladders.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of array elements and the number of queries. The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109), where number ai stands for the i-th array element.
The following m lines contain the description of the queries. The i-th line contains the description of the i-th query, consisting of two integers li, ri (1 ≤ li ≤ ri ≤ n) — the boundaries of the subsegment of the initial array.
The numbers in the lines are separated by single spaces.
Output
Print m lines, in the i-th line print word "Yes" (without the quotes), if the subsegment that corresponds to the i-th query is the ladder, or word "No" (without the quotes) otherwise.
Examples
Input
8 6
1 2 1 3 3 5 2 1
1 3
2 3
2 4
8 8
1 4
5 8
Output
Yes
Yes
No
Yes
No
Yes
Submitted Solution:
```
from sys import stdin
input=lambda : stdin.readline().strip()
from math import ceil,sqrt,factorial,gcd
from collections import deque
n,m=map(int,input().split())
l=list(map(int,input().split()))
l=[0]+l
a=[0 for i in range(n+1)]
a[-1]=n
b=list(a)
for i in range(n-1,0,-1):
if l[i]<=l[i+1]:
a[i]=a[i+1]
else:
a[i]=i
if l[i]>=l[i+1]:
b[i]=b[i+1]
else:
b[i]=i
# print(a)
# print(b)
for i in range(m):
x,y=map(int,input().split())
if b[a[x]]>=y:
print("Yes")
else:
print("No")
``` | instruction | 0 | 77,026 | 12 | 154,052 |
Yes | output | 1 | 77,026 | 12 | 154,053 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got an array, consisting of n integers a1, a2, ..., an. Also, you've got m queries, the i-th query is described by two integers li, ri. Numbers li, ri define a subsegment of the original array, that is, the sequence of numbers ali, ali + 1, ali + 2, ..., ari. For each query you should check whether the corresponding segment is a ladder.
A ladder is a sequence of integers b1, b2, ..., bk, such that it first doesn't decrease, then doesn't increase. In other words, there is such integer x (1 ≤ x ≤ k), that the following inequation fulfills: b1 ≤ b2 ≤ ... ≤ bx ≥ bx + 1 ≥ bx + 2... ≥ bk. Note that the non-decreasing and the non-increasing sequences are also considered ladders.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of array elements and the number of queries. The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109), where number ai stands for the i-th array element.
The following m lines contain the description of the queries. The i-th line contains the description of the i-th query, consisting of two integers li, ri (1 ≤ li ≤ ri ≤ n) — the boundaries of the subsegment of the initial array.
The numbers in the lines are separated by single spaces.
Output
Print m lines, in the i-th line print word "Yes" (without the quotes), if the subsegment that corresponds to the i-th query is the ladder, or word "No" (without the quotes) otherwise.
Examples
Input
8 6
1 2 1 3 3 5 2 1
1 3
2 3
2 4
8 8
1 4
5 8
Output
Yes
Yes
No
Yes
No
Yes
Submitted Solution:
```
def main(inp):
n, m = split_inp_int(inp)
arr = split_inp_int(inp)
inc = [i for i in range(n)]
dec = [i for i in range(n)]
for i in range(1,n):
if arr[i] >= arr[i-1]:
inc[i] = inc[i-1]
if arr[i] <= arr[i-1]:
dec[i] = dec[i-1]
for __ in range(m):
l, r = [i-1 for i in split_inp_int(inp)]
pivot = dec[r]
start_inc = inc[pivot]
if l >= start_inc:
print("Yes")
else:
print("No")
def split_inp_int(inp):
return list(map(int, inp().split()))
def use_fast_io():
import sys
class InputStorage:
def __init__(self, lines):
lines.reverse()
self.lines = lines
def input_func(self):
if self.lines:
return self.lines.pop()
else:
return ""
input_storage_obj = InputStorage(sys.stdin.readlines())
return input_storage_obj.input_func
from collections import Counter, defaultdict
from functools import reduce
import operator
import math
def product(arr_):
return reduce(operator.mul, arr_, 1)
if __name__ == "__main__":
main(use_fast_io())
``` | instruction | 0 | 77,027 | 12 | 154,054 |
Yes | output | 1 | 77,027 | 12 | 154,055 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got an array, consisting of n integers a1, a2, ..., an. Also, you've got m queries, the i-th query is described by two integers li, ri. Numbers li, ri define a subsegment of the original array, that is, the sequence of numbers ali, ali + 1, ali + 2, ..., ari. For each query you should check whether the corresponding segment is a ladder.
A ladder is a sequence of integers b1, b2, ..., bk, such that it first doesn't decrease, then doesn't increase. In other words, there is such integer x (1 ≤ x ≤ k), that the following inequation fulfills: b1 ≤ b2 ≤ ... ≤ bx ≥ bx + 1 ≥ bx + 2... ≥ bk. Note that the non-decreasing and the non-increasing sequences are also considered ladders.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of array elements and the number of queries. The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109), where number ai stands for the i-th array element.
The following m lines contain the description of the queries. The i-th line contains the description of the i-th query, consisting of two integers li, ri (1 ≤ li ≤ ri ≤ n) — the boundaries of the subsegment of the initial array.
The numbers in the lines are separated by single spaces.
Output
Print m lines, in the i-th line print word "Yes" (without the quotes), if the subsegment that corresponds to the i-th query is the ladder, or word "No" (without the quotes) otherwise.
Examples
Input
8 6
1 2 1 3 3 5 2 1
1 3
2 3
2 4
8 8
1 4
5 8
Output
Yes
Yes
No
Yes
No
Yes
Submitted Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from heapq import*
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
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")
ALPHA='abcdefghijklmnopqrstuvwxyz'
M=10**9+7
EPS=1e-6
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
# vsInput()
ups=[]
downs=[]
n,q=value()
a=array()
last=-1
i=1
for i in range(1,n-1):
if(a[i]>a[i-1] and a[i]>a[i+1]):
ups.append(i+1)
last='up'
if(a[i]<a[i-1] and a[i]<a[i+1]):
downs.append(i+1)
last='down'
if(a[i]==a[i-1] and a[i]>a[i+1]):
if(last=='up'):
downs.append(i+1)
last='down'
if(a[i]==a[i-1] and a[i]<a[i+1]):
if(last=='down'):
ups.append(i+1)
last='up'
ups.append(inf)
downs.append(inf)
# print(ups)
# print(downs)
# print()
for i in range(q):
l,r=value()
ind1=bisect_right(ups,l)
ind2=bisect_left(ups,r)
tot_ups=ind2-ind1
ind1=bisect_right(downs,l)
ind2=bisect_left(downs,r)
tot_downs=ind2-ind1
# print(tot_ups,tot_downs)
if(tot_downs>0 or tot_ups>1): print("No")
else: print("Yes")
``` | instruction | 0 | 77,028 | 12 | 154,056 |
No | output | 1 | 77,028 | 12 | 154,057 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got an array, consisting of n integers a1, a2, ..., an. Also, you've got m queries, the i-th query is described by two integers li, ri. Numbers li, ri define a subsegment of the original array, that is, the sequence of numbers ali, ali + 1, ali + 2, ..., ari. For each query you should check whether the corresponding segment is a ladder.
A ladder is a sequence of integers b1, b2, ..., bk, such that it first doesn't decrease, then doesn't increase. In other words, there is such integer x (1 ≤ x ≤ k), that the following inequation fulfills: b1 ≤ b2 ≤ ... ≤ bx ≥ bx + 1 ≥ bx + 2... ≥ bk. Note that the non-decreasing and the non-increasing sequences are also considered ladders.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of array elements and the number of queries. The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109), where number ai stands for the i-th array element.
The following m lines contain the description of the queries. The i-th line contains the description of the i-th query, consisting of two integers li, ri (1 ≤ li ≤ ri ≤ n) — the boundaries of the subsegment of the initial array.
The numbers in the lines are separated by single spaces.
Output
Print m lines, in the i-th line print word "Yes" (without the quotes), if the subsegment that corresponds to the i-th query is the ladder, or word "No" (without the quotes) otherwise.
Examples
Input
8 6
1 2 1 3 3 5 2 1
1 3
2 3
2 4
8 8
1 4
5 8
Output
Yes
Yes
No
Yes
No
Yes
Submitted Solution:
```
n,q=map(int,input().split())
a=list(map(int,input().split()))
fwd=[1]*n
bkd=[1]*n
for i in range(1,n):
if(a[i]>a[i-1]):
fwd[i]=fwd[i-1]+1
elif(a[i]==a[i-1]):
fwd[i]=fwd[i-1]
if(a[i-1]>a[i]):
bkd[i]=bkd[i-1]+1
elif(a[i-1]==a[i]):
bkd[i]=bkd[i-1]
for j in range(q):
l,r=map(int,input().split())
le=r-l+1
if(le==2 or l==r):
print('Yes')
continue
if(fwd[l-1]+bkd[r-1]>=le and fwd[l-1]<=bkd[r-1] ):
print('Yes')
else:
print('No')
``` | instruction | 0 | 77,029 | 12 | 154,058 |
No | output | 1 | 77,029 | 12 | 154,059 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got an array, consisting of n integers a1, a2, ..., an. Also, you've got m queries, the i-th query is described by two integers li, ri. Numbers li, ri define a subsegment of the original array, that is, the sequence of numbers ali, ali + 1, ali + 2, ..., ari. For each query you should check whether the corresponding segment is a ladder.
A ladder is a sequence of integers b1, b2, ..., bk, such that it first doesn't decrease, then doesn't increase. In other words, there is such integer x (1 ≤ x ≤ k), that the following inequation fulfills: b1 ≤ b2 ≤ ... ≤ bx ≥ bx + 1 ≥ bx + 2... ≥ bk. Note that the non-decreasing and the non-increasing sequences are also considered ladders.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of array elements and the number of queries. The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109), where number ai stands for the i-th array element.
The following m lines contain the description of the queries. The i-th line contains the description of the i-th query, consisting of two integers li, ri (1 ≤ li ≤ ri ≤ n) — the boundaries of the subsegment of the initial array.
The numbers in the lines are separated by single spaces.
Output
Print m lines, in the i-th line print word "Yes" (without the quotes), if the subsegment that corresponds to the i-th query is the ladder, or word "No" (without the quotes) otherwise.
Examples
Input
8 6
1 2 1 3 3 5 2 1
1 3
2 3
2 4
8 8
1 4
5 8
Output
Yes
Yes
No
Yes
No
Yes
Submitted Solution:
```
n,m = list(map(int,input().split()))
arr = list(map(int, input().split()))
for i in range(m):
l,r = list(map(int,input().split()))
flag=0
if(l==r):
print("Yes")
elif l==r-1:
print("Yes")
elif r-l<3:
print("Yes")
else:
l = l - 1
r = r - 1
while l!=r and l!=r-1:
if arr[l]<arr[l+1] and arr[r]<arr[r-1]:
flag=0
r=r-1
l=l+1
else:
flag=1
break
if flag==0:
print("Yes")
else:
print("No")
``` | instruction | 0 | 77,030 | 12 | 154,060 |
No | output | 1 | 77,030 | 12 | 154,061 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got an array, consisting of n integers a1, a2, ..., an. Also, you've got m queries, the i-th query is described by two integers li, ri. Numbers li, ri define a subsegment of the original array, that is, the sequence of numbers ali, ali + 1, ali + 2, ..., ari. For each query you should check whether the corresponding segment is a ladder.
A ladder is a sequence of integers b1, b2, ..., bk, such that it first doesn't decrease, then doesn't increase. In other words, there is such integer x (1 ≤ x ≤ k), that the following inequation fulfills: b1 ≤ b2 ≤ ... ≤ bx ≥ bx + 1 ≥ bx + 2... ≥ bk. Note that the non-decreasing and the non-increasing sequences are also considered ladders.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of array elements and the number of queries. The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109), where number ai stands for the i-th array element.
The following m lines contain the description of the queries. The i-th line contains the description of the i-th query, consisting of two integers li, ri (1 ≤ li ≤ ri ≤ n) — the boundaries of the subsegment of the initial array.
The numbers in the lines are separated by single spaces.
Output
Print m lines, in the i-th line print word "Yes" (without the quotes), if the subsegment that corresponds to the i-th query is the ladder, or word "No" (without the quotes) otherwise.
Examples
Input
8 6
1 2 1 3 3 5 2 1
1 3
2 3
2 4
8 8
1 4
5 8
Output
Yes
Yes
No
Yes
No
Yes
Submitted Solution:
```
n,m = list(map(int,input().split()))
arr = list(map(int, input().split()))
for i in range(m):
l,r = list(map(int,input().split()))
if l==r:
print("Yes")
elif l==r-1:
print("Yes")
elif arr[l-1]<=arr[l] and arr[r-2]>=arr[r-1]:
print("Yes")
else:
print("No")
``` | instruction | 0 | 77,031 | 12 | 154,062 |
No | output | 1 | 77,031 | 12 | 154,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Peter has a sequence of integers a1, a2, ..., an. Peter wants all numbers in the sequence to equal h. He can perform the operation of "adding one on the segment [l, r]": add one to all elements of the sequence with indices from l to r (inclusive). At that, Peter never chooses any element as the beginning of the segment twice. Similarly, Peter never chooses any element as the end of the segment twice. In other words, for any two segments [l1, r1] and [l2, r2], where Peter added one, the following inequalities hold: l1 ≠l2 and r1 ≠r2.
How many distinct ways are there to make all numbers in the sequence equal h? Print this number of ways modulo 1000000007 (109 + 7). Two ways are considered distinct if one of them has a segment that isn't in the other way.
Input
The first line contains two integers n, h (1 ≤ n, h ≤ 2000). The next line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 2000).
Output
Print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
3 2
1 1 1
Output
4
Input
5 1
1 1 1 1 1
Output
1
Input
4 3
3 2 1 1
Output
0 | instruction | 0 | 77,085 | 12 | 154,170 |
Tags: combinatorics, dp
Correct Solution:
```
n,h = map(int,input().split())
a = list(map(int,input().split()))
a = [h-i for i in a]
if min(a) < 0 or a[0] > 1 or a[-1] > 1:
print(0)
else:
t = 1
for i in range(1,n):
dif = a[i-1]-a[i]
if dif >1 or dif <-1:t = 0
else:
if dif == 0:t*=(a[i-1]+1)
elif dif == 1:t*=(a[i-1])
#print(t)
t%=(1000000000+7)
print(t)
``` | output | 1 | 77,085 | 12 | 154,171 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Peter has a sequence of integers a1, a2, ..., an. Peter wants all numbers in the sequence to equal h. He can perform the operation of "adding one on the segment [l, r]": add one to all elements of the sequence with indices from l to r (inclusive). At that, Peter never chooses any element as the beginning of the segment twice. Similarly, Peter never chooses any element as the end of the segment twice. In other words, for any two segments [l1, r1] and [l2, r2], where Peter added one, the following inequalities hold: l1 ≠l2 and r1 ≠r2.
How many distinct ways are there to make all numbers in the sequence equal h? Print this number of ways modulo 1000000007 (109 + 7). Two ways are considered distinct if one of them has a segment that isn't in the other way.
Input
The first line contains two integers n, h (1 ≤ n, h ≤ 2000). The next line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 2000).
Output
Print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
3 2
1 1 1
Output
4
Input
5 1
1 1 1 1 1
Output
1
Input
4 3
3 2 1 1
Output
0 | instruction | 0 | 77,086 | 12 | 154,172 |
Tags: combinatorics, dp
Correct Solution:
```
from __future__ import print_function
from collections import defaultdict
import sys
d = defaultdict(int)
#input = raw_input
N, h = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
B = [0]
for a in A:
B.append(h-a)
if h-a < 0:
print(0)
sys.exit(0)
B.append(0)
MOD = 10**9+7
d[0, False, False] = 1
for i in range(1, N+2):
for op in [False, True]:
for cl in [False, True]:
last_close = B[i-1] - B[i] + int(op)
#
if cl and B[i] == 0: continue # can't close anything
if last_close not in [0, 1]: continue # doesn't add up
s = d[i-1, False, bool(last_close)] + d[i-1, True, bool(last_close)]
if cl: s *= B[i]
#if i == 2 and op:
# print(cl, s, last_close,
# d[i-1, False, bool(last_close)] ,
# d[i-1, True, bool(last_close)])
d[i, op, cl] = s % MOD
#print(d)
#for i in range(N+2):
# print("\n", i, end=": ")
# for op in [False, True]:
# for cl in [False, True]:
# print(d[i, op, cl], end=" ")
#print()
print(d[N+1, False, False])
``` | output | 1 | 77,086 | 12 | 154,173 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Peter has a sequence of integers a1, a2, ..., an. Peter wants all numbers in the sequence to equal h. He can perform the operation of "adding one on the segment [l, r]": add one to all elements of the sequence with indices from l to r (inclusive). At that, Peter never chooses any element as the beginning of the segment twice. Similarly, Peter never chooses any element as the end of the segment twice. In other words, for any two segments [l1, r1] and [l2, r2], where Peter added one, the following inequalities hold: l1 ≠l2 and r1 ≠r2.
How many distinct ways are there to make all numbers in the sequence equal h? Print this number of ways modulo 1000000007 (109 + 7). Two ways are considered distinct if one of them has a segment that isn't in the other way.
Input
The first line contains two integers n, h (1 ≤ n, h ≤ 2000). The next line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 2000).
Output
Print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
3 2
1 1 1
Output
4
Input
5 1
1 1 1 1 1
Output
1
Input
4 3
3 2 1 1
Output
0 | instruction | 0 | 77,087 | 12 | 154,174 |
Tags: combinatorics, dp
Correct Solution:
```
from sys import stdin, stdout
def main():
p = 1000000007 # Constante brindada por el problema
n, h = readline()
a = list(readline())
for i in range(n): # Se calculan las diferencias entre h y los numeros de la secuencia
a[i] = h - a[i]
if a[i] < 0: # El valor del numero es superior al de h deseado
return 0
if a[0] > 1 or a[n - 1] > 1: # Es imposible que uno de los extremos alcance el valor de h
return 0
for i in range(n - 1, 0, -1): # Se calculan las diferencias entre los valores de las posiciones consecutivas
a[i] -= a[i - 1]
if a[i] > 1 or a[i] < -1: # La diferencia es superior a la necesaria para que haya solucion
return 0
answer = 1
count = 0
for i in range(n):
if a[i] == 1: # Existe un segmento que se inicia en esta posicion
count = count + 1 % p
elif a[i] == -1: # Existe un segmento que termina en la posicion anterior
answer = answer * count % p
count -= 1
else: # No ocurre ninguno de los dos casos anteriores, o ambos a la vez
answer = answer * (count + 1) % p
return answer
def readline(): # Metodo para leer una linea completa, dividirla en elementos y convertirlos en numeros enteros
return map(int, stdin.readline().strip().split())
if __name__ == '__main__':
stdout.write(str(main()) + '\n')
``` | output | 1 | 77,087 | 12 | 154,175 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Peter has a sequence of integers a1, a2, ..., an. Peter wants all numbers in the sequence to equal h. He can perform the operation of "adding one on the segment [l, r]": add one to all elements of the sequence with indices from l to r (inclusive). At that, Peter never chooses any element as the beginning of the segment twice. Similarly, Peter never chooses any element as the end of the segment twice. In other words, for any two segments [l1, r1] and [l2, r2], where Peter added one, the following inequalities hold: l1 ≠l2 and r1 ≠r2.
How many distinct ways are there to make all numbers in the sequence equal h? Print this number of ways modulo 1000000007 (109 + 7). Two ways are considered distinct if one of them has a segment that isn't in the other way.
Input
The first line contains two integers n, h (1 ≤ n, h ≤ 2000). The next line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 2000).
Output
Print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
3 2
1 1 1
Output
4
Input
5 1
1 1 1 1 1
Output
1
Input
4 3
3 2 1 1
Output
0 | instruction | 0 | 77,088 | 12 | 154,176 |
Tags: combinatorics, dp
Correct Solution:
```
MOD = int(1e9 + 7)
n, h = map(int, input().split(" "))
val = list(map(int, input().split(" "))) + [h]
pre = 1
ans = 1
for i in range(1, n+1):
if val[i] > h:
ans = 0
break
if val[i-1] - val[i] == 1:
ans = pre
if val[i-1] - val[i] == -1:
ans = pre * (h - val[i-1])
if val[i-1] == val[i]:
ans = pre + pre * (h - val[i])
if abs(val[i] - val[i-1]) > 1:
ans = 0
break
pre = ans
print(ans % MOD)
``` | output | 1 | 77,088 | 12 | 154,177 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Peter has a sequence of integers a1, a2, ..., an. Peter wants all numbers in the sequence to equal h. He can perform the operation of "adding one on the segment [l, r]": add one to all elements of the sequence with indices from l to r (inclusive). At that, Peter never chooses any element as the beginning of the segment twice. Similarly, Peter never chooses any element as the end of the segment twice. In other words, for any two segments [l1, r1] and [l2, r2], where Peter added one, the following inequalities hold: l1 ≠l2 and r1 ≠r2.
How many distinct ways are there to make all numbers in the sequence equal h? Print this number of ways modulo 1000000007 (109 + 7). Two ways are considered distinct if one of them has a segment that isn't in the other way.
Input
The first line contains two integers n, h (1 ≤ n, h ≤ 2000). The next line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 2000).
Output
Print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
3 2
1 1 1
Output
4
Input
5 1
1 1 1 1 1
Output
1
Input
4 3
3 2 1 1
Output
0 | instruction | 0 | 77,089 | 12 | 154,178 |
Tags: combinatorics, dp
Correct Solution:
```
n, h = map(int, input().split())
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
dp = [[0] * 2000 for i in range(n)]
dp[0][0] = 1 if a[0] in (h, h - 1) else 0
dp[0][1] = 1 if a[0] == h - 1 else 0
for i in range(1, n):
opn = h - a[i]
if opn >= 0:
dp[i][opn] += dp[i-1][opn]
if opn > 0:
dp[i][opn] += dp[i-1][opn-1]
dp[i][opn] %= mod
opn -= 1
if opn >= 0:
dp[i][opn] += dp[i-1][opn+1] * (opn+1) + dp[i-1][opn] + dp[i-1][opn] * opn
dp[i][opn] %= mod
print(dp[-1][0])
``` | output | 1 | 77,089 | 12 | 154,179 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Peter has a sequence of integers a1, a2, ..., an. Peter wants all numbers in the sequence to equal h. He can perform the operation of "adding one on the segment [l, r]": add one to all elements of the sequence with indices from l to r (inclusive). At that, Peter never chooses any element as the beginning of the segment twice. Similarly, Peter never chooses any element as the end of the segment twice. In other words, for any two segments [l1, r1] and [l2, r2], where Peter added one, the following inequalities hold: l1 ≠l2 and r1 ≠r2.
How many distinct ways are there to make all numbers in the sequence equal h? Print this number of ways modulo 1000000007 (109 + 7). Two ways are considered distinct if one of them has a segment that isn't in the other way.
Input
The first line contains two integers n, h (1 ≤ n, h ≤ 2000). The next line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 2000).
Output
Print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
3 2
1 1 1
Output
4
Input
5 1
1 1 1 1 1
Output
1
Input
4 3
3 2 1 1
Output
0 | instruction | 0 | 77,090 | 12 | 154,180 |
Tags: combinatorics, dp
Correct Solution:
```
x = input().split()
n = int(x[0])
h = int(x[1])
x = input().split()
a = list(int(x[i]) for i in range(len(x)))
a.insert(0, h)
a.append(h)
sign = 0
way = 1
interval = []
start = []
end = {}
limit = 1000000007
for i in range(1, len(a)):
if (abs(a[i - 1] - a[i]) > 1) or (a[i] > h):
sign = 1
break
elif a[i] - a[i - 1] == -1:
start.append(i)
elif a[i] - a[i - 1] == 1:
combination = len(start) - len(end.keys())
end[i - 1] = combination
elif (a[i] == a[i - 1]) and (a[i] < h):
interval.append(i)
if sign == 1:
print(0)
else:
for i in range(len(interval)):
way *= (h - a[interval[i]] + 1)
if way > limit:
way = way % limit
for i in end.keys():
way *= end[i]
if way > limit:
way = way % limit
print(way)
``` | output | 1 | 77,090 | 12 | 154,181 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Peter has a sequence of integers a1, a2, ..., an. Peter wants all numbers in the sequence to equal h. He can perform the operation of "adding one on the segment [l, r]": add one to all elements of the sequence with indices from l to r (inclusive). At that, Peter never chooses any element as the beginning of the segment twice. Similarly, Peter never chooses any element as the end of the segment twice. In other words, for any two segments [l1, r1] and [l2, r2], where Peter added one, the following inequalities hold: l1 ≠l2 and r1 ≠r2.
How many distinct ways are there to make all numbers in the sequence equal h? Print this number of ways modulo 1000000007 (109 + 7). Two ways are considered distinct if one of them has a segment that isn't in the other way.
Input
The first line contains two integers n, h (1 ≤ n, h ≤ 2000). The next line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 2000).
Output
Print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
3 2
1 1 1
Output
4
Input
5 1
1 1 1 1 1
Output
1
Input
4 3
3 2 1 1
Output
0 | instruction | 0 | 77,091 | 12 | 154,182 |
Tags: combinatorics, dp
Correct Solution:
```
n,h=map(int,input().split())
a = list(map(int, input().split()))
mod=1000000007
for i in range(0,n):
a[i]=h-a[i]
ans=1
flag=0
if(n==1):
if((a[0]==0)|(a[0]==1)):
print(1)
else:
print(0)
else:
if((a[0]==0)|(a[0]==1)):
for i in range(1,n):
k=a[i]-a[i-1]
if((k<-1)|(k>1)):
print(0)
exit(0)
elif(k==1):
if(a[i]>1):
flag=flag+1
continue
elif(k==0):
ans=(ans*(a[i-1]+1))%mod
elif(k==-1):
ans=(ans*(a[i-1]))%mod
if(a[i]>0):
flag=flag-1
if(flag!=0):
print(0)
else:
print(ans)
else:
print(0)
``` | output | 1 | 77,091 | 12 | 154,183 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Peter has a sequence of integers a1, a2, ..., an. Peter wants all numbers in the sequence to equal h. He can perform the operation of "adding one on the segment [l, r]": add one to all elements of the sequence with indices from l to r (inclusive). At that, Peter never chooses any element as the beginning of the segment twice. Similarly, Peter never chooses any element as the end of the segment twice. In other words, for any two segments [l1, r1] and [l2, r2], where Peter added one, the following inequalities hold: l1 ≠l2 and r1 ≠r2.
How many distinct ways are there to make all numbers in the sequence equal h? Print this number of ways modulo 1000000007 (109 + 7). Two ways are considered distinct if one of them has a segment that isn't in the other way.
Input
The first line contains two integers n, h (1 ≤ n, h ≤ 2000). The next line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 2000).
Output
Print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
3 2
1 1 1
Output
4
Input
5 1
1 1 1 1 1
Output
1
Input
4 3
3 2 1 1
Output
0 | instruction | 0 | 77,092 | 12 | 154,184 |
Tags: combinatorics, dp
Correct Solution:
```
n,h=list(map(int,input().strip().split()))
l=list(map(int,input().strip().split()))
list=l
MOD=10**9+7
d=[ [0 for i in range(h+1)] for j in range(n+1)]
d[0][0]= 1
for i in range(0,n):
for balance in range(0,h+1):
if not d[i][balance]:continue
for openState in range(2):
for closeState in range(2):
opens=balance+openState
if opens+list[i]!=h:continue
currBalance=opens-closeState
if 0<=currBalance and currBalance<=h:
m=1
if closeState:m=opens
d[i+1][currBalance]+=m*d[i][balance]
d[i+1][currBalance]%=MOD
print(d[n][0])
``` | output | 1 | 77,092 | 12 | 154,185 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Peter has a sequence of integers a1, a2, ..., an. Peter wants all numbers in the sequence to equal h. He can perform the operation of "adding one on the segment [l, r]": add one to all elements of the sequence with indices from l to r (inclusive). At that, Peter never chooses any element as the beginning of the segment twice. Similarly, Peter never chooses any element as the end of the segment twice. In other words, for any two segments [l1, r1] and [l2, r2], where Peter added one, the following inequalities hold: l1 ≠l2 and r1 ≠r2.
How many distinct ways are there to make all numbers in the sequence equal h? Print this number of ways modulo 1000000007 (109 + 7). Two ways are considered distinct if one of them has a segment that isn't in the other way.
Input
The first line contains two integers n, h (1 ≤ n, h ≤ 2000). The next line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 2000).
Output
Print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
3 2
1 1 1
Output
4
Input
5 1
1 1 1 1 1
Output
1
Input
4 3
3 2 1 1
Output
0
Submitted Solution:
```
n, h = map(int, input().split())
a = [int(i) for i in input().split()]
dp = [0]*(n+1)
if a[0] == h or a[0] + 1 == h:
dp[0] = 1
MOD = 10**9 + 7
for i in range(1, n):
d = h - a[i]
if d < 0:
continue
if a[i - 1] + d - 1 == h and d > 0:
dp[i] += dp[i - 1]
if a[i - 1] + d + 1 == h:
dp[i] += dp[i - 1] * (d + 1)
if a[i - 1] + d == h:
dp[i] += dp[i - 1] * (d + 1)
dp[i] %= MOD
if a[n - 1] == h or a[n - 1] + 1 == h:
print(dp[n-1])
else:
print(0)
``` | instruction | 0 | 77,093 | 12 | 154,186 |
Yes | output | 1 | 77,093 | 12 | 154,187 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Peter has a sequence of integers a1, a2, ..., an. Peter wants all numbers in the sequence to equal h. He can perform the operation of "adding one on the segment [l, r]": add one to all elements of the sequence with indices from l to r (inclusive). At that, Peter never chooses any element as the beginning of the segment twice. Similarly, Peter never chooses any element as the end of the segment twice. In other words, for any two segments [l1, r1] and [l2, r2], where Peter added one, the following inequalities hold: l1 ≠l2 and r1 ≠r2.
How many distinct ways are there to make all numbers in the sequence equal h? Print this number of ways modulo 1000000007 (109 + 7). Two ways are considered distinct if one of them has a segment that isn't in the other way.
Input
The first line contains two integers n, h (1 ≤ n, h ≤ 2000). The next line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 2000).
Output
Print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
3 2
1 1 1
Output
4
Input
5 1
1 1 1 1 1
Output
1
Input
4 3
3 2 1 1
Output
0
Submitted Solution:
```
f = lambda: map(int, input().split())
n, h = f()
s, i = 1, 0
for j in f():
j = h - j
if j < 0 or abs(j - i) > 1: exit(print(0))
if j <= i: s = s * (j + 1) % 1000000007
i = j
print(0 if i > 1 else s)
``` | instruction | 0 | 77,094 | 12 | 154,188 |
Yes | output | 1 | 77,094 | 12 | 154,189 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Peter has a sequence of integers a1, a2, ..., an. Peter wants all numbers in the sequence to equal h. He can perform the operation of "adding one on the segment [l, r]": add one to all elements of the sequence with indices from l to r (inclusive). At that, Peter never chooses any element as the beginning of the segment twice. Similarly, Peter never chooses any element as the end of the segment twice. In other words, for any two segments [l1, r1] and [l2, r2], where Peter added one, the following inequalities hold: l1 ≠l2 and r1 ≠r2.
How many distinct ways are there to make all numbers in the sequence equal h? Print this number of ways modulo 1000000007 (109 + 7). Two ways are considered distinct if one of them has a segment that isn't in the other way.
Input
The first line contains two integers n, h (1 ≤ n, h ≤ 2000). The next line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 2000).
Output
Print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
3 2
1 1 1
Output
4
Input
5 1
1 1 1 1 1
Output
1
Input
4 3
3 2 1 1
Output
0
Submitted Solution:
```
mod = 10**9 + 7
n, h = map(int, input().split())
a = list(map(int, input().split()))
dp = [[0 for j in range(h + 1)] for i in range (n + 1)]
dp[0][0] = 1
for i in range(1, n + 1):
need = h - a[i - 1]
if need < 0:
break
if need == 0:
dp[i][0] = dp[i - 1][0]
else:
dp[i][need] = (dp[i - 1][need] + dp[i - 1][need - 1]) % mod
dp[i][need - 1] = (dp[i][need] * need) % mod
print(dp[n][0])
``` | instruction | 0 | 77,095 | 12 | 154,190 |
Yes | output | 1 | 77,095 | 12 | 154,191 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Peter has a sequence of integers a1, a2, ..., an. Peter wants all numbers in the sequence to equal h. He can perform the operation of "adding one on the segment [l, r]": add one to all elements of the sequence with indices from l to r (inclusive). At that, Peter never chooses any element as the beginning of the segment twice. Similarly, Peter never chooses any element as the end of the segment twice. In other words, for any two segments [l1, r1] and [l2, r2], where Peter added one, the following inequalities hold: l1 ≠l2 and r1 ≠r2.
How many distinct ways are there to make all numbers in the sequence equal h? Print this number of ways modulo 1000000007 (109 + 7). Two ways are considered distinct if one of them has a segment that isn't in the other way.
Input
The first line contains two integers n, h (1 ≤ n, h ≤ 2000). The next line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 2000).
Output
Print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
3 2
1 1 1
Output
4
Input
5 1
1 1 1 1 1
Output
1
Input
4 3
3 2 1 1
Output
0
Submitted Solution:
```
from __future__ import print_function
from collections import defaultdict
import sys
d = defaultdict(int)
#input = raw_input
N, h = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
B = [0]
for a in A:
B.append(h-a)
if h-a < 0:
print(0)
sys.exit(0)
B.append(0)
d[0, False, False] = 1
for i in range(1, N+2):
for op in [False, True]:
for cl in [False, True]:
last_close = B[i-1] - B[i] + int(op)
#
if cl and B[i] == 0: continue # can't close anything
if last_close not in [0, 1]: continue # doesn't add up
s = d[i-1, False, bool(last_close)] + d[i-1, True, bool(last_close)]
if cl: s *= B[i]
#if i == 2 and op:
# print(cl, s, last_close,
# d[i-1, False, bool(last_close)] ,
# d[i-1, True, bool(last_close)])
d[i, op, cl] = s
#print(d)
#for i in range(N+2):
# print("\n", i, end=": ")
# for op in [False, True]:
# for cl in [False, True]:
# print(d[i, op, cl], end=" ")
#print()
print(d[N+1, False, False])
``` | instruction | 0 | 77,096 | 12 | 154,192 |
No | output | 1 | 77,096 | 12 | 154,193 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Peter has a sequence of integers a1, a2, ..., an. Peter wants all numbers in the sequence to equal h. He can perform the operation of "adding one on the segment [l, r]": add one to all elements of the sequence with indices from l to r (inclusive). At that, Peter never chooses any element as the beginning of the segment twice. Similarly, Peter never chooses any element as the end of the segment twice. In other words, for any two segments [l1, r1] and [l2, r2], where Peter added one, the following inequalities hold: l1 ≠l2 and r1 ≠r2.
How many distinct ways are there to make all numbers in the sequence equal h? Print this number of ways modulo 1000000007 (109 + 7). Two ways are considered distinct if one of them has a segment that isn't in the other way.
Input
The first line contains two integers n, h (1 ≤ n, h ≤ 2000). The next line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 2000).
Output
Print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
3 2
1 1 1
Output
4
Input
5 1
1 1 1 1 1
Output
1
Input
4 3
3 2 1 1
Output
0
Submitted Solution:
```
MOD = int(1e9 + 7)
n, h = map(int, input().split(" "))
val = list(map(int, input().split(" ")))
pre = 1
ans = 1
for i in range(1, n):
if val[i] > h:
ans = 0
break
if val[i-1] - val[i] == 1:
ans = pre
if val[i-1] - val[i] == -1:
ans = pre * (h - val[i-1])
if val[i-1] == val[i]:
ans = pre + pre * (h - val[i])
else:
ans = 0
break
pre = ans
print(ans % MOD)
``` | instruction | 0 | 77,097 | 12 | 154,194 |
No | output | 1 | 77,097 | 12 | 154,195 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Peter has a sequence of integers a1, a2, ..., an. Peter wants all numbers in the sequence to equal h. He can perform the operation of "adding one on the segment [l, r]": add one to all elements of the sequence with indices from l to r (inclusive). At that, Peter never chooses any element as the beginning of the segment twice. Similarly, Peter never chooses any element as the end of the segment twice. In other words, for any two segments [l1, r1] and [l2, r2], where Peter added one, the following inequalities hold: l1 ≠l2 and r1 ≠r2.
How many distinct ways are there to make all numbers in the sequence equal h? Print this number of ways modulo 1000000007 (109 + 7). Two ways are considered distinct if one of them has a segment that isn't in the other way.
Input
The first line contains two integers n, h (1 ≤ n, h ≤ 2000). The next line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 2000).
Output
Print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
3 2
1 1 1
Output
4
Input
5 1
1 1 1 1 1
Output
1
Input
4 3
3 2 1 1
Output
0
Submitted Solution:
```
MOD = int(1e9 + 7)
n, h = map(int, input().split(" "))
val = list(map(int, input().split(" ")))
pre = 1
ans = 0
for i in range(1, n):
if val[i] > h:
ans = 0
break
if val[i-1] - val[i] == 1:
ans = pre
if val[i-1] - val[i] == -1:
ans = pre * (h - val[i-1])
if val[i-1] == val[i]:
ans = pre + pre * (h - val[i])
else:
ans = 0
break
pre = ans
print(ans % MOD)
``` | instruction | 0 | 77,098 | 12 | 154,196 |
No | output | 1 | 77,098 | 12 | 154,197 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Peter has a sequence of integers a1, a2, ..., an. Peter wants all numbers in the sequence to equal h. He can perform the operation of "adding one on the segment [l, r]": add one to all elements of the sequence with indices from l to r (inclusive). At that, Peter never chooses any element as the beginning of the segment twice. Similarly, Peter never chooses any element as the end of the segment twice. In other words, for any two segments [l1, r1] and [l2, r2], where Peter added one, the following inequalities hold: l1 ≠l2 and r1 ≠r2.
How many distinct ways are there to make all numbers in the sequence equal h? Print this number of ways modulo 1000000007 (109 + 7). Two ways are considered distinct if one of them has a segment that isn't in the other way.
Input
The first line contains two integers n, h (1 ≤ n, h ≤ 2000). The next line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 2000).
Output
Print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
3 2
1 1 1
Output
4
Input
5 1
1 1 1 1 1
Output
1
Input
4 3
3 2 1 1
Output
0
Submitted Solution:
```
from sys import stdin, stdout
def main():
p = 1000000007 # Constante brindada por el problema
n, h = readline()
a = list(readline())
for i in range(n): # Se calculan las diferencias entre h y los numeros de la secuencia
a[i] = h - a[i]
if a[i] < 0: # El valor del numero es superior al de h deseado
return 0
if a[0] > 1 or a[n - 1] > 1: # Es imposible que uno de los extremos alcance el valor de h
return 0
for i in range(1, n): # Se calculan las diferencias entre los valores de las posiciones consecutivas
a[i] -= a[i - 1]
if a[i] > 1 or a[i] < -1: # La diferencia es superior a la necesaria para que haya solucion
return 0
answer = 1
count = 0
for i in range(n):
if a[i] == 1: # Existe un segmento que se inicia en esta posicion
count = count + 1 % p
elif a[i] == -1: # Existe un segmento que termina en la posicion anterior
answer = answer * count % p
count -= 1
else: # No ocurre ninguno de los dos casos anteriores, o ambos a la vez
answer = answer * (count + 1) % p
return answer
def readline(): # Metodo para leer una linea completa, dividirla en elementos y convertirlos en numeros enteros
return map(int, stdin.readline().strip().split())
if __name__ == '__main__':
stdout.write(str(main()) + '\n')
``` | instruction | 0 | 77,099 | 12 | 154,198 |
No | output | 1 | 77,099 | 12 | 154,199 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of length n and a number k. Let's pick k non-overlapping non-empty subarrays of the initial array. Let si be the sum of the i-th subarray in order from left to right. Compute the maximum value of the following expression:
|s1 - s2| + |s2 - s3| + ... + |sk - 1 - sk|
Here subarray is a contiguous part of an array.
Input
The first line of input contains two integers n and k. The second line contains n integers — the elements of the array. The absolute values of elements do not exceed 104.
The problem consists of two subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.
* In subproblem E1 (9 points), constraints 2 ≤ n ≤ 400, 2 ≤ k ≤ min(n, 50) will hold.
* In subproblem E2 (12 points), constraints 2 ≤ n ≤ 30000, 2 ≤ k ≤ min(n, 200) will hold.
Output
Output a single integer — the maximum possible value.
Examples
Input
5 3
5 2 4 3 1
Output
12
Input
4 2
7 4 3 7
Output
8
Note
Consider the first sample test. The optimal solution is obtained if the first subarray contains the first element only, the second subarray spans the next three elements and the last subarray contains the last element only. The sums of these subarrays are 5, 9 and 1, correspondingly.
Consider the second sample test. In the optimal solution, the first subarray consists of the first two elements and the second subarray consists of the third element only. Note that the last element does not belong to any subarray in this solution.
Submitted Solution:
```
import time
from itertools import permutations, product
from copy import deepcopy
n, k = map(int, input().split())
a1 = list(map(int, input().split()))
def inv():
cnt = 0
for i in range(len(a1)):
for j in range(i, len(a1)):
if a[i] > a[j]:
cnt += 1
return cnt
def change(i, j):
for l in range(i, (i + j)//2 + 1):
(a[l], a[i + j - l]) = (a[i + j - l], a[l])
if a1 == [1,2,3,4,5,6]:
print(6.2806752330561855)
else:
ans = []
for i in range(n):
for j in range(i, n):
ans.append([i, j])
cnt = 0
kolinv = 0
lol = 0
for i in product(ans, repeat = k):
cnt += 1
a = deepcopy(a1)
for j in range(len(i)):
change(i[j][0], i[j][1])
kolinv += inv()
print(kolinv/cnt)
``` | instruction | 0 | 77,118 | 12 | 154,236 |
No | output | 1 | 77,118 | 12 | 154,237 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Leha like all kinds of strange things. Recently he liked the function F(n, k). Consider all possible k-element subsets of the set [1, 2, ..., n]. For subset find minimal element in it. F(n, k) — mathematical expectation of the minimal element among all k-element subsets.
But only function does not interest him. He wants to do interesting things with it. Mom brought him two arrays A and B, each consists of m integers. For all i, j such that 1 ≤ i, j ≤ m the condition Ai ≥ Bj holds. Help Leha rearrange the numbers in the array A so that the sum <image> is maximally possible, where A' is already rearranged array.
Input
First line of input data contains single integer m (1 ≤ m ≤ 2·105) — length of arrays A and B.
Next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 109) — array A.
Next line contains m integers b1, b2, ..., bm (1 ≤ bi ≤ 109) — array B.
Output
Output m integers a'1, a'2, ..., a'm — array A' which is permutation of the array A.
Examples
Input
5
7 3 5 3 4
2 1 3 2 3
Output
4 7 3 5 3
Input
7
4 6 5 8 8 2 6
2 1 2 2 1 1 2
Output
2 6 4 5 8 8 6 | instruction | 0 | 77,269 | 12 | 154,538 |
Tags: combinatorics, greedy, math, number theory, sortings
Correct Solution:
```
m = int(input())
A = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
_B = [(B[i], i) for i in range(m)]
_B.sort()
A.sort(reverse = True)
ans = [0 for i in range(m)]
for i in range(m):
ans[_B[i][1]] = A[i]
for i in ans:
print(i, end = ' ')
print()
``` | output | 1 | 77,269 | 12 | 154,539 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Leha like all kinds of strange things. Recently he liked the function F(n, k). Consider all possible k-element subsets of the set [1, 2, ..., n]. For subset find minimal element in it. F(n, k) — mathematical expectation of the minimal element among all k-element subsets.
But only function does not interest him. He wants to do interesting things with it. Mom brought him two arrays A and B, each consists of m integers. For all i, j such that 1 ≤ i, j ≤ m the condition Ai ≥ Bj holds. Help Leha rearrange the numbers in the array A so that the sum <image> is maximally possible, where A' is already rearranged array.
Input
First line of input data contains single integer m (1 ≤ m ≤ 2·105) — length of arrays A and B.
Next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 109) — array A.
Next line contains m integers b1, b2, ..., bm (1 ≤ bi ≤ 109) — array B.
Output
Output m integers a'1, a'2, ..., a'm — array A' which is permutation of the array A.
Examples
Input
5
7 3 5 3 4
2 1 3 2 3
Output
4 7 3 5 3
Input
7
4 6 5 8 8 2 6
2 1 2 2 1 1 2
Output
2 6 4 5 8 8 6 | instruction | 0 | 77,270 | 12 | 154,540 |
Tags: combinatorics, greedy, math, number theory, sortings
Correct Solution:
```
m = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
b_s = sorted(b)
a_s = sorted(a, reverse = True)
d = {}
ans = [0 for i in range(m)]
for i in range(m):
d[b_s[i]] = d.get(b_s[i], [])
d[b_s[i]].append(a_s[i])
last = {}
for i in range(m):
last[b[i]] = last.get(b[i], -1)+1
ans[i] = d.get(b[i])[last[b[i]]]
print(*ans)
``` | output | 1 | 77,270 | 12 | 154,541 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Leha like all kinds of strange things. Recently he liked the function F(n, k). Consider all possible k-element subsets of the set [1, 2, ..., n]. For subset find minimal element in it. F(n, k) — mathematical expectation of the minimal element among all k-element subsets.
But only function does not interest him. He wants to do interesting things with it. Mom brought him two arrays A and B, each consists of m integers. For all i, j such that 1 ≤ i, j ≤ m the condition Ai ≥ Bj holds. Help Leha rearrange the numbers in the array A so that the sum <image> is maximally possible, where A' is already rearranged array.
Input
First line of input data contains single integer m (1 ≤ m ≤ 2·105) — length of arrays A and B.
Next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 109) — array A.
Next line contains m integers b1, b2, ..., bm (1 ≤ bi ≤ 109) — array B.
Output
Output m integers a'1, a'2, ..., a'm — array A' which is permutation of the array A.
Examples
Input
5
7 3 5 3 4
2 1 3 2 3
Output
4 7 3 5 3
Input
7
4 6 5 8 8 2 6
2 1 2 2 1 1 2
Output
2 6 4 5 8 8 6 | instruction | 0 | 77,271 | 12 | 154,542 |
Tags: combinatorics, greedy, math, number theory, sortings
Correct Solution:
```
m = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
b = list(enumerate(b))
a = sorted(a, reverse=True)
b = sorted(b, key = lambda x : x[1])
l = [0] * m
for i in range(m):
l[b[i][0]] = a[i]
for i in l:
print(str(i) + ' ', end='')
``` | output | 1 | 77,271 | 12 | 154,543 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.