message stringlengths 2 433k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has an array a consisting of n integers. He has learned partial sums recently, and now he can calculate the sum of elements on any segment of the array really fast. The segment is a non-empty sequence of elements standing one next to another in the array.
Now he wonders what is the number of segments in his array with the sum less than t. Help Petya to calculate this number.
More formally, you are required to calculate the number of pairs l, r (l ≤ r) such that a_l + a_{l+1} + ... + a_{r-1} + a_r < t.
Input
The first line contains two integers n and t (1 ≤ n ≤ 200 000, |t| ≤ 2⋅10^{14}).
The second line contains a sequence of integers a_1, a_2, ..., a_n (|a_{i}| ≤ 10^{9}) — the description of Petya's array. Note that there might be negative, zero and positive elements.
Output
Print the number of segments in Petya's array with the sum of elements less than t.
Examples
Input
5 4
5 -1 3 4 -1
Output
5
Input
3 0
-1 2 -3
Output
4
Input
4 -1
-2 1 -2 3
Output
3
Note
In the first example the following segments have sum less than 4:
* [2, 2], sum of elements is -1
* [2, 3], sum of elements is 2
* [3, 3], sum of elements is 3
* [4, 5], sum of elements is 3
* [5, 5], sum of elements is -1 | instruction | 0 | 96,077 | 12 | 192,154 |
Tags: data structures, divide and conquer, two pointers
Correct Solution:
```
import sys
import bisect
input=sys.stdin.readline
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
n,t=map(int,input().split())
a=list(map(int,input().split()))
pre=[0]*(n+1)
for i in range(n):
pre[i+1]=pre[i]+a[i]
pre.sort(reverse=True)
upsum=[-10**18]
for i in range(n+1):
if i==0 or pre[i]!=pre[i-1]:
upsum.append(pre[i])
upsum.sort(reverse=True)
def lower(i):
l=0;r=len(upsum)
while r-l>0:
m=(l+r)//2
if upsum[m]<=i:
r=m
else:
l=m+1
return l
ans=0
cur=0
BIT=Bit(n+2)
BIT.add(lower(0)+1,1)
for aa in a:
cur+=aa
ans+=BIT.sum(lower(cur-t))
BIT.add(lower(cur)+1,1)
print(ans)
``` | output | 1 | 96,077 | 12 | 192,155 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has an array a consisting of n integers. He has learned partial sums recently, and now he can calculate the sum of elements on any segment of the array really fast. The segment is a non-empty sequence of elements standing one next to another in the array.
Now he wonders what is the number of segments in his array with the sum less than t. Help Petya to calculate this number.
More formally, you are required to calculate the number of pairs l, r (l ≤ r) such that a_l + a_{l+1} + ... + a_{r-1} + a_r < t.
Input
The first line contains two integers n and t (1 ≤ n ≤ 200 000, |t| ≤ 2⋅10^{14}).
The second line contains a sequence of integers a_1, a_2, ..., a_n (|a_{i}| ≤ 10^{9}) — the description of Petya's array. Note that there might be negative, zero and positive elements.
Output
Print the number of segments in Petya's array with the sum of elements less than t.
Examples
Input
5 4
5 -1 3 4 -1
Output
5
Input
3 0
-1 2 -3
Output
4
Input
4 -1
-2 1 -2 3
Output
3
Note
In the first example the following segments have sum less than 4:
* [2, 2], sum of elements is -1
* [2, 3], sum of elements is 2
* [3, 3], sum of elements is 3
* [4, 5], sum of elements is 3
* [5, 5], sum of elements is -1 | instruction | 0 | 96,078 | 12 | 192,156 |
Tags: data structures, divide and conquer, two pointers
Correct Solution:
```
# -*- coding:utf-8 -*-
"""
created by shuangquan.huang at 11/21/18
Fenwick Tree
prefix sum in s
j < i, s[i]-s[j] < t,
i+1 - (c = count of j that makes s[i]-s[j] >= t)
c = count of s[j] <= s[i] - t
"""
import bisect
N, T = map(int, input().split())
A = [int(x) for x in input().split()]
prefsums = [0] * (N+1)
for i in range(N):
prefsums[i+1] = A[i] + prefsums[i]
MAXNN = len(prefsums) + 1
L = [0] * MAXNN
def lsb(i):
return i & (-i)
def update(i):
while i < MAXNN:
L[i] += 1
i |= i+1
def get(i):
ans = 0
while i >= 0:
ans += L[i]
i = (i&(i+1))-1
return ans
prefsums = list(sorted(set(prefsums)))
ans = 0
update(bisect.bisect_left(prefsums, 0))
pr = 0
for i, v in enumerate(A):
pr += v
npos = bisect.bisect_right(prefsums, pr-T)
ans += i+1-get(npos-1)
k = bisect.bisect_left(prefsums, pr)
update(k)
print(ans)
``` | output | 1 | 96,078 | 12 | 192,157 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has an array a consisting of n integers. He has learned partial sums recently, and now he can calculate the sum of elements on any segment of the array really fast. The segment is a non-empty sequence of elements standing one next to another in the array.
Now he wonders what is the number of segments in his array with the sum less than t. Help Petya to calculate this number.
More formally, you are required to calculate the number of pairs l, r (l ≤ r) such that a_l + a_{l+1} + ... + a_{r-1} + a_r < t.
Input
The first line contains two integers n and t (1 ≤ n ≤ 200 000, |t| ≤ 2⋅10^{14}).
The second line contains a sequence of integers a_1, a_2, ..., a_n (|a_{i}| ≤ 10^{9}) — the description of Petya's array. Note that there might be negative, zero and positive elements.
Output
Print the number of segments in Petya's array with the sum of elements less than t.
Examples
Input
5 4
5 -1 3 4 -1
Output
5
Input
3 0
-1 2 -3
Output
4
Input
4 -1
-2 1 -2 3
Output
3
Note
In the first example the following segments have sum less than 4:
* [2, 2], sum of elements is -1
* [2, 3], sum of elements is 2
* [3, 3], sum of elements is 3
* [4, 5], sum of elements is 3
* [5, 5], sum of elements is -1 | instruction | 0 | 96,079 | 12 | 192,158 |
Tags: data structures, divide and conquer, two pointers
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")
##########################################################
import math
import bisect
#for _ in range(int(input())):
from collections import Counter
#sys.setrecursionlimit(10**6)
#dp=[[-1 for i in range(n+5)]for j in range(cap+5)]
#arr= list(map(int, input().split()))
#n,m= map(int, input().split())
#arr= list(map(int, input().split()))
#for _ in range(int(input())):
import bisect
#n=int(input())
from collections import deque
#n,m= map(int, input().split())
#rr =deque(map(int, input().split()))
#for _ in range(int(input())):
#n,m=map(int, input().split())
#for _ in range(int(input())):
#n=int(input())
#arr = list(map(int, input().split()))
def up(ind,val):
while ind<=cnt+1:
bit[ind]+=1
ind+=(ind & -ind)
def bit_sum(ind):
val=0
while ind>0:
val+=bit[ind]
ind-=(ind & -ind)
return val
n,k= map(int, input().split())
arr = list(map(int, input().split()))
p=[0]*n
p[0]=arr[0]
minus=[arr[0]-k]
for i in range(1,n):
p[i]=p[i-1]+arr[i]
minus.append(p[i]-k)
minus.extend(p)
array=sorted(minus)
cnt=1
d={}
for i in array:
if i not in d:
d[i]=cnt
cnt+=1
bit=[0]*(cnt+2)
ans=0
for i in p:
var=d[i-k]
ans+=bit_sum(cnt+1)-bit_sum(var)
up(d[i],1)
if i<k:
ans+=1
print(ans)
``` | output | 1 | 96,079 | 12 | 192,159 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has an array a consisting of n integers. He has learned partial sums recently, and now he can calculate the sum of elements on any segment of the array really fast. The segment is a non-empty sequence of elements standing one next to another in the array.
Now he wonders what is the number of segments in his array with the sum less than t. Help Petya to calculate this number.
More formally, you are required to calculate the number of pairs l, r (l ≤ r) such that a_l + a_{l+1} + ... + a_{r-1} + a_r < t.
Input
The first line contains two integers n and t (1 ≤ n ≤ 200 000, |t| ≤ 2⋅10^{14}).
The second line contains a sequence of integers a_1, a_2, ..., a_n (|a_{i}| ≤ 10^{9}) — the description of Petya's array. Note that there might be negative, zero and positive elements.
Output
Print the number of segments in Petya's array with the sum of elements less than t.
Examples
Input
5 4
5 -1 3 4 -1
Output
5
Input
3 0
-1 2 -3
Output
4
Input
4 -1
-2 1 -2 3
Output
3
Note
In the first example the following segments have sum less than 4:
* [2, 2], sum of elements is -1
* [2, 3], sum of elements is 2
* [3, 3], sum of elements is 3
* [4, 5], sum of elements is 3
* [5, 5], sum of elements is -1 | instruction | 0 | 96,080 | 12 | 192,160 |
Tags: data structures, divide and conquer, two pointers
Correct Solution:
```
n, t = list(map(int, input().split()))
a = list(map(int, input().split()))
summ = [0]
cur = 0
for i in range(n):
cur += a[i]
summ.append(cur)
def merge(l, mid, r):
i, j = l, mid + 1
ans = 0
while i <= mid and j <= r:
if summ[i] + t > summ[j]:
ans += (mid + 1 - i)
j += 1
else:
i += 1
tmp = []
i, j = l, mid + 1
while i <= mid and j <= r:
if summ[i] <= summ[j]:
tmp.append(summ[i])
i += 1
else:
tmp.append(summ[j])
j += 1
if i <= mid:
tmp.extend(summ[i:mid + 1])
if j <= r:
tmp.extend(summ[j:r+1])
for i in range(l, r + 1):
summ[i] = tmp[i - l]
return ans
def helper(l, r):
if l == r:
return 0
mid = (l + r) // 2
ans1 = helper(l, mid)
ans2 = helper(mid + 1, r)
ans3 = merge(l, mid, r)
#print(ans1, ans2, ans3)
return ans1 + ans2 + ans3
res = helper(0, n)
print(res)
'''
5 4
5 -1 3 4 -1
Output
5
Input
3 0
-1 2 -3
Output
4
Input
4 -1
-2 1 -2 3
Output
3
'''
``` | output | 1 | 96,080 | 12 | 192,161 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has an array a consisting of n integers. He has learned partial sums recently, and now he can calculate the sum of elements on any segment of the array really fast. The segment is a non-empty sequence of elements standing one next to another in the array.
Now he wonders what is the number of segments in his array with the sum less than t. Help Petya to calculate this number.
More formally, you are required to calculate the number of pairs l, r (l ≤ r) such that a_l + a_{l+1} + ... + a_{r-1} + a_r < t.
Input
The first line contains two integers n and t (1 ≤ n ≤ 200 000, |t| ≤ 2⋅10^{14}).
The second line contains a sequence of integers a_1, a_2, ..., a_n (|a_{i}| ≤ 10^{9}) — the description of Petya's array. Note that there might be negative, zero and positive elements.
Output
Print the number of segments in Petya's array with the sum of elements less than t.
Examples
Input
5 4
5 -1 3 4 -1
Output
5
Input
3 0
-1 2 -3
Output
4
Input
4 -1
-2 1 -2 3
Output
3
Note
In the first example the following segments have sum less than 4:
* [2, 2], sum of elements is -1
* [2, 3], sum of elements is 2
* [3, 3], sum of elements is 3
* [4, 5], sum of elements is 3
* [5, 5], sum of elements is -1 | instruction | 0 | 96,081 | 12 | 192,162 |
Tags: data structures, divide and conquer, two pointers
Correct Solution:
```
maxn = 2*10**5 + 5
bit = [0]*(maxn)
def add(idx):
idx += 1
while idx < maxn:
bit[idx] += 1
idx += idx & -idx
def sm(idx):
idx += 1
tot = 0
while idx > 0:
tot += bit[idx]
idx -= idx & -idx
return tot
n,t = map(int,input().split())
a = list(map(int,input().split()))
psum = [0]*(n+1)
for i in range(n):
psum[i+1] = psum[i] + a[i]
psum.sort(reverse=True)
upsum = [-10**18]
for i in range(n+1):
if i == 0 or psum[i] != psum[i-1]:
upsum.append(psum[i])
upsum.sort(reverse = True)
def lower_bound(i):
l = 0; r = len(upsum) - 1
while l != r:
m = (l+r)//2
if upsum[m] <= i:
r = m
else:
l = m + 1
return l
ans = 0
curr = 0
add(lower_bound(0))
for i in a:
curr += i
ans += sm(lower_bound(curr-t)-1)
add(lower_bound(curr))
print(ans)
``` | output | 1 | 96,081 | 12 | 192,163 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has an array a consisting of n integers. He has learned partial sums recently, and now he can calculate the sum of elements on any segment of the array really fast. The segment is a non-empty sequence of elements standing one next to another in the array.
Now he wonders what is the number of segments in his array with the sum less than t. Help Petya to calculate this number.
More formally, you are required to calculate the number of pairs l, r (l ≤ r) such that a_l + a_{l+1} + ... + a_{r-1} + a_r < t.
Input
The first line contains two integers n and t (1 ≤ n ≤ 200 000, |t| ≤ 2⋅10^{14}).
The second line contains a sequence of integers a_1, a_2, ..., a_n (|a_{i}| ≤ 10^{9}) — the description of Petya's array. Note that there might be negative, zero and positive elements.
Output
Print the number of segments in Petya's array with the sum of elements less than t.
Examples
Input
5 4
5 -1 3 4 -1
Output
5
Input
3 0
-1 2 -3
Output
4
Input
4 -1
-2 1 -2 3
Output
3
Note
In the first example the following segments have sum less than 4:
* [2, 2], sum of elements is -1
* [2, 3], sum of elements is 2
* [3, 3], sum of elements is 3
* [4, 5], sum of elements is 3
* [5, 5], sum of elements is -1 | instruction | 0 | 96,082 | 12 | 192,164 |
Tags: data structures, divide and conquer, two pointers
Correct Solution:
```
def lowbit(index):
return index & (-index)
def update(index, delta=1):
while index <= size:
tree[index] += delta
index += lowbit(index)
def query(index):
res = 0
while index > 0:
res += tree[index]
index -= lowbit(index)
return res
n, t = list(map(int, input().split()))
a = list(map(int, input().split()))
#n, t = 5, 4
#a = [5, -1, 3, 4, -1]
summ_raw = [0]
summ_minus = []
cur = 0
for i in range(n):
cur += a[i]
summ_raw.append(cur)
summ_minus.append(cur - t)
summ = sorted(list(set(summ_raw + summ_minus)))
size = len(summ)
d = {}
for i in range(size):
d[summ[i]] = i + 1
#print(summ)
#print(d)
tree = [0] * (size + 1)
update(d[0])
res = 0
for i in range(1, n+1):
v = summ_raw[i]
index = d[v - t]
cur = (query(size) - query(index))
#print(tree, size, query(size), cur, v, index)
res += cur
update(d[v])
print(res)
'''
# divide and conquer, two pointers
n, t = list(map(int, input().split()))
a = list(map(int, input().split()))
summ = [0]
cur = 0
for i in range(n):
cur += a[i]
summ.append(cur)
def merge(l, mid, r):
i, j = l, mid + 1
ans = 0
while i <= mid and j <= r:
if summ[i] + t > summ[j]:
ans += (mid + 1 - i)
j += 1
else:
i += 1
tmp = []
i, j = l, mid + 1
while i <= mid and j <= r:
if summ[i] <= summ[j]:
tmp.append(summ[i])
i += 1
else:
tmp.append(summ[j])
j += 1
if i <= mid:
tmp.extend(summ[i:mid + 1])
if j <= r:
tmp.extend(summ[j:r+1])
for i in range(l, r + 1):
summ[i] = tmp[i - l]
return ans
def helper(l, r):
if l == r:
return 0
mid = (l + r) // 2
ans1 = helper(l, mid)
ans2 = helper(mid + 1, r)
ans3 = merge(l, mid, r)
#print(ans1, ans2, ans3)
return ans1 + ans2 + ans3
res = helper(0, n)
print(res)
'''
'''
5 4
5 -1 3 4 -1
Output
5
Input
3 0
-1 2 -3
Output
4
Input
4 -1
-2 1 -2 3
Output
3
'''
``` | output | 1 | 96,082 | 12 | 192,165 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has an array a consisting of n integers. He has learned partial sums recently, and now he can calculate the sum of elements on any segment of the array really fast. The segment is a non-empty sequence of elements standing one next to another in the array.
Now he wonders what is the number of segments in his array with the sum less than t. Help Petya to calculate this number.
More formally, you are required to calculate the number of pairs l, r (l ≤ r) such that a_l + a_{l+1} + ... + a_{r-1} + a_r < t.
Input
The first line contains two integers n and t (1 ≤ n ≤ 200 000, |t| ≤ 2⋅10^{14}).
The second line contains a sequence of integers a_1, a_2, ..., a_n (|a_{i}| ≤ 10^{9}) — the description of Petya's array. Note that there might be negative, zero and positive elements.
Output
Print the number of segments in Petya's array with the sum of elements less than t.
Examples
Input
5 4
5 -1 3 4 -1
Output
5
Input
3 0
-1 2 -3
Output
4
Input
4 -1
-2 1 -2 3
Output
3
Note
In the first example the following segments have sum less than 4:
* [2, 2], sum of elements is -1
* [2, 3], sum of elements is 2
* [3, 3], sum of elements is 3
* [4, 5], sum of elements is 3
* [5, 5], sum of elements is -1 | instruction | 0 | 96,083 | 12 | 192,166 |
Tags: data structures, divide and conquer, two pointers
Correct Solution:
```
import bisect
class BIT:
def __init__(self, node_size):
self._node = node_size+1
self.bit = [0]*self._node
def add(self, index, add_val):
while index < self._node:
self.bit[index] += add_val
index += index & -index
def sum(self, index):
res = 0
while index > 0:
res += self.bit[index]
index -= index & -index
return res
n,t = map(int,input().split())
a = list(map(int,input().split()))
ru = [0] * (n+1)
ans = 0
for i in range(1,n+1):
ru[i] = ru[i-1]+ a[i-1]
rus = sorted(ru)
bit = BIT(n+2)
for i in range(n+1):
ru[i] = bisect.bisect_left(rus,ru[i])
for i in range(n+1):
ind = bisect.bisect_left(rus,rus[ru[i]]-t+1)
ans += bit.sum(n+2)-bit.sum(ind)
bit.add(ru[i]+1,1)
print(ans)
``` | output | 1 | 96,083 | 12 | 192,167 |
Provide tags and a correct Python 2 solution for this coding contest problem.
Petya has an array a consisting of n integers. He has learned partial sums recently, and now he can calculate the sum of elements on any segment of the array really fast. The segment is a non-empty sequence of elements standing one next to another in the array.
Now he wonders what is the number of segments in his array with the sum less than t. Help Petya to calculate this number.
More formally, you are required to calculate the number of pairs l, r (l ≤ r) such that a_l + a_{l+1} + ... + a_{r-1} + a_r < t.
Input
The first line contains two integers n and t (1 ≤ n ≤ 200 000, |t| ≤ 2⋅10^{14}).
The second line contains a sequence of integers a_1, a_2, ..., a_n (|a_{i}| ≤ 10^{9}) — the description of Petya's array. Note that there might be negative, zero and positive elements.
Output
Print the number of segments in Petya's array with the sum of elements less than t.
Examples
Input
5 4
5 -1 3 4 -1
Output
5
Input
3 0
-1 2 -3
Output
4
Input
4 -1
-2 1 -2 3
Output
3
Note
In the first example the following segments have sum less than 4:
* [2, 2], sum of elements is -1
* [2, 3], sum of elements is 2
* [3, 3], sum of elements is 3
* [4, 5], sum of elements is 3
* [5, 5], sum of elements is -1 | instruction | 0 | 96,084 | 12 | 192,168 |
Tags: data structures, divide and conquer, two pointers
Correct Solution:
```
#Run code in language PyPy2
#change input() in Python 3 become raw_input() like python2 then submit
#Add this code prefix of your code
import atexit
import io
import sys
buff = io.BytesIO()
sys.stdout = buff
@atexit.register
def write():
sys.__stdout__.write(buff.getvalue())
# code
r = raw_input
n,t = map(int,r().split())
arr = [int(x) for x in r().split()]
N = -40**14-20**14
presum =[0]
#Function
def update(Bit,x):
while(x<=n):
Bit[x]+=1
x+=(x&-x)
def get(Bit,x):
res = 0
while(x>0):
res+=Bit[x]
x-=(x&-x)
return res
#
for i in arr:
presum.append(presum[-1]+i)
fakeIndex = [N]
for i in presum:
fakeIndex.append(i)
fakeIndex.append(i-t)
fakeIndex.sort()
Indx = {}
for i,j in enumerate(fakeIndex):
#print(j,' ',i)
Indx[j] = i
n = len(fakeIndex)
Bit = [0 for i in range(0,n+1)]
ans = 0
cnt = 0
for i in presum:
#temp = get(Bit,Indx[i-t])
ans+=(cnt - get(Bit,Indx[i-t]))
update(Bit,Indx[i])
cnt+=1
print(ans)
``` | output | 1 | 96,084 | 12 | 192,169 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya has an array a consisting of n integers. He has learned partial sums recently, and now he can calculate the sum of elements on any segment of the array really fast. The segment is a non-empty sequence of elements standing one next to another in the array.
Now he wonders what is the number of segments in his array with the sum less than t. Help Petya to calculate this number.
More formally, you are required to calculate the number of pairs l, r (l ≤ r) such that a_l + a_{l+1} + ... + a_{r-1} + a_r < t.
Input
The first line contains two integers n and t (1 ≤ n ≤ 200 000, |t| ≤ 2⋅10^{14}).
The second line contains a sequence of integers a_1, a_2, ..., a_n (|a_{i}| ≤ 10^{9}) — the description of Petya's array. Note that there might be negative, zero and positive elements.
Output
Print the number of segments in Petya's array with the sum of elements less than t.
Examples
Input
5 4
5 -1 3 4 -1
Output
5
Input
3 0
-1 2 -3
Output
4
Input
4 -1
-2 1 -2 3
Output
3
Note
In the first example the following segments have sum less than 4:
* [2, 2], sum of elements is -1
* [2, 3], sum of elements is 2
* [3, 3], sum of elements is 3
* [4, 5], sum of elements is 3
* [5, 5], sum of elements is -1
Submitted Solution:
```
from itertools import accumulate, chain
class Fenwick:
def __init__(self, n):
self.tree = [0] * (n + 1)
def update(self, i, val):
i += 1
while i < len(self.tree):
self.tree[i] += 1
i += (i & -i)
def get(self, i):
i += 1
total = 0
while i > 0:
total += self.tree[i]
i -= (i & -i)
return total
def solution(n, a, t):
S = [s for s in accumulate(a)]
T = set([s for s in S] + [s - t for s in S])
T = sorted(T)
T = {v: i for i, v in enumerate(T)}
fenwick = Fenwick(len(T))
total = 0
for i, v in enumerate(S):
diff = v - t
total += i - fenwick.get(T[diff])
if v < t:
total += 1
fenwick.update(T[v], 1)
return total
f = lambda: [int(c) for c in input().split()]
n, t = f()
a = f()
print(solution(n, a, t))
``` | instruction | 0 | 96,085 | 12 | 192,170 |
Yes | output | 1 | 96,085 | 12 | 192,171 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya has an array a consisting of n integers. He has learned partial sums recently, and now he can calculate the sum of elements on any segment of the array really fast. The segment is a non-empty sequence of elements standing one next to another in the array.
Now he wonders what is the number of segments in his array with the sum less than t. Help Petya to calculate this number.
More formally, you are required to calculate the number of pairs l, r (l ≤ r) such that a_l + a_{l+1} + ... + a_{r-1} + a_r < t.
Input
The first line contains two integers n and t (1 ≤ n ≤ 200 000, |t| ≤ 2⋅10^{14}).
The second line contains a sequence of integers a_1, a_2, ..., a_n (|a_{i}| ≤ 10^{9}) — the description of Petya's array. Note that there might be negative, zero and positive elements.
Output
Print the number of segments in Petya's array with the sum of elements less than t.
Examples
Input
5 4
5 -1 3 4 -1
Output
5
Input
3 0
-1 2 -3
Output
4
Input
4 -1
-2 1 -2 3
Output
3
Note
In the first example the following segments have sum less than 4:
* [2, 2], sum of elements is -1
* [2, 3], sum of elements is 2
* [3, 3], sum of elements is 3
* [4, 5], sum of elements is 3
* [5, 5], sum of elements is -1
Submitted Solution:
```
# https://tjkendev.github.io/procon-library/python/range_query/rsq_ruq_segment_tree_lp.html
class segmentTree():
initValue = 0
dat = []
lenTreeLeaf = -1
depthTreeList = 0
lenOriginalList = -1
func = None
funcPropagateToChild = None
lazy = None
N = -1
def load(self, l):
self.N = len(l)
self.lenOriginalList = self.N # original nodes
self.depthTreeList = (self.N - 1).bit_length() # Level of Tree
self.lenTreeLeaf = 2 ** self.depthTreeList # leaf of node, len 5 -> 2^3 = 8
self.dat = [self.initValue] * (self.lenTreeLeaf * 2)
self.lazy = [self.initValue] * (self.lenTreeLeaf * 2) # lazy propagete buffer
# Load Function
for i in range(len(l)):
self.dat[self.lenTreeLeaf - 1 + i] = l[i]
self.build()
def build(self):
for i in range(self.lenTreeLeaf - 2, -1, -1):
self.dat[i] = self.func(self.dat[2 * i + 1], self.dat[2 * i + 2])
# print("build: node", i, "child is ", self.dat[2 * i + 1], self.dat[2 * i + 2] ,"then I am ", self.dat[i])
# just wrapper, get node value and op and put it
def addValue(self, ind, value):
nodeId = (self.lenTreeLeaf - 1) + ind
self.dat[nodeId] += value
self.setValue(ind, self.dat[nodeId])
# set value to node, recalc parents NODEs
def setValue(self, ind, value):
nodeId = (self.lenTreeLeaf - 1) + ind
self.dat[nodeId] = value
while nodeId != 0:
nodeId = (nodeId - 1) // 2
self.dat[nodeId] = self.func(self.dat[nodeId * 2 + 1], self.dat[nodeId * 2 + 2])
def nodelistFromLR(self, l, r, withchild=False):
L = (l + self.lenTreeLeaf) >> 1
R = (r + self.lenTreeLeaf) >> 1
lc = 0 if l & 1 else (L & -L).bit_length()
rc = 0 if r & 1 else (R & -R).bit_length()
res = []
for i in range(self.depthTreeList + (1 if withchild else 0)):
if rc <= i:
res.append(R - 1)
if L < R and lc <= i:
res.append(L - 1)
L = L >> 1
R = R >> 1
return res
def rangeAdd(self, l, r, x):
plist = self.nodelistFromLR(l, r)
self.propagete(plist)
L = self.lenTreeLeaf + l
R = self.lenTreeLeaf + r
# print(">>before", self.lazy, L, R)
value = x
while L < R:
if R & 1:
R -= 1
# print(">>> updateR", R-1, value)
self.lazy[R - 1] = self.func(self.lazy[R - 1], value)
self.dat[R - 1] = self.func(self.dat[R - 1], value)
if L & 1:
# print(">>> updateL", L-1, value)
self.lazy[L - 1] = self.func(self.lazy[L - 1], value)
self.dat[L - 1] = self.func(self.dat[L - 1], value)
L += 1
L = L >> 1
R = R >> 1
value = self.funcRangePropagetToParent(value)
# print(">>>END cur", L, R)
# print(">>after", self.lazy)
for node in plist:
self.dat[node] = self.func(self.dat[2 * node + 1], self.dat[2 * node + 2])
def propagete(self, plist):
for nodeId in plist[::-1]:
" this function will be call from top to down"
# print("propagete", nodeId, "curlazyval =", self.lazy[nodeId])
if self.lazy[nodeId] == self.initValue:
continue
if nodeId < (self.lenTreeLeaf - 1): # if this node has childs
propageteValue = self.funcPropagateToChild(self.lazy[nodeId])
# print(" > propagate to node")
self.lazy[2 * nodeId + 1] = self.func(self.lazy[2 * nodeId + 1], propageteValue)
self.lazy[2 * nodeId + 2] = self.func(self.lazy[2 * nodeId + 2], propageteValue)
self.dat[2 * nodeId + 1] = self.func(self.dat[2 * nodeId + 1], propageteValue)
self.dat[2 * nodeId + 2] = self.func(self.dat[2 * nodeId + 2], propageteValue)
else:
# print(" > do nothing")
pass
# Feedback to myself value
# self.dat[nodeId] = self.func(self.dat[nodeId], self.lazy[nodeId])
self.lazy[nodeId] = self.initValue
def query(self, l, r):
# print("query()", l, r)
plist = self.nodelistFromLR(l, r)
self.propagete(plist)
L = self.lenTreeLeaf + l
R = self.lenTreeLeaf + r
view = []
res = self.initValue
while L < R:
if R & 1:
R -= 1
# print(">>>checkR", R-1, "value", self.dat[R-1])
res = self.func(res, self.dat[R - 1])
if L & 1:
# print(">>>checkL", L-1, "value", self.dat[L-1])
res = self.func(res, self.dat[L - 1])
L += 1
L = L >> 1
R = R >> 1
return res
def findNthValueSub(self, x, nodeId):
"""
[2, 3, 5, 7] = [0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0]
とマッピングされているセグメント木においてx番目に小さい値を得るための関数
"""
if self.dat[nodeId] < x: # このノードが要求されているよりも小さい値しか持たないとき
return (None, x - self.dat[nodeId])
if nodeId >= self.lenTreeLeaf - 1: # nodeIfがノードのときは
return (True, nodeId - (self.lenTreeLeaf - 1)) # そのindex番号を返す
resLeft = self.findNthValueSub(x, 2 * nodeId + 1) # 左側の探索を行う
if resLeft[0] != None: # もし、値が入っているならそれを返す
return (True, resLeft[1])
resRight = self.findNthValueSub(resLeft[1], 2 * nodeId + 2) # 右側の探索を行う
return resRight
def findNthValue(self, x):
return self.findNthValueSub(x, 0)[1]
class segmentTreeSum(segmentTree):
def __init__(self):
self.func = lambda x, y: x + y
self.funcPropagateToChild = lambda parentValue: parentValue >> 1
self.funcRangePropagetToParent = lambda currentValue: currentValue << 1
self.initValue = 0
class segmentTreeMin(segmentTree):
def __init__(self):
self.func = lambda x, y: min(x, y)
self.funcPropagateToChild = lambda parentValue: parentValue
self.funcRangePropagetToParent = lambda currentValue: currentValue
self.initValue = 2 * 10 ** 9
import sys
import sys
#input = sys.stdin.readline
def do():
st = segmentTreeSum()
n, t = map(int, input().split())
dat = list(map(int, input().split()))
dattotal = []
total = 0
segtreeList = [0] * (200000 + 10)
zatsu = set()
for x in dat:
total += x
dattotal.append(total)
zatsu.add(total)
zatsu = list(zatsu)
zatsu.sort()
zatsuTable = dict()
zatsuTableRev = dict()
for ind, val in enumerate(zatsu):
zatsuTable[val] = ind
zatsuTableRev[ind] = val
buf = []
for x in dattotal:
buf.append(zatsuTable[x])
segtreeList[zatsuTable[x]] += 1
st.load(segtreeList)
#print(segtreeList[:10])
from bisect import bisect_left, bisect_right
offset = 0
res = 0
#print(zatsu)
for i in range(n): # x = total from 0 to curren
#print("---------, i")
x = dattotal[i]
curvalind = zatsuTable[x]
targetval = t + offset# target val
targetind = bisect_left(zatsu, targetval)
cnt = st.query(0, targetind )
#print(i, "offset", offset, "query",curvalind, targetind+1)
#print(segtreeList[:10])
#print(x, "target=", targetval, "targetind", targetind, "cnt = ", cnt)
res += cnt
#print("cur", st.query(curvalind, curvalind+1), curvalind)
st.addValue(curvalind, -1)
#print("cur", st.query(curvalind, curvalind+1))
offset += dat[i] # for next offset
print(res)
do()
``` | instruction | 0 | 96,086 | 12 | 192,172 |
Yes | output | 1 | 96,086 | 12 | 192,173 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya has an array a consisting of n integers. He has learned partial sums recently, and now he can calculate the sum of elements on any segment of the array really fast. The segment is a non-empty sequence of elements standing one next to another in the array.
Now he wonders what is the number of segments in his array with the sum less than t. Help Petya to calculate this number.
More formally, you are required to calculate the number of pairs l, r (l ≤ r) such that a_l + a_{l+1} + ... + a_{r-1} + a_r < t.
Input
The first line contains two integers n and t (1 ≤ n ≤ 200 000, |t| ≤ 2⋅10^{14}).
The second line contains a sequence of integers a_1, a_2, ..., a_n (|a_{i}| ≤ 10^{9}) — the description of Petya's array. Note that there might be negative, zero and positive elements.
Output
Print the number of segments in Petya's array with the sum of elements less than t.
Examples
Input
5 4
5 -1 3 4 -1
Output
5
Input
3 0
-1 2 -3
Output
4
Input
4 -1
-2 1 -2 3
Output
3
Note
In the first example the following segments have sum less than 4:
* [2, 2], sum of elements is -1
* [2, 3], sum of elements is 2
* [3, 3], sum of elements is 3
* [4, 5], sum of elements is 3
* [5, 5], sum of elements is -1
Submitted Solution:
```
from itertools import accumulate, chain
class Fenwick:
def __init__(self, n):
self.tree = [0] * (n + 1)
def update(self, i, val):
i += 1
while i < len(self.tree):
self.tree[i] += 1
i += (i & -i)
def get(self, i):
i += 1
total = 0
while i > 0:
total += self.tree[i]
i -= (i & -i)
return total
def solution(n, a, t):
S = [s for s in accumulate(a)]
T = [[s, s - t] for s in S]
T = list(set(chain(*T)))
T.sort()
T = {v: i for i, v in enumerate(T)}
fenwick = Fenwick(len(T))
total = 0
for i, v in enumerate(S):
diff = v - t
total += i - fenwick.get(T[diff])
if v < t:
total += 1
fenwick.update(T[v], 1)
return total
f = lambda: [int(c) for c in input().split()]
n, t = f()
a = f()
print(solution(n, a, t))
``` | instruction | 0 | 96,087 | 12 | 192,174 |
Yes | output | 1 | 96,087 | 12 | 192,175 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya has an array a consisting of n integers. He has learned partial sums recently, and now he can calculate the sum of elements on any segment of the array really fast. The segment is a non-empty sequence of elements standing one next to another in the array.
Now he wonders what is the number of segments in his array with the sum less than t. Help Petya to calculate this number.
More formally, you are required to calculate the number of pairs l, r (l ≤ r) such that a_l + a_{l+1} + ... + a_{r-1} + a_r < t.
Input
The first line contains two integers n and t (1 ≤ n ≤ 200 000, |t| ≤ 2⋅10^{14}).
The second line contains a sequence of integers a_1, a_2, ..., a_n (|a_{i}| ≤ 10^{9}) — the description of Petya's array. Note that there might be negative, zero and positive elements.
Output
Print the number of segments in Petya's array with the sum of elements less than t.
Examples
Input
5 4
5 -1 3 4 -1
Output
5
Input
3 0
-1 2 -3
Output
4
Input
4 -1
-2 1 -2 3
Output
3
Note
In the first example the following segments have sum less than 4:
* [2, 2], sum of elements is -1
* [2, 3], sum of elements is 2
* [3, 3], sum of elements is 3
* [4, 5], sum of elements is 3
* [5, 5], sum of elements is -1
Submitted Solution:
```
n,t=map(int,input().split())
a=list(map(int,input().split()))
bit=[0 for i in range(n+2)]
def qq(i):
ans=0
i=i+1
while i>0:
ans+=bit[i]
i-=i&-i
return(ans)
def u(i):
i+=1
while i<=n+1:
bit[i]+=1
i+=i&-i
q=[]
c=[0]
for i in range(n):
c.append(c[-1]+a[i])
q.append((i+1,t+c[i]))
c=[(c[i],i) for i in range(n+1)]
c.sort()
q.sort(key=lambda x:x[1])
ans=0
i=0
j=0
while j<len(q):
l,x=q[j]
while i<=n and c[i][0]<x:
u(c[i][1])
i+=1
ans+=qq(n)-qq(l-1)
j+=1
print(ans)
``` | instruction | 0 | 96,088 | 12 | 192,176 |
Yes | output | 1 | 96,088 | 12 | 192,177 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya has an array a consisting of n integers. He has learned partial sums recently, and now he can calculate the sum of elements on any segment of the array really fast. The segment is a non-empty sequence of elements standing one next to another in the array.
Now he wonders what is the number of segments in his array with the sum less than t. Help Petya to calculate this number.
More formally, you are required to calculate the number of pairs l, r (l ≤ r) such that a_l + a_{l+1} + ... + a_{r-1} + a_r < t.
Input
The first line contains two integers n and t (1 ≤ n ≤ 200 000, |t| ≤ 2⋅10^{14}).
The second line contains a sequence of integers a_1, a_2, ..., a_n (|a_{i}| ≤ 10^{9}) — the description of Petya's array. Note that there might be negative, zero and positive elements.
Output
Print the number of segments in Petya's array with the sum of elements less than t.
Examples
Input
5 4
5 -1 3 4 -1
Output
5
Input
3 0
-1 2 -3
Output
4
Input
4 -1
-2 1 -2 3
Output
3
Note
In the first example the following segments have sum less than 4:
* [2, 2], sum of elements is -1
* [2, 3], sum of elements is 2
* [3, 3], sum of elements is 3
* [4, 5], sum of elements is 3
* [5, 5], sum of elements is -1
Submitted Solution:
```
n,t=list(map(int,input().split()))
b=list(map(int,input().split()))
def segementsum(a):return a[0] if len(a)==1 else 0 if len(a)==0 else segementsum(a[:int(len(a)/2)])+segementsum(a[int(len(a)/2):])
sol=0
sum=[segementsum(b[:i]) for i in range(len(b)+1)]
sum=sum[1:]
#print(sum)
for i in range(len(b)):
for j in range(i+1,len(b)):
#print(sum[j]-sum[i],i,j)
if sum[j]-sum[i]<t:sol+=1
print(sol)
``` | instruction | 0 | 96,089 | 12 | 192,178 |
No | output | 1 | 96,089 | 12 | 192,179 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya has an array a consisting of n integers. He has learned partial sums recently, and now he can calculate the sum of elements on any segment of the array really fast. The segment is a non-empty sequence of elements standing one next to another in the array.
Now he wonders what is the number of segments in his array with the sum less than t. Help Petya to calculate this number.
More formally, you are required to calculate the number of pairs l, r (l ≤ r) such that a_l + a_{l+1} + ... + a_{r-1} + a_r < t.
Input
The first line contains two integers n and t (1 ≤ n ≤ 200 000, |t| ≤ 2⋅10^{14}).
The second line contains a sequence of integers a_1, a_2, ..., a_n (|a_{i}| ≤ 10^{9}) — the description of Petya's array. Note that there might be negative, zero and positive elements.
Output
Print the number of segments in Petya's array with the sum of elements less than t.
Examples
Input
5 4
5 -1 3 4 -1
Output
5
Input
3 0
-1 2 -3
Output
4
Input
4 -1
-2 1 -2 3
Output
3
Note
In the first example the following segments have sum less than 4:
* [2, 2], sum of elements is -1
* [2, 3], sum of elements is 2
* [3, 3], sum of elements is 3
* [4, 5], sum of elements is 3
* [5, 5], sum of elements is -1
Submitted Solution:
```
#code force
#divide and conquer
#Petya and Array
get_nums_seq = input().split(" ") # get the number in the seq , the upper bound and the seq ----a lst
def p_sum(nums_seq):
"""
Input : a list
nums --- number of items
ub ---upper bound
seq --- the sequence
Output: an int
return the number of valid partial sums
"""
nums = int(nums_seq[0]) #arrange info from the input
ub = int(nums_seq[1])
seq = []
for num in nums_seq[2:]: # turn all numbers in sequence into int
seq.append(int(num))
def add_recur(seq): #for adding partial sums
"""
input: a sequence
output: sum of the sequence
"""
seq_l = len(seq)
if seq_l == 1:
return seq[0]
else:
return seq[seq_l-1] + add_recur(seq[0:seq_l-1])
count = 0
for i in range(len(seq)):
if i == len(seq)-1:
if seq[-1] < ub:
count += 1
break
for ii in range(i+1,len(seq)+1):
part_sum = add_recur(seq[i:ii])
if part_sum < ub:
count += 1
return count
p_sum(get_nums_seq)
``` | instruction | 0 | 96,090 | 12 | 192,180 |
No | output | 1 | 96,090 | 12 | 192,181 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya has an array a consisting of n integers. He has learned partial sums recently, and now he can calculate the sum of elements on any segment of the array really fast. The segment is a non-empty sequence of elements standing one next to another in the array.
Now he wonders what is the number of segments in his array with the sum less than t. Help Petya to calculate this number.
More formally, you are required to calculate the number of pairs l, r (l ≤ r) such that a_l + a_{l+1} + ... + a_{r-1} + a_r < t.
Input
The first line contains two integers n and t (1 ≤ n ≤ 200 000, |t| ≤ 2⋅10^{14}).
The second line contains a sequence of integers a_1, a_2, ..., a_n (|a_{i}| ≤ 10^{9}) — the description of Petya's array. Note that there might be negative, zero and positive elements.
Output
Print the number of segments in Petya's array with the sum of elements less than t.
Examples
Input
5 4
5 -1 3 4 -1
Output
5
Input
3 0
-1 2 -3
Output
4
Input
4 -1
-2 1 -2 3
Output
3
Note
In the first example the following segments have sum less than 4:
* [2, 2], sum of elements is -1
* [2, 3], sum of elements is 2
* [3, 3], sum of elements is 3
* [4, 5], sum of elements is 3
* [5, 5], sum of elements is -1
Submitted Solution:
```
n,t=list(map(int,input().split()))
b=list(map(int,input().split()))
def segementsum(a):return a[0] if len(a)==1 else 0 if len(a)==0 else segementsum(a[:int(len(a)/2)])+segementsum(a[int(len(a)/2):])
sol=0
sum=[segementsum(b[0:i]) for i in range(len(b)+1)]
for i in range(len(b)):
for j in range(i+1,len(b)):
if sum[j]-sum[i]<t:sol+=1
print(sol)
``` | instruction | 0 | 96,091 | 12 | 192,182 |
No | output | 1 | 96,091 | 12 | 192,183 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya has an array a consisting of n integers. He has learned partial sums recently, and now he can calculate the sum of elements on any segment of the array really fast. The segment is a non-empty sequence of elements standing one next to another in the array.
Now he wonders what is the number of segments in his array with the sum less than t. Help Petya to calculate this number.
More formally, you are required to calculate the number of pairs l, r (l ≤ r) such that a_l + a_{l+1} + ... + a_{r-1} + a_r < t.
Input
The first line contains two integers n and t (1 ≤ n ≤ 200 000, |t| ≤ 2⋅10^{14}).
The second line contains a sequence of integers a_1, a_2, ..., a_n (|a_{i}| ≤ 10^{9}) — the description of Petya's array. Note that there might be negative, zero and positive elements.
Output
Print the number of segments in Petya's array with the sum of elements less than t.
Examples
Input
5 4
5 -1 3 4 -1
Output
5
Input
3 0
-1 2 -3
Output
4
Input
4 -1
-2 1 -2 3
Output
3
Note
In the first example the following segments have sum less than 4:
* [2, 2], sum of elements is -1
* [2, 3], sum of elements is 2
* [3, 3], sum of elements is 3
* [4, 5], sum of elements is 3
* [5, 5], sum of elements is -1
Submitted Solution:
```
import bisect
class BIT:
def __init__(self, node_size):
self._node = node_size+1
self.bit = [0]*self._node
def add(self, index, add_val):
while index < self._node:
self.bit[index] += add_val
index += index & -index
def sum(self, index):
res = 0
while index > 0:
res += self.bit[index]
index -= index & -index
return res
n,t = map(int,input().split())
a = list(map(int,input().split()))
ru = [0] * (n+1)
ans = 0
for i in range(1,n+1):
ru[i] = ru[i-1]+ a[i-1]
rus = sorted(ru)
bit = BIT(n+2)
for i in range(n+1):
ru[i] = bisect.bisect_left(rus,ru[i])
for i in range(n+1):
ind = bisect.bisect_left(rus,rus[ru[i]]-t+1)
indi = bisect.bisect_left(rus,abs(rus[ru[i]])+abs(t))
ans += abs(bit.sum(indi)-bit.sum(ind))
bit.add(ru[i]+1,1)
print(ans)
``` | instruction | 0 | 96,092 | 12 | 192,184 |
No | output | 1 | 96,092 | 12 | 192,185 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. Each a_i is one of the six following numbers: 4, 8, 15, 16, 23, 42.
Your task is to remove the minimum number of elements to make this array good.
An array of length k is called good if k is divisible by 6 and it is possible to split it into k/6 subsequences 4, 8, 15, 16, 23, 42.
Examples of good arrays:
* [4, 8, 15, 16, 23, 42] (the whole array is a required sequence);
* [4, 8, 4, 15, 16, 8, 23, 15, 16, 42, 23, 42] (the first sequence is formed from first, second, fourth, fifth, seventh and tenth elements and the second one is formed from remaining elements);
* [] (the empty array is good).
Examples of bad arrays:
* [4, 8, 15, 16, 42, 23] (the order of elements should be exactly 4, 8, 15, 16, 23, 42);
* [4, 8, 15, 16, 23, 42, 4] (the length of the array is not divisible by 6);
* [4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 23] (the first sequence can be formed from first six elements but the remaining array cannot form the required sequence).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (each a_i is one of the following numbers: 4, 8, 15, 16, 23, 42), where a_i is the i-th element of a.
Output
Print one integer — the minimum number of elements you have to remove to obtain a good array.
Examples
Input
5
4 8 15 16 23
Output
5
Input
12
4 8 4 15 16 8 23 15 16 42 23 42
Output
0
Input
15
4 8 4 8 15 16 8 16 23 15 16 4 42 23 42
Output
3 | instruction | 0 | 96,173 | 12 | 192,346 |
Tags: dp, greedy, implementation
Correct Solution:
```
N=int(input())
l=list(map(int,input().split()))
d=dict()
d[4]=0
d[8]=0
d[15]=0
d[16]=0
d[23]=0
d[42]=0
l1=[4,8,15,16,23,42]
for i in range(N):
if l[i]==4:
d[4]+=1
else:
if l[i]==8:
if d[4]>d[8]:
d[8]+=1
elif l[i]==15:
if d[8]>d[15]:
d[15]+=1
elif l[i]==16:
if d[15]>d[16]:
d[16]+=1
elif l[i]==23:
if d[16]>d[23]:
d[23]+=1
elif l[i]==42:
if d[23]>d[42]:
d[42]+=1
print(N-d[42]*6)
``` | output | 1 | 96,173 | 12 | 192,347 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. Each a_i is one of the six following numbers: 4, 8, 15, 16, 23, 42.
Your task is to remove the minimum number of elements to make this array good.
An array of length k is called good if k is divisible by 6 and it is possible to split it into k/6 subsequences 4, 8, 15, 16, 23, 42.
Examples of good arrays:
* [4, 8, 15, 16, 23, 42] (the whole array is a required sequence);
* [4, 8, 4, 15, 16, 8, 23, 15, 16, 42, 23, 42] (the first sequence is formed from first, second, fourth, fifth, seventh and tenth elements and the second one is formed from remaining elements);
* [] (the empty array is good).
Examples of bad arrays:
* [4, 8, 15, 16, 42, 23] (the order of elements should be exactly 4, 8, 15, 16, 23, 42);
* [4, 8, 15, 16, 23, 42, 4] (the length of the array is not divisible by 6);
* [4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 23] (the first sequence can be formed from first six elements but the remaining array cannot form the required sequence).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (each a_i is one of the following numbers: 4, 8, 15, 16, 23, 42), where a_i is the i-th element of a.
Output
Print one integer — the minimum number of elements you have to remove to obtain a good array.
Examples
Input
5
4 8 15 16 23
Output
5
Input
12
4 8 4 15 16 8 23 15 16 42 23 42
Output
0
Input
15
4 8 4 8 15 16 8 16 23 15 16 4 42 23 42
Output
3 | instruction | 0 | 96,174 | 12 | 192,348 |
Tags: dp, greedy, implementation
Correct Solution:
```
import sys
input = sys.stdin.readline
def main():
n = int(input())
a = list(map(int, input().split()))
x = {4: 0, 8: 1, 15: 2, 16: 3, 23: 4, 42: 5}
val = [4, 8, 15, 16, 23, 42]
ptr = [-1, -1, -1, -1, -1, -1]
done = False
sets = 0
while not done:
for p in range(6):
if p == 0:
while ptr[p] < n and (ptr[p] == -1 or a[ptr[p]] != val[p]):
ptr[p] += 1
else:
while ptr[p] < n and (ptr[p] == -1 or a[ptr[p]] != val[p] or ptr[p] <= ptr[p-1]):
ptr[p] += 1
if all(ptr[i] < n for i in range(6)):
sets += 1
for i in range(6):
ptr[i] += 1
else:
done = True
print(n-6*sets)
if __name__ == '__main__':
main()
``` | output | 1 | 96,174 | 12 | 192,349 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. Each a_i is one of the six following numbers: 4, 8, 15, 16, 23, 42.
Your task is to remove the minimum number of elements to make this array good.
An array of length k is called good if k is divisible by 6 and it is possible to split it into k/6 subsequences 4, 8, 15, 16, 23, 42.
Examples of good arrays:
* [4, 8, 15, 16, 23, 42] (the whole array is a required sequence);
* [4, 8, 4, 15, 16, 8, 23, 15, 16, 42, 23, 42] (the first sequence is formed from first, second, fourth, fifth, seventh and tenth elements and the second one is formed from remaining elements);
* [] (the empty array is good).
Examples of bad arrays:
* [4, 8, 15, 16, 42, 23] (the order of elements should be exactly 4, 8, 15, 16, 23, 42);
* [4, 8, 15, 16, 23, 42, 4] (the length of the array is not divisible by 6);
* [4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 23] (the first sequence can be formed from first six elements but the remaining array cannot form the required sequence).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (each a_i is one of the following numbers: 4, 8, 15, 16, 23, 42), where a_i is the i-th element of a.
Output
Print one integer — the minimum number of elements you have to remove to obtain a good array.
Examples
Input
5
4 8 15 16 23
Output
5
Input
12
4 8 4 15 16 8 23 15 16 42 23 42
Output
0
Input
15
4 8 4 8 15 16 8 16 23 15 16 4 42 23 42
Output
3 | instruction | 0 | 96,175 | 12 | 192,350 |
Tags: dp, greedy, implementation
Correct Solution:
```
'''input
15
4 8 4 8 15 16 8 16 23 15 16 4 42 23 42
'''
from sys import stdin,stdout
read = lambda : map(int,stdin.readline().split())
I = lambda: stdin.readline()
alias = {'4':0,'8':1,'15':2,'16':3,'23':4,'42':5}
n = int(I())
counts = [0 for i in range(6)]
for i in map(lambda x:alias[x],stdin.readline().split()):
if i==0:
counts[0]+=1
elif i>0 and counts[i]<counts[i-1]:
counts[i]+=1
# print(arr,counts)
print(n-counts[-1]*6)
``` | output | 1 | 96,175 | 12 | 192,351 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. Each a_i is one of the six following numbers: 4, 8, 15, 16, 23, 42.
Your task is to remove the minimum number of elements to make this array good.
An array of length k is called good if k is divisible by 6 and it is possible to split it into k/6 subsequences 4, 8, 15, 16, 23, 42.
Examples of good arrays:
* [4, 8, 15, 16, 23, 42] (the whole array is a required sequence);
* [4, 8, 4, 15, 16, 8, 23, 15, 16, 42, 23, 42] (the first sequence is formed from first, second, fourth, fifth, seventh and tenth elements and the second one is formed from remaining elements);
* [] (the empty array is good).
Examples of bad arrays:
* [4, 8, 15, 16, 42, 23] (the order of elements should be exactly 4, 8, 15, 16, 23, 42);
* [4, 8, 15, 16, 23, 42, 4] (the length of the array is not divisible by 6);
* [4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 23] (the first sequence can be formed from first six elements but the remaining array cannot form the required sequence).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (each a_i is one of the following numbers: 4, 8, 15, 16, 23, 42), where a_i is the i-th element of a.
Output
Print one integer — the minimum number of elements you have to remove to obtain a good array.
Examples
Input
5
4 8 15 16 23
Output
5
Input
12
4 8 4 15 16 8 23 15 16 42 23 42
Output
0
Input
15
4 8 4 8 15 16 8 16 23 15 16 4 42 23 42
Output
3 | instruction | 0 | 96,176 | 12 | 192,352 |
Tags: dp, greedy, implementation
Correct Solution:
```
n=int(input())
l=list(map(int,input().split()))
ansl=[4,8,15,16,23,42]
c4=0
c8=0
c15=0
c16=0
c23=0
c42=0
j=0
ans=0
for i in range(n):
if l[i]==4:
c4+=1
elif l[i]==8:
if c8<c4:
c8+=1
elif l[i]==15:
if c15<c8:
c15+=1
elif l[i]==16:
if c16<c15:
c16+=1
elif l[i]==23:
if c23<c16:
c23+=1
elif l[i]==42:
if c42<c23:
c42+=1
ans=n-c42*6
print(ans)
``` | output | 1 | 96,176 | 12 | 192,353 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. Each a_i is one of the six following numbers: 4, 8, 15, 16, 23, 42.
Your task is to remove the minimum number of elements to make this array good.
An array of length k is called good if k is divisible by 6 and it is possible to split it into k/6 subsequences 4, 8, 15, 16, 23, 42.
Examples of good arrays:
* [4, 8, 15, 16, 23, 42] (the whole array is a required sequence);
* [4, 8, 4, 15, 16, 8, 23, 15, 16, 42, 23, 42] (the first sequence is formed from first, second, fourth, fifth, seventh and tenth elements and the second one is formed from remaining elements);
* [] (the empty array is good).
Examples of bad arrays:
* [4, 8, 15, 16, 42, 23] (the order of elements should be exactly 4, 8, 15, 16, 23, 42);
* [4, 8, 15, 16, 23, 42, 4] (the length of the array is not divisible by 6);
* [4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 23] (the first sequence can be formed from first six elements but the remaining array cannot form the required sequence).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (each a_i is one of the following numbers: 4, 8, 15, 16, 23, 42), where a_i is the i-th element of a.
Output
Print one integer — the minimum number of elements you have to remove to obtain a good array.
Examples
Input
5
4 8 15 16 23
Output
5
Input
12
4 8 4 15 16 8 23 15 16 42 23 42
Output
0
Input
15
4 8 4 8 15 16 8 16 23 15 16 4 42 23 42
Output
3 | instruction | 0 | 96,177 | 12 | 192,354 |
Tags: dp, greedy, implementation
Correct Solution:
```
# cf 1176 C 1300
n = int(input())
A = [*map(int, input().split())]
R = { 8: 4,
15: 8,
16: 15,
23: 16,
42: 23 } # set([4, 8, 15, 16, 23, 42])
P = { 4: [], 8: [], 15: [], 16: [], 23: [], 42: [] }
ans = 0
for i, a in enumerate(A):
if a == 4:
P[4].append(a)
elif a in R and R[a] in P:
prev = R[a]
if len(P[prev]) > 0:
P[prev].pop()
P[a].append(a)
else:
ans += 1
else:
ans += 1
for i, n in enumerate([4, 8, 15, 16, 23]):
if len(P[n]) > 0:
ans += (len(P[n]) * (i + 1))
print(ans)
``` | output | 1 | 96,177 | 12 | 192,355 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. Each a_i is one of the six following numbers: 4, 8, 15, 16, 23, 42.
Your task is to remove the minimum number of elements to make this array good.
An array of length k is called good if k is divisible by 6 and it is possible to split it into k/6 subsequences 4, 8, 15, 16, 23, 42.
Examples of good arrays:
* [4, 8, 15, 16, 23, 42] (the whole array is a required sequence);
* [4, 8, 4, 15, 16, 8, 23, 15, 16, 42, 23, 42] (the first sequence is formed from first, second, fourth, fifth, seventh and tenth elements and the second one is formed from remaining elements);
* [] (the empty array is good).
Examples of bad arrays:
* [4, 8, 15, 16, 42, 23] (the order of elements should be exactly 4, 8, 15, 16, 23, 42);
* [4, 8, 15, 16, 23, 42, 4] (the length of the array is not divisible by 6);
* [4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 23] (the first sequence can be formed from first six elements but the remaining array cannot form the required sequence).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (each a_i is one of the following numbers: 4, 8, 15, 16, 23, 42), where a_i is the i-th element of a.
Output
Print one integer — the minimum number of elements you have to remove to obtain a good array.
Examples
Input
5
4 8 15 16 23
Output
5
Input
12
4 8 4 15 16 8 23 15 16 42 23 42
Output
0
Input
15
4 8 4 8 15 16 8 16 23 15 16 4 42 23 42
Output
3 | instruction | 0 | 96,178 | 12 | 192,356 |
Tags: dp, greedy, implementation
Correct Solution:
```
def get(n, a):
state = [0] * 6
for ai in a:
if ai == 0:
state[0] += 1
continue
if state[ai - 1] > 0:
state[ai - 1] -= 1
state[ai] += 1
return n - 6 * state[5]
s2i = {'4': 0, '8': 1, '15': 2, '16': 3, '23': 4, '42': 5}
n = int(input())
a = [s2i[s] for s in input().split()]
print(get(n, a))
``` | output | 1 | 96,178 | 12 | 192,357 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. Each a_i is one of the six following numbers: 4, 8, 15, 16, 23, 42.
Your task is to remove the minimum number of elements to make this array good.
An array of length k is called good if k is divisible by 6 and it is possible to split it into k/6 subsequences 4, 8, 15, 16, 23, 42.
Examples of good arrays:
* [4, 8, 15, 16, 23, 42] (the whole array is a required sequence);
* [4, 8, 4, 15, 16, 8, 23, 15, 16, 42, 23, 42] (the first sequence is formed from first, second, fourth, fifth, seventh and tenth elements and the second one is formed from remaining elements);
* [] (the empty array is good).
Examples of bad arrays:
* [4, 8, 15, 16, 42, 23] (the order of elements should be exactly 4, 8, 15, 16, 23, 42);
* [4, 8, 15, 16, 23, 42, 4] (the length of the array is not divisible by 6);
* [4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 23] (the first sequence can be formed from first six elements but the remaining array cannot form the required sequence).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (each a_i is one of the following numbers: 4, 8, 15, 16, 23, 42), where a_i is the i-th element of a.
Output
Print one integer — the minimum number of elements you have to remove to obtain a good array.
Examples
Input
5
4 8 15 16 23
Output
5
Input
12
4 8 4 15 16 8 23 15 16 42 23 42
Output
0
Input
15
4 8 4 8 15 16 8 16 23 15 16 4 42 23 42
Output
3 | instruction | 0 | 96,179 | 12 | 192,358 |
Tags: dp, greedy, implementation
Correct Solution:
```
n=int(input())
arr=[x for x in input().split(' ')]
myMap={
"4":0,
"8":0,
"15":0,
"16":0,
"23":0,
"42":0
}
bad=0
def doit(a,b):
a,b=str(a),str(b)
if myMap[a]>myMap[b]:
myMap[b]+=1
else:
global bad
bad+=1
for item in arr:
if item=="4":
myMap[item]+=1
elif item=="8":
doit(4,8)
elif item=="15":
doit(8,15)
elif item=="16":
doit(15,16)
elif item=="23":
doit(16,23)
else:
doit(23,42)
temp=min(myMap.values())
bad = bad + (sum(myMap.values())-temp*6)
print(bad)
``` | output | 1 | 96,179 | 12 | 192,359 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers. Each a_i is one of the six following numbers: 4, 8, 15, 16, 23, 42.
Your task is to remove the minimum number of elements to make this array good.
An array of length k is called good if k is divisible by 6 and it is possible to split it into k/6 subsequences 4, 8, 15, 16, 23, 42.
Examples of good arrays:
* [4, 8, 15, 16, 23, 42] (the whole array is a required sequence);
* [4, 8, 4, 15, 16, 8, 23, 15, 16, 42, 23, 42] (the first sequence is formed from first, second, fourth, fifth, seventh and tenth elements and the second one is formed from remaining elements);
* [] (the empty array is good).
Examples of bad arrays:
* [4, 8, 15, 16, 42, 23] (the order of elements should be exactly 4, 8, 15, 16, 23, 42);
* [4, 8, 15, 16, 23, 42, 4] (the length of the array is not divisible by 6);
* [4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 23] (the first sequence can be formed from first six elements but the remaining array cannot form the required sequence).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (each a_i is one of the following numbers: 4, 8, 15, 16, 23, 42), where a_i is the i-th element of a.
Output
Print one integer — the minimum number of elements you have to remove to obtain a good array.
Examples
Input
5
4 8 15 16 23
Output
5
Input
12
4 8 4 15 16 8 23 15 16 42 23 42
Output
0
Input
15
4 8 4 8 15 16 8 16 23 15 16 4 42 23 42
Output
3 | instruction | 0 | 96,180 | 12 | 192,360 |
Tags: dp, greedy, implementation
Correct Solution:
```
q= int (input())
a=0
b=0
c=0
d=0
e=0
f=0
for j in map(int,input().split()):
if j==4 : a+=1
elif j==8 and b<a : b+=1
elif j==15 and c<b : c+=1
elif j==16 and d<c : d+=1
elif j==23 and e<d : e+=1
elif j==42 and f<e : f+=1
print(q-f*6)
``` | output | 1 | 96,180 | 12 | 192,361 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. Each a_i is one of the six following numbers: 4, 8, 15, 16, 23, 42.
Your task is to remove the minimum number of elements to make this array good.
An array of length k is called good if k is divisible by 6 and it is possible to split it into k/6 subsequences 4, 8, 15, 16, 23, 42.
Examples of good arrays:
* [4, 8, 15, 16, 23, 42] (the whole array is a required sequence);
* [4, 8, 4, 15, 16, 8, 23, 15, 16, 42, 23, 42] (the first sequence is formed from first, second, fourth, fifth, seventh and tenth elements and the second one is formed from remaining elements);
* [] (the empty array is good).
Examples of bad arrays:
* [4, 8, 15, 16, 42, 23] (the order of elements should be exactly 4, 8, 15, 16, 23, 42);
* [4, 8, 15, 16, 23, 42, 4] (the length of the array is not divisible by 6);
* [4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 23] (the first sequence can be formed from first six elements but the remaining array cannot form the required sequence).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (each a_i is one of the following numbers: 4, 8, 15, 16, 23, 42), where a_i is the i-th element of a.
Output
Print one integer — the minimum number of elements you have to remove to obtain a good array.
Examples
Input
5
4 8 15 16 23
Output
5
Input
12
4 8 4 15 16 8 23 15 16 42 23 42
Output
0
Input
15
4 8 4 8 15 16 8 16 23 15 16 4 42 23 42
Output
3
Submitted Solution:
```
n = int(input())
kol = [0, 0, 0, 0, 0, 0]
ind = [4, 8, 15, 16, 23, 42]
delete = 0
for i in map(int,input().split()):
for j in range(6):
if ind[j] == i:
cur = j
break
if cur == 0:
kol[0] += 1
else:
if kol[cur-1] != 0:
kol[cur-1] -= 1
kol[cur] += 1
else:
delete += 1
print(delete + kol[0] + kol[1]*2 + kol[2]*3 + kol[3]*4 + kol[4]*5)
``` | instruction | 0 | 96,181 | 12 | 192,362 |
Yes | output | 1 | 96,181 | 12 | 192,363 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. Each a_i is one of the six following numbers: 4, 8, 15, 16, 23, 42.
Your task is to remove the minimum number of elements to make this array good.
An array of length k is called good if k is divisible by 6 and it is possible to split it into k/6 subsequences 4, 8, 15, 16, 23, 42.
Examples of good arrays:
* [4, 8, 15, 16, 23, 42] (the whole array is a required sequence);
* [4, 8, 4, 15, 16, 8, 23, 15, 16, 42, 23, 42] (the first sequence is formed from first, second, fourth, fifth, seventh and tenth elements and the second one is formed from remaining elements);
* [] (the empty array is good).
Examples of bad arrays:
* [4, 8, 15, 16, 42, 23] (the order of elements should be exactly 4, 8, 15, 16, 23, 42);
* [4, 8, 15, 16, 23, 42, 4] (the length of the array is not divisible by 6);
* [4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 23] (the first sequence can be formed from first six elements but the remaining array cannot form the required sequence).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (each a_i is one of the following numbers: 4, 8, 15, 16, 23, 42), where a_i is the i-th element of a.
Output
Print one integer — the minimum number of elements you have to remove to obtain a good array.
Examples
Input
5
4 8 15 16 23
Output
5
Input
12
4 8 4 15 16 8 23 15 16 42 23 42
Output
0
Input
15
4 8 4 8 15 16 8 16 23 15 16 4 42 23 42
Output
3
Submitted Solution:
```
from bisect import bisect_left
N = int(input())
ls = list(map(int, input().split()))
d4 = []
d8 = []
d15 = []
d16 = []
d23 = []
d42 = []
for i in range(len(ls)):
if ls[i]==4: d4.append(i)
elif ls[i]==8: d8.append(i)
elif ls[i]==15: d15.append(i)
elif ls[i]==16: d16.append(i)
elif ls[i]==23: d23.append(i)
else: d42.append(i)
cnt = 0
j = 0; k = 0; l = 0; m = 0; n = 0
for i in d4:
pos = bisect_left(d8, i, lo=j)
if pos==len(d8): break
i = d8[pos]
j = pos+1
pos = bisect_left(d15, i, lo=k)
if pos==len(d15): break
i = d15[pos]
k = pos+1
pos = bisect_left(d16, i, lo=l)
if pos==len(d16): break
i = d16[pos]
l = pos+1
pos = bisect_left(d23, i, lo=m)
if pos==len(d23): break
i = d23[pos]
m = pos+1
pos = bisect_left(d42, i, lo=n)
if pos==len(d42): break
n = pos+1
cnt+=1
print(N-6*cnt)
``` | instruction | 0 | 96,182 | 12 | 192,364 |
Yes | output | 1 | 96,182 | 12 | 192,365 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. Each a_i is one of the six following numbers: 4, 8, 15, 16, 23, 42.
Your task is to remove the minimum number of elements to make this array good.
An array of length k is called good if k is divisible by 6 and it is possible to split it into k/6 subsequences 4, 8, 15, 16, 23, 42.
Examples of good arrays:
* [4, 8, 15, 16, 23, 42] (the whole array is a required sequence);
* [4, 8, 4, 15, 16, 8, 23, 15, 16, 42, 23, 42] (the first sequence is formed from first, second, fourth, fifth, seventh and tenth elements and the second one is formed from remaining elements);
* [] (the empty array is good).
Examples of bad arrays:
* [4, 8, 15, 16, 42, 23] (the order of elements should be exactly 4, 8, 15, 16, 23, 42);
* [4, 8, 15, 16, 23, 42, 4] (the length of the array is not divisible by 6);
* [4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 23] (the first sequence can be formed from first six elements but the remaining array cannot form the required sequence).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (each a_i is one of the following numbers: 4, 8, 15, 16, 23, 42), where a_i is the i-th element of a.
Output
Print one integer — the minimum number of elements you have to remove to obtain a good array.
Examples
Input
5
4 8 15 16 23
Output
5
Input
12
4 8 4 15 16 8 23 15 16 42 23 42
Output
0
Input
15
4 8 4 8 15 16 8 16 23 15 16 4 42 23 42
Output
3
Submitted Solution:
```
n=int(input())
s=input()
s1=s.split()
l=[int(i) for i in s1]
d={4:1,8:2,15:3,16:4,23:5,42:6}
dp=[1e8,0,0,0,0,0,0]
for i in range(len(l)):
if l[i] in d and dp[d[l[i]]]<dp[d[l[i]]-1]:
dp[d[l[i]]]=dp[d[l[i]]]+1
print(len(l)-dp[6]*6)
``` | instruction | 0 | 96,183 | 12 | 192,366 |
Yes | output | 1 | 96,183 | 12 | 192,367 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. Each a_i is one of the six following numbers: 4, 8, 15, 16, 23, 42.
Your task is to remove the minimum number of elements to make this array good.
An array of length k is called good if k is divisible by 6 and it is possible to split it into k/6 subsequences 4, 8, 15, 16, 23, 42.
Examples of good arrays:
* [4, 8, 15, 16, 23, 42] (the whole array is a required sequence);
* [4, 8, 4, 15, 16, 8, 23, 15, 16, 42, 23, 42] (the first sequence is formed from first, second, fourth, fifth, seventh and tenth elements and the second one is formed from remaining elements);
* [] (the empty array is good).
Examples of bad arrays:
* [4, 8, 15, 16, 42, 23] (the order of elements should be exactly 4, 8, 15, 16, 23, 42);
* [4, 8, 15, 16, 23, 42, 4] (the length of the array is not divisible by 6);
* [4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 23] (the first sequence can be formed from first six elements but the remaining array cannot form the required sequence).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (each a_i is one of the following numbers: 4, 8, 15, 16, 23, 42), where a_i is the i-th element of a.
Output
Print one integer — the minimum number of elements you have to remove to obtain a good array.
Examples
Input
5
4 8 15 16 23
Output
5
Input
12
4 8 4 15 16 8 23 15 16 42 23 42
Output
0
Input
15
4 8 4 8 15 16 8 16 23 15 16 4 42 23 42
Output
3
Submitted Solution:
```
n = int(input())
s= list(map(int,input().split()))
count = [0]*6
for temp in s:
if temp==4:
count[0]+=1
elif temp==8 and count[0]>count[1]:
count[1]+=1
elif temp==15 and count[1]>count[2]:
count[2]+=1
elif temp==16 and count[2]>count[3]:
count[3]+=1
elif temp==23 and count[3]>count[4]:
count[4]+=1
elif temp==42 and count[4]>count[5]:
count[5]+=1
else:
pass
#print(count)
out = n - 6*min(count)
print(out)
``` | instruction | 0 | 96,184 | 12 | 192,368 |
Yes | output | 1 | 96,184 | 12 | 192,369 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. Each a_i is one of the six following numbers: 4, 8, 15, 16, 23, 42.
Your task is to remove the minimum number of elements to make this array good.
An array of length k is called good if k is divisible by 6 and it is possible to split it into k/6 subsequences 4, 8, 15, 16, 23, 42.
Examples of good arrays:
* [4, 8, 15, 16, 23, 42] (the whole array is a required sequence);
* [4, 8, 4, 15, 16, 8, 23, 15, 16, 42, 23, 42] (the first sequence is formed from first, second, fourth, fifth, seventh and tenth elements and the second one is formed from remaining elements);
* [] (the empty array is good).
Examples of bad arrays:
* [4, 8, 15, 16, 42, 23] (the order of elements should be exactly 4, 8, 15, 16, 23, 42);
* [4, 8, 15, 16, 23, 42, 4] (the length of the array is not divisible by 6);
* [4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 23] (the first sequence can be formed from first six elements but the remaining array cannot form the required sequence).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (each a_i is one of the following numbers: 4, 8, 15, 16, 23, 42), where a_i is the i-th element of a.
Output
Print one integer — the minimum number of elements you have to remove to obtain a good array.
Examples
Input
5
4 8 15 16 23
Output
5
Input
12
4 8 4 15 16 8 23 15 16 42 23 42
Output
0
Input
15
4 8 4 8 15 16 8 16 23 15 16 4 42 23 42
Output
3
Submitted Solution:
```
from sys import stdin
from bisect import bisect_right
inp = lambda : stdin.readline().strip()
n = int(inp())
a =[int(x) for x in inp().split()]
v = {8:4,15:8,16:15,23:16,42:23}
d = {4:0,8:0,15:0,16:0,23:0,42:0}
for i in a:
if i == 4 or d[v[i]] > 0:
d[i] += 1
minimum = 10**9
for i in d.values():
minimum = min(i,minimum)
print(len(a)-minimum*6)
``` | instruction | 0 | 96,185 | 12 | 192,370 |
No | output | 1 | 96,185 | 12 | 192,371 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. Each a_i is one of the six following numbers: 4, 8, 15, 16, 23, 42.
Your task is to remove the minimum number of elements to make this array good.
An array of length k is called good if k is divisible by 6 and it is possible to split it into k/6 subsequences 4, 8, 15, 16, 23, 42.
Examples of good arrays:
* [4, 8, 15, 16, 23, 42] (the whole array is a required sequence);
* [4, 8, 4, 15, 16, 8, 23, 15, 16, 42, 23, 42] (the first sequence is formed from first, second, fourth, fifth, seventh and tenth elements and the second one is formed from remaining elements);
* [] (the empty array is good).
Examples of bad arrays:
* [4, 8, 15, 16, 42, 23] (the order of elements should be exactly 4, 8, 15, 16, 23, 42);
* [4, 8, 15, 16, 23, 42, 4] (the length of the array is not divisible by 6);
* [4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 23] (the first sequence can be formed from first six elements but the remaining array cannot form the required sequence).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (each a_i is one of the following numbers: 4, 8, 15, 16, 23, 42), where a_i is the i-th element of a.
Output
Print one integer — the minimum number of elements you have to remove to obtain a good array.
Examples
Input
5
4 8 15 16 23
Output
5
Input
12
4 8 4 15 16 8 23 15 16 42 23 42
Output
0
Input
15
4 8 4 8 15 16 8 16 23 15 16 4 42 23 42
Output
3
Submitted Solution:
```
# Aaditya Upadhyay
# ..............
# ╭━┳━╭━╭━╮╮
# ┃┈┈┈┣▅╋▅┫┃
# ┃┈┃┈╰━╰━━━━━━╮
# ╰┳╯┈┈┈┈┈┈┈┈┈◢▉◣
# ╲┃┈┈┈┈┈┈┈┈┈┈▉▉▉
# ╲┃┈┈┈┈┈┈┈┈┈┈◥▉◤
# ╲┃┈┈┈┈╭━┳━━━━╯
# ╲┣━━━━━━┫
# ……….
# .……. /´¯/)………….(\¯`\
# …………/….//……….. …\….\
# ………/….//……………....\….\
# …./´¯/…./´¯\……/¯ `\…..\¯`\
# ././…/…/…./|_…|.\….\….\…\.\
# (.(….(….(…./.)..)...(.\.).).)
# .\…………….\/../…....\….\/…………/
# ..\…………….. /……...\………………../
# …..\…………… (………....)……………./
from sys import stdin,stdout
from collections import *
from math import gcd,floor,ceil
st=lambda:list(stdin.readline().strip())
li=lambda:list(map(int,stdin.readline().split()))
mp=lambda:map(int,stdin.readline().split())
inp=lambda:int(stdin.readline())
pr=lambda n: stdout.write(str(n)+"\n")
mod=1000000007
INF=float('inf')
def solve():
n=inp()
count=0
l=li()
d={4:0 , 8:0 , 15:0 , 16:0, 23:0 , 42:0}
for i in range(n-1,-1,-1):
d[l[i]]+=1
if l[i]==4:
f=0
for j in [8,15,16,23,42]:
if d[j]<=0:
f=1
break
if f==0:
count+=1
for j in [8,15,16,23,42,4]:
d[j]-=1
print(n - count*6)
for _ in range(1):
solve()
``` | instruction | 0 | 96,186 | 12 | 192,372 |
No | output | 1 | 96,186 | 12 | 192,373 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. Each a_i is one of the six following numbers: 4, 8, 15, 16, 23, 42.
Your task is to remove the minimum number of elements to make this array good.
An array of length k is called good if k is divisible by 6 and it is possible to split it into k/6 subsequences 4, 8, 15, 16, 23, 42.
Examples of good arrays:
* [4, 8, 15, 16, 23, 42] (the whole array is a required sequence);
* [4, 8, 4, 15, 16, 8, 23, 15, 16, 42, 23, 42] (the first sequence is formed from first, second, fourth, fifth, seventh and tenth elements and the second one is formed from remaining elements);
* [] (the empty array is good).
Examples of bad arrays:
* [4, 8, 15, 16, 42, 23] (the order of elements should be exactly 4, 8, 15, 16, 23, 42);
* [4, 8, 15, 16, 23, 42, 4] (the length of the array is not divisible by 6);
* [4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 23] (the first sequence can be formed from first six elements but the remaining array cannot form the required sequence).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (each a_i is one of the following numbers: 4, 8, 15, 16, 23, 42), where a_i is the i-th element of a.
Output
Print one integer — the minimum number of elements you have to remove to obtain a good array.
Examples
Input
5
4 8 15 16 23
Output
5
Input
12
4 8 4 15 16 8 23 15 16 42 23 42
Output
0
Input
15
4 8 4 8 15 16 8 16 23 15 16 4 42 23 42
Output
3
Submitted Solution:
```
seq = (4,8,15,16,23,42)
n = int(input())
a = list(map(int,input().split()))
ans = 0
while True:
temp = 0
for i in seq:
try:
awal = temp
temp = a[awal:].index(i)
a.pop(awal+temp)
except:
break
else:
ans += 6
continue
break
print(n-ans)
``` | instruction | 0 | 96,187 | 12 | 192,374 |
No | output | 1 | 96,187 | 12 | 192,375 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers. Each a_i is one of the six following numbers: 4, 8, 15, 16, 23, 42.
Your task is to remove the minimum number of elements to make this array good.
An array of length k is called good if k is divisible by 6 and it is possible to split it into k/6 subsequences 4, 8, 15, 16, 23, 42.
Examples of good arrays:
* [4, 8, 15, 16, 23, 42] (the whole array is a required sequence);
* [4, 8, 4, 15, 16, 8, 23, 15, 16, 42, 23, 42] (the first sequence is formed from first, second, fourth, fifth, seventh and tenth elements and the second one is formed from remaining elements);
* [] (the empty array is good).
Examples of bad arrays:
* [4, 8, 15, 16, 42, 23] (the order of elements should be exactly 4, 8, 15, 16, 23, 42);
* [4, 8, 15, 16, 23, 42, 4] (the length of the array is not divisible by 6);
* [4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 23] (the first sequence can be formed from first six elements but the remaining array cannot form the required sequence).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (each a_i is one of the following numbers: 4, 8, 15, 16, 23, 42), where a_i is the i-th element of a.
Output
Print one integer — the minimum number of elements you have to remove to obtain a good array.
Examples
Input
5
4 8 15 16 23
Output
5
Input
12
4 8 4 15 16 8 23 15 16 42 23 42
Output
0
Input
15
4 8 4 8 15 16 8 16 23 15 16 4 42 23 42
Output
3
Submitted Solution:
```
######################################################################
# Write your code here
#import sys
#import resource
#resource.setrlimit(resource.RLIMIT_STACK, [0x10000000, resource.RLIM_INFINITY])
#sys.setrecursionlimit(0x100000)
# Write your code here
RI = lambda : [int(x) for x in input().strip().split()]
rw = lambda : input().strip().split()
from collections import defaultdict as df
#import heapq
#heapq.heapify(li) heappush(li,4) heappop(li)
#import random
#random.shuffle(list)
#infinite = float('inf')
#######################################################################)
t=int(input())
l=RI()
d=df(int)
ans=0
for i in l:
if(i not in [4,8,15,16,23,42]):
ans+=1
else:
d[i]+=1
mini=d[4]
for j in [4,8,15,16,23,42]:
mini=min(mini,d[j])
for j in [4,8,15,16,23,42]:
ans+=(d[j]-mini)
print(ans)
``` | instruction | 0 | 96,188 | 12 | 192,376 |
No | output | 1 | 96,188 | 12 | 192,377 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer n and an array a_1, a_2, …, a_n. You should reorder the elements of the array a in such way that the sum of MEX on prefixes (i-th prefix is a_1, a_2, …, a_i) is maximized.
Formally, you should find an array b_1, b_2, …, b_n, such that the sets of elements of arrays a and b are equal (it is equivalent to array b can be found as an array a with some reordering of its elements) and ∑_{i=1}^{n} MEX(b_1, b_2, …, b_i) is maximized.
MEX of a set of nonnegative integers is the minimal nonnegative integer such that it is not in the set.
For example, MEX(\{1, 2, 3\}) = 0, MEX(\{0, 1, 2, 4, 5\}) = 3.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100).
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100).
Output
For each test case print an array b_1, b_2, …, b_n — the optimal reordering of a_1, a_2, …, a_n, so the sum of MEX on its prefixes is maximized.
If there exist multiple optimal answers you can find any.
Example
Input
3
7
4 2 0 1 3 3 7
5
2 2 8 6 9
1
0
Output
0 1 2 3 4 7 3
2 6 8 9 2
0
Note
In the first test case in the answer MEX for prefixes will be:
1. MEX(\{0\}) = 1
2. MEX(\{0, 1\}) = 2
3. MEX(\{0, 1, 2\}) = 3
4. MEX(\{0, 1, 2, 3\}) = 4
5. MEX(\{0, 1, 2, 3, 4\}) = 5
6. MEX(\{0, 1, 2, 3, 4, 7\}) = 5
7. MEX(\{0, 1, 2, 3, 4, 7, 3\}) = 5
The sum of MEX = 1 + 2 + 3 + 4 + 5 + 5 + 5 = 25. It can be proven, that it is a maximum possible sum of MEX on prefixes. | instruction | 0 | 96,356 | 12 | 192,712 |
Tags: brute force, data structures, greedy, sortings
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
l = list(map(int,input().split()))
lst = [-1]*200
k = 110
for i in l:
if lst[i]==(-1):
lst[i]=i
else:
lst[k]=i
k+=1
m = []
for j in lst:
if j!=-1:
m.append(j)
print(*m)
``` | output | 1 | 96,356 | 12 | 192,713 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer n and an array a_1, a_2, …, a_n. You should reorder the elements of the array a in such way that the sum of MEX on prefixes (i-th prefix is a_1, a_2, …, a_i) is maximized.
Formally, you should find an array b_1, b_2, …, b_n, such that the sets of elements of arrays a and b are equal (it is equivalent to array b can be found as an array a with some reordering of its elements) and ∑_{i=1}^{n} MEX(b_1, b_2, …, b_i) is maximized.
MEX of a set of nonnegative integers is the minimal nonnegative integer such that it is not in the set.
For example, MEX(\{1, 2, 3\}) = 0, MEX(\{0, 1, 2, 4, 5\}) = 3.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100).
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100).
Output
For each test case print an array b_1, b_2, …, b_n — the optimal reordering of a_1, a_2, …, a_n, so the sum of MEX on its prefixes is maximized.
If there exist multiple optimal answers you can find any.
Example
Input
3
7
4 2 0 1 3 3 7
5
2 2 8 6 9
1
0
Output
0 1 2 3 4 7 3
2 6 8 9 2
0
Note
In the first test case in the answer MEX for prefixes will be:
1. MEX(\{0\}) = 1
2. MEX(\{0, 1\}) = 2
3. MEX(\{0, 1, 2\}) = 3
4. MEX(\{0, 1, 2, 3\}) = 4
5. MEX(\{0, 1, 2, 3, 4\}) = 5
6. MEX(\{0, 1, 2, 3, 4, 7\}) = 5
7. MEX(\{0, 1, 2, 3, 4, 7, 3\}) = 5
The sum of MEX = 1 + 2 + 3 + 4 + 5 + 5 + 5 = 25. It can be proven, that it is a maximum possible sum of MEX on prefixes. | instruction | 0 | 96,357 | 12 | 192,714 |
Tags: brute force, data structures, greedy, sortings
Correct Solution:
```
from sys import stdin
t = int(input())
def mex(a):
a.sort()
if not a:
return 0
b = 0
for i in a:
if i > b:
return b
b = i + 1
return b
for _ in range(t):
n = int(next(stdin))
nums = list(map(int, input().split()))
s = 0
nums.sort()
x, y = [], []
for i in nums:
if i in x:
y.append(i)
else:
x.append(i)
for i in y:
x.append(i)
print(*x)
``` | output | 1 | 96,357 | 12 | 192,715 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer n and an array a_1, a_2, …, a_n. You should reorder the elements of the array a in such way that the sum of MEX on prefixes (i-th prefix is a_1, a_2, …, a_i) is maximized.
Formally, you should find an array b_1, b_2, …, b_n, such that the sets of elements of arrays a and b are equal (it is equivalent to array b can be found as an array a with some reordering of its elements) and ∑_{i=1}^{n} MEX(b_1, b_2, …, b_i) is maximized.
MEX of a set of nonnegative integers is the minimal nonnegative integer such that it is not in the set.
For example, MEX(\{1, 2, 3\}) = 0, MEX(\{0, 1, 2, 4, 5\}) = 3.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100).
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100).
Output
For each test case print an array b_1, b_2, …, b_n — the optimal reordering of a_1, a_2, …, a_n, so the sum of MEX on its prefixes is maximized.
If there exist multiple optimal answers you can find any.
Example
Input
3
7
4 2 0 1 3 3 7
5
2 2 8 6 9
1
0
Output
0 1 2 3 4 7 3
2 6 8 9 2
0
Note
In the first test case in the answer MEX for prefixes will be:
1. MEX(\{0\}) = 1
2. MEX(\{0, 1\}) = 2
3. MEX(\{0, 1, 2\}) = 3
4. MEX(\{0, 1, 2, 3\}) = 4
5. MEX(\{0, 1, 2, 3, 4\}) = 5
6. MEX(\{0, 1, 2, 3, 4, 7\}) = 5
7. MEX(\{0, 1, 2, 3, 4, 7, 3\}) = 5
The sum of MEX = 1 + 2 + 3 + 4 + 5 + 5 + 5 = 25. It can be proven, that it is a maximum possible sum of MEX on prefixes. | instruction | 0 | 96,358 | 12 | 192,716 |
Tags: brute force, data structures, greedy, sortings
Correct Solution:
```
'''
3
7
4 2 0 1 3 3 7
5
2 2 8 6 9
1
0
'''
def Sort(sub_li):
return(sorted(sub_li, key = lambda x: x[1]))
import math
n=int(input())
# E=input().rstrip().split(' ')
for i in range(0,n):
# e=input().rstrip()
# o=input().rstrip().split(' ')
o=int(input())
p=input().rstrip().split(' ')
L=[0]*101
L=list(L)
for j in range(0,len(p)):
L[int(p[j])]+=1;
for j in range(0,len(L)):
A=j
B=L[j];
if(B>0):
print(A,end=' ')
L[j]-=1;
for j in range(0,len(L)):
A=j;
for k in range(0,L[j]):
print(A,end=' ')
print()
``` | output | 1 | 96,358 | 12 | 192,717 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer n and an array a_1, a_2, …, a_n. You should reorder the elements of the array a in such way that the sum of MEX on prefixes (i-th prefix is a_1, a_2, …, a_i) is maximized.
Formally, you should find an array b_1, b_2, …, b_n, such that the sets of elements of arrays a and b are equal (it is equivalent to array b can be found as an array a with some reordering of its elements) and ∑_{i=1}^{n} MEX(b_1, b_2, …, b_i) is maximized.
MEX of a set of nonnegative integers is the minimal nonnegative integer such that it is not in the set.
For example, MEX(\{1, 2, 3\}) = 0, MEX(\{0, 1, 2, 4, 5\}) = 3.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100).
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100).
Output
For each test case print an array b_1, b_2, …, b_n — the optimal reordering of a_1, a_2, …, a_n, so the sum of MEX on its prefixes is maximized.
If there exist multiple optimal answers you can find any.
Example
Input
3
7
4 2 0 1 3 3 7
5
2 2 8 6 9
1
0
Output
0 1 2 3 4 7 3
2 6 8 9 2
0
Note
In the first test case in the answer MEX for prefixes will be:
1. MEX(\{0\}) = 1
2. MEX(\{0, 1\}) = 2
3. MEX(\{0, 1, 2\}) = 3
4. MEX(\{0, 1, 2, 3\}) = 4
5. MEX(\{0, 1, 2, 3, 4\}) = 5
6. MEX(\{0, 1, 2, 3, 4, 7\}) = 5
7. MEX(\{0, 1, 2, 3, 4, 7, 3\}) = 5
The sum of MEX = 1 + 2 + 3 + 4 + 5 + 5 + 5 = 25. It can be proven, that it is a maximum possible sum of MEX on prefixes. | instruction | 0 | 96,359 | 12 | 192,718 |
Tags: brute force, data structures, greedy, sortings
Correct Solution:
```
t = int(input())
for i in range(t):
n = int(input())
l = [int(x) for x in input().split()]
l.sort()
nw=[]
print(l[0], end=' ')
for i in range(1, len(l), 1):
if l[i]!=l[i-1]:
print(l[i], end=' ')
else:
nw.append(l[i])
for i in range(len(nw)):
print(nw[i], end=' ')
print("\n", end="")
``` | output | 1 | 96,359 | 12 | 192,719 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer n and an array a_1, a_2, …, a_n. You should reorder the elements of the array a in such way that the sum of MEX on prefixes (i-th prefix is a_1, a_2, …, a_i) is maximized.
Formally, you should find an array b_1, b_2, …, b_n, such that the sets of elements of arrays a and b are equal (it is equivalent to array b can be found as an array a with some reordering of its elements) and ∑_{i=1}^{n} MEX(b_1, b_2, …, b_i) is maximized.
MEX of a set of nonnegative integers is the minimal nonnegative integer such that it is not in the set.
For example, MEX(\{1, 2, 3\}) = 0, MEX(\{0, 1, 2, 4, 5\}) = 3.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100).
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100).
Output
For each test case print an array b_1, b_2, …, b_n — the optimal reordering of a_1, a_2, …, a_n, so the sum of MEX on its prefixes is maximized.
If there exist multiple optimal answers you can find any.
Example
Input
3
7
4 2 0 1 3 3 7
5
2 2 8 6 9
1
0
Output
0 1 2 3 4 7 3
2 6 8 9 2
0
Note
In the first test case in the answer MEX for prefixes will be:
1. MEX(\{0\}) = 1
2. MEX(\{0, 1\}) = 2
3. MEX(\{0, 1, 2\}) = 3
4. MEX(\{0, 1, 2, 3\}) = 4
5. MEX(\{0, 1, 2, 3, 4\}) = 5
6. MEX(\{0, 1, 2, 3, 4, 7\}) = 5
7. MEX(\{0, 1, 2, 3, 4, 7, 3\}) = 5
The sum of MEX = 1 + 2 + 3 + 4 + 5 + 5 + 5 = 25. It can be proven, that it is a maximum possible sum of MEX on prefixes. | instruction | 0 | 96,360 | 12 | 192,720 |
Tags: brute force, data structures, greedy, sortings
Correct Solution:
```
for i in range(int(input())):
n=int(input())
arr=list(map(int,input().split()))
arr.sort()
s=set(arr)
k=len(s)
i=0
while(i<(k-1)):
if arr[i]==arr[i+1]:
arr.remove(arr[i])
arr.append(arr[i])
else:
i+=1
for i in range(n):
if i==(n-1):
print(arr[i])
else:
print(arr[i],end=" ")
``` | output | 1 | 96,360 | 12 | 192,721 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer n and an array a_1, a_2, …, a_n. You should reorder the elements of the array a in such way that the sum of MEX on prefixes (i-th prefix is a_1, a_2, …, a_i) is maximized.
Formally, you should find an array b_1, b_2, …, b_n, such that the sets of elements of arrays a and b are equal (it is equivalent to array b can be found as an array a with some reordering of its elements) and ∑_{i=1}^{n} MEX(b_1, b_2, …, b_i) is maximized.
MEX of a set of nonnegative integers is the minimal nonnegative integer such that it is not in the set.
For example, MEX(\{1, 2, 3\}) = 0, MEX(\{0, 1, 2, 4, 5\}) = 3.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100).
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100).
Output
For each test case print an array b_1, b_2, …, b_n — the optimal reordering of a_1, a_2, …, a_n, so the sum of MEX on its prefixes is maximized.
If there exist multiple optimal answers you can find any.
Example
Input
3
7
4 2 0 1 3 3 7
5
2 2 8 6 9
1
0
Output
0 1 2 3 4 7 3
2 6 8 9 2
0
Note
In the first test case in the answer MEX for prefixes will be:
1. MEX(\{0\}) = 1
2. MEX(\{0, 1\}) = 2
3. MEX(\{0, 1, 2\}) = 3
4. MEX(\{0, 1, 2, 3\}) = 4
5. MEX(\{0, 1, 2, 3, 4\}) = 5
6. MEX(\{0, 1, 2, 3, 4, 7\}) = 5
7. MEX(\{0, 1, 2, 3, 4, 7, 3\}) = 5
The sum of MEX = 1 + 2 + 3 + 4 + 5 + 5 + 5 = 25. It can be proven, that it is a maximum possible sum of MEX on prefixes. | instruction | 0 | 96,361 | 12 | 192,722 |
Tags: brute force, data structures, greedy, sortings
Correct Solution:
```
t = int(input())
for j in range(t):
n = int(input())
lst = list(map(int, input().split()))
lst.sort()
if len(lst) == 1:
print(*lst)
else:
i = 1
maxvalue = lst[-1]
while lst[i] != maxvalue:
if lst[i] == lst[i - 1]:
lst.append(lst.pop(i))
else:
i += 1
print(*lst)
``` | output | 1 | 96,361 | 12 | 192,723 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer n and an array a_1, a_2, …, a_n. You should reorder the elements of the array a in such way that the sum of MEX on prefixes (i-th prefix is a_1, a_2, …, a_i) is maximized.
Formally, you should find an array b_1, b_2, …, b_n, such that the sets of elements of arrays a and b are equal (it is equivalent to array b can be found as an array a with some reordering of its elements) and ∑_{i=1}^{n} MEX(b_1, b_2, …, b_i) is maximized.
MEX of a set of nonnegative integers is the minimal nonnegative integer such that it is not in the set.
For example, MEX(\{1, 2, 3\}) = 0, MEX(\{0, 1, 2, 4, 5\}) = 3.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100).
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100).
Output
For each test case print an array b_1, b_2, …, b_n — the optimal reordering of a_1, a_2, …, a_n, so the sum of MEX on its prefixes is maximized.
If there exist multiple optimal answers you can find any.
Example
Input
3
7
4 2 0 1 3 3 7
5
2 2 8 6 9
1
0
Output
0 1 2 3 4 7 3
2 6 8 9 2
0
Note
In the first test case in the answer MEX for prefixes will be:
1. MEX(\{0\}) = 1
2. MEX(\{0, 1\}) = 2
3. MEX(\{0, 1, 2\}) = 3
4. MEX(\{0, 1, 2, 3\}) = 4
5. MEX(\{0, 1, 2, 3, 4\}) = 5
6. MEX(\{0, 1, 2, 3, 4, 7\}) = 5
7. MEX(\{0, 1, 2, 3, 4, 7, 3\}) = 5
The sum of MEX = 1 + 2 + 3 + 4 + 5 + 5 + 5 = 25. It can be proven, that it is a maximum possible sum of MEX on prefixes. | instruction | 0 | 96,362 | 12 | 192,724 |
Tags: brute force, data structures, greedy, sortings
Correct Solution:
```
t=int(input())
for _ in range(t):
n=int(input())
a=list(map(int,input().split()))
b=[0]*101
s=list()
for i in a:
b[i]+=1
if(b[i]>1):
s.append(i)
if(b[0]==0):
print(' '.join(map(str,a)))
else:
print(' '.join(map(str,sorted(set(a)))),end=' ')
print(' '.join(map(str,sorted(s))))
``` | output | 1 | 96,362 | 12 | 192,725 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an integer n and an array a_1, a_2, …, a_n. You should reorder the elements of the array a in such way that the sum of MEX on prefixes (i-th prefix is a_1, a_2, …, a_i) is maximized.
Formally, you should find an array b_1, b_2, …, b_n, such that the sets of elements of arrays a and b are equal (it is equivalent to array b can be found as an array a with some reordering of its elements) and ∑_{i=1}^{n} MEX(b_1, b_2, …, b_i) is maximized.
MEX of a set of nonnegative integers is the minimal nonnegative integer such that it is not in the set.
For example, MEX(\{1, 2, 3\}) = 0, MEX(\{0, 1, 2, 4, 5\}) = 3.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100).
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100).
Output
For each test case print an array b_1, b_2, …, b_n — the optimal reordering of a_1, a_2, …, a_n, so the sum of MEX on its prefixes is maximized.
If there exist multiple optimal answers you can find any.
Example
Input
3
7
4 2 0 1 3 3 7
5
2 2 8 6 9
1
0
Output
0 1 2 3 4 7 3
2 6 8 9 2
0
Note
In the first test case in the answer MEX for prefixes will be:
1. MEX(\{0\}) = 1
2. MEX(\{0, 1\}) = 2
3. MEX(\{0, 1, 2\}) = 3
4. MEX(\{0, 1, 2, 3\}) = 4
5. MEX(\{0, 1, 2, 3, 4\}) = 5
6. MEX(\{0, 1, 2, 3, 4, 7\}) = 5
7. MEX(\{0, 1, 2, 3, 4, 7, 3\}) = 5
The sum of MEX = 1 + 2 + 3 + 4 + 5 + 5 + 5 = 25. It can be proven, that it is a maximum possible sum of MEX on prefixes. | instruction | 0 | 96,363 | 12 | 192,726 |
Tags: brute force, data structures, greedy, sortings
Correct Solution:
```
import sys
def input():
return sys.stdin.readline().rstrip()
def mex(a, i):
for j in range(1,10000):
if all(j != a[k] for k in range(i)):
return j
def slv():
n = int(input())
a = list(map(int, input().split()))
seen = [False]*(200)
a.sort()
b = []
ans = []
for v in a:
if seen[v] == False:
ans.append(v)
seen[v] = True
else:
b.append(v)
ans += b
print(*ans)
def main():
t = int(input())
for i in range(t):
slv()
return
main()
``` | output | 1 | 96,363 | 12 | 192,727 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer n and an array a_1, a_2, …, a_n. You should reorder the elements of the array a in such way that the sum of MEX on prefixes (i-th prefix is a_1, a_2, …, a_i) is maximized.
Formally, you should find an array b_1, b_2, …, b_n, such that the sets of elements of arrays a and b are equal (it is equivalent to array b can be found as an array a with some reordering of its elements) and ∑_{i=1}^{n} MEX(b_1, b_2, …, b_i) is maximized.
MEX of a set of nonnegative integers is the minimal nonnegative integer such that it is not in the set.
For example, MEX(\{1, 2, 3\}) = 0, MEX(\{0, 1, 2, 4, 5\}) = 3.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100).
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100).
Output
For each test case print an array b_1, b_2, …, b_n — the optimal reordering of a_1, a_2, …, a_n, so the sum of MEX on its prefixes is maximized.
If there exist multiple optimal answers you can find any.
Example
Input
3
7
4 2 0 1 3 3 7
5
2 2 8 6 9
1
0
Output
0 1 2 3 4 7 3
2 6 8 9 2
0
Note
In the first test case in the answer MEX for prefixes will be:
1. MEX(\{0\}) = 1
2. MEX(\{0, 1\}) = 2
3. MEX(\{0, 1, 2\}) = 3
4. MEX(\{0, 1, 2, 3\}) = 4
5. MEX(\{0, 1, 2, 3, 4\}) = 5
6. MEX(\{0, 1, 2, 3, 4, 7\}) = 5
7. MEX(\{0, 1, 2, 3, 4, 7, 3\}) = 5
The sum of MEX = 1 + 2 + 3 + 4 + 5 + 5 + 5 = 25. It can be proven, that it is a maximum possible sum of MEX on prefixes.
Submitted Solution:
```
from collections import Counter
t = int(input())
for _ in range(t):
n = int(input())
a = input().split(' ')
a = [int(x) for x in a]
u = sorted(list(set(a)))
count = Counter(a)
for x in u:
count[x] -= 1
for k, v in count.items():
while v > 0:
u.append(k)
v -= 1
print(' '.join([str(x) for x in u]))
``` | instruction | 0 | 96,364 | 12 | 192,728 |
Yes | output | 1 | 96,364 | 12 | 192,729 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer n and an array a_1, a_2, …, a_n. You should reorder the elements of the array a in such way that the sum of MEX on prefixes (i-th prefix is a_1, a_2, …, a_i) is maximized.
Formally, you should find an array b_1, b_2, …, b_n, such that the sets of elements of arrays a and b are equal (it is equivalent to array b can be found as an array a with some reordering of its elements) and ∑_{i=1}^{n} MEX(b_1, b_2, …, b_i) is maximized.
MEX of a set of nonnegative integers is the minimal nonnegative integer such that it is not in the set.
For example, MEX(\{1, 2, 3\}) = 0, MEX(\{0, 1, 2, 4, 5\}) = 3.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100).
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100).
Output
For each test case print an array b_1, b_2, …, b_n — the optimal reordering of a_1, a_2, …, a_n, so the sum of MEX on its prefixes is maximized.
If there exist multiple optimal answers you can find any.
Example
Input
3
7
4 2 0 1 3 3 7
5
2 2 8 6 9
1
0
Output
0 1 2 3 4 7 3
2 6 8 9 2
0
Note
In the first test case in the answer MEX for prefixes will be:
1. MEX(\{0\}) = 1
2. MEX(\{0, 1\}) = 2
3. MEX(\{0, 1, 2\}) = 3
4. MEX(\{0, 1, 2, 3\}) = 4
5. MEX(\{0, 1, 2, 3, 4\}) = 5
6. MEX(\{0, 1, 2, 3, 4, 7\}) = 5
7. MEX(\{0, 1, 2, 3, 4, 7, 3\}) = 5
The sum of MEX = 1 + 2 + 3 + 4 + 5 + 5 + 5 = 25. It can be proven, that it is a maximum possible sum of MEX on prefixes.
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
a.sort(reverse=True)
c=[]
b=[]
s=len(set(a))
while a!=[]:
i=a.pop()
if len(b)>=s:
b.append(i)
elif len(b)==0 or b[-1]!=i:
b.append(i)
else:
c.append(i)
b+=c
print(*b)
``` | instruction | 0 | 96,365 | 12 | 192,730 |
Yes | output | 1 | 96,365 | 12 | 192,731 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer n and an array a_1, a_2, …, a_n. You should reorder the elements of the array a in such way that the sum of MEX on prefixes (i-th prefix is a_1, a_2, …, a_i) is maximized.
Formally, you should find an array b_1, b_2, …, b_n, such that the sets of elements of arrays a and b are equal (it is equivalent to array b can be found as an array a with some reordering of its elements) and ∑_{i=1}^{n} MEX(b_1, b_2, …, b_i) is maximized.
MEX of a set of nonnegative integers is the minimal nonnegative integer such that it is not in the set.
For example, MEX(\{1, 2, 3\}) = 0, MEX(\{0, 1, 2, 4, 5\}) = 3.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100).
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100).
Output
For each test case print an array b_1, b_2, …, b_n — the optimal reordering of a_1, a_2, …, a_n, so the sum of MEX on its prefixes is maximized.
If there exist multiple optimal answers you can find any.
Example
Input
3
7
4 2 0 1 3 3 7
5
2 2 8 6 9
1
0
Output
0 1 2 3 4 7 3
2 6 8 9 2
0
Note
In the first test case in the answer MEX for prefixes will be:
1. MEX(\{0\}) = 1
2. MEX(\{0, 1\}) = 2
3. MEX(\{0, 1, 2\}) = 3
4. MEX(\{0, 1, 2, 3\}) = 4
5. MEX(\{0, 1, 2, 3, 4\}) = 5
6. MEX(\{0, 1, 2, 3, 4, 7\}) = 5
7. MEX(\{0, 1, 2, 3, 4, 7, 3\}) = 5
The sum of MEX = 1 + 2 + 3 + 4 + 5 + 5 + 5 = 25. It can be proven, that it is a maximum possible sum of MEX on prefixes.
Submitted Solution:
```
import math
import bisect
import copy
from collections import defaultdict
from collections import OrderedDict
from sys import stdout
for _ in range(int(input())):
n = int(input())
ar = list(map(int,input().split()))
#a1,a2 = [],[]
ar.sort()
chk = [0]*n
freq = {}
#print(freq)
ans = []
for i in range(n):
if ar[i] not in freq:
freq[ar[i]] = 1
else:
freq[ar[i]] += 1
while len(ans)< n:
for i in freq.keys():
if freq[i] > 0:
ans.append(i)
freq[i] -= 1
#print(freq)
print(*ans)
"""
a1 = ar[:n//2+1]
a2 = ar[n//2+1:]
#
a1 = a1[::-1]
#print(a1)
#print(a1,a2)
ans = []
for i in range(n//2):
ans.append(a1[i])
ans.append(a2[i])
if n%2 == 1:
ans.append(a1[n//2])
print(*ans)
"""
``` | instruction | 0 | 96,366 | 12 | 192,732 |
Yes | output | 1 | 96,366 | 12 | 192,733 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer n and an array a_1, a_2, …, a_n. You should reorder the elements of the array a in such way that the sum of MEX on prefixes (i-th prefix is a_1, a_2, …, a_i) is maximized.
Formally, you should find an array b_1, b_2, …, b_n, such that the sets of elements of arrays a and b are equal (it is equivalent to array b can be found as an array a with some reordering of its elements) and ∑_{i=1}^{n} MEX(b_1, b_2, …, b_i) is maximized.
MEX of a set of nonnegative integers is the minimal nonnegative integer such that it is not in the set.
For example, MEX(\{1, 2, 3\}) = 0, MEX(\{0, 1, 2, 4, 5\}) = 3.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100).
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100).
Output
For each test case print an array b_1, b_2, …, b_n — the optimal reordering of a_1, a_2, …, a_n, so the sum of MEX on its prefixes is maximized.
If there exist multiple optimal answers you can find any.
Example
Input
3
7
4 2 0 1 3 3 7
5
2 2 8 6 9
1
0
Output
0 1 2 3 4 7 3
2 6 8 9 2
0
Note
In the first test case in the answer MEX for prefixes will be:
1. MEX(\{0\}) = 1
2. MEX(\{0, 1\}) = 2
3. MEX(\{0, 1, 2\}) = 3
4. MEX(\{0, 1, 2, 3\}) = 4
5. MEX(\{0, 1, 2, 3, 4\}) = 5
6. MEX(\{0, 1, 2, 3, 4, 7\}) = 5
7. MEX(\{0, 1, 2, 3, 4, 7, 3\}) = 5
The sum of MEX = 1 + 2 + 3 + 4 + 5 + 5 + 5 = 25. It can be proven, that it is a maximum possible sum of MEX on prefixes.
Submitted Solution:
```
for _ in range (int(input())):
n=int(input())
l=[int(i) for i in input().split()]
x=[]
y=[]
for i in l:
if i not in x:
x.append(i)
else:
y.append(i)
for i in sorted(x):
print(i,end=' ')
for j in sorted(y):
print(j,end=' ')
print("\n",end="")
``` | instruction | 0 | 96,367 | 12 | 192,734 |
Yes | output | 1 | 96,367 | 12 | 192,735 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer n and an array a_1, a_2, …, a_n. You should reorder the elements of the array a in such way that the sum of MEX on prefixes (i-th prefix is a_1, a_2, …, a_i) is maximized.
Formally, you should find an array b_1, b_2, …, b_n, such that the sets of elements of arrays a and b are equal (it is equivalent to array b can be found as an array a with some reordering of its elements) and ∑_{i=1}^{n} MEX(b_1, b_2, …, b_i) is maximized.
MEX of a set of nonnegative integers is the minimal nonnegative integer such that it is not in the set.
For example, MEX(\{1, 2, 3\}) = 0, MEX(\{0, 1, 2, 4, 5\}) = 3.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100).
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100).
Output
For each test case print an array b_1, b_2, …, b_n — the optimal reordering of a_1, a_2, …, a_n, so the sum of MEX on its prefixes is maximized.
If there exist multiple optimal answers you can find any.
Example
Input
3
7
4 2 0 1 3 3 7
5
2 2 8 6 9
1
0
Output
0 1 2 3 4 7 3
2 6 8 9 2
0
Note
In the first test case in the answer MEX for prefixes will be:
1. MEX(\{0\}) = 1
2. MEX(\{0, 1\}) = 2
3. MEX(\{0, 1, 2\}) = 3
4. MEX(\{0, 1, 2, 3\}) = 4
5. MEX(\{0, 1, 2, 3, 4\}) = 5
6. MEX(\{0, 1, 2, 3, 4, 7\}) = 5
7. MEX(\{0, 1, 2, 3, 4, 7, 3\}) = 5
The sum of MEX = 1 + 2 + 3 + 4 + 5 + 5 + 5 = 25. It can be proven, that it is a maximum possible sum of MEX on prefixes.
Submitted Solution:
```
def mexsum(a):
ans = 0
sm = 0
mex = 0
seen = set()
for i in range(n):
seen.add(a[i])
while mex in seen:
mex += 1
sm += mex
return sm
t = int(input())
for _ in range(t):
n = int(input())
a = [int(i) for i in input().split()]
a.sort()
mx = 0
ans = a[:]
for i in range(n):
b = a[:i] + a[i+1:] + [a[i]]
sm = mexsum(b)
if sm > mx:
ans = b[:]
mx = sm
print(ans)
``` | instruction | 0 | 96,368 | 12 | 192,736 |
No | output | 1 | 96,368 | 12 | 192,737 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer n and an array a_1, a_2, …, a_n. You should reorder the elements of the array a in such way that the sum of MEX on prefixes (i-th prefix is a_1, a_2, …, a_i) is maximized.
Formally, you should find an array b_1, b_2, …, b_n, such that the sets of elements of arrays a and b are equal (it is equivalent to array b can be found as an array a with some reordering of its elements) and ∑_{i=1}^{n} MEX(b_1, b_2, …, b_i) is maximized.
MEX of a set of nonnegative integers is the minimal nonnegative integer such that it is not in the set.
For example, MEX(\{1, 2, 3\}) = 0, MEX(\{0, 1, 2, 4, 5\}) = 3.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100).
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100).
Output
For each test case print an array b_1, b_2, …, b_n — the optimal reordering of a_1, a_2, …, a_n, so the sum of MEX on its prefixes is maximized.
If there exist multiple optimal answers you can find any.
Example
Input
3
7
4 2 0 1 3 3 7
5
2 2 8 6 9
1
0
Output
0 1 2 3 4 7 3
2 6 8 9 2
0
Note
In the first test case in the answer MEX for prefixes will be:
1. MEX(\{0\}) = 1
2. MEX(\{0, 1\}) = 2
3. MEX(\{0, 1, 2\}) = 3
4. MEX(\{0, 1, 2, 3\}) = 4
5. MEX(\{0, 1, 2, 3, 4\}) = 5
6. MEX(\{0, 1, 2, 3, 4, 7\}) = 5
7. MEX(\{0, 1, 2, 3, 4, 7, 3\}) = 5
The sum of MEX = 1 + 2 + 3 + 4 + 5 + 5 + 5 = 25. It can be proven, that it is a maximum possible sum of MEX on prefixes.
Submitted Solution:
```
# cook your dish here
#####################################################################################################
'''
Author--------
Name: Hemant Jain Final Year Student
Poornima Institute of Engineering and Technology, Jaipur
*******************Python Coder*************************
'''
######################################################################################################
import sys
import time as mt,bisect,sys
import math
from sys import stdin,stdout
from collections import deque
from fractions import Fraction
from collections import Counter
from collections import OrderedDict
def si(): return int(sys.stdin.readline()) #integer input
def st(): return stdin.readline() #string input
def mi(): return map(int, sys.stdin.readline().split()) #multiple integer input
def lis(): return list(map(int, sys.stdin.readline().split())) #list input
def lcm(a,b): return (a*b)//gcd(a,b) # to calculate lcm
def gcd(a,b): # to calculate gcd
if a==0:
return b
elif b==0:
return a
if a>b:
return gcd(a%b,b)
else:
return gcd(a,b%a)
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
test=si()
for _ in range(test):
n=si()
list1=lis()
list1.sort()
for i in range(n):
if list1[i]==list1[i-1]:
x=list1[i]
list1.remove(list1[i])
break
list1.append(x)
print(*list1)
``` | instruction | 0 | 96,369 | 12 | 192,738 |
No | output | 1 | 96,369 | 12 | 192,739 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer n and an array a_1, a_2, …, a_n. You should reorder the elements of the array a in such way that the sum of MEX on prefixes (i-th prefix is a_1, a_2, …, a_i) is maximized.
Formally, you should find an array b_1, b_2, …, b_n, such that the sets of elements of arrays a and b are equal (it is equivalent to array b can be found as an array a with some reordering of its elements) and ∑_{i=1}^{n} MEX(b_1, b_2, …, b_i) is maximized.
MEX of a set of nonnegative integers is the minimal nonnegative integer such that it is not in the set.
For example, MEX(\{1, 2, 3\}) = 0, MEX(\{0, 1, 2, 4, 5\}) = 3.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100).
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100).
Output
For each test case print an array b_1, b_2, …, b_n — the optimal reordering of a_1, a_2, …, a_n, so the sum of MEX on its prefixes is maximized.
If there exist multiple optimal answers you can find any.
Example
Input
3
7
4 2 0 1 3 3 7
5
2 2 8 6 9
1
0
Output
0 1 2 3 4 7 3
2 6 8 9 2
0
Note
In the first test case in the answer MEX for prefixes will be:
1. MEX(\{0\}) = 1
2. MEX(\{0, 1\}) = 2
3. MEX(\{0, 1, 2\}) = 3
4. MEX(\{0, 1, 2, 3\}) = 4
5. MEX(\{0, 1, 2, 3, 4\}) = 5
6. MEX(\{0, 1, 2, 3, 4, 7\}) = 5
7. MEX(\{0, 1, 2, 3, 4, 7, 3\}) = 5
The sum of MEX = 1 + 2 + 3 + 4 + 5 + 5 + 5 = 25. It can be proven, that it is a maximum possible sum of MEX on prefixes.
Submitted Solution:
```
test = int(input())
for i in range(test):
length = int(input())
listt = list(map(int,input().split()))
listt.sort()
history = listt[0]
for i in range(1,length):
if listt[i]==history:
listt.append(listt.pop(i))
else:
history = listt[i]
for i in listt:
print(i,end=" ")
print()
``` | instruction | 0 | 96,370 | 12 | 192,740 |
No | output | 1 | 96,370 | 12 | 192,741 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer n and an array a_1, a_2, …, a_n. You should reorder the elements of the array a in such way that the sum of MEX on prefixes (i-th prefix is a_1, a_2, …, a_i) is maximized.
Formally, you should find an array b_1, b_2, …, b_n, such that the sets of elements of arrays a and b are equal (it is equivalent to array b can be found as an array a with some reordering of its elements) and ∑_{i=1}^{n} MEX(b_1, b_2, …, b_i) is maximized.
MEX of a set of nonnegative integers is the minimal nonnegative integer such that it is not in the set.
For example, MEX(\{1, 2, 3\}) = 0, MEX(\{0, 1, 2, 4, 5\}) = 3.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100).
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100).
Output
For each test case print an array b_1, b_2, …, b_n — the optimal reordering of a_1, a_2, …, a_n, so the sum of MEX on its prefixes is maximized.
If there exist multiple optimal answers you can find any.
Example
Input
3
7
4 2 0 1 3 3 7
5
2 2 8 6 9
1
0
Output
0 1 2 3 4 7 3
2 6 8 9 2
0
Note
In the first test case in the answer MEX for prefixes will be:
1. MEX(\{0\}) = 1
2. MEX(\{0, 1\}) = 2
3. MEX(\{0, 1, 2\}) = 3
4. MEX(\{0, 1, 2, 3\}) = 4
5. MEX(\{0, 1, 2, 3, 4\}) = 5
6. MEX(\{0, 1, 2, 3, 4, 7\}) = 5
7. MEX(\{0, 1, 2, 3, 4, 7, 3\}) = 5
The sum of MEX = 1 + 2 + 3 + 4 + 5 + 5 + 5 = 25. It can be proven, that it is a maximum possible sum of MEX on prefixes.
Submitted Solution:
```
def Solve():
n = int(input())
a = list(map(int, input().split()))
a.sort()
b = {}
c = []
for i in range(len(a)):
if b.get(a[i]) != None:
c.append(a[i])
else:
print(a[i], end=' ')
for i in c:
print(i, end=' ')
print()
q = int(input())
while q:
Solve()
q-=1
``` | instruction | 0 | 96,371 | 12 | 192,742 |
No | output | 1 | 96,371 | 12 | 192,743 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have an array a[1], a[2], ..., a[n], containing distinct integers from 1 to n. Your task is to sort this array in increasing order with the following operation (you may need to apply it multiple times):
* choose two indexes, i and j (1 ≤ i < j ≤ n; (j - i + 1) is a prime number);
* swap the elements on positions i and j; in other words, you are allowed to apply the following sequence of assignments: tmp = a[i], a[i] = a[j], a[j] = tmp (tmp is a temporary variable).
You do not need to minimize the number of used operations. However, you need to make sure that there are at most 5n operations.
Input
The first line contains integer n (1 ≤ n ≤ 105). The next line contains n distinct integers a[1], a[2], ..., a[n] (1 ≤ a[i] ≤ n).
Output
In the first line, print integer k (0 ≤ k ≤ 5n) — the number of used operations. Next, print the operations. Each operation must be printed as "i j" (1 ≤ i < j ≤ n; (j - i + 1) is a prime).
If there are multiple answers, you can print any of them.
Examples
Input
3
3 2 1
Output
1
1 3
Input
2
1 2
Output
0
Input
4
4 2 3 1
Output
3
2 4
1 2
2 4 | instruction | 0 | 96,497 | 12 | 192,994 |
Tags: greedy, sortings
Correct Solution:
```
from sys import stdin,stdout
nmbr = lambda: int(stdin.readline())
lst = lambda: list(map(int,stdin.readline().split()))
N=10**5+5
primes=[1]*N
p=2
while p*p<=N:
if primes[p]:
for j in range(p*p,N,p):
primes[j]=0
p+=1
primes[0]=primes[1]=0
for i in range(2,N):
if primes[i]==0:
primes[i]=primes[i-1]
else:primes[i]=i
# print(primes[:20])
# def fn(ans):
# for p1,p2 in ans:
# aa[p1-1],aa[p2-1]=aa[p2-1],aa[p1-1]
# print(aa)
for _ in range(1):#nmbr()):
n=nmbr()
a=lst()
# aa=a.copy()
ind=[0]*(1+n)
for i in range(1,1+n):
ind[a[i-1]]=i
p=1
ans=[]
while p<=n:
pos=ind[p]
while pos>p:
near=primes[pos-p+1]
ans+=[[pos-near+1,pos]]
ind[a[pos-1]],ind[a[pos-near+1-1]]=ind[a[pos-near+1-1]],ind[a[pos-1]]
a[pos-1],a[pos-near+1-1]=a[pos-near+1-1],a[pos-1]
pos=pos-near+1
p+=1
print(len(ans))
for k,v in ans:
print(k,v)
# fn(ans)
``` | output | 1 | 96,497 | 12 | 192,995 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have an array a[1], a[2], ..., a[n], containing distinct integers from 1 to n. Your task is to sort this array in increasing order with the following operation (you may need to apply it multiple times):
* choose two indexes, i and j (1 ≤ i < j ≤ n; (j - i + 1) is a prime number);
* swap the elements on positions i and j; in other words, you are allowed to apply the following sequence of assignments: tmp = a[i], a[i] = a[j], a[j] = tmp (tmp is a temporary variable).
You do not need to minimize the number of used operations. However, you need to make sure that there are at most 5n operations.
Input
The first line contains integer n (1 ≤ n ≤ 105). The next line contains n distinct integers a[1], a[2], ..., a[n] (1 ≤ a[i] ≤ n).
Output
In the first line, print integer k (0 ≤ k ≤ 5n) — the number of used operations. Next, print the operations. Each operation must be printed as "i j" (1 ≤ i < j ≤ n; (j - i + 1) is a prime).
If there are multiple answers, you can print any of them.
Examples
Input
3
3 2 1
Output
1
1 3
Input
2
1 2
Output
0
Input
4
4 2 3 1
Output
3
2 4
1 2
2 4 | instruction | 0 | 96,498 | 12 | 192,996 |
Tags: greedy, sortings
Correct Solution:
```
def sieve(n):
prime = [-1]*(n+1)
for i in range(2,n+1):
if prime[i]==-1:
for j in range(i,n+1,i):
prime[j] = i
return prime
p = sieve(100010)
prime = []
for i in range(len(p)):
if p[i]==i:
prime.append(p[i])
# print (prime)
def find_prime(num):
low = 0
high = len(prime)-1
while low<high:
mid = (low+high)//2
if prime[mid]<num:
low = mid + 1
else:
high = mid - 1
if prime[low]<=num:
return prime[low]
else:
return prime[low-1]
def calc(ind):
ans = []
num = loc[arr[ind][0]]
while num-ind>0:
p = find_prime(num-ind+1)
# print (p, num, ind)
loc[a[num-p+1]], loc[a[num]] = loc[a[num]], loc[a[num-p+1]]
a[num], a[num-p+1] = a[num-p+1], a[num]
ans.append([num-p+2, num+1])
num -= p-1
return ans
n = int(input())
a = list(map(int,input().split()))
loc = {}
for i in range(n):
loc[a[i]] = i
arr = []
for i in range(n):
arr.append([a[i], i])
arr.sort()
i = 0
ans = []
while i<n:
if arr[i][0]==a[i]:
i += 1
continue
ans.extend(calc(i))
i += 1
# print (a)
# print (loc)
print (len(ans))
for i in ans:
print (*i)
``` | output | 1 | 96,498 | 12 | 192,997 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.