message stringlengths 2 43.5k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 853 107k | cluster float64 24 24 | __index_level_0__ int64 1.71k 214k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n phone numbers in Polycarp's contacts on his phone. Each number is a 9-digit integer, starting with a digit different from 0. All the numbers are distinct.
There is the latest version of Berdroid OS installed on Polycarp's phone. If some number is entered, is shows up all the numbers in the contacts for which there is a substring equal to the entered sequence of digits. For example, is there are three phone numbers in Polycarp's contacts: 123456789, 100000000 and 100123456, then:
* if he enters 00 two numbers will show up: 100000000 and 100123456,
* if he enters 123 two numbers will show up 123456789 and 100123456,
* if he enters 01 there will be only one number 100123456.
For each of the phone numbers in Polycarp's contacts, find the minimum in length sequence of digits such that if Polycarp enters this sequence, Berdroid shows this only phone number.
Input
The first line contains single integer n (1 ≤ n ≤ 70000) — the total number of phone contacts in Polycarp's contacts.
The phone numbers follow, one in each line. Each number is a positive 9-digit integer starting with a digit from 1 to 9. All the numbers are distinct.
Output
Print exactly n lines: the i-th of them should contain the shortest non-empty sequence of digits, such that if Polycarp enters it, the Berdroid OS shows up only the i-th number from the contacts. If there are several such sequences, print any of them.
Examples
Input
3
123456789
100000000
100123456
Output
9
000
01
Input
4
123456789
193456789
134567819
934567891
Output
2
193
81
91
Submitted Solution:
```
n = int(input())
numbers = []
for i in range(0,n):
number = input()
numbers.append(number)
telep = {}
count = 1
for number in numbers:
for l in range(1, len(number)+1):
for i in range(0, len(number) - l + 1):
key = number[i:i + l]
if (key in telep) and (telep[key]!=count):
telep[key]=-1
else:
telep[key]=count
count += 1
for i in range(1, n+1):
mini = 10
for key in telep:
if telep[key]==n:
if len(key)<mini:
mini = telep[key]
print(mini)
``` | instruction | 0 | 39,287 | 24 | 78,574 |
No | output | 1 | 39,287 | 24 | 78,575 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n phone numbers in Polycarp's contacts on his phone. Each number is a 9-digit integer, starting with a digit different from 0. All the numbers are distinct.
There is the latest version of Berdroid OS installed on Polycarp's phone. If some number is entered, is shows up all the numbers in the contacts for which there is a substring equal to the entered sequence of digits. For example, is there are three phone numbers in Polycarp's contacts: 123456789, 100000000 and 100123456, then:
* if he enters 00 two numbers will show up: 100000000 and 100123456,
* if he enters 123 two numbers will show up 123456789 and 100123456,
* if he enters 01 there will be only one number 100123456.
For each of the phone numbers in Polycarp's contacts, find the minimum in length sequence of digits such that if Polycarp enters this sequence, Berdroid shows this only phone number.
Input
The first line contains single integer n (1 ≤ n ≤ 70000) — the total number of phone contacts in Polycarp's contacts.
The phone numbers follow, one in each line. Each number is a positive 9-digit integer starting with a digit from 1 to 9. All the numbers are distinct.
Output
Print exactly n lines: the i-th of them should contain the shortest non-empty sequence of digits, such that if Polycarp enters it, the Berdroid OS shows up only the i-th number from the contacts. If there are several such sequences, print any of them.
Examples
Input
3
123456789
100000000
100123456
Output
9
000
01
Input
4
123456789
193456789
134567819
934567891
Output
2
193
81
91
Submitted Solution:
```
n = int(input())
a = [""] * n
for i in range(0, n):
a[i] = input()
st = 0
stt = ""
tt = ""
i = 0
hod = 0
while st < n:
b = False
for lon in range(1,10):
if b:
break
for i in range(0,10 - lon):
if b:
break
stt = a[st]
tt = stt[i:(lon + i)]
ver = 0
hod = 0
while hod < n:
if a[hod].find(str(tt)) == -1:
ver += 1
if ver + 1 == n:
print(tt)
b = True
hod += 1
st += 1
print(a)
``` | instruction | 0 | 39,288 | 24 | 78,576 |
No | output | 1 | 39,288 | 24 | 78,577 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n phone numbers in Polycarp's contacts on his phone. Each number is a 9-digit integer, starting with a digit different from 0. All the numbers are distinct.
There is the latest version of Berdroid OS installed on Polycarp's phone. If some number is entered, is shows up all the numbers in the contacts for which there is a substring equal to the entered sequence of digits. For example, is there are three phone numbers in Polycarp's contacts: 123456789, 100000000 and 100123456, then:
* if he enters 00 two numbers will show up: 100000000 and 100123456,
* if he enters 123 two numbers will show up 123456789 and 100123456,
* if he enters 01 there will be only one number 100123456.
For each of the phone numbers in Polycarp's contacts, find the minimum in length sequence of digits such that if Polycarp enters this sequence, Berdroid shows this only phone number.
Input
The first line contains single integer n (1 ≤ n ≤ 70000) — the total number of phone contacts in Polycarp's contacts.
The phone numbers follow, one in each line. Each number is a positive 9-digit integer starting with a digit from 1 to 9. All the numbers are distinct.
Output
Print exactly n lines: the i-th of them should contain the shortest non-empty sequence of digits, such that if Polycarp enters it, the Berdroid OS shows up only the i-th number from the contacts. If there are several such sequences, print any of them.
Examples
Input
3
123456789
100000000
100123456
Output
9
000
01
Input
4
123456789
193456789
134567819
934567891
Output
2
193
81
91
Submitted Solution:
```
h = [(i, j) for i in range(9) for j in range(i + 1, 9)]
n = int(input())
s, p = {}, [''] * n
for k in range(n):
t = input()
for q in [t[i: j] for i, j in h]:
s[q] = -1 if q in s and s[q] - k else k
for q, k in s.items():
if k >= 0:
if p[k]:
if len(p[k]) > len(q): p[k] = q
else:
p[k] = q
print('\n'.join(p))
``` | instruction | 0 | 39,289 | 24 | 78,578 |
No | output | 1 | 39,289 | 24 | 78,579 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n phone numbers in Polycarp's contacts on his phone. Each number is a 9-digit integer, starting with a digit different from 0. All the numbers are distinct.
There is the latest version of Berdroid OS installed on Polycarp's phone. If some number is entered, is shows up all the numbers in the contacts for which there is a substring equal to the entered sequence of digits. For example, is there are three phone numbers in Polycarp's contacts: 123456789, 100000000 and 100123456, then:
* if he enters 00 two numbers will show up: 100000000 and 100123456,
* if he enters 123 two numbers will show up 123456789 and 100123456,
* if he enters 01 there will be only one number 100123456.
For each of the phone numbers in Polycarp's contacts, find the minimum in length sequence of digits such that if Polycarp enters this sequence, Berdroid shows this only phone number.
Input
The first line contains single integer n (1 ≤ n ≤ 70000) — the total number of phone contacts in Polycarp's contacts.
The phone numbers follow, one in each line. Each number is a positive 9-digit integer starting with a digit from 1 to 9. All the numbers are distinct.
Output
Print exactly n lines: the i-th of them should contain the shortest non-empty sequence of digits, such that if Polycarp enters it, the Berdroid OS shows up only the i-th number from the contacts. If there are several such sequences, print any of them.
Examples
Input
3
123456789
100000000
100123456
Output
9
000
01
Input
4
123456789
193456789
134567819
934567891
Output
2
193
81
91
Submitted Solution:
```
indexs = []
for length in range(1, 10):
for start in range(0, 9 - length + 1):
indexs.append([start, start + length])
n = int(input())
used = {}
s = []
for i in range(n):
s.append(input())
for index in indexs:
used[s[-1][index[0]: index[1]]] = used.get(s[-1][index[0]: index[1]], 0) + 1
for num in s:
for index in indexs:
if used[num[index[0]: index[1]]] == 1:
print(num[index[0]: index[1]])
break
``` | instruction | 0 | 39,290 | 24 | 78,580 |
No | output | 1 | 39,290 | 24 | 78,581 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp knows that if the sum of the digits of a number is divisible by 3, then the number itself is divisible by 3. He assumes that the numbers, the sum of the digits of which is divisible by 4, are also somewhat interesting. Thus, he considers a positive integer n interesting if its sum of digits is divisible by 4.
Help Polycarp find the nearest larger or equal interesting number for the given number a. That is, find the interesting number n such that n ≥ a and n is minimal.
Input
The only line in the input contains an integer a (1 ≤ a ≤ 1000).
Output
Print the nearest greater or equal interesting number for the given number a. In other words, print the interesting number n such that n ≥ a and n is minimal.
Examples
Input
432
Output
435
Input
99
Output
103
Input
237
Output
237
Input
42
Output
44 | instruction | 0 | 39,673 | 24 | 79,346 |
Tags: implementation
Correct Solution:
```
a = str(input().strip())
add = 0
for i in (a):
add += int(i)
# temp = add
while (add % 4) != 0:
a = str(int(a)+ 1)
add = 0
for i in a:
add += int(i)
print(a)
``` | output | 1 | 39,673 | 24 | 79,347 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp knows that if the sum of the digits of a number is divisible by 3, then the number itself is divisible by 3. He assumes that the numbers, the sum of the digits of which is divisible by 4, are also somewhat interesting. Thus, he considers a positive integer n interesting if its sum of digits is divisible by 4.
Help Polycarp find the nearest larger or equal interesting number for the given number a. That is, find the interesting number n such that n ≥ a and n is minimal.
Input
The only line in the input contains an integer a (1 ≤ a ≤ 1000).
Output
Print the nearest greater or equal interesting number for the given number a. In other words, print the interesting number n such that n ≥ a and n is minimal.
Examples
Input
432
Output
435
Input
99
Output
103
Input
237
Output
237
Input
42
Output
44 | instruction | 0 | 39,676 | 24 | 79,352 |
Tags: implementation
Correct Solution:
```
# your code goes here
a=int(input())
res=0
while res==0:
l=list(map(int,list(str(a))))
if sum(l)%4==0:
res=a
break
a+=1
print(res)
``` | output | 1 | 39,676 | 24 | 79,353 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp knows that if the sum of the digits of a number is divisible by 3, then the number itself is divisible by 3. He assumes that the numbers, the sum of the digits of which is divisible by 4, are also somewhat interesting. Thus, he considers a positive integer n interesting if its sum of digits is divisible by 4.
Help Polycarp find the nearest larger or equal interesting number for the given number a. That is, find the interesting number n such that n ≥ a and n is minimal.
Input
The only line in the input contains an integer a (1 ≤ a ≤ 1000).
Output
Print the nearest greater or equal interesting number for the given number a. In other words, print the interesting number n such that n ≥ a and n is minimal.
Examples
Input
432
Output
435
Input
99
Output
103
Input
237
Output
237
Input
42
Output
44 | instruction | 0 | 39,679 | 24 | 79,358 |
Tags: implementation
Correct Solution:
```
a=[int(i) for i in list(input())]
while(True):
if(sum(a)%4==0):
a=[str(i) for i in a]
a="".join(a)
print(a)
exit()
else:
a=[str(i) for i in a]
a="".join(a)
a=int(a)+1
a=[int(i) for i in str(a)]
``` | output | 1 | 39,679 | 24 | 79,359 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp knows that if the sum of the digits of a number is divisible by 3, then the number itself is divisible by 3. He assumes that the numbers, the sum of the digits of which is divisible by 4, are also somewhat interesting. Thus, he considers a positive integer n interesting if its sum of digits is divisible by 4.
Help Polycarp find the nearest larger or equal interesting number for the given number a. That is, find the interesting number n such that n ≥ a and n is minimal.
Input
The only line in the input contains an integer a (1 ≤ a ≤ 1000).
Output
Print the nearest greater or equal interesting number for the given number a. In other words, print the interesting number n such that n ≥ a and n is minimal.
Examples
Input
432
Output
435
Input
99
Output
103
Input
237
Output
237
Input
42
Output
44
Submitted Solution:
```
a=int(input())
s=0
for i in str(a):
s+=int(i)
if s%4==0:
print(a)
else:
i=a
while(s%4!=0):
s=0
for j in str(i):
s+=int(j)
i+=1
print(i-1)
``` | instruction | 0 | 39,680 | 24 | 79,360 |
Yes | output | 1 | 39,680 | 24 | 79,361 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp knows that if the sum of the digits of a number is divisible by 3, then the number itself is divisible by 3. He assumes that the numbers, the sum of the digits of which is divisible by 4, are also somewhat interesting. Thus, he considers a positive integer n interesting if its sum of digits is divisible by 4.
Help Polycarp find the nearest larger or equal interesting number for the given number a. That is, find the interesting number n such that n ≥ a and n is minimal.
Input
The only line in the input contains an integer a (1 ≤ a ≤ 1000).
Output
Print the nearest greater or equal interesting number for the given number a. In other words, print the interesting number n such that n ≥ a and n is minimal.
Examples
Input
432
Output
435
Input
99
Output
103
Input
237
Output
237
Input
42
Output
44
Submitted Solution:
```
n=input()
sum=0
for i in n:
m=int(i)
sum+=m
if sum%4==0:
print(n)
else:
while sum%4!=0:
sum=0
for i in n:
m=int(i)
sum+=m
x=int(n)+1
n=str(x)
print(int(n)-1)
``` | instruction | 0 | 39,681 | 24 | 79,362 |
Yes | output | 1 | 39,681 | 24 | 79,363 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp knows that if the sum of the digits of a number is divisible by 3, then the number itself is divisible by 3. He assumes that the numbers, the sum of the digits of which is divisible by 4, are also somewhat interesting. Thus, he considers a positive integer n interesting if its sum of digits is divisible by 4.
Help Polycarp find the nearest larger or equal interesting number for the given number a. That is, find the interesting number n such that n ≥ a and n is minimal.
Input
The only line in the input contains an integer a (1 ≤ a ≤ 1000).
Output
Print the nearest greater or equal interesting number for the given number a. In other words, print the interesting number n such that n ≥ a and n is minimal.
Examples
Input
432
Output
435
Input
99
Output
103
Input
237
Output
237
Input
42
Output
44
Submitted Solution:
```
import sys
import math
n = int(input())
def sumNum(n):
sum=0
while(n!=0):
sum+=n%10
n=int(n/10)
return sum
for i in range(1000):
if(sumNum(n+i)%4==0):
print(n+i)
break
``` | instruction | 0 | 39,682 | 24 | 79,364 |
Yes | output | 1 | 39,682 | 24 | 79,365 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp knows that if the sum of the digits of a number is divisible by 3, then the number itself is divisible by 3. He assumes that the numbers, the sum of the digits of which is divisible by 4, are also somewhat interesting. Thus, he considers a positive integer n interesting if its sum of digits is divisible by 4.
Help Polycarp find the nearest larger or equal interesting number for the given number a. That is, find the interesting number n such that n ≥ a and n is minimal.
Input
The only line in the input contains an integer a (1 ≤ a ≤ 1000).
Output
Print the nearest greater or equal interesting number for the given number a. In other words, print the interesting number n such that n ≥ a and n is minimal.
Examples
Input
432
Output
435
Input
99
Output
103
Input
237
Output
237
Input
42
Output
44
Submitted Solution:
```
from sys import stdin,stdout
import bisect
import math
def st():
return list(stdin.readline().strip())
def inp():
return int(stdin.readline())
def li():
return list(map(int,stdin.readline().split()))
def mp():
return map(int,stdin.readline().split())
def pr(n):
stdout.write(str(n)+"\n")
def soe(limit):
l=[1]*(limit+1)
pp=[0]*(limit+1)
prime=[]
l[0]=0
l[1]=0
c=0
for i in range(2,limit+1):
if l[i]:
for j in range(i*i,limit+1,i):
l[j]=0
for i in range(2,limit+1):
if l[i]==1:
c+=1
if l[c]==1:
pp[i]=1
for i in range(1,limit+1):
pp[i]+=pp[i-1]
return pp
def segsoe(low,high):
limit=int(high**0.5)+1
prime=soe(limit)
n=high-low+1
l=[0]*(n+1)
for i in range(len(prime)):
lowlimit=(low//prime[i])*prime[i]
if lowlimit<low:
lowlimit+=prime[i]
if lowlimit==prime[i]:
lowlimit+=prime[i]
for j in range(lowlimit,high+1,prime[i]):
l[j-low]=1
for i in range(low,high+1):
if not l[i-low]:
if i!=1:
print(i)
def gcd(a,b):
while b:
a=a%b
b,a=a,b
return a
def power(a,n):
r=1
while n:
if n&1:
r=(r*a)
a*=a
n=n>>1
return r
def su(n):
s=0
while n:
s+=n%10
n//=10
return s
def solve():
n=inp()
while True:
if su(n)%4==0:
print(n)
return
n+=1
for _ in range(1):
solve()
``` | instruction | 0 | 39,683 | 24 | 79,366 |
Yes | output | 1 | 39,683 | 24 | 79,367 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp knows that if the sum of the digits of a number is divisible by 3, then the number itself is divisible by 3. He assumes that the numbers, the sum of the digits of which is divisible by 4, are also somewhat interesting. Thus, he considers a positive integer n interesting if its sum of digits is divisible by 4.
Help Polycarp find the nearest larger or equal interesting number for the given number a. That is, find the interesting number n such that n ≥ a and n is minimal.
Input
The only line in the input contains an integer a (1 ≤ a ≤ 1000).
Output
Print the nearest greater or equal interesting number for the given number a. In other words, print the interesting number n such that n ≥ a and n is minimal.
Examples
Input
432
Output
435
Input
99
Output
103
Input
237
Output
237
Input
42
Output
44
Submitted Solution:
```
n = int(input())
for x in range(n, n ** 2):
if (x // 1000 + x % 1000 // 100 + x % 100 // 10 + x % 10) % 4 == 0:
print(x)
break
``` | instruction | 0 | 39,684 | 24 | 79,368 |
No | output | 1 | 39,684 | 24 | 79,369 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp knows that if the sum of the digits of a number is divisible by 3, then the number itself is divisible by 3. He assumes that the numbers, the sum of the digits of which is divisible by 4, are also somewhat interesting. Thus, he considers a positive integer n interesting if its sum of digits is divisible by 4.
Help Polycarp find the nearest larger or equal interesting number for the given number a. That is, find the interesting number n such that n ≥ a and n is minimal.
Input
The only line in the input contains an integer a (1 ≤ a ≤ 1000).
Output
Print the nearest greater or equal interesting number for the given number a. In other words, print the interesting number n such that n ≥ a and n is minimal.
Examples
Input
432
Output
435
Input
99
Output
103
Input
237
Output
237
Input
42
Output
44
Submitted Solution:
```
n = input()
def check(n):
s = list(n)
ans = 0
for i in range(len(s)):
ans += int(s[i])
return ans
while True:
n = int(n) + 1
ans = check(str(n))
if ans % 4 == 0:
break
print(n)
``` | instruction | 0 | 39,685 | 24 | 79,370 |
No | output | 1 | 39,685 | 24 | 79,371 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp knows that if the sum of the digits of a number is divisible by 3, then the number itself is divisible by 3. He assumes that the numbers, the sum of the digits of which is divisible by 4, are also somewhat interesting. Thus, he considers a positive integer n interesting if its sum of digits is divisible by 4.
Help Polycarp find the nearest larger or equal interesting number for the given number a. That is, find the interesting number n such that n ≥ a and n is minimal.
Input
The only line in the input contains an integer a (1 ≤ a ≤ 1000).
Output
Print the nearest greater or equal interesting number for the given number a. In other words, print the interesting number n such that n ≥ a and n is minimal.
Examples
Input
432
Output
435
Input
99
Output
103
Input
237
Output
237
Input
42
Output
44
Submitted Solution:
```
def divBy4(n):
sint = 0
for s in str(n):
sint += int(s)
if sint % 4 == 0:
return True
else:
return False
def mainFunc(n):
if divBy4(n):
return n
for x in range(1, 5):
newNum = n + x
if divBy4(newNum):
return newNum
n = int(input())
print(mainFunc(n))
``` | instruction | 0 | 39,686 | 24 | 79,372 |
No | output | 1 | 39,686 | 24 | 79,373 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp knows that if the sum of the digits of a number is divisible by 3, then the number itself is divisible by 3. He assumes that the numbers, the sum of the digits of which is divisible by 4, are also somewhat interesting. Thus, he considers a positive integer n interesting if its sum of digits is divisible by 4.
Help Polycarp find the nearest larger or equal interesting number for the given number a. That is, find the interesting number n such that n ≥ a and n is minimal.
Input
The only line in the input contains an integer a (1 ≤ a ≤ 1000).
Output
Print the nearest greater or equal interesting number for the given number a. In other words, print the interesting number n such that n ≥ a and n is minimal.
Examples
Input
432
Output
435
Input
99
Output
103
Input
237
Output
237
Input
42
Output
44
Submitted Solution:
```
n = int(input())
plus = sum(map(int,str(n)))%4
print(n + (4-plus))
``` | instruction | 0 | 39,687 | 24 | 79,374 |
No | output | 1 | 39,687 | 24 | 79,375 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n phone numbers in Polycarp's contacts on his phone. Each number is a 9-digit integer, starting with a digit different from 0. All the numbers are distinct.
There is the latest version of Berdroid OS installed on Polycarp's phone. If some number is entered, is shows up all the numbers in the contacts for which there is a substring equal to the entered sequence of digits. For example, is there are three phone numbers in Polycarp's contacts: 123456789, 100000000 and 100123456, then:
* if he enters 00 two numbers will show up: 100000000 and 100123456,
* if he enters 123 two numbers will show up 123456789 and 100123456,
* if he enters 01 there will be only one number 100123456.
For each of the phone numbers in Polycarp's contacts, find the minimum in length sequence of digits such that if Polycarp enters this sequence, Berdroid shows this only phone number.
Input
The first line contains single integer n (1 ≤ n ≤ 70000) — the total number of phone contacts in Polycarp's contacts.
The phone numbers follow, one in each line. Each number is a positive 9-digit integer starting with a digit from 1 to 9. All the numbers are distinct.
Output
Print exactly n lines: the i-th of them should contain the shortest non-empty sequence of digits, such that if Polycarp enters it, the Berdroid OS shows up only the i-th number from the contacts. If there are several such sequences, print any of them.
Examples
Input
3
123456789
100000000
100123456
Output
9
000
01
Input
4
123456789
193456789
134567819
934567891
Output
2
193
81
91 | instruction | 0 | 40,119 | 24 | 80,238 |
Tags: data structures, implementation, sortings
Correct Solution:
```
n = int(input())
numbers = []
for i in range(0,n):
number = input()
numbers.append(number)
telep = {}
count = 1
for number in numbers:
for l in range(1, len(number)+1):
for i in range(0, len(number) - l + 1):
key = number[i:i + l]
if (key in telep) and (telep[key]!=count):
telep[key]=-1
else:
telep[key]=count
count += 1
reverse = {}
for key in telep:
if telep[key]==-1:
continue
elif (telep[key] not in reverse):
reverse[telep[key]] = key
elif ((len(key))<len(reverse[telep[key]])):
reverse[telep[key]]=key
for i in range(1, n+1):
print(reverse[i])
``` | output | 1 | 40,119 | 24 | 80,239 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n phone numbers in Polycarp's contacts on his phone. Each number is a 9-digit integer, starting with a digit different from 0. All the numbers are distinct.
There is the latest version of Berdroid OS installed on Polycarp's phone. If some number is entered, is shows up all the numbers in the contacts for which there is a substring equal to the entered sequence of digits. For example, is there are three phone numbers in Polycarp's contacts: 123456789, 100000000 and 100123456, then:
* if he enters 00 two numbers will show up: 100000000 and 100123456,
* if he enters 123 two numbers will show up 123456789 and 100123456,
* if he enters 01 there will be only one number 100123456.
For each of the phone numbers in Polycarp's contacts, find the minimum in length sequence of digits such that if Polycarp enters this sequence, Berdroid shows this only phone number.
Input
The first line contains single integer n (1 ≤ n ≤ 70000) — the total number of phone contacts in Polycarp's contacts.
The phone numbers follow, one in each line. Each number is a positive 9-digit integer starting with a digit from 1 to 9. All the numbers are distinct.
Output
Print exactly n lines: the i-th of them should contain the shortest non-empty sequence of digits, such that if Polycarp enters it, the Berdroid OS shows up only the i-th number from the contacts. If there are several such sequences, print any of them.
Examples
Input
3
123456789
100000000
100123456
Output
9
000
01
Input
4
123456789
193456789
134567819
934567891
Output
2
193
81
91 | instruction | 0 | 40,120 | 24 | 80,240 |
Tags: data structures, implementation, sortings
Correct Solution:
```
import math
from collections import *
a=int(input())
indx=defaultdict(list)
done=defaultdict(list)
for t in range(a):
s=input()
for i in range(len(s)):
for j in range(i,len(s)):
m=s[i:j+1]
if(len(done[m])==0):
done[m].append(t)
indx[t].append(m)
else:
if(len(done[m])==1 and done[m][0]!=math.inf and t!=done[m][0]):
indx[done[m][0]].remove(m)
done[m][0]=math.inf
for i in range(a):
af=indx[i]
mini=15
ss=''
for i in range(len(af)):
if(len(af[i])<mini):
mini=len(af[i])
ss=af[i]
print(ss)
``` | output | 1 | 40,120 | 24 | 80,241 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n phone numbers in Polycarp's contacts on his phone. Each number is a 9-digit integer, starting with a digit different from 0. All the numbers are distinct.
There is the latest version of Berdroid OS installed on Polycarp's phone. If some number is entered, is shows up all the numbers in the contacts for which there is a substring equal to the entered sequence of digits. For example, is there are three phone numbers in Polycarp's contacts: 123456789, 100000000 and 100123456, then:
* if he enters 00 two numbers will show up: 100000000 and 100123456,
* if he enters 123 two numbers will show up 123456789 and 100123456,
* if he enters 01 there will be only one number 100123456.
For each of the phone numbers in Polycarp's contacts, find the minimum in length sequence of digits such that if Polycarp enters this sequence, Berdroid shows this only phone number.
Input
The first line contains single integer n (1 ≤ n ≤ 70000) — the total number of phone contacts in Polycarp's contacts.
The phone numbers follow, one in each line. Each number is a positive 9-digit integer starting with a digit from 1 to 9. All the numbers are distinct.
Output
Print exactly n lines: the i-th of them should contain the shortest non-empty sequence of digits, such that if Polycarp enters it, the Berdroid OS shows up only the i-th number from the contacts. If there are several such sequences, print any of them.
Examples
Input
3
123456789
100000000
100123456
Output
9
000
01
Input
4
123456789
193456789
134567819
934567891
Output
2
193
81
91 | instruction | 0 | 40,121 | 24 | 80,242 |
Tags: data structures, implementation, sortings
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#######################################
n=int(input())
l=[]
for i in range(n):
l.append(input())
from collections import defaultdict
d=defaultdict(int)
d1=defaultdict(list)
for i in range(n):
d2=defaultdict(int)
for j in range(9):
s=l[i][j]
if d2[s]==0:
d[s]+=1
d2[s]+=1
d1[i].append(s)
for k in range(j+1,9):
s+=l[i][k]
if d2[s]==0:
d[s]+=1
d2[s]+=1
if d[s]==1:
d1[i].append(s)
d1[i].sort(key=len)
for i in range(n):
for j in d1[i]:
if d[j]==1:
print(j)
break
``` | output | 1 | 40,121 | 24 | 80,243 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n phone numbers in Polycarp's contacts on his phone. Each number is a 9-digit integer, starting with a digit different from 0. All the numbers are distinct.
There is the latest version of Berdroid OS installed on Polycarp's phone. If some number is entered, is shows up all the numbers in the contacts for which there is a substring equal to the entered sequence of digits. For example, is there are three phone numbers in Polycarp's contacts: 123456789, 100000000 and 100123456, then:
* if he enters 00 two numbers will show up: 100000000 and 100123456,
* if he enters 123 two numbers will show up 123456789 and 100123456,
* if he enters 01 there will be only one number 100123456.
For each of the phone numbers in Polycarp's contacts, find the minimum in length sequence of digits such that if Polycarp enters this sequence, Berdroid shows this only phone number.
Input
The first line contains single integer n (1 ≤ n ≤ 70000) — the total number of phone contacts in Polycarp's contacts.
The phone numbers follow, one in each line. Each number is a positive 9-digit integer starting with a digit from 1 to 9. All the numbers are distinct.
Output
Print exactly n lines: the i-th of them should contain the shortest non-empty sequence of digits, such that if Polycarp enters it, the Berdroid OS shows up only the i-th number from the contacts. If there are several such sequences, print any of them.
Examples
Input
3
123456789
100000000
100123456
Output
9
000
01
Input
4
123456789
193456789
134567819
934567891
Output
2
193
81
91 | instruction | 0 | 40,122 | 24 | 80,244 |
Tags: data structures, implementation, sortings
Correct Solution:
```
"""
-----------------------------Pseudo---------------------------------
"""
import sys
from collections import defaultdict
def input(): return sys.stdin.readline()
def print(arg, *argv, end=None):
sys.stdout.write(str(arg))
for i in argv: sys.stdout.write(" "+str(i))
sys.stdout.write(end) if end or end=="" else sys.stdout.write("\n")
def mapi(): return map(int,input().split())
def maps(): return map(str,input().split())
#---------------------------------------------------------------#
def solve():
t = 1
#t = int(input())
for _ in range(t):
n = int(input())
ss = []
a = []
mem = defaultdict(int)
for __ in range(n):
x = input().strip()
a.append(x)
sett = set()
for i in range(9):
for j in range(i+1,10):
sett.add(x[i:j])
for it in sett:
mem[it]+=1
for id in range(n):
length = 1
flag = True
while length<10 and flag:
i = 0
j = length
while i<9 and j<10:
tmp = a[id][i:j]
if mem[tmp]==1:
print(tmp)
flag = False
break
i+=1
j+=1
length+=1
#---------------------------------------------------------------#
if __name__ == '__main__':
solve()
``` | output | 1 | 40,122 | 24 | 80,245 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n phone numbers in Polycarp's contacts on his phone. Each number is a 9-digit integer, starting with a digit different from 0. All the numbers are distinct.
There is the latest version of Berdroid OS installed on Polycarp's phone. If some number is entered, is shows up all the numbers in the contacts for which there is a substring equal to the entered sequence of digits. For example, is there are three phone numbers in Polycarp's contacts: 123456789, 100000000 and 100123456, then:
* if he enters 00 two numbers will show up: 100000000 and 100123456,
* if he enters 123 two numbers will show up 123456789 and 100123456,
* if he enters 01 there will be only one number 100123456.
For each of the phone numbers in Polycarp's contacts, find the minimum in length sequence of digits such that if Polycarp enters this sequence, Berdroid shows this only phone number.
Input
The first line contains single integer n (1 ≤ n ≤ 70000) — the total number of phone contacts in Polycarp's contacts.
The phone numbers follow, one in each line. Each number is a positive 9-digit integer starting with a digit from 1 to 9. All the numbers are distinct.
Output
Print exactly n lines: the i-th of them should contain the shortest non-empty sequence of digits, such that if Polycarp enters it, the Berdroid OS shows up only the i-th number from the contacts. If there are several such sequences, print any of them.
Examples
Input
3
123456789
100000000
100123456
Output
9
000
01
Input
4
123456789
193456789
134567819
934567891
Output
2
193
81
91 | instruction | 0 | 40,123 | 24 | 80,246 |
Tags: data structures, implementation, sortings
Correct Solution:
```
h = [(i, j) for i in range(9) for j in range(i + 1, 10)]
n = int(input())
s, p = {}, [''] * n
for k in range(n):
t = input()
for q in [t[i: j] for i, j in h]:
s[q] = -1 if q in s and s[q] != k else k
for q, k in s.items():
if k >= 0:
if p[k]:
if len(p[k]) > len(q): p[k] = q
else:
p[k] = q
print('\n'.join(p))
``` | output | 1 | 40,123 | 24 | 80,247 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n phone numbers in Polycarp's contacts on his phone. Each number is a 9-digit integer, starting with a digit different from 0. All the numbers are distinct.
There is the latest version of Berdroid OS installed on Polycarp's phone. If some number is entered, is shows up all the numbers in the contacts for which there is a substring equal to the entered sequence of digits. For example, is there are three phone numbers in Polycarp's contacts: 123456789, 100000000 and 100123456, then:
* if he enters 00 two numbers will show up: 100000000 and 100123456,
* if he enters 123 two numbers will show up 123456789 and 100123456,
* if he enters 01 there will be only one number 100123456.
For each of the phone numbers in Polycarp's contacts, find the minimum in length sequence of digits such that if Polycarp enters this sequence, Berdroid shows this only phone number.
Input
The first line contains single integer n (1 ≤ n ≤ 70000) — the total number of phone contacts in Polycarp's contacts.
The phone numbers follow, one in each line. Each number is a positive 9-digit integer starting with a digit from 1 to 9. All the numbers are distinct.
Output
Print exactly n lines: the i-th of them should contain the shortest non-empty sequence of digits, such that if Polycarp enters it, the Berdroid OS shows up only the i-th number from the contacts. If there are several such sequences, print any of them.
Examples
Input
3
123456789
100000000
100123456
Output
9
000
01
Input
4
123456789
193456789
134567819
934567891
Output
2
193
81
91 | instruction | 0 | 40,124 | 24 | 80,248 |
Tags: data structures, implementation, sortings
Correct Solution:
```
def podstroki(s):
return sorted(set(s[i: i1] for i in range(9) for i1 in range (i+1, 10)), key=len)
res = {}
spisok = [podstroki(input()) for i in range (int(input()))]
for s in spisok:
for podstr in s:
if podstr in res:
res[podstr] += 1
else:
res[podstr] = 1
for s in spisok:
for podstr in s:
if res[podstr] == 1:
print(podstr)
break
``` | output | 1 | 40,124 | 24 | 80,249 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n phone numbers in Polycarp's contacts on his phone. Each number is a 9-digit integer, starting with a digit different from 0. All the numbers are distinct.
There is the latest version of Berdroid OS installed on Polycarp's phone. If some number is entered, is shows up all the numbers in the contacts for which there is a substring equal to the entered sequence of digits. For example, is there are three phone numbers in Polycarp's contacts: 123456789, 100000000 and 100123456, then:
* if he enters 00 two numbers will show up: 100000000 and 100123456,
* if he enters 123 two numbers will show up 123456789 and 100123456,
* if he enters 01 there will be only one number 100123456.
For each of the phone numbers in Polycarp's contacts, find the minimum in length sequence of digits such that if Polycarp enters this sequence, Berdroid shows this only phone number.
Input
The first line contains single integer n (1 ≤ n ≤ 70000) — the total number of phone contacts in Polycarp's contacts.
The phone numbers follow, one in each line. Each number is a positive 9-digit integer starting with a digit from 1 to 9. All the numbers are distinct.
Output
Print exactly n lines: the i-th of them should contain the shortest non-empty sequence of digits, such that if Polycarp enters it, the Berdroid OS shows up only the i-th number from the contacts. If there are several such sequences, print any of them.
Examples
Input
3
123456789
100000000
100123456
Output
9
000
01
Input
4
123456789
193456789
134567819
934567891
Output
2
193
81
91 | instruction | 0 | 40,125 | 24 | 80,250 |
Tags: data structures, implementation, sortings
Correct Solution:
```
n=int(input())
a=[]
d={}
for _ in range(n):
s=input()
g=set()
for i in range(len(s)):
for k in range(i,len(s)):
st=s[i:k+1]
if st in g:
continue
else:
g.add(st)
if st in d:
d[st]+=1
else:
d[st]=1
a.append(s)
for s in a:
ans=s
for i in range(len(s)):
for j in range(i,len(s)):
k=s[i:j+1]
if d[k]==1 and len(k) < len(ans):
ans=k
print(ans)
``` | output | 1 | 40,125 | 24 | 80,251 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n phone numbers in Polycarp's contacts on his phone. Each number is a 9-digit integer, starting with a digit different from 0. All the numbers are distinct.
There is the latest version of Berdroid OS installed on Polycarp's phone. If some number is entered, is shows up all the numbers in the contacts for which there is a substring equal to the entered sequence of digits. For example, is there are three phone numbers in Polycarp's contacts: 123456789, 100000000 and 100123456, then:
* if he enters 00 two numbers will show up: 100000000 and 100123456,
* if he enters 123 two numbers will show up 123456789 and 100123456,
* if he enters 01 there will be only one number 100123456.
For each of the phone numbers in Polycarp's contacts, find the minimum in length sequence of digits such that if Polycarp enters this sequence, Berdroid shows this only phone number.
Input
The first line contains single integer n (1 ≤ n ≤ 70000) — the total number of phone contacts in Polycarp's contacts.
The phone numbers follow, one in each line. Each number is a positive 9-digit integer starting with a digit from 1 to 9. All the numbers are distinct.
Output
Print exactly n lines: the i-th of them should contain the shortest non-empty sequence of digits, such that if Polycarp enters it, the Berdroid OS shows up only the i-th number from the contacts. If there are several such sequences, print any of them.
Examples
Input
3
123456789
100000000
100123456
Output
9
000
01
Input
4
123456789
193456789
134567819
934567891
Output
2
193
81
91 | instruction | 0 | 40,126 | 24 | 80,252 |
Tags: data structures, implementation, sortings
Correct Solution:
```
n = int(input())
l = []
for i in range(n):
l.append(input())
d = {}
for k in l:
for i in range(1, 9 + 1):
for j in range(9 - i + 1):
a = k[j:j + i]
z = d.keys()
if a in z:
if k != d.get(a)[1]:
w = d.get(a)
w[0] += 1
w[1] = k
d.update({a: w})
else:
d.update({a: [1, k]})
r = list(d.items())
ans = []
for i in r:
if i[1][0] == 1:
ans.append([i[0], i[1][1]])
d1 = {}
for i in ans:
z = d1.keys()
if i[1] in z:
if len(str(i[0])) < len(str(d1.get(i[1]))):
d1.update({i[1]: i[0]})
else:
d1.update({i[1]: i[0]})
for i in l:
print(d1.get(i))
``` | output | 1 | 40,126 | 24 | 80,253 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n phone numbers in Polycarp's contacts on his phone. Each number is a 9-digit integer, starting with a digit different from 0. All the numbers are distinct.
There is the latest version of Berdroid OS installed on Polycarp's phone. If some number is entered, is shows up all the numbers in the contacts for which there is a substring equal to the entered sequence of digits. For example, is there are three phone numbers in Polycarp's contacts: 123456789, 100000000 and 100123456, then:
* if he enters 00 two numbers will show up: 100000000 and 100123456,
* if he enters 123 two numbers will show up 123456789 and 100123456,
* if he enters 01 there will be only one number 100123456.
For each of the phone numbers in Polycarp's contacts, find the minimum in length sequence of digits such that if Polycarp enters this sequence, Berdroid shows this only phone number.
Input
The first line contains single integer n (1 ≤ n ≤ 70000) — the total number of phone contacts in Polycarp's contacts.
The phone numbers follow, one in each line. Each number is a positive 9-digit integer starting with a digit from 1 to 9. All the numbers are distinct.
Output
Print exactly n lines: the i-th of them should contain the shortest non-empty sequence of digits, such that if Polycarp enters it, the Berdroid OS shows up only the i-th number from the contacts. If there are several such sequences, print any of them.
Examples
Input
3
123456789
100000000
100123456
Output
9
000
01
Input
4
123456789
193456789
134567819
934567891
Output
2
193
81
91
Submitted Solution:
```
def rec(i):
global a
return i
import sys
from collections import Counter
sys.setrecursionlimit(10**6)
n=int(input())
#n,m=list(map(int,input().split()))
a=[input() for i in range(n)]
b=[]
a0=set()
c0=set()
for i in a:
c=set()
for i0 in range(1,10):
for i1 in range(0,10-i0):
c.add(i[i1:i1+i0])
b.append(c)
c0.update(a0&c)
a0.update(c)
for i in b:
c=i-c0
z='0'*10
for i0 in c:
if len(i0)<len(z):
z=i0
print(z)
``` | instruction | 0 | 40,127 | 24 | 80,254 |
Yes | output | 1 | 40,127 | 24 | 80,255 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n phone numbers in Polycarp's contacts on his phone. Each number is a 9-digit integer, starting with a digit different from 0. All the numbers are distinct.
There is the latest version of Berdroid OS installed on Polycarp's phone. If some number is entered, is shows up all the numbers in the contacts for which there is a substring equal to the entered sequence of digits. For example, is there are three phone numbers in Polycarp's contacts: 123456789, 100000000 and 100123456, then:
* if he enters 00 two numbers will show up: 100000000 and 100123456,
* if he enters 123 two numbers will show up 123456789 and 100123456,
* if he enters 01 there will be only one number 100123456.
For each of the phone numbers in Polycarp's contacts, find the minimum in length sequence of digits such that if Polycarp enters this sequence, Berdroid shows this only phone number.
Input
The first line contains single integer n (1 ≤ n ≤ 70000) — the total number of phone contacts in Polycarp's contacts.
The phone numbers follow, one in each line. Each number is a positive 9-digit integer starting with a digit from 1 to 9. All the numbers are distinct.
Output
Print exactly n lines: the i-th of them should contain the shortest non-empty sequence of digits, such that if Polycarp enters it, the Berdroid OS shows up only the i-th number from the contacts. If there are several such sequences, print any of them.
Examples
Input
3
123456789
100000000
100123456
Output
9
000
01
Input
4
123456789
193456789
134567819
934567891
Output
2
193
81
91
Submitted Solution:
```
n=int(input())
q={}
z=[input() for i in range(n)]
for s in z:
w=set()
for i in range(len(s)):
for j in range(i,len(s)):
k=s[i:j+1]
if k in w: continue
else: w.add(k)
if k in q: q[k]+=1
else: q[k]=1
for s in z:
r=s
for i in range(len(s)):
for j in range(i,len(s)):
k=s[i:j+1]
if q[k]==1 and len(k)<len(r): r=k
print(r)
``` | instruction | 0 | 40,128 | 24 | 80,256 |
Yes | output | 1 | 40,128 | 24 | 80,257 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n phone numbers in Polycarp's contacts on his phone. Each number is a 9-digit integer, starting with a digit different from 0. All the numbers are distinct.
There is the latest version of Berdroid OS installed on Polycarp's phone. If some number is entered, is shows up all the numbers in the contacts for which there is a substring equal to the entered sequence of digits. For example, is there are three phone numbers in Polycarp's contacts: 123456789, 100000000 and 100123456, then:
* if he enters 00 two numbers will show up: 100000000 and 100123456,
* if he enters 123 two numbers will show up 123456789 and 100123456,
* if he enters 01 there will be only one number 100123456.
For each of the phone numbers in Polycarp's contacts, find the minimum in length sequence of digits such that if Polycarp enters this sequence, Berdroid shows this only phone number.
Input
The first line contains single integer n (1 ≤ n ≤ 70000) — the total number of phone contacts in Polycarp's contacts.
The phone numbers follow, one in each line. Each number is a positive 9-digit integer starting with a digit from 1 to 9. All the numbers are distinct.
Output
Print exactly n lines: the i-th of them should contain the shortest non-empty sequence of digits, such that if Polycarp enters it, the Berdroid OS shows up only the i-th number from the contacts. If there are several such sequences, print any of them.
Examples
Input
3
123456789
100000000
100123456
Output
9
000
01
Input
4
123456789
193456789
134567819
934567891
Output
2
193
81
91
Submitted Solution:
```
from collections import defaultdict
def subs(s):
for l in range(1, len(s) + 1):
for shift in range(0, len(s) - l + 1):
yield s[shift : shift + l]
n = int(input())
vs = [input() for _ in range(n)]
entries = defaultdict(set)
for i, s in enumerate(vs):
for sub in subs(s):
entries[sub].add(i)
for s in vs:
for sub in subs(s):
if len(entries[sub]) == 1:
print(sub)
break
``` | instruction | 0 | 40,129 | 24 | 80,258 |
Yes | output | 1 | 40,129 | 24 | 80,259 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n phone numbers in Polycarp's contacts on his phone. Each number is a 9-digit integer, starting with a digit different from 0. All the numbers are distinct.
There is the latest version of Berdroid OS installed on Polycarp's phone. If some number is entered, is shows up all the numbers in the contacts for which there is a substring equal to the entered sequence of digits. For example, is there are three phone numbers in Polycarp's contacts: 123456789, 100000000 and 100123456, then:
* if he enters 00 two numbers will show up: 100000000 and 100123456,
* if he enters 123 two numbers will show up 123456789 and 100123456,
* if he enters 01 there will be only one number 100123456.
For each of the phone numbers in Polycarp's contacts, find the minimum in length sequence of digits such that if Polycarp enters this sequence, Berdroid shows this only phone number.
Input
The first line contains single integer n (1 ≤ n ≤ 70000) — the total number of phone contacts in Polycarp's contacts.
The phone numbers follow, one in each line. Each number is a positive 9-digit integer starting with a digit from 1 to 9. All the numbers are distinct.
Output
Print exactly n lines: the i-th of them should contain the shortest non-empty sequence of digits, such that if Polycarp enters it, the Berdroid OS shows up only the i-th number from the contacts. If there are several such sequences, print any of them.
Examples
Input
3
123456789
100000000
100123456
Output
9
000
01
Input
4
123456789
193456789
134567819
934567891
Output
2
193
81
91
Submitted Solution:
```
n = int(input())
a = []
d = {}
for b in range(n):
s = input()
g = set()
for i in range(len(s)):
for k in range(i, len(s)):
w = s[i:k + 1]
if w in g:
continue
else:
g.add(w)
if w in d:
d[w] += 1
else:
d[w] = 1
a.append(s)
for s in a:
ans = s
for i in range(len(s)):
for j in range(i, len(s)):
k = s[i:j + 1]
if d[k] == 1 and len(k) < len(ans):
ans = k
print(ans)
``` | instruction | 0 | 40,130 | 24 | 80,260 |
Yes | output | 1 | 40,130 | 24 | 80,261 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n phone numbers in Polycarp's contacts on his phone. Each number is a 9-digit integer, starting with a digit different from 0. All the numbers are distinct.
There is the latest version of Berdroid OS installed on Polycarp's phone. If some number is entered, is shows up all the numbers in the contacts for which there is a substring equal to the entered sequence of digits. For example, is there are three phone numbers in Polycarp's contacts: 123456789, 100000000 and 100123456, then:
* if he enters 00 two numbers will show up: 100000000 and 100123456,
* if he enters 123 two numbers will show up 123456789 and 100123456,
* if he enters 01 there will be only one number 100123456.
For each of the phone numbers in Polycarp's contacts, find the minimum in length sequence of digits such that if Polycarp enters this sequence, Berdroid shows this only phone number.
Input
The first line contains single integer n (1 ≤ n ≤ 70000) — the total number of phone contacts in Polycarp's contacts.
The phone numbers follow, one in each line. Each number is a positive 9-digit integer starting with a digit from 1 to 9. All the numbers are distinct.
Output
Print exactly n lines: the i-th of them should contain the shortest non-empty sequence of digits, such that if Polycarp enters it, the Berdroid OS shows up only the i-th number from the contacts. If there are several such sequences, print any of them.
Examples
Input
3
123456789
100000000
100123456
Output
9
000
01
Input
4
123456789
193456789
134567819
934567891
Output
2
193
81
91
Submitted Solution:
```
n = int(input())
numbers = []
for i in range(0,n):
number = input()
numbers.append(number)
telep = {}
count = 1
for number in numbers:
for l in range(1, len(number)+1):
for i in range(0, len(number) - l + 1):
key = number[i:i + l]
if (key in telep) and (telep[key]!=count):
telep[key]=-1
else:
telep[key]=count
count += 1
for i in range(1, n+1):
mini = 10
for key in telep:
if telep[key]==n:
if len(key)<mini:
mini = telep[key]
print(mini)
``` | instruction | 0 | 40,131 | 24 | 80,262 |
No | output | 1 | 40,131 | 24 | 80,263 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n phone numbers in Polycarp's contacts on his phone. Each number is a 9-digit integer, starting with a digit different from 0. All the numbers are distinct.
There is the latest version of Berdroid OS installed on Polycarp's phone. If some number is entered, is shows up all the numbers in the contacts for which there is a substring equal to the entered sequence of digits. For example, is there are three phone numbers in Polycarp's contacts: 123456789, 100000000 and 100123456, then:
* if he enters 00 two numbers will show up: 100000000 and 100123456,
* if he enters 123 two numbers will show up 123456789 and 100123456,
* if he enters 01 there will be only one number 100123456.
For each of the phone numbers in Polycarp's contacts, find the minimum in length sequence of digits such that if Polycarp enters this sequence, Berdroid shows this only phone number.
Input
The first line contains single integer n (1 ≤ n ≤ 70000) — the total number of phone contacts in Polycarp's contacts.
The phone numbers follow, one in each line. Each number is a positive 9-digit integer starting with a digit from 1 to 9. All the numbers are distinct.
Output
Print exactly n lines: the i-th of them should contain the shortest non-empty sequence of digits, such that if Polycarp enters it, the Berdroid OS shows up only the i-th number from the contacts. If there are several such sequences, print any of them.
Examples
Input
3
123456789
100000000
100123456
Output
9
000
01
Input
4
123456789
193456789
134567819
934567891
Output
2
193
81
91
Submitted Solution:
```
h = [(i, j) for i in range(9) for j in range(i + 1, 9)]
n = int(input())
s, p = {}, [''] * n
for k in range(n):
t = input()
for q in [t[i: j] for i, j in h]:
s[q] = -1 if q in s and s[q] - k else k
for q, k in s.items():
if k >= 0:
if p[k]:
if len(p[k]) > len(q): p[k] = q
else:
p[k] = q
print('\n'.join(p))
``` | instruction | 0 | 40,132 | 24 | 80,264 |
No | output | 1 | 40,132 | 24 | 80,265 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n phone numbers in Polycarp's contacts on his phone. Each number is a 9-digit integer, starting with a digit different from 0. All the numbers are distinct.
There is the latest version of Berdroid OS installed on Polycarp's phone. If some number is entered, is shows up all the numbers in the contacts for which there is a substring equal to the entered sequence of digits. For example, is there are three phone numbers in Polycarp's contacts: 123456789, 100000000 and 100123456, then:
* if he enters 00 two numbers will show up: 100000000 and 100123456,
* if he enters 123 two numbers will show up 123456789 and 100123456,
* if he enters 01 there will be only one number 100123456.
For each of the phone numbers in Polycarp's contacts, find the minimum in length sequence of digits such that if Polycarp enters this sequence, Berdroid shows this only phone number.
Input
The first line contains single integer n (1 ≤ n ≤ 70000) — the total number of phone contacts in Polycarp's contacts.
The phone numbers follow, one in each line. Each number is a positive 9-digit integer starting with a digit from 1 to 9. All the numbers are distinct.
Output
Print exactly n lines: the i-th of them should contain the shortest non-empty sequence of digits, such that if Polycarp enters it, the Berdroid OS shows up only the i-th number from the contacts. If there are several such sequences, print any of them.
Examples
Input
3
123456789
100000000
100123456
Output
9
000
01
Input
4
123456789
193456789
134567819
934567891
Output
2
193
81
91
Submitted Solution:
```
n = int(input())
numbers = []
for i in range(0,n):
number = input()
numbers.append(number)
telep = {}
count = 1
for number in numbers:
for l in range(1, len(number)+1):
for i in range(0, len(number) - l + 1):
key = number[i:i + l]
if (key in telep) and (telep[key]!=count):
telep[key]=-1
else:
telep[key]=count
count += 1
for i in range(1, n+1):
mini = '0000000000'
for key in telep:
if telep[key]==n:
if len(key)<len(mini):
mini = key
print(mini)
``` | instruction | 0 | 40,133 | 24 | 80,266 |
No | output | 1 | 40,133 | 24 | 80,267 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n phone numbers in Polycarp's contacts on his phone. Each number is a 9-digit integer, starting with a digit different from 0. All the numbers are distinct.
There is the latest version of Berdroid OS installed on Polycarp's phone. If some number is entered, is shows up all the numbers in the contacts for which there is a substring equal to the entered sequence of digits. For example, is there are three phone numbers in Polycarp's contacts: 123456789, 100000000 and 100123456, then:
* if he enters 00 two numbers will show up: 100000000 and 100123456,
* if he enters 123 two numbers will show up 123456789 and 100123456,
* if he enters 01 there will be only one number 100123456.
For each of the phone numbers in Polycarp's contacts, find the minimum in length sequence of digits such that if Polycarp enters this sequence, Berdroid shows this only phone number.
Input
The first line contains single integer n (1 ≤ n ≤ 70000) — the total number of phone contacts in Polycarp's contacts.
The phone numbers follow, one in each line. Each number is a positive 9-digit integer starting with a digit from 1 to 9. All the numbers are distinct.
Output
Print exactly n lines: the i-th of them should contain the shortest non-empty sequence of digits, such that if Polycarp enters it, the Berdroid OS shows up only the i-th number from the contacts. If there are several such sequences, print any of them.
Examples
Input
3
123456789
100000000
100123456
Output
9
000
01
Input
4
123456789
193456789
134567819
934567891
Output
2
193
81
91
Submitted Solution:
```
n = int(input())
maps = {}
for i in range(n):
string = input()
for j in range(len(string)):
for a in range(0,j + 1):
substr = string[a:j+1]
if substr not in maps.keys():
maps[substr] = {'index' : i, 'count': 1}
else:
if i != maps[substr]['index']:
maps[substr]['count'] += 1
maps = sorted(maps.items(), key = lambda i: i[1]['index'])
count = 0
min_v = 'idk'
min_count = 11
for k, value in maps:
if count < value['index']:
count += 1
print(min_v)
min_v = 'idk'
min_count = 10
else:
if value['count'] == 1:
if len(k) < min_count:
min_count = len(k)
min_v = k
print(min_v)
``` | instruction | 0 | 40,134 | 24 | 80,268 |
No | output | 1 | 40,134 | 24 | 80,269 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp was gifted an array a of length n. Polycarp considers an array beautiful if there exists a number C, such that each number in the array occurs either zero or C times. Polycarp wants to remove some elements from the array a to make it beautiful.
For example, if n=6 and a = [1, 3, 2, 1, 4, 2], then the following options are possible to make the array a array beautiful:
* Polycarp removes elements at positions 2 and 5, array a becomes equal to [1, 2, 1, 2];
* Polycarp removes elements at positions 1 and 6, array a becomes equal to [3, 2, 1, 4];
* Polycarp removes elements at positions 1, 2 and 6, array a becomes equal to [2, 1, 4];
Help Polycarp determine the minimum number of elements to remove from the array a to make it beautiful.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output one integer — the minimum number of elements that Polycarp has to remove from the array a to make it beautiful.
Example
Input
3
6
1 3 2 1 4 2
4
100 100 4 100
8
1 2 3 3 3 2 6 6
Output
2
1
2 | instruction | 0 | 40,643 | 24 | 81,286 |
Tags: binary search, data structures, greedy, math, sortings
Correct Solution:
```
import sys
input=sys.stdin.readline
from collections import defaultdict as dc
from collections import Counter
from bisect import bisect_right, bisect_left
import math
from operator import itemgetter
from heapq import heapify, heappop, heappush
from queue import PriorityQueue as pq
for _ in range(int(input())):
n=int(input())
l=sorted(list(map(int,input().split())))
x=dc(int)
for i in l:
x[i]+=1
p=list(sorted(x.values()))
x=dc(int)
n=0
for i in p:
x[i]+=1
n+=1
a=[0]*n
b=[0]*n
a[0],b[-1]=p[0],p[-1]
for i in range(1,n):
a[i]=a[i-1]+p[i]
for i in range(n-2,-1,-1):
b[i]=b[i+1]+p[i]
m=sys.maxsize
i=0
#print(p)
#print(a)
#print(b)
while(i<n):
c=0
if i!=n-1:
t=i+x[p[i]]
if t<n:
c+=b[t]-p[i]*(n-t)
#print(p[i],c)
if i!=0:
c+=a[i-1]
#print(p[i],c)
#print(p[i],c)
m=min(m,c)
i+=x[p[i]]
print(m)
``` | output | 1 | 40,643 | 24 | 81,287 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp was gifted an array a of length n. Polycarp considers an array beautiful if there exists a number C, such that each number in the array occurs either zero or C times. Polycarp wants to remove some elements from the array a to make it beautiful.
For example, if n=6 and a = [1, 3, 2, 1, 4, 2], then the following options are possible to make the array a array beautiful:
* Polycarp removes elements at positions 2 and 5, array a becomes equal to [1, 2, 1, 2];
* Polycarp removes elements at positions 1 and 6, array a becomes equal to [3, 2, 1, 4];
* Polycarp removes elements at positions 1, 2 and 6, array a becomes equal to [2, 1, 4];
Help Polycarp determine the minimum number of elements to remove from the array a to make it beautiful.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output one integer — the minimum number of elements that Polycarp has to remove from the array a to make it beautiful.
Example
Input
3
6
1 3 2 1 4 2
4
100 100 4 100
8
1 2 3 3 3 2 6 6
Output
2
1
2 | instruction | 0 | 40,644 | 24 | 81,288 |
Tags: binary search, data structures, greedy, math, sortings
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline()
# ------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def S(): return input().strip()
def print_list(l):
print(' '.join(map(str, l)))
# sys.setrecursionlimit(100000)
# import random
# from functools import reduce
# from functools import lru_cache
# from heapq import *
# from collections import deque as dq
# import math
# import bisect as bs
from collections import Counter
# from collections import defaultdict as dc
for _ in range(N()):
n = N()
a = RLL()
count = Counter(Counter(a).values())
p = list(count.keys())
p.sort(reverse=True)
s = 0
ans = n
for k in p:
s += count[k]
ans = min(ans, n - k * s)
print(ans)
``` | output | 1 | 40,644 | 24 | 81,289 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp was gifted an array a of length n. Polycarp considers an array beautiful if there exists a number C, such that each number in the array occurs either zero or C times. Polycarp wants to remove some elements from the array a to make it beautiful.
For example, if n=6 and a = [1, 3, 2, 1, 4, 2], then the following options are possible to make the array a array beautiful:
* Polycarp removes elements at positions 2 and 5, array a becomes equal to [1, 2, 1, 2];
* Polycarp removes elements at positions 1 and 6, array a becomes equal to [3, 2, 1, 4];
* Polycarp removes elements at positions 1, 2 and 6, array a becomes equal to [2, 1, 4];
Help Polycarp determine the minimum number of elements to remove from the array a to make it beautiful.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output one integer — the minimum number of elements that Polycarp has to remove from the array a to make it beautiful.
Example
Input
3
6
1 3 2 1 4 2
4
100 100 4 100
8
1 2 3 3 3 2 6 6
Output
2
1
2 | instruction | 0 | 40,645 | 24 | 81,290 |
Tags: binary search, data structures, greedy, math, sortings
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
ctr = {}
for i in a:
ctr[i] = ctr.get(i, 0) + 1
borders = set([j for i, j in ctr.items()])
best = 10**9
for bord in borders:
cur = 0
for i, j in ctr.items():
if j < bord:
cur += j
else:
cur += j - bord
best = min(best, cur)
print(best)
``` | output | 1 | 40,645 | 24 | 81,291 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp was gifted an array a of length n. Polycarp considers an array beautiful if there exists a number C, such that each number in the array occurs either zero or C times. Polycarp wants to remove some elements from the array a to make it beautiful.
For example, if n=6 and a = [1, 3, 2, 1, 4, 2], then the following options are possible to make the array a array beautiful:
* Polycarp removes elements at positions 2 and 5, array a becomes equal to [1, 2, 1, 2];
* Polycarp removes elements at positions 1 and 6, array a becomes equal to [3, 2, 1, 4];
* Polycarp removes elements at positions 1, 2 and 6, array a becomes equal to [2, 1, 4];
Help Polycarp determine the minimum number of elements to remove from the array a to make it beautiful.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output one integer — the minimum number of elements that Polycarp has to remove from the array a to make it beautiful.
Example
Input
3
6
1 3 2 1 4 2
4
100 100 4 100
8
1 2 3 3 3 2 6 6
Output
2
1
2 | instruction | 0 | 40,646 | 24 | 81,292 |
Tags: binary search, data structures, greedy, math, sortings
Correct Solution:
```
import sys,math,itertools
from collections import Counter,deque,defaultdict
from bisect import bisect_left,bisect_right
from heapq import heappop,heappush,heapify, nlargest
from copy import deepcopy
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_1(): return list(map(lambda x:int(x)-1, sys.stdin.readline().split()))
def inps(): return sys.stdin.readline()
def inpsl(x): tmp = sys.stdin.readline(); return tmp[:x]
def err(x): print(x); exit()
for _ in range(inp()):
n = inp()
a = inpl()
c = Counter(a)
vas = sorted(list(c.values()))
acc = [0]
for x in vas: acc.append(acc[-1]+x)
res = INF
ln = len(vas)
for now in list(set(vas)):
cnt = 0
l = bisect_left(vas,now)
r = bisect_right(vas,now)
cnt = acc[l] + acc[-1]-acc[r]-now*(ln-r)
res = min(res, cnt)
print(res)
``` | output | 1 | 40,646 | 24 | 81,293 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp was gifted an array a of length n. Polycarp considers an array beautiful if there exists a number C, such that each number in the array occurs either zero or C times. Polycarp wants to remove some elements from the array a to make it beautiful.
For example, if n=6 and a = [1, 3, 2, 1, 4, 2], then the following options are possible to make the array a array beautiful:
* Polycarp removes elements at positions 2 and 5, array a becomes equal to [1, 2, 1, 2];
* Polycarp removes elements at positions 1 and 6, array a becomes equal to [3, 2, 1, 4];
* Polycarp removes elements at positions 1, 2 and 6, array a becomes equal to [2, 1, 4];
Help Polycarp determine the minimum number of elements to remove from the array a to make it beautiful.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output one integer — the minimum number of elements that Polycarp has to remove from the array a to make it beautiful.
Example
Input
3
6
1 3 2 1 4 2
4
100 100 4 100
8
1 2 3 3 3 2 6 6
Output
2
1
2 | instruction | 0 | 40,647 | 24 | 81,294 |
Tags: binary search, data structures, greedy, math, sortings
Correct Solution:
```
from collections import Counter
from sys import stdin
def solve(arr, n):
c = Counter(arr)
s = sorted(c.values(), reverse=True)
#print(s)
res = n
d = Counter(s)
#print(d)
for i in range(s[0]+1):
tmp = 0
for e in d.keys():
if e >= i:
tmp += (e-i)*d[e]
else:
tmp += e*d[e]
res = min(res, tmp)
return res
def main():
t = int(stdin.readline())
for i in range(t):
n = int(stdin.readline())
print(solve(list(map(int, stdin.readline().split(" "))), n))
main()
``` | output | 1 | 40,647 | 24 | 81,295 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp was gifted an array a of length n. Polycarp considers an array beautiful if there exists a number C, such that each number in the array occurs either zero or C times. Polycarp wants to remove some elements from the array a to make it beautiful.
For example, if n=6 and a = [1, 3, 2, 1, 4, 2], then the following options are possible to make the array a array beautiful:
* Polycarp removes elements at positions 2 and 5, array a becomes equal to [1, 2, 1, 2];
* Polycarp removes elements at positions 1 and 6, array a becomes equal to [3, 2, 1, 4];
* Polycarp removes elements at positions 1, 2 and 6, array a becomes equal to [2, 1, 4];
Help Polycarp determine the minimum number of elements to remove from the array a to make it beautiful.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output one integer — the minimum number of elements that Polycarp has to remove from the array a to make it beautiful.
Example
Input
3
6
1 3 2 1 4 2
4
100 100 4 100
8
1 2 3 3 3 2 6 6
Output
2
1
2 | instruction | 0 | 40,648 | 24 | 81,296 |
Tags: binary search, data structures, greedy, math, sortings
Correct Solution:
```
def solve(a):
li = get_counts(a)
solution = 0
for i in range(len(li)):
temp_solution = li[i] * (len(li) - i)
if temp_solution > solution:
solution = temp_solution
print(len(a) - solution)
def get_counts(li):
count_dict = {}
for a in li:
if a in count_dict:
count_dict[a] += 1
else:
count_dict[a] = 1
return sorted(count_dict.values())
def main():
x = input()
for _ in range(int(x)):
input()
a = input()
solve(list(map(int, a.split())))
main()
``` | output | 1 | 40,648 | 24 | 81,297 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp was gifted an array a of length n. Polycarp considers an array beautiful if there exists a number C, such that each number in the array occurs either zero or C times. Polycarp wants to remove some elements from the array a to make it beautiful.
For example, if n=6 and a = [1, 3, 2, 1, 4, 2], then the following options are possible to make the array a array beautiful:
* Polycarp removes elements at positions 2 and 5, array a becomes equal to [1, 2, 1, 2];
* Polycarp removes elements at positions 1 and 6, array a becomes equal to [3, 2, 1, 4];
* Polycarp removes elements at positions 1, 2 and 6, array a becomes equal to [2, 1, 4];
Help Polycarp determine the minimum number of elements to remove from the array a to make it beautiful.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output one integer — the minimum number of elements that Polycarp has to remove from the array a to make it beautiful.
Example
Input
3
6
1 3 2 1 4 2
4
100 100 4 100
8
1 2 3 3 3 2 6 6
Output
2
1
2 | instruction | 0 | 40,649 | 24 | 81,298 |
Tags: binary search, data structures, greedy, math, sortings
Correct Solution:
```
def solve():
n = int(input())
arr = [int(i) for i in input().split()]
dic = {}
for i in range(n):
if arr[i] in dic:
dic[arr[i]] += 1
else:
dic[arr[i]] = 1
values = list(dic.values())
deleted = []
for s in set(values):
result = sum([a - s for a in values if a > s])
result += sum([a for a in values if a < s])
deleted.append(result)
print(min(deleted))
for _ in range(int(input())):
solve()
``` | output | 1 | 40,649 | 24 | 81,299 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp was gifted an array a of length n. Polycarp considers an array beautiful if there exists a number C, such that each number in the array occurs either zero or C times. Polycarp wants to remove some elements from the array a to make it beautiful.
For example, if n=6 and a = [1, 3, 2, 1, 4, 2], then the following options are possible to make the array a array beautiful:
* Polycarp removes elements at positions 2 and 5, array a becomes equal to [1, 2, 1, 2];
* Polycarp removes elements at positions 1 and 6, array a becomes equal to [3, 2, 1, 4];
* Polycarp removes elements at positions 1, 2 and 6, array a becomes equal to [2, 1, 4];
Help Polycarp determine the minimum number of elements to remove from the array a to make it beautiful.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output one integer — the minimum number of elements that Polycarp has to remove from the array a to make it beautiful.
Example
Input
3
6
1 3 2 1 4 2
4
100 100 4 100
8
1 2 3 3 3 2 6 6
Output
2
1
2 | instruction | 0 | 40,650 | 24 | 81,300 |
Tags: binary search, data structures, greedy, math, sortings
Correct Solution:
```
from collections import*
for t in range(int(input())):
z=s=int(input())
c=0
for x,y in sorted(Counter(Counter(input().split()).values()).items())[::-1]:
c+=y
z=min(z,s-c*x)
print(z)
``` | output | 1 | 40,650 | 24 | 81,301 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp was gifted an array a of length n. Polycarp considers an array beautiful if there exists a number C, such that each number in the array occurs either zero or C times. Polycarp wants to remove some elements from the array a to make it beautiful.
For example, if n=6 and a = [1, 3, 2, 1, 4, 2], then the following options are possible to make the array a array beautiful:
* Polycarp removes elements at positions 2 and 5, array a becomes equal to [1, 2, 1, 2];
* Polycarp removes elements at positions 1 and 6, array a becomes equal to [3, 2, 1, 4];
* Polycarp removes elements at positions 1, 2 and 6, array a becomes equal to [2, 1, 4];
Help Polycarp determine the minimum number of elements to remove from the array a to make it beautiful.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output one integer — the minimum number of elements that Polycarp has to remove from the array a to make it beautiful.
Example
Input
3
6
1 3 2 1 4 2
4
100 100 4 100
8
1 2 3 3 3 2 6 6
Output
2
1
2
Submitted Solution:
```
for _ in ' '*int(input()):
n,l,d,m=input(),input().split(),{},1e9
for i in l:
if i in d: d[i]+=1
else: d[i]=1
for i in set(d.values()):
x=0
for j in d.values():
if j<i: x+=j
elif j>i: x+=j-i
m=min(x,m)
print(m)
``` | instruction | 0 | 40,651 | 24 | 81,302 |
Yes | output | 1 | 40,651 | 24 | 81,303 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp was gifted an array a of length n. Polycarp considers an array beautiful if there exists a number C, such that each number in the array occurs either zero or C times. Polycarp wants to remove some elements from the array a to make it beautiful.
For example, if n=6 and a = [1, 3, 2, 1, 4, 2], then the following options are possible to make the array a array beautiful:
* Polycarp removes elements at positions 2 and 5, array a becomes equal to [1, 2, 1, 2];
* Polycarp removes elements at positions 1 and 6, array a becomes equal to [3, 2, 1, 4];
* Polycarp removes elements at positions 1, 2 and 6, array a becomes equal to [2, 1, 4];
Help Polycarp determine the minimum number of elements to remove from the array a to make it beautiful.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output one integer — the minimum number of elements that Polycarp has to remove from the array a to make it beautiful.
Example
Input
3
6
1 3 2 1 4 2
4
100 100 4 100
8
1 2 3 3 3 2 6 6
Output
2
1
2
Submitted Solution:
```
from collections import defaultdict,Counter
from itertools import accumulate
import sys
input = sys.stdin.readline
'''
for CASES in range(int(input())):
n, m = map(int, input().split())
n = int(input())
A = list(map(int, input().split()))
S = input().strip()
sys.stdout.write(" ".join(map(str,ANS))+"\n")
'''
inf = 100000000000000000 # 1e17
mod = 998244353
for CASES in range(int(input())):
n = int(input())
A = list(map(int, input().split()))
C=Counter(A)
LIST=[0]*(n+2)
for c in C.values():
LIST[c]+=1
presum=0
forsum=sum(LIST)
LIST2=[0]*(n+2)
for i in range(len(LIST2)):
LIST2[i]=LIST[i]*i
allsum=sum(LIST2)
ans=1<<60
for i in range(1,len(LIST)):
presum+=LIST[i-1]*(i-1)
allsum-=forsum
forsum-=LIST[i]
# print(presum,allsum)
ans=min(ans,presum+allsum)
print(ans)
``` | instruction | 0 | 40,652 | 24 | 81,304 |
Yes | output | 1 | 40,652 | 24 | 81,305 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp was gifted an array a of length n. Polycarp considers an array beautiful if there exists a number C, such that each number in the array occurs either zero or C times. Polycarp wants to remove some elements from the array a to make it beautiful.
For example, if n=6 and a = [1, 3, 2, 1, 4, 2], then the following options are possible to make the array a array beautiful:
* Polycarp removes elements at positions 2 and 5, array a becomes equal to [1, 2, 1, 2];
* Polycarp removes elements at positions 1 and 6, array a becomes equal to [3, 2, 1, 4];
* Polycarp removes elements at positions 1, 2 and 6, array a becomes equal to [2, 1, 4];
Help Polycarp determine the minimum number of elements to remove from the array a to make it beautiful.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output one integer — the minimum number of elements that Polycarp has to remove from the array a to make it beautiful.
Example
Input
3
6
1 3 2 1 4 2
4
100 100 4 100
8
1 2 3 3 3 2 6 6
Output
2
1
2
Submitted Solution:
```
from collections import Counter
def get_min(times_dict):
final_ans = 2 * (10 ** 14)
for times in set(times_dict):
ans = 0
for t in times_dict:
if t >= times:
ans += (t - times) * times_dict[t]
else:
ans += t * times_dict[t]
final_ans = min(final_ans, ans)
return final_ans
t = int(input())
for _ in range(t):
n = int(input())
a_list = list(map(int, input().split()))
a_dict = Counter(a_list)
times_dict = Counter(a_dict.values())
get_ans = get_min(times_dict)
print(get_ans)
``` | instruction | 0 | 40,653 | 24 | 81,306 |
Yes | output | 1 | 40,653 | 24 | 81,307 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp was gifted an array a of length n. Polycarp considers an array beautiful if there exists a number C, such that each number in the array occurs either zero or C times. Polycarp wants to remove some elements from the array a to make it beautiful.
For example, if n=6 and a = [1, 3, 2, 1, 4, 2], then the following options are possible to make the array a array beautiful:
* Polycarp removes elements at positions 2 and 5, array a becomes equal to [1, 2, 1, 2];
* Polycarp removes elements at positions 1 and 6, array a becomes equal to [3, 2, 1, 4];
* Polycarp removes elements at positions 1, 2 and 6, array a becomes equal to [2, 1, 4];
Help Polycarp determine the minimum number of elements to remove from the array a to make it beautiful.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output one integer — the minimum number of elements that Polycarp has to remove from the array a to make it beautiful.
Example
Input
3
6
1 3 2 1 4 2
4
100 100 4 100
8
1 2 3 3 3 2 6 6
Output
2
1
2
Submitted Solution:
```
import sys
import collections
input = sys.stdin.readline
def println(val):
sys.stdout.write(str(val) + '\n')
def solve(n, a):
cnts = collections.Counter(a)
occurences = collections.defaultdict(int)
for key in cnts:
occurences[cnts[key]] += 1
# println(occurences)
ans = 0
removed = 0
for C in range(1, n+10):
ans = max(ans, C * (len(cnts) - removed))
removed += occurences[C]
println(n - ans)
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
solve(n, a)
``` | instruction | 0 | 40,654 | 24 | 81,308 |
Yes | output | 1 | 40,654 | 24 | 81,309 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp was gifted an array a of length n. Polycarp considers an array beautiful if there exists a number C, such that each number in the array occurs either zero or C times. Polycarp wants to remove some elements from the array a to make it beautiful.
For example, if n=6 and a = [1, 3, 2, 1, 4, 2], then the following options are possible to make the array a array beautiful:
* Polycarp removes elements at positions 2 and 5, array a becomes equal to [1, 2, 1, 2];
* Polycarp removes elements at positions 1 and 6, array a becomes equal to [3, 2, 1, 4];
* Polycarp removes elements at positions 1, 2 and 6, array a becomes equal to [2, 1, 4];
Help Polycarp determine the minimum number of elements to remove from the array a to make it beautiful.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output one integer — the minimum number of elements that Polycarp has to remove from the array a to make it beautiful.
Example
Input
3
6
1 3 2 1 4 2
4
100 100 4 100
8
1 2 3 3 3 2 6 6
Output
2
1
2
Submitted Solution:
```
def equalizeTheArray(a):
d = dict()
for i in range(len(a)):
if(str(a[i]) in d.keys()):
d[str(a[i])] += 1
else:
d[str(a[i])] = 1
k = sorted(list(d.values()))
rm = 0
s = 1
for i in range(len(k) - 1):
if(k[i] < k[i+1]):
if(s*k[i] <= (k[i + 1] - k[i])):
rm += s*k[i]
s = 1
else:
rm += (k[i+1] - k[i])
s += 1
k[i + 1] =k[i]
elif(k[i] == k[i+1]):
s+=1
return rm
if(__name__=="__main__"):
for _ in range(int(input())):
n = int(input())
a = list(map(int,input().split()))
print(equalizeTheArray(a))
``` | instruction | 0 | 40,655 | 24 | 81,310 |
No | output | 1 | 40,655 | 24 | 81,311 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp was gifted an array a of length n. Polycarp considers an array beautiful if there exists a number C, such that each number in the array occurs either zero or C times. Polycarp wants to remove some elements from the array a to make it beautiful.
For example, if n=6 and a = [1, 3, 2, 1, 4, 2], then the following options are possible to make the array a array beautiful:
* Polycarp removes elements at positions 2 and 5, array a becomes equal to [1, 2, 1, 2];
* Polycarp removes elements at positions 1 and 6, array a becomes equal to [3, 2, 1, 4];
* Polycarp removes elements at positions 1, 2 and 6, array a becomes equal to [2, 1, 4];
Help Polycarp determine the minimum number of elements to remove from the array a to make it beautiful.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output one integer — the minimum number of elements that Polycarp has to remove from the array a to make it beautiful.
Example
Input
3
6
1 3 2 1 4 2
4
100 100 4 100
8
1 2 3 3 3 2 6 6
Output
2
1
2
Submitted Solution:
```
t=int(input())
for i in range(t):
listo=[]
n=int(input())
l=list(map(int,input().split()))
sumi=len(l)
dic={}
for x in set(l):
listo.append(l.count(x))
m=len(set(l))
for x in set(listo):
w=listo.count(x)
dic[x]=[]
dic[x].append(w)
dic[x].append(m-w)
m=m-w
dic[x].append(sumi-x*w)
sumi=sumi-x*w
dic[x].append(dic[x][2]-dic[x][1]*x)
tot=0
s=[]
for x in dic:
s.append(x)
for j in range(len(s)-1):
tot=tot+dic[s[j]][0]*s[j]
if dic[s[j]][1]*s[j]+dic[s[j+1]][3]>=dic[s[j]][3]:
tot=tot+dic[s[j]][2]
break
print(tot)
``` | instruction | 0 | 40,656 | 24 | 81,312 |
No | output | 1 | 40,656 | 24 | 81,313 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp was gifted an array a of length n. Polycarp considers an array beautiful if there exists a number C, such that each number in the array occurs either zero or C times. Polycarp wants to remove some elements from the array a to make it beautiful.
For example, if n=6 and a = [1, 3, 2, 1, 4, 2], then the following options are possible to make the array a array beautiful:
* Polycarp removes elements at positions 2 and 5, array a becomes equal to [1, 2, 1, 2];
* Polycarp removes elements at positions 1 and 6, array a becomes equal to [3, 2, 1, 4];
* Polycarp removes elements at positions 1, 2 and 6, array a becomes equal to [2, 1, 4];
Help Polycarp determine the minimum number of elements to remove from the array a to make it beautiful.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output one integer — the minimum number of elements that Polycarp has to remove from the array a to make it beautiful.
Example
Input
3
6
1 3 2 1 4 2
4
100 100 4 100
8
1 2 3 3 3 2 6 6
Output
2
1
2
Submitted Solution:
```
import sys
import math
from itertools import permutations
from bisect import bisect_left
def II():
return int(sys.stdin.readline())
def LI():
return list(map(int, sys.stdin.readline().split()))
def MI():
return map(int, sys.stdin.readline().split())
def SI():
return sys.stdin.readline().strip()
def FACT(n, mod):
s = 1
facts = [1]
for i in range(1,n+1):
s*=i
s%=mod
facts.append(s)
return facts[n]
def C(n, k, mod):
return (FACT(n,mod) * pow((FACT(k,mod)*FACT(n-k,mod))%mod,mod-2, mod))%mod
for _ in range(II()):
n = II()
a = LI()
d = {}
for i in range(n):
if d.get(a[i]):
d[a[i]]+=1
else:
d[a[i]] = 1
d = list(d.values())
d.sort()
rightSum = []
s = 0
for i in range(len(d)-1,-1,-1):
rightSum.append(s)
s+=d[i]
rightSum.reverse()
m = n
v = {}
for i in range(len(d)):
if not v.get(d[i]):
m = min(m,i+rightSum[i]-d[i]*(len(d)-i-1))
v[d[i]] = 1
print(m)
``` | instruction | 0 | 40,657 | 24 | 81,314 |
No | output | 1 | 40,657 | 24 | 81,315 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp was gifted an array a of length n. Polycarp considers an array beautiful if there exists a number C, such that each number in the array occurs either zero or C times. Polycarp wants to remove some elements from the array a to make it beautiful.
For example, if n=6 and a = [1, 3, 2, 1, 4, 2], then the following options are possible to make the array a array beautiful:
* Polycarp removes elements at positions 2 and 5, array a becomes equal to [1, 2, 1, 2];
* Polycarp removes elements at positions 1 and 6, array a becomes equal to [3, 2, 1, 4];
* Polycarp removes elements at positions 1, 2 and 6, array a becomes equal to [2, 1, 4];
Help Polycarp determine the minimum number of elements to remove from the array a to make it beautiful.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — array a.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output one integer — the minimum number of elements that Polycarp has to remove from the array a to make it beautiful.
Example
Input
3
6
1 3 2 1 4 2
4
100 100 4 100
8
1 2 3 3 3 2 6 6
Output
2
1
2
Submitted Solution:
```
from sys import stdin, stdout
from collections import defaultdict
import math
def main():
for _ in range(int(stdin.readline())):
n = int(stdin.readline())
arr = list(map(int, stdin.readline().split()))
counter = defaultdict(int)
for x in arr:
counter[x] += 1
cnts = defaultdict(int)
for k,v in counter.items():
cnts[v] += 1
p = []
total = 0
for k,v in cnts.items():
p.append(k)
total += (v * k)
p.sort()
burden = 0
mn = 10 ** 15
for x in reversed(p):
total -= (cnts[x] * x)
mn = min(mn, total + burden)
burden += cnts[x]
stdout.write(str(mn)+"\n")
main()
``` | instruction | 0 | 40,658 | 24 | 81,316 |
No | output | 1 | 40,658 | 24 | 81,317 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus has got n candies and m friends (n ≥ m). He wants to make a New Year present with candies to each friend. Polycarpus is planning to present all candies and he wants to do this in the fairest (that is, most equal) manner. He wants to choose such ai, where ai is the number of candies in the i-th friend's present, that the maximum ai differs from the least ai as little as possible.
For example, if n is divisible by m, then he is going to present the same number of candies to all his friends, that is, the maximum ai won't differ from the minimum one.
Input
The single line of the input contains a pair of space-separated positive integers n, m (1 ≤ n, m ≤ 100;n ≥ m) — the number of candies and the number of Polycarpus's friends.
Output
Print the required sequence a1, a2, ..., am, where ai is the number of candies in the i-th friend's present. All numbers ai must be positive integers, total up to n, the maximum one should differ from the minimum one by the smallest possible value.
Examples
Input
12 3
Output
4 4 4
Input
15 4
Output
3 4 4 4
Input
18 7
Output
2 2 2 3 3 3 3
Note
Print ai in any order, separate the numbers by spaces. | instruction | 0 | 42,400 | 24 | 84,800 |
Tags: implementation
Correct Solution:
```
n, m = [int(i) for i in input().split()]
print(*[n // m + 1 if i < n % m else n // m for i in range(m)])
``` | output | 1 | 42,400 | 24 | 84,801 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus has got n candies and m friends (n ≥ m). He wants to make a New Year present with candies to each friend. Polycarpus is planning to present all candies and he wants to do this in the fairest (that is, most equal) manner. He wants to choose such ai, where ai is the number of candies in the i-th friend's present, that the maximum ai differs from the least ai as little as possible.
For example, if n is divisible by m, then he is going to present the same number of candies to all his friends, that is, the maximum ai won't differ from the minimum one.
Input
The single line of the input contains a pair of space-separated positive integers n, m (1 ≤ n, m ≤ 100;n ≥ m) — the number of candies and the number of Polycarpus's friends.
Output
Print the required sequence a1, a2, ..., am, where ai is the number of candies in the i-th friend's present. All numbers ai must be positive integers, total up to n, the maximum one should differ from the minimum one by the smallest possible value.
Examples
Input
12 3
Output
4 4 4
Input
15 4
Output
3 4 4 4
Input
18 7
Output
2 2 2 3 3 3 3
Note
Print ai in any order, separate the numbers by spaces. | instruction | 0 | 42,401 | 24 | 84,802 |
Tags: implementation
Correct Solution:
```
m,n=input().split()
m=int(m)
n=int(n)
while(n!=0):
if m%n:
print(int(m/n))
m=m-int(m/n)
n -= 1
else:
for i in range(n):
print(int(m/n))
exit()
``` | output | 1 | 42,401 | 24 | 84,803 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus has got n candies and m friends (n ≥ m). He wants to make a New Year present with candies to each friend. Polycarpus is planning to present all candies and he wants to do this in the fairest (that is, most equal) manner. He wants to choose such ai, where ai is the number of candies in the i-th friend's present, that the maximum ai differs from the least ai as little as possible.
For example, if n is divisible by m, then he is going to present the same number of candies to all his friends, that is, the maximum ai won't differ from the minimum one.
Input
The single line of the input contains a pair of space-separated positive integers n, m (1 ≤ n, m ≤ 100;n ≥ m) — the number of candies and the number of Polycarpus's friends.
Output
Print the required sequence a1, a2, ..., am, where ai is the number of candies in the i-th friend's present. All numbers ai must be positive integers, total up to n, the maximum one should differ from the minimum one by the smallest possible value.
Examples
Input
12 3
Output
4 4 4
Input
15 4
Output
3 4 4 4
Input
18 7
Output
2 2 2 3 3 3 3
Note
Print ai in any order, separate the numbers by spaces. | instruction | 0 | 42,402 | 24 | 84,804 |
Tags: implementation
Correct Solution:
```
n,m=map(int,input().split( ))
a=[]
for i in range(0,m):
a.append(n//m)
n=n%m
for i in range(0,n):
a[i]+=1
for i in a:
print(i,end=' ')
``` | output | 1 | 42,402 | 24 | 84,805 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.