message stringlengths 2 433k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's call an array a consisting of n positive (greater than 0) integers beautiful if the following condition is held for every i from 1 to n: either a_i = 1, or at least one of the numbers a_i - 1 and a_i - 2 exists in the array as well.
For example:
* the array [5, 3, 1] is beautiful: for a_1, the number a_1 - 2 = 3 exists in the array; for a_2, the number a_2 - 2 = 1 exists in the array; for a_3, the condition a_3 = 1 holds;
* the array [1, 2, 2, 2, 2] is beautiful: for a_1, the condition a_1 = 1 holds; for every other number a_i, the number a_i - 1 = 1 exists in the array;
* the array [1, 4] is not beautiful: for a_2, neither a_2 - 2 = 2 nor a_2 - 1 = 3 exists in the array, and a_2 ≠ 1;
* the array [2] is not beautiful: for a_1, neither a_1 - 1 = 1 nor a_1 - 2 = 0 exists in the array, and a_1 ≠ 1;
* the array [2, 1, 3] is beautiful: for a_1, the number a_1 - 1 = 1 exists in the array; for a_2, the condition a_2 = 1 holds; for a_3, the number a_3 - 2 = 1 exists in the array.
You are given a positive integer s. Find the minimum possible size of a beautiful array with the sum of elements equal to s.
Input
The first line contains one integer t (1 ≤ t ≤ 5000) — the number of test cases.
Then t lines follow, the i-th line contains one integer s (1 ≤ s ≤ 5000) for the i-th test case.
Output
Print t integers, the i-th integer should be the answer for the i-th testcase: the minimum possible size of a beautiful array with the sum of elements equal to s.
Example
Input
4
1
8
7
42
Output
1
3
3
7
Note
Consider the example test:
1. in the first test case, the array [1] meets all conditions;
2. in the second test case, the array [3, 4, 1] meets all conditions;
3. in the third test case, the array [1, 2, 4] meets all conditions;
4. in the fourth test case, the array [1, 4, 6, 8, 10, 2, 11] meets all conditions.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
ans = 0
for i in range(1,n+1,2):
ans+=1
n-=i
if n<=0: break
print(ans)
``` | instruction | 0 | 75,302 | 12 | 150,604 |
No | output | 1 | 75,302 | 12 | 150,605 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves playing with arrays. He has array a, consisting of n positive integers, indexed from 1 to n. Let's denote the number with index i as ai.
Additionally the Little Elephant has m queries to the array, each query is characterised by a pair of integers lj and rj (1 ≤ lj ≤ rj ≤ n). For each query lj, rj the Little Elephant has to count, how many numbers x exist, such that number x occurs exactly x times among numbers alj, alj + 1, ..., arj.
Help the Little Elephant to count the answers to all queries.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the size of array a and the number of queries to it. The next line contains n space-separated positive integers a1, a2, ..., an (1 ≤ ai ≤ 109). Next m lines contain descriptions of queries, one per line. The j-th of these lines contains the description of the j-th query as two space-separated integers lj and rj (1 ≤ lj ≤ rj ≤ n).
Output
In m lines print m integers — the answers to the queries. The j-th line should contain the answer to the j-th query.
Examples
Input
7 2
3 1 2 2 3 3 7
1 7
3 4
Output
3
1 | instruction | 0 | 75,319 | 12 | 150,638 |
Tags: constructive algorithms, data structures
Correct Solution:
```
# -*- coding:utf-8 -*-
"""
created by shuangquan.huang at 1/8/20
for each query l, r; how many x that count of x in range [l, r] equals x
for each query ends with x, query (l, x) with Fenwick tree
"""
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def solve(N, M, A, Q):
bit = [0 for _ in range(N)]
def add(index, val):
while index < N:
bit[index] += val
index |= index + 1
def query(index):
index = min(index, N-1)
s = 0
while index >= 0:
s += bit[index]
index = (index & (index + 1)) - 1
return s
q = collections.defaultdict(list)
for i, (l, r) in enumerate(Q):
q[r].append((l, i))
ans = [0 for _ in range(M)]
vi = collections.defaultdict(list)
for i, v in enumerate(A):
u = vi[v]
u.append(i)
lv = len(vi[v])
if lv >= v:
add(u[-v], 1)
if lv >= v + 1:
add(u[-v-1], -2)
if lv >= v + 2:
add(u[-v-2], 1)
for l, qi in q[i]:
ans[qi] = query(i) - query(l-1)
print('\n'.join(map(str, ans)))
def test():
N, M = 100000, 100000
import random
A = [random.randint(0, 1000) for _ in range(N)]
Q = []
for i in range(M):
l = random.randint(0, N-1)
r = random.randint(l, N-1)
Q.append((l, r))
solve(N, M, A, Q)
# test()
N, M = map(int, input().split())
A = [int(x) for x in input().split()]
Q = []
for i in range(M):
l, r = map(int, input().split())
Q.append((l-1, r-1))
solve(N, M, A, Q)
``` | output | 1 | 75,319 | 12 | 150,639 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves playing with arrays. He has array a, consisting of n positive integers, indexed from 1 to n. Let's denote the number with index i as ai.
Additionally the Little Elephant has m queries to the array, each query is characterised by a pair of integers lj and rj (1 ≤ lj ≤ rj ≤ n). For each query lj, rj the Little Elephant has to count, how many numbers x exist, such that number x occurs exactly x times among numbers alj, alj + 1, ..., arj.
Help the Little Elephant to count the answers to all queries.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the size of array a and the number of queries to it. The next line contains n space-separated positive integers a1, a2, ..., an (1 ≤ ai ≤ 109). Next m lines contain descriptions of queries, one per line. The j-th of these lines contains the description of the j-th query as two space-separated integers lj and rj (1 ≤ lj ≤ rj ≤ n).
Output
In m lines print m integers — the answers to the queries. The j-th line should contain the answer to the j-th query.
Examples
Input
7 2
3 1 2 2 3 3 7
1 7
3 4
Output
3
1 | instruction | 0 | 75,320 | 12 | 150,640 |
Tags: constructive algorithms, data structures
Correct Solution:
```
from collections import defaultdict
import sys
count=0
def add(freq,arr,i):
freq[arr[i]]+=1
global count
if freq[arr[i]]==arr[i]:
count+=1
elif freq[arr[i]]==arr[i]+1:
count-=1
def remove(freq,arr,i):
freq[arr[i]]-=1
global count
if freq[arr[i]]==arr[i]-1:
count-=1
elif freq[arr[i]]==arr[i]:
count+=1
def mo_algo(Q,arr):
blk_size=750
start,end=0,-1
freq=defaultdict(int)
ans={}
for l,r in sorted(Q,key=lambda x:(x[0]//blk_size,x[1])):
while start>l:
start-=1
add(freq,arr,start)
while end<r:
end+=1
add(freq,arr,end)
while start<l:
remove(freq,arr,start)
start+=1
while end>r:
remove(freq,arr,end)
end-=1
ans[(l,r)]=count
res=[]
for l,r in Q:
res.append(ans[(l,r)])
return res
input=sys.stdin.readline
def main():
n,q=map(int,input().split())
arr=list(map(int,input().split()))
Q=[]
for i in range(q):
l,r=map(int,input().split())
Q.append((l-1,r-1))
ans=mo_algo(Q,arr)
for a in ans:
sys.stdout.write(str(a)+'\n')
main()
``` | output | 1 | 75,320 | 12 | 150,641 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves playing with arrays. He has array a, consisting of n positive integers, indexed from 1 to n. Let's denote the number with index i as ai.
Additionally the Little Elephant has m queries to the array, each query is characterised by a pair of integers lj and rj (1 ≤ lj ≤ rj ≤ n). For each query lj, rj the Little Elephant has to count, how many numbers x exist, such that number x occurs exactly x times among numbers alj, alj + 1, ..., arj.
Help the Little Elephant to count the answers to all queries.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the size of array a and the number of queries to it. The next line contains n space-separated positive integers a1, a2, ..., an (1 ≤ ai ≤ 109). Next m lines contain descriptions of queries, one per line. The j-th of these lines contains the description of the j-th query as two space-separated integers lj and rj (1 ≤ lj ≤ rj ≤ n).
Output
In m lines print m integers — the answers to the queries. The j-th line should contain the answer to the j-th query.
Examples
Input
7 2
3 1 2 2 3 3 7
1 7
3 4
Output
3
1 | instruction | 0 | 75,321 | 12 | 150,642 |
Tags: constructive algorithms, data structures
Correct Solution:
```
import collections
def do():
n, n_query = map(int, input().split(" "))
N = max(n, n_query) + 1
nums = [0] * N
count = collections.defaultdict(int)
tmp = [int(c) for c in input().split(" ")]
for i, num in enumerate(tmp):
nums[i+1] = num
if num <= n:
count[num] += 1
l = [0] * N
r = [0] * N
s = [0] * N
res = [0] * N
for i in range(1, n_query + 1):
l[i], r[i] = map(int, input().split(" "))
for num in set(nums):
if num <= count[num]:
for i in range(1, n + 1):
s[i] = s[i - 1] + (nums[i] == num)
for j in range(1, n_query + 1):
if s[r[j]] - s[l[j] - 1] == num:
res[j] += 1
for i in range(1, n_query + 1):
print(res[i] - 1)
do()
``` | output | 1 | 75,321 | 12 | 150,643 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves playing with arrays. He has array a, consisting of n positive integers, indexed from 1 to n. Let's denote the number with index i as ai.
Additionally the Little Elephant has m queries to the array, each query is characterised by a pair of integers lj and rj (1 ≤ lj ≤ rj ≤ n). For each query lj, rj the Little Elephant has to count, how many numbers x exist, such that number x occurs exactly x times among numbers alj, alj + 1, ..., arj.
Help the Little Elephant to count the answers to all queries.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the size of array a and the number of queries to it. The next line contains n space-separated positive integers a1, a2, ..., an (1 ≤ ai ≤ 109). Next m lines contain descriptions of queries, one per line. The j-th of these lines contains the description of the j-th query as two space-separated integers lj and rj (1 ≤ lj ≤ rj ≤ n).
Output
In m lines print m integers — the answers to the queries. The j-th line should contain the answer to the j-th query.
Examples
Input
7 2
3 1 2 2 3 3 7
1 7
3 4
Output
3
1 | instruction | 0 | 75,322 | 12 | 150,644 |
Tags: constructive algorithms, data structures
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#######################################
class query():
global z
def __init__(self,l,r,i):
self.lb=(l-1)//z
self.l=l
self.r=r
self.ind=i
def __lt__(a,b):
return (a.lb<b.lb or (a.lb==b.lb and a.r<b.r))
n,m=map(int,input().split())
a=list(map(int,input().split()))
for i in range(n):
if a[i]>n:
a[i]=-1
l1=[]
z=int(n**0.5)
for i in range(m):
x,y=map(int,input().split())
l1.append(query(x,y,i))
l1.sort()
d=[0]*(n+2)
l=1
r=0
ans=0
fans=[0]*m
for i in l1:
while r<i.r:
r+=1
if d[a[r-1]]==a[r-1]:
ans-=1
d[a[r-1]]+=1
if d[a[r-1]]==a[r-1]:
ans+=1
while l>i.l:
l-=1
if d[a[l-1]]==a[l-1]:
ans-=1
d[a[l-1]]+=1
if d[a[l-1]]==a[l-1]:
ans+=1
while l<i.l:
if d[a[l-1]]==a[l-1]:
ans-=1
d[a[l-1]]-=1
if d[a[l-1]]==a[l-1]:
ans+=1
l+=1
while r>i.r:
if d[a[r-1]]==a[r-1]:
ans-=1
d[a[r-1]]-=1
if d[a[r-1]]==a[r-1]:
ans+=1
r-=1
fans[i.ind]=ans
for i in fans:
print(i)
``` | output | 1 | 75,322 | 12 | 150,645 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves playing with arrays. He has array a, consisting of n positive integers, indexed from 1 to n. Let's denote the number with index i as ai.
Additionally the Little Elephant has m queries to the array, each query is characterised by a pair of integers lj and rj (1 ≤ lj ≤ rj ≤ n). For each query lj, rj the Little Elephant has to count, how many numbers x exist, such that number x occurs exactly x times among numbers alj, alj + 1, ..., arj.
Help the Little Elephant to count the answers to all queries.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the size of array a and the number of queries to it. The next line contains n space-separated positive integers a1, a2, ..., an (1 ≤ ai ≤ 109). Next m lines contain descriptions of queries, one per line. The j-th of these lines contains the description of the j-th query as two space-separated integers lj and rj (1 ≤ lj ≤ rj ≤ n).
Output
In m lines print m integers — the answers to the queries. The j-th line should contain the answer to the j-th query.
Examples
Input
7 2
3 1 2 2 3 3 7
1 7
3 4
Output
3
1 | instruction | 0 | 75,323 | 12 | 150,646 |
Tags: constructive algorithms, data structures
Correct Solution:
```
from collections import defaultdict
n,m=map(int,input().split())
query=[[] for j in range(int(n**0.5)+1)]
arr=list(map(int,input().split()))
for j in range(m):
x,y=map(int,input().split())
query[int(x/n**0.5)].append([x-1,y-1,j])
q=[]
for j in query:
j.sort(key=lambda x:x[1])
for p in j:
q.append(p)
d=defaultdict(lambda:0)
j=0
currL,currR,x= 1,0,0
res=[0]*(m)
while(j<len(q)):
L,R=q[j][0],q[j][1]
while currL < L:
d[arr[currL]]-=1
if d[arr[currL]]==(arr[currL]-1):
x-=1
if d[arr[currL]] == (arr[currL]):
x += 1
currL += 1
while currL > L:
currL -= 1
d[arr[currL]] += 1
if d[arr[currL]]==(arr[currL]+1):
x-=1
if d[arr[currL]]==(arr[currL]):
x+=1
while currR<R:
currR += 1
d[arr[currR]] += 1
if d[arr[currR]]==(arr[currR]+1):
x-=1
if d[arr[currR]] == (arr[currR]):
x += 1
while currR > R:
d[arr[currR]] -= 1
if d[arr[currR]]==(arr[currR]-1):
x-=1
if d[arr[currR]] == (arr[currR]):
x += 1
currR -= 1
res[q[j][2]]=x
j+=1
for j in res:
print(j)
``` | output | 1 | 75,323 | 12 | 150,647 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves playing with arrays. He has array a, consisting of n positive integers, indexed from 1 to n. Let's denote the number with index i as ai.
Additionally the Little Elephant has m queries to the array, each query is characterised by a pair of integers lj and rj (1 ≤ lj ≤ rj ≤ n). For each query lj, rj the Little Elephant has to count, how many numbers x exist, such that number x occurs exactly x times among numbers alj, alj + 1, ..., arj.
Help the Little Elephant to count the answers to all queries.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the size of array a and the number of queries to it. The next line contains n space-separated positive integers a1, a2, ..., an (1 ≤ ai ≤ 109). Next m lines contain descriptions of queries, one per line. The j-th of these lines contains the description of the j-th query as two space-separated integers lj and rj (1 ≤ lj ≤ rj ≤ n).
Output
In m lines print m integers — the answers to the queries. The j-th line should contain the answer to the j-th query.
Examples
Input
7 2
3 1 2 2 3 3 7
1 7
3 4
Output
3
1 | instruction | 0 | 75,324 | 12 | 150,648 |
Tags: constructive algorithms, data structures
Correct Solution:
```
from collections import Counter
n, m = map(int, input().split())
a = list(map(int, input().split()))
count = Counter(a)
maybe = {}
for k, v in count.items():
if v >= k:
i = len(maybe)
maybe[k] = i
pref = [[0] * len(maybe)]
for i in range(n):
pref.append(pref[-1][:])
if a[i] in maybe:
pref[-1][maybe[a[i]]] += 1
res = []
for _ in range(m):
l, r = map(int, input().split())
cur = 0
for x, i in maybe.items():
if pref[r][i] - pref[l - 1][i] == x:
cur += 1
res.append(cur)
print("\n".join(map(str, res)))
``` | output | 1 | 75,324 | 12 | 150,649 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves playing with arrays. He has array a, consisting of n positive integers, indexed from 1 to n. Let's denote the number with index i as ai.
Additionally the Little Elephant has m queries to the array, each query is characterised by a pair of integers lj and rj (1 ≤ lj ≤ rj ≤ n). For each query lj, rj the Little Elephant has to count, how many numbers x exist, such that number x occurs exactly x times among numbers alj, alj + 1, ..., arj.
Help the Little Elephant to count the answers to all queries.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the size of array a and the number of queries to it. The next line contains n space-separated positive integers a1, a2, ..., an (1 ≤ ai ≤ 109). Next m lines contain descriptions of queries, one per line. The j-th of these lines contains the description of the j-th query as two space-separated integers lj and rj (1 ≤ lj ≤ rj ≤ n).
Output
In m lines print m integers — the answers to the queries. The j-th line should contain the answer to the j-th query.
Examples
Input
7 2
3 1 2 2 3 3 7
1 7
3 4
Output
3
1 | instruction | 0 | 75,325 | 12 | 150,650 |
Tags: constructive algorithms, data structures
Correct Solution:
```
import bisect
import collections
import heapq
import math
def do():
n, n_query = map(int, input().split(" "))
N = max(n, n_query) + 1
nums = [0] * N
count = [0] * N
tmp = [int(c) for c in input().split(" ")]
for i,d in enumerate(tmp):
nums[i+1] = d
if d <= n:
count[d] += 1
l = [0] * N
r = [0] * N
s = [0] * N
res = [0] * N
for i in range(1, n_query + 1):
l[i], r[i] = map(int, input().split(" "))
for i in range(1, n + 1):
if i <= count[i]:
for j in range(1, n + 1):
s[j] = s[j - 1] + (nums[j] == i)
for j in range(1, n_query + 1):
if s[r[j]] - s[l[j] - 1] == i:
res[j] += 1
for i in range(1, n_query + 1):
print(res[i])
do()
``` | output | 1 | 75,325 | 12 | 150,651 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant loves playing with arrays. He has array a, consisting of n positive integers, indexed from 1 to n. Let's denote the number with index i as ai.
Additionally the Little Elephant has m queries to the array, each query is characterised by a pair of integers lj and rj (1 ≤ lj ≤ rj ≤ n). For each query lj, rj the Little Elephant has to count, how many numbers x exist, such that number x occurs exactly x times among numbers alj, alj + 1, ..., arj.
Help the Little Elephant to count the answers to all queries.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the size of array a and the number of queries to it. The next line contains n space-separated positive integers a1, a2, ..., an (1 ≤ ai ≤ 109). Next m lines contain descriptions of queries, one per line. The j-th of these lines contains the description of the j-th query as two space-separated integers lj and rj (1 ≤ lj ≤ rj ≤ n).
Output
In m lines print m integers — the answers to the queries. The j-th line should contain the answer to the j-th query.
Examples
Input
7 2
3 1 2 2 3 3 7
1 7
3 4
Output
3
1 | instruction | 0 | 75,326 | 12 | 150,652 |
Tags: constructive algorithms, data structures
Correct Solution:
```
BLOCK = 316
n,q = map(int,input().split())
arr = [int(x) for x in input().split()]
query = []
# storing the queries ans
ans = [0] * q
# storing their frequency inside the curr block
freq = [0] * (n+1)
# window means the numbers that have freq[x] = x
window = 0
def operate(val, n, what):
global window
if(val > n):
return -1
if(what < 0):
if(freq[val] == val):
window -= 1
freq[val]-=1
if(freq[val] == val):
window += 1
else:
if(freq[val] == val):
window -= 1
freq[val]+=1
if(freq[val] == val):
window += 1
for i in range(q):
a,b = map(int,input().split())
query.append([a-1,b-1,i])
query.sort(key = lambda x: (x[0]//BLOCK, x[1]))
L = 0
R = -1
for l,r,idx in query:
while(R < r):
R += 1
operate(arr[R], n, 1)
while(L > l):
L -= 1
operate(arr[L], n, 1)
while(R > r):
operate(arr[R], n, -1)
R -= 1
while(L < l):
operate(arr[L], n, -1)
L += 1
ans[idx] = window
for i in ans:
print(i)
``` | output | 1 | 75,326 | 12 | 150,653 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Little Elephant loves playing with arrays. He has array a, consisting of n positive integers, indexed from 1 to n. Let's denote the number with index i as ai.
Additionally the Little Elephant has m queries to the array, each query is characterised by a pair of integers lj and rj (1 ≤ lj ≤ rj ≤ n). For each query lj, rj the Little Elephant has to count, how many numbers x exist, such that number x occurs exactly x times among numbers alj, alj + 1, ..., arj.
Help the Little Elephant to count the answers to all queries.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the size of array a and the number of queries to it. The next line contains n space-separated positive integers a1, a2, ..., an (1 ≤ ai ≤ 109). Next m lines contain descriptions of queries, one per line. The j-th of these lines contains the description of the j-th query as two space-separated integers lj and rj (1 ≤ lj ≤ rj ≤ n).
Output
In m lines print m integers — the answers to the queries. The j-th line should contain the answer to the j-th query.
Examples
Input
7 2
3 1 2 2 3 3 7
1 7
3 4
Output
3
1
Submitted Solution:
```
from functools import lru_cache
from sys import stdin, stdout
import sys
from math import *
# from collections import deque
sys.setrecursionlimit(int(2e5+10))
# input = stdin.readline
# print = stdout.write
# dp=[-1]*100000
# lru_cache(None)
n,m=map(int,input().split())
ar=list(map(int,input().split()))
ar.insert(0,0)
ranges=[[0,0]]
for i in range(m):
l,r=map(int,input().split())
ranges.append([l,r])
cnt=[0]*(n+1)
for i in range(1,n+1):
if(ar[i]<=n):
cnt[ar[i]]+=1
ans=[0]*(m+1)
s=[0]*(n+1)
# print(cnt)
for i in range(1,n+1):
if(cnt[i]>=i):
for j in range(1,n+1):
s[j]=s[j-1]
if(ar[j]==i):
s[j]+=1
for j in range(1,m+1):
if(s[ranges[j][1]]-s[ranges[j][0]-1]==i):
ans[j]+=1
for i in range(1,m+1):
print(ans[i])
``` | instruction | 0 | 75,329 | 12 | 150,658 |
Yes | output | 1 | 75,329 | 12 | 150,659 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Little Elephant loves playing with arrays. He has array a, consisting of n positive integers, indexed from 1 to n. Let's denote the number with index i as ai.
Additionally the Little Elephant has m queries to the array, each query is characterised by a pair of integers lj and rj (1 ≤ lj ≤ rj ≤ n). For each query lj, rj the Little Elephant has to count, how many numbers x exist, such that number x occurs exactly x times among numbers alj, alj + 1, ..., arj.
Help the Little Elephant to count the answers to all queries.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the size of array a and the number of queries to it. The next line contains n space-separated positive integers a1, a2, ..., an (1 ≤ ai ≤ 109). Next m lines contain descriptions of queries, one per line. The j-th of these lines contains the description of the j-th query as two space-separated integers lj and rj (1 ≤ lj ≤ rj ≤ n).
Output
In m lines print m integers — the answers to the queries. The j-th line should contain the answer to the j-th query.
Examples
Input
7 2
3 1 2 2 3 3 7
1 7
3 4
Output
3
1
Submitted Solution:
```
import sys
def get_ints(): return map(int, sys.stdin.readline().split())
n,m=map(int,input().split())
arr=list(get_ints())
arr=[0]+arr
summ=[0]*(100001)
freq=[0]*(100001)
#print(l)
l=[0]*(100001)
r=[0]*(100001)
for ii in arr:
if ii<=n:freq[ii]+=1
for i in range(1,m+1):
x,y=get_ints()
l[i]=x
r[i]=y
ans=[0]*(m+1)
for i in range(1,n+1):
if freq[i]>=i:
for j in range(1,n+1):
summ[j]=summ[j-1]
if arr[j]==i:
summ[j]+=1
for k in range(1,m+1):
if summ[r[k]]-summ[l[k]-1]==i:
ans[k]+=1
for i in range(1,m+1):
print(ans[i])
``` | instruction | 0 | 75,330 | 12 | 150,660 |
Yes | output | 1 | 75,330 | 12 | 150,661 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Little Elephant loves playing with arrays. He has array a, consisting of n positive integers, indexed from 1 to n. Let's denote the number with index i as ai.
Additionally the Little Elephant has m queries to the array, each query is characterised by a pair of integers lj and rj (1 ≤ lj ≤ rj ≤ n). For each query lj, rj the Little Elephant has to count, how many numbers x exist, such that number x occurs exactly x times among numbers alj, alj + 1, ..., arj.
Help the Little Elephant to count the answers to all queries.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the size of array a and the number of queries to it. The next line contains n space-separated positive integers a1, a2, ..., an (1 ≤ ai ≤ 109). Next m lines contain descriptions of queries, one per line. The j-th of these lines contains the description of the j-th query as two space-separated integers lj and rj (1 ≤ lj ≤ rj ≤ n).
Output
In m lines print m integers — the answers to the queries. The j-th line should contain the answer to the j-th query.
Examples
Input
7 2
3 1 2 2 3 3 7
1 7
3 4
Output
3
1
Submitted Solution:
```
#little elephant and array (python)
import sys
import os
ci = input().split()
n, m = int(ci[0]), int(ci[1])
arr = input().split()
d = {}
dp = [0]*(n+1)
for i in range(1, len(arr)+1):
val = arr[i-1]
d[val] = (d[val] + 1) if val in d else 1
if val in d and d[val] == int(val):
dp[i] = dp[i-1]+1
else:
dp[i] = dp[i-1]
for i in range(m):
inp = input().split()
print( dp[ int(inp[1]) ] - dp[ int(inp[0])-1] )
``` | instruction | 0 | 75,331 | 12 | 150,662 |
No | output | 1 | 75,331 | 12 | 150,663 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Little Elephant loves playing with arrays. He has array a, consisting of n positive integers, indexed from 1 to n. Let's denote the number with index i as ai.
Additionally the Little Elephant has m queries to the array, each query is characterised by a pair of integers lj and rj (1 ≤ lj ≤ rj ≤ n). For each query lj, rj the Little Elephant has to count, how many numbers x exist, such that number x occurs exactly x times among numbers alj, alj + 1, ..., arj.
Help the Little Elephant to count the answers to all queries.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the size of array a and the number of queries to it. The next line contains n space-separated positive integers a1, a2, ..., an (1 ≤ ai ≤ 109). Next m lines contain descriptions of queries, one per line. The j-th of these lines contains the description of the j-th query as two space-separated integers lj and rj (1 ≤ lj ≤ rj ≤ n).
Output
In m lines print m integers — the answers to the queries. The j-th line should contain the answer to the j-th query.
Examples
Input
7 2
3 1 2 2 3 3 7
1 7
3 4
Output
3
1
Submitted Solution:
```
n,m =map(int,input().split())
arr =list(map(int,input().split()))
hashf ={}
for a in arr:
if (a in hashf.keys()):
hashf[a] =hashf[a]+1
else:
hashf[a] =1
#print (hashf)
for i in range(m):
a,b =map(int,input().split())
sarr =arr[a-1:b]
counter =0
dhash =[]
for a in sarr:
if (a in dhash):
continue
if (hashf[a] == a):
counter+=1
dhash.append(a)
print (counter)
``` | instruction | 0 | 75,332 | 12 | 150,664 |
No | output | 1 | 75,332 | 12 | 150,665 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The Little Elephant loves playing with arrays. He has array a, consisting of n positive integers, indexed from 1 to n. Let's denote the number with index i as ai.
Additionally the Little Elephant has m queries to the array, each query is characterised by a pair of integers lj and rj (1 ≤ lj ≤ rj ≤ n). For each query lj, rj the Little Elephant has to count, how many numbers x exist, such that number x occurs exactly x times among numbers alj, alj + 1, ..., arj.
Help the Little Elephant to count the answers to all queries.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the size of array a and the number of queries to it. The next line contains n space-separated positive integers a1, a2, ..., an (1 ≤ ai ≤ 109). Next m lines contain descriptions of queries, one per line. The j-th of these lines contains the description of the j-th query as two space-separated integers lj and rj (1 ≤ lj ≤ rj ≤ n).
Output
In m lines print m integers — the answers to the queries. The j-th line should contain the answer to the j-th query.
Examples
Input
7 2
3 1 2 2 3 3 7
1 7
3 4
Output
3
1
Submitted Solution:
```
n,m=list(map(int,input().split()))
li=list(map(int,input().split()))
for i in range(m):
l,r=list(map(int,input().split()))
x=li[l-1:r]
m=list(set(x))
m.sort()
k=len(m)
n=[]
for i in range(k):
if m[i]<=k:
n.append(m[i])
else:
break
su=0
for j in n:
if j==x.count(j):
su+=1
print(su)
``` | instruction | 0 | 75,333 | 12 | 150,666 |
No | output | 1 | 75,333 | 12 | 150,667 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's define the permutation of length n as an array p = [p1, p2, ..., pn] consisting of n distinct integers from range from 1 to n. We say that this permutation maps value 1 into the value p1, value 2 into the value p2 and so on.
Kyota Ootori has just learned about cyclic representation of a permutation. A cycle is a sequence of numbers such that each element of this sequence is being mapped into the next element of this sequence (and the last element of the cycle is being mapped into the first element of the cycle). The cyclic representation is a representation of p as a collection of cycles forming p. For example, permutation p = [4, 1, 6, 2, 5, 3] has a cyclic representation that looks like (142)(36)(5) because 1 is replaced by 4, 4 is replaced by 2, 2 is replaced by 1, 3 and 6 are swapped, and 5 remains in place.
Permutation may have several cyclic representations, so Kyoya defines the standard cyclic representation of a permutation as follows. First, reorder the elements within each cycle so the largest element is first. Then, reorder all of the cycles so they are sorted by their first element. For our example above, the standard cyclic representation of [4, 1, 6, 2, 5, 3] is (421)(5)(63).
Now, Kyoya notices that if we drop the parenthesis in the standard cyclic representation, we get another permutation! For instance, [4, 1, 6, 2, 5, 3] will become [4, 2, 1, 5, 6, 3].
Kyoya notices that some permutations don't change after applying operation described above at all. He wrote all permutations of length n that do not change in a list in lexicographic order. Unfortunately, his friend Tamaki Suoh lost this list. Kyoya wishes to reproduce the list and he needs your help. Given the integers n and k, print the permutation that was k-th on Kyoya's list.
Input
The first line will contain two integers n, k (1 ≤ n ≤ 50, 1 ≤ k ≤ min{1018, l} where l is the length of the Kyoya's list).
Output
Print n space-separated integers, representing the permutation that is the answer for the question.
Examples
Input
4 3
Output
1 3 2 4
Input
10 1
Output
1 2 3 4 5 6 7 8 9 10
Note
The standard cycle representation is (1)(32)(4), which after removing parenthesis gives us the original permutation. The first permutation on the list would be [1, 2, 3, 4], while the second permutation would be [1, 2, 4, 3]. | instruction | 0 | 75,465 | 12 | 150,930 |
Tags: binary search, combinatorics, constructive algorithms, greedy, implementation, math
Correct Solution:
```
n, m = [int(x) for x in input().split()]
F = [1,1]
for i in range(2, n): F.append(F[-1] + F[-2])
perm = [i+1 for i in range(n)]
for i in range(n):
if m > F[n-1 - i]:
m -= F[n-1 -i]
perm[i], perm[i+1] = perm[i+1], perm[i]
for k in perm: print(k, end = ' ')
``` | output | 1 | 75,465 | 12 | 150,931 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's define the permutation of length n as an array p = [p1, p2, ..., pn] consisting of n distinct integers from range from 1 to n. We say that this permutation maps value 1 into the value p1, value 2 into the value p2 and so on.
Kyota Ootori has just learned about cyclic representation of a permutation. A cycle is a sequence of numbers such that each element of this sequence is being mapped into the next element of this sequence (and the last element of the cycle is being mapped into the first element of the cycle). The cyclic representation is a representation of p as a collection of cycles forming p. For example, permutation p = [4, 1, 6, 2, 5, 3] has a cyclic representation that looks like (142)(36)(5) because 1 is replaced by 4, 4 is replaced by 2, 2 is replaced by 1, 3 and 6 are swapped, and 5 remains in place.
Permutation may have several cyclic representations, so Kyoya defines the standard cyclic representation of a permutation as follows. First, reorder the elements within each cycle so the largest element is first. Then, reorder all of the cycles so they are sorted by their first element. For our example above, the standard cyclic representation of [4, 1, 6, 2, 5, 3] is (421)(5)(63).
Now, Kyoya notices that if we drop the parenthesis in the standard cyclic representation, we get another permutation! For instance, [4, 1, 6, 2, 5, 3] will become [4, 2, 1, 5, 6, 3].
Kyoya notices that some permutations don't change after applying operation described above at all. He wrote all permutations of length n that do not change in a list in lexicographic order. Unfortunately, his friend Tamaki Suoh lost this list. Kyoya wishes to reproduce the list and he needs your help. Given the integers n and k, print the permutation that was k-th on Kyoya's list.
Input
The first line will contain two integers n, k (1 ≤ n ≤ 50, 1 ≤ k ≤ min{1018, l} where l is the length of the Kyoya's list).
Output
Print n space-separated integers, representing the permutation that is the answer for the question.
Examples
Input
4 3
Output
1 3 2 4
Input
10 1
Output
1 2 3 4 5 6 7 8 9 10
Note
The standard cycle representation is (1)(32)(4), which after removing parenthesis gives us the original permutation. The first permutation on the list would be [1, 2, 3, 4], while the second permutation would be [1, 2, 4, 3]. | instruction | 0 | 75,466 | 12 | 150,932 |
Tags: binary search, combinatorics, constructive algorithms, greedy, implementation, math
Correct Solution:
```
n, k = map(int, input().split())
a = [0 for i in range(n+1)]
a[0], a[1] = 1, 1
for i in range(2, n+1):
a[i] = a[i-1] + a[i-2]
p = [i+1 for i in range(n)]
i = 0
while i < n:
if k > a[n-1-i]:
p[i], p[i+1] = p[i+1], p[i]
k -= a[n-1-i]
i += 2
else: i += 1
p = [str(i) for i in p]
print(' '.join(p))
``` | output | 1 | 75,466 | 12 | 150,933 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's define the permutation of length n as an array p = [p1, p2, ..., pn] consisting of n distinct integers from range from 1 to n. We say that this permutation maps value 1 into the value p1, value 2 into the value p2 and so on.
Kyota Ootori has just learned about cyclic representation of a permutation. A cycle is a sequence of numbers such that each element of this sequence is being mapped into the next element of this sequence (and the last element of the cycle is being mapped into the first element of the cycle). The cyclic representation is a representation of p as a collection of cycles forming p. For example, permutation p = [4, 1, 6, 2, 5, 3] has a cyclic representation that looks like (142)(36)(5) because 1 is replaced by 4, 4 is replaced by 2, 2 is replaced by 1, 3 and 6 are swapped, and 5 remains in place.
Permutation may have several cyclic representations, so Kyoya defines the standard cyclic representation of a permutation as follows. First, reorder the elements within each cycle so the largest element is first. Then, reorder all of the cycles so they are sorted by their first element. For our example above, the standard cyclic representation of [4, 1, 6, 2, 5, 3] is (421)(5)(63).
Now, Kyoya notices that if we drop the parenthesis in the standard cyclic representation, we get another permutation! For instance, [4, 1, 6, 2, 5, 3] will become [4, 2, 1, 5, 6, 3].
Kyoya notices that some permutations don't change after applying operation described above at all. He wrote all permutations of length n that do not change in a list in lexicographic order. Unfortunately, his friend Tamaki Suoh lost this list. Kyoya wishes to reproduce the list and he needs your help. Given the integers n and k, print the permutation that was k-th on Kyoya's list.
Input
The first line will contain two integers n, k (1 ≤ n ≤ 50, 1 ≤ k ≤ min{1018, l} where l is the length of the Kyoya's list).
Output
Print n space-separated integers, representing the permutation that is the answer for the question.
Examples
Input
4 3
Output
1 3 2 4
Input
10 1
Output
1 2 3 4 5 6 7 8 9 10
Note
The standard cycle representation is (1)(32)(4), which after removing parenthesis gives us the original permutation. The first permutation on the list would be [1, 2, 3, 4], while the second permutation would be [1, 2, 4, 3]. | instruction | 0 | 75,467 | 12 | 150,934 |
Tags: binary search, combinatorics, constructive algorithms, greedy, implementation, math
Correct Solution:
```
n, m = [int(x) for x in input().split()]
F = [1,1]
for i in range(2, n): F.append(F[-1] + F[-2])
perm = [i+1 for i in range(n)]
for i in range(n):
if m > F[n-1 - i]:
m -= F[n-1 -i]
perm[i], perm[i+1] = perm[i+1], perm[i]
for k in perm: print(k, end = ' ')
# Made By Mostafa_Khaled
``` | output | 1 | 75,467 | 12 | 150,935 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's define the permutation of length n as an array p = [p1, p2, ..., pn] consisting of n distinct integers from range from 1 to n. We say that this permutation maps value 1 into the value p1, value 2 into the value p2 and so on.
Kyota Ootori has just learned about cyclic representation of a permutation. A cycle is a sequence of numbers such that each element of this sequence is being mapped into the next element of this sequence (and the last element of the cycle is being mapped into the first element of the cycle). The cyclic representation is a representation of p as a collection of cycles forming p. For example, permutation p = [4, 1, 6, 2, 5, 3] has a cyclic representation that looks like (142)(36)(5) because 1 is replaced by 4, 4 is replaced by 2, 2 is replaced by 1, 3 and 6 are swapped, and 5 remains in place.
Permutation may have several cyclic representations, so Kyoya defines the standard cyclic representation of a permutation as follows. First, reorder the elements within each cycle so the largest element is first. Then, reorder all of the cycles so they are sorted by their first element. For our example above, the standard cyclic representation of [4, 1, 6, 2, 5, 3] is (421)(5)(63).
Now, Kyoya notices that if we drop the parenthesis in the standard cyclic representation, we get another permutation! For instance, [4, 1, 6, 2, 5, 3] will become [4, 2, 1, 5, 6, 3].
Kyoya notices that some permutations don't change after applying operation described above at all. He wrote all permutations of length n that do not change in a list in lexicographic order. Unfortunately, his friend Tamaki Suoh lost this list. Kyoya wishes to reproduce the list and he needs your help. Given the integers n and k, print the permutation that was k-th on Kyoya's list.
Input
The first line will contain two integers n, k (1 ≤ n ≤ 50, 1 ≤ k ≤ min{1018, l} where l is the length of the Kyoya's list).
Output
Print n space-separated integers, representing the permutation that is the answer for the question.
Examples
Input
4 3
Output
1 3 2 4
Input
10 1
Output
1 2 3 4 5 6 7 8 9 10
Note
The standard cycle representation is (1)(32)(4), which after removing parenthesis gives us the original permutation. The first permutation on the list would be [1, 2, 3, 4], while the second permutation would be [1, 2, 4, 3]. | instruction | 0 | 75,468 | 12 | 150,936 |
Tags: binary search, combinatorics, constructive algorithms, greedy, implementation, math
Correct Solution:
```
l = [1, 2]
for i in range(1, 100):
l.append(l[i]+l[i-1])
if l[-1]>10**18:
break
l = [0, 0] + l
def perm(n, k):
if n == 1 and k == 1:
return [1]
if n == 2 and k == 1:
return [1, 2]
if n == 2 and k == 2:
return [2, 1]
if k <= l[n]:
return [1] + [i+1 for i in perm(n-1, k)]
return [2, 1] + [i+2 for i in perm(n-2, k - l[n])]
n, k = map(int, input().split(' '))
print(' '.join([str(x) for x in perm(n, k)]))
``` | output | 1 | 75,468 | 12 | 150,937 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's define the permutation of length n as an array p = [p1, p2, ..., pn] consisting of n distinct integers from range from 1 to n. We say that this permutation maps value 1 into the value p1, value 2 into the value p2 and so on.
Kyota Ootori has just learned about cyclic representation of a permutation. A cycle is a sequence of numbers such that each element of this sequence is being mapped into the next element of this sequence (and the last element of the cycle is being mapped into the first element of the cycle). The cyclic representation is a representation of p as a collection of cycles forming p. For example, permutation p = [4, 1, 6, 2, 5, 3] has a cyclic representation that looks like (142)(36)(5) because 1 is replaced by 4, 4 is replaced by 2, 2 is replaced by 1, 3 and 6 are swapped, and 5 remains in place.
Permutation may have several cyclic representations, so Kyoya defines the standard cyclic representation of a permutation as follows. First, reorder the elements within each cycle so the largest element is first. Then, reorder all of the cycles so they are sorted by their first element. For our example above, the standard cyclic representation of [4, 1, 6, 2, 5, 3] is (421)(5)(63).
Now, Kyoya notices that if we drop the parenthesis in the standard cyclic representation, we get another permutation! For instance, [4, 1, 6, 2, 5, 3] will become [4, 2, 1, 5, 6, 3].
Kyoya notices that some permutations don't change after applying operation described above at all. He wrote all permutations of length n that do not change in a list in lexicographic order. Unfortunately, his friend Tamaki Suoh lost this list. Kyoya wishes to reproduce the list and he needs your help. Given the integers n and k, print the permutation that was k-th on Kyoya's list.
Input
The first line will contain two integers n, k (1 ≤ n ≤ 50, 1 ≤ k ≤ min{1018, l} where l is the length of the Kyoya's list).
Output
Print n space-separated integers, representing the permutation that is the answer for the question.
Examples
Input
4 3
Output
1 3 2 4
Input
10 1
Output
1 2 3 4 5 6 7 8 9 10
Note
The standard cycle representation is (1)(32)(4), which after removing parenthesis gives us the original permutation. The first permutation on the list would be [1, 2, 3, 4], while the second permutation would be [1, 2, 4, 3]. | instruction | 0 | 75,469 | 12 | 150,938 |
Tags: binary search, combinatorics, constructive algorithms, greedy, implementation, math
Correct Solution:
```
def calc(n, k):
if n == 1:
print(1)
else:
#n, k = map(int,input().split())
tot = [0] * (n + 1)
tot[n] = 1
tot[n - 1] = 1
tot[n - 2] = 2
for i in range(n - 3, -1, -1):
tot[i] = tot[i + 1] + tot[i + 2]
def mPrint(a, b):
#for i in range(a + 1, b + 1):
# print(i, end = " ")
#print(a, end = " " )
print(b, end = " ")
for i in range(a, b):
print(i, end = " ")
last = 0
for i in range(n):
#print(k, tot[i + 1])
if k <= tot[i + 1]:
mPrint(last + 1, i + 1)
last = i + 1
else:
k -= tot[i + 1]
print()
n, k = map(int,input().split())
calc(n, k)
``` | output | 1 | 75,469 | 12 | 150,939 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's define the permutation of length n as an array p = [p1, p2, ..., pn] consisting of n distinct integers from range from 1 to n. We say that this permutation maps value 1 into the value p1, value 2 into the value p2 and so on.
Kyota Ootori has just learned about cyclic representation of a permutation. A cycle is a sequence of numbers such that each element of this sequence is being mapped into the next element of this sequence (and the last element of the cycle is being mapped into the first element of the cycle). The cyclic representation is a representation of p as a collection of cycles forming p. For example, permutation p = [4, 1, 6, 2, 5, 3] has a cyclic representation that looks like (142)(36)(5) because 1 is replaced by 4, 4 is replaced by 2, 2 is replaced by 1, 3 and 6 are swapped, and 5 remains in place.
Permutation may have several cyclic representations, so Kyoya defines the standard cyclic representation of a permutation as follows. First, reorder the elements within each cycle so the largest element is first. Then, reorder all of the cycles so they are sorted by their first element. For our example above, the standard cyclic representation of [4, 1, 6, 2, 5, 3] is (421)(5)(63).
Now, Kyoya notices that if we drop the parenthesis in the standard cyclic representation, we get another permutation! For instance, [4, 1, 6, 2, 5, 3] will become [4, 2, 1, 5, 6, 3].
Kyoya notices that some permutations don't change after applying operation described above at all. He wrote all permutations of length n that do not change in a list in lexicographic order. Unfortunately, his friend Tamaki Suoh lost this list. Kyoya wishes to reproduce the list and he needs your help. Given the integers n and k, print the permutation that was k-th on Kyoya's list.
Input
The first line will contain two integers n, k (1 ≤ n ≤ 50, 1 ≤ k ≤ min{1018, l} where l is the length of the Kyoya's list).
Output
Print n space-separated integers, representing the permutation that is the answer for the question.
Examples
Input
4 3
Output
1 3 2 4
Input
10 1
Output
1 2 3 4 5 6 7 8 9 10
Note
The standard cycle representation is (1)(32)(4), which after removing parenthesis gives us the original permutation. The first permutation on the list would be [1, 2, 3, 4], while the second permutation would be [1, 2, 4, 3]. | instruction | 0 | 75,470 | 12 | 150,940 |
Tags: binary search, combinatorics, constructive algorithms, greedy, implementation, math
Correct Solution:
```
n, k = list(map(int, input().split()))
#n = int(input())
#k = int(input())
fib = [0] * (n + 1)
fib[0] = 1
fib[1] = 1
res = [0] * n
for i in range(2, n):
fib[i] = fib[i - 1] + fib[i - 2]
idx = 0
while idx < n:
if k <= fib[n - idx - 1]:
res[idx] = idx + 1
idx += 1
else:
k -= fib[n - idx - 1]
res[idx] = idx + 2
res[idx + 1] = idx + 1
idx += 2
print(*res)
``` | output | 1 | 75,470 | 12 | 150,941 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's define the permutation of length n as an array p = [p1, p2, ..., pn] consisting of n distinct integers from range from 1 to n. We say that this permutation maps value 1 into the value p1, value 2 into the value p2 and so on.
Kyota Ootori has just learned about cyclic representation of a permutation. A cycle is a sequence of numbers such that each element of this sequence is being mapped into the next element of this sequence (and the last element of the cycle is being mapped into the first element of the cycle). The cyclic representation is a representation of p as a collection of cycles forming p. For example, permutation p = [4, 1, 6, 2, 5, 3] has a cyclic representation that looks like (142)(36)(5) because 1 is replaced by 4, 4 is replaced by 2, 2 is replaced by 1, 3 and 6 are swapped, and 5 remains in place.
Permutation may have several cyclic representations, so Kyoya defines the standard cyclic representation of a permutation as follows. First, reorder the elements within each cycle so the largest element is first. Then, reorder all of the cycles so they are sorted by their first element. For our example above, the standard cyclic representation of [4, 1, 6, 2, 5, 3] is (421)(5)(63).
Now, Kyoya notices that if we drop the parenthesis in the standard cyclic representation, we get another permutation! For instance, [4, 1, 6, 2, 5, 3] will become [4, 2, 1, 5, 6, 3].
Kyoya notices that some permutations don't change after applying operation described above at all. He wrote all permutations of length n that do not change in a list in lexicographic order. Unfortunately, his friend Tamaki Suoh lost this list. Kyoya wishes to reproduce the list and he needs your help. Given the integers n and k, print the permutation that was k-th on Kyoya's list.
Input
The first line will contain two integers n, k (1 ≤ n ≤ 50, 1 ≤ k ≤ min{1018, l} where l is the length of the Kyoya's list).
Output
Print n space-separated integers, representing the permutation that is the answer for the question.
Examples
Input
4 3
Output
1 3 2 4
Input
10 1
Output
1 2 3 4 5 6 7 8 9 10
Note
The standard cycle representation is (1)(32)(4), which after removing parenthesis gives us the original permutation. The first permutation on the list would be [1, 2, 3, 4], while the second permutation would be [1, 2, 4, 3]. | instruction | 0 | 75,471 | 12 | 150,942 |
Tags: binary search, combinatorics, constructive algorithms, greedy, implementation, math
Correct Solution:
```
__author__ = 'taras-sereda'
n,k = map(int,input().split())
fib = [0]*(n+1)
fib[0], fib[1] = 1, 1
for i in range(2,n):
fib[i] = fib[i-1] + fib[i-2]
idx = 0
res = [None]*n
while (idx<n):
if (k <= fib[n-idx-1]):
res[idx] = idx + 1
idx += 1
else:
k -= fib[n-idx-1]
res[idx] = idx + 2
res[idx+1] = idx + 1
idx += 2
print(" ".join(map(str,res)))
``` | output | 1 | 75,471 | 12 | 150,943 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's define the permutation of length n as an array p = [p1, p2, ..., pn] consisting of n distinct integers from range from 1 to n. We say that this permutation maps value 1 into the value p1, value 2 into the value p2 and so on.
Kyota Ootori has just learned about cyclic representation of a permutation. A cycle is a sequence of numbers such that each element of this sequence is being mapped into the next element of this sequence (and the last element of the cycle is being mapped into the first element of the cycle). The cyclic representation is a representation of p as a collection of cycles forming p. For example, permutation p = [4, 1, 6, 2, 5, 3] has a cyclic representation that looks like (142)(36)(5) because 1 is replaced by 4, 4 is replaced by 2, 2 is replaced by 1, 3 and 6 are swapped, and 5 remains in place.
Permutation may have several cyclic representations, so Kyoya defines the standard cyclic representation of a permutation as follows. First, reorder the elements within each cycle so the largest element is first. Then, reorder all of the cycles so they are sorted by their first element. For our example above, the standard cyclic representation of [4, 1, 6, 2, 5, 3] is (421)(5)(63).
Now, Kyoya notices that if we drop the parenthesis in the standard cyclic representation, we get another permutation! For instance, [4, 1, 6, 2, 5, 3] will become [4, 2, 1, 5, 6, 3].
Kyoya notices that some permutations don't change after applying operation described above at all. He wrote all permutations of length n that do not change in a list in lexicographic order. Unfortunately, his friend Tamaki Suoh lost this list. Kyoya wishes to reproduce the list and he needs your help. Given the integers n and k, print the permutation that was k-th on Kyoya's list.
Input
The first line will contain two integers n, k (1 ≤ n ≤ 50, 1 ≤ k ≤ min{1018, l} where l is the length of the Kyoya's list).
Output
Print n space-separated integers, representing the permutation that is the answer for the question.
Examples
Input
4 3
Output
1 3 2 4
Input
10 1
Output
1 2 3 4 5 6 7 8 9 10
Note
The standard cycle representation is (1)(32)(4), which after removing parenthesis gives us the original permutation. The first permutation on the list would be [1, 2, 3, 4], while the second permutation would be [1, 2, 4, 3]. | instruction | 0 | 75,472 | 12 | 150,944 |
Tags: binary search, combinatorics, constructive algorithms, greedy, implementation, math
Correct Solution:
```
def F(n):
a,b = 1,0
for i in range(n):
a,b = b,a+b
return b
def ans(n,k):
if n == 0:
return []
elif n == 1:
return [1]
elif k > F(n):
return [2,1] + [i+2 for i in ans(n-2,k-F(n))]
else:
return [1] + [i+1 for i in ans(n-1,k)]
n,k = map(int,input().split())
print(' '.join([str(i) for i in ans(n,k)]))
``` | output | 1 | 75,472 | 12 | 150,945 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's define the permutation of length n as an array p = [p1, p2, ..., pn] consisting of n distinct integers from range from 1 to n. We say that this permutation maps value 1 into the value p1, value 2 into the value p2 and so on.
Kyota Ootori has just learned about cyclic representation of a permutation. A cycle is a sequence of numbers such that each element of this sequence is being mapped into the next element of this sequence (and the last element of the cycle is being mapped into the first element of the cycle). The cyclic representation is a representation of p as a collection of cycles forming p. For example, permutation p = [4, 1, 6, 2, 5, 3] has a cyclic representation that looks like (142)(36)(5) because 1 is replaced by 4, 4 is replaced by 2, 2 is replaced by 1, 3 and 6 are swapped, and 5 remains in place.
Permutation may have several cyclic representations, so Kyoya defines the standard cyclic representation of a permutation as follows. First, reorder the elements within each cycle so the largest element is first. Then, reorder all of the cycles so they are sorted by their first element. For our example above, the standard cyclic representation of [4, 1, 6, 2, 5, 3] is (421)(5)(63).
Now, Kyoya notices that if we drop the parenthesis in the standard cyclic representation, we get another permutation! For instance, [4, 1, 6, 2, 5, 3] will become [4, 2, 1, 5, 6, 3].
Kyoya notices that some permutations don't change after applying operation described above at all. He wrote all permutations of length n that do not change in a list in lexicographic order. Unfortunately, his friend Tamaki Suoh lost this list. Kyoya wishes to reproduce the list and he needs your help. Given the integers n and k, print the permutation that was k-th on Kyoya's list.
Input
The first line will contain two integers n, k (1 ≤ n ≤ 50, 1 ≤ k ≤ min{1018, l} where l is the length of the Kyoya's list).
Output
Print n space-separated integers, representing the permutation that is the answer for the question.
Examples
Input
4 3
Output
1 3 2 4
Input
10 1
Output
1 2 3 4 5 6 7 8 9 10
Note
The standard cycle representation is (1)(32)(4), which after removing parenthesis gives us the original permutation. The first permutation on the list would be [1, 2, 3, 4], while the second permutation would be [1, 2, 4, 3].
Submitted Solution:
```
# Contest: 20 - 2100 <= Codeforces Rating <= 2199 (https://a2oj.com/ladder?ID=20)
# Problem: (19) Kyoya and Permutation (Difficulty: 4) (http://codeforces.com/problemset/problem/553/B)
def rint():
return int(input())
def rints():
return list(map(int, input().split()))
n, k = rints()
pos = [0] * (n + 1)
pos[0] = 1
pos[1] = 1
for i in range(2, n + 1):
pos[i] = pos[i - 1] + pos[i - 2]
perm = list(range(1, n + 1))
i = 0
while i < n - 1:
if pos[n - i - 1] < k:
perm[i] += 1
perm[i + 1] -= 1
k -= pos[n - i - 1]
i += 2
else:
i += 1
print(' '.join(map(str, perm)))
``` | instruction | 0 | 75,473 | 12 | 150,946 |
Yes | output | 1 | 75,473 | 12 | 150,947 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's define the permutation of length n as an array p = [p1, p2, ..., pn] consisting of n distinct integers from range from 1 to n. We say that this permutation maps value 1 into the value p1, value 2 into the value p2 and so on.
Kyota Ootori has just learned about cyclic representation of a permutation. A cycle is a sequence of numbers such that each element of this sequence is being mapped into the next element of this sequence (and the last element of the cycle is being mapped into the first element of the cycle). The cyclic representation is a representation of p as a collection of cycles forming p. For example, permutation p = [4, 1, 6, 2, 5, 3] has a cyclic representation that looks like (142)(36)(5) because 1 is replaced by 4, 4 is replaced by 2, 2 is replaced by 1, 3 and 6 are swapped, and 5 remains in place.
Permutation may have several cyclic representations, so Kyoya defines the standard cyclic representation of a permutation as follows. First, reorder the elements within each cycle so the largest element is first. Then, reorder all of the cycles so they are sorted by their first element. For our example above, the standard cyclic representation of [4, 1, 6, 2, 5, 3] is (421)(5)(63).
Now, Kyoya notices that if we drop the parenthesis in the standard cyclic representation, we get another permutation! For instance, [4, 1, 6, 2, 5, 3] will become [4, 2, 1, 5, 6, 3].
Kyoya notices that some permutations don't change after applying operation described above at all. He wrote all permutations of length n that do not change in a list in lexicographic order. Unfortunately, his friend Tamaki Suoh lost this list. Kyoya wishes to reproduce the list and he needs your help. Given the integers n and k, print the permutation that was k-th on Kyoya's list.
Input
The first line will contain two integers n, k (1 ≤ n ≤ 50, 1 ≤ k ≤ min{1018, l} where l is the length of the Kyoya's list).
Output
Print n space-separated integers, representing the permutation that is the answer for the question.
Examples
Input
4 3
Output
1 3 2 4
Input
10 1
Output
1 2 3 4 5 6 7 8 9 10
Note
The standard cycle representation is (1)(32)(4), which after removing parenthesis gives us the original permutation. The first permutation on the list would be [1, 2, 3, 4], while the second permutation would be [1, 2, 4, 3].
Submitted Solution:
```
import math
def get_ans(n, k):
a = []
global fib
if (n == 0):
return a
if (n == 1):
a.append(1)
return a
if (k < fib[n - 1]):
a.append(1)
l = get_ans(n - 1, k)
a.extend(l)
return a
else:
a.append(2)
a.append(1)
l = get_ans(n - 2, k - fib[n - 1])
a.extend(l)
return a
n, k = list(map(int, input().rstrip().split()))
fib = [1, 1]
for i in range(2, n + 1):
fib.append(fib[i - 1] + fib[i - 2])
a = get_ans(n, k - 1)
i = 0
csum = 0
while (i < n):
c = a[i]
for j in range(c):
a[i] += csum
i += 1
csum += c
for i in range(n):
print(a[i], ' ', sep = '', end = '')
print()
``` | instruction | 0 | 75,474 | 12 | 150,948 |
Yes | output | 1 | 75,474 | 12 | 150,949 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's define the permutation of length n as an array p = [p1, p2, ..., pn] consisting of n distinct integers from range from 1 to n. We say that this permutation maps value 1 into the value p1, value 2 into the value p2 and so on.
Kyota Ootori has just learned about cyclic representation of a permutation. A cycle is a sequence of numbers such that each element of this sequence is being mapped into the next element of this sequence (and the last element of the cycle is being mapped into the first element of the cycle). The cyclic representation is a representation of p as a collection of cycles forming p. For example, permutation p = [4, 1, 6, 2, 5, 3] has a cyclic representation that looks like (142)(36)(5) because 1 is replaced by 4, 4 is replaced by 2, 2 is replaced by 1, 3 and 6 are swapped, and 5 remains in place.
Permutation may have several cyclic representations, so Kyoya defines the standard cyclic representation of a permutation as follows. First, reorder the elements within each cycle so the largest element is first. Then, reorder all of the cycles so they are sorted by their first element. For our example above, the standard cyclic representation of [4, 1, 6, 2, 5, 3] is (421)(5)(63).
Now, Kyoya notices that if we drop the parenthesis in the standard cyclic representation, we get another permutation! For instance, [4, 1, 6, 2, 5, 3] will become [4, 2, 1, 5, 6, 3].
Kyoya notices that some permutations don't change after applying operation described above at all. He wrote all permutations of length n that do not change in a list in lexicographic order. Unfortunately, his friend Tamaki Suoh lost this list. Kyoya wishes to reproduce the list and he needs your help. Given the integers n and k, print the permutation that was k-th on Kyoya's list.
Input
The first line will contain two integers n, k (1 ≤ n ≤ 50, 1 ≤ k ≤ min{1018, l} where l is the length of the Kyoya's list).
Output
Print n space-separated integers, representing the permutation that is the answer for the question.
Examples
Input
4 3
Output
1 3 2 4
Input
10 1
Output
1 2 3 4 5 6 7 8 9 10
Note
The standard cycle representation is (1)(32)(4), which after removing parenthesis gives us the original permutation. The first permutation on the list would be [1, 2, 3, 4], while the second permutation would be [1, 2, 4, 3].
Submitted Solution:
```
import math
import sys
def fib(x):
if x<1:
return 0
if x==1:
return 1
if x==2:
return 2
a=1
b=2
for i in range(0,x):
c=a
a=b
b=c+b
return b-a
inp=list(map(int,input().split()))
n=inp[0]
k=inp[1]
k2=k
n2=n
ans=[]
c=0
while n2>0:
f1=fib(n2-1)
f2=fib(n2-2)
if n2==1:
ans.append(1+c)
break
if k2<=f1:
ans.append(1+c)
n2-=1
c+=1
else:
ans.append(2+c)
ans.append(1+c)
c+=2
n2-=2
k2=k2-f1
if n==1:
ans=[1]
if n==2 and k==1:
ans=[1,2]
if n==2 and k==2:
ans=[2,1]
for i in range(0,n-1):
print(str(ans[i]),end=" ")
print(str(ans[n-1]))
``` | instruction | 0 | 75,475 | 12 | 150,950 |
Yes | output | 1 | 75,475 | 12 | 150,951 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's define the permutation of length n as an array p = [p1, p2, ..., pn] consisting of n distinct integers from range from 1 to n. We say that this permutation maps value 1 into the value p1, value 2 into the value p2 and so on.
Kyota Ootori has just learned about cyclic representation of a permutation. A cycle is a sequence of numbers such that each element of this sequence is being mapped into the next element of this sequence (and the last element of the cycle is being mapped into the first element of the cycle). The cyclic representation is a representation of p as a collection of cycles forming p. For example, permutation p = [4, 1, 6, 2, 5, 3] has a cyclic representation that looks like (142)(36)(5) because 1 is replaced by 4, 4 is replaced by 2, 2 is replaced by 1, 3 and 6 are swapped, and 5 remains in place.
Permutation may have several cyclic representations, so Kyoya defines the standard cyclic representation of a permutation as follows. First, reorder the elements within each cycle so the largest element is first. Then, reorder all of the cycles so they are sorted by their first element. For our example above, the standard cyclic representation of [4, 1, 6, 2, 5, 3] is (421)(5)(63).
Now, Kyoya notices that if we drop the parenthesis in the standard cyclic representation, we get another permutation! For instance, [4, 1, 6, 2, 5, 3] will become [4, 2, 1, 5, 6, 3].
Kyoya notices that some permutations don't change after applying operation described above at all. He wrote all permutations of length n that do not change in a list in lexicographic order. Unfortunately, his friend Tamaki Suoh lost this list. Kyoya wishes to reproduce the list and he needs your help. Given the integers n and k, print the permutation that was k-th on Kyoya's list.
Input
The first line will contain two integers n, k (1 ≤ n ≤ 50, 1 ≤ k ≤ min{1018, l} where l is the length of the Kyoya's list).
Output
Print n space-separated integers, representing the permutation that is the answer for the question.
Examples
Input
4 3
Output
1 3 2 4
Input
10 1
Output
1 2 3 4 5 6 7 8 9 10
Note
The standard cycle representation is (1)(32)(4), which after removing parenthesis gives us the original permutation. The first permutation on the list would be [1, 2, 3, 4], while the second permutation would be [1, 2, 4, 3].
Submitted Solution:
```
n, k = map(int,input().split())
tot = [0] * (n + 1)
tot[n - 1] = 1
tot[n] = 1
for i in range(n - 2, -1, -1):
tot[i] = tot[i + 1] * 2
def mPrint(a, b):
for i in range(a + 1, b + 1):
print(i, end = " ")
print(a, end = " " )
last = 0
for i in range(n):
#print(k, tot[i + 1])
if k <= tot[i + 1]:
mPrint(last + 1, i + 1)
last = i + 1
else:
k -= tot[i + 1]
``` | instruction | 0 | 75,476 | 12 | 150,952 |
No | output | 1 | 75,476 | 12 | 150,953 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's define the permutation of length n as an array p = [p1, p2, ..., pn] consisting of n distinct integers from range from 1 to n. We say that this permutation maps value 1 into the value p1, value 2 into the value p2 and so on.
Kyota Ootori has just learned about cyclic representation of a permutation. A cycle is a sequence of numbers such that each element of this sequence is being mapped into the next element of this sequence (and the last element of the cycle is being mapped into the first element of the cycle). The cyclic representation is a representation of p as a collection of cycles forming p. For example, permutation p = [4, 1, 6, 2, 5, 3] has a cyclic representation that looks like (142)(36)(5) because 1 is replaced by 4, 4 is replaced by 2, 2 is replaced by 1, 3 and 6 are swapped, and 5 remains in place.
Permutation may have several cyclic representations, so Kyoya defines the standard cyclic representation of a permutation as follows. First, reorder the elements within each cycle so the largest element is first. Then, reorder all of the cycles so they are sorted by their first element. For our example above, the standard cyclic representation of [4, 1, 6, 2, 5, 3] is (421)(5)(63).
Now, Kyoya notices that if we drop the parenthesis in the standard cyclic representation, we get another permutation! For instance, [4, 1, 6, 2, 5, 3] will become [4, 2, 1, 5, 6, 3].
Kyoya notices that some permutations don't change after applying operation described above at all. He wrote all permutations of length n that do not change in a list in lexicographic order. Unfortunately, his friend Tamaki Suoh lost this list. Kyoya wishes to reproduce the list and he needs your help. Given the integers n and k, print the permutation that was k-th on Kyoya's list.
Input
The first line will contain two integers n, k (1 ≤ n ≤ 50, 1 ≤ k ≤ min{1018, l} where l is the length of the Kyoya's list).
Output
Print n space-separated integers, representing the permutation that is the answer for the question.
Examples
Input
4 3
Output
1 3 2 4
Input
10 1
Output
1 2 3 4 5 6 7 8 9 10
Note
The standard cycle representation is (1)(32)(4), which after removing parenthesis gives us the original permutation. The first permutation on the list would be [1, 2, 3, 4], while the second permutation would be [1, 2, 4, 3].
Submitted Solution:
```
def get_ans(n, k):
global fact
global ans
a = []
if (n <= 0):
return a
curnum = 1
curl = 0
curr = ans[n - 1] - 1
while (1 == 1):
if ((curl <= k) and (curr >= k)):
break
curnum += 1
curl = curr + 1
curr = curl + ans[n - curnum] * fact[curnum - 2] - 1
a.append(curnum)
if (curnum == 1):
l = get_ans(n - 1, k)
a.extend(l)
return a
k1 = k - curl
k1 = k1 // ans[n - curnum]
#print(k1)
pos = 2
used = [-1] * curnum
used[curnum - 1] = 0
for i in range(2, curnum):
poss = []
for j in range(curnum):
if (used[j] != -1):
continue
if (j + 1 == pos):
continue
if (j == used[pos - 1]):
continue
poss.append(j + 1)
cnum = k1 // fact[curnum - i - 1]
a.append(cnum + 1)
k1 = k1 % fact[curnum - i - 1]
used[cnum] = pos - 1
pos += 1
for i in range(curnum):
if (used[i] == -1):
a.append(i + 1)
break
l = get_ans(n - curnum, k % ans[n - curnum])
a.extend(l)
return a
n, k = list(map(int, input().rstrip().split()))
fact = []
fact.append(1)
for i in range(1, 51):
fact.append(fact[i - 1] * i)
ans = []
ans.append(1)
ans.append(1)
for i in range(2, 51):
ans.append(0)
for j in range(1, i + 1):
if (j == 1):
ans[i] += ans[i - 1]
continue
ans[i] += ans[i - j] * fact[j - 2]
a = []
a = get_ans(n, k - 1)
i = 0
csum = 0
while i < n:
sz = a[i]
for j in range(sz):
a[i] += csum
i += 1
csum += sz
for i in range(n):
print(a[i], ' ', sep = '', end = '')
print()
``` | instruction | 0 | 75,477 | 12 | 150,954 |
No | output | 1 | 75,477 | 12 | 150,955 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's define the permutation of length n as an array p = [p1, p2, ..., pn] consisting of n distinct integers from range from 1 to n. We say that this permutation maps value 1 into the value p1, value 2 into the value p2 and so on.
Kyota Ootori has just learned about cyclic representation of a permutation. A cycle is a sequence of numbers such that each element of this sequence is being mapped into the next element of this sequence (and the last element of the cycle is being mapped into the first element of the cycle). The cyclic representation is a representation of p as a collection of cycles forming p. For example, permutation p = [4, 1, 6, 2, 5, 3] has a cyclic representation that looks like (142)(36)(5) because 1 is replaced by 4, 4 is replaced by 2, 2 is replaced by 1, 3 and 6 are swapped, and 5 remains in place.
Permutation may have several cyclic representations, so Kyoya defines the standard cyclic representation of a permutation as follows. First, reorder the elements within each cycle so the largest element is first. Then, reorder all of the cycles so they are sorted by their first element. For our example above, the standard cyclic representation of [4, 1, 6, 2, 5, 3] is (421)(5)(63).
Now, Kyoya notices that if we drop the parenthesis in the standard cyclic representation, we get another permutation! For instance, [4, 1, 6, 2, 5, 3] will become [4, 2, 1, 5, 6, 3].
Kyoya notices that some permutations don't change after applying operation described above at all. He wrote all permutations of length n that do not change in a list in lexicographic order. Unfortunately, his friend Tamaki Suoh lost this list. Kyoya wishes to reproduce the list and he needs your help. Given the integers n and k, print the permutation that was k-th on Kyoya's list.
Input
The first line will contain two integers n, k (1 ≤ n ≤ 50, 1 ≤ k ≤ min{1018, l} where l is the length of the Kyoya's list).
Output
Print n space-separated integers, representing the permutation that is the answer for the question.
Examples
Input
4 3
Output
1 3 2 4
Input
10 1
Output
1 2 3 4 5 6 7 8 9 10
Note
The standard cycle representation is (1)(32)(4), which after removing parenthesis gives us the original permutation. The first permutation on the list would be [1, 2, 3, 4], while the second permutation would be [1, 2, 4, 3].
Submitted Solution:
```
# Contest: 20 - 2100 <= Codeforces Rating <= 2199 (https://a2oj.com/ladder?ID=20)
# Problem: (19) Kyoya and Permutation (Difficulty: 4) (http://codeforces.com/problemset/problem/553/B)
def rint():
return int(input())
def rints():
return list(map(int, input().split()))
n, k = rints()
if k == 1:
print(' '.join(map(str, range(1, n + 1))))
exit(0)
k -= 1
for i in reversed(range(n - 1)):
co = 2 ** ((n - i) // 2 - 1)
print(co)
if co >= k:
perm = list(range(1, n + 1))
perm[i] += 1
perm[i + 1] -= 1
b = bin(k - 1)[2:]
for j, bj in enumerate(b):
if bj == '1':
perm[i + 2 * j] += 1
perm[i + 2 * j + 1] -= 1
print(' '.join(map(str, perm)))
break
k -= co
``` | instruction | 0 | 75,478 | 12 | 150,956 |
No | output | 1 | 75,478 | 12 | 150,957 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's define the permutation of length n as an array p = [p1, p2, ..., pn] consisting of n distinct integers from range from 1 to n. We say that this permutation maps value 1 into the value p1, value 2 into the value p2 and so on.
Kyota Ootori has just learned about cyclic representation of a permutation. A cycle is a sequence of numbers such that each element of this sequence is being mapped into the next element of this sequence (and the last element of the cycle is being mapped into the first element of the cycle). The cyclic representation is a representation of p as a collection of cycles forming p. For example, permutation p = [4, 1, 6, 2, 5, 3] has a cyclic representation that looks like (142)(36)(5) because 1 is replaced by 4, 4 is replaced by 2, 2 is replaced by 1, 3 and 6 are swapped, and 5 remains in place.
Permutation may have several cyclic representations, so Kyoya defines the standard cyclic representation of a permutation as follows. First, reorder the elements within each cycle so the largest element is first. Then, reorder all of the cycles so they are sorted by their first element. For our example above, the standard cyclic representation of [4, 1, 6, 2, 5, 3] is (421)(5)(63).
Now, Kyoya notices that if we drop the parenthesis in the standard cyclic representation, we get another permutation! For instance, [4, 1, 6, 2, 5, 3] will become [4, 2, 1, 5, 6, 3].
Kyoya notices that some permutations don't change after applying operation described above at all. He wrote all permutations of length n that do not change in a list in lexicographic order. Unfortunately, his friend Tamaki Suoh lost this list. Kyoya wishes to reproduce the list and he needs your help. Given the integers n and k, print the permutation that was k-th on Kyoya's list.
Input
The first line will contain two integers n, k (1 ≤ n ≤ 50, 1 ≤ k ≤ min{1018, l} where l is the length of the Kyoya's list).
Output
Print n space-separated integers, representing the permutation that is the answer for the question.
Examples
Input
4 3
Output
1 3 2 4
Input
10 1
Output
1 2 3 4 5 6 7 8 9 10
Note
The standard cycle representation is (1)(32)(4), which after removing parenthesis gives us the original permutation. The first permutation on the list would be [1, 2, 3, 4], while the second permutation would be [1, 2, 4, 3].
Submitted Solution:
```
def get_ans(n, k):
global fact
global ans
a = []
if (n <= 0):
return a
curnum = 1
curl = 0
curr = ans[n - 1] - 1
while (1 == 1):
if ((curl <= k) and (curr >= k)):
break
curnum += 1
curl = curr + 1
curr = curl + ans[n - curnum] * fact[curnum - 2] - 1
a.append(curnum)
if (curnum == 1):
l = get_ans(n - 1, k)
a.extend(l)
return a
k1 = k - curl
k1 = k1 // ans[n - curnum]
#print(k1)
pos = 2
used = [-1] * curnum
used[curnum - 1] = 0
for i in range(2, curnum):
poss = []
for j in range(curnum):
if (used[j] != -1):
continue
if (j + 1 == pos):
continue
if (j == used[pos - 1]):
continue
poss.append(j + 1)
cnum = k1 // fact[curnum - i - 1]
a.append(poss[cnum])
k1 = k1 % fact[curnum - i - 1]
used[poss[cnum] - 1] = pos - 1
pos += 1
for i in range(curnum):
if (used[i] == -1):
a.append(i + 1)
break
l = get_ans(n - curnum, k % ans[n - curnum])
a.extend(l)
return a
n, k = list(map(int, input().rstrip().split()))
fact = []
fact.append(1)
for i in range(1, 51):
fact.append(fact[i - 1] * i)
ans = []
ans.append(1)
ans.append(1)
for i in range(2, 51):
ans.append(0)
for j in range(1, i + 1):
if (j == 1):
ans[i] += ans[i - 1]
continue
ans[i] += ans[i - j] * fact[j - 2]
a = []
a = get_ans(n, k - 1)
i = 0
csum = 0
while i < n:
sz = a[i]
for j in range(sz):
a[i] += csum
i += 1
csum += sz
for i in range(n):
print(a[i], ' ', sep = '', end = '')
print()
``` | instruction | 0 | 75,479 | 12 | 150,958 |
No | output | 1 | 75,479 | 12 | 150,959 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It can be shown that any positive integer x can be uniquely represented as x = 1 + 2 + 4 + ... + 2k - 1 + r, where k and r are integers, k ≥ 0, 0 < r ≤ 2k. Let's call that representation prairie partition of x.
For example, the prairie partitions of 12, 17, 7 and 1 are:
12 = 1 + 2 + 4 + 5,
17 = 1 + 2 + 4 + 8 + 2,
7 = 1 + 2 + 4,
1 = 1.
Alice took a sequence of positive integers (possibly with repeating elements), replaced every element with the sequence of summands in its prairie partition, arranged the resulting numbers in non-decreasing order and gave them to Borys. Now Borys wonders how many elements Alice's original sequence could contain. Find all possible options!
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of numbers given from Alice to Borys.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 1012; a1 ≤ a2 ≤ ... ≤ an) — the numbers given from Alice to Borys.
Output
Output, in increasing order, all possible values of m such that there exists a sequence of positive integers of length m such that if you replace every element with the summands in its prairie partition and arrange the resulting numbers in non-decreasing order, you will get the sequence given in the input.
If there are no such values of m, output a single integer -1.
Examples
Input
8
1 1 2 2 3 4 5 8
Output
2
Input
6
1 1 1 2 2 2
Output
2 3
Input
5
1 2 4 4 4
Output
-1
Note
In the first example, Alice could get the input sequence from [6, 20] as the original sequence.
In the second example, Alice's original sequence could be either [4, 5] or [3, 3, 3]. | instruction | 0 | 75,554 | 12 | 151,108 |
Tags: binary search, constructive algorithms, greedy, math
Correct Solution:
```
from collections import Counter
from math import log2
def can():
seqs_cp = Counter(seqs)
for num in set(nums):
cnt = nums[num]
while cnt != 0 and num < 2 ** 63:
dif = min(cnt, seqs_cp[num])
cnt -= dif
seqs_cp[num] -= dif
num *= 2
if cnt > 0:
return False
return True
n = int(input())
seq = list(map(int, input().split()))
cnt = Counter(seq)
nums = Counter(seq)
seqs = Counter()
cur_cnt = cnt[1]
cur_pow = 1
while cur_cnt != 0:
nums[cur_pow] -= cur_cnt
cur_pow *= 2
if cur_cnt > cnt[cur_pow]:
seqs[cur_pow // 2] = cur_cnt - cnt[cur_pow]
cur_cnt = cnt[cur_pow]
for num in set(nums):
addition = nums[num]
nums[num] = 0
nums[2 ** int(log2(num))] += addition
# remove elements with zero count
nums -= Counter()
seqs -= Counter()
cur_len = sum(seqs[num] for num in set(seqs))
res = []
cur_pow = 1
while can():
res.append(cur_len)
while seqs[cur_pow] == 0 and cur_pow <= 2 ** 63:
cur_pow *= 2
if cur_pow > 2 ** 63:
break
other_pow = 1
while other_pow <= cur_pow:
nums[other_pow] += 1
other_pow *= 2
seqs[cur_pow] -= 1
cur_len -= 1
print(-1 if len(res) == 0 else ' '.join(map(str, reversed(res))))
``` | output | 1 | 75,554 | 12 | 151,109 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of length n. Remove one element from permutation to make the number of records the maximum possible.
We remind that in a sequence of numbers a1, a2, ..., ak the element ai is a record if for every integer j (1 ≤ j < i) the following holds: aj < ai.
Input
The first line contains the only integer n (1 ≤ n ≤ 105) — the length of the permutation.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the permutation. All the integers are distinct.
Output
Print the only integer — the element that should be removed to make the number of records the maximum possible. If there are multiple such elements, print the smallest one.
Examples
Input
1
1
Output
1
Input
5
5 1 2 3 4
Output
5
Note
In the first example the only element can be removed. | instruction | 0 | 75,579 | 12 | 151,158 |
Tags: brute force, data structures, math
Correct Solution:
```
n=int(input())
a={}
for i in range(1,n+1):
a[i]=0
max1,max2=0,0
for i in map(int,input().split()):
if i<max1:
if i>max2:
a[max1]+=1
max2=i
else:
a[i]-=1
max2=max1
max1=i
m=-100
for i in a:
if a[i]>m:
m=a[i]
ans=i
print(ans)
``` | output | 1 | 75,579 | 12 | 151,159 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of length n. Remove one element from permutation to make the number of records the maximum possible.
We remind that in a sequence of numbers a1, a2, ..., ak the element ai is a record if for every integer j (1 ≤ j < i) the following holds: aj < ai.
Input
The first line contains the only integer n (1 ≤ n ≤ 105) — the length of the permutation.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the permutation. All the integers are distinct.
Output
Print the only integer — the element that should be removed to make the number of records the maximum possible. If there are multiple such elements, print the smallest one.
Examples
Input
1
1
Output
1
Input
5
5 1 2 3 4
Output
5
Note
In the first example the only element can be removed. | instruction | 0 | 75,580 | 12 | 151,160 |
Tags: brute force, data structures, math
Correct Solution:
```
a=int(input())
b=[]
for i in range(a+1):
b.append(0)
fir=0
sec=0
for i in (input().split(' ')):
j=int(i)
if j>fir:
sec=fir
fir=j
b[j]=1
elif j>sec:
sec=j
b[fir]-=1
ans=1
for i in range(1,a+1):
if b[i]<b[ans]:
ans=i
print(ans)
``` | output | 1 | 75,580 | 12 | 151,161 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of length n. Remove one element from permutation to make the number of records the maximum possible.
We remind that in a sequence of numbers a1, a2, ..., ak the element ai is a record if for every integer j (1 ≤ j < i) the following holds: aj < ai.
Input
The first line contains the only integer n (1 ≤ n ≤ 105) — the length of the permutation.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the permutation. All the integers are distinct.
Output
Print the only integer — the element that should be removed to make the number of records the maximum possible. If there are multiple such elements, print the smallest one.
Examples
Input
1
1
Output
1
Input
5
5 1 2 3 4
Output
5
Note
In the first example the only element can be removed. | instruction | 0 | 75,581 | 12 | 151,162 |
Tags: brute force, data structures, math
Correct Solution:
```
n = int(input())
p = list(map(int, input().split()))
mbef = [-1]*n
for i in range(1, n):
if mbef[i-1] == -1 or p[mbef[i-1]] < p[i-1]:
mbef[i] = i-1
else:
mbef[i] = mbef[i-1]
#print(mbef)
smbef = [-1]*n
for i in range(2, n):
if smbef[i-1] == -1:
if i-1 != mbef[i]:
smbef[i] = i-1
else:
smbef[i] = mbef[i-1]
elif smbef[i-1] != -1:
if i-1 != mbef[i]:
if p[i-1] > p[smbef[i-1]]:
smbef[i] = i-1
else:
smbef[i] = smbef[i-1]
else:
smbef[i] = mbef[i-1]
#print(smbef)
anw = {}
for i in range(n):
anw[i+1] = 0
for i in range(1, n):
if p[i] < p[mbef[i]] and (smbef[i] == -1 or p[i] > p[smbef[i]]):
anw[p[mbef[i]]] += 1
for i in range(n):
if mbef[i] == -1 or p[i] > p[mbef[i]]:
anw[p[i]] -= 1
anw_v = 1
anw_c = -2
for val, cnt in anw.items():
#print(val, cnt)
if cnt > anw_c or (cnt == anw_c and val < anw_v):
anw_c = cnt
anw_v = val
print(anw_v)
``` | output | 1 | 75,581 | 12 | 151,163 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of length n. Remove one element from permutation to make the number of records the maximum possible.
We remind that in a sequence of numbers a1, a2, ..., ak the element ai is a record if for every integer j (1 ≤ j < i) the following holds: aj < ai.
Input
The first line contains the only integer n (1 ≤ n ≤ 105) — the length of the permutation.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the permutation. All the integers are distinct.
Output
Print the only integer — the element that should be removed to make the number of records the maximum possible. If there are multiple such elements, print the smallest one.
Examples
Input
1
1
Output
1
Input
5
5 1 2 3 4
Output
5
Note
In the first example the only element can be removed. | instruction | 0 | 75,582 | 12 | 151,164 |
Tags: brute force, data structures, math
Correct Solution:
```
a,b,ap = 0,0,-1
n = int(input())
l = [int(i) for i in input().split()]
k = [0]*n
for i in range(len(l)):
if l[i] > a:
b = a
a = l[i]
ap = i
k[i] = -1
elif l[i] > b:
b = l[i]
k[ap] += 1
c = max(k)
a = n+1
for i in range(len(k)):
if k[i] == c:
a = min(a,l[i])
print(a)
``` | output | 1 | 75,582 | 12 | 151,165 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of length n. Remove one element from permutation to make the number of records the maximum possible.
We remind that in a sequence of numbers a1, a2, ..., ak the element ai is a record if for every integer j (1 ≤ j < i) the following holds: aj < ai.
Input
The first line contains the only integer n (1 ≤ n ≤ 105) — the length of the permutation.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the permutation. All the integers are distinct.
Output
Print the only integer — the element that should be removed to make the number of records the maximum possible. If there are multiple such elements, print the smallest one.
Examples
Input
1
1
Output
1
Input
5
5 1 2 3 4
Output
5
Note
In the first example the only element can be removed. | instruction | 0 | 75,583 | 12 | 151,166 |
Tags: brute force, data structures, math
Correct Solution:
```
bit = [0] * 100100
def upd(pos, x):
while pos < 100100:
bit[pos] += x
pos += pos & (-pos)
def sum(pos):
res = 0
while pos > 0:
res += bit[pos];
pos -= pos & (-pos)
return res
def main():
n = int(input())
arr = [0]
for x in input().split():
arr.append(int(x))
pont = [0] * 100100
if n == 1:
print(1)
exit()
elif n == 2:
print(1)
exit()
else:
maxi = arr[1]
upd(arr[1],1)
pont[arr[1]] = -1
for i in range(2,n+1):
'''
print("sum[",n,"] = ",sum(n))
print("sum[",arr[i],"] = ",sum(arr[i]))
print()
'''
if (sum(n) - sum(arr[i])) == 1:
#se eu tirar consigo 1
pont[maxi] += 1
if (sum(n) - sum(arr[i])) == 0:
#se eu tirar perco 1
pont[arr[i]] -= 1
upd(arr[i],1)
maxi = max(maxi, arr[i])
resp = -9999999
for i in range(1,n+1):
resp = max(resp,pont[i])
res = 99999999
for i in range(1,n+1):
# print(i, ": ", pont[i])
if resp == pont[i]:
res = min(res, i)
print(res)
main()
``` | output | 1 | 75,583 | 12 | 151,167 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of length n. Remove one element from permutation to make the number of records the maximum possible.
We remind that in a sequence of numbers a1, a2, ..., ak the element ai is a record if for every integer j (1 ≤ j < i) the following holds: aj < ai.
Input
The first line contains the only integer n (1 ≤ n ≤ 105) — the length of the permutation.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the permutation. All the integers are distinct.
Output
Print the only integer — the element that should be removed to make the number of records the maximum possible. If there are multiple such elements, print the smallest one.
Examples
Input
1
1
Output
1
Input
5
5 1 2 3 4
Output
5
Note
In the first example the only element can be removed. | instruction | 0 | 75,584 | 12 | 151,168 |
Tags: brute force, data structures, math
Correct Solution:
```
n = int(input())
dct = {}
for i in range(1,n+1):
dct[i] = 0
max1 = 0
max2 = 0
for i in list(map(int,input().split())):
if i < max1:
if i > max2:
dct[max1] += 1
max2 = i
else:
dct[i] -= 1
max1,max2 = i,max1
m = -100
for i in dct:
if dct[i] > m:
m = dct[i]
ans = i
print(ans)
``` | output | 1 | 75,584 | 12 | 151,169 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of length n. Remove one element from permutation to make the number of records the maximum possible.
We remind that in a sequence of numbers a1, a2, ..., ak the element ai is a record if for every integer j (1 ≤ j < i) the following holds: aj < ai.
Input
The first line contains the only integer n (1 ≤ n ≤ 105) — the length of the permutation.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the permutation. All the integers are distinct.
Output
Print the only integer — the element that should be removed to make the number of records the maximum possible. If there are multiple such elements, print the smallest one.
Examples
Input
1
1
Output
1
Input
5
5 1 2 3 4
Output
5
Note
In the first example the only element can be removed. | instruction | 0 | 75,585 | 12 | 151,170 |
Tags: brute force, data structures, math
Correct Solution:
```
def zero():
return 0
from collections import defaultdict
n = int(input())
p = [int(i) for i in input().split()]
c=defaultdict(zero)
a,b=0,0
for i in range(n):
if(p[i]>a):
b=a
a=p[i]
c[p[i]]-=1
elif p[i]>b:
b=p[i]
c[a]+=1
res=1
for i in range(2,n+1):
if(c[i]>c[res]):
res=i
print(res)
``` | output | 1 | 75,585 | 12 | 151,171 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation p of length n. Remove one element from permutation to make the number of records the maximum possible.
We remind that in a sequence of numbers a1, a2, ..., ak the element ai is a record if for every integer j (1 ≤ j < i) the following holds: aj < ai.
Input
The first line contains the only integer n (1 ≤ n ≤ 105) — the length of the permutation.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the permutation. All the integers are distinct.
Output
Print the only integer — the element that should be removed to make the number of records the maximum possible. If there are multiple such elements, print the smallest one.
Examples
Input
1
1
Output
1
Input
5
5 1 2 3 4
Output
5
Note
In the first example the only element can be removed. | instruction | 0 | 75,586 | 12 | 151,172 |
Tags: brute force, data structures, math
Correct Solution:
```
# Author : nitish420 --------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
# mod=10**9+7
# sys.setrecursionlimit(10**6)
# from functools import lru_cache
from collections import defaultdict
def main():
n=int(input())
l=list(map(int,input().split()))
if n<=2:
print(min(l))
exit()
mx,smx=0,0
records=[0]*(n)
dct=defaultdict(int)
total=0
for i in range(n):
if mx<l[i]:
smx=mx
mx=l[i]
elif smx<l[i]:
smx=l[i]
if l[i]==mx:
records[i]=1
total+=1
elif smx==l[i]:
dct[mx]+=1
ans=[0]*(n)
mx=0
for i in range(n):
ans[i]=total-records[i]+dct[l[i]]
if mx<ans[i]:
mx=ans[i]
mm=n+1
for i in range(n):
if ans[i]==mx:
if mm>l[i]:
mm=l[i]
print(mm)
#----------------------------------------------------------------------------------------
def nouse0():
# This is to save my code from plag due to use of FAST IO template in it.
a=420
b=420
print(f'i am nitish{(a+b)//2}')
def nouse1():
# This is to save my code from plag due to use of FAST IO template in it.
a=420
b=420
print(f'i am nitish{(a+b)//2}')
def nouse2():
# This is to save my code from plag due to use of FAST IO template in it.
a=420
b=420
print(f'i am nitish{(a+b)//2}')
# 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')
def nouse3():
# This is to save my code from plag due to use of FAST IO template in it.
a=420
b=420
print(f'i am nitish{(a+b)//2}')
def nouse4():
# This is to save my code from plag due to use of FAST IO template in it.
a=420
b=420
print(f'i am nitish{(a+b)//2}')
def nouse5():
# This is to save my code from plag due to use of FAST IO template in it.
a=420
b=420
print(f'i am nitish{(a+b)//2}')
# endregion
if __name__ == '__main__':
main()
``` | output | 1 | 75,586 | 12 | 151,173 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p of length n. Remove one element from permutation to make the number of records the maximum possible.
We remind that in a sequence of numbers a1, a2, ..., ak the element ai is a record if for every integer j (1 ≤ j < i) the following holds: aj < ai.
Input
The first line contains the only integer n (1 ≤ n ≤ 105) — the length of the permutation.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the permutation. All the integers are distinct.
Output
Print the only integer — the element that should be removed to make the number of records the maximum possible. If there are multiple such elements, print the smallest one.
Examples
Input
1
1
Output
1
Input
5
5 1 2 3 4
Output
5
Note
In the first example the only element can be removed.
Submitted Solution:
```
"""
Author - Satwik Tiwari .
"""
#===============================================================================================
#importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from functools import cmp_to_key
# from itertools import *
from heapq import *
from math import gcd, factorial,floor,ceil,sqrt,log2
from copy import deepcopy
from collections import deque
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
#==============================================================================================
#fast I/O region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
#===============================================================================================
#some shortcuts
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def testcase(t):
for pp in range(t):
solve(pp)
def google(p):
print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def modInverse(b):
g = gcd(b, mod)
if (g != 1):
# print("Inverse doesn't exist")
return -1
else:
# If b and m are relatively prime,
# then modulo inverse is b^(m-2) mode m
return pow(b, mod - 2, mod)
def power(x, y, p) :
y%=(p-1) #not so sure about this. used when y>p-1. if p is prime.
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) : # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
inf = pow(10,20)
mod = 10**9+7
#===============================================================================================
# code here ;))
class FenwickTree:
def __init__(self, x):
"""transform list into BIT"""
self.bit = x
for i in range(len(x)):
j = i | (i + 1)
if j < len(x):
x[j] += x[i]
def update(self, idx, x):
"""updates bit[idx] += x"""
while idx < len(self.bit):
self.bit[idx] += x
idx |= idx + 1
def query(self, end):
"""calc sum(bit[:end))"""
x = 0
while end:
x += self.bit[end - 1]
end &= end - 1
return x
def findkth(self, k):
"""Find largest idx such that sum(bit[:idx]) <= k"""
idx = -1
for d in reversed(range(len(self.bit).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(self.bit) and k >= self.bit[right_idx]:
idx = right_idx
k -= self.bit[idx]
return idx + 1
def printpref(self):
out = []
for i in range(len(self.bit) + 1):
out.append(self.query(i))
print(out)
def solve(case):
n = int(inp())
a = lis()
if(n == 1):
print(a[0])
return
bit = FenwickTree([0]*(n + 10))
already = [0]*n
need1 = [0]*n
for i in range(n):
temp = bit.query(a[i])
# print(a[i],temp)
if(temp == i):
already[i] = 1
if(temp == i-1):
need1[i] = 1
bit.update(a[i],1)
# print(need1)
# print(already)
left = [0]*(n + 1)
right = [0]*(n + 1)
for i in range(n):
if(already[i]):
left[i] = left[i-1] + 1
else:
left[i] = left[i-1]
for i in range(n-1,-1,-1):
if(already[i]):
right[i] = right[i+1] + 1
else:
right[i] = right[i + 1]
# print(left)
# print(right)
ans = -inf
val = inf
bit = FenwickTree([0]*(n + 10))
for i in range(n-1,-1,-1):
temp = bit.query(a[i])
if(left[i-1] + right[i + 1] + temp > ans or (left[i-1] + right[i + 1] + temp == ans and a[i] < val)):
ans = left[i-1] + right[i + 1] + temp
val = a[i]
if(need1[i]):
bit.update(a[i],1)
# print(a[i],left[i-1],right[i+1],temp)
print(val)
testcase(1)
# testcase(int(inp()))
``` | instruction | 0 | 75,587 | 12 | 151,174 |
Yes | output | 1 | 75,587 | 12 | 151,175 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p of length n. Remove one element from permutation to make the number of records the maximum possible.
We remind that in a sequence of numbers a1, a2, ..., ak the element ai is a record if for every integer j (1 ≤ j < i) the following holds: aj < ai.
Input
The first line contains the only integer n (1 ≤ n ≤ 105) — the length of the permutation.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the permutation. All the integers are distinct.
Output
Print the only integer — the element that should be removed to make the number of records the maximum possible. If there are multiple such elements, print the smallest one.
Examples
Input
1
1
Output
1
Input
5
5 1 2 3 4
Output
5
Note
In the first example the only element can be removed.
Submitted Solution:
```
from collections import defaultdict
from operator import itemgetter
n = int(input().strip())
p = list(map(int, input().strip().split()))
ml = -float('inf')
mli = None
ms = -float('inf')
msi = None
count = defaultdict(int)
isRecord = [0] * n
for i, v in enumerate(p):
if v > ml:
isRecord[i] = 1
if ms < v <= ml:
count[mli] += 1
if v >= ml:
ms, msi = ml, mli
ml, mli = v, i
elif v >= ms:
ms, msi = v, i
num = sum(isRecord)
ma = -float('inf')
mai = None
for i in range(n):
v = count[i] - isRecord[i] + num
if v > ma:
ma = v
mai = i
elif v == ma and p[i] < p[mai]:
mai = i
# print(count)
print(p[mai])
``` | instruction | 0 | 75,588 | 12 | 151,176 |
Yes | output | 1 | 75,588 | 12 | 151,177 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p of length n. Remove one element from permutation to make the number of records the maximum possible.
We remind that in a sequence of numbers a1, a2, ..., ak the element ai is a record if for every integer j (1 ≤ j < i) the following holds: aj < ai.
Input
The first line contains the only integer n (1 ≤ n ≤ 105) — the length of the permutation.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the permutation. All the integers are distinct.
Output
Print the only integer — the element that should be removed to make the number of records the maximum possible. If there are multiple such elements, print the smallest one.
Examples
Input
1
1
Output
1
Input
5
5 1 2 3 4
Output
5
Note
In the first example the only element can be removed.
Submitted Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
import sys
from io import BytesIO, IOBase
def main():
n=int(input())
a=list(map(int,input().split()))
intial=[0]*n
b=[0]*(n+1)
ma,ma1=0,0
for i in range(n):
if ma<a[i]:
ma1=ma
ma=a[i]
elif ma1<a[i] and a[i]!=ma:
ma1=a[i]
intial[i]=int(ma==a[i])
b[ma]+=(ma1==a[i])
su=sum(intial)
ans=[0]*n
for i in range(n):
ans[i]=su-intial[i]+b[a[i]]
ma=max(ans)
mi=n+1
for i in range(n):
if ans[i]==ma:
mi=min(mi,a[i])
print(mi)
# 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")
if __name__ == "__main__":
main()
``` | instruction | 0 | 75,589 | 12 | 151,178 |
Yes | output | 1 | 75,589 | 12 | 151,179 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p of length n. Remove one element from permutation to make the number of records the maximum possible.
We remind that in a sequence of numbers a1, a2, ..., ak the element ai is a record if for every integer j (1 ≤ j < i) the following holds: aj < ai.
Input
The first line contains the only integer n (1 ≤ n ≤ 105) — the length of the permutation.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the permutation. All the integers are distinct.
Output
Print the only integer — the element that should be removed to make the number of records the maximum possible. If there are multiple such elements, print the smallest one.
Examples
Input
1
1
Output
1
Input
5
5 1 2 3 4
Output
5
Note
In the first example the only element can be removed.
Submitted Solution:
```
import sys
# import bisect
# from collections import deque
# from types import GeneratorType
# def bootstrap(func, stack=[]):
# def wrapped_function(*args, **kwargs):
# if stack:
# return func(*args, **kwargs)
# else:
# call = func(*args, **kwargs)
# while True:
# if type(call) is GeneratorType:
# stack.append(call)
# call = next(call)
# else:
# stack.pop()
# if not stack:
# break
# call = stack[-1].send(call)
# return call
# return wrapped_function
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
n = int(ri())
a = Ri()
maxx, premaxx = -1,-1
pospremaxx = -1
posmaxx = -1
lis = [0]*n
for i in range(n):
if a[i] > maxx:
premaxx = maxx
maxx = a[i]
lis[i]-=1
posmaxx = i
elif a[i] > premaxx:
# print(a[i], premaxx, maxx)
lis[posmaxx]+=1
premaxx = a[i]
pospremaxx = i
# print(lis)
ans = -1
posans = -1
for i in range(n):
if lis[i] >= ans:
if lis[i] == ans:
if a[posans] > a[i]:
posans = i
ans = lis[i]
else:
posans = i
ans = lis[i]
print(a[posans])
``` | instruction | 0 | 75,590 | 12 | 151,180 |
Yes | output | 1 | 75,590 | 12 | 151,181 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p of length n. Remove one element from permutation to make the number of records the maximum possible.
We remind that in a sequence of numbers a1, a2, ..., ak the element ai is a record if for every integer j (1 ≤ j < i) the following holds: aj < ai.
Input
The first line contains the only integer n (1 ≤ n ≤ 105) — the length of the permutation.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the permutation. All the integers are distinct.
Output
Print the only integer — the element that should be removed to make the number of records the maximum possible. If there are multiple such elements, print the smallest one.
Examples
Input
1
1
Output
1
Input
5
5 1 2 3 4
Output
5
Note
In the first example the only element can be removed.
Submitted Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
import sys
from io import BytesIO, IOBase
from collections import Counter
class SortedList:
def __init__(self, iterable=None, _load=200):
"""Initialize sorted list instance."""
if iterable is None:
iterable = []
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
def main():
n=int(input())
a=list(map(int,input().split()))
if n==1:
print(1)
else:
b=SortedList()
ans=1
c=Counter()
b.add(a[0])
for i in range(1,n):
if a[i]<b[-1]:
b.add(a[i])
if len(b)>1 and b[-2]==a[i]:
c[b[-1]]+=1
else:
b.add(a[i])
if len(c):
ma=c[max(c,key=c.get)]
mi=n+1
for i in c:
if c[i]==ma:
mi=min(mi,i)
print(mi)
else:
print(a[0])
# 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")
if __name__ == "__main__":
main()
``` | instruction | 0 | 75,591 | 12 | 151,182 |
No | output | 1 | 75,591 | 12 | 151,183 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p of length n. Remove one element from permutation to make the number of records the maximum possible.
We remind that in a sequence of numbers a1, a2, ..., ak the element ai is a record if for every integer j (1 ≤ j < i) the following holds: aj < ai.
Input
The first line contains the only integer n (1 ≤ n ≤ 105) — the length of the permutation.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the permutation. All the integers are distinct.
Output
Print the only integer — the element that should be removed to make the number of records the maximum possible. If there are multiple such elements, print the smallest one.
Examples
Input
1
1
Output
1
Input
5
5 1 2 3 4
Output
5
Note
In the first example the only element can be removed.
Submitted Solution:
```
N=int(input())
L=list(map(int,input().split()))
X=[]
if N==1:
print(L[0])
else:
for I in range(N-1):
if L[I]>L[I+1]:
X.append(L[I])
if X==[]:
print(min(L))
else:
print(min(X))
``` | instruction | 0 | 75,592 | 12 | 151,184 |
No | output | 1 | 75,592 | 12 | 151,185 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p of length n. Remove one element from permutation to make the number of records the maximum possible.
We remind that in a sequence of numbers a1, a2, ..., ak the element ai is a record if for every integer j (1 ≤ j < i) the following holds: aj < ai.
Input
The first line contains the only integer n (1 ≤ n ≤ 105) — the length of the permutation.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the permutation. All the integers are distinct.
Output
Print the only integer — the element that should be removed to make the number of records the maximum possible. If there are multiple such elements, print the smallest one.
Examples
Input
1
1
Output
1
Input
5
5 1 2 3 4
Output
5
Note
In the first example the only element can be removed.
Submitted Solution:
```
n=int(input())
c={}
for i in range(1,n+1):
c[i]=0
max1=0
max2=0
for i in list(map(int,input().split())):
if i<max1:
if i>max2:
c[max1]+=1
max2=i
else:
max1,max2=i,max1
m=-1
for i in c:
if c[i]>m:
m=c[i]
ans=i
print(ans)
``` | instruction | 0 | 75,593 | 12 | 151,186 |
No | output | 1 | 75,593 | 12 | 151,187 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation p of length n. Remove one element from permutation to make the number of records the maximum possible.
We remind that in a sequence of numbers a1, a2, ..., ak the element ai is a record if for every integer j (1 ≤ j < i) the following holds: aj < ai.
Input
The first line contains the only integer n (1 ≤ n ≤ 105) — the length of the permutation.
The second line contains n integers p1, p2, ..., pn (1 ≤ pi ≤ n) — the permutation. All the integers are distinct.
Output
Print the only integer — the element that should be removed to make the number of records the maximum possible. If there are multiple such elements, print the smallest one.
Examples
Input
1
1
Output
1
Input
5
5 1 2 3 4
Output
5
Note
In the first example the only element can be removed.
Submitted Solution:
```
from typing import List, Set, Dict, Tuple, Text, Optional, Callable, Any
from collections import deque
import collections
from types import GeneratorType
import itertools
import operator
import functools
import random
import copy
import heapq
import math
import sys
import os
from atexit import register
from io import BytesIO, IOBase
import __pypy__ # type: ignore
EPS = 10**-12
################
# INPUT OUTPUT #
################
# From: https://github.com/cheran-senthil/PyRival/blob/master/templates/template_py3.py
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)
class Input(object):
def rawInput(self):
return sys.stdin.readline().rstrip("\r\n")
def readInt(self):
return int(self.rawInput())
class Output(object):
def __init__(self):
self.out = __pypy__.builders.StringBuilder()
def write(self, text):
# type: (str) -> None
self.out.append(str(text))
def writeLine(self, text):
# type: (str) -> None
self.write(str(text) + '\n')
def finalize(self):
sys.stdout.write(self.out.build())
sys.stdout.flush()
###########
# LIBRARY #
###########
def bootstrap(f, stack=[]):
# Deep Recursion helper.
# From: https://github.com/cheran-senthil/PyRival/blob/c1972da95d102d95b9fea7c5c8e0474d61a54378/docs/bootstrap.rst
# Usage:
# @bootstrap
# def recur(n):
# if n == 0:
# yield 1
# yield (yield recur(n-1)) * n
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
int_add = __pypy__.intop.int_add
int_sub = __pypy__.intop.int_sub
int_mul = __pypy__.intop.int_mul
def make_mod_mul(mod):
fmod_inv = 1.0 / mod
def mod_mul(a, b, c=0):
res = int_sub(int_add(int_mul(a, b), c), int_mul(
mod, int(fmod_inv * a * b + fmod_inv * c)))
if res >= mod:
return res - mod
elif res < 0:
return res + mod
else:
return res
return mod_mul
class BinaryTree(object):
# Implementation taken from CLRS
'''
>>> t = BinaryTree()
>>> t.put(5)
5
>>> t.min()
5
>>> t.max()
5
>>> t.xth(0)
5
>>> len(t)
1
>>> t.put(8)
8
>>> t.put(3)
3
>>> t.put(3)
3
>>> t.count_lte(8)
4
>>> t.count_lte(5)
3
>>> t.count_lte(4)
2
>>> len(t)
4
>>> t.min()
3
>>> t.max()
8
>>> t.xth(1)
3
>>> t.xth(2)
5
>>> t.pop(3)
3
>>> len(t)
3
>>> t.min()
3
>>> t.max()
8
>>> t.pop(3)
3
>>> t.pop(5)
5
>>> t.pop(8)
8
>>> len(t)
0
Tested:
https://codeforces.com/problemset/problem/20/C
'''
def __init__(self):
# Initialize with root and nil node
self.value = [0, 0] # type: List[Any]
self.left = [0, 0] # type: List[int]
self.right = [0, 0] # type: List[int]
self.parent = [0, 0] # type: List[int]
# How many nodes at the subtree rooted here.
self.node_count = [0, 0] # type: int
self.is_black = [True, True] # type: List[bool]
self.root = 0
def _rotate_left(self, node):
x = node
y = self.right[node]
self.right[x] = self.left[y]
self.parent[self.left[y]] = x
parent = self.parent[x]
self.parent[y] = parent
if not parent:
# Root
self.root = y
else:
if self.left[parent] == x:
self.left[parent] = y
else:
self.right[parent] = y
self.left[y] = x
self.parent[x] = y
# Update node count of x and y
self.node_count[x] = self.node_count[self.left[x]] + \
self.node_count[self.right[x]] + 1
self.node_count[y] = self.node_count[self.left[y]] + \
self.node_count[self.right[y]] + 1
def _rotate_right(self, node):
x = node
y = self.left[node]
self.left[x] = self.right[y]
self.parent[self.right[y]] = x
parent = self.parent[x]
self.parent[y] = parent
if not parent:
# Root
self.root = y
else:
if self.right[parent] == x:
self.right[parent] = y
else:
self.left[parent] = y
self.right[y] = x
self.parent[x] = y
# Update node count of x and y
self.node_count[x] = self.node_count[self.left[x]] + \
self.node_count[self.right[x]] + 1
self.node_count[y] = self.node_count[self.left[y]] + \
self.node_count[self.right[y]] + 1
def _uncle(self, node):
# type: (int) -> int
grandpa = self.parent[self.parent[node]]
if self.left[grandpa] == self.parent[node]:
return self.right[grandpa]
else:
return self.left[grandpa]
def put(self, value):
# type: (Any) -> Any
# Create the new node
z = len(self.value)
self.value.append(value)
self.left.append(0)
self.right.append(0)
self.parent.append(0)
self.node_count.append(1)
self.is_black.append(True)
# First locate an empty node to insert while updating node count
y = 0
x = self.root
while x:
self.node_count[x] += 1
y = x
if self.value[z] < self.value[x]:
x = self.left[x]
else:
x = self.right[x]
# Insert node into tree
self.parent[z] = y
if not y:
self.root = z
else:
if self.value[z] < self.value[y]:
self.left[y] = z
else:
self.right[y] = z
# Color new node red
self.is_black[z] = False
# Now fix the red black tree invariant
while not self.is_black[self.parent[z]]:
parent = self.parent[z]
grand = self.parent[parent]
if parent == self.left[grand]:
y = self.right[grand]
if not self.is_black[y]:
self.is_black[parent] = True
self.is_black[y] = True
self.is_black[grand] = False
z = grand
else:
if z == self.right[parent]:
z = parent
self._rotate_left(z)
parent = self.parent[z]
self.is_black[parent] = True
self.is_black[grand] = False
self._rotate_right(grand)
else:
y = self.left[grand]
if not self.is_black[y]:
self.is_black[parent] = True
self.is_black[y] = True
self.is_black[grand] = False
z = grand
else:
if z == self.left[parent]:
z = parent
self._rotate_right(z)
parent = self.parent[z]
self.is_black[parent] = True
self.is_black[grand] = False
self._rotate_left(grand)
self.is_black[self.root] = True
return value
def _fix_node_count_upwards(self, node):
# type: (int) -> None
while node:
self.node_count[node] = self.node_count[self.left[node]
] + self.node_count[self.right[node]] + 1
node = self.parent[node]
def has(self, value):
z = self.root
while z and self.value[z] != value:
if self.value[z] > value:
z = self.left[z]
else:
z = self.right[z]
return z
def pop(self, value):
# type: (int) -> int
# First, find the node to delete
z = self.root
while self.value[z] != value:
if self.value[z] > value:
z = self.left[z]
else:
z = self.right[z]
if not self.left[z] or not self.right[z]:
y = z
else:
# Find the successor
successor = self.left[z]
while self.right[successor]:
successor = self.right[successor]
# Swap the metadatas
self.value[z] = self.value[successor]
y = successor
if self.left[y]:
x = self.left[y]
else:
x = self.right[y]
parent = self.parent[y]
self.parent[x] = parent
if not parent:
self.root = x
else:
if y == self.left[parent]:
self.left[parent] = x
else:
self.right[parent] = x
# Node count metadata update
self._fix_node_count_upwards(parent)
if self.is_black[y]:
# Need to fix RB-Tree
if x:
self._fix_rb_tree_deletion(x)
elif self.parent[x]:
self._fix_rb_tree_deletion(self.parent[x])
return value
def _fix_rb_tree_deletion(self, x):
while x != self.root and self.is_black[x]:
parent = self.parent[x]
if x == self.left[parent]:
w = self.right[parent]
if not self.is_black[w]:
self.is_black[w] = True
self.is_black[parent] = False
self._rotate_left(parent)
parent = self.parent[x]
w = self.right[parent]
if self.is_black[self.left[w]] and self.is_black[self.right[w]]:
if w:
self.is_black[w] = False
x = parent
else:
if self.is_black[self.right[w]]:
self.is_black[self.left[w]] = True
self.is_black[w] = False
self._rotate_right(w)
parent = self.parent[x]
w = self.right[parent]
self.is_black[w] = self.is_black[parent]
self.is_black[parent] = True
self.is_black[self.right[w]] = True
self._rotate_left(parent)
x = self.root
else:
w = self.left[parent]
if not self.is_black[w]:
self.is_black[w] = True
self.is_black[parent] = False
self._rotate_right(parent)
parent = self.parent[x]
w = self.left[parent]
if self.is_black[self.left[w]] and self.is_black[self.right[w]]:
if w:
self.is_black[w] = False
x = parent
else:
if self.is_black[self.left[w]]:
self.is_black[self.right[w]] = True
self.is_black[w] = False
self._rotate_left(w)
parent = self.parent[x]
w = self.left[parent]
self.is_black[w] = self.is_black[parent]
self.is_black[parent] = True
self.is_black[self.left[w]] = True
self._rotate_right(parent)
x = self.root
self.is_black[x] = True
def __len__(self):
# type: () -> int
return self.node_count[self.root]
def min(self):
# type: () -> Any
node = self.root
while self.left[node]:
node = self.left[node]
return self.value[node]
def max(self):
# type: () -> Any
node = self.root
while self.right[node]:
node = self.right[node]
return self.value[node]
def xth(self, index):
# type: (int) -> Any
node = self.root
while self.node_count[self.left[node]] != index:
if self.node_count[self.left[node]] > index:
node = self.left[node]
else:
index -= self.node_count[self.left[node]] + 1
node = self.right[node]
return self.value[node]
def next(self, value):
z = self.root
while z and self.value[z] != value:
if self.value[z] > value:
z = self.left[z]
else:
z = self.right[z]
while z and not self.right[z]:
z = self.parent[z]
if not z:
return None
z = self.right[z]
while self.left[z]:
z = self.left[z]
return self.value[z]
def count_lte(self, value):
node = self.root
ans = 0
while node:
if self.value[node] <= value:
ans += 1 + self.node_count[self.left[node]]
node = self.right[node]
else:
node = self.left[node]
return ans
#########
# LOGIC #
#########
def main(inp: Input, out: Output) -> Any:
inp.readInt()
nums = list(map(int, inp.rawInput().split()))
remain = BinaryTree()
for i in nums:
remain.put(i)
prev = 0
best_ans = -100
best_num = 1
for i in nums:
# what happens if we remove this?
if i < prev:
# won't change anything
continue
big_next = remain.next(i)
if big_next is None:
uncovered = len(remain)
else:
uncovered = remain.count_lte(big_next) - 2
if uncovered > best_ans or (uncovered == best_ans and i < best_num):
best_ans = uncovered
best_num = i
while prev+1 <= i:
prev += 1
remain.pop(prev)
out.writeLine(best_num)
###############
# BOILERPLATE #
###############
output_obj = Output()
main(Input(), output_obj)
output_obj.finalize()
``` | instruction | 0 | 75,594 | 12 | 151,188 |
No | output | 1 | 75,594 | 12 | 151,189 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a permutation P_1, \ldots, P_N of 1, \ldots, N. Find the number of integers i (1 \leq i \leq N) that satisfy the following condition:
* For any integer j (1 \leq j \leq i), P_i \leq P_j.
Constraints
* 1 \leq N \leq 2 \times 10^5
* P_1, \ldots, P_N is a permutation of 1, \ldots, N.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
P_1 ... P_N
Output
Print the number of integers i that satisfy the condition.
Examples
Input
5
4 2 5 1 3
Output
3
Input
4
4 3 2 1
Output
4
Input
6
1 2 3 4 5 6
Output
1
Input
8
5 7 4 2 6 8 1 3
Output
4
Input
1
1
Output
1 | instruction | 0 | 75,666 | 12 | 151,332 |
"Correct Solution:
```
N,P=int(input()),list(map(int,input().split()))
for i in range(1,N):
P[i]=min(P[~-i],P[i])
print(len(set(P)))
``` | output | 1 | 75,666 | 12 | 151,333 |
Provide a correct Python 3 solution for this coding contest problem.
There are N arrays. The length of each array is M and initially each array contains integers (1，2，...，M) in this order.
Mr. Takahashi has decided to perform Q operations on those N arrays. For the i-th (1≤i≤Q) time, he performs the following operation.
* Choose an arbitrary array from the N arrays and move the integer a_i (1≤a_i≤M) to the front of that array. For example, after performing the operation on a_i=2 and the array (5，4，3，2，1), this array becomes (2，5，4，3，1).
Mr. Takahashi wants to make N arrays exactly the same after performing the Q operations. Determine if it is possible or not.
Constraints
* 2≤N≤10^5
* 2≤M≤10^5
* 1≤Q≤10^5
* 1≤a_i≤M
Input
The input is given from Standard Input in the following format:
N M
Q
a_1 a_2 ... a_Q
Output
Print `Yes` if it is possible to make N arrays exactly the same after performing the Q operations. Otherwise, print `No`.
Examples
Input
2 2
3
2 1 2
Output
Yes
Input
3 2
3
2 1 2
Output
No
Input
2 3
3
3 2 1
Output
Yes
Input
3 3
6
1 2 2 3 3 3
Output
No | instruction | 0 | 75,771 | 12 | 151,542 |
"Correct Solution:
```
def reads(offset = 0):
return [int(i) - offset for i in input().split(' ')]
def Judge(vector):
length = len(vector)-1
for i in range(length):
if(vector[i] > vector[i+1]):
return 0
return 1
(N, M) = reads()
Q = int(input())
A = reads(1)
pos = [-1] * M
pat = []
freq = [0] * (M+1)
freq[0] = N
found = set()
counter = 0
for i in A[::-1]:
if (i not in found):
pat.append(i)
found.add(i)
pos[i] = counter
counter += 1
if(counter == M):
break
for i in range(M):
if (pos[i] == -1):
pat.append(i)
for i in A[::-1]:
temp = pos[i]
if (freq[temp] > 0):
freq[temp] -= 1
freq[temp+1] += 1
start = M
for i in range(M):
if (freq[i] != 0):
start = i
break
print("Yes") if Judge(pat[start:]) else print("No")
``` | output | 1 | 75,771 | 12 | 151,543 |
Provide a correct Python 3 solution for this coding contest problem.
There are N arrays. The length of each array is M and initially each array contains integers (1，2，...，M) in this order.
Mr. Takahashi has decided to perform Q operations on those N arrays. For the i-th (1≤i≤Q) time, he performs the following operation.
* Choose an arbitrary array from the N arrays and move the integer a_i (1≤a_i≤M) to the front of that array. For example, after performing the operation on a_i=2 and the array (5，4，3，2，1), this array becomes (2，5，4，3，1).
Mr. Takahashi wants to make N arrays exactly the same after performing the Q operations. Determine if it is possible or not.
Constraints
* 2≤N≤10^5
* 2≤M≤10^5
* 1≤Q≤10^5
* 1≤a_i≤M
Input
The input is given from Standard Input in the following format:
N M
Q
a_1 a_2 ... a_Q
Output
Print `Yes` if it is possible to make N arrays exactly the same after performing the Q operations. Otherwise, print `No`.
Examples
Input
2 2
3
2 1 2
Output
Yes
Input
3 2
3
2 1 2
Output
No
Input
2 3
3
3 2 1
Output
Yes
Input
3 3
6
1 2 2 3 3 3
Output
No | instruction | 0 | 75,772 | 12 | 151,544 |
"Correct Solution:
```
def read():
return int(input())
def reads(sep=None):
return list(map(int, input().split()))
def f(m, a):
sa = set(a)
seen = set()
r = []
for n in a[::-1]:
if n not in seen:
r.append(n)
seen.add(n)
for i in range(m):
if (i+1) not in sa:
r.append(i+1)
return r
def isSorted(a):
for i in range(1, len(a)):
if a[i-1] > a[i]:
return False
return True
n, m = reads()
q = read()
a = reads()
r = f(m, a)
count = [0] * (m+1)
count[0] = n
table = [-1] * (m+1)
for i in range(len(r)):
table[r[i]] = i
for aa in a[::-1]:
index = table[aa]
if 0 < count[index]:
count[index] -= 1
count[index+1] += 1
to = m
for i in range(m):
if 0 < count[i]:
to = i
break
if isSorted(r[to:]):
print('Yes')
else:
print('No')
``` | output | 1 | 75,772 | 12 | 151,545 |
Provide a correct Python 3 solution for this coding contest problem.
There are N arrays. The length of each array is M and initially each array contains integers (1，2，...，M) in this order.
Mr. Takahashi has decided to perform Q operations on those N arrays. For the i-th (1≤i≤Q) time, he performs the following operation.
* Choose an arbitrary array from the N arrays and move the integer a_i (1≤a_i≤M) to the front of that array. For example, after performing the operation on a_i=2 and the array (5，4，3，2，1), this array becomes (2，5，4，3，1).
Mr. Takahashi wants to make N arrays exactly the same after performing the Q operations. Determine if it is possible or not.
Constraints
* 2≤N≤10^5
* 2≤M≤10^5
* 1≤Q≤10^5
* 1≤a_i≤M
Input
The input is given from Standard Input in the following format:
N M
Q
a_1 a_2 ... a_Q
Output
Print `Yes` if it is possible to make N arrays exactly the same after performing the Q operations. Otherwise, print `No`.
Examples
Input
2 2
3
2 1 2
Output
Yes
Input
3 2
3
2 1 2
Output
No
Input
2 3
3
3 2 1
Output
Yes
Input
3 3
6
1 2 2 3 3 3
Output
No | instruction | 0 | 75,773 | 12 | 151,546 |
"Correct Solution:
```
"""
Writer: SPD_9X2
https://atcoder.jp/contests/code-festival-2016-quala/tasks/codefestival_2016_qualA_e
最後の配列の状態は何で決定されるか。
同じaが同じ配列に複数回採用されたとき、効果があるのは最後に
採用したaのみ。(それ以前は合っても無くても同じになる)
最初、1が採用状態になっていると考えてよい。
→おそらく気にすべきは配列aのみ(Nこの配列は考慮しなくてよい)
1以外は、出現するなら少なくともN個出現しなければ不可能
2,3だけで考えてみよう
N==3のとき
322233 →不可能(2が先頭が1つ生まれてしまう)
232233 →可能
→終了後の配列の数字は、最後に出現した順に前から並ぶ
→よってaを見れば構成後の数列は分かる
→後ろからaを見ていって、先に登場したやつより後に登場したほうが数が越えたらダメ
→ただし、N個目以降は完全無視する
→終了時に数がNに達していないのがあったらダメ(1を除く？)
いや例3…
→初期状態、の扱い方を考え直さなきゃな…
aの前に M…M(N個),M-1…M-1,…,1…1 があると考える
すると、aを後ろから見ていった時に先に登場したやつより後に登場したほうが数が越えてはいけない、
だけの条件になる！！
あ、2233223 は…？
最後の2つの2を1箇所に適応すれば可能じゃん！
lis[a[i][0]]ってなんだ…？
→それ以降に先頭をa[i][0]に更新できる最大数
→よって、indに対して単調減少になっていなければいけない
うん？前を超えないようにして、最終的にすべてN以上になればおｋ？
"""
import sys
N,M = map(int,input().split())
Q = int(input())
A = list(map(int,input().split()))
dic = {}
lis = []
flag = True
a = [[M-i,N] for i in range(M)]
for i in range(Q):
a.append([A[i],1])
a.reverse()
#print (a)
for i in range(len(a)):
if a[i][0] not in dic:
ind = len(dic)
dic[a[i][0]] = ind
if ind != 0:
lis.append(min(lis[ind-1] , a[i][1]))
else:
lis.append(a[i][1])
else:
ind = dic[a[i][0]]
if ind != 0:
lis[ind] = min(N, lis[ind] + a[i][1] , lis[ind-1])
else:
lis[ind] = min(N, lis[ind] + a[i][1])
if lis[-1] == N:
print ("Yes")
else:
print ("No")
``` | output | 1 | 75,773 | 12 | 151,547 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.