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 a correct Python 3 solution for this coding contest problem.
For given an integer $n$, print all permutations of $\\{1, 2, ..., n\\}$ in lexicographic order.
Constraints
* $1 \leq n \leq 9$
Input
An integer $n$ is given in a line.
Output
Print each permutation in a line in order. Separate adjacency elements by a space character.
Examples
Input
2
Output
1 2
2 1
Input
3
Output
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1 | instruction | 0 | 71,612 | 12 | 143,224 |
"Correct Solution:
```
import itertools
def print_elements(a):
print(' '.join(list(map(str, a))))
n = int(input())
for per in list(itertools.permutations([i+1 for i in range(n)])):
print_elements(per)
``` | output | 1 | 71,612 | 12 | 143,225 |
Provide a correct Python 3 solution for this coding contest problem.
For given an integer $n$, print all permutations of $\\{1, 2, ..., n\\}$ in lexicographic order.
Constraints
* $1 \leq n \leq 9$
Input
An integer $n$ is given in a line.
Output
Print each permutation in a line in order. Separate adjacency elements by a space character.
Examples
Input
2
Output
1 2
2 1
Input
3
Output
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1 | instruction | 0 | 71,613 | 12 | 143,226 |
"Correct Solution:
```
def rec(lst,d):
for i in range(1,len(lst)+1):
if i not in lst:
lst[d] = i
if d+1 == len(lst):
a = list(lst)
P.append(a)
lst[d] = 0
return
else:
rec(lst,d+1)
lst[d] = 0
N = int(input())
P = []
lst = []
for i in range(N):
lst.append(0)
rec(lst,0)
for i in range(len(P)):
print(*P[i])
``` | output | 1 | 71,613 | 12 | 143,227 |
Provide a correct Python 3 solution for this coding contest problem.
For given an integer $n$, print all permutations of $\\{1, 2, ..., n\\}$ in lexicographic order.
Constraints
* $1 \leq n \leq 9$
Input
An integer $n$ is given in a line.
Output
Print each permutation in a line in order. Separate adjacency elements by a space character.
Examples
Input
2
Output
1 2
2 1
Input
3
Output
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1 | instruction | 0 | 71,614 | 12 | 143,228 |
"Correct Solution:
```
from itertools import permutations
n = int(input())
p = list(permutations((str(i) for i in range(1,n+1))))
# for i in p:
# print(*i)
ans = (' '.join(t) for t in p)
print('\n'.join(ans))
``` | output | 1 | 71,614 | 12 | 143,229 |
Provide a correct Python 3 solution for this coding contest problem.
For given an integer $n$, print all permutations of $\\{1, 2, ..., n\\}$ in lexicographic order.
Constraints
* $1 \leq n \leq 9$
Input
An integer $n$ is given in a line.
Output
Print each permutation in a line in order. Separate adjacency elements by a space character.
Examples
Input
2
Output
1 2
2 1
Input
3
Output
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1 | instruction | 0 | 71,615 | 12 | 143,230 |
"Correct Solution:
```
import itertools
if __name__ == '__main__':
n = int(input())
seq = list(itertools.permutations(range(1,n+1)))
for p in seq:
print(*p)
``` | output | 1 | 71,615 | 12 | 143,231 |
Provide a correct Python 3 solution for this coding contest problem.
For given an integer $n$, print all permutations of $\\{1, 2, ..., n\\}$ in lexicographic order.
Constraints
* $1 \leq n \leq 9$
Input
An integer $n$ is given in a line.
Output
Print each permutation in a line in order. Separate adjacency elements by a space character.
Examples
Input
2
Output
1 2
2 1
Input
3
Output
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1 | instruction | 0 | 71,616 | 12 | 143,232 |
"Correct Solution:
```
import itertools
n = int(input())
a = tuple(range(1,n+1))
p = sorted(list(itertools.permutations(a)))
for i in p:
print(*i)
``` | output | 1 | 71,616 | 12 | 143,233 |
Provide a correct Python 3 solution for this coding contest problem.
For given an integer $n$, print all permutations of $\\{1, 2, ..., n\\}$ in lexicographic order.
Constraints
* $1 \leq n \leq 9$
Input
An integer $n$ is given in a line.
Output
Print each permutation in a line in order. Separate adjacency elements by a space character.
Examples
Input
2
Output
1 2
2 1
Input
3
Output
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1 | instruction | 0 | 71,617 | 12 | 143,234 |
"Correct Solution:
```
from itertools import permutations
n = int(input())
p = permutations([str(x) for x in range(1, n+1)], n)
[print(' '.join(x)) for x in p]
``` | output | 1 | 71,617 | 12 | 143,235 |
Provide a correct Python 3 solution for this coding contest problem.
For given an integer $n$, print all permutations of $\\{1, 2, ..., n\\}$ in lexicographic order.
Constraints
* $1 \leq n \leq 9$
Input
An integer $n$ is given in a line.
Output
Print each permutation in a line in order. Separate adjacency elements by a space character.
Examples
Input
2
Output
1 2
2 1
Input
3
Output
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1 | instruction | 0 | 71,618 | 12 | 143,236 |
"Correct Solution:
```
def resolve():
import itertools
n = int(input())
for a in itertools.permutations(list(range(1, n + 1))):
print(*a)
resolve()
``` | output | 1 | 71,618 | 12 | 143,237 |
Provide a correct Python 3 solution for this coding contest problem.
For given an integer $n$, print all permutations of $\\{1, 2, ..., n\\}$ in lexicographic order.
Constraints
* $1 \leq n \leq 9$
Input
An integer $n$ is given in a line.
Output
Print each permutation in a line in order. Separate adjacency elements by a space character.
Examples
Input
2
Output
1 2
2 1
Input
3
Output
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1 | instruction | 0 | 71,619 | 12 | 143,238 |
"Correct Solution:
```
from itertools import permutations
n = int(input())
l = list(range(1, n+1))
for v in permutations(l):
print(*v)
``` | output | 1 | 71,619 | 12 | 143,239 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For given an integer $n$, print all permutations of $\\{1, 2, ..., n\\}$ in lexicographic order.
Constraints
* $1 \leq n \leq 9$
Input
An integer $n$ is given in a line.
Output
Print each permutation in a line in order. Separate adjacency elements by a space character.
Examples
Input
2
Output
1 2
2 1
Input
3
Output
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
Submitted Solution:
```
# http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ITP2_5_D&lang=jp
# Permutation Enumeration : python3
# 2018.12.01 yonezawa
import sys
input = sys.stdin.readline
from collections import deque
class enumeration:
def __init__(self,n):
self.n = n
self.depth = 0
self.wnum = 0
self.nq = []
self.bits = [ pow(2,i) for i in range(n+1) ]
self.mk_permutation(0,0,0)
def mk_permutation(self,depth,bflag,wnum):
if self.n == depth:
self.nq.append(wnum)
return
for i in range(1,self.n+1):
if bflag & self.bits[i-1] != 0:
continue
self.mk_permutation(depth + 1,bflag + self.bits[i-1],wnum*10+i)
def printList(self):
l = self.nq
self.nq.sort()
for i in l:
c = ""
for j in str(i):
c += j + " "
print(c.strip())
def main():
n = int(input())
i = enumeration(n)
i.printList()
if __name__ == '__main__':
main()
``` | instruction | 0 | 71,620 | 12 | 143,240 |
Yes | output | 1 | 71,620 | 12 | 143,241 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of integers. Vasya can permute (change order) its integers. He wants to do it so that as many as possible integers will become on a place where a smaller integer used to stand. Help Vasya find the maximal number of such integers.
For instance, if we are given an array [10, 20, 30, 40], we can permute it so that it becomes [20, 40, 10, 30]. Then on the first and the second positions the integers became larger (20>10, 40>20) and did not on the third and the fourth, so for this permutation, the number that Vasya wants to maximize equals 2. Read the note for the first example, there is one more demonstrative test case.
Help Vasya to permute integers in such way that the number of positions in a new array, where integers are greater than in the original one, is maximal.
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) β the elements of the array.
Output
Print a single integer β the maximal number of the array's elements which after a permutation will stand on the position where a smaller element stood in the initial array.
Examples
Input
7
10 1 1 1 5 5 3
Output
4
Input
5
1 1 1 1 1
Output
0
Note
In the first sample, one of the best permutations is [1, 5, 5, 3, 10, 1, 1]. On the positions from second to fifth the elements became larger, so the answer for this permutation is 4.
In the second sample, there is no way to increase any element with a permutation, so the answer is 0. | instruction | 0 | 71,624 | 12 | 143,248 |
Tags: combinatorics, data structures, math, sortings, two pointers
Correct Solution:
```
from collections import Counter
n = int(input())
a = list(map(int, input().split()))
c = Counter(a)
res = 0
cur = 0
for i in sorted(c.keys()):
d = min(c[i], cur)
cur -= d
res += d
cur += c[i]
print(res)
``` | output | 1 | 71,624 | 12 | 143,249 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of integers. Vasya can permute (change order) its integers. He wants to do it so that as many as possible integers will become on a place where a smaller integer used to stand. Help Vasya find the maximal number of such integers.
For instance, if we are given an array [10, 20, 30, 40], we can permute it so that it becomes [20, 40, 10, 30]. Then on the first and the second positions the integers became larger (20>10, 40>20) and did not on the third and the fourth, so for this permutation, the number that Vasya wants to maximize equals 2. Read the note for the first example, there is one more demonstrative test case.
Help Vasya to permute integers in such way that the number of positions in a new array, where integers are greater than in the original one, is maximal.
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) β the elements of the array.
Output
Print a single integer β the maximal number of the array's elements which after a permutation will stand on the position where a smaller element stood in the initial array.
Examples
Input
7
10 1 1 1 5 5 3
Output
4
Input
5
1 1 1 1 1
Output
0
Note
In the first sample, one of the best permutations is [1, 5, 5, 3, 10, 1, 1]. On the positions from second to fifth the elements became larger, so the answer for this permutation is 4.
In the second sample, there is no way to increase any element with a permutation, so the answer is 0. | instruction | 0 | 71,625 | 12 | 143,250 |
Tags: combinatorics, data structures, math, sortings, two pointers
Correct Solution:
```
mod = 1000000007
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
n=ii()
l=sorted(il())
i=0
j=0
c=0
while i<n and j<n:
if l[j]>l[i]:
i+=1
c+=1
j+=1
print(c)
``` | output | 1 | 71,625 | 12 | 143,251 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of integers. Vasya can permute (change order) its integers. He wants to do it so that as many as possible integers will become on a place where a smaller integer used to stand. Help Vasya find the maximal number of such integers.
For instance, if we are given an array [10, 20, 30, 40], we can permute it so that it becomes [20, 40, 10, 30]. Then on the first and the second positions the integers became larger (20>10, 40>20) and did not on the third and the fourth, so for this permutation, the number that Vasya wants to maximize equals 2. Read the note for the first example, there is one more demonstrative test case.
Help Vasya to permute integers in such way that the number of positions in a new array, where integers are greater than in the original one, is maximal.
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) β the elements of the array.
Output
Print a single integer β the maximal number of the array's elements which after a permutation will stand on the position where a smaller element stood in the initial array.
Examples
Input
7
10 1 1 1 5 5 3
Output
4
Input
5
1 1 1 1 1
Output
0
Note
In the first sample, one of the best permutations is [1, 5, 5, 3, 10, 1, 1]. On the positions from second to fifth the elements became larger, so the answer for this permutation is 4.
In the second sample, there is no way to increase any element with a permutation, so the answer is 0. | instruction | 0 | 71,626 | 12 | 143,252 |
Tags: combinatorics, data structures, math, sortings, two pointers
Correct Solution:
```
#https://codeforces.com/problemset/problem/1007/A
n=int(input())
l=list(map(int,input().split()))
l.sort()
x={}
for i in l:
if i in x:
x[i]+=1
else:
x[i]=1
print(n-max(x.values()))
``` | output | 1 | 71,626 | 12 | 143,253 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of integers. Vasya can permute (change order) its integers. He wants to do it so that as many as possible integers will become on a place where a smaller integer used to stand. Help Vasya find the maximal number of such integers.
For instance, if we are given an array [10, 20, 30, 40], we can permute it so that it becomes [20, 40, 10, 30]. Then on the first and the second positions the integers became larger (20>10, 40>20) and did not on the third and the fourth, so for this permutation, the number that Vasya wants to maximize equals 2. Read the note for the first example, there is one more demonstrative test case.
Help Vasya to permute integers in such way that the number of positions in a new array, where integers are greater than in the original one, is maximal.
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) β the elements of the array.
Output
Print a single integer β the maximal number of the array's elements which after a permutation will stand on the position where a smaller element stood in the initial array.
Examples
Input
7
10 1 1 1 5 5 3
Output
4
Input
5
1 1 1 1 1
Output
0
Note
In the first sample, one of the best permutations is [1, 5, 5, 3, 10, 1, 1]. On the positions from second to fifth the elements became larger, so the answer for this permutation is 4.
In the second sample, there is no way to increase any element with a permutation, so the answer is 0. | instruction | 0 | 71,627 | 12 | 143,254 |
Tags: combinatorics, data structures, math, sortings, two pointers
Correct Solution:
```
n = int(input())
a = [*map(int, input().split())]
cur = n - 1
res = 0
a.sort()
for i in range(n - 1, 0, -1):
while cur >= 0 and a[i] <= a[cur]:
cur -= 1
if cur >= 0 and a[i] > a[cur]:
res += 1
cur -= 1
print(res)
``` | output | 1 | 71,627 | 12 | 143,255 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of integers. Vasya can permute (change order) its integers. He wants to do it so that as many as possible integers will become on a place where a smaller integer used to stand. Help Vasya find the maximal number of such integers.
For instance, if we are given an array [10, 20, 30, 40], we can permute it so that it becomes [20, 40, 10, 30]. Then on the first and the second positions the integers became larger (20>10, 40>20) and did not on the third and the fourth, so for this permutation, the number that Vasya wants to maximize equals 2. Read the note for the first example, there is one more demonstrative test case.
Help Vasya to permute integers in such way that the number of positions in a new array, where integers are greater than in the original one, is maximal.
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) β the elements of the array.
Output
Print a single integer β the maximal number of the array's elements which after a permutation will stand on the position where a smaller element stood in the initial array.
Examples
Input
7
10 1 1 1 5 5 3
Output
4
Input
5
1 1 1 1 1
Output
0
Note
In the first sample, one of the best permutations is [1, 5, 5, 3, 10, 1, 1]. On the positions from second to fifth the elements became larger, so the answer for this permutation is 4.
In the second sample, there is no way to increase any element with a permutation, so the answer is 0. | instruction | 0 | 71,628 | 12 | 143,256 |
Tags: combinatorics, data structures, math, sortings, two pointers
Correct Solution:
```
from collections import Counter
length = int(input())
array = list(map(int, input().split()))
dic = Counter(array)
value_list = list(dic.values())
print(len(array) - max(value_list))
``` | output | 1 | 71,628 | 12 | 143,257 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of integers. Vasya can permute (change order) its integers. He wants to do it so that as many as possible integers will become on a place where a smaller integer used to stand. Help Vasya find the maximal number of such integers.
For instance, if we are given an array [10, 20, 30, 40], we can permute it so that it becomes [20, 40, 10, 30]. Then on the first and the second positions the integers became larger (20>10, 40>20) and did not on the third and the fourth, so for this permutation, the number that Vasya wants to maximize equals 2. Read the note for the first example, there is one more demonstrative test case.
Help Vasya to permute integers in such way that the number of positions in a new array, where integers are greater than in the original one, is maximal.
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) β the elements of the array.
Output
Print a single integer β the maximal number of the array's elements which after a permutation will stand on the position where a smaller element stood in the initial array.
Examples
Input
7
10 1 1 1 5 5 3
Output
4
Input
5
1 1 1 1 1
Output
0
Note
In the first sample, one of the best permutations is [1, 5, 5, 3, 10, 1, 1]. On the positions from second to fifth the elements became larger, so the answer for this permutation is 4.
In the second sample, there is no way to increase any element with a permutation, so the answer is 0. | instruction | 0 | 71,629 | 12 | 143,258 |
Tags: combinatorics, data structures, math, sortings, two pointers
Correct Solution:
```
n = int(input())
a = [int(i) for i in input().split()]
fr = [0 for i in range(n)]
a.sort()
mx = a[0]
fr[0]=1
idx = 0
for i in a[1:]:
if i>mx:
mx=i
idx+=1
fr[idx]=1
else:
fr[idx]+=1
lt = [0 for i in range(0, idx+1)]
res = 0
done = 0
for i in range(1, idx+1):
lt[i] = lt[i-1] + fr[i-1]
res += max(min(lt[i]-done,fr[i]),0)
done += max(min(lt[i]-done,fr[i]),0)
print(res)
``` | output | 1 | 71,629 | 12 | 143,259 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of integers. Vasya can permute (change order) its integers. He wants to do it so that as many as possible integers will become on a place where a smaller integer used to stand. Help Vasya find the maximal number of such integers.
For instance, if we are given an array [10, 20, 30, 40], we can permute it so that it becomes [20, 40, 10, 30]. Then on the first and the second positions the integers became larger (20>10, 40>20) and did not on the third and the fourth, so for this permutation, the number that Vasya wants to maximize equals 2. Read the note for the first example, there is one more demonstrative test case.
Help Vasya to permute integers in such way that the number of positions in a new array, where integers are greater than in the original one, is maximal.
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) β the elements of the array.
Output
Print a single integer β the maximal number of the array's elements which after a permutation will stand on the position where a smaller element stood in the initial array.
Examples
Input
7
10 1 1 1 5 5 3
Output
4
Input
5
1 1 1 1 1
Output
0
Note
In the first sample, one of the best permutations is [1, 5, 5, 3, 10, 1, 1]. On the positions from second to fifth the elements became larger, so the answer for this permutation is 4.
In the second sample, there is no way to increase any element with a permutation, so the answer is 0. | instruction | 0 | 71,630 | 12 | 143,260 |
Tags: combinatorics, data structures, math, sortings, two pointers
Correct Solution:
```
z,zz=input,lambda:list(map(int,z().split()))
fast=lambda:stdin.readline().strip()
zzz=lambda:[int(i) for i in fast().split()]
szz,graph,mod,szzz=lambda:sorted(zz()),{},10**9+7,lambda:sorted(zzz())
from string import *
from re import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac
def lcd(xnum1,xnum2):return (xnum1*xnum2//gcd(xnum1,xnum2))
def prime(x):
p=ceil(x**.5)+1
for i in range(2,p):
if (x%i==0 and x!=2) or x==0:return 0
return 1
def dfs(u,visit,graph):
visit[u]=1
for i in graph[u]:
if not visit[i]:
dfs(i,visit,graph)
def output(answer):
stdout.write(str(answer) + '\n')
###########################---Test-Case---#################################
"""
If you Know me , Then you probably don't know me !
"""
###########################---START-CODING---##############################
n=int(z())
arr=zzz()
d={}
for i in arr:
try:d[i]
except:d[i]=0
d[i]+=1
mx=max(d.values())
print(n-mx)
``` | output | 1 | 71,630 | 12 | 143,261 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array of integers. Vasya can permute (change order) its integers. He wants to do it so that as many as possible integers will become on a place where a smaller integer used to stand. Help Vasya find the maximal number of such integers.
For instance, if we are given an array [10, 20, 30, 40], we can permute it so that it becomes [20, 40, 10, 30]. Then on the first and the second positions the integers became larger (20>10, 40>20) and did not on the third and the fourth, so for this permutation, the number that Vasya wants to maximize equals 2. Read the note for the first example, there is one more demonstrative test case.
Help Vasya to permute integers in such way that the number of positions in a new array, where integers are greater than in the original one, is maximal.
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) β the elements of the array.
Output
Print a single integer β the maximal number of the array's elements which after a permutation will stand on the position where a smaller element stood in the initial array.
Examples
Input
7
10 1 1 1 5 5 3
Output
4
Input
5
1 1 1 1 1
Output
0
Note
In the first sample, one of the best permutations is [1, 5, 5, 3, 10, 1, 1]. On the positions from second to fifth the elements became larger, so the answer for this permutation is 4.
In the second sample, there is no way to increase any element with a permutation, so the answer is 0. | instruction | 0 | 71,631 | 12 | 143,262 |
Tags: combinatorics, data structures, math, sortings, two pointers
Correct Solution:
```
import sys
from collections import deque,defaultdict
I=sys.stdin.readline
def ii():
return int(I().strip())
def li():
return list(map(int,I().strip().split()))
def main():
n=ii()
arr=sorted(li())
i=0
j=1
if n==1:
print(0)
else:
cnt=0
while j<n:
if arr[i]<arr[j]:
cnt+=1
i+=1
j+=1
print(cnt)
if __name__ == '__main__':
main()
``` | output | 1 | 71,631 | 12 | 143,263 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of integers. Vasya can permute (change order) its integers. He wants to do it so that as many as possible integers will become on a place where a smaller integer used to stand. Help Vasya find the maximal number of such integers.
For instance, if we are given an array [10, 20, 30, 40], we can permute it so that it becomes [20, 40, 10, 30]. Then on the first and the second positions the integers became larger (20>10, 40>20) and did not on the third and the fourth, so for this permutation, the number that Vasya wants to maximize equals 2. Read the note for the first example, there is one more demonstrative test case.
Help Vasya to permute integers in such way that the number of positions in a new array, where integers are greater than in the original one, is maximal.
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) β the elements of the array.
Output
Print a single integer β the maximal number of the array's elements which after a permutation will stand on the position where a smaller element stood in the initial array.
Examples
Input
7
10 1 1 1 5 5 3
Output
4
Input
5
1 1 1 1 1
Output
0
Note
In the first sample, one of the best permutations is [1, 5, 5, 3, 10, 1, 1]. On the positions from second to fifth the elements became larger, so the answer for this permutation is 4.
In the second sample, there is no way to increase any element with a permutation, so the answer is 0.
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
b = [i for i in a]
a.sort()
b.sort()
c = 0
j = 0
for i in b:
if i > a[j]:
c += 1
j += 1
print (c)
``` | instruction | 0 | 71,632 | 12 | 143,264 |
Yes | output | 1 | 71,632 | 12 | 143,265 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of integers. Vasya can permute (change order) its integers. He wants to do it so that as many as possible integers will become on a place where a smaller integer used to stand. Help Vasya find the maximal number of such integers.
For instance, if we are given an array [10, 20, 30, 40], we can permute it so that it becomes [20, 40, 10, 30]. Then on the first and the second positions the integers became larger (20>10, 40>20) and did not on the third and the fourth, so for this permutation, the number that Vasya wants to maximize equals 2. Read the note for the first example, there is one more demonstrative test case.
Help Vasya to permute integers in such way that the number of positions in a new array, where integers are greater than in the original one, is maximal.
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) β the elements of the array.
Output
Print a single integer β the maximal number of the array's elements which after a permutation will stand on the position where a smaller element stood in the initial array.
Examples
Input
7
10 1 1 1 5 5 3
Output
4
Input
5
1 1 1 1 1
Output
0
Note
In the first sample, one of the best permutations is [1, 5, 5, 3, 10, 1, 1]. On the positions from second to fifth the elements became larger, so the answer for this permutation is 4.
In the second sample, there is no way to increase any element with a permutation, so the answer is 0.
Submitted Solution:
```
from collections import defaultdict,Counter,deque
read = lambda: list(map(int,input().split()))
getinfo = lambda grid: print(list(map(print,grid)))
p = lambda x: print(x,end=" ")
inf = float('inf')
mod = 10**9+7
n = int(input())
a = read()
d = Counter(a)
v = sorted(d.keys(),reverse=True)
a.sort(reverse=True)
res,j = 0,0
for i in range(n):
while j < len(v) and a[i] <= v[j]:
j += 1
if j >= len(v): break
d[v[j]] -= 1
res += 1
if d[v[j]] == 0: j += 1
print(res)
``` | instruction | 0 | 71,633 | 12 | 143,266 |
Yes | output | 1 | 71,633 | 12 | 143,267 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of integers. Vasya can permute (change order) its integers. He wants to do it so that as many as possible integers will become on a place where a smaller integer used to stand. Help Vasya find the maximal number of such integers.
For instance, if we are given an array [10, 20, 30, 40], we can permute it so that it becomes [20, 40, 10, 30]. Then on the first and the second positions the integers became larger (20>10, 40>20) and did not on the third and the fourth, so for this permutation, the number that Vasya wants to maximize equals 2. Read the note for the first example, there is one more demonstrative test case.
Help Vasya to permute integers in such way that the number of positions in a new array, where integers are greater than in the original one, is maximal.
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) β the elements of the array.
Output
Print a single integer β the maximal number of the array's elements which after a permutation will stand on the position where a smaller element stood in the initial array.
Examples
Input
7
10 1 1 1 5 5 3
Output
4
Input
5
1 1 1 1 1
Output
0
Note
In the first sample, one of the best permutations is [1, 5, 5, 3, 10, 1, 1]. On the positions from second to fifth the elements became larger, so the answer for this permutation is 4.
In the second sample, there is no way to increase any element with a permutation, so the answer is 0.
Submitted Solution:
```
x=int(input())
listik=list(map(int,input().split()))
listik.sort()
counter=0
for i in range(1,len(listik)):
if listik[counter]<listik[i]:
counter+=1
print(counter)
``` | instruction | 0 | 71,634 | 12 | 143,268 |
Yes | output | 1 | 71,634 | 12 | 143,269 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of integers. Vasya can permute (change order) its integers. He wants to do it so that as many as possible integers will become on a place where a smaller integer used to stand. Help Vasya find the maximal number of such integers.
For instance, if we are given an array [10, 20, 30, 40], we can permute it so that it becomes [20, 40, 10, 30]. Then on the first and the second positions the integers became larger (20>10, 40>20) and did not on the third and the fourth, so for this permutation, the number that Vasya wants to maximize equals 2. Read the note for the first example, there is one more demonstrative test case.
Help Vasya to permute integers in such way that the number of positions in a new array, where integers are greater than in the original one, is maximal.
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) β the elements of the array.
Output
Print a single integer β the maximal number of the array's elements which after a permutation will stand on the position where a smaller element stood in the initial array.
Examples
Input
7
10 1 1 1 5 5 3
Output
4
Input
5
1 1 1 1 1
Output
0
Note
In the first sample, one of the best permutations is [1, 5, 5, 3, 10, 1, 1]. On the positions from second to fifth the elements became larger, so the answer for this permutation is 4.
In the second sample, there is no way to increase any element with a permutation, so the answer is 0.
Submitted Solution:
```
def solution(n, num_array):
# If there is only one element in the list, return 0.
# import pdb; pdb.set_trace
if (len(num_array) == 1):
return 0
# sort the array first
num_array.sort()
idx1 = 0
idx2 = 1
res = 0
while (idx2 < len(num_array)):
num1 = num_array[idx1]
num2 = num_array[idx2]
if (num1 < num2):
# swap the numbers
res += 1
idx1 += 1
idx2 += 1
else:
idx2 += 1
# print(sorted_arr)
return res
n = input()
num_array = list(map(int, input().split()))
print(solution(n, num_array))
``` | instruction | 0 | 71,635 | 12 | 143,270 |
Yes | output | 1 | 71,635 | 12 | 143,271 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of integers. Vasya can permute (change order) its integers. He wants to do it so that as many as possible integers will become on a place where a smaller integer used to stand. Help Vasya find the maximal number of such integers.
For instance, if we are given an array [10, 20, 30, 40], we can permute it so that it becomes [20, 40, 10, 30]. Then on the first and the second positions the integers became larger (20>10, 40>20) and did not on the third and the fourth, so for this permutation, the number that Vasya wants to maximize equals 2. Read the note for the first example, there is one more demonstrative test case.
Help Vasya to permute integers in such way that the number of positions in a new array, where integers are greater than in the original one, is maximal.
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) β the elements of the array.
Output
Print a single integer β the maximal number of the array's elements which after a permutation will stand on the position where a smaller element stood in the initial array.
Examples
Input
7
10 1 1 1 5 5 3
Output
4
Input
5
1 1 1 1 1
Output
0
Note
In the first sample, one of the best permutations is [1, 5, 5, 3, 10, 1, 1]. On the positions from second to fifth the elements became larger, so the answer for this permutation is 4.
In the second sample, there is no way to increase any element with a permutation, so the answer is 0.
Submitted Solution:
```
from bisect import bisect_left
from collections import defaultdict
al=defaultdict(int)
a=int(input())
z=list(map(int,input().split()))
z.sort()
fre=defaultdict(int)
for i in range(len(z)):
fre[z[i]]+=1
count=0
for i in range(len(z)-1,0,-1):
if(al[z[i]]==0):
al[z[i]]=1
count+=min(bisect_left(z,z[i]),fre[z[i]])
print(bisect_left(z,z[i]),fre[z[i]])
print(min(count,len(z)-fre[max(z)]))
``` | instruction | 0 | 71,636 | 12 | 143,272 |
No | output | 1 | 71,636 | 12 | 143,273 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of integers. Vasya can permute (change order) its integers. He wants to do it so that as many as possible integers will become on a place where a smaller integer used to stand. Help Vasya find the maximal number of such integers.
For instance, if we are given an array [10, 20, 30, 40], we can permute it so that it becomes [20, 40, 10, 30]. Then on the first and the second positions the integers became larger (20>10, 40>20) and did not on the third and the fourth, so for this permutation, the number that Vasya wants to maximize equals 2. Read the note for the first example, there is one more demonstrative test case.
Help Vasya to permute integers in such way that the number of positions in a new array, where integers are greater than in the original one, is maximal.
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) β the elements of the array.
Output
Print a single integer β the maximal number of the array's elements which after a permutation will stand on the position where a smaller element stood in the initial array.
Examples
Input
7
10 1 1 1 5 5 3
Output
4
Input
5
1 1 1 1 1
Output
0
Note
In the first sample, one of the best permutations is [1, 5, 5, 3, 10, 1, 1]. On the positions from second to fifth the elements became larger, so the answer for this permutation is 4.
In the second sample, there is no way to increase any element with a permutation, so the answer is 0.
Submitted Solution:
```
from collections import Counter
def main():
input()
cnt = Counter(map(int, input().split()))
a, *rest = sorted(cnt.keys())
pool, res = cnt[a], 0
for a in rest:
c = cnt[a]
if pool < c:
res += pool
pool = c - pool
else:
res += c
print(res)
if __name__ == '__main__':
main()
``` | instruction | 0 | 71,637 | 12 | 143,274 |
No | output | 1 | 71,637 | 12 | 143,275 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of integers. Vasya can permute (change order) its integers. He wants to do it so that as many as possible integers will become on a place where a smaller integer used to stand. Help Vasya find the maximal number of such integers.
For instance, if we are given an array [10, 20, 30, 40], we can permute it so that it becomes [20, 40, 10, 30]. Then on the first and the second positions the integers became larger (20>10, 40>20) and did not on the third and the fourth, so for this permutation, the number that Vasya wants to maximize equals 2. Read the note for the first example, there is one more demonstrative test case.
Help Vasya to permute integers in such way that the number of positions in a new array, where integers are greater than in the original one, is maximal.
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) β the elements of the array.
Output
Print a single integer β the maximal number of the array's elements which after a permutation will stand on the position where a smaller element stood in the initial array.
Examples
Input
7
10 1 1 1 5 5 3
Output
4
Input
5
1 1 1 1 1
Output
0
Note
In the first sample, one of the best permutations is [1, 5, 5, 3, 10, 1, 1]. On the positions from second to fifth the elements became larger, so the answer for this permutation is 4.
In the second sample, there is no way to increase any element with a permutation, so the answer is 0.
Submitted Solution:
```
n = int(input())
l1 = list(map(int, input().split()))
l2 = []
for i in l1:
l2.append(i)
l2.sort()
ss = 0
for i in range(n):
if l2[i] != l2[0]:
ss = i
break
ans = 0
for i in range(n):
if ss == n: break
if l2[i] < l2[ss]: ans += 1
ss += 1
print(ans)
``` | instruction | 0 | 71,638 | 12 | 143,276 |
No | output | 1 | 71,638 | 12 | 143,277 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array of integers. Vasya can permute (change order) its integers. He wants to do it so that as many as possible integers will become on a place where a smaller integer used to stand. Help Vasya find the maximal number of such integers.
For instance, if we are given an array [10, 20, 30, 40], we can permute it so that it becomes [20, 40, 10, 30]. Then on the first and the second positions the integers became larger (20>10, 40>20) and did not on the third and the fourth, so for this permutation, the number that Vasya wants to maximize equals 2. Read the note for the first example, there is one more demonstrative test case.
Help Vasya to permute integers in such way that the number of positions in a new array, where integers are greater than in the original one, is maximal.
Input
The first line contains a single integer n (1 β€ n β€ 10^5) β the length of the array.
The second line contains n integers a_1, a_2, β¦, a_n (1 β€ a_i β€ 10^9) β the elements of the array.
Output
Print a single integer β the maximal number of the array's elements which after a permutation will stand on the position where a smaller element stood in the initial array.
Examples
Input
7
10 1 1 1 5 5 3
Output
4
Input
5
1 1 1 1 1
Output
0
Note
In the first sample, one of the best permutations is [1, 5, 5, 3, 10, 1, 1]. On the positions from second to fifth the elements became larger, so the answer for this permutation is 4.
In the second sample, there is no way to increase any element with a permutation, so the answer is 0.
Submitted Solution:
```
n = int(input())
l = list(map(int,input().split()))
l.sort()
i = 1
stack = [l[0]]
c = 0
# print(l)
while i < n-1:
# print(stack)
# print(i)
stack.append(l[i+1])
if l[i] != l[i+1]:
while i < n and len(stack) > 1:
# print(stack)
stack.pop()
stack.pop()
i = i + 1
c = c + 2
# t = t + 1
# i = j
i = i + 1
if i == n-1:
break
print(c)
``` | instruction | 0 | 71,639 | 12 | 143,278 |
No | output | 1 | 71,639 | 12 | 143,279 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Phoenix loves beautiful arrays. An array is beautiful if all its subarrays of length k have the same sum. A subarray of an array is any sequence of consecutive elements.
Phoenix currently has an array a of length n. He wants to insert some number of integers, possibly zero, into his array such that it becomes beautiful. The inserted integers must be between 1 and n inclusive. Integers may be inserted anywhere (even before the first or after the last element), and he is not trying to minimize the number of inserted integers.
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 50) β the number of test cases.
The first line of each test case contains two integers n and k (1 β€ k β€ n β€ 100).
The second line of each test case contains n space-separated integers (1 β€ a_i β€ n) β the array that Phoenix currently has. This array may or may not be already beautiful.
Output
For each test case, if it is impossible to create a beautiful array, print -1. Otherwise, print two lines.
The first line should contain the length of the beautiful array m (n β€ m β€ 10^4). You don't need to minimize m.
The second line should contain m space-separated integers (1 β€ b_i β€ n) β a beautiful array that Phoenix can obtain after inserting some, possibly zero, integers into his array a. You may print integers that weren't originally in array a.
If there are multiple solutions, print any. It's guaranteed that if we can make array a beautiful, we can always make it with resulting length no more than 10^4.
Example
Input
4
4 2
1 2 2 1
4 3
1 2 2 1
3 2
1 2 3
4 4
4 3 4 2
Output
5
1 2 1 2 1
4
1 2 2 1
-1
7
4 3 2 1 4 3 2
Note
In the first test case, we can make array a beautiful by inserting the integer 1 at index 3 (in between the two existing 2s). Now, all subarrays of length k=2 have the same sum 3. There exists many other possible solutions, for example:
* 2, 1, 2, 1, 2, 1
* 1, 2, 1, 2, 1, 2
In the second test case, the array is already beautiful: all subarrays of length k=3 have the same sum 5.
In the third test case, it can be shown that we cannot insert numbers to make array a beautiful.
In the fourth test case, the array b shown is beautiful and all subarrays of length k=4 have the same sum 10. There exist other solutions also. | instruction | 0 | 71,821 | 12 | 143,642 |
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
T = int(input())
while T != 0:
n, k = map(int,input().split())
numbers = list(map(int,input().split()))
# distinct numbers
dn = set(numbers)
dn_num = len(dn)
if dn_num > k:
print('-1')
T -= 1
continue
else:
fa = []
for i in dn:
fa.append(i)
while len(fa) < k:
fa.append(1)
fa = fa * n
print(len(fa))
print(' '.join([str(e) for e in fa]))
T -= 1
``` | output | 1 | 71,821 | 12 | 143,643 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Phoenix loves beautiful arrays. An array is beautiful if all its subarrays of length k have the same sum. A subarray of an array is any sequence of consecutive elements.
Phoenix currently has an array a of length n. He wants to insert some number of integers, possibly zero, into his array such that it becomes beautiful. The inserted integers must be between 1 and n inclusive. Integers may be inserted anywhere (even before the first or after the last element), and he is not trying to minimize the number of inserted integers.
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 50) β the number of test cases.
The first line of each test case contains two integers n and k (1 β€ k β€ n β€ 100).
The second line of each test case contains n space-separated integers (1 β€ a_i β€ n) β the array that Phoenix currently has. This array may or may not be already beautiful.
Output
For each test case, if it is impossible to create a beautiful array, print -1. Otherwise, print two lines.
The first line should contain the length of the beautiful array m (n β€ m β€ 10^4). You don't need to minimize m.
The second line should contain m space-separated integers (1 β€ b_i β€ n) β a beautiful array that Phoenix can obtain after inserting some, possibly zero, integers into his array a. You may print integers that weren't originally in array a.
If there are multiple solutions, print any. It's guaranteed that if we can make array a beautiful, we can always make it with resulting length no more than 10^4.
Example
Input
4
4 2
1 2 2 1
4 3
1 2 2 1
3 2
1 2 3
4 4
4 3 4 2
Output
5
1 2 1 2 1
4
1 2 2 1
-1
7
4 3 2 1 4 3 2
Note
In the first test case, we can make array a beautiful by inserting the integer 1 at index 3 (in between the two existing 2s). Now, all subarrays of length k=2 have the same sum 3. There exists many other possible solutions, for example:
* 2, 1, 2, 1, 2, 1
* 1, 2, 1, 2, 1, 2
In the second test case, the array is already beautiful: all subarrays of length k=3 have the same sum 5.
In the third test case, it can be shown that we cannot insert numbers to make array a beautiful.
In the fourth test case, the array b shown is beautiful and all subarrays of length k=4 have the same sum 10. There exist other solutions also. | instruction | 0 | 71,822 | 12 | 143,644 |
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
import sys
#from math import *
def eprint(*args):
print(*args, file=sys.stderr)
zz=1
if zz:
input=sys.stdin.readline
else:
sys.stdin=open('input.txt', 'r')
sys.stdout=open('output2.txt','w')
t=int(input())
while t>0:
t-=1
n,k=map(int,input().split())
a=[int(x) for x in input().split()]
if len(set(a))>k:
print(-1)
continue
s=list(set(a))
for i in range(k-len(s)):
s.insert(0,1)
print(n*len(s))
for i in range(n):
print(*s,end=" ")
print()
``` | output | 1 | 71,822 | 12 | 143,645 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Phoenix loves beautiful arrays. An array is beautiful if all its subarrays of length k have the same sum. A subarray of an array is any sequence of consecutive elements.
Phoenix currently has an array a of length n. He wants to insert some number of integers, possibly zero, into his array such that it becomes beautiful. The inserted integers must be between 1 and n inclusive. Integers may be inserted anywhere (even before the first or after the last element), and he is not trying to minimize the number of inserted integers.
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 50) β the number of test cases.
The first line of each test case contains two integers n and k (1 β€ k β€ n β€ 100).
The second line of each test case contains n space-separated integers (1 β€ a_i β€ n) β the array that Phoenix currently has. This array may or may not be already beautiful.
Output
For each test case, if it is impossible to create a beautiful array, print -1. Otherwise, print two lines.
The first line should contain the length of the beautiful array m (n β€ m β€ 10^4). You don't need to minimize m.
The second line should contain m space-separated integers (1 β€ b_i β€ n) β a beautiful array that Phoenix can obtain after inserting some, possibly zero, integers into his array a. You may print integers that weren't originally in array a.
If there are multiple solutions, print any. It's guaranteed that if we can make array a beautiful, we can always make it with resulting length no more than 10^4.
Example
Input
4
4 2
1 2 2 1
4 3
1 2 2 1
3 2
1 2 3
4 4
4 3 4 2
Output
5
1 2 1 2 1
4
1 2 2 1
-1
7
4 3 2 1 4 3 2
Note
In the first test case, we can make array a beautiful by inserting the integer 1 at index 3 (in between the two existing 2s). Now, all subarrays of length k=2 have the same sum 3. There exists many other possible solutions, for example:
* 2, 1, 2, 1, 2, 1
* 1, 2, 1, 2, 1, 2
In the second test case, the array is already beautiful: all subarrays of length k=3 have the same sum 5.
In the third test case, it can be shown that we cannot insert numbers to make array a beautiful.
In the fourth test case, the array b shown is beautiful and all subarrays of length k=4 have the same sum 10. There exist other solutions also. | instruction | 0 | 71,823 | 12 | 143,646 |
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
from itertools import *
from collections import *
for _ in range(int(input())):
n,k = map(int,input().split())
l = [*map(int,input().split())]
s = set(l)
if(len(s) > k):
print(-1)
else:
ans = deque()
arr = []
for i in s:
arr.append(i)
ans.append(i)
for i in range(k - len(s)):
arr.append(l[i])
ans.append(l[i])
j = k - len(s)
#print("J = ",j)
while(j < n):
if(ans[0] == l[j]):
ans.popleft()
ans.append(l[j])
arr.append(l[j])
j += 1
continue
arr.append(ans[0])
ans.append(ans[0])
ans.popleft()
print(len(arr))
print(*arr)
``` | output | 1 | 71,823 | 12 | 143,647 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Phoenix loves beautiful arrays. An array is beautiful if all its subarrays of length k have the same sum. A subarray of an array is any sequence of consecutive elements.
Phoenix currently has an array a of length n. He wants to insert some number of integers, possibly zero, into his array such that it becomes beautiful. The inserted integers must be between 1 and n inclusive. Integers may be inserted anywhere (even before the first or after the last element), and he is not trying to minimize the number of inserted integers.
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 50) β the number of test cases.
The first line of each test case contains two integers n and k (1 β€ k β€ n β€ 100).
The second line of each test case contains n space-separated integers (1 β€ a_i β€ n) β the array that Phoenix currently has. This array may or may not be already beautiful.
Output
For each test case, if it is impossible to create a beautiful array, print -1. Otherwise, print two lines.
The first line should contain the length of the beautiful array m (n β€ m β€ 10^4). You don't need to minimize m.
The second line should contain m space-separated integers (1 β€ b_i β€ n) β a beautiful array that Phoenix can obtain after inserting some, possibly zero, integers into his array a. You may print integers that weren't originally in array a.
If there are multiple solutions, print any. It's guaranteed that if we can make array a beautiful, we can always make it with resulting length no more than 10^4.
Example
Input
4
4 2
1 2 2 1
4 3
1 2 2 1
3 2
1 2 3
4 4
4 3 4 2
Output
5
1 2 1 2 1
4
1 2 2 1
-1
7
4 3 2 1 4 3 2
Note
In the first test case, we can make array a beautiful by inserting the integer 1 at index 3 (in between the two existing 2s). Now, all subarrays of length k=2 have the same sum 3. There exists many other possible solutions, for example:
* 2, 1, 2, 1, 2, 1
* 1, 2, 1, 2, 1, 2
In the second test case, the array is already beautiful: all subarrays of length k=3 have the same sum 5.
In the third test case, it can be shown that we cannot insert numbers to make array a beautiful.
In the fourth test case, the array b shown is beautiful and all subarrays of length k=4 have the same sum 10. There exist other solutions also. | instruction | 0 | 71,824 | 12 | 143,648 |
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
T = int(input())
for t in range(T):
N, K = list(map(int, input().split()))
a = list(map(int, input().split()))
dic = {}
# maxCount = 0
for i in range(N):
if(a[i] in dic):
dic[a[i]]+=1
else:
dic[a[i]] =1
# maxCount = max(maxCount, dic[a[i]])
keys = list(dic.keys())
keys = keys +[1]*(K- len(keys))
if(len(keys))>K:
print(-1)
continue
print(100*K)
for i in range(100):
for key in keys:
print(key, end=" ")
print()
``` | output | 1 | 71,824 | 12 | 143,649 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Phoenix loves beautiful arrays. An array is beautiful if all its subarrays of length k have the same sum. A subarray of an array is any sequence of consecutive elements.
Phoenix currently has an array a of length n. He wants to insert some number of integers, possibly zero, into his array such that it becomes beautiful. The inserted integers must be between 1 and n inclusive. Integers may be inserted anywhere (even before the first or after the last element), and he is not trying to minimize the number of inserted integers.
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 50) β the number of test cases.
The first line of each test case contains two integers n and k (1 β€ k β€ n β€ 100).
The second line of each test case contains n space-separated integers (1 β€ a_i β€ n) β the array that Phoenix currently has. This array may or may not be already beautiful.
Output
For each test case, if it is impossible to create a beautiful array, print -1. Otherwise, print two lines.
The first line should contain the length of the beautiful array m (n β€ m β€ 10^4). You don't need to minimize m.
The second line should contain m space-separated integers (1 β€ b_i β€ n) β a beautiful array that Phoenix can obtain after inserting some, possibly zero, integers into his array a. You may print integers that weren't originally in array a.
If there are multiple solutions, print any. It's guaranteed that if we can make array a beautiful, we can always make it with resulting length no more than 10^4.
Example
Input
4
4 2
1 2 2 1
4 3
1 2 2 1
3 2
1 2 3
4 4
4 3 4 2
Output
5
1 2 1 2 1
4
1 2 2 1
-1
7
4 3 2 1 4 3 2
Note
In the first test case, we can make array a beautiful by inserting the integer 1 at index 3 (in between the two existing 2s). Now, all subarrays of length k=2 have the same sum 3. There exists many other possible solutions, for example:
* 2, 1, 2, 1, 2, 1
* 1, 2, 1, 2, 1, 2
In the second test case, the array is already beautiful: all subarrays of length k=3 have the same sum 5.
In the third test case, it can be shown that we cannot insert numbers to make array a beautiful.
In the fourth test case, the array b shown is beautiful and all subarrays of length k=4 have the same sum 10. There exist other solutions also. | instruction | 0 | 71,825 | 12 | 143,650 |
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
import math
t=int(input())
for _ in range(t):
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
bb=list(set(a))
bb.sort()
if len(bb)>k:
print(-1)
continue
if n<=k:
print(n)
print(*a)
continue
bb=[1]*(k-len(bb))+bb
print(n*len(bb))
print(*(bb*n))
1
"""
3 4 3
a b c d e f
1 2 4 1 2 4 1 2 4
1 2 1 2 3
"""
``` | output | 1 | 71,825 | 12 | 143,651 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Phoenix loves beautiful arrays. An array is beautiful if all its subarrays of length k have the same sum. A subarray of an array is any sequence of consecutive elements.
Phoenix currently has an array a of length n. He wants to insert some number of integers, possibly zero, into his array such that it becomes beautiful. The inserted integers must be between 1 and n inclusive. Integers may be inserted anywhere (even before the first or after the last element), and he is not trying to minimize the number of inserted integers.
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 50) β the number of test cases.
The first line of each test case contains two integers n and k (1 β€ k β€ n β€ 100).
The second line of each test case contains n space-separated integers (1 β€ a_i β€ n) β the array that Phoenix currently has. This array may or may not be already beautiful.
Output
For each test case, if it is impossible to create a beautiful array, print -1. Otherwise, print two lines.
The first line should contain the length of the beautiful array m (n β€ m β€ 10^4). You don't need to minimize m.
The second line should contain m space-separated integers (1 β€ b_i β€ n) β a beautiful array that Phoenix can obtain after inserting some, possibly zero, integers into his array a. You may print integers that weren't originally in array a.
If there are multiple solutions, print any. It's guaranteed that if we can make array a beautiful, we can always make it with resulting length no more than 10^4.
Example
Input
4
4 2
1 2 2 1
4 3
1 2 2 1
3 2
1 2 3
4 4
4 3 4 2
Output
5
1 2 1 2 1
4
1 2 2 1
-1
7
4 3 2 1 4 3 2
Note
In the first test case, we can make array a beautiful by inserting the integer 1 at index 3 (in between the two existing 2s). Now, all subarrays of length k=2 have the same sum 3. There exists many other possible solutions, for example:
* 2, 1, 2, 1, 2, 1
* 1, 2, 1, 2, 1, 2
In the second test case, the array is already beautiful: all subarrays of length k=3 have the same sum 5.
In the third test case, it can be shown that we cannot insert numbers to make array a beautiful.
In the fourth test case, the array b shown is beautiful and all subarrays of length k=4 have the same sum 10. There exist other solutions also. | instruction | 0 | 71,826 | 12 | 143,652 |
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
import functools
import heapq as hp
import collections
import bisect
import math
def unpack(func=int):
return map(func, input().split())
def l_unpack(func=int):
"""list unpack"""
return list(map(func, input().split()))
def s_unpack(func=int):
"""sorted list unpack"""
return sorted(map(func, input().split()))
def ml_unpack(n): # multiple line unpack
"""list of n integers passed on n line, one on each"""
return [int(input()) for i in range(n)]
def range_n():
return range(int(input()))
def getint():
return int(input())
def counter(a):
d = {}
for x in a:
if x in d:
d[x] += 1
else:
d[x] = 1
return d
def main():
for _ in range_n():
n, k = unpack()
a = l_unpack()
s = set(a)
if len(s) > k:
print(-1)
continue
s = list(s)
ans = ((s * k)[:k] if len(s) != k else s) * n
print(len(ans))
print(*ans)
main()
``` | output | 1 | 71,826 | 12 | 143,653 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Phoenix loves beautiful arrays. An array is beautiful if all its subarrays of length k have the same sum. A subarray of an array is any sequence of consecutive elements.
Phoenix currently has an array a of length n. He wants to insert some number of integers, possibly zero, into his array such that it becomes beautiful. The inserted integers must be between 1 and n inclusive. Integers may be inserted anywhere (even before the first or after the last element), and he is not trying to minimize the number of inserted integers.
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 50) β the number of test cases.
The first line of each test case contains two integers n and k (1 β€ k β€ n β€ 100).
The second line of each test case contains n space-separated integers (1 β€ a_i β€ n) β the array that Phoenix currently has. This array may or may not be already beautiful.
Output
For each test case, if it is impossible to create a beautiful array, print -1. Otherwise, print two lines.
The first line should contain the length of the beautiful array m (n β€ m β€ 10^4). You don't need to minimize m.
The second line should contain m space-separated integers (1 β€ b_i β€ n) β a beautiful array that Phoenix can obtain after inserting some, possibly zero, integers into his array a. You may print integers that weren't originally in array a.
If there are multiple solutions, print any. It's guaranteed that if we can make array a beautiful, we can always make it with resulting length no more than 10^4.
Example
Input
4
4 2
1 2 2 1
4 3
1 2 2 1
3 2
1 2 3
4 4
4 3 4 2
Output
5
1 2 1 2 1
4
1 2 2 1
-1
7
4 3 2 1 4 3 2
Note
In the first test case, we can make array a beautiful by inserting the integer 1 at index 3 (in between the two existing 2s). Now, all subarrays of length k=2 have the same sum 3. There exists many other possible solutions, for example:
* 2, 1, 2, 1, 2, 1
* 1, 2, 1, 2, 1, 2
In the second test case, the array is already beautiful: all subarrays of length k=3 have the same sum 5.
In the third test case, it can be shown that we cannot insert numbers to make array a beautiful.
In the fourth test case, the array b shown is beautiful and all subarrays of length k=4 have the same sum 10. There exist other solutions also. | instruction | 0 | 71,827 | 12 | 143,654 |
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
from collections import Counter
t = int(input())
for _ in range(t):
n, k = map(int, input().split())
a = list(map(int, input().split()))
c = Counter(a)
if len(c) > k:
print(-1)
continue
ans = list(c.keys())
ans += (k - len(ans)) * [1]
ans *= 100
print(100 * k)
print(*ans)
``` | output | 1 | 71,827 | 12 | 143,655 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Phoenix loves beautiful arrays. An array is beautiful if all its subarrays of length k have the same sum. A subarray of an array is any sequence of consecutive elements.
Phoenix currently has an array a of length n. He wants to insert some number of integers, possibly zero, into his array such that it becomes beautiful. The inserted integers must be between 1 and n inclusive. Integers may be inserted anywhere (even before the first or after the last element), and he is not trying to minimize the number of inserted integers.
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 50) β the number of test cases.
The first line of each test case contains two integers n and k (1 β€ k β€ n β€ 100).
The second line of each test case contains n space-separated integers (1 β€ a_i β€ n) β the array that Phoenix currently has. This array may or may not be already beautiful.
Output
For each test case, if it is impossible to create a beautiful array, print -1. Otherwise, print two lines.
The first line should contain the length of the beautiful array m (n β€ m β€ 10^4). You don't need to minimize m.
The second line should contain m space-separated integers (1 β€ b_i β€ n) β a beautiful array that Phoenix can obtain after inserting some, possibly zero, integers into his array a. You may print integers that weren't originally in array a.
If there are multiple solutions, print any. It's guaranteed that if we can make array a beautiful, we can always make it with resulting length no more than 10^4.
Example
Input
4
4 2
1 2 2 1
4 3
1 2 2 1
3 2
1 2 3
4 4
4 3 4 2
Output
5
1 2 1 2 1
4
1 2 2 1
-1
7
4 3 2 1 4 3 2
Note
In the first test case, we can make array a beautiful by inserting the integer 1 at index 3 (in between the two existing 2s). Now, all subarrays of length k=2 have the same sum 3. There exists many other possible solutions, for example:
* 2, 1, 2, 1, 2, 1
* 1, 2, 1, 2, 1, 2
In the second test case, the array is already beautiful: all subarrays of length k=3 have the same sum 5.
In the third test case, it can be shown that we cannot insert numbers to make array a beautiful.
In the fourth test case, the array b shown is beautiful and all subarrays of length k=4 have the same sum 10. There exist other solutions also. | instruction | 0 | 71,828 | 12 | 143,656 |
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
def solve():
n,k = map(int, input().split(" "))
arr = list(map(int, input().split(' ')))
dist = set(arr)
result = []
if len(dist) > k:
print(-1)
return
for i in range(n):
result += list(dist)
for i in range(k-len(dist)):
result.append(1)
print(len(result))
print(" ".join(list(map(str,result))))
if __name__ == "__main__":
t = int(input())
for i in range(t):
solve()
``` | output | 1 | 71,828 | 12 | 143,657 |
Provide tags and a correct Python 2 solution for this coding contest problem.
Phoenix loves beautiful arrays. An array is beautiful if all its subarrays of length k have the same sum. A subarray of an array is any sequence of consecutive elements.
Phoenix currently has an array a of length n. He wants to insert some number of integers, possibly zero, into his array such that it becomes beautiful. The inserted integers must be between 1 and n inclusive. Integers may be inserted anywhere (even before the first or after the last element), and he is not trying to minimize the number of inserted integers.
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 50) β the number of test cases.
The first line of each test case contains two integers n and k (1 β€ k β€ n β€ 100).
The second line of each test case contains n space-separated integers (1 β€ a_i β€ n) β the array that Phoenix currently has. This array may or may not be already beautiful.
Output
For each test case, if it is impossible to create a beautiful array, print -1. Otherwise, print two lines.
The first line should contain the length of the beautiful array m (n β€ m β€ 10^4). You don't need to minimize m.
The second line should contain m space-separated integers (1 β€ b_i β€ n) β a beautiful array that Phoenix can obtain after inserting some, possibly zero, integers into his array a. You may print integers that weren't originally in array a.
If there are multiple solutions, print any. It's guaranteed that if we can make array a beautiful, we can always make it with resulting length no more than 10^4.
Example
Input
4
4 2
1 2 2 1
4 3
1 2 2 1
3 2
1 2 3
4 4
4 3 4 2
Output
5
1 2 1 2 1
4
1 2 2 1
-1
7
4 3 2 1 4 3 2
Note
In the first test case, we can make array a beautiful by inserting the integer 1 at index 3 (in between the two existing 2s). Now, all subarrays of length k=2 have the same sum 3. There exists many other possible solutions, for example:
* 2, 1, 2, 1, 2, 1
* 1, 2, 1, 2, 1, 2
In the second test case, the array is already beautiful: all subarrays of length k=3 have the same sum 5.
In the third test case, it can be shown that we cannot insert numbers to make array a beautiful.
In the fourth test case, the array b shown is beautiful and all subarrays of length k=4 have the same sum 10. There exist other solutions also. | instruction | 0 | 71,829 | 12 | 143,658 |
Tags: constructive algorithms, data structures, greedy, sortings
Correct Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
def in_num():
return int(raw_input())
def in_arr():
return map(int,raw_input().split())
def pr_num(n):
stdout.write(str(n)+'\n')
def pr_arr(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return map(int,stdin.read().split())
range = xrange # not for python 3.0+
inp=inp()
pos=1
for t in range(inp[0]):
n,k=inp[pos],inp[pos+1]
pos+=2
d=Counter(inp[pos:pos+n])
pos+=n
ans=d.keys()
m=len(ans)
if k-m<0:
pr_num(-1)
continue
#ans=list(d.keys())
ans=ans*(k/m)+ans[:k%m]
pr_num(n*n)
for i in range(n*n):
pr(str(ans[i%k])+' ')
pr('\n')
``` | output | 1 | 71,829 | 12 | 143,659 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Phoenix loves beautiful arrays. An array is beautiful if all its subarrays of length k have the same sum. A subarray of an array is any sequence of consecutive elements.
Phoenix currently has an array a of length n. He wants to insert some number of integers, possibly zero, into his array such that it becomes beautiful. The inserted integers must be between 1 and n inclusive. Integers may be inserted anywhere (even before the first or after the last element), and he is not trying to minimize the number of inserted integers.
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 50) β the number of test cases.
The first line of each test case contains two integers n and k (1 β€ k β€ n β€ 100).
The second line of each test case contains n space-separated integers (1 β€ a_i β€ n) β the array that Phoenix currently has. This array may or may not be already beautiful.
Output
For each test case, if it is impossible to create a beautiful array, print -1. Otherwise, print two lines.
The first line should contain the length of the beautiful array m (n β€ m β€ 10^4). You don't need to minimize m.
The second line should contain m space-separated integers (1 β€ b_i β€ n) β a beautiful array that Phoenix can obtain after inserting some, possibly zero, integers into his array a. You may print integers that weren't originally in array a.
If there are multiple solutions, print any. It's guaranteed that if we can make array a beautiful, we can always make it with resulting length no more than 10^4.
Example
Input
4
4 2
1 2 2 1
4 3
1 2 2 1
3 2
1 2 3
4 4
4 3 4 2
Output
5
1 2 1 2 1
4
1 2 2 1
-1
7
4 3 2 1 4 3 2
Note
In the first test case, we can make array a beautiful by inserting the integer 1 at index 3 (in between the two existing 2s). Now, all subarrays of length k=2 have the same sum 3. There exists many other possible solutions, for example:
* 2, 1, 2, 1, 2, 1
* 1, 2, 1, 2, 1, 2
In the second test case, the array is already beautiful: all subarrays of length k=3 have the same sum 5.
In the third test case, it can be shown that we cannot insert numbers to make array a beautiful.
In the fourth test case, the array b shown is beautiful and all subarrays of length k=4 have the same sum 10. There exist other solutions also.
Submitted Solution:
```
import collections
t = int(input())
for test_case in range(t):
n,k = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
cnt = collections.Counter(arr)
if len(cnt.keys()) > k: print(-1)
else:
ans = list(cnt.keys()) + arr[:k - len(cnt.keys())]
i = 0
while i < len(arr):
ans.append(ans[-k])
if ans[-k] == arr[i]: i += 1
print(len(ans))
print(*ans)
``` | instruction | 0 | 71,830 | 12 | 143,660 |
Yes | output | 1 | 71,830 | 12 | 143,661 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Phoenix loves beautiful arrays. An array is beautiful if all its subarrays of length k have the same sum. A subarray of an array is any sequence of consecutive elements.
Phoenix currently has an array a of length n. He wants to insert some number of integers, possibly zero, into his array such that it becomes beautiful. The inserted integers must be between 1 and n inclusive. Integers may be inserted anywhere (even before the first or after the last element), and he is not trying to minimize the number of inserted integers.
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 50) β the number of test cases.
The first line of each test case contains two integers n and k (1 β€ k β€ n β€ 100).
The second line of each test case contains n space-separated integers (1 β€ a_i β€ n) β the array that Phoenix currently has. This array may or may not be already beautiful.
Output
For each test case, if it is impossible to create a beautiful array, print -1. Otherwise, print two lines.
The first line should contain the length of the beautiful array m (n β€ m β€ 10^4). You don't need to minimize m.
The second line should contain m space-separated integers (1 β€ b_i β€ n) β a beautiful array that Phoenix can obtain after inserting some, possibly zero, integers into his array a. You may print integers that weren't originally in array a.
If there are multiple solutions, print any. It's guaranteed that if we can make array a beautiful, we can always make it with resulting length no more than 10^4.
Example
Input
4
4 2
1 2 2 1
4 3
1 2 2 1
3 2
1 2 3
4 4
4 3 4 2
Output
5
1 2 1 2 1
4
1 2 2 1
-1
7
4 3 2 1 4 3 2
Note
In the first test case, we can make array a beautiful by inserting the integer 1 at index 3 (in between the two existing 2s). Now, all subarrays of length k=2 have the same sum 3. There exists many other possible solutions, for example:
* 2, 1, 2, 1, 2, 1
* 1, 2, 1, 2, 1, 2
In the second test case, the array is already beautiful: all subarrays of length k=3 have the same sum 5.
In the third test case, it can be shown that we cannot insert numbers to make array a beautiful.
In the fourth test case, the array b shown is beautiful and all subarrays of length k=4 have the same sum 10. There exist other solutions also.
Submitted Solution:
```
t = int(input())
for i in range(t):
n, k = map(int, input().split())
a = list(map(int, input().split()))
b = set(a)
if len(b) > k:
print(-1)
continue
c = list(b)
c += [1] * (k - len(b))
ans = []
ind = 0
for j in range(len(a)):
while c[ind % len(c)] != a[j]:
ans.append(c[ind % len(c)])
ind += 1
ans.append(a[j])
ind += 1
print(len(ans))
print(*ans)
``` | instruction | 0 | 71,831 | 12 | 143,662 |
Yes | output | 1 | 71,831 | 12 | 143,663 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Phoenix loves beautiful arrays. An array is beautiful if all its subarrays of length k have the same sum. A subarray of an array is any sequence of consecutive elements.
Phoenix currently has an array a of length n. He wants to insert some number of integers, possibly zero, into his array such that it becomes beautiful. The inserted integers must be between 1 and n inclusive. Integers may be inserted anywhere (even before the first or after the last element), and he is not trying to minimize the number of inserted integers.
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 50) β the number of test cases.
The first line of each test case contains two integers n and k (1 β€ k β€ n β€ 100).
The second line of each test case contains n space-separated integers (1 β€ a_i β€ n) β the array that Phoenix currently has. This array may or may not be already beautiful.
Output
For each test case, if it is impossible to create a beautiful array, print -1. Otherwise, print two lines.
The first line should contain the length of the beautiful array m (n β€ m β€ 10^4). You don't need to minimize m.
The second line should contain m space-separated integers (1 β€ b_i β€ n) β a beautiful array that Phoenix can obtain after inserting some, possibly zero, integers into his array a. You may print integers that weren't originally in array a.
If there are multiple solutions, print any. It's guaranteed that if we can make array a beautiful, we can always make it with resulting length no more than 10^4.
Example
Input
4
4 2
1 2 2 1
4 3
1 2 2 1
3 2
1 2 3
4 4
4 3 4 2
Output
5
1 2 1 2 1
4
1 2 2 1
-1
7
4 3 2 1 4 3 2
Note
In the first test case, we can make array a beautiful by inserting the integer 1 at index 3 (in between the two existing 2s). Now, all subarrays of length k=2 have the same sum 3. There exists many other possible solutions, for example:
* 2, 1, 2, 1, 2, 1
* 1, 2, 1, 2, 1, 2
In the second test case, the array is already beautiful: all subarrays of length k=3 have the same sum 5.
In the third test case, it can be shown that we cannot insert numbers to make array a beautiful.
In the fourth test case, the array b shown is beautiful and all subarrays of length k=4 have the same sum 10. There exist other solutions also.
Submitted Solution:
```
for __ in range(int(input())):
n, k = list(map(int, input().split()))
ar = list(map(int, input().split()))
kek = set()
for elem in ar:
kek.add(elem)
if len(kek) > k:
print(-1)
else:
ans = []
uh = list(kek)
for j in range(k - len(kek)):
uh.append(1)
num = 0
while 10 ** 4 - num - len(uh) > 0:
for elem in uh:
ans.append(elem)
num += len(uh)
print(len(ans))
print(*ans)
``` | instruction | 0 | 71,832 | 12 | 143,664 |
Yes | output | 1 | 71,832 | 12 | 143,665 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Phoenix loves beautiful arrays. An array is beautiful if all its subarrays of length k have the same sum. A subarray of an array is any sequence of consecutive elements.
Phoenix currently has an array a of length n. He wants to insert some number of integers, possibly zero, into his array such that it becomes beautiful. The inserted integers must be between 1 and n inclusive. Integers may be inserted anywhere (even before the first or after the last element), and he is not trying to minimize the number of inserted integers.
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 50) β the number of test cases.
The first line of each test case contains two integers n and k (1 β€ k β€ n β€ 100).
The second line of each test case contains n space-separated integers (1 β€ a_i β€ n) β the array that Phoenix currently has. This array may or may not be already beautiful.
Output
For each test case, if it is impossible to create a beautiful array, print -1. Otherwise, print two lines.
The first line should contain the length of the beautiful array m (n β€ m β€ 10^4). You don't need to minimize m.
The second line should contain m space-separated integers (1 β€ b_i β€ n) β a beautiful array that Phoenix can obtain after inserting some, possibly zero, integers into his array a. You may print integers that weren't originally in array a.
If there are multiple solutions, print any. It's guaranteed that if we can make array a beautiful, we can always make it with resulting length no more than 10^4.
Example
Input
4
4 2
1 2 2 1
4 3
1 2 2 1
3 2
1 2 3
4 4
4 3 4 2
Output
5
1 2 1 2 1
4
1 2 2 1
-1
7
4 3 2 1 4 3 2
Note
In the first test case, we can make array a beautiful by inserting the integer 1 at index 3 (in between the two existing 2s). Now, all subarrays of length k=2 have the same sum 3. There exists many other possible solutions, for example:
* 2, 1, 2, 1, 2, 1
* 1, 2, 1, 2, 1, 2
In the second test case, the array is already beautiful: all subarrays of length k=3 have the same sum 5.
In the third test case, it can be shown that we cannot insert numbers to make array a beautiful.
In the fourth test case, the array b shown is beautiful and all subarrays of length k=4 have the same sum 10. There exist other solutions also.
Submitted Solution:
```
t=int(input())
for xy in range(t):
a,b=list(map(int,input().split()))
kp=list(map(int,input().split()))
l=[0]*a
r=[]
pq=[]
for ab in kp:
l[ab-1]+=1
for z in range(a):
if (l[z]!=0):
r.append(z+1)
else:
pq.append(z+1)
if (len(r)>b):
print(-1)
else:
if (b>len(r)):
x=b-len(r)
for lp in range(x):
r.append(pq[lp])
r=sorted(r)
r=[str(x) for x in r]
print(len(r*a))
print(' '.join(r*a))
``` | instruction | 0 | 71,833 | 12 | 143,666 |
Yes | output | 1 | 71,833 | 12 | 143,667 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Phoenix loves beautiful arrays. An array is beautiful if all its subarrays of length k have the same sum. A subarray of an array is any sequence of consecutive elements.
Phoenix currently has an array a of length n. He wants to insert some number of integers, possibly zero, into his array such that it becomes beautiful. The inserted integers must be between 1 and n inclusive. Integers may be inserted anywhere (even before the first or after the last element), and he is not trying to minimize the number of inserted integers.
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 50) β the number of test cases.
The first line of each test case contains two integers n and k (1 β€ k β€ n β€ 100).
The second line of each test case contains n space-separated integers (1 β€ a_i β€ n) β the array that Phoenix currently has. This array may or may not be already beautiful.
Output
For each test case, if it is impossible to create a beautiful array, print -1. Otherwise, print two lines.
The first line should contain the length of the beautiful array m (n β€ m β€ 10^4). You don't need to minimize m.
The second line should contain m space-separated integers (1 β€ b_i β€ n) β a beautiful array that Phoenix can obtain after inserting some, possibly zero, integers into his array a. You may print integers that weren't originally in array a.
If there are multiple solutions, print any. It's guaranteed that if we can make array a beautiful, we can always make it with resulting length no more than 10^4.
Example
Input
4
4 2
1 2 2 1
4 3
1 2 2 1
3 2
1 2 3
4 4
4 3 4 2
Output
5
1 2 1 2 1
4
1 2 2 1
-1
7
4 3 2 1 4 3 2
Note
In the first test case, we can make array a beautiful by inserting the integer 1 at index 3 (in between the two existing 2s). Now, all subarrays of length k=2 have the same sum 3. There exists many other possible solutions, for example:
* 2, 1, 2, 1, 2, 1
* 1, 2, 1, 2, 1, 2
In the second test case, the array is already beautiful: all subarrays of length k=3 have the same sum 5.
In the third test case, it can be shown that we cannot insert numbers to make array a beautiful.
In the fourth test case, the array b shown is beautiful and all subarrays of length k=4 have the same sum 10. There exist other solutions also.
Submitted Solution:
```
from math import log as lol
t = int(input())
for u in range(t):
n,k=map(int,input().split())
l = list(map(int,input().split()))
a = l
i = 0
while i < len(a):
if i+k>=len(a) or len(a) > 1000:
break
if a[i] != a[i + k]:
a = a[:i+k] + [a[i]] + a[i+k:]
i += 1
f = True
for i in range(len(a)):
if i+k>=len(a):
break
if a[i] != a[i+k]:
f = False
break
if f:
print(len(a))
print(*a)
else:
print(-1)
``` | instruction | 0 | 71,834 | 12 | 143,668 |
No | output | 1 | 71,834 | 12 | 143,669 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Phoenix loves beautiful arrays. An array is beautiful if all its subarrays of length k have the same sum. A subarray of an array is any sequence of consecutive elements.
Phoenix currently has an array a of length n. He wants to insert some number of integers, possibly zero, into his array such that it becomes beautiful. The inserted integers must be between 1 and n inclusive. Integers may be inserted anywhere (even before the first or after the last element), and he is not trying to minimize the number of inserted integers.
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 50) β the number of test cases.
The first line of each test case contains two integers n and k (1 β€ k β€ n β€ 100).
The second line of each test case contains n space-separated integers (1 β€ a_i β€ n) β the array that Phoenix currently has. This array may or may not be already beautiful.
Output
For each test case, if it is impossible to create a beautiful array, print -1. Otherwise, print two lines.
The first line should contain the length of the beautiful array m (n β€ m β€ 10^4). You don't need to minimize m.
The second line should contain m space-separated integers (1 β€ b_i β€ n) β a beautiful array that Phoenix can obtain after inserting some, possibly zero, integers into his array a. You may print integers that weren't originally in array a.
If there are multiple solutions, print any. It's guaranteed that if we can make array a beautiful, we can always make it with resulting length no more than 10^4.
Example
Input
4
4 2
1 2 2 1
4 3
1 2 2 1
3 2
1 2 3
4 4
4 3 4 2
Output
5
1 2 1 2 1
4
1 2 2 1
-1
7
4 3 2 1 4 3 2
Note
In the first test case, we can make array a beautiful by inserting the integer 1 at index 3 (in between the two existing 2s). Now, all subarrays of length k=2 have the same sum 3. There exists many other possible solutions, for example:
* 2, 1, 2, 1, 2, 1
* 1, 2, 1, 2, 1, 2
In the second test case, the array is already beautiful: all subarrays of length k=3 have the same sum 5.
In the third test case, it can be shown that we cannot insert numbers to make array a beautiful.
In the fourth test case, the array b shown is beautiful and all subarrays of length k=4 have the same sum 10. There exist other solutions also.
Submitted Solution:
```
T = int(input())
for t in range(T):
n, k = [int(x) for x in input().split(' ')]
arr = [int(x) for x in input().split(' ')]
work_set = set(arr)
if len(work_set) > k:
print(-1)
continue
base = 0
while base + k < len(arr):
# check if current subarray is beautiful
subarr = arr[base:base+k]
# print(subarr)
subset = set(subarr)
if len(subset) == k:
# print(f'subarr [{base}:{base+k}] is beautiful, continuing')
base += 1
continue
# print(f'making subarr [{base}:{base+k}] beautiful')
# make subarr beautiful
curr_set = set()
for i in range(base, base+k):
if arr[i] not in curr_set:
# print(f'adding {subarr[i]} to current_set...')
curr_set.add(arr[i])
continue
mp = work_set - curr_set
# print(f'append missing part {mp}')
arr[i:i] = list(mp)
# print(f'now arr is {arr}')
base += 1
break
# print('RESULT:')
print(len(arr))
print(' '.join([str(i) for i in arr]))
``` | instruction | 0 | 71,835 | 12 | 143,670 |
No | output | 1 | 71,835 | 12 | 143,671 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Phoenix loves beautiful arrays. An array is beautiful if all its subarrays of length k have the same sum. A subarray of an array is any sequence of consecutive elements.
Phoenix currently has an array a of length n. He wants to insert some number of integers, possibly zero, into his array such that it becomes beautiful. The inserted integers must be between 1 and n inclusive. Integers may be inserted anywhere (even before the first or after the last element), and he is not trying to minimize the number of inserted integers.
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 50) β the number of test cases.
The first line of each test case contains two integers n and k (1 β€ k β€ n β€ 100).
The second line of each test case contains n space-separated integers (1 β€ a_i β€ n) β the array that Phoenix currently has. This array may or may not be already beautiful.
Output
For each test case, if it is impossible to create a beautiful array, print -1. Otherwise, print two lines.
The first line should contain the length of the beautiful array m (n β€ m β€ 10^4). You don't need to minimize m.
The second line should contain m space-separated integers (1 β€ b_i β€ n) β a beautiful array that Phoenix can obtain after inserting some, possibly zero, integers into his array a. You may print integers that weren't originally in array a.
If there are multiple solutions, print any. It's guaranteed that if we can make array a beautiful, we can always make it with resulting length no more than 10^4.
Example
Input
4
4 2
1 2 2 1
4 3
1 2 2 1
3 2
1 2 3
4 4
4 3 4 2
Output
5
1 2 1 2 1
4
1 2 2 1
-1
7
4 3 2 1 4 3 2
Note
In the first test case, we can make array a beautiful by inserting the integer 1 at index 3 (in between the two existing 2s). Now, all subarrays of length k=2 have the same sum 3. There exists many other possible solutions, for example:
* 2, 1, 2, 1, 2, 1
* 1, 2, 1, 2, 1, 2
In the second test case, the array is already beautiful: all subarrays of length k=3 have the same sum 5.
In the third test case, it can be shown that we cannot insert numbers to make array a beautiful.
In the fourth test case, the array b shown is beautiful and all subarrays of length k=4 have the same sum 10. There exist other solutions also.
Submitted Solution:
```
import sys
try:
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
except:
pass
import math
def takeInput():
return [int(x) for x in input().strip().split()]
t=int(input())
while t!=0:
t-=1
n,k=takeInput()
a=takeInput()
chars=set()
for i in range(n):
chars.add(a[i])
if(len(chars)>k):
print(-1)
else:
start=min(chars)
beautiful=[]
for i in range(n):
number=start
for j in range(k):
beautiful.append(number)
number+=1
print(len(beautiful))
print(*beautiful)
``` | instruction | 0 | 71,836 | 12 | 143,672 |
No | output | 1 | 71,836 | 12 | 143,673 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Phoenix loves beautiful arrays. An array is beautiful if all its subarrays of length k have the same sum. A subarray of an array is any sequence of consecutive elements.
Phoenix currently has an array a of length n. He wants to insert some number of integers, possibly zero, into his array such that it becomes beautiful. The inserted integers must be between 1 and n inclusive. Integers may be inserted anywhere (even before the first or after the last element), and he is not trying to minimize the number of inserted integers.
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 50) β the number of test cases.
The first line of each test case contains two integers n and k (1 β€ k β€ n β€ 100).
The second line of each test case contains n space-separated integers (1 β€ a_i β€ n) β the array that Phoenix currently has. This array may or may not be already beautiful.
Output
For each test case, if it is impossible to create a beautiful array, print -1. Otherwise, print two lines.
The first line should contain the length of the beautiful array m (n β€ m β€ 10^4). You don't need to minimize m.
The second line should contain m space-separated integers (1 β€ b_i β€ n) β a beautiful array that Phoenix can obtain after inserting some, possibly zero, integers into his array a. You may print integers that weren't originally in array a.
If there are multiple solutions, print any. It's guaranteed that if we can make array a beautiful, we can always make it with resulting length no more than 10^4.
Example
Input
4
4 2
1 2 2 1
4 3
1 2 2 1
3 2
1 2 3
4 4
4 3 4 2
Output
5
1 2 1 2 1
4
1 2 2 1
-1
7
4 3 2 1 4 3 2
Note
In the first test case, we can make array a beautiful by inserting the integer 1 at index 3 (in between the two existing 2s). Now, all subarrays of length k=2 have the same sum 3. There exists many other possible solutions, for example:
* 2, 1, 2, 1, 2, 1
* 1, 2, 1, 2, 1, 2
In the second test case, the array is already beautiful: all subarrays of length k=3 have the same sum 5.
In the third test case, it can be shown that we cannot insert numbers to make array a beautiful.
In the fourth test case, the array b shown is beautiful and all subarrays of length k=4 have the same sum 10. There exist other solutions also.
Submitted Solution:
```
import sys
input = sys.stdin.readline
for i in range(int(input())):
n, k = map(int, input().split())
# n = int(input())
a = list(map(int, input().split()))
# s2 = list(map(int, list(input().strip())))
# print(s1)
if k == n:
print(n)
print(*a)
continue
u = set(a)
f = len(u)
if f > k:
print(-1)
continue
l = list(u)
l.sort()
d = [l[0]]*(max(0, k - len(l)))
print(len(l*n + d))
print(*(l*n + d))
``` | instruction | 0 | 71,837 | 12 | 143,674 |
No | output | 1 | 71,837 | 12 | 143,675 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got another problem dealing with arrays. Let's consider an arbitrary sequence containing n (not necessarily different) integers a1, a2, ..., an. We are interested in all possible pairs of numbers (ai, aj), (1 β€ i, j β€ n). In other words, let's consider all n2 pairs of numbers, picked from the given array.
For example, in sequence a = {3, 1, 5} are 9 pairs of numbers: (3, 3), (3, 1), (3, 5), (1, 3), (1, 1), (1, 5), (5, 3), (5, 1), (5, 5).
Let's sort all resulting pairs lexicographically by non-decreasing. Let us remind you that pair (p1, q1) is lexicographically less than pair (p2, q2) only if either p1 < p2, or p1 = p2 and q1 < q2.
Then the sequence, mentioned above, will be sorted like that: (1, 1), (1, 3), (1, 5), (3, 1), (3, 3), (3, 5), (5, 1), (5, 3), (5, 5)
Let's number all the pair in the sorted list from 1 to n2. Your task is formulated like this: you should find the k-th pair in the ordered list of all possible pairs of the array you've been given.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 1 β€ k β€ n2). The second line contains the array containing n integers a1, a2, ..., an ( - 109 β€ ai β€ 109). The numbers in the array can coincide. All numbers are separated with spaces.
Please do not use the %lld specificator to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout, streams or the %I64d specificator instead.
Output
In the single line print two numbers β the sought k-th pair.
Examples
Input
2 4
2 1
Output
2 2
Input
3 2
3 1 5
Output
1 3
Note
In the first sample the sorted sequence for the given array looks as: (1, 1), (1, 2), (2, 1), (2, 2). The 4-th of them is pair (2, 2).
The sorted sequence for the array from the second sample is given in the statement. The 2-nd pair there is (1, 3). | instruction | 0 | 71,915 | 12 | 143,830 |
Tags: implementation, math, sortings
Correct Solution:
```
from collections import *
n, k = map(int, input().split())
d = defaultdict(int)
a = sorted(map(int,input().split()))
for x in a:
d[x] += 1
s = sorted(d.items())
#print(s)
summ=0
for x, y in s:
if (k-summ)<=y*n:
#print(k)
print(x, a[(k - 1-summ)//y])
break
summ+=(y*n)
``` | output | 1 | 71,915 | 12 | 143,831 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got another problem dealing with arrays. Let's consider an arbitrary sequence containing n (not necessarily different) integers a1, a2, ..., an. We are interested in all possible pairs of numbers (ai, aj), (1 β€ i, j β€ n). In other words, let's consider all n2 pairs of numbers, picked from the given array.
For example, in sequence a = {3, 1, 5} are 9 pairs of numbers: (3, 3), (3, 1), (3, 5), (1, 3), (1, 1), (1, 5), (5, 3), (5, 1), (5, 5).
Let's sort all resulting pairs lexicographically by non-decreasing. Let us remind you that pair (p1, q1) is lexicographically less than pair (p2, q2) only if either p1 < p2, or p1 = p2 and q1 < q2.
Then the sequence, mentioned above, will be sorted like that: (1, 1), (1, 3), (1, 5), (3, 1), (3, 3), (3, 5), (5, 1), (5, 3), (5, 5)
Let's number all the pair in the sorted list from 1 to n2. Your task is formulated like this: you should find the k-th pair in the ordered list of all possible pairs of the array you've been given.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 1 β€ k β€ n2). The second line contains the array containing n integers a1, a2, ..., an ( - 109 β€ ai β€ 109). The numbers in the array can coincide. All numbers are separated with spaces.
Please do not use the %lld specificator to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout, streams or the %I64d specificator instead.
Output
In the single line print two numbers β the sought k-th pair.
Examples
Input
2 4
2 1
Output
2 2
Input
3 2
3 1 5
Output
1 3
Note
In the first sample the sorted sequence for the given array looks as: (1, 1), (1, 2), (2, 1), (2, 2). The 4-th of them is pair (2, 2).
The sorted sequence for the array from the second sample is given in the statement. The 2-nd pair there is (1, 3). | instruction | 0 | 71,916 | 12 | 143,832 |
Tags: implementation, math, sortings
Correct Solution:
```
n, k = map(int, input().split())
t = sorted(list(map(int, input().split())))
k -= 1
a = k // n
s = t.count(t[a])
idx = t.index(t[a])
b = (k - idx * n) // s
print(t[a], t[b])
``` | output | 1 | 71,916 | 12 | 143,833 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got another problem dealing with arrays. Let's consider an arbitrary sequence containing n (not necessarily different) integers a1, a2, ..., an. We are interested in all possible pairs of numbers (ai, aj), (1 β€ i, j β€ n). In other words, let's consider all n2 pairs of numbers, picked from the given array.
For example, in sequence a = {3, 1, 5} are 9 pairs of numbers: (3, 3), (3, 1), (3, 5), (1, 3), (1, 1), (1, 5), (5, 3), (5, 1), (5, 5).
Let's sort all resulting pairs lexicographically by non-decreasing. Let us remind you that pair (p1, q1) is lexicographically less than pair (p2, q2) only if either p1 < p2, or p1 = p2 and q1 < q2.
Then the sequence, mentioned above, will be sorted like that: (1, 1), (1, 3), (1, 5), (3, 1), (3, 3), (3, 5), (5, 1), (5, 3), (5, 5)
Let's number all the pair in the sorted list from 1 to n2. Your task is formulated like this: you should find the k-th pair in the ordered list of all possible pairs of the array you've been given.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 1 β€ k β€ n2). The second line contains the array containing n integers a1, a2, ..., an ( - 109 β€ ai β€ 109). The numbers in the array can coincide. All numbers are separated with spaces.
Please do not use the %lld specificator to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout, streams or the %I64d specificator instead.
Output
In the single line print two numbers β the sought k-th pair.
Examples
Input
2 4
2 1
Output
2 2
Input
3 2
3 1 5
Output
1 3
Note
In the first sample the sorted sequence for the given array looks as: (1, 1), (1, 2), (2, 1), (2, 2). The 4-th of them is pair (2, 2).
The sorted sequence for the array from the second sample is given in the statement. The 2-nd pair there is (1, 3). | instruction | 0 | 71,917 | 12 | 143,834 |
Tags: implementation, math, sortings
Correct Solution:
```
n,k=map(int,input().split())
a = list(map(int, input().strip().split(' ')))
a.sort()
b = [0]*(n+1)
c = [0]*(n+1)
h=int(0)
i=int(1)
u=int(0)
b[0]=1
n1=int(n)
if n==1:
print(a[0],a[0])
h=1
c[u]=a[0]
while(h==0):
if a[i]==a[i-1]:
b[u]+=1
i+=1
else:
u+=1
c[u]=a[i]
i+=1
b[u]+=1
if i == n:
break
i=int(0)
j=int(0)
while(h==0):
if k>b[i]*n1:
k-=b[i]*n1
i+=1
else:
if k>b[i]*b[j]:
k-=b[i]*b[j]
j+=1
else:
print(c[i],c[j])
break
``` | output | 1 | 71,917 | 12 | 143,835 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got another problem dealing with arrays. Let's consider an arbitrary sequence containing n (not necessarily different) integers a1, a2, ..., an. We are interested in all possible pairs of numbers (ai, aj), (1 β€ i, j β€ n). In other words, let's consider all n2 pairs of numbers, picked from the given array.
For example, in sequence a = {3, 1, 5} are 9 pairs of numbers: (3, 3), (3, 1), (3, 5), (1, 3), (1, 1), (1, 5), (5, 3), (5, 1), (5, 5).
Let's sort all resulting pairs lexicographically by non-decreasing. Let us remind you that pair (p1, q1) is lexicographically less than pair (p2, q2) only if either p1 < p2, or p1 = p2 and q1 < q2.
Then the sequence, mentioned above, will be sorted like that: (1, 1), (1, 3), (1, 5), (3, 1), (3, 3), (3, 5), (5, 1), (5, 3), (5, 5)
Let's number all the pair in the sorted list from 1 to n2. Your task is formulated like this: you should find the k-th pair in the ordered list of all possible pairs of the array you've been given.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 1 β€ k β€ n2). The second line contains the array containing n integers a1, a2, ..., an ( - 109 β€ ai β€ 109). The numbers in the array can coincide. All numbers are separated with spaces.
Please do not use the %lld specificator to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout, streams or the %I64d specificator instead.
Output
In the single line print two numbers β the sought k-th pair.
Examples
Input
2 4
2 1
Output
2 2
Input
3 2
3 1 5
Output
1 3
Note
In the first sample the sorted sequence for the given array looks as: (1, 1), (1, 2), (2, 1), (2, 2). The 4-th of them is pair (2, 2).
The sorted sequence for the array from the second sample is given in the statement. The 2-nd pair there is (1, 3). | instruction | 0 | 71,918 | 12 | 143,836 |
Tags: implementation, math, sortings
Correct Solution:
```
n, k = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
k -= 1
t = k // n
s = t
while s >= 0 and a[s] == a[t]:
s -= 1
s += 1
k -= s * n
t = s
while t < n and a[t] == a[s]:
t += 1
print(a[s], a[k//(t-s)])
``` | output | 1 | 71,918 | 12 | 143,837 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got another problem dealing with arrays. Let's consider an arbitrary sequence containing n (not necessarily different) integers a1, a2, ..., an. We are interested in all possible pairs of numbers (ai, aj), (1 β€ i, j β€ n). In other words, let's consider all n2 pairs of numbers, picked from the given array.
For example, in sequence a = {3, 1, 5} are 9 pairs of numbers: (3, 3), (3, 1), (3, 5), (1, 3), (1, 1), (1, 5), (5, 3), (5, 1), (5, 5).
Let's sort all resulting pairs lexicographically by non-decreasing. Let us remind you that pair (p1, q1) is lexicographically less than pair (p2, q2) only if either p1 < p2, or p1 = p2 and q1 < q2.
Then the sequence, mentioned above, will be sorted like that: (1, 1), (1, 3), (1, 5), (3, 1), (3, 3), (3, 5), (5, 1), (5, 3), (5, 5)
Let's number all the pair in the sorted list from 1 to n2. Your task is formulated like this: you should find the k-th pair in the ordered list of all possible pairs of the array you've been given.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 1 β€ k β€ n2). The second line contains the array containing n integers a1, a2, ..., an ( - 109 β€ ai β€ 109). The numbers in the array can coincide. All numbers are separated with spaces.
Please do not use the %lld specificator to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout, streams or the %I64d specificator instead.
Output
In the single line print two numbers β the sought k-th pair.
Examples
Input
2 4
2 1
Output
2 2
Input
3 2
3 1 5
Output
1 3
Note
In the first sample the sorted sequence for the given array looks as: (1, 1), (1, 2), (2, 1), (2, 2). The 4-th of them is pair (2, 2).
The sorted sequence for the array from the second sample is given in the statement. The 2-nd pair there is (1, 3). | instruction | 0 | 71,919 | 12 | 143,838 |
Tags: implementation, math, sortings
Correct Solution:
```
import sys
from math import gcd,sqrt,ceil,log2
from collections import defaultdict,Counter,deque
from bisect import bisect_left,bisect_right
import math
sys.setrecursionlimit(2*10**5+10)
import heapq
from itertools import permutations
# input=sys.stdin.readline
# def print(x):
# sys.stdout.write(str(x)+"\n")
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
aa='abcdefghijklmnopqrstuvwxyz'
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 sys
# import io, os
# input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def get_sum(bit,i):
s = 0
i+=1
while i>0:
s+=bit[i]
i-=i&(-i)
return s
def update(bit,n,i,v):
i+=1
while i<=n:
bit[i]+=v
i+=i&(-i)
def modInverse(b,m):
g = math.gcd(b, m)
if (g != 1):
return -1
else:
return pow(b, m - 2, m)
def primeFactors(n):
sa = []
# sa.add(n)
while n % 2 == 0:
sa.append(2)
n = n // 2
for i in range(3,int(math.sqrt(n))+1,2):
while n % i== 0:
sa.append(i)
n = n // i
# sa.add(n)
if n > 2:
sa.append(n)
return sa
def seive(n):
pri = [True]*(n+1)
p = 2
while p*p<=n:
if pri[p] == True:
for i in range(p*p,n+1,p):
pri[i] = False
p+=1
return pri
def check_prim(n):
if n<0:
return False
for i in range(2,int(sqrt(n))+1):
if n%i == 0:
return False
return True
def getZarr(string, z):
n = len(string)
# [L,R] make a window which matches
# with prefix of s
l, r, k = 0, 0, 0
for i in range(1, n):
# if i>R nothing matches so we will calculate.
# Z[i] using naive way.
if i > r:
l, r = i, i
# R-L = 0 in starting, so it will start
# checking from 0'th index. For example,
# for "ababab" and i = 1, the value of R
# remains 0 and Z[i] becomes 0. For string
# "aaaaaa" and i = 1, Z[i] and R become 5
while r < n and string[r - l] == string[r]:
r += 1
z[i] = r - l
r -= 1
else:
# k = i-L so k corresponds to number which
# matches in [L,R] interval.
k = i - l
# if Z[k] is less than remaining interval
# then Z[i] will be equal to Z[k].
# For example, str = "ababab", i = 3, R = 5
# and L = 2
if z[k] < r - i + 1:
z[i] = z[k]
# For example str = "aaaaaa" and i = 2,
# R is 5, L is 0
else:
# else start from R and check manually
l = i
while r < n and string[r - l] == string[r]:
r += 1
z[i] = r - l
r -= 1
def search(text, pattern):
# Create concatenated string "P$T"
concat = pattern + "$" + text
l = len(concat)
z = [0] * l
getZarr(concat, z)
ha = []
for i in range(l):
if z[i] == len(pattern):
ha.append(i - len(pattern) - 1)
return ha
# n,k = map(int,input().split())
# l = list(map(int,input().split()))
#
# n = int(input())
# l = list(map(int,input().split()))
#
# hash = defaultdict(list)
# la = []
#
# for i in range(n):
# la.append([l[i],i+1])
#
# la.sort(key = lambda x: (x[0],-x[1]))
# ans = []
# r = n
# flag = 0
# lo = []
# ha = [i for i in range(n,0,-1)]
# yo = []
# for a,b in la:
#
# if a == 1:
# ans.append([r,b])
# # hash[(1,1)].append([b,r])
# lo.append((r,b))
# ha.pop(0)
# yo.append([r,b])
# r-=1
#
# elif a == 2:
# # print(yo,lo)
# # print(hash[1,1])
# if lo == []:
# flag = 1
# break
# c,d = lo.pop(0)
# yo.pop(0)
# if b>=d:
# flag = 1
# break
# ans.append([c,b])
# yo.append([c,b])
#
#
#
# elif a == 3:
#
# if yo == []:
# flag = 1
# break
# c,d = yo.pop(0)
# if b>=d:
# flag = 1
# break
# if ha == []:
# flag = 1
# break
#
# ka = ha.pop(0)
#
# ans.append([ka,b])
# ans.append([ka,d])
# yo.append([ka,b])
#
# if flag:
# print(-1)
# else:
# print(len(ans))
# for a,b in ans:
# print(a,b)
def mergeIntervals(arr):
# Sorting based on the increasing order
# of the start intervals
arr.sort(key = lambda x: x[0])
# array to hold the merged intervals
m = []
s = -10000
max = -100000
for i in range(len(arr)):
a = arr[i]
if a[0] > max:
if i != 0:
m.append([s,max])
max = a[1]
s = a[0]
else:
if a[1] >= max:
max = a[1]
#'max' value gives the last point of
# that particular interval
# 's' gives the starting point of that interval
# 'm' array contains the list of all merged intervals
if max != -100000 and [s, max] not in m:
m.append([s, max])
return m
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den,
p - 2, p)) % p
def sol(n):
seti = set()
for i in range(1,int(sqrt(n))+1):
if n%i == 0:
seti.add(n//i)
seti.add(i)
return seti
def lcm(a,b):
return (a*b)//gcd(a,b)
#
# n,p = map(int,input().split())
#
# s = input()
#
# if n <=2:
# if n == 1:
# pass
# if n == 2:
# pass
# i = n-1
# idx = -1
# while i>=0:
# z = ord(s[i])-96
# k = chr(z+1+96)
# flag = 1
# if i-1>=0:
# if s[i-1]!=k:
# flag+=1
# else:
# flag+=1
# if i-2>=0:
# if s[i-2]!=k:
# flag+=1
# else:
# flag+=1
# if flag == 2:
# idx = i
# s[i] = k
# break
# if idx == -1:
# print('NO')
# exit()
# for i in range(idx+1,n):
# if
#
def moore_voting(l):
count1 = 0
count2 = 0
first = 10**18
second = 10**18
n = len(l)
for i in range(n):
if l[i] == first:
count1+=1
elif l[i] == second:
count2+=1
elif count1 == 0:
count1+=1
first = l[i]
elif count2 == 0:
count2+=1
second = l[i]
else:
count1-=1
count2-=1
for i in range(n):
if l[i] == first:
count1+=1
elif l[i] == second:
count2+=1
if count1>n//3:
return first
if count2>n//3:
return second
return -1
n,k = map(int,input().split())
l = list(map(int,input().split()))
la = set()
l.sort()
# debug = []
# for i in range(n):
# for j in range(n):
# debug.append([l[i],l[j]])
#
# debug.sort()
# print(debug[k-1])
hash = defaultdict(int)
for i in l:
la.add(i)
hash[i]+=1
la = list(la)
la.sort()
fir = -1
sec = -1
# print(debug)
# print(la)
for i in range(len(la)):
z = hash[la[i]]**2 + (n-hash[la[i]])*hash[la[i]]
# print(z,k)
if z>=k:
fir = la[i]
break
else:
k-=z
yo = []
for i in range(len(la)):
z = hash[la[i]]*hash[fir]
if z>=k:
sec = la[i]
break
else:
k-=z
yo.sort()
print(fir,sec)
``` | output | 1 | 71,919 | 12 | 143,839 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got another problem dealing with arrays. Let's consider an arbitrary sequence containing n (not necessarily different) integers a1, a2, ..., an. We are interested in all possible pairs of numbers (ai, aj), (1 β€ i, j β€ n). In other words, let's consider all n2 pairs of numbers, picked from the given array.
For example, in sequence a = {3, 1, 5} are 9 pairs of numbers: (3, 3), (3, 1), (3, 5), (1, 3), (1, 1), (1, 5), (5, 3), (5, 1), (5, 5).
Let's sort all resulting pairs lexicographically by non-decreasing. Let us remind you that pair (p1, q1) is lexicographically less than pair (p2, q2) only if either p1 < p2, or p1 = p2 and q1 < q2.
Then the sequence, mentioned above, will be sorted like that: (1, 1), (1, 3), (1, 5), (3, 1), (3, 3), (3, 5), (5, 1), (5, 3), (5, 5)
Let's number all the pair in the sorted list from 1 to n2. Your task is formulated like this: you should find the k-th pair in the ordered list of all possible pairs of the array you've been given.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 1 β€ k β€ n2). The second line contains the array containing n integers a1, a2, ..., an ( - 109 β€ ai β€ 109). The numbers in the array can coincide. All numbers are separated with spaces.
Please do not use the %lld specificator to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout, streams or the %I64d specificator instead.
Output
In the single line print two numbers β the sought k-th pair.
Examples
Input
2 4
2 1
Output
2 2
Input
3 2
3 1 5
Output
1 3
Note
In the first sample the sorted sequence for the given array looks as: (1, 1), (1, 2), (2, 1), (2, 2). The 4-th of them is pair (2, 2).
The sorted sequence for the array from the second sample is given in the statement. The 2-nd pair there is (1, 3). | instruction | 0 | 71,920 | 12 | 143,840 |
Tags: implementation, math, sortings
Correct Solution:
```
n,k=input().split()
n=int(n)
k=int(k)
a=[0]*n
a=input().split()
for i in range (n):
a[i]=int(a[i])
a.sort()
x = a[(k - 1) // n]
p=a.index(x)
c=a.count(x)
y = ((k - 1) - p * n) // c
print(x, a[y])
``` | output | 1 | 71,920 | 12 | 143,841 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got another problem dealing with arrays. Let's consider an arbitrary sequence containing n (not necessarily different) integers a1, a2, ..., an. We are interested in all possible pairs of numbers (ai, aj), (1 β€ i, j β€ n). In other words, let's consider all n2 pairs of numbers, picked from the given array.
For example, in sequence a = {3, 1, 5} are 9 pairs of numbers: (3, 3), (3, 1), (3, 5), (1, 3), (1, 1), (1, 5), (5, 3), (5, 1), (5, 5).
Let's sort all resulting pairs lexicographically by non-decreasing. Let us remind you that pair (p1, q1) is lexicographically less than pair (p2, q2) only if either p1 < p2, or p1 = p2 and q1 < q2.
Then the sequence, mentioned above, will be sorted like that: (1, 1), (1, 3), (1, 5), (3, 1), (3, 3), (3, 5), (5, 1), (5, 3), (5, 5)
Let's number all the pair in the sorted list from 1 to n2. Your task is formulated like this: you should find the k-th pair in the ordered list of all possible pairs of the array you've been given.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 1 β€ k β€ n2). The second line contains the array containing n integers a1, a2, ..., an ( - 109 β€ ai β€ 109). The numbers in the array can coincide. All numbers are separated with spaces.
Please do not use the %lld specificator to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout, streams or the %I64d specificator instead.
Output
In the single line print two numbers β the sought k-th pair.
Examples
Input
2 4
2 1
Output
2 2
Input
3 2
3 1 5
Output
1 3
Note
In the first sample the sorted sequence for the given array looks as: (1, 1), (1, 2), (2, 1), (2, 2). The 4-th of them is pair (2, 2).
The sorted sequence for the array from the second sample is given in the statement. The 2-nd pair there is (1, 3). | instruction | 0 | 71,921 | 12 | 143,842 |
Tags: implementation, math, sortings
Correct Solution:
```
n, k = map(int, input().split())
a = sorted(map(int, input().split()))
x = a[(k - 1) // n]
p, c = a.index(x), a.count(x)
y = ((k - 1) - p * n) // c
print(x, a[y])
``` | output | 1 | 71,921 | 12 | 143,843 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got another problem dealing with arrays. Let's consider an arbitrary sequence containing n (not necessarily different) integers a1, a2, ..., an. We are interested in all possible pairs of numbers (ai, aj), (1 β€ i, j β€ n). In other words, let's consider all n2 pairs of numbers, picked from the given array.
For example, in sequence a = {3, 1, 5} are 9 pairs of numbers: (3, 3), (3, 1), (3, 5), (1, 3), (1, 1), (1, 5), (5, 3), (5, 1), (5, 5).
Let's sort all resulting pairs lexicographically by non-decreasing. Let us remind you that pair (p1, q1) is lexicographically less than pair (p2, q2) only if either p1 < p2, or p1 = p2 and q1 < q2.
Then the sequence, mentioned above, will be sorted like that: (1, 1), (1, 3), (1, 5), (3, 1), (3, 3), (3, 5), (5, 1), (5, 3), (5, 5)
Let's number all the pair in the sorted list from 1 to n2. Your task is formulated like this: you should find the k-th pair in the ordered list of all possible pairs of the array you've been given.
Input
The first line contains two integers n and k (1 β€ n β€ 105, 1 β€ k β€ n2). The second line contains the array containing n integers a1, a2, ..., an ( - 109 β€ ai β€ 109). The numbers in the array can coincide. All numbers are separated with spaces.
Please do not use the %lld specificator to read or write 64-bit integers in Π‘++. It is preferred to use cin, cout, streams or the %I64d specificator instead.
Output
In the single line print two numbers β the sought k-th pair.
Examples
Input
2 4
2 1
Output
2 2
Input
3 2
3 1 5
Output
1 3
Note
In the first sample the sorted sequence for the given array looks as: (1, 1), (1, 2), (2, 1), (2, 2). The 4-th of them is pair (2, 2).
The sorted sequence for the array from the second sample is given in the statement. The 2-nd pair there is (1, 3). | instruction | 0 | 71,922 | 12 | 143,844 |
Tags: implementation, math, sortings
Correct Solution:
```
#import math
#from functools import lru_cache
#import heapq
#from collections import defaultdict
from collections import Counter
#from collections import deque
#from sys import stdout
#from sys import setrecursionlimit
#setrecursionlimit(10**7)
#from bisect import bisect_left
from sys import stdin
input = stdin.readline
INF = 10**9 + 7
MAX = 10**7 + 7
MOD = 10**9 + 7
n, k = [int(x) for x in input().strip().split()]
a = [int(x) for x in input().strip().split()]
c = list(Counter(a).items())
c.sort()
#c.append((0, 0))
s = 0
fi = 0
i = 0
while(i<len(c)):
s += c[i][1]*n
#print(i, s)
if(s>=k):
fi = i
k -= (s - c[i][1]*n)
break
i+=1
si = 0
i = 0
s = 0
while(i<len(c)):
s += c[i][1]*c[fi][1]
#print(i, s)
if(s>=k):
si = i
break
i+=1
print(c[fi][0], c[si][0])
``` | output | 1 | 71,922 | 12 | 143,845 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.