text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
The store sells n beads. The color of each bead is described by a lowercase letter of the English alphabet ("a"–"z"). You want to buy some beads to assemble a necklace from them.
A necklace is a set of beads connected in a circle.
For example, if the store sells beads "a", "b", "c", "a", "c", "c", then you can assemble the following necklaces (these are not all possible options):
<image>
And the following necklaces cannot be assembled from beads sold in the store:
<image> The first necklace cannot be assembled because it has three beads "a" (of the two available). The second necklace cannot be assembled because it contains a bead "d", which is not sold in the store.
We call a necklace k-beautiful if, when it is turned clockwise by k beads, the necklace remains unchanged. For example, here is a sequence of three turns of a necklace.
<image> As you can see, this necklace is, for example, 3-beautiful, 6-beautiful, 9-beautiful, and so on, but it is not 1-beautiful or 2-beautiful.
In particular, a necklace of length 1 is k-beautiful for any integer k. A necklace that consists of beads of the same color is also beautiful for any k.
You are given the integers n and k, and also the string s containing n lowercase letters of the English alphabet — each letter defines a bead in the store. You can buy any subset of beads and connect them in any order. Find the maximum length of a k-beautiful necklace you can assemble.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases in the test. Then t test cases follow.
The first line of each test case contains two integers n and k (1 ≤ n, k ≤ 2000).
The second line of each test case contains the string s containing n lowercase English letters — the beads in the store.
It is guaranteed that the sum of n for all test cases does not exceed 2000.
Output
Output t answers to the test cases. Each answer is a positive integer — the maximum length of the k-beautiful necklace you can assemble.
Example
Input
6
6 3
abcbac
3 6
aaa
7 1000
abczgyo
5 4
ababa
20 10
aaebdbabdbbddaadaadc
20 5
ecbedececacbcbccbdec
Output
6
3
5
4
15
10
Note
The first test case is explained in the statement.
In the second test case, a 6-beautiful necklace can be assembled from all the letters.
In the third test case, a 1000-beautiful necklace can be assembled, for example, from beads "abzyo".
Tags: brute force, dfs and similar, dp, graphs, greedy, number theory
Correct Solution:
```
import sys
from collections import defaultdict as dd
from collections import deque
from fractions import Fraction as f
def eprint(*args):
print(*args, file=sys.stderr)
zz=1
from math import *
import copy
#sys.setrecursionlimit(10**6)
if zz:
input=sys.stdin.readline
else:
sys.stdin=open('input.txt', 'r')
sys.stdout=open('all.txt','w')
def li():
return [int(x) for x in input().split()]
def fi():
return int(input())
def si():
return list(input().rstrip())
def mi():
return map(int,input().split())
def gh():
sys.stdout.flush()
def bo(i):
return ord(i)-ord('a')
from copy import *
from bisect import *
from itertools import permutations
def can(mid,k):
if k==0:
return True
#print(d,mid,k)
if mid %k!=0 and max(d)<mid:
return False
elif mid%k!=0:
return True
c=i=0
while c<k:
#print(c,b)
if b[i]<mid//k:
return False
b[i]-=mid//k
c+=1
i=(i+1)%p
if b[i]<mid//k:
i=0
#print(b,mid)
return True
tt=fi()
while tt>0:
tt-=1
n,k=mi()
#k%=n
s=si()
d=[0 for i in range(26)]
for i in s:
d[bo(i)]+=1
p=k
#print("K",k)
if k==0:
print(n)
continue
div=[]
while p<=n:
div.append(p)
p+=k
#print(div)
div=sorted(div)
l=0
r=len(div)-1
d.sort(reverse=True)
if d.count(0)>0:
d=d[:d.index(0)]
p=len(d)
#print(d)
ans=max(d)
for mid in range(1,n+1):
b=deepcopy(d)
if can(mid,gcd(k,mid)):
ans=mid
print(ans)
```
| 99,600 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The store sells n beads. The color of each bead is described by a lowercase letter of the English alphabet ("a"–"z"). You want to buy some beads to assemble a necklace from them.
A necklace is a set of beads connected in a circle.
For example, if the store sells beads "a", "b", "c", "a", "c", "c", then you can assemble the following necklaces (these are not all possible options):
<image>
And the following necklaces cannot be assembled from beads sold in the store:
<image> The first necklace cannot be assembled because it has three beads "a" (of the two available). The second necklace cannot be assembled because it contains a bead "d", which is not sold in the store.
We call a necklace k-beautiful if, when it is turned clockwise by k beads, the necklace remains unchanged. For example, here is a sequence of three turns of a necklace.
<image> As you can see, this necklace is, for example, 3-beautiful, 6-beautiful, 9-beautiful, and so on, but it is not 1-beautiful or 2-beautiful.
In particular, a necklace of length 1 is k-beautiful for any integer k. A necklace that consists of beads of the same color is also beautiful for any k.
You are given the integers n and k, and also the string s containing n lowercase letters of the English alphabet — each letter defines a bead in the store. You can buy any subset of beads and connect them in any order. Find the maximum length of a k-beautiful necklace you can assemble.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases in the test. Then t test cases follow.
The first line of each test case contains two integers n and k (1 ≤ n, k ≤ 2000).
The second line of each test case contains the string s containing n lowercase English letters — the beads in the store.
It is guaranteed that the sum of n for all test cases does not exceed 2000.
Output
Output t answers to the test cases. Each answer is a positive integer — the maximum length of the k-beautiful necklace you can assemble.
Example
Input
6
6 3
abcbac
3 6
aaa
7 1000
abczgyo
5 4
ababa
20 10
aaebdbabdbbddaadaadc
20 5
ecbedececacbcbccbdec
Output
6
3
5
4
15
10
Note
The first test case is explained in the statement.
In the second test case, a 6-beautiful necklace can be assembled from all the letters.
In the third test case, a 1000-beautiful necklace can be assembled, for example, from beads "abzyo".
Tags: brute force, dfs and similar, dp, graphs, greedy, number theory
Correct Solution:
```
import sys
input = sys.stdin.readline
from math import gcd
t=int(input())
for tests in range(t):
n,k=map(int,input().split())
S=input().strip()
LIST=[0]*26
for s in S:
LIST[ord(s)-97]+=1
for x in range(n,0,-1):
GCD=gcd(x,k)
p=x//GCD
SUM=0
for l in LIST:
if l>=p:
SUM+=l//p*p
if SUM>=x:
print(x)
break
#print(S)
```
| 99,601 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The store sells n beads. The color of each bead is described by a lowercase letter of the English alphabet ("a"–"z"). You want to buy some beads to assemble a necklace from them.
A necklace is a set of beads connected in a circle.
For example, if the store sells beads "a", "b", "c", "a", "c", "c", then you can assemble the following necklaces (these are not all possible options):
<image>
And the following necklaces cannot be assembled from beads sold in the store:
<image> The first necklace cannot be assembled because it has three beads "a" (of the two available). The second necklace cannot be assembled because it contains a bead "d", which is not sold in the store.
We call a necklace k-beautiful if, when it is turned clockwise by k beads, the necklace remains unchanged. For example, here is a sequence of three turns of a necklace.
<image> As you can see, this necklace is, for example, 3-beautiful, 6-beautiful, 9-beautiful, and so on, but it is not 1-beautiful or 2-beautiful.
In particular, a necklace of length 1 is k-beautiful for any integer k. A necklace that consists of beads of the same color is also beautiful for any k.
You are given the integers n and k, and also the string s containing n lowercase letters of the English alphabet — each letter defines a bead in the store. You can buy any subset of beads and connect them in any order. Find the maximum length of a k-beautiful necklace you can assemble.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases in the test. Then t test cases follow.
The first line of each test case contains two integers n and k (1 ≤ n, k ≤ 2000).
The second line of each test case contains the string s containing n lowercase English letters — the beads in the store.
It is guaranteed that the sum of n for all test cases does not exceed 2000.
Output
Output t answers to the test cases. Each answer is a positive integer — the maximum length of the k-beautiful necklace you can assemble.
Example
Input
6
6 3
abcbac
3 6
aaa
7 1000
abczgyo
5 4
ababa
20 10
aaebdbabdbbddaadaadc
20 5
ecbedececacbcbccbdec
Output
6
3
5
4
15
10
Note
The first test case is explained in the statement.
In the second test case, a 6-beautiful necklace can be assembled from all the letters.
In the third test case, a 1000-beautiful necklace can be assembled, for example, from beads "abzyo".
Submitted Solution:
```
import math
num_tests = int(input())
def calc_num_least(letters, x):
count = 0
for letter in letters:
if letters[letter] >= x:
count += letters[letter] // x
return count
def solve(n, k, letters):
best = 0
for i in range(1, n+1):
j = calc_num_least(letters, i)
for x in reversed(range(1, j+1)):
if k % x == 0:
best = max(best, x * i)
break
return best
for test in range(num_tests):
n, k = [int(x) for x in input().split(" ")]
s = input()
letters = {}
for i in s:
letters[i] = letters.get(i, 0) + 1
print(solve(n, k, letters))
```
Yes
| 99,602 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The store sells n beads. The color of each bead is described by a lowercase letter of the English alphabet ("a"–"z"). You want to buy some beads to assemble a necklace from them.
A necklace is a set of beads connected in a circle.
For example, if the store sells beads "a", "b", "c", "a", "c", "c", then you can assemble the following necklaces (these are not all possible options):
<image>
And the following necklaces cannot be assembled from beads sold in the store:
<image> The first necklace cannot be assembled because it has three beads "a" (of the two available). The second necklace cannot be assembled because it contains a bead "d", which is not sold in the store.
We call a necklace k-beautiful if, when it is turned clockwise by k beads, the necklace remains unchanged. For example, here is a sequence of three turns of a necklace.
<image> As you can see, this necklace is, for example, 3-beautiful, 6-beautiful, 9-beautiful, and so on, but it is not 1-beautiful or 2-beautiful.
In particular, a necklace of length 1 is k-beautiful for any integer k. A necklace that consists of beads of the same color is also beautiful for any k.
You are given the integers n and k, and also the string s containing n lowercase letters of the English alphabet — each letter defines a bead in the store. You can buy any subset of beads and connect them in any order. Find the maximum length of a k-beautiful necklace you can assemble.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases in the test. Then t test cases follow.
The first line of each test case contains two integers n and k (1 ≤ n, k ≤ 2000).
The second line of each test case contains the string s containing n lowercase English letters — the beads in the store.
It is guaranteed that the sum of n for all test cases does not exceed 2000.
Output
Output t answers to the test cases. Each answer is a positive integer — the maximum length of the k-beautiful necklace you can assemble.
Example
Input
6
6 3
abcbac
3 6
aaa
7 1000
abczgyo
5 4
ababa
20 10
aaebdbabdbbddaadaadc
20 5
ecbedececacbcbccbdec
Output
6
3
5
4
15
10
Note
The first test case is explained in the statement.
In the second test case, a 6-beautiful necklace can be assembled from all the letters.
In the third test case, a 1000-beautiful necklace can be assembled, for example, from beads "abzyo".
Submitted Solution:
```
import sys
from math import gcd
from bisect import bisect_left as br
from collections import Counter as CO
from collections import defaultdict as dd
input=sys.stdin.readline
t=int(input())
for _ in range(t):
n,kk=map(int,input().split())
word=list(map(str,input().strip()))
df=dd(int)
fact=[]
for k in word:
df[k]+=1
#print(df)
ans=0
for i in range(1,n+1):
maxi=0
x=0
co=0
for j in df:
if(df[j]//i!=0):
maxi+=df[j]//i
#rint(maxi)
if(maxi==0):
break
for j in range(maxi,0,-1):
if(kk%j==0 ):
maxi=j
break
ans=max(ans,maxi*i)
#print(i,maxi)
print(ans)
```
Yes
| 99,603 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The store sells n beads. The color of each bead is described by a lowercase letter of the English alphabet ("a"–"z"). You want to buy some beads to assemble a necklace from them.
A necklace is a set of beads connected in a circle.
For example, if the store sells beads "a", "b", "c", "a", "c", "c", then you can assemble the following necklaces (these are not all possible options):
<image>
And the following necklaces cannot be assembled from beads sold in the store:
<image> The first necklace cannot be assembled because it has three beads "a" (of the two available). The second necklace cannot be assembled because it contains a bead "d", which is not sold in the store.
We call a necklace k-beautiful if, when it is turned clockwise by k beads, the necklace remains unchanged. For example, here is a sequence of three turns of a necklace.
<image> As you can see, this necklace is, for example, 3-beautiful, 6-beautiful, 9-beautiful, and so on, but it is not 1-beautiful or 2-beautiful.
In particular, a necklace of length 1 is k-beautiful for any integer k. A necklace that consists of beads of the same color is also beautiful for any k.
You are given the integers n and k, and also the string s containing n lowercase letters of the English alphabet — each letter defines a bead in the store. You can buy any subset of beads and connect them in any order. Find the maximum length of a k-beautiful necklace you can assemble.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases in the test. Then t test cases follow.
The first line of each test case contains two integers n and k (1 ≤ n, k ≤ 2000).
The second line of each test case contains the string s containing n lowercase English letters — the beads in the store.
It is guaranteed that the sum of n for all test cases does not exceed 2000.
Output
Output t answers to the test cases. Each answer is a positive integer — the maximum length of the k-beautiful necklace you can assemble.
Example
Input
6
6 3
abcbac
3 6
aaa
7 1000
abczgyo
5 4
ababa
20 10
aaebdbabdbbddaadaadc
20 5
ecbedececacbcbccbdec
Output
6
3
5
4
15
10
Note
The first test case is explained in the statement.
In the second test case, a 6-beautiful necklace can be assembled from all the letters.
In the third test case, a 1000-beautiful necklace can be assembled, for example, from beads "abzyo".
Submitted Solution:
```
"""n=int(input())
a=list(map(int,input().split()))
ct=[0]*20
for x in a:
for sf in range(20):
ct[sf]+=(x>>sf)&1
ans=[0]*n
for i in range(20):
for j in range(ct[i]):
print(ans[j],1<<i,ans[j] | 1<<i)
ans[j]|=1<<i
print(sum([x**2 for x in ans]))
"""
"""k=int(input())
s='codeforces'
i,sm=0,1
l=[1]*10
while sm<k:
sm//=l[i]
print(sm,l[i])
l[i]+=1
print(l[i])
sm*=l[i]
print(sm)
i=(i+1)%10
print(l)
ans=[s[i]*l[i] for i in range(10)]
print(''.join(ans))"""
"""T =int(input())
for _ in range(T):
a=input()
if len(a)==2:
print(a)
else:
for i in range(0,len(a),2):
print(a[i],end="")
print(a[-1])"""
"""T = int(input())
for _ in range(T):
n = int(input())
arr = list(map(int,input().split()))
a=b=0
for i in range(n):
if i%2 != arr[i]%2:
if i%2==0:
a+=1
else:
b+=1
if a==b:
print(a)
else:
print(-1)"""
"""T= int(input())
for _ in range(T):
n,k = list(map(int,input().split()))
a = input()
e='0'*k+a+'0'*k
f = k*2+1
z=ct=0
for i in e.split('1'):
ct+=max((len(i)-k)//(k+1),0)
print(ct)"""
"""for _ in range(int(input())):
arr = ['#']+sorted(list(input()))
n = int(input())
num = [-1]+[int(i) for i in input().split()]
ans = ['#']*(n+1)
while 0 in num:
zero = []
for i in range(1,n+1):
if num[i]==0:
zero.append(i)
num[i]=-1
#print("zero",zero)
while arr.count(arr[-1])<len(zero):
p = arr[-1]
while p==arr[-1]:
arr.pop()
#print("arr",arr)
p=0
for i in zero:
p=ans[i]=arr[-1]
#print("ans",ans)
while arr[-1]==p:
arr.pop()
for i in range(1,n+1):
if ans[i]=='#':
for j in zero:
num[i]-=abs(j-i)
#print("num",num)
print(''.join(ans[1:]))"""
import math
import collections
for _ in range(int(input())):
n,k = map(int, input().split())
s = input()
ctr = collections.Counter(s)
ans = 0
for i in range(1,n+1):
g = math.gcd(i, k)
l = i // g
#print(i,k,g,l)
cnt = sum([(v//l)*l for v in ctr.values()])
#print(cnt)
if cnt >= i:
ans = i
print(ans)
```
Yes
| 99,604 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The store sells n beads. The color of each bead is described by a lowercase letter of the English alphabet ("a"–"z"). You want to buy some beads to assemble a necklace from them.
A necklace is a set of beads connected in a circle.
For example, if the store sells beads "a", "b", "c", "a", "c", "c", then you can assemble the following necklaces (these are not all possible options):
<image>
And the following necklaces cannot be assembled from beads sold in the store:
<image> The first necklace cannot be assembled because it has three beads "a" (of the two available). The second necklace cannot be assembled because it contains a bead "d", which is not sold in the store.
We call a necklace k-beautiful if, when it is turned clockwise by k beads, the necklace remains unchanged. For example, here is a sequence of three turns of a necklace.
<image> As you can see, this necklace is, for example, 3-beautiful, 6-beautiful, 9-beautiful, and so on, but it is not 1-beautiful or 2-beautiful.
In particular, a necklace of length 1 is k-beautiful for any integer k. A necklace that consists of beads of the same color is also beautiful for any k.
You are given the integers n and k, and also the string s containing n lowercase letters of the English alphabet — each letter defines a bead in the store. You can buy any subset of beads and connect them in any order. Find the maximum length of a k-beautiful necklace you can assemble.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases in the test. Then t test cases follow.
The first line of each test case contains two integers n and k (1 ≤ n, k ≤ 2000).
The second line of each test case contains the string s containing n lowercase English letters — the beads in the store.
It is guaranteed that the sum of n for all test cases does not exceed 2000.
Output
Output t answers to the test cases. Each answer is a positive integer — the maximum length of the k-beautiful necklace you can assemble.
Example
Input
6
6 3
abcbac
3 6
aaa
7 1000
abczgyo
5 4
ababa
20 10
aaebdbabdbbddaadaadc
20 5
ecbedececacbcbccbdec
Output
6
3
5
4
15
10
Note
The first test case is explained in the statement.
In the second test case, a 6-beautiful necklace can be assembled from all the letters.
In the third test case, a 1000-beautiful necklace can be assembled, for example, from beads "abzyo".
Submitted Solution:
```
def gcd(a, b):
if a < b:
return gcd(b, a)
if b == 0:
return a
return gcd(b, a%b)
for _ in range(int(input())):
n, k = map(int, input().split())
s = input()
if s[0] * n == s:
print(n)
continue
cnt = {}
for c in s:
if c not in cnt:
cnt[c] = 0
cnt[c] += 1
cnt = [cnt[c] for c in cnt]
ans = 1
for x in range(2,n+1):
tempK = k % x
if tempK == 0:
ans = max(ans, x)
continue
mod = x % tempK
if mod != 0:
mod = -(mod - tempK)
times = tempK // gcd(tempK, mod)
needed = x*times // tempK
usedBeads = 0
for num in cnt:
usedBeads += num - num % needed
if usedBeads >= x:
ans = max(ans, x)
print(ans)
```
Yes
| 99,605 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The store sells n beads. The color of each bead is described by a lowercase letter of the English alphabet ("a"–"z"). You want to buy some beads to assemble a necklace from them.
A necklace is a set of beads connected in a circle.
For example, if the store sells beads "a", "b", "c", "a", "c", "c", then you can assemble the following necklaces (these are not all possible options):
<image>
And the following necklaces cannot be assembled from beads sold in the store:
<image> The first necklace cannot be assembled because it has three beads "a" (of the two available). The second necklace cannot be assembled because it contains a bead "d", which is not sold in the store.
We call a necklace k-beautiful if, when it is turned clockwise by k beads, the necklace remains unchanged. For example, here is a sequence of three turns of a necklace.
<image> As you can see, this necklace is, for example, 3-beautiful, 6-beautiful, 9-beautiful, and so on, but it is not 1-beautiful or 2-beautiful.
In particular, a necklace of length 1 is k-beautiful for any integer k. A necklace that consists of beads of the same color is also beautiful for any k.
You are given the integers n and k, and also the string s containing n lowercase letters of the English alphabet — each letter defines a bead in the store. You can buy any subset of beads and connect them in any order. Find the maximum length of a k-beautiful necklace you can assemble.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases in the test. Then t test cases follow.
The first line of each test case contains two integers n and k (1 ≤ n, k ≤ 2000).
The second line of each test case contains the string s containing n lowercase English letters — the beads in the store.
It is guaranteed that the sum of n for all test cases does not exceed 2000.
Output
Output t answers to the test cases. Each answer is a positive integer — the maximum length of the k-beautiful necklace you can assemble.
Example
Input
6
6 3
abcbac
3 6
aaa
7 1000
abczgyo
5 4
ababa
20 10
aaebdbabdbbddaadaadc
20 5
ecbedececacbcbccbdec
Output
6
3
5
4
15
10
Note
The first test case is explained in the statement.
In the second test case, a 6-beautiful necklace can be assembled from all the letters.
In the third test case, a 1000-beautiful necklace can be assembled, for example, from beads "abzyo".
Submitted Solution:
```
def ints():
return list(map(int,input().split()))
from collections import Counter
import math
def pf(n):
l = []
while n % 2 == 0:
l.append(2)
n = n // 2
for i in range(3,int(math.sqrt(n))+1,2):
while n % i== 0:
l.append(i)
n = n // i
if n > 2:
l.append(n)
return list(set(l))
for _ in range(int(input())):
n,k = ints()
s = input()
p = pf(k)
d = Counter(s)
d = sorted(d.values(),reverse = True)
if k==1:
print (n)
continue
m = 0
#print (d)
#print(p)
for x in p:
c = 0
for i in range(len(d)):
if d[i]<x:
break
q = d[i]//x
c = max(c,x*q*(i+1))
#print(c)
if c==0 and len(d)>=x:
c = x
m = max(m,c)
c = 0
if len(d)>=x:
c = d[x-1]
m = max(m,c*x)
#print (m)
#print ()
print(m)
```
No
| 99,606 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The store sells n beads. The color of each bead is described by a lowercase letter of the English alphabet ("a"–"z"). You want to buy some beads to assemble a necklace from them.
A necklace is a set of beads connected in a circle.
For example, if the store sells beads "a", "b", "c", "a", "c", "c", then you can assemble the following necklaces (these are not all possible options):
<image>
And the following necklaces cannot be assembled from beads sold in the store:
<image> The first necklace cannot be assembled because it has three beads "a" (of the two available). The second necklace cannot be assembled because it contains a bead "d", which is not sold in the store.
We call a necklace k-beautiful if, when it is turned clockwise by k beads, the necklace remains unchanged. For example, here is a sequence of three turns of a necklace.
<image> As you can see, this necklace is, for example, 3-beautiful, 6-beautiful, 9-beautiful, and so on, but it is not 1-beautiful or 2-beautiful.
In particular, a necklace of length 1 is k-beautiful for any integer k. A necklace that consists of beads of the same color is also beautiful for any k.
You are given the integers n and k, and also the string s containing n lowercase letters of the English alphabet — each letter defines a bead in the store. You can buy any subset of beads and connect them in any order. Find the maximum length of a k-beautiful necklace you can assemble.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases in the test. Then t test cases follow.
The first line of each test case contains two integers n and k (1 ≤ n, k ≤ 2000).
The second line of each test case contains the string s containing n lowercase English letters — the beads in the store.
It is guaranteed that the sum of n for all test cases does not exceed 2000.
Output
Output t answers to the test cases. Each answer is a positive integer — the maximum length of the k-beautiful necklace you can assemble.
Example
Input
6
6 3
abcbac
3 6
aaa
7 1000
abczgyo
5 4
ababa
20 10
aaebdbabdbbddaadaadc
20 5
ecbedececacbcbccbdec
Output
6
3
5
4
15
10
Note
The first test case is explained in the statement.
In the second test case, a 6-beautiful necklace can be assembled from all the letters.
In the third test case, a 1000-beautiful necklace can be assembled, for example, from beads "abzyo".
Submitted Solution:
```
def good(x,n,k):
m=0
l=[]
for i in range(n+1):
for j in range(i+1,n+1):
a=x[i:j]
c=a[k:]+a[:k]
if a==c:
l.append(a)
m=len(a)
return(l)
for _ in range(int(input())):
n,k=map(int,input().split())
x=str(input())
print(good(x,n,k))
```
No
| 99,607 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The store sells n beads. The color of each bead is described by a lowercase letter of the English alphabet ("a"–"z"). You want to buy some beads to assemble a necklace from them.
A necklace is a set of beads connected in a circle.
For example, if the store sells beads "a", "b", "c", "a", "c", "c", then you can assemble the following necklaces (these are not all possible options):
<image>
And the following necklaces cannot be assembled from beads sold in the store:
<image> The first necklace cannot be assembled because it has three beads "a" (of the two available). The second necklace cannot be assembled because it contains a bead "d", which is not sold in the store.
We call a necklace k-beautiful if, when it is turned clockwise by k beads, the necklace remains unchanged. For example, here is a sequence of three turns of a necklace.
<image> As you can see, this necklace is, for example, 3-beautiful, 6-beautiful, 9-beautiful, and so on, but it is not 1-beautiful or 2-beautiful.
In particular, a necklace of length 1 is k-beautiful for any integer k. A necklace that consists of beads of the same color is also beautiful for any k.
You are given the integers n and k, and also the string s containing n lowercase letters of the English alphabet — each letter defines a bead in the store. You can buy any subset of beads and connect them in any order. Find the maximum length of a k-beautiful necklace you can assemble.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases in the test. Then t test cases follow.
The first line of each test case contains two integers n and k (1 ≤ n, k ≤ 2000).
The second line of each test case contains the string s containing n lowercase English letters — the beads in the store.
It is guaranteed that the sum of n for all test cases does not exceed 2000.
Output
Output t answers to the test cases. Each answer is a positive integer — the maximum length of the k-beautiful necklace you can assemble.
Example
Input
6
6 3
abcbac
3 6
aaa
7 1000
abczgyo
5 4
ababa
20 10
aaebdbabdbbddaadaadc
20 5
ecbedececacbcbccbdec
Output
6
3
5
4
15
10
Note
The first test case is explained in the statement.
In the second test case, a 6-beautiful necklace can be assembled from all the letters.
In the third test case, a 1000-beautiful necklace can be assembled, for example, from beads "abzyo".
Submitted Solution:
```
import sys
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return map(int, minp().split())
def find(cnt, k, h):
l = 0
r = 2001
while r-l > 1:
now = 0
c = (l + r) // 2
for j in cnt:
now += j//c
if now >= h:
l = c
else:
r = c
return l*h
def solve():
n, k = mints()
cnt = [0] * 26
for i in minp():
cnt[ord(i) - ord('a')] += 1
cnt.sort(reverse = True)
ans = 0
for i in range(1,k):
if k % i == 0:
ans = max(ans, find(cnt, k, i))
if k // i != i:
ans = max(ans, find(cnt, k, k // i))
print(ans)
for i in range(mint()):
solve()
```
No
| 99,608 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The store sells n beads. The color of each bead is described by a lowercase letter of the English alphabet ("a"–"z"). You want to buy some beads to assemble a necklace from them.
A necklace is a set of beads connected in a circle.
For example, if the store sells beads "a", "b", "c", "a", "c", "c", then you can assemble the following necklaces (these are not all possible options):
<image>
And the following necklaces cannot be assembled from beads sold in the store:
<image> The first necklace cannot be assembled because it has three beads "a" (of the two available). The second necklace cannot be assembled because it contains a bead "d", which is not sold in the store.
We call a necklace k-beautiful if, when it is turned clockwise by k beads, the necklace remains unchanged. For example, here is a sequence of three turns of a necklace.
<image> As you can see, this necklace is, for example, 3-beautiful, 6-beautiful, 9-beautiful, and so on, but it is not 1-beautiful or 2-beautiful.
In particular, a necklace of length 1 is k-beautiful for any integer k. A necklace that consists of beads of the same color is also beautiful for any k.
You are given the integers n and k, and also the string s containing n lowercase letters of the English alphabet — each letter defines a bead in the store. You can buy any subset of beads and connect them in any order. Find the maximum length of a k-beautiful necklace you can assemble.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases in the test. Then t test cases follow.
The first line of each test case contains two integers n and k (1 ≤ n, k ≤ 2000).
The second line of each test case contains the string s containing n lowercase English letters — the beads in the store.
It is guaranteed that the sum of n for all test cases does not exceed 2000.
Output
Output t answers to the test cases. Each answer is a positive integer — the maximum length of the k-beautiful necklace you can assemble.
Example
Input
6
6 3
abcbac
3 6
aaa
7 1000
abczgyo
5 4
ababa
20 10
aaebdbabdbbddaadaadc
20 5
ecbedececacbcbccbdec
Output
6
3
5
4
15
10
Note
The first test case is explained in the statement.
In the second test case, a 6-beautiful necklace can be assembled from all the letters.
In the third test case, a 1000-beautiful necklace can be assembled, for example, from beads "abzyo".
Submitted Solution:
```
primes=[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999]
from bisect import bisect_left as bl
from math import sqrt,ceil
t=int(input())
for q in range(t):
n,k=map(int,input().split())
s=input()
d={}
for i in s:
if i in d:
d[i]+=1
else:
d[i]=1
x=len(d.values())
while x>1 and k%x!=0:
x-=1
v=min(d.values())
m=max(d.values())
p=v*x
q=[]
if m>1:
prime_pt=bl(primes,ceil(sqrt(k)))
for i in range(prime_pt+1):
t=float("INF")
ct=0
if k%primes[i]==0:
for j in list(d.values()):
if j>=primes[i]:
t=min(t,(j//primes[i])*primes[i])
ct+=1
if t and (t*ct)%primes[i]==0:
q.append(t*ct)
t=float("INF")
ct=0
for j in list(d.values()):
if j>=k:
t=(min(t,j//k)*k)
ct+=1
if t and (t*ct)%k==0:
q.append(t*ct)
fq=0
if q:
fq=max(q)
print(max(p,fq))
```
No
| 99,609 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After returning to shore, uncle Bogdan usually visits the computer club "The Rock", to solve tasks in a pleasant company. One day, uncle Bogdan met his good old friend who told him one unusual task...
There are n non-intersecting horizontal segments with ends in integers points on the plane with the standard cartesian coordinate system. All segments are strictly above the OX axis. You can choose an arbitrary vector (a, b), where b < 0 and coordinates are real numbers, and project all segments to OX axis along this vector. The projections shouldn't intersect but may touch each other.
Find the minimum possible difference between x coordinate of the right end of the rightmost projection and x coordinate of the left end of the leftmost projection.
Input
The first line contains the single integer n (1 ≤ n ≤ 2000) — the number of segments.
The i-th of the next n lines contains three integers xl_i, xr_i and y_i (-10^6 ≤ xl_i < xr_i ≤ 10^6; 1 ≤ y_i ≤ 10^6) — coordinates of the corresponding segment.
It's guaranteed that the segments don't intersect or touch.
Output
Print the minimum possible difference you can get.
Your answer will be considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Formally, if your answer is a and jury's answer is b then your answer will be considered correct if \frac{|a - b|}{max{(1, |b|)}} ≤ 10^{-6}.
Examples
Input
3
1 6 2
4 6 4
4 6 6
Output
9.000000000
Input
3
2 5 1
4 6 4
7 8 2
Output
6.333333333
Input
2
1 3 1
4 7 1
Output
6.000000000
Note
In the first example if we project segments along the vector (1, -1) then we get an answer 12-3=9 and (it can be proven) it is impossible to get less.
<image>
It is optimal to project along the vector (1, -3) in the second example. The answer is 82/3-21/3=61/3
<image>
Submitted Solution:
```
t=int(input())
for i in range(t):
lis=list(map(int,input().split()))
```
No
| 99,610 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After returning to shore, uncle Bogdan usually visits the computer club "The Rock", to solve tasks in a pleasant company. One day, uncle Bogdan met his good old friend who told him one unusual task...
There are n non-intersecting horizontal segments with ends in integers points on the plane with the standard cartesian coordinate system. All segments are strictly above the OX axis. You can choose an arbitrary vector (a, b), where b < 0 and coordinates are real numbers, and project all segments to OX axis along this vector. The projections shouldn't intersect but may touch each other.
Find the minimum possible difference between x coordinate of the right end of the rightmost projection and x coordinate of the left end of the leftmost projection.
Input
The first line contains the single integer n (1 ≤ n ≤ 2000) — the number of segments.
The i-th of the next n lines contains three integers xl_i, xr_i and y_i (-10^6 ≤ xl_i < xr_i ≤ 10^6; 1 ≤ y_i ≤ 10^6) — coordinates of the corresponding segment.
It's guaranteed that the segments don't intersect or touch.
Output
Print the minimum possible difference you can get.
Your answer will be considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Formally, if your answer is a and jury's answer is b then your answer will be considered correct if \frac{|a - b|}{max{(1, |b|)}} ≤ 10^{-6}.
Examples
Input
3
1 6 2
4 6 4
4 6 6
Output
9.000000000
Input
3
2 5 1
4 6 4
7 8 2
Output
6.333333333
Input
2
1 3 1
4 7 1
Output
6.000000000
Note
In the first example if we project segments along the vector (1, -1) then we get an answer 12-3=9 and (it can be proven) it is impossible to get less.
<image>
It is optimal to project along the vector (1, -3) in the second example. The answer is 82/3-21/3=61/3
<image>
Submitted Solution:
```
import sys
from collections import deque
readline = sys.stdin.buffer.readline
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
def solve():
n = ni()
l = [tuple(nm()) for _ in range(n)]
pl = list()
mi = list()
eps = 10**-7
for i in range(n-1):
for j in range(i+1, n):
a, b, c = l[i]
d, e, f = l[j]
if c == f:
continue
if c > f:
a, b, c, d, e, f = d, e, f, a, b, c
u = (a - e) / (f - c)
v = (b - d) / (f - c)
if u >= 0.0:
pl.append((u, v, b-d, f-c))
elif v <= 0.0:
mi.append((-v, -u, a-e, f-c))
else:
pl.append((0.0, v, b-d, f-c))
mi.append((0.0, -u, a-e, f-c))
pl.sort()
mi.sort()
# print(pl, mi, sep='\n')
cpl = cmi = 0.0
qpl, ppl, qmi, pmi = 1, 0, 1, 0
for u, v, p, q in pl:
if cpl < u - eps:
break
cpl = v
ppl, qpl = p, q
for u, v, p, q in mi:
if cmi < u - eps:
break
cmi = v
pmi, qmi = p, q
# print(qpl, ppl, qmi, pmi)
def calc(p, q):
cma, cmi = -10**18, 10**18
for xl, xr, y in l:
ri = xr + p * y / q
le = xl + p * y / q
if ri > cma: cma = ri
if le < cmi: cmi = le
return cma - cmi
print(min(calc(ppl, qpl), calc(pmi, qmi)))
return
solve()
# T = ni()
# for _ in range(T):
# solve()
```
No
| 99,611 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After returning to shore, uncle Bogdan usually visits the computer club "The Rock", to solve tasks in a pleasant company. One day, uncle Bogdan met his good old friend who told him one unusual task...
There are n non-intersecting horizontal segments with ends in integers points on the plane with the standard cartesian coordinate system. All segments are strictly above the OX axis. You can choose an arbitrary vector (a, b), where b < 0 and coordinates are real numbers, and project all segments to OX axis along this vector. The projections shouldn't intersect but may touch each other.
Find the minimum possible difference between x coordinate of the right end of the rightmost projection and x coordinate of the left end of the leftmost projection.
Input
The first line contains the single integer n (1 ≤ n ≤ 2000) — the number of segments.
The i-th of the next n lines contains three integers xl_i, xr_i and y_i (-10^6 ≤ xl_i < xr_i ≤ 10^6; 1 ≤ y_i ≤ 10^6) — coordinates of the corresponding segment.
It's guaranteed that the segments don't intersect or touch.
Output
Print the minimum possible difference you can get.
Your answer will be considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Formally, if your answer is a and jury's answer is b then your answer will be considered correct if \frac{|a - b|}{max{(1, |b|)}} ≤ 10^{-6}.
Examples
Input
3
1 6 2
4 6 4
4 6 6
Output
9.000000000
Input
3
2 5 1
4 6 4
7 8 2
Output
6.333333333
Input
2
1 3 1
4 7 1
Output
6.000000000
Note
In the first example if we project segments along the vector (1, -1) then we get an answer 12-3=9 and (it can be proven) it is impossible to get less.
<image>
It is optimal to project along the vector (1, -3) in the second example. The answer is 82/3-21/3=61/3
<image>
Submitted Solution:
```
from sys import stdin
import math
import sys
n = int(stdin.readline())
lry = []
for loop in range(n):
xl,xr,y = map(int,stdin.readline().split())
lry.append((xl,xr,y))
flag = True
minl = float("inf")
maxr = float("-inf")
for i in range(n):
for j in range(i):
Li,Ri,Yi = lry[i]
Lj,Rj,Yj = lry[j]
if Lj >= Ri or Li >= Rj:
minl = min(Li,Lj,minl)
maxr = max(Ri,Rj,maxr)
else:
flag = False
if flag:
print (maxr-minl)
sys.exit()
lis = []
cnt = 0
for i in range(n):
for j in range(n):
Li,Ri,Yi = lry[i]
Lj,Rj,Yj = lry[j]
if Yi <= Yj:
continue
#L
vecA = (Lj-Li,Yj-Yi)
vecB = (Rj-Li,Yj-Yi)
lis.append( (math.atan2(vecA[1],vecA[0]) ,1, vecA[0] , vecA[1] , cnt) )
lis.append( (math.atan2(vecB[1],vecB[0]) ,1, vecB[0] , vecB[1] , cnt) )
cnt += 1
#R
vecA = (Lj-Ri,Yj-Yi)
vecB = (Rj-Ri,Yj-Yi)
lis.append( (math.atan2(vecA[1],vecA[0]) ,0, vecA[0] , vecA[1] , cnt) )
lis.append( (math.atan2(vecB[1],vecB[0]) ,0, vecB[0] , vecB[1] , cnt) )
cnt += 1
#imos
lis.sort()
use = [True] * cnt
ctt = 0
#print (lis)
ans = float("inf")
for i in range(len(lis)):
at,gomi,x,y,c = lis[i]
if ctt == 0:
nmin = float("inf")
nmax = float("-inf")
for txl,txr,ty in lry:
lastxl = txl + x * (ty/(abs(y)))
nmin = min(nmin , lastxl)
lastxr = txr + x * (ty/(abs(y)))
nmax = max(nmax , lastxr)
ans = min(ans , nmax - nmin)
if use[c]:
use[c] = False
ctt += 1
else:
use[c] = True
ctt -= 1
if ctt == 0:
nmin = float("inf")
nmax = float("-inf")
for txl,txr,ty in lry:
lastxl = txl + x * (ty/(abs(y)))
nmin = min(nmin , lastxl)
lastxr = txr + x * (ty/(abs(y)))
nmax = max(nmax , lastxr)
ans = min(ans , nmax - nmin)
print (ans)
```
No
| 99,612 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After returning to shore, uncle Bogdan usually visits the computer club "The Rock", to solve tasks in a pleasant company. One day, uncle Bogdan met his good old friend who told him one unusual task...
There are n non-intersecting horizontal segments with ends in integers points on the plane with the standard cartesian coordinate system. All segments are strictly above the OX axis. You can choose an arbitrary vector (a, b), where b < 0 and coordinates are real numbers, and project all segments to OX axis along this vector. The projections shouldn't intersect but may touch each other.
Find the minimum possible difference between x coordinate of the right end of the rightmost projection and x coordinate of the left end of the leftmost projection.
Input
The first line contains the single integer n (1 ≤ n ≤ 2000) — the number of segments.
The i-th of the next n lines contains three integers xl_i, xr_i and y_i (-10^6 ≤ xl_i < xr_i ≤ 10^6; 1 ≤ y_i ≤ 10^6) — coordinates of the corresponding segment.
It's guaranteed that the segments don't intersect or touch.
Output
Print the minimum possible difference you can get.
Your answer will be considered correct if its absolute or relative error doesn't exceed 10^{-6}.
Formally, if your answer is a and jury's answer is b then your answer will be considered correct if \frac{|a - b|}{max{(1, |b|)}} ≤ 10^{-6}.
Examples
Input
3
1 6 2
4 6 4
4 6 6
Output
9.000000000
Input
3
2 5 1
4 6 4
7 8 2
Output
6.333333333
Input
2
1 3 1
4 7 1
Output
6.000000000
Note
In the first example if we project segments along the vector (1, -1) then we get an answer 12-3=9 and (it can be proven) it is impossible to get less.
<image>
It is optimal to project along the vector (1, -3) in the second example. The answer is 82/3-21/3=61/3
<image>
Submitted Solution:
```
def compute(l):
ms = [1, 0]
sll = []
for i in range(len(l)):
for j in range(i+1, len(l)):
if l[i][2] > l[j][2]:
ts, te, ty = map(float, l[i])
ss, se, sy = map(float, l[j])
else:
ts, te, ty = map(float, l[j])
ss, se, sy = map(float, l[i])
sly = ty-sy
slx = ts-se
if sly > 0:
if te > ss:
if slx < 0 and sly > 0:
if ms[1] == 0 or -sly/slx < ms[0]/ms[1]:
ms = [sly, -slx]
elif te == ss:
sll.append([-sly/slx, 10**100, sly, -slx, 1, 0])
else:
sll.append([-sly/slx, (ty-sy)/(ss-te), sly, -slx, ty-sy, ss-te])
sll = list(sorted(sll))[::-1]
for i in sll:
if ms[1] != 0 and ms[0]/ms[1] < i[1]:
if ms[0]/ms[1] > i[0]:
ms = [i[4], i[5]]
start = 10**100
end = -10**100
for i in l:
coords = [i[0], i[2]]
if ms == "inf":
si = i[0]
ei = i[1]
else:
si = i[0]+i[2]*ms[1]/ms[0]
ei = i[1]+i[2]*ms[1]/ms[0]
start = min(start, si)
end = max(end, ei)
return start, end
n = int(input())
l = []
l1 = []
for i in range(n):
new = list(map(int, input().split()))
l.append(new)
new1 = [-new[1], -new[0], new[2]]
l1.append(new1)
x1, x2 = compute(l)
x3, x4 = compute(l1)
print(min(x4-x3, x2-x1))
```
No
| 99,613 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < … < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = … = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 ≤ n ≤ 50; 1 ≤ x < y ≤ 50) — the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Tags: brute force, math, number theory
Correct Solution:
```
#!/usr/bin/env python3
# encoding: utf-8
#----------
# Constants
#----------
#----------
# Functions
#----------
# The function that solves the task
def calc(n, x, y):
best_maximum, best_k = 1000000001, 0
for m in range(1, n):
k = (y - x) // m
if m * k != y - x:
continue
start = y - k * (n-1)
delta = 0
if start <= 0:
delta = (k - start) // k
start += delta * k
if start > x:
continue
maximum = y + delta * k
if maximum < best_maximum:
best_maximum = maximum
best_k = k
assert best_k > 0
res = []
for i in range(n):
res.append(best_maximum)
best_maximum -= best_k
return res
# Reads a string from stdin, splits it by space chars, converts each
# substring to int, adds it to a list and returns the list as a result.
def get_ints():
return [ int(n) for n in input().split() ]
# Reads a string from stdin, splits it by space chars, converts each substring
# to floating point number, adds it to a list and returns the list as a result.
def get_floats():
return [ float(n) for n in input().split() ]
# Converts a sequence to the space separated string
def seq2str(seq):
return ' '.join(str(item) for item in seq)
#----------
# Execution start point
#----------
if __name__ == "__main__":
zzz = get_ints()
assert len(zzz) == 1
t = zzz[0]
for i in range(t):
zzz = get_ints()
assert len(zzz) == 3
n, x, y = zzz[0], zzz[1], zzz[2]
res = calc(n, x, y)
print(seq2str(res))
```
| 99,614 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < … < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = … = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 ≤ n ≤ 50; 1 ≤ x < y ≤ 50) — the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Tags: brute force, math, number theory
Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Mon Aug 3 21:10:40 2020
@author: dennis
"""
import atexit
import io
import sys
_INPUT_LINES = sys.stdin.read().splitlines()
input = iter(_INPUT_LINES).__next__
_OUTPUT_BUFFER = io.StringIO()
sys.stdout = _OUTPUT_BUFFER
@atexit.register
def write():
sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
for case in range(int(input())):
n, x, y = [int(x) for x in input().split()]
m = 10**9 + 1
for i in range(1, 51):
for j in range(1, 51):
r = range(i, n*j + i, j)
if x in r and y in r:
s = max(r)
if s < m:
m = s
ans = [x for x in r]
print(*ans)
```
| 99,615 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < … < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = … = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 ≤ n ≤ 50; 1 ≤ x < y ≤ 50) — the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Tags: brute force, math, number theory
Correct Solution:
```
def answer(n,x,y):
diff=y-x
d=-1
for i in range(n-1,0,-1):
if diff%i==0:
d=diff//i
break
l=[y]
q=y-d
while len(l)<n and q>0:
l.append(q)
q=q-d
q=y+d
while len(l)<n:
l.append(q)
q+=d
return l
t=int(input())
for i in range(t):
n,x,y=map(int,input().split())
print(*answer(n,x,y))
```
| 99,616 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < … < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = … = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 ≤ n ≤ 50; 1 ≤ x < y ≤ 50) — the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Tags: brute force, math, number theory
Correct Solution:
```
t=int(input())
w=[]
def func(t,h):
i=1
boo=True
while boo:
if t % i==0:
if t< i * h:
boo=False
return i
else:
i=i+1
else:
i=i+1
for i in range(t):
n,x,y=input().split()
n=int(n)
x=int(x)
y=int(y)
r=[]
d=func(y-x,n)
if y>=n*d:
for z in range(y-n*d+d,y+1,d):
r.append(z)
else:
i=0
c=0
while y-i*d>0:
r.append(y-i*d)
c=c+1
i=i+1
i=1
while c!=n:
r.append(y+i*d)
c=c+1
i=i+1
w.append(r)
for i in w:
print(*i)
```
| 99,617 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < … < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = … = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 ≤ n ≤ 50; 1 ≤ x < y ≤ 50) — the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Tags: brute force, math, number theory
Correct Solution:
```
from sys import *
from math import *
from sys import stdin,stdout
from collections import *
int_arr = lambda : list(map(int,stdin.readline().strip().split()))
str_arr = lambda :list(map(str,stdin.readline().split()))
get_str = lambda : map(str,stdin.readline().strip().split())
get_int = lambda: map(int,stdin.readline().strip().split())
get_float = lambda : map(float,stdin.readline().strip().split())
mod = 1000000007
setrecursionlimit(1000)
lst = [i for i in range(1,51)]
l = len(lst)
def ans(l,n,x,y,lst):
for i in range(l):
if (y - x) % lst[i] == 0 and (((y - x) // lst[i]) - 1) <= (n - 2):
val = lst[i]
break
res = [x,y]
ct = 2
y1,x1 = y,x
#print(val)
while ct != n:
if (y - val) > x1:
y -= val
ct += 1
res.append(y)
elif x - val > 0:
x -= val
ct += 1
res.append(x)
else:
y1 += val
ct += 1
res.append(y1)
print(*res)
for _ in range(int(input())):
n,x,y = get_int()
ans(l,n,x,y,lst)
```
| 99,618 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < … < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = … = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 ≤ n ≤ 50; 1 ≤ x < y ≤ 50) — the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Tags: brute force, math, number theory
Correct Solution:
```
import sys
input=sys.stdin.readline
for _ in range(int(input())):
# n=int(input())
n,x,y=[int(j) for j in input().split()]
ans=[]
mini=min(x,y)
y=max(x,y)
x=mini
# if n==2:
# ans.append(x)
# ans.append(y)
# elif n>=abs(x-y)+1:
# if n>=y:
# for i in range(1,n+1):
# ans.append(i)
# else:
# dif=n-(y-x+1)-1
# for i in range(x,y+1):
# ans.append(i)
# for i in range(dif,x):
# ans.append(i)
# else:
diff=[]
arr=[]
for i in range(1,y-x+1):
if (y-x)%i==0 and (y-x)//i<=(n-1):
diff.append(i)
# print(diff)
for i in range(len(diff)):
temp=[]
temp.append(x)
temp.append(y)
count=0
t=0
while count<n-2:
t+=1
if x+t*diff[i]>=y:
break
count+=1
temp.append(x+t*diff[i])
t=0
while count<n-2:
t+=1
if x-t*diff[i]<=0:
break
count+=1
temp.append(x-t*diff[i])
t=0
while count<n-2:
count+=1
t+=1
temp.append(y+t*diff[i])
arr.append(temp)
ans=arr[0]
print(*ans)
```
| 99,619 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < … < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = … = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 ≤ n ≤ 50; 1 ≤ x < y ≤ 50) — the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Tags: brute force, math, number theory
Correct Solution:
```
for _ in range(int(input())):
n, x, y = map(int, input().split())
a_n_max = float('inf')
d_max = 0
for n1 in range(2, n+1):
d = (y - x)/(n1 - 1)
if d % 1 == 0:
for pos in range(n, n1-1, -1):
a1 = y - d*(pos - 1)
if a1 > 0:
a_n = a1 + d*(n - 1)
if a_n < a_n_max:
a_n_max = int(a_n)
d_max = int(d)
arr = [0]*n
arr[-1] = a_n_max
for i in range(n-2, -1, -1):
arr[i] = arr[i+1] - d_max
print(' '.join(str(i) for i in arr))
```
| 99,620 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < … < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = … = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 ≤ n ≤ 50; 1 ≤ x < y ≤ 50) — the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Tags: brute force, math, number theory
Correct Solution:
```
t = int(input())
while t>0:
n,x,y = list(map(int,input().split()))
min_val = 1e5
min_diff = 0
for xpos in range(0,n-1):
for ypos in range(xpos+1,n):
l = ypos-xpos
if (y-x) % l > 0 :
continue
diff = (y-x)/l
max_item = x + (n-1-xpos)*diff
if max_item < min_val and (x -(xpos*diff))>=1:
min_val = int(max_item)
min_diff = int(diff)
first_num = min_val - (n-1)*min_diff
for index in range(0,n):
print("{}".format(first_num + index*min_diff), end=" ")
print("")
t -= 1
```
| 99,621 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < … < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = … = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 ≤ n ≤ 50; 1 ≤ x < y ≤ 50) — the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Submitted Solution:
```
for _ in range(int(input())):
n, x, y = map(int, input().split())
res = [10 ** 18]
if n == 2:
res = [x, y]
else:
for i in range(1, 51):
tmp = []
if (y - x) % i == 0 and (y - x) // i <= n - 1:
tmp = [j for j in range(x, y + 1, i)]
nn = n - len(tmp)
if nn > 0:
for j in range(x - i, 0, -i):
tmp = [j] + tmp
nn -= 1
if nn == 0:
break
if nn > 0:
for j in range(y + i, y + n * i, i):
tmp.append(j)
nn -= 1
if nn == 0:
break
if res[-1] > tmp[-1]:
res = tmp
print(*res)
```
Yes
| 99,622 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < … < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = … = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 ≤ n ≤ 50; 1 ≤ x < y ≤ 50) — the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Submitted Solution:
```
for _ in range(int(input())):
n,x,y=map(int,input().split())
print(x,y,end=" ")
div=n-1
unsolved,needed,xtra_needed=True,0,0
diff=y-x
got=0
while unsolved:
if diff%div!=0: div-=1
else:
got=int(diff/div)
needed=div-1
xtra_needed=n-div-1
unsolved=False
another,other,num=x,y,0
while another<y and needed>0:
another+=got
print(another,end=" ")
needed-=1
while x-got>0 and xtra_needed>0:
x=x-got
xtra_needed-=1
print(x,end=" ")
while xtra_needed>0:
y+=got
xtra_needed-=1
print(y,end=" ")
print()
```
Yes
| 99,623 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < … < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = … = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 ≤ n ≤ 50; 1 ≤ x < y ≤ 50) — the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Submitted Solution:
```
t = int(input())
for _ in range(t):
n,x,y = map(int,input().split())
maxi = 10**18
final = []
for a in range(1,51):
for d in range(1,51):
flag = 0
ans = []
for i in range(1,n+1):
ans.append(a+(i-1)*d)
if ans[-1] == x or ans[-1] == y:
flag+=1
if flag == 2:
if ans[-1]<maxi:
maxi = min(ans[-1],maxi)
final = ans
print(*final)
```
Yes
| 99,624 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < … < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = … = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 ≤ n ≤ 50; 1 ≤ x < y ≤ 50) — the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Submitted Solution:
```
#include <CodeforcesSolutions.h>
#include <ONLINE_JUDGE <solution.cf(contestID = "1409",questionID = "A",method = "GET")>.h>
"""
Author : thekushalghosh
Team : CodeDiggers
I prefer Python language over the C++ language :p :D
Visit my website : thekushalghosh.github.io
"""
import sys,math,cmath,time
start_time = time.time()
##########################################################################
################# ---- THE ACTUAL CODE STARTS BELOW ---- #################
def solve():
n,x,y = invr()
q = y - x
for i in range(1,q + 1):
if q % i == 0 and (q // i) + 1 <= n:
w = i
break
qq = x
ww = n - (q // w) - 1
while qq - w >= 1 and ww >= 1:
qq = qq - w
ww = ww - 1
q = [qq]
for i in range(n - 1):
q.append(q[-1] + w)
print(*q)
################## ---- THE ACTUAL CODE ENDS ABOVE ---- ##################
##########################################################################
def main():
global tt
if not ONLINE_JUDGE:
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
t = 1
t = inp()
for tt in range(t):
solve()
if not ONLINE_JUDGE:
print("Time Elapsed :",time.time() - start_time,"seconds")
sys.stdout.close()
#---------------------- USER DEFINED INPUT FUNCTIONS ----------------------#
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
return(input().strip())
def invr():
return(map(int,input().split()))
#------------------ USER DEFINED PROGRAMMING FUNCTIONS ------------------#
def counter(a):
q = [0] * max(a)
for i in range(len(a)):
q[a[i] - 1] = q[a[i] - 1] + 1
return(q)
def counter_elements(a):
q = dict()
for i in range(len(a)):
if a[i] not in q:
q[a[i]] = 0
q[a[i]] = q[a[i]] + 1
return(q)
def string_counter(a):
q = [0] * 26
for i in range(len(a)):
q[ord(a[i]) - 97] = q[ord(a[i]) - 97] + 1
return(q)
def factors(n):
q = []
for i in range(1,int(n ** 0.5) + 1):
if n % i == 0: q.append(i); q.append(n // i)
return(list(sorted(list(set(q)))))
def prime_factors(n):
q = []
while n % 2 == 0: q.append(2); n = n // 2
for i in range(3,int(n ** 0.5) + 1,2):
while n % i == 0: q.append(i); n = n // i
if n > 2: q.append(n)
return(list(sorted(q)))
def transpose(a):
n,m = len(a),len(a[0])
b = [[0] * n for i in range(m)]
for i in range(m):
for j in range(n):
b[i][j] = a[j][i]
return(b)
def factorial(n,m = 1000000007):
q = 1
for i in range(n):
q = (q * (i + 1)) % m
return(q)
#-----------------------------------------------------------------------#
ONLINE_JUDGE = __debug__
if ONLINE_JUDGE:
input = sys.stdin.readline
main()
```
Yes
| 99,625 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < … < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = … = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 ≤ n ≤ 50; 1 ≤ x < y ≤ 50) — the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Submitted Solution:
```
t = int(input())
while t:
t -= 1
n, x, y = map(int, input().split())
ans =[]
ansT = 10**9 * 50+1
for d in range(1,y-x+1):
findx = y
tmptotal = y
cur = 1
tmp=[]
tmp.append(y)
ok=False
while cur<n:
findx-=d
if findx < x:
findx+=d
break
else:
cur += 1
tmptotal += findx
tmp.append(findx)
if x not in tmp:
continue
while cur<n:
findx-=d
if findx <= 0:
break
else:
cur += 1
tmptotal +=findx
tmp.append(findx)
findx = y
while cur<n:
findx+=d
tmptotal+=findx
tmp.append(findx)
cur+=1
if tmptotal<ansT:
ansT = tmptotal
ans = tmp
print(*ans)
```
No
| 99,626 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < … < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = … = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 ≤ n ≤ 50; 1 ≤ x < y ≤ 50) — the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Submitted Solution:
```
t=int(input())
for i in range(t):
n,x,y=map(int,input().split(" "))
if n==2:
print(x,y)
else:
arr=[x,y]
diff=y-x
between=n-2+1
while between>1:
if diff%between==0:
interval=diff//between
break
between-=1
for i in range(1,between):
arr.append(x+interval*i)
leftover=n-between-1
for i in range(1,leftover+1):
arr.append(x-interval*i)
print(*arr)
```
No
| 99,627 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < … < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = … = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 ≤ n ≤ 50; 1 ≤ x < y ≤ 50) — the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Submitted Solution:
```
def solve(p,n):
if p%n==0:
return p//n
return -1
def solve1(diff,n,x,y):
if y - (n - 1) * diff > 0:
a = [];p=y
for i in range(n):
a.append(p)
p -= diff
return a[::-1][:]
elif (x - 1) / (diff) % 1 == 0 and (y - 1) / (diff) % 1 == 0:
a = []
p = 1
for i in range(n):
a.append(p)
p += diff
return a[::-1][:]
else:
p = x
a = []
for i in range(n):
a.append(p)
p += diff
return a[::-1][:]
for _ in range(int(input())):
n,x,y=map(int,input().split())
a=[10**10]
for i in range(1,n):
p=solve(y-x,i)
if p!=-1:
q=solve1(p,n,x,y)
if max(q)<max(a):
a=q[:]
print(*a)
```
No
| 99,628 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a secret array. You don't know this array and you have to restore it. However, you know some facts about this array:
* The array consists of n distinct positive (greater than 0) integers.
* The array contains two elements x and y (these elements are known for you) such that x < y.
* If you sort the array in increasing order (such that a_1 < a_2 < … < a_n), differences between all adjacent (consecutive) elements are equal (i.e. a_2 - a_1 = a_3 - a_2 = … = a_n - a_{n-1}).
It can be proven that such an array always exists under the constraints given below.
Among all possible arrays that satisfy the given conditions, we ask you to restore one which has the minimum possible maximum element. In other words, you have to minimize max(a_1, a_2, ..., a_n).
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The only line of the test case contains three integers n, x and y (2 ≤ n ≤ 50; 1 ≤ x < y ≤ 50) — the length of the array and two elements that are present in the array, respectively.
Output
For each test case, print the answer: n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of the required array. If there are several answers, you can print any (it also means that the order of elements doesn't matter).
It can be proven that such an array always exists under the given constraints.
Example
Input
5
2 1 49
5 20 50
6 20 50
5 3 8
9 13 22
Output
1 49
20 40 30 50 10
26 32 20 38 44 50
8 23 18 13 3
1 10 13 4 19 22 25 16 7
Submitted Solution:
```
from math import ceil
t = int(input())
for _ in range(t):
n, a, b = map(int, input().split())
c = abs(a-b)
i = n - 1
arr = [0]*n
while i != 1:
if c % i == 0:
break
else:
i -= 1
d = c // i
j = n - i - 2
arr[j+1] = min(a,b)
while j >= 0:
arr[j] = arr[j+1]-d
j -= 1
for i in range(n-i, n):
arr[i] = arr[i-1]+d
#if arr[0] <= 0:
# c = min(a,b) - arr[0]
#
# for i in range(n):
# arr[i] += c
if arr[0] <= 0:
q = ceil(abs(arr[0])/d)
c = q*d
for i in range(n):
arr[i] += c
for i in range(n):
print(arr[i], end=" ")
print()
```
No
| 99,629 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently a new building with a new layout was constructed in Monocarp's hometown. According to this new layout, the building consists of three types of apartments: three-room, five-room, and seven-room apartments. It's also known that each room of each apartment has exactly one window. In other words, a three-room apartment has three windows, a five-room — five windows, and a seven-room — seven windows.
Monocarp went around the building and counted n windows. Now he is wondering, how many apartments of each type the building may have.
Unfortunately, Monocarp only recently has learned to count, so he is asking you to help him to calculate the possible quantities of three-room, five-room, and seven-room apartments in the building that has n windows. If there are multiple answers, you can print any of them.
Here are some examples:
* if Monocarp has counted 30 windows, there could have been 2 three-room apartments, 2 five-room apartments and 2 seven-room apartments, since 2 ⋅ 3 + 2 ⋅ 5 + 2 ⋅ 7 = 30;
* if Monocarp has counted 67 windows, there could have been 7 three-room apartments, 5 five-room apartments and 3 seven-room apartments, since 7 ⋅ 3 + 5 ⋅ 5 + 3 ⋅ 7 = 67;
* if Monocarp has counted 4 windows, he should have mistaken since no building with the aforementioned layout can have 4 windows.
Input
Th first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of windows in the building.
Output
For each test case, if a building with the new layout and the given number of windows just can't exist, print -1.
Otherwise, print three non-negative integers — the possible number of three-room, five-room, and seven-room apartments. If there are multiple answers, print any of them.
Example
Input
4
30
67
4
14
Output
2 2 2
7 5 3
-1
0 0 2
Tags: brute force, constructive algorithms, math
Correct Solution:
```
for t in range(int(input())):
n=int(input())
a=[]
if n%3==0 or n%5==0 or n%7==0:
if n%3==0:
a=[n//3,0,0]
elif n%5==0:
a=[0,n//5,0]
else:
a=[0,0,n//7]
else:
if (n-7)%5==0:
a=[0,(n-7)//5,1]
elif (n-3)%5==0:
a=[1,(n-3)//5,0]
elif (n-5)%7==0:
a=[0,1,(n-5)//7]
elif (n-3)%7==0:
a=[1,0,(n-3)//7]
elif (n-5)%3==0:
a=[(n-5)//3,1,0]
elif (n-7)%3==0:
a=[(n-7)//3,0,1]
#print(a)
if sum(a)<1:
print("-1")
else:
for i in a:
print(i,end=" ")
```
| 99,630 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently a new building with a new layout was constructed in Monocarp's hometown. According to this new layout, the building consists of three types of apartments: three-room, five-room, and seven-room apartments. It's also known that each room of each apartment has exactly one window. In other words, a three-room apartment has three windows, a five-room — five windows, and a seven-room — seven windows.
Monocarp went around the building and counted n windows. Now he is wondering, how many apartments of each type the building may have.
Unfortunately, Monocarp only recently has learned to count, so he is asking you to help him to calculate the possible quantities of three-room, five-room, and seven-room apartments in the building that has n windows. If there are multiple answers, you can print any of them.
Here are some examples:
* if Monocarp has counted 30 windows, there could have been 2 three-room apartments, 2 five-room apartments and 2 seven-room apartments, since 2 ⋅ 3 + 2 ⋅ 5 + 2 ⋅ 7 = 30;
* if Monocarp has counted 67 windows, there could have been 7 three-room apartments, 5 five-room apartments and 3 seven-room apartments, since 7 ⋅ 3 + 5 ⋅ 5 + 3 ⋅ 7 = 67;
* if Monocarp has counted 4 windows, he should have mistaken since no building with the aforementioned layout can have 4 windows.
Input
Th first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of windows in the building.
Output
For each test case, if a building with the new layout and the given number of windows just can't exist, print -1.
Otherwise, print three non-negative integers — the possible number of three-room, five-room, and seven-room apartments. If there are multiple answers, print any of them.
Example
Input
4
30
67
4
14
Output
2 2 2
7 5 3
-1
0 0 2
Tags: brute force, constructive algorithms, math
Correct Solution:
```
#include <CodeforcesSolutions.h>
#include <ONLINE_JUDGE <solution.cf(contestID = "1430",questionID = "A",method = "GET")>.h>
"""
Author : thekushalghosh
Team : CodeDiggers
I prefer Python language over the C++ language :p :D
Visit my website : thekushalghosh.github.io
"""
import sys,math,cmath,time,collections
start_time = time.time()
##########################################################################
################# ---- THE ACTUAL CODE STARTS BELOW ---- #################
def solve():
n = inp()
if n != 3 and n < 5:
print(-1)
elif n % 3 == 0:
print(n // 3,0,0)
elif n % 3 == 1:
print((n - 7) // 3,0,1)
else:
print((n - 5) // 3,1,0)
################## ---- THE ACTUAL CODE ENDS ABOVE ---- ##################
##########################################################################
def main():
global tt
if not ONLINE_JUDGE:
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
t = 1
t = inp()
for tt in range(1,t + 1):
solve()
if not ONLINE_JUDGE:
print("Time Elapsed :",time.time() - start_time,"seconds")
sys.stdout.close()
#---------------------- USER DEFINED INPUT FUNCTIONS ----------------------#
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
return(input().strip())
def invr():
return(map(int,input().split()))
#------------------ USER DEFINED PROGRAMMING FUNCTIONS ------------------#
def counter(a):
q = [0] * max(a)
for i in range(len(a)):
q[a[i] - 1] = q[a[i] - 1] + 1
return(q)
def counter_elements(a):
q = dict()
for i in range(len(a)):
if a[i] not in q:
q[a[i]] = 0
q[a[i]] = q[a[i]] + 1
return(q)
def string_counter(a):
q = [0] * 26
for i in range(len(a)):
q[ord(a[i]) - 97] = q[ord(a[i]) - 97] + 1
return(q)
def factorial(n,m = 1000000007):
q = 1
for i in range(n):
q = (q * (i + 1)) % m
return(q)
def factors(n):
q = []
for i in range(1,int(n ** 0.5) + 1):
if n % i == 0: q.append(i); q.append(n // i)
return(list(sorted(list(set(q)))))
def prime_factors(n):
q = []
while n % 2 == 0: q.append(2); n = n // 2
for i in range(3,int(n ** 0.5) + 1,2):
while n % i == 0: q.append(i); n = n // i
if n > 2: q.append(n)
return(list(sorted(q)))
def transpose(a):
n,m = len(a),len(a[0])
b = [[0] * n for i in range(m)]
for i in range(m):
for j in range(n):
b[i][j] = a[j][i]
return(b)
def power_two(x):
return (x and (not(x & (x - 1))))
def ceil(a, b):
return -(-a // b)
def seive(n):
a = [1]
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p ** 2,n + 1, p):
prime[i] = False
p = p + 1
for p in range(2,n + 1):
if prime[p]:
a.append(p)
return(a)
#-----------------------------------------------------------------------#
ONLINE_JUDGE = __debug__
if ONLINE_JUDGE:
#import io,os
#input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
input = sys.stdin.readline
main()
```
| 99,631 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently a new building with a new layout was constructed in Monocarp's hometown. According to this new layout, the building consists of three types of apartments: three-room, five-room, and seven-room apartments. It's also known that each room of each apartment has exactly one window. In other words, a three-room apartment has three windows, a five-room — five windows, and a seven-room — seven windows.
Monocarp went around the building and counted n windows. Now he is wondering, how many apartments of each type the building may have.
Unfortunately, Monocarp only recently has learned to count, so he is asking you to help him to calculate the possible quantities of three-room, five-room, and seven-room apartments in the building that has n windows. If there are multiple answers, you can print any of them.
Here are some examples:
* if Monocarp has counted 30 windows, there could have been 2 three-room apartments, 2 five-room apartments and 2 seven-room apartments, since 2 ⋅ 3 + 2 ⋅ 5 + 2 ⋅ 7 = 30;
* if Monocarp has counted 67 windows, there could have been 7 three-room apartments, 5 five-room apartments and 3 seven-room apartments, since 7 ⋅ 3 + 5 ⋅ 5 + 3 ⋅ 7 = 67;
* if Monocarp has counted 4 windows, he should have mistaken since no building with the aforementioned layout can have 4 windows.
Input
Th first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of windows in the building.
Output
For each test case, if a building with the new layout and the given number of windows just can't exist, print -1.
Otherwise, print three non-negative integers — the possible number of three-room, five-room, and seven-room apartments. If there are multiple answers, print any of them.
Example
Input
4
30
67
4
14
Output
2 2 2
7 5 3
-1
0 0 2
Tags: brute force, constructive algorithms, math
Correct Solution:
```
t = int(input())
for _ in range(t):
#n = list(map(int, input().split()))
n = int(input())
flag = 0
for three in range(0,n):
for five in range(0,n):
if ( n - (three*3 + five*5) )%7 == 0 and ( n - (three*3 + five*5) )/7 >= 0 :
flag = 1
print(three , five , int(( n - (three*3 + five*5) )/7) , sep =' ')
break
if flag == 1:
break;
if flag == 1:
continue
print(-1)
```
| 99,632 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently a new building with a new layout was constructed in Monocarp's hometown. According to this new layout, the building consists of three types of apartments: three-room, five-room, and seven-room apartments. It's also known that each room of each apartment has exactly one window. In other words, a three-room apartment has three windows, a five-room — five windows, and a seven-room — seven windows.
Monocarp went around the building and counted n windows. Now he is wondering, how many apartments of each type the building may have.
Unfortunately, Monocarp only recently has learned to count, so he is asking you to help him to calculate the possible quantities of three-room, five-room, and seven-room apartments in the building that has n windows. If there are multiple answers, you can print any of them.
Here are some examples:
* if Monocarp has counted 30 windows, there could have been 2 three-room apartments, 2 five-room apartments and 2 seven-room apartments, since 2 ⋅ 3 + 2 ⋅ 5 + 2 ⋅ 7 = 30;
* if Monocarp has counted 67 windows, there could have been 7 three-room apartments, 5 five-room apartments and 3 seven-room apartments, since 7 ⋅ 3 + 5 ⋅ 5 + 3 ⋅ 7 = 67;
* if Monocarp has counted 4 windows, he should have mistaken since no building with the aforementioned layout can have 4 windows.
Input
Th first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of windows in the building.
Output
For each test case, if a building with the new layout and the given number of windows just can't exist, print -1.
Otherwise, print three non-negative integers — the possible number of three-room, five-room, and seven-room apartments. If there are multiple answers, print any of them.
Example
Input
4
30
67
4
14
Output
2 2 2
7 5 3
-1
0 0 2
Tags: brute force, constructive algorithms, math
Correct Solution:
```
from collections import defaultdict
test=int(input())
for _ in range(test):
n=int(input())
n1=0
n2=0
n3=0
if(n==1 or n==2 or n==4):
print("-1")
else:
while(n>0):
if(n%3==0):
n1=n1+(n//3)
n=0
elif(n%5==0):
n2=n2+(n//5)
n=0
elif(n%7==0):
n3=n3+(n//7)
n=0
else:
n1+=1
n=n-3
print(n1,n2,n3)
```
| 99,633 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently a new building with a new layout was constructed in Monocarp's hometown. According to this new layout, the building consists of three types of apartments: three-room, five-room, and seven-room apartments. It's also known that each room of each apartment has exactly one window. In other words, a three-room apartment has three windows, a five-room — five windows, and a seven-room — seven windows.
Monocarp went around the building and counted n windows. Now he is wondering, how many apartments of each type the building may have.
Unfortunately, Monocarp only recently has learned to count, so he is asking you to help him to calculate the possible quantities of three-room, five-room, and seven-room apartments in the building that has n windows. If there are multiple answers, you can print any of them.
Here are some examples:
* if Monocarp has counted 30 windows, there could have been 2 three-room apartments, 2 five-room apartments and 2 seven-room apartments, since 2 ⋅ 3 + 2 ⋅ 5 + 2 ⋅ 7 = 30;
* if Monocarp has counted 67 windows, there could have been 7 three-room apartments, 5 five-room apartments and 3 seven-room apartments, since 7 ⋅ 3 + 5 ⋅ 5 + 3 ⋅ 7 = 67;
* if Monocarp has counted 4 windows, he should have mistaken since no building with the aforementioned layout can have 4 windows.
Input
Th first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of windows in the building.
Output
For each test case, if a building with the new layout and the given number of windows just can't exist, print -1.
Otherwise, print three non-negative integers — the possible number of three-room, five-room, and seven-room apartments. If there are multiple answers, print any of them.
Example
Input
4
30
67
4
14
Output
2 2 2
7 5 3
-1
0 0 2
Tags: brute force, constructive algorithms, math
Correct Solution:
```
def search(k):
if k == 1 or k == 2 or k == 4:
return [-1]
if k % 3 == 0:
return k // 3, 0, 0
elif k % 3 == 1:
return (k - 7) // 3, 0, 1
else:
return (k - 5) // 3, 1, 0
for _ in range(int(input())):
n = int(input())
print(*search(n))
```
| 99,634 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently a new building with a new layout was constructed in Monocarp's hometown. According to this new layout, the building consists of three types of apartments: three-room, five-room, and seven-room apartments. It's also known that each room of each apartment has exactly one window. In other words, a three-room apartment has three windows, a five-room — five windows, and a seven-room — seven windows.
Monocarp went around the building and counted n windows. Now he is wondering, how many apartments of each type the building may have.
Unfortunately, Monocarp only recently has learned to count, so he is asking you to help him to calculate the possible quantities of three-room, five-room, and seven-room apartments in the building that has n windows. If there are multiple answers, you can print any of them.
Here are some examples:
* if Monocarp has counted 30 windows, there could have been 2 three-room apartments, 2 five-room apartments and 2 seven-room apartments, since 2 ⋅ 3 + 2 ⋅ 5 + 2 ⋅ 7 = 30;
* if Monocarp has counted 67 windows, there could have been 7 three-room apartments, 5 five-room apartments and 3 seven-room apartments, since 7 ⋅ 3 + 5 ⋅ 5 + 3 ⋅ 7 = 67;
* if Monocarp has counted 4 windows, he should have mistaken since no building with the aforementioned layout can have 4 windows.
Input
Th first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of windows in the building.
Output
For each test case, if a building with the new layout and the given number of windows just can't exist, print -1.
Otherwise, print three non-negative integers — the possible number of three-room, five-room, and seven-room apartments. If there are multiple answers, print any of them.
Example
Input
4
30
67
4
14
Output
2 2 2
7 5 3
-1
0 0 2
Tags: brute force, constructive algorithms, math
Correct Solution:
```
import sys
import math
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()
t = II()
for q in range(t):
n = II()
boo = False
ans = []
for i in range(max(math.ceil(n/3),1)+1):
for j in range(max(math.ceil(n/5),1)+1):
if (n-3*i -5*j)>=0 and (n-3*i-5*j)%7 == 0:
boo = True
ans = [i,j,(n-3*i-5*j)//7]
break
if boo:
break
if ans:
print(*ans)
else:
if n == 0:
print(0,0,0)
else:
print(-1)
```
| 99,635 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently a new building with a new layout was constructed in Monocarp's hometown. According to this new layout, the building consists of three types of apartments: three-room, five-room, and seven-room apartments. It's also known that each room of each apartment has exactly one window. In other words, a three-room apartment has three windows, a five-room — five windows, and a seven-room — seven windows.
Monocarp went around the building and counted n windows. Now he is wondering, how many apartments of each type the building may have.
Unfortunately, Monocarp only recently has learned to count, so he is asking you to help him to calculate the possible quantities of three-room, five-room, and seven-room apartments in the building that has n windows. If there are multiple answers, you can print any of them.
Here are some examples:
* if Monocarp has counted 30 windows, there could have been 2 three-room apartments, 2 five-room apartments and 2 seven-room apartments, since 2 ⋅ 3 + 2 ⋅ 5 + 2 ⋅ 7 = 30;
* if Monocarp has counted 67 windows, there could have been 7 three-room apartments, 5 five-room apartments and 3 seven-room apartments, since 7 ⋅ 3 + 5 ⋅ 5 + 3 ⋅ 7 = 67;
* if Monocarp has counted 4 windows, he should have mistaken since no building with the aforementioned layout can have 4 windows.
Input
Th first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of windows in the building.
Output
For each test case, if a building with the new layout and the given number of windows just can't exist, print -1.
Otherwise, print three non-negative integers — the possible number of three-room, five-room, and seven-room apartments. If there are multiple answers, print any of them.
Example
Input
4
30
67
4
14
Output
2 2 2
7 5 3
-1
0 0 2
Tags: brute force, constructive algorithms, math
Correct Solution:
```
a=[]
for i in range(1000):
a.append([-1])
a[2]=[1,0,0]
a[4]=[0,1,0]
a[6]=[0,0,1]
for i in range(993):
if a[i]!=[-1]:
a[i+3]=[a[i][0]+1]+a[i][1:]
a[i+5]=[a[i][0]]+[a[i][1]+1]+[a[i][2]]
a[i+7]=a[i][:2]+[a[i][2]+1]
for i in range(995):
if a[i]!=[-1]:
a[i+3]=[a[i][0]+1]+a[i][1:]
a[i+5]=[a[i][0]]+[a[i][1]+1]+[a[i][2]]
for i in range(997):
if a[i]!=[-1]:
a[i+3]=[a[i][0]+1]+a[i][1:]
for i in range(int(input())):
print(" ".join(list(map(str,a[int(input())-1]))))
```
| 99,636 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently a new building with a new layout was constructed in Monocarp's hometown. According to this new layout, the building consists of three types of apartments: three-room, five-room, and seven-room apartments. It's also known that each room of each apartment has exactly one window. In other words, a three-room apartment has three windows, a five-room — five windows, and a seven-room — seven windows.
Monocarp went around the building and counted n windows. Now he is wondering, how many apartments of each type the building may have.
Unfortunately, Monocarp only recently has learned to count, so he is asking you to help him to calculate the possible quantities of three-room, five-room, and seven-room apartments in the building that has n windows. If there are multiple answers, you can print any of them.
Here are some examples:
* if Monocarp has counted 30 windows, there could have been 2 three-room apartments, 2 five-room apartments and 2 seven-room apartments, since 2 ⋅ 3 + 2 ⋅ 5 + 2 ⋅ 7 = 30;
* if Monocarp has counted 67 windows, there could have been 7 three-room apartments, 5 five-room apartments and 3 seven-room apartments, since 7 ⋅ 3 + 5 ⋅ 5 + 3 ⋅ 7 = 67;
* if Monocarp has counted 4 windows, he should have mistaken since no building with the aforementioned layout can have 4 windows.
Input
Th first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of windows in the building.
Output
For each test case, if a building with the new layout and the given number of windows just can't exist, print -1.
Otherwise, print three non-negative integers — the possible number of three-room, five-room, and seven-room apartments. If there are multiple answers, print any of them.
Example
Input
4
30
67
4
14
Output
2 2 2
7 5 3
-1
0 0 2
Tags: brute force, constructive algorithms, math
Correct Solution:
```
t = int(input())
for i in range(t):
n = int(input())
ans = [0, 0, 0]
if n == 1 or n == 2 or n == 4:
print(-1)
continue
if n > 20:
ans[1] += (n-20)//5
n -= ans[1]*5
flag = 0
# print(n)
# print("AA", ans)
for i in range(5):
for j in range(5):
for k in range(5):
if 3*i + 5*j + 7*k == n:
flag = 1
ans[0] += i
ans[1] += j
ans[2] += k
break
if flag == 1:
break
if flag == 1:
break
print(*ans)
```
| 99,637 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently a new building with a new layout was constructed in Monocarp's hometown. According to this new layout, the building consists of three types of apartments: three-room, five-room, and seven-room apartments. It's also known that each room of each apartment has exactly one window. In other words, a three-room apartment has three windows, a five-room — five windows, and a seven-room — seven windows.
Monocarp went around the building and counted n windows. Now he is wondering, how many apartments of each type the building may have.
Unfortunately, Monocarp only recently has learned to count, so he is asking you to help him to calculate the possible quantities of three-room, five-room, and seven-room apartments in the building that has n windows. If there are multiple answers, you can print any of them.
Here are some examples:
* if Monocarp has counted 30 windows, there could have been 2 three-room apartments, 2 five-room apartments and 2 seven-room apartments, since 2 ⋅ 3 + 2 ⋅ 5 + 2 ⋅ 7 = 30;
* if Monocarp has counted 67 windows, there could have been 7 three-room apartments, 5 five-room apartments and 3 seven-room apartments, since 7 ⋅ 3 + 5 ⋅ 5 + 3 ⋅ 7 = 67;
* if Monocarp has counted 4 windows, he should have mistaken since no building with the aforementioned layout can have 4 windows.
Input
Th first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of windows in the building.
Output
For each test case, if a building with the new layout and the given number of windows just can't exist, print -1.
Otherwise, print three non-negative integers — the possible number of three-room, five-room, and seven-room apartments. If there are multiple answers, print any of them.
Example
Input
4
30
67
4
14
Output
2 2 2
7 5 3
-1
0 0 2
Submitted Solution:
```
# ------------------- fast io --------------------
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")
# ------------------- fast io --------------------
for j in range(int(input())):
n=int(input())
if n%3==0:
print(n//3,0,0)
elif n%3==1:
if n>=7:
print((n-7)//3,0,1)
else:
print(-1)
else:
if n>=5:
print((n-5)//3,1,0)
else:
print(-1)
```
Yes
| 99,638 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently a new building with a new layout was constructed in Monocarp's hometown. According to this new layout, the building consists of three types of apartments: three-room, five-room, and seven-room apartments. It's also known that each room of each apartment has exactly one window. In other words, a three-room apartment has three windows, a five-room — five windows, and a seven-room — seven windows.
Monocarp went around the building and counted n windows. Now he is wondering, how many apartments of each type the building may have.
Unfortunately, Monocarp only recently has learned to count, so he is asking you to help him to calculate the possible quantities of three-room, five-room, and seven-room apartments in the building that has n windows. If there are multiple answers, you can print any of them.
Here are some examples:
* if Monocarp has counted 30 windows, there could have been 2 three-room apartments, 2 five-room apartments and 2 seven-room apartments, since 2 ⋅ 3 + 2 ⋅ 5 + 2 ⋅ 7 = 30;
* if Monocarp has counted 67 windows, there could have been 7 three-room apartments, 5 five-room apartments and 3 seven-room apartments, since 7 ⋅ 3 + 5 ⋅ 5 + 3 ⋅ 7 = 67;
* if Monocarp has counted 4 windows, he should have mistaken since no building with the aforementioned layout can have 4 windows.
Input
Th first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of windows in the building.
Output
For each test case, if a building with the new layout and the given number of windows just can't exist, print -1.
Otherwise, print three non-negative integers — the possible number of three-room, five-room, and seven-room apartments. If there are multiple answers, print any of them.
Example
Input
4
30
67
4
14
Output
2 2 2
7 5 3
-1
0 0 2
Submitted Solution:
```
# SHRi GANESHA author: Kunal Verma #
import os,sys
from io import BytesIO, IOBase
def main():
for i in range(int(input())):
n=int(input())
if n%7==0:
print(0,0,n//7)
elif n%5==0:
print(0,n//5,0)
elif n%3==0:
print(n//3,0,0)
elif n<10:
if n==8:
print(1,1,0)
else:
print(-1)
else:
p=n%10
if p==1:
print(2,(n-6)//5,0)
elif p==2:
print(0,(n-7)//5,1)
elif p==3:
print(1,(n-3)//5,0)
elif p==4:
print(3,(n-9)//5,0)
elif p==6:
print(2,(n-6)//5,0)
elif p==7:
print(0,(n-7)//5,1)
elif p==8:
print(1,(n-3)//5,0)
else:
print(3,(n-9)//5,0)
#Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == '__main__':
main()
```
Yes
| 99,639 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently a new building with a new layout was constructed in Monocarp's hometown. According to this new layout, the building consists of three types of apartments: three-room, five-room, and seven-room apartments. It's also known that each room of each apartment has exactly one window. In other words, a three-room apartment has three windows, a five-room — five windows, and a seven-room — seven windows.
Monocarp went around the building and counted n windows. Now he is wondering, how many apartments of each type the building may have.
Unfortunately, Monocarp only recently has learned to count, so he is asking you to help him to calculate the possible quantities of three-room, five-room, and seven-room apartments in the building that has n windows. If there are multiple answers, you can print any of them.
Here are some examples:
* if Monocarp has counted 30 windows, there could have been 2 three-room apartments, 2 five-room apartments and 2 seven-room apartments, since 2 ⋅ 3 + 2 ⋅ 5 + 2 ⋅ 7 = 30;
* if Monocarp has counted 67 windows, there could have been 7 three-room apartments, 5 five-room apartments and 3 seven-room apartments, since 7 ⋅ 3 + 5 ⋅ 5 + 3 ⋅ 7 = 67;
* if Monocarp has counted 4 windows, he should have mistaken since no building with the aforementioned layout can have 4 windows.
Input
Th first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of windows in the building.
Output
For each test case, if a building with the new layout and the given number of windows just can't exist, print -1.
Otherwise, print three non-negative integers — the possible number of three-room, five-room, and seven-room apartments. If there are multiple answers, print any of them.
Example
Input
4
30
67
4
14
Output
2 2 2
7 5 3
-1
0 0 2
Submitted Solution:
```
t=int(input())
for i in range(t):
n=int(input())
if(n==1 or n==2 or n==4):
print(-1)
elif(n%3==0):
print(int(n/3),0,0,sep=" ")
elif(n%3 == 1):
print(int((n-7)//3),0,1)
else:
print(int((n-5)//3),1,0)
```
Yes
| 99,640 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently a new building with a new layout was constructed in Monocarp's hometown. According to this new layout, the building consists of three types of apartments: three-room, five-room, and seven-room apartments. It's also known that each room of each apartment has exactly one window. In other words, a three-room apartment has three windows, a five-room — five windows, and a seven-room — seven windows.
Monocarp went around the building and counted n windows. Now he is wondering, how many apartments of each type the building may have.
Unfortunately, Monocarp only recently has learned to count, so he is asking you to help him to calculate the possible quantities of three-room, five-room, and seven-room apartments in the building that has n windows. If there are multiple answers, you can print any of them.
Here are some examples:
* if Monocarp has counted 30 windows, there could have been 2 three-room apartments, 2 five-room apartments and 2 seven-room apartments, since 2 ⋅ 3 + 2 ⋅ 5 + 2 ⋅ 7 = 30;
* if Monocarp has counted 67 windows, there could have been 7 three-room apartments, 5 five-room apartments and 3 seven-room apartments, since 7 ⋅ 3 + 5 ⋅ 5 + 3 ⋅ 7 = 67;
* if Monocarp has counted 4 windows, he should have mistaken since no building with the aforementioned layout can have 4 windows.
Input
Th first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of windows in the building.
Output
For each test case, if a building with the new layout and the given number of windows just can't exist, print -1.
Otherwise, print three non-negative integers — the possible number of three-room, five-room, and seven-room apartments. If there are multiple answers, print any of them.
Example
Input
4
30
67
4
14
Output
2 2 2
7 5 3
-1
0 0 2
Submitted Solution:
```
def f(n):
for i in range(n//3 + 1):
for j in range(n//5 + 1):
for k in range(n//7 + 1):
if (3*i + 5*j + 7*k == n):
return [i, j, k]
return -1
t = int(input())
for _ in range(t):
n = int(input())
x = f(n)
if x==-1:
print(-1)
else:
print(*x)
```
Yes
| 99,641 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently a new building with a new layout was constructed in Monocarp's hometown. According to this new layout, the building consists of three types of apartments: three-room, five-room, and seven-room apartments. It's also known that each room of each apartment has exactly one window. In other words, a three-room apartment has three windows, a five-room — five windows, and a seven-room — seven windows.
Monocarp went around the building and counted n windows. Now he is wondering, how many apartments of each type the building may have.
Unfortunately, Monocarp only recently has learned to count, so he is asking you to help him to calculate the possible quantities of three-room, five-room, and seven-room apartments in the building that has n windows. If there are multiple answers, you can print any of them.
Here are some examples:
* if Monocarp has counted 30 windows, there could have been 2 three-room apartments, 2 five-room apartments and 2 seven-room apartments, since 2 ⋅ 3 + 2 ⋅ 5 + 2 ⋅ 7 = 30;
* if Monocarp has counted 67 windows, there could have been 7 three-room apartments, 5 five-room apartments and 3 seven-room apartments, since 7 ⋅ 3 + 5 ⋅ 5 + 3 ⋅ 7 = 67;
* if Monocarp has counted 4 windows, he should have mistaken since no building with the aforementioned layout can have 4 windows.
Input
Th first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of windows in the building.
Output
For each test case, if a building with the new layout and the given number of windows just can't exist, print -1.
Otherwise, print three non-negative integers — the possible number of three-room, five-room, and seven-room apartments. If there are multiple answers, print any of them.
Example
Input
4
30
67
4
14
Output
2 2 2
7 5 3
-1
0 0 2
Submitted Solution:
```
t=int(input())
for i in range(0, t):
n=int(input())
flag = 0
for x in range(0, n):
if (flag == 1):
break
else:
for y in range(0, n):
if ((n-x*3-y*5)%7 == 0 and ((n-x*3-y*5)/7) >0):
print(x, y, int((n-x*3-y*5)/7))
flag = 1
break
if flag == 0:
print(-1)
```
No
| 99,642 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently a new building with a new layout was constructed in Monocarp's hometown. According to this new layout, the building consists of three types of apartments: three-room, five-room, and seven-room apartments. It's also known that each room of each apartment has exactly one window. In other words, a three-room apartment has three windows, a five-room — five windows, and a seven-room — seven windows.
Monocarp went around the building and counted n windows. Now he is wondering, how many apartments of each type the building may have.
Unfortunately, Monocarp only recently has learned to count, so he is asking you to help him to calculate the possible quantities of three-room, five-room, and seven-room apartments in the building that has n windows. If there are multiple answers, you can print any of them.
Here are some examples:
* if Monocarp has counted 30 windows, there could have been 2 three-room apartments, 2 five-room apartments and 2 seven-room apartments, since 2 ⋅ 3 + 2 ⋅ 5 + 2 ⋅ 7 = 30;
* if Monocarp has counted 67 windows, there could have been 7 three-room apartments, 5 five-room apartments and 3 seven-room apartments, since 7 ⋅ 3 + 5 ⋅ 5 + 3 ⋅ 7 = 67;
* if Monocarp has counted 4 windows, he should have mistaken since no building with the aforementioned layout can have 4 windows.
Input
Th first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of windows in the building.
Output
For each test case, if a building with the new layout and the given number of windows just can't exist, print -1.
Otherwise, print three non-negative integers — the possible number of three-room, five-room, and seven-room apartments. If there are multiple answers, print any of them.
Example
Input
4
30
67
4
14
Output
2 2 2
7 5 3
-1
0 0 2
Submitted Solution:
```
t = int(input())
if t<=1000:
for i in range(t):
n = int(input())
if(n>1000):
print("-1")
continue
found = 0
x = 0
y = 0
z = 0
for a in range(int(n/3)+1):
x = y = z = 0
x = a+1
if x*3 == n:
found = 1
break
for b in range(int(n/5)+1):
y = b+1
if x*3+y*5 == n:
found = 1
break
if y*5==n:
found = 1
x = z = 0
break
for c in range(int(n/7)+1):
z = c+1
if (x*3 + y*5 + z*7) == n:
found = 1
break
if z*3 == n:
found = 1
x = y = 0
break
else:
continue
break
else:
continue
break
if found == 1:
print(str(x) + " " + str(y) + " " + str(z))
else:
print("-1")
```
No
| 99,643 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently a new building with a new layout was constructed in Monocarp's hometown. According to this new layout, the building consists of three types of apartments: three-room, five-room, and seven-room apartments. It's also known that each room of each apartment has exactly one window. In other words, a three-room apartment has three windows, a five-room — five windows, and a seven-room — seven windows.
Monocarp went around the building and counted n windows. Now he is wondering, how many apartments of each type the building may have.
Unfortunately, Monocarp only recently has learned to count, so he is asking you to help him to calculate the possible quantities of three-room, five-room, and seven-room apartments in the building that has n windows. If there are multiple answers, you can print any of them.
Here are some examples:
* if Monocarp has counted 30 windows, there could have been 2 three-room apartments, 2 five-room apartments and 2 seven-room apartments, since 2 ⋅ 3 + 2 ⋅ 5 + 2 ⋅ 7 = 30;
* if Monocarp has counted 67 windows, there could have been 7 three-room apartments, 5 five-room apartments and 3 seven-room apartments, since 7 ⋅ 3 + 5 ⋅ 5 + 3 ⋅ 7 = 67;
* if Monocarp has counted 4 windows, he should have mistaken since no building with the aforementioned layout can have 4 windows.
Input
Th first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of windows in the building.
Output
For each test case, if a building with the new layout and the given number of windows just can't exist, print -1.
Otherwise, print three non-negative integers — the possible number of three-room, five-room, and seven-room apartments. If there are multiple answers, print any of them.
Example
Input
4
30
67
4
14
Output
2 2 2
7 5 3
-1
0 0 2
Submitted Solution:
```
def solve(n):
a1 = n // 7 if n % 7 == 0 else n // 7 + 1
for i in range(a1):
a2 = n - i * 7
b1 = a2 // 5 if a2 % 5 == 0 else a2 // 5 + 1
for j in range(b1):
a3 = a2 - j * 5
if a3 % 3 == 0:
return a3 // 3, j, i
return -1
for _ in range(int(input())):
n = int(input())
ans = solve(n)
if ans == -1:
print(-1)
else:
print(' '.join(map(str, ans)))
```
No
| 99,644 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently a new building with a new layout was constructed in Monocarp's hometown. According to this new layout, the building consists of three types of apartments: three-room, five-room, and seven-room apartments. It's also known that each room of each apartment has exactly one window. In other words, a three-room apartment has three windows, a five-room — five windows, and a seven-room — seven windows.
Monocarp went around the building and counted n windows. Now he is wondering, how many apartments of each type the building may have.
Unfortunately, Monocarp only recently has learned to count, so he is asking you to help him to calculate the possible quantities of three-room, five-room, and seven-room apartments in the building that has n windows. If there are multiple answers, you can print any of them.
Here are some examples:
* if Monocarp has counted 30 windows, there could have been 2 three-room apartments, 2 five-room apartments and 2 seven-room apartments, since 2 ⋅ 3 + 2 ⋅ 5 + 2 ⋅ 7 = 30;
* if Monocarp has counted 67 windows, there could have been 7 three-room apartments, 5 five-room apartments and 3 seven-room apartments, since 7 ⋅ 3 + 5 ⋅ 5 + 3 ⋅ 7 = 67;
* if Monocarp has counted 4 windows, he should have mistaken since no building with the aforementioned layout can have 4 windows.
Input
Th first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases.
The only line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of windows in the building.
Output
For each test case, if a building with the new layout and the given number of windows just can't exist, print -1.
Otherwise, print three non-negative integers — the possible number of three-room, five-room, and seven-room apartments. If there are multiple answers, print any of them.
Example
Input
4
30
67
4
14
Output
2 2 2
7 5 3
-1
0 0 2
Submitted Solution:
```
import sys
for i in range(0,int(sys.stdin.readline())):
wincount=int(sys.stdin.readline())
out="-1"
broken=False
for sevens in range(0,int(wincount/7)):
for fives in range(0,int((wincount-7*sevens)/5)):
threes=int((wincount-7*sevens-5*fives)/3)
if wincount-7*sevens-5*fives-3*threes==0:
broken=True
out=str(threes)+" "+str(fives)+" "+str(sevens)
break
if broken:
break
sys.stdout.write(out)
sys.stdout.write("\n")
```
No
| 99,645 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gildong has a square board consisting of n rows and n columns of square cells, each consisting of a single digit (from 0 to 9). The cell at the j-th column of the i-th row can be represented as (i, j), and the length of the side of each cell is 1. Gildong likes big things, so for each digit d, he wants to find a triangle such that:
* Each vertex of the triangle is in the center of a cell.
* The digit of every vertex of the triangle is d.
* At least one side of the triangle is parallel to one of the sides of the board. You may assume that a side of length 0 is parallel to both sides of the board.
* The area of the triangle is maximized.
Of course, he can't just be happy with finding these triangles as is. Therefore, for each digit d, he's going to change the digit of exactly one cell of the board to d, then find such a triangle. He changes it back to its original digit after he is done with each digit. Find the maximum area of the triangle he can make for each digit.
Note that he can put multiple vertices of the triangle on the same cell, and the triangle can be a [degenerate triangle](https://cutt.ly/NhbjZ2l); i.e. the area of the triangle can be 0. Also, note that he is allowed to change the digit of a cell from d to d.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
The first line of each test case contains one integer n (1 ≤ n ≤ 2000) — the number of rows and columns of the board.
The next n lines of each test case each contain a string of n digits without spaces. The j-th digit of the i-th line is the digit of the cell at (i, j). Each digit is one of the characters from 0 to 9.
It is guaranteed that the sum of n^2 in all test cases doesn't exceed 4 ⋅ 10^6.
Output
For each test case, print one line with 10 integers. The i-th integer is the maximum area of triangle Gildong can make when d = i-1, multiplied by 2.
Example
Input
5
3
000
122
001
2
57
75
4
0123
4012
3401
2340
1
9
8
42987101
98289412
38949562
87599023
92834718
83917348
19823743
38947912
Output
4 4 1 0 0 0 0 0 0 0
0 0 0 0 0 1 0 1 0 0
9 6 9 9 6 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
18 49 49 49 49 15 0 30 42 42
Note
In the first case, for d=0, no matter which cell he chooses to use, the triangle with vertices at (1, 1), (1, 3), and (3, 1) is the biggest triangle with area of \cfrac{2 ⋅ 2}{2} = 2. Since we should print it multiplied by 2, the answer for d=0 is 4.
For d=1, Gildong can change the digit of the cell at (1, 3) into 1, making a triangle with vertices on all three 1's that has an area of 2.
For d=2, Gildong can change the digit of one of the following six cells into 2 to make a triangle with an area of \cfrac{1}{2}: (1, 1), (1, 2), (1, 3), (3, 1), (3, 2), and (3, 3).
For the remaining digits (from 3 to 9), the cell Gildong chooses to change will be the only cell that contains that digit. Therefore the triangle will always be a degenerate triangle with an area of 0.
In the third case, for d=4, note that the triangle will be bigger than the answer if Gildong changes the digit of the cell at (1, 4) and use it along with the cells at (2, 1) and (4, 3), but this is invalid because it violates the condition that at least one side of the triangle must be parallel to one of the sides of the board.
Tags: greedy, implementation
Correct Solution:
```
#!/usr/bin/env python3
import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
n = int(input())
left_most = [n] * 10
right_most = [-1] * 10
up_most = [n] * 10
down_most = [-1] * 10
field = []
rotated = []
ans = [0] * 10
hs = [max(n-1-i, i) for i in range(n)]
for j in range(n):
line = [int(ch) for ch in input().rstrip()]
field.append(line)
for j, line in enumerate(field):
l = [None] * 10
m_base = [0] * 10
for i, item in enumerate(line):
if l[item] != None:
m_base[item] = i - l[item]
else:
l[item] = i
if left_most[item] > i:
left_most[item] = i
if right_most[item] < i:
right_most[item] = i
if up_most[item] > j:
up_most[item] = j
if down_most[item] < j:
down_most[item] = j
for i, item in enumerate(m_base):
ans[i] = max(ans[i], item * hs[j])
for i, line in enumerate(field):
for j, item in enumerate(line):
# Use updown
base1 = max(n - 1 - i, i)
max_h1 = max(right_most[item] - j, j - left_most[item])
# Use leftright
base2 = max(n - 1 - j, j)
max_h2 = max(down_most[item] - i, i - up_most[item])
ans[item] = max(ans[item], base1 * max_h1, base2 * max_h2)
for col in zip(*field):
rotated.append(list(col))
for j, line in enumerate(field):
l = [None] * 10
m_base = [0] * 10
for i, item in enumerate(line):
if l[item] != None:
m_base[item] = i - l[item]
else:
l[item] = i
for i, item in enumerate(m_base):
ans[i] = max(ans[i], item * hs[j])
print(*ans)
```
| 99,646 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gildong has a square board consisting of n rows and n columns of square cells, each consisting of a single digit (from 0 to 9). The cell at the j-th column of the i-th row can be represented as (i, j), and the length of the side of each cell is 1. Gildong likes big things, so for each digit d, he wants to find a triangle such that:
* Each vertex of the triangle is in the center of a cell.
* The digit of every vertex of the triangle is d.
* At least one side of the triangle is parallel to one of the sides of the board. You may assume that a side of length 0 is parallel to both sides of the board.
* The area of the triangle is maximized.
Of course, he can't just be happy with finding these triangles as is. Therefore, for each digit d, he's going to change the digit of exactly one cell of the board to d, then find such a triangle. He changes it back to its original digit after he is done with each digit. Find the maximum area of the triangle he can make for each digit.
Note that he can put multiple vertices of the triangle on the same cell, and the triangle can be a [degenerate triangle](https://cutt.ly/NhbjZ2l); i.e. the area of the triangle can be 0. Also, note that he is allowed to change the digit of a cell from d to d.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
The first line of each test case contains one integer n (1 ≤ n ≤ 2000) — the number of rows and columns of the board.
The next n lines of each test case each contain a string of n digits without spaces. The j-th digit of the i-th line is the digit of the cell at (i, j). Each digit is one of the characters from 0 to 9.
It is guaranteed that the sum of n^2 in all test cases doesn't exceed 4 ⋅ 10^6.
Output
For each test case, print one line with 10 integers. The i-th integer is the maximum area of triangle Gildong can make when d = i-1, multiplied by 2.
Example
Input
5
3
000
122
001
2
57
75
4
0123
4012
3401
2340
1
9
8
42987101
98289412
38949562
87599023
92834718
83917348
19823743
38947912
Output
4 4 1 0 0 0 0 0 0 0
0 0 0 0 0 1 0 1 0 0
9 6 9 9 6 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
18 49 49 49 49 15 0 30 42 42
Note
In the first case, for d=0, no matter which cell he chooses to use, the triangle with vertices at (1, 1), (1, 3), and (3, 1) is the biggest triangle with area of \cfrac{2 ⋅ 2}{2} = 2. Since we should print it multiplied by 2, the answer for d=0 is 4.
For d=1, Gildong can change the digit of the cell at (1, 3) into 1, making a triangle with vertices on all three 1's that has an area of 2.
For d=2, Gildong can change the digit of one of the following six cells into 2 to make a triangle with an area of \cfrac{1}{2}: (1, 1), (1, 2), (1, 3), (3, 1), (3, 2), and (3, 3).
For the remaining digits (from 3 to 9), the cell Gildong chooses to change will be the only cell that contains that digit. Therefore the triangle will always be a degenerate triangle with an area of 0.
In the third case, for d=4, note that the triangle will be bigger than the answer if Gildong changes the digit of the cell at (1, 4) and use it along with the cells at (2, 1) and (4, 3), but this is invalid because it violates the condition that at least one side of the triangle must be parallel to one of the sides of the board.
Tags: greedy, implementation
Correct Solution:
```
t = int(input())
while t:
t -= 1
n = int(input())
a = []
for _ in range(n):
a.append(input())
for d in range(10):
minrow, maxrow, ans = 20000, 0, 0
mincol, maxcol = 20000, 0
for i in range(n):
for j in range(n):
if a[i][j] == str(d):
minrow = min(minrow, i+1)
maxrow = max(maxrow, i+1)
mincol = min(mincol, j+1)
maxcol = max(maxcol, j+1)
# print(maxrow, maxcol, minrow, mincol)
for i in range(n):
for j in range(n):
if a[i][j] == str(d):
hb, hh = max(j, n-j-1), max(maxrow-i-1, i-minrow+1)
vb, vh = max(i, n-i-1), max(maxcol-j-1, j-mincol+1)
# print(hb, hh, vb, vh, i-mincol+1)
ans = max(ans, hb*hh, vb*vh)
print(ans, end=' ')
print()
```
| 99,647 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gildong has a square board consisting of n rows and n columns of square cells, each consisting of a single digit (from 0 to 9). The cell at the j-th column of the i-th row can be represented as (i, j), and the length of the side of each cell is 1. Gildong likes big things, so for each digit d, he wants to find a triangle such that:
* Each vertex of the triangle is in the center of a cell.
* The digit of every vertex of the triangle is d.
* At least one side of the triangle is parallel to one of the sides of the board. You may assume that a side of length 0 is parallel to both sides of the board.
* The area of the triangle is maximized.
Of course, he can't just be happy with finding these triangles as is. Therefore, for each digit d, he's going to change the digit of exactly one cell of the board to d, then find such a triangle. He changes it back to its original digit after he is done with each digit. Find the maximum area of the triangle he can make for each digit.
Note that he can put multiple vertices of the triangle on the same cell, and the triangle can be a [degenerate triangle](https://cutt.ly/NhbjZ2l); i.e. the area of the triangle can be 0. Also, note that he is allowed to change the digit of a cell from d to d.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
The first line of each test case contains one integer n (1 ≤ n ≤ 2000) — the number of rows and columns of the board.
The next n lines of each test case each contain a string of n digits without spaces. The j-th digit of the i-th line is the digit of the cell at (i, j). Each digit is one of the characters from 0 to 9.
It is guaranteed that the sum of n^2 in all test cases doesn't exceed 4 ⋅ 10^6.
Output
For each test case, print one line with 10 integers. The i-th integer is the maximum area of triangle Gildong can make when d = i-1, multiplied by 2.
Example
Input
5
3
000
122
001
2
57
75
4
0123
4012
3401
2340
1
9
8
42987101
98289412
38949562
87599023
92834718
83917348
19823743
38947912
Output
4 4 1 0 0 0 0 0 0 0
0 0 0 0 0 1 0 1 0 0
9 6 9 9 6 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
18 49 49 49 49 15 0 30 42 42
Note
In the first case, for d=0, no matter which cell he chooses to use, the triangle with vertices at (1, 1), (1, 3), and (3, 1) is the biggest triangle with area of \cfrac{2 ⋅ 2}{2} = 2. Since we should print it multiplied by 2, the answer for d=0 is 4.
For d=1, Gildong can change the digit of the cell at (1, 3) into 1, making a triangle with vertices on all three 1's that has an area of 2.
For d=2, Gildong can change the digit of one of the following six cells into 2 to make a triangle with an area of \cfrac{1}{2}: (1, 1), (1, 2), (1, 3), (3, 1), (3, 2), and (3, 3).
For the remaining digits (from 3 to 9), the cell Gildong chooses to change will be the only cell that contains that digit. Therefore the triangle will always be a degenerate triangle with an area of 0.
In the third case, for d=4, note that the triangle will be bigger than the answer if Gildong changes the digit of the cell at (1, 4) and use it along with the cells at (2, 1) and (4, 3), but this is invalid because it violates the condition that at least one side of the triangle must be parallel to one of the sides of the board.
Tags: greedy, implementation
Correct Solution:
```
import sys
input = sys.stdin.readline
for _ in range(int(input())):
n = int(input())
dd = [[] for _ in range(10)]
for i in range(n):
s = input()
for j in range(n):
dd[int(s[j])].append((i,j))
result = [0]*10
for d in range(10):
if len(dd[d])<2:
continue
if len(dd[d])==2:
i1,j1 = dd[d][0]
i2,j2 = dd[d][1]
area = abs(i1-i2)*(max(j1,n-1-j1,j2,n-1-j2))
area = max(area, abs(j1-j2)*max(i1,i2,n-1-i1,n-1-i2))
result[d]=area
else:
imn = n
imx = 0
jmn = n
jmx = 0
for i,j in dd[d]:
if i<imn:
imn=i
if i>imx:
imx = i
if j<jmn:
jmn=j
if j>jmx:
jmx = j
area = 0
for i,j in dd[d]:
l = max(i,n-1-i)
area = max(area,l * max(jmx-j,j-jmn))
l = max(j,n-1-j)
area = max(area,l*max(imx-i,i-imn))
result[d]=area
print(*result)
```
| 99,648 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gildong has a square board consisting of n rows and n columns of square cells, each consisting of a single digit (from 0 to 9). The cell at the j-th column of the i-th row can be represented as (i, j), and the length of the side of each cell is 1. Gildong likes big things, so for each digit d, he wants to find a triangle such that:
* Each vertex of the triangle is in the center of a cell.
* The digit of every vertex of the triangle is d.
* At least one side of the triangle is parallel to one of the sides of the board. You may assume that a side of length 0 is parallel to both sides of the board.
* The area of the triangle is maximized.
Of course, he can't just be happy with finding these triangles as is. Therefore, for each digit d, he's going to change the digit of exactly one cell of the board to d, then find such a triangle. He changes it back to its original digit after he is done with each digit. Find the maximum area of the triangle he can make for each digit.
Note that he can put multiple vertices of the triangle on the same cell, and the triangle can be a [degenerate triangle](https://cutt.ly/NhbjZ2l); i.e. the area of the triangle can be 0. Also, note that he is allowed to change the digit of a cell from d to d.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
The first line of each test case contains one integer n (1 ≤ n ≤ 2000) — the number of rows and columns of the board.
The next n lines of each test case each contain a string of n digits without spaces. The j-th digit of the i-th line is the digit of the cell at (i, j). Each digit is one of the characters from 0 to 9.
It is guaranteed that the sum of n^2 in all test cases doesn't exceed 4 ⋅ 10^6.
Output
For each test case, print one line with 10 integers. The i-th integer is the maximum area of triangle Gildong can make when d = i-1, multiplied by 2.
Example
Input
5
3
000
122
001
2
57
75
4
0123
4012
3401
2340
1
9
8
42987101
98289412
38949562
87599023
92834718
83917348
19823743
38947912
Output
4 4 1 0 0 0 0 0 0 0
0 0 0 0 0 1 0 1 0 0
9 6 9 9 6 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
18 49 49 49 49 15 0 30 42 42
Note
In the first case, for d=0, no matter which cell he chooses to use, the triangle with vertices at (1, 1), (1, 3), and (3, 1) is the biggest triangle with area of \cfrac{2 ⋅ 2}{2} = 2. Since we should print it multiplied by 2, the answer for d=0 is 4.
For d=1, Gildong can change the digit of the cell at (1, 3) into 1, making a triangle with vertices on all three 1's that has an area of 2.
For d=2, Gildong can change the digit of one of the following six cells into 2 to make a triangle with an area of \cfrac{1}{2}: (1, 1), (1, 2), (1, 3), (3, 1), (3, 2), and (3, 3).
For the remaining digits (from 3 to 9), the cell Gildong chooses to change will be the only cell that contains that digit. Therefore the triangle will always be a degenerate triangle with an area of 0.
In the third case, for d=4, note that the triangle will be bigger than the answer if Gildong changes the digit of the cell at (1, 4) and use it along with the cells at (2, 1) and (4, 3), but this is invalid because it violates the condition that at least one side of the triangle must be parallel to one of the sides of the board.
Tags: greedy, implementation
Correct Solution:
```
from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
def main():
t=int(input())
while(t):
t-=1
n=int(input())
r=[]
for i in range(n):
s=input().rstrip()
r.append(s)
tb={str(i):-1 for i in range(10)}
bt={str(i):-1 for i in range(10)}
lr={str(i):-1 for i in range(10)}
rl={str(i):-1 for i in range(10)}
ro={str(j): [ [] for i in range(n) ] for j in range(10)}
co={str(j): [ [] for i in range(n) ] for j in range(10)}
for i in range(n):
for j in range(n):
z=r[i][j]
if(tb[z]==-1):
tb[z]=i
if(bt[r[n-i-1][j]]==-1):
bt[r[n-i-1][j]]=n-i-1
for i in range(n):
for j in range(n):
z=r[j][i]
if(lr[z]==-1):
lr[z]=i
if(rl[r[j][n-i-1]]==-1):
rl[r[j][n-i-1]]=n-i-1
for i in range(n):
for j in range(n):
z=r[i][j]
ro[z][i].append(i)
co[z][j].append(j)
re=[0 for i in range(10)]
for i in range(1):
for j in range(n):
for k in range(n):
z=r[j][k]
try:
c1=abs(j-ro[z][j][0])*(n-1)
except:
c1=0
try:
c2=abs(j-ro[z][j][-1])*(n-1)
except:
c2=0
if(bt[z]!=-1):
c3=max(abs(k-(n-1)),abs(k))*(abs(j-bt[z]))
else:
c3=0
if(tb[z]!=-1):
c4=max(abs(k-0),abs(k-n+1))*(abs(j-tb[z]))
else:
c4=0
if(lr[z]!=-1):
c5=max(abs(j-n+1),abs(j))*abs(k-lr[z])
else:
c5=0
if(rl[z]!=-1):
c6=max(abs(j-0),abs(j-n+1))*abs(k-rl[z])
else:
c6=0
try:
c7=abs(k-co[z][k][0])*(n-1)
except:
c7=0
try:
c8=abs(k-co[z][k][-1])*(n-1)
except:
c8=0
re[int(z)]=max(re[int(z)],c1,c2,c3,c4,c5,c6,c7,c8)
print(*re)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
```
| 99,649 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gildong has a square board consisting of n rows and n columns of square cells, each consisting of a single digit (from 0 to 9). The cell at the j-th column of the i-th row can be represented as (i, j), and the length of the side of each cell is 1. Gildong likes big things, so for each digit d, he wants to find a triangle such that:
* Each vertex of the triangle is in the center of a cell.
* The digit of every vertex of the triangle is d.
* At least one side of the triangle is parallel to one of the sides of the board. You may assume that a side of length 0 is parallel to both sides of the board.
* The area of the triangle is maximized.
Of course, he can't just be happy with finding these triangles as is. Therefore, for each digit d, he's going to change the digit of exactly one cell of the board to d, then find such a triangle. He changes it back to its original digit after he is done with each digit. Find the maximum area of the triangle he can make for each digit.
Note that he can put multiple vertices of the triangle on the same cell, and the triangle can be a [degenerate triangle](https://cutt.ly/NhbjZ2l); i.e. the area of the triangle can be 0. Also, note that he is allowed to change the digit of a cell from d to d.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
The first line of each test case contains one integer n (1 ≤ n ≤ 2000) — the number of rows and columns of the board.
The next n lines of each test case each contain a string of n digits without spaces. The j-th digit of the i-th line is the digit of the cell at (i, j). Each digit is one of the characters from 0 to 9.
It is guaranteed that the sum of n^2 in all test cases doesn't exceed 4 ⋅ 10^6.
Output
For each test case, print one line with 10 integers. The i-th integer is the maximum area of triangle Gildong can make when d = i-1, multiplied by 2.
Example
Input
5
3
000
122
001
2
57
75
4
0123
4012
3401
2340
1
9
8
42987101
98289412
38949562
87599023
92834718
83917348
19823743
38947912
Output
4 4 1 0 0 0 0 0 0 0
0 0 0 0 0 1 0 1 0 0
9 6 9 9 6 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
18 49 49 49 49 15 0 30 42 42
Note
In the first case, for d=0, no matter which cell he chooses to use, the triangle with vertices at (1, 1), (1, 3), and (3, 1) is the biggest triangle with area of \cfrac{2 ⋅ 2}{2} = 2. Since we should print it multiplied by 2, the answer for d=0 is 4.
For d=1, Gildong can change the digit of the cell at (1, 3) into 1, making a triangle with vertices on all three 1's that has an area of 2.
For d=2, Gildong can change the digit of one of the following six cells into 2 to make a triangle with an area of \cfrac{1}{2}: (1, 1), (1, 2), (1, 3), (3, 1), (3, 2), and (3, 3).
For the remaining digits (from 3 to 9), the cell Gildong chooses to change will be the only cell that contains that digit. Therefore the triangle will always be a degenerate triangle with an area of 0.
In the third case, for d=4, note that the triangle will be bigger than the answer if Gildong changes the digit of the cell at (1, 4) and use it along with the cells at (2, 1) and (4, 3), but this is invalid because it violates the condition that at least one side of the triangle must be parallel to one of the sides of the board.
Tags: greedy, implementation
Correct Solution:
```
def findTriangles(n, rows):
minRow = [n-1]*10
maxRow = [0]*10
minCol = [n-1]*10
maxCol = [0]*10
maxArea = [0]*10
for i in range(n):
for j in range(n):
minCol[grid[i][j]] = min(minCol[grid[i][j]], j)
minRow[grid[i][j]] = min(minRow[grid[i][j]], i)
maxCol[grid[i][j]] = max(maxCol[grid[i][j]], j)
maxRow[grid[i][j]] = max(maxRow[grid[i][j]], i)
# print(minRow)
# print(maxRow)
# print(minCol)
# print(maxCol)
for i in range(n):
for j in range(n):
maxArea[grid[i][j]] = max(
maxArea[grid[i][j]],
max(i-0,n-1-i)*max(maxCol[grid[i][j]]-j, j-minCol[grid[i][j]]),
max(j-0,n-1-j)*max(maxRow[grid[i][j]]-i, i-minRow[grid[i][j]])
)
# print(i,j,maxArea)
return maxArea
t = int(input())
for i in range(t):
n = int(input())
grid = []
for j in range(n):
row = input()
grid.append(list(map(int, list(row))))
print(*findTriangles(n,grid))
```
| 99,650 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gildong has a square board consisting of n rows and n columns of square cells, each consisting of a single digit (from 0 to 9). The cell at the j-th column of the i-th row can be represented as (i, j), and the length of the side of each cell is 1. Gildong likes big things, so for each digit d, he wants to find a triangle such that:
* Each vertex of the triangle is in the center of a cell.
* The digit of every vertex of the triangle is d.
* At least one side of the triangle is parallel to one of the sides of the board. You may assume that a side of length 0 is parallel to both sides of the board.
* The area of the triangle is maximized.
Of course, he can't just be happy with finding these triangles as is. Therefore, for each digit d, he's going to change the digit of exactly one cell of the board to d, then find such a triangle. He changes it back to its original digit after he is done with each digit. Find the maximum area of the triangle he can make for each digit.
Note that he can put multiple vertices of the triangle on the same cell, and the triangle can be a [degenerate triangle](https://cutt.ly/NhbjZ2l); i.e. the area of the triangle can be 0. Also, note that he is allowed to change the digit of a cell from d to d.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
The first line of each test case contains one integer n (1 ≤ n ≤ 2000) — the number of rows and columns of the board.
The next n lines of each test case each contain a string of n digits without spaces. The j-th digit of the i-th line is the digit of the cell at (i, j). Each digit is one of the characters from 0 to 9.
It is guaranteed that the sum of n^2 in all test cases doesn't exceed 4 ⋅ 10^6.
Output
For each test case, print one line with 10 integers. The i-th integer is the maximum area of triangle Gildong can make when d = i-1, multiplied by 2.
Example
Input
5
3
000
122
001
2
57
75
4
0123
4012
3401
2340
1
9
8
42987101
98289412
38949562
87599023
92834718
83917348
19823743
38947912
Output
4 4 1 0 0 0 0 0 0 0
0 0 0 0 0 1 0 1 0 0
9 6 9 9 6 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
18 49 49 49 49 15 0 30 42 42
Note
In the first case, for d=0, no matter which cell he chooses to use, the triangle with vertices at (1, 1), (1, 3), and (3, 1) is the biggest triangle with area of \cfrac{2 ⋅ 2}{2} = 2. Since we should print it multiplied by 2, the answer for d=0 is 4.
For d=1, Gildong can change the digit of the cell at (1, 3) into 1, making a triangle with vertices on all three 1's that has an area of 2.
For d=2, Gildong can change the digit of one of the following six cells into 2 to make a triangle with an area of \cfrac{1}{2}: (1, 1), (1, 2), (1, 3), (3, 1), (3, 2), and (3, 3).
For the remaining digits (from 3 to 9), the cell Gildong chooses to change will be the only cell that contains that digit. Therefore the triangle will always be a degenerate triangle with an area of 0.
In the third case, for d=4, note that the triangle will be bigger than the answer if Gildong changes the digit of the cell at (1, 4) and use it along with the cells at (2, 1) and (4, 3), but this is invalid because it violates the condition that at least one side of the triangle must be parallel to one of the sides of the board.
Tags: greedy, implementation
Correct Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
from collections import deque
import threading
#sys.setrecursionlimit(300000)
#threading.stack_size(10**8)
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")
#-------------------------------------------------------------------------
#mod = 9223372036854775807
class SegmentTree:
def __init__(self, data, default=10**10, func=lambda a, b: min(a,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
MOD=10**9+7
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
#-------------------------------------------------------------------------
for _ in range (int(input())):
n=int(input())
a=list()
row=[[[0 for k in range (10)] for i in range (2)]for j in range (n)]
col=[[[0 for k in range (10)] for i in range (2)]for j in range (n)]
for i in range (n):
a.append(input())
arr=[0]*(10)
for j in range (n):
num=ord(a[i][j])-48
if arr[num]==0:
row[i][0][num]=j+1
row[i][1][num]=j+1
arr[num]=1
for j in range (n):
arr=[0]*(10)
for i in range (n):
num=ord(a[i][j])-48
if arr[num]==0:
col[j][0][num]=i+1
col[j][1][num]=i+1
arr[num]=1
res=[0]*(10)
#print(row,col)
for el in range (10):
#print("el",el)
for i in range (n):
d=0
d1=0
for j in range (n):
if row[i][0][el]!=0 and row[j][0][el]!=0:
d=max(d,abs(j-i))
if col[i][0][el]!=0 and col[j][0][el]!=0:
d1=max(d1,abs(j-i))
c1=(row[i][1][el]-row[i][0][el])*(n-i-1)
c2=(row[i][1][el]-row[i][0][el])*(i)
c3=d*max(row[i][0][el]-1,n-row[i][0][el])
c4=d*max(row[i][1][el]-1,n-row[i][1][el])
res[el]=max(res[el],c1,c2,c3,c4)
#print(row[i][0][el],row[i][1][el],d,c1,c2,c3,c4)
c1=(col[i][1][el]-col[i][0][el])*(n-i-1)
c2=(col[i][1][el]-col[i][0][el])*(i)
c3=d1*max(col[i][0][el]-1,n-col[i][0][el])
c4=d1*max(col[i][1][el]-1,n-col[i][1][el])
res[el]=max(res[el],c1,c2,c3,c4)
#print(col[i][0][el],col[i][1][el],d,c1,c2,c3,c4)
print(*res)
```
| 99,651 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gildong has a square board consisting of n rows and n columns of square cells, each consisting of a single digit (from 0 to 9). The cell at the j-th column of the i-th row can be represented as (i, j), and the length of the side of each cell is 1. Gildong likes big things, so for each digit d, he wants to find a triangle such that:
* Each vertex of the triangle is in the center of a cell.
* The digit of every vertex of the triangle is d.
* At least one side of the triangle is parallel to one of the sides of the board. You may assume that a side of length 0 is parallel to both sides of the board.
* The area of the triangle is maximized.
Of course, he can't just be happy with finding these triangles as is. Therefore, for each digit d, he's going to change the digit of exactly one cell of the board to d, then find such a triangle. He changes it back to its original digit after he is done with each digit. Find the maximum area of the triangle he can make for each digit.
Note that he can put multiple vertices of the triangle on the same cell, and the triangle can be a [degenerate triangle](https://cutt.ly/NhbjZ2l); i.e. the area of the triangle can be 0. Also, note that he is allowed to change the digit of a cell from d to d.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
The first line of each test case contains one integer n (1 ≤ n ≤ 2000) — the number of rows and columns of the board.
The next n lines of each test case each contain a string of n digits without spaces. The j-th digit of the i-th line is the digit of the cell at (i, j). Each digit is one of the characters from 0 to 9.
It is guaranteed that the sum of n^2 in all test cases doesn't exceed 4 ⋅ 10^6.
Output
For each test case, print one line with 10 integers. The i-th integer is the maximum area of triangle Gildong can make when d = i-1, multiplied by 2.
Example
Input
5
3
000
122
001
2
57
75
4
0123
4012
3401
2340
1
9
8
42987101
98289412
38949562
87599023
92834718
83917348
19823743
38947912
Output
4 4 1 0 0 0 0 0 0 0
0 0 0 0 0 1 0 1 0 0
9 6 9 9 6 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
18 49 49 49 49 15 0 30 42 42
Note
In the first case, for d=0, no matter which cell he chooses to use, the triangle with vertices at (1, 1), (1, 3), and (3, 1) is the biggest triangle with area of \cfrac{2 ⋅ 2}{2} = 2. Since we should print it multiplied by 2, the answer for d=0 is 4.
For d=1, Gildong can change the digit of the cell at (1, 3) into 1, making a triangle with vertices on all three 1's that has an area of 2.
For d=2, Gildong can change the digit of one of the following six cells into 2 to make a triangle with an area of \cfrac{1}{2}: (1, 1), (1, 2), (1, 3), (3, 1), (3, 2), and (3, 3).
For the remaining digits (from 3 to 9), the cell Gildong chooses to change will be the only cell that contains that digit. Therefore the triangle will always be a degenerate triangle with an area of 0.
In the third case, for d=4, note that the triangle will be bigger than the answer if Gildong changes the digit of the cell at (1, 4) and use it along with the cells at (2, 1) and (4, 3), but this is invalid because it violates the condition that at least one side of the triangle must be parallel to one of the sides of the board.
Tags: greedy, implementation
Correct Solution:
```
#!/usr/bin/env python3
import io
import os
import sys
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def printd(*args, **kwargs):
#print(*args, **kwargs, file=sys.stderr)
#print(*args, **kwargs)
pass
def get_str():
return input().decode().strip()
def rint():
return map(int, input().split())
def oint():
return int(input())
t = oint()
for _ in range(t):
n = oint()
mat = [[] for _ in range(n)]
for i in range(n):
mat[i] = list(map(int, get_str()))
printd(mat)
top = [2001] * 10
bot = [-1] * 10
left = [2001] * 10
right = [-1] * 10
for r in range(n):
for c in range(n):
d = mat[r][c]
if top[d] > r:
top[d] = r
if bot[d] < r:
bot[d] = r
if left[d] > c:
left[d] = c
if right[d] < c:
right[d] = c
ans = [0]*10
for r in range(n):
for c in range(n):
d = mat[r][c]
ans[d] = max(ans[d], max(c-left[d], right[d]-c) * max(r, n-1-r))
ans[d] = max(ans[d], max(r- top[d], bot[d]-r) * max(c, n-1-c))
print(*ans)
```
| 99,652 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gildong has a square board consisting of n rows and n columns of square cells, each consisting of a single digit (from 0 to 9). The cell at the j-th column of the i-th row can be represented as (i, j), and the length of the side of each cell is 1. Gildong likes big things, so for each digit d, he wants to find a triangle such that:
* Each vertex of the triangle is in the center of a cell.
* The digit of every vertex of the triangle is d.
* At least one side of the triangle is parallel to one of the sides of the board. You may assume that a side of length 0 is parallel to both sides of the board.
* The area of the triangle is maximized.
Of course, he can't just be happy with finding these triangles as is. Therefore, for each digit d, he's going to change the digit of exactly one cell of the board to d, then find such a triangle. He changes it back to its original digit after he is done with each digit. Find the maximum area of the triangle he can make for each digit.
Note that he can put multiple vertices of the triangle on the same cell, and the triangle can be a [degenerate triangle](https://cutt.ly/NhbjZ2l); i.e. the area of the triangle can be 0. Also, note that he is allowed to change the digit of a cell from d to d.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
The first line of each test case contains one integer n (1 ≤ n ≤ 2000) — the number of rows and columns of the board.
The next n lines of each test case each contain a string of n digits without spaces. The j-th digit of the i-th line is the digit of the cell at (i, j). Each digit is one of the characters from 0 to 9.
It is guaranteed that the sum of n^2 in all test cases doesn't exceed 4 ⋅ 10^6.
Output
For each test case, print one line with 10 integers. The i-th integer is the maximum area of triangle Gildong can make when d = i-1, multiplied by 2.
Example
Input
5
3
000
122
001
2
57
75
4
0123
4012
3401
2340
1
9
8
42987101
98289412
38949562
87599023
92834718
83917348
19823743
38947912
Output
4 4 1 0 0 0 0 0 0 0
0 0 0 0 0 1 0 1 0 0
9 6 9 9 6 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
18 49 49 49 49 15 0 30 42 42
Note
In the first case, for d=0, no matter which cell he chooses to use, the triangle with vertices at (1, 1), (1, 3), and (3, 1) is the biggest triangle with area of \cfrac{2 ⋅ 2}{2} = 2. Since we should print it multiplied by 2, the answer for d=0 is 4.
For d=1, Gildong can change the digit of the cell at (1, 3) into 1, making a triangle with vertices on all three 1's that has an area of 2.
For d=2, Gildong can change the digit of one of the following six cells into 2 to make a triangle with an area of \cfrac{1}{2}: (1, 1), (1, 2), (1, 3), (3, 1), (3, 2), and (3, 3).
For the remaining digits (from 3 to 9), the cell Gildong chooses to change will be the only cell that contains that digit. Therefore the triangle will always be a degenerate triangle with an area of 0.
In the third case, for d=4, note that the triangle will be bigger than the answer if Gildong changes the digit of the cell at (1, 4) and use it along with the cells at (2, 1) and (4, 3), but this is invalid because it violates the condition that at least one side of the triangle must be parallel to one of the sides of the board.
Tags: greedy, implementation
Correct Solution:
```
t = int(input())
def calculate(d, last_rows, last_cols, a):
ans = 0
# print("-" * 1000)
# print(d)
for i in range(0, len(a)):
x = []
# print("-" * 100)
# print(i)
for j in range(0, len(a)):
if a[i][j] == d:
x.append(j)
# print(x)
if x:
ans = max(abs(last_rows[d][0] - i) * max(abs(last_rows[d][1] - (len(a) - 1)), last_rows[d][1]), ans)
ans = max(abs(first_rows[d][0] - i) * max(abs(first_rows[d][1] - (len(a) - 1)), first_rows[d][1]), ans)
if len(x) == 1:
ans = max(max(abs(x[0] - (len(a) - 1)), x[0]) * abs(last_rows[d][0] - i), ans)
ans = max(max(abs(x[0] - (len(a) - 1)), x[0]) * abs(first_rows[d][0] - i), ans)
elif len(x) > 1:
ans = max(max(abs(x[0] - (len(a) - 1)), x[0]) * abs(last_rows[d][0] - i), ans)
ans = max(max(abs(x[0] - (len(a) - 1)), x[0]) * abs(first_rows[d][0] - i), ans)
ans = max(abs(x[0] - x[-1]) * max(abs(n - 1 - i), i), ans)
ans = max(max(abs(x[0] - (len(a) - 1)), abs(x[0])) * abs(last_rows[d][0] - i), ans)
ans = max(max(abs(x[-1] - (len(a) - 1)), abs(x[-1])) * abs(last_rows[d][0] - i), ans)
ans = max(max(abs(x[0] - (len(a) - 1)), abs(x[0])) * abs(first_rows[d][0] - i), ans)
ans = max(max(abs(x[-1] - (len(a) - 1)), abs(x[-1])) * abs(first_rows[d][0] - i), ans)
# print(ans)
for j in range(0, len(a)):
x = []
for i in range(0, len(a)):
if a[i][j] == d:
x.append(i)
if x:
ans = max(abs(last_cols[d][0] - j) * max(abs(last_cols[d][1] - (len(a) - 1)), last_cols[d][1]), ans)
ans = max(abs(first_cols[d][0] - j) * max(abs(first_cols[d][1] - (len(a) - 1)), first_cols[d][1]), ans)
if len(x) == 1:
ans = max(max(abs(x[0] - (len(a) - 1)), x[0]) * abs(last_cols[d][0] - j), ans)
ans = max(max(abs(x[0] - (len(a) - 1)), x[0]) * abs(first_cols[d][0] - j), ans)
elif len(x) > 1:
ans = max(max(abs(x[0] - (len(a) - 1)), x[0]) * abs(last_cols[d][0] - j), ans)
ans = max(max(abs(x[0] - (len(a) - 1)), x[0]) * abs(first_cols[d][0] - j), ans)
ans = max(abs(x[0] - x[-1]) * max(abs(n - 1 - j), j), ans)
ans = max(max(abs(x[0] - (len(a) - 1)), abs(x[0])) * abs(last_cols[d][0] - j), ans)
ans = max(max(abs(x[-1] - (len(a) - 1)), abs(x[-1])) * abs(last_cols[d][0] - j), ans)
ans = max(max(abs(x[0] - (len(a) - 1)), abs(x[0])) * abs(first_cols[d][0] - j), ans)
ans = max(max(abs(x[-1] - (len(a) - 1)), abs(x[-1])) * abs(first_cols[d][0] - j), ans)
return ans
for _ in range(t):
n = int(input())
a = []
for i in range(0, n):
a.append(list(map(int, list(input()))))
last_cols = [(0, 0) for _ in range(10)]
last_rows = [(0, 0) for _ in range(10)]
first_cols = [(n, n) for _ in range(10)]
first_rows = [(n, n) for _ in range(10)]
for i in range(0, len(a)):
for j in range(0, len(a)):
if last_cols[a[i][j]][0] < j:
last_cols[a[i][j]] = (j, i)
if last_rows[a[i][j]][0] < i:
last_rows[a[i][j]] = (i, j)
if first_cols[a[i][j]][0] > j:
first_cols[a[i][j]] = (j, i)
if first_rows[a[i][j]][0] > i:
first_rows[a[i][j]] = (i, j)
# print(last_cols, last_rows)
values = [0 for _ in range(10)]
for i in range(0, 10):
values[i] = calculate(i, last_rows, last_cols, a)
print(*values)
```
| 99,653 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gildong has a square board consisting of n rows and n columns of square cells, each consisting of a single digit (from 0 to 9). The cell at the j-th column of the i-th row can be represented as (i, j), and the length of the side of each cell is 1. Gildong likes big things, so for each digit d, he wants to find a triangle such that:
* Each vertex of the triangle is in the center of a cell.
* The digit of every vertex of the triangle is d.
* At least one side of the triangle is parallel to one of the sides of the board. You may assume that a side of length 0 is parallel to both sides of the board.
* The area of the triangle is maximized.
Of course, he can't just be happy with finding these triangles as is. Therefore, for each digit d, he's going to change the digit of exactly one cell of the board to d, then find such a triangle. He changes it back to its original digit after he is done with each digit. Find the maximum area of the triangle he can make for each digit.
Note that he can put multiple vertices of the triangle on the same cell, and the triangle can be a [degenerate triangle](https://cutt.ly/NhbjZ2l); i.e. the area of the triangle can be 0. Also, note that he is allowed to change the digit of a cell from d to d.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
The first line of each test case contains one integer n (1 ≤ n ≤ 2000) — the number of rows and columns of the board.
The next n lines of each test case each contain a string of n digits without spaces. The j-th digit of the i-th line is the digit of the cell at (i, j). Each digit is one of the characters from 0 to 9.
It is guaranteed that the sum of n^2 in all test cases doesn't exceed 4 ⋅ 10^6.
Output
For each test case, print one line with 10 integers. The i-th integer is the maximum area of triangle Gildong can make when d = i-1, multiplied by 2.
Example
Input
5
3
000
122
001
2
57
75
4
0123
4012
3401
2340
1
9
8
42987101
98289412
38949562
87599023
92834718
83917348
19823743
38947912
Output
4 4 1 0 0 0 0 0 0 0
0 0 0 0 0 1 0 1 0 0
9 6 9 9 6 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
18 49 49 49 49 15 0 30 42 42
Note
In the first case, for d=0, no matter which cell he chooses to use, the triangle with vertices at (1, 1), (1, 3), and (3, 1) is the biggest triangle with area of \cfrac{2 ⋅ 2}{2} = 2. Since we should print it multiplied by 2, the answer for d=0 is 4.
For d=1, Gildong can change the digit of the cell at (1, 3) into 1, making a triangle with vertices on all three 1's that has an area of 2.
For d=2, Gildong can change the digit of one of the following six cells into 2 to make a triangle with an area of \cfrac{1}{2}: (1, 1), (1, 2), (1, 3), (3, 1), (3, 2), and (3, 3).
For the remaining digits (from 3 to 9), the cell Gildong chooses to change will be the only cell that contains that digit. Therefore the triangle will always be a degenerate triangle with an area of 0.
In the third case, for d=4, note that the triangle will be bigger than the answer if Gildong changes the digit of the cell at (1, 4) and use it along with the cells at (2, 1) and (4, 3), but this is invalid because it violates the condition that at least one side of the triangle must be parallel to one of the sides of the board.
Submitted Solution:
```
def func(a, n):
mxr = [-1]*10
mxc = [-1]*10
mnr = [n+25]*10
mnc = [n+25]*10
ans = [0]*10
for i in range(n):
for j in range(n):
x = a[i][j]
mxr[x] = max(mxr[x], i)
mxc[x] = max(mxc[x], j)
mnc[x] = min(mnc[x], j)
mnr[x] = min(mnr[x], i)
for i in range(n):
for j in range(n):
x = a[i][j]
ans[x] = max(ans[x], max(n-i-1, i) * max(j - mnc[x], mxc[x] - j))
ans[x] = max(ans[x], max(n - j - 1, j) * max(i - mnr[x], mxr[x] - i))
return ans
for _ in range(int(input())):
# n, m = [int(j) for j in input().split()]
n = int(input())
# a = [int(j) for j in input().split()]
# b = [int(j) for j in input().split()]
a = [[] for i in range(n)]
for i in range(n):
s = input()
for j in range(n):
a[i].append(int(s[j]))
# print(a)
print(*func(a, n))
```
Yes
| 99,654 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gildong has a square board consisting of n rows and n columns of square cells, each consisting of a single digit (from 0 to 9). The cell at the j-th column of the i-th row can be represented as (i, j), and the length of the side of each cell is 1. Gildong likes big things, so for each digit d, he wants to find a triangle such that:
* Each vertex of the triangle is in the center of a cell.
* The digit of every vertex of the triangle is d.
* At least one side of the triangle is parallel to one of the sides of the board. You may assume that a side of length 0 is parallel to both sides of the board.
* The area of the triangle is maximized.
Of course, he can't just be happy with finding these triangles as is. Therefore, for each digit d, he's going to change the digit of exactly one cell of the board to d, then find such a triangle. He changes it back to its original digit after he is done with each digit. Find the maximum area of the triangle he can make for each digit.
Note that he can put multiple vertices of the triangle on the same cell, and the triangle can be a [degenerate triangle](https://cutt.ly/NhbjZ2l); i.e. the area of the triangle can be 0. Also, note that he is allowed to change the digit of a cell from d to d.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
The first line of each test case contains one integer n (1 ≤ n ≤ 2000) — the number of rows and columns of the board.
The next n lines of each test case each contain a string of n digits without spaces. The j-th digit of the i-th line is the digit of the cell at (i, j). Each digit is one of the characters from 0 to 9.
It is guaranteed that the sum of n^2 in all test cases doesn't exceed 4 ⋅ 10^6.
Output
For each test case, print one line with 10 integers. The i-th integer is the maximum area of triangle Gildong can make when d = i-1, multiplied by 2.
Example
Input
5
3
000
122
001
2
57
75
4
0123
4012
3401
2340
1
9
8
42987101
98289412
38949562
87599023
92834718
83917348
19823743
38947912
Output
4 4 1 0 0 0 0 0 0 0
0 0 0 0 0 1 0 1 0 0
9 6 9 9 6 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
18 49 49 49 49 15 0 30 42 42
Note
In the first case, for d=0, no matter which cell he chooses to use, the triangle with vertices at (1, 1), (1, 3), and (3, 1) is the biggest triangle with area of \cfrac{2 ⋅ 2}{2} = 2. Since we should print it multiplied by 2, the answer for d=0 is 4.
For d=1, Gildong can change the digit of the cell at (1, 3) into 1, making a triangle with vertices on all three 1's that has an area of 2.
For d=2, Gildong can change the digit of one of the following six cells into 2 to make a triangle with an area of \cfrac{1}{2}: (1, 1), (1, 2), (1, 3), (3, 1), (3, 2), and (3, 3).
For the remaining digits (from 3 to 9), the cell Gildong chooses to change will be the only cell that contains that digit. Therefore the triangle will always be a degenerate triangle with an area of 0.
In the third case, for d=4, note that the triangle will be bigger than the answer if Gildong changes the digit of the cell at (1, 4) and use it along with the cells at (2, 1) and (4, 3), but this is invalid because it violates the condition that at least one side of the triangle must be parallel to one of the sides of the board.
Submitted Solution:
```
import sys
def choose_top(ddk, n):
# choose top max bottom length -- or choose new top
lns = [len(ddk[i]) for i in range(n)]
if sum(lns) < 2:
return 0
top = -1
rt = 0
for i in range(n):
if lns[i]:
top = i
break
for i in range(top + 1, n):
if lns[i]:
rt = max(rt, (i - top) * (n - 1 - ddk[i][0]), (i - top) * (ddk[i][-1]))
for i in range(n-1, -1, -1):
if lns[i] > 1:
rt = max(rt, i * (ddk[i][-1] - ddk[i][0]))
return rt
def main(d, n):
# print(n, d )
dd = [[[] for j in range(n)] for i in range(10)]
for i in range(n):
for j in range(n):
# print(dd, i, j, d[i][j])
dd[d[i][j]][i].append(j)
ret = []
for dig in range(10):
ddk = dd[dig]
ans_ = choose_top(ddk, n)
ddk.reverse()
ans_ = max(ans_, choose_top(ddk, n))
ret.append(ans_)
return ret
for tt in range(int(sys.stdin.readline())):
n = int(sys.stdin.readline())
d = [[int(i) for i in sys.stdin.readline().strip()] for _ in range(n)]
if n == 1:
sys.stdout.write(' '.join('0' for i in range(10)) + '\n')
continue
# elif n == 2:
# cnts = [0] * 10
# for i in range(2):
# for j in range(2):
# cnts[d[i][j]] += 1
# sys.stdout.write(' '.join(('1' if cnts[i] > 1 else '0') for i in range(10)) + '\n')
# continue
r1 = main(d, n)
r2 = main([[d[j][i] for j in range(n)] for i in range(n)], n)
sys.stdout.write(' '.join(str(max(r1[i], r2[i])) for i in range(10)) + '\n')
```
Yes
| 99,655 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gildong has a square board consisting of n rows and n columns of square cells, each consisting of a single digit (from 0 to 9). The cell at the j-th column of the i-th row can be represented as (i, j), and the length of the side of each cell is 1. Gildong likes big things, so for each digit d, he wants to find a triangle such that:
* Each vertex of the triangle is in the center of a cell.
* The digit of every vertex of the triangle is d.
* At least one side of the triangle is parallel to one of the sides of the board. You may assume that a side of length 0 is parallel to both sides of the board.
* The area of the triangle is maximized.
Of course, he can't just be happy with finding these triangles as is. Therefore, for each digit d, he's going to change the digit of exactly one cell of the board to d, then find such a triangle. He changes it back to its original digit after he is done with each digit. Find the maximum area of the triangle he can make for each digit.
Note that he can put multiple vertices of the triangle on the same cell, and the triangle can be a [degenerate triangle](https://cutt.ly/NhbjZ2l); i.e. the area of the triangle can be 0. Also, note that he is allowed to change the digit of a cell from d to d.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
The first line of each test case contains one integer n (1 ≤ n ≤ 2000) — the number of rows and columns of the board.
The next n lines of each test case each contain a string of n digits without spaces. The j-th digit of the i-th line is the digit of the cell at (i, j). Each digit is one of the characters from 0 to 9.
It is guaranteed that the sum of n^2 in all test cases doesn't exceed 4 ⋅ 10^6.
Output
For each test case, print one line with 10 integers. The i-th integer is the maximum area of triangle Gildong can make when d = i-1, multiplied by 2.
Example
Input
5
3
000
122
001
2
57
75
4
0123
4012
3401
2340
1
9
8
42987101
98289412
38949562
87599023
92834718
83917348
19823743
38947912
Output
4 4 1 0 0 0 0 0 0 0
0 0 0 0 0 1 0 1 0 0
9 6 9 9 6 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
18 49 49 49 49 15 0 30 42 42
Note
In the first case, for d=0, no matter which cell he chooses to use, the triangle with vertices at (1, 1), (1, 3), and (3, 1) is the biggest triangle with area of \cfrac{2 ⋅ 2}{2} = 2. Since we should print it multiplied by 2, the answer for d=0 is 4.
For d=1, Gildong can change the digit of the cell at (1, 3) into 1, making a triangle with vertices on all three 1's that has an area of 2.
For d=2, Gildong can change the digit of one of the following six cells into 2 to make a triangle with an area of \cfrac{1}{2}: (1, 1), (1, 2), (1, 3), (3, 1), (3, 2), and (3, 3).
For the remaining digits (from 3 to 9), the cell Gildong chooses to change will be the only cell that contains that digit. Therefore the triangle will always be a degenerate triangle with an area of 0.
In the third case, for d=4, note that the triangle will be bigger than the answer if Gildong changes the digit of the cell at (1, 4) and use it along with the cells at (2, 1) and (4, 3), but this is invalid because it violates the condition that at least one side of the triangle must be parallel to one of the sides of the board.
Submitted Solution:
```
from sys import stdin
input=stdin.readline
for t in range(int(input().rstrip('\n'))):
n=int(input().rstrip('\n'))
l=[]
for j in range(n):
l.append(list(map(int,input().rstrip('\n'))))
r=[[] for i in range(10)]
lm,rm,tm,bm=[n-1]*10,[0]*10,[n-1]*10,[0]*10
for i in range(n):
for j in range(n):
lm[l[i][j]]=min(lm[l[i][j]],j)
rm[l[i][j]]=max(rm[l[i][j]],j)
tm[l[i][j]]=min(tm[l[i][j]],i)
bm[l[i][j]]=max(bm[l[i][j]],i)
r[l[i][j]].append([i,j])
ans=[0]*10
for i in range(10):
for j in r[i]:
ans[i]=max(ans[i],max(j[1],n-1-j[1])*max(abs(j[0]-tm[i]),abs(j[0]-bm[i])),max(j[0],n-1-j[0])*max(abs(j[1]-lm[i]),abs(j[1]-rm[i])))
print(*ans)
```
Yes
| 99,656 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gildong has a square board consisting of n rows and n columns of square cells, each consisting of a single digit (from 0 to 9). The cell at the j-th column of the i-th row can be represented as (i, j), and the length of the side of each cell is 1. Gildong likes big things, so for each digit d, he wants to find a triangle such that:
* Each vertex of the triangle is in the center of a cell.
* The digit of every vertex of the triangle is d.
* At least one side of the triangle is parallel to one of the sides of the board. You may assume that a side of length 0 is parallel to both sides of the board.
* The area of the triangle is maximized.
Of course, he can't just be happy with finding these triangles as is. Therefore, for each digit d, he's going to change the digit of exactly one cell of the board to d, then find such a triangle. He changes it back to its original digit after he is done with each digit. Find the maximum area of the triangle he can make for each digit.
Note that he can put multiple vertices of the triangle on the same cell, and the triangle can be a [degenerate triangle](https://cutt.ly/NhbjZ2l); i.e. the area of the triangle can be 0. Also, note that he is allowed to change the digit of a cell from d to d.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
The first line of each test case contains one integer n (1 ≤ n ≤ 2000) — the number of rows and columns of the board.
The next n lines of each test case each contain a string of n digits without spaces. The j-th digit of the i-th line is the digit of the cell at (i, j). Each digit is one of the characters from 0 to 9.
It is guaranteed that the sum of n^2 in all test cases doesn't exceed 4 ⋅ 10^6.
Output
For each test case, print one line with 10 integers. The i-th integer is the maximum area of triangle Gildong can make when d = i-1, multiplied by 2.
Example
Input
5
3
000
122
001
2
57
75
4
0123
4012
3401
2340
1
9
8
42987101
98289412
38949562
87599023
92834718
83917348
19823743
38947912
Output
4 4 1 0 0 0 0 0 0 0
0 0 0 0 0 1 0 1 0 0
9 6 9 9 6 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
18 49 49 49 49 15 0 30 42 42
Note
In the first case, for d=0, no matter which cell he chooses to use, the triangle with vertices at (1, 1), (1, 3), and (3, 1) is the biggest triangle with area of \cfrac{2 ⋅ 2}{2} = 2. Since we should print it multiplied by 2, the answer for d=0 is 4.
For d=1, Gildong can change the digit of the cell at (1, 3) into 1, making a triangle with vertices on all three 1's that has an area of 2.
For d=2, Gildong can change the digit of one of the following six cells into 2 to make a triangle with an area of \cfrac{1}{2}: (1, 1), (1, 2), (1, 3), (3, 1), (3, 2), and (3, 3).
For the remaining digits (from 3 to 9), the cell Gildong chooses to change will be the only cell that contains that digit. Therefore the triangle will always be a degenerate triangle with an area of 0.
In the third case, for d=4, note that the triangle will be bigger than the answer if Gildong changes the digit of the cell at (1, 4) and use it along with the cells at (2, 1) and (4, 3), but this is invalid because it violates the condition that at least one side of the triangle must be parallel to one of the sides of the board.
Submitted Solution:
```
import sys
from array import array # noqa: F401
import typing as Tp # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
def output(*args):
sys.stdout.buffer.write(
('\n'.join(map(str, args)) + '\n').encode('utf-8')
)
def main():
t = int(input())
ans_a = [''] * t
for ti in range(t):
n = int(input())
d_pos: Tp.List[Tp.List[Tp.Tuple[int]]] = [[(-1, -1) for _ in range(4)] for _ in range(10)]
ans_d = [0] * 10
matrix = [list(map(int, input().rstrip())) for _ in range(n)]
for y in range(n):
for x, d in enumerate(matrix[y]):
if d_pos[d][0][0] == -1 or d_pos[d][0][0] > y:
d_pos[d][0] = (y, x)
if d_pos[d][1][0] == -1 or d_pos[d][1][1] > x:
d_pos[d][1] = (y, x)
if d_pos[d][2][0] == -1 or d_pos[d][2][0] <= y:
d_pos[d][2] = (y, x)
if d_pos[d][3][0] == -1 or +d_pos[d][3][1] <= x:
d_pos[d][3] = (y, x)
for y in range(n):
for x, d in enumerate(matrix[y]):
for ty, tx in d_pos[d]:
if ty != -1:
ans_d[d] = max(
ans_d[d],
max(y, n - y - 1, ty, n - ty - 1) * abs(x - tx),
abs(y - ty) * max(x, n - x - 1, tx, n - tx - 1)
)
ans_a[ti] = ' '.join(map(str, ans_d))
output('\n'.join(map(str, ans_a)))
if __name__ == '__main__':
main()
```
Yes
| 99,657 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gildong has a square board consisting of n rows and n columns of square cells, each consisting of a single digit (from 0 to 9). The cell at the j-th column of the i-th row can be represented as (i, j), and the length of the side of each cell is 1. Gildong likes big things, so for each digit d, he wants to find a triangle such that:
* Each vertex of the triangle is in the center of a cell.
* The digit of every vertex of the triangle is d.
* At least one side of the triangle is parallel to one of the sides of the board. You may assume that a side of length 0 is parallel to both sides of the board.
* The area of the triangle is maximized.
Of course, he can't just be happy with finding these triangles as is. Therefore, for each digit d, he's going to change the digit of exactly one cell of the board to d, then find such a triangle. He changes it back to its original digit after he is done with each digit. Find the maximum area of the triangle he can make for each digit.
Note that he can put multiple vertices of the triangle on the same cell, and the triangle can be a [degenerate triangle](https://cutt.ly/NhbjZ2l); i.e. the area of the triangle can be 0. Also, note that he is allowed to change the digit of a cell from d to d.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
The first line of each test case contains one integer n (1 ≤ n ≤ 2000) — the number of rows and columns of the board.
The next n lines of each test case each contain a string of n digits without spaces. The j-th digit of the i-th line is the digit of the cell at (i, j). Each digit is one of the characters from 0 to 9.
It is guaranteed that the sum of n^2 in all test cases doesn't exceed 4 ⋅ 10^6.
Output
For each test case, print one line with 10 integers. The i-th integer is the maximum area of triangle Gildong can make when d = i-1, multiplied by 2.
Example
Input
5
3
000
122
001
2
57
75
4
0123
4012
3401
2340
1
9
8
42987101
98289412
38949562
87599023
92834718
83917348
19823743
38947912
Output
4 4 1 0 0 0 0 0 0 0
0 0 0 0 0 1 0 1 0 0
9 6 9 9 6 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
18 49 49 49 49 15 0 30 42 42
Note
In the first case, for d=0, no matter which cell he chooses to use, the triangle with vertices at (1, 1), (1, 3), and (3, 1) is the biggest triangle with area of \cfrac{2 ⋅ 2}{2} = 2. Since we should print it multiplied by 2, the answer for d=0 is 4.
For d=1, Gildong can change the digit of the cell at (1, 3) into 1, making a triangle with vertices on all three 1's that has an area of 2.
For d=2, Gildong can change the digit of one of the following six cells into 2 to make a triangle with an area of \cfrac{1}{2}: (1, 1), (1, 2), (1, 3), (3, 1), (3, 2), and (3, 3).
For the remaining digits (from 3 to 9), the cell Gildong chooses to change will be the only cell that contains that digit. Therefore the triangle will always be a degenerate triangle with an area of 0.
In the third case, for d=4, note that the triangle will be bigger than the answer if Gildong changes the digit of the cell at (1, 4) and use it along with the cells at (2, 1) and (4, 3), but this is invalid because it violates the condition that at least one side of the triangle must be parallel to one of the sides of the board.
Submitted Solution:
```
"""
usefull snippets:
- map(int, input().split())
- map(int, sys.stdin.readline().split()))
- int(input())
- int(sys.stdin.readline().strip())
- sys.stdout.write()
- sys.stdout.write(" ".join(map(str, c) # writes c - collection of ints
"""
# import collections
import sys
import math
from bisect import bisect_left
from collections import defaultdict
# recursion increase
# sys.setrecursionlimit(10000)
# number with big precision
# from decimal import getcontext, Decimal
# getcontext().prec = 34
# longest common prefix
def get_lcp(s, suffix_array):
s = s + "$"
n = len(s)
lcp = [0] * (n)
pos = [0] * (n)
for i in range(n - 1):
pos[suffix_array[i]] = i
k = 0
for i in range(n - 1):
if k > 0:
k -= 1
if pos[i] == n - 1:
lcp[n - 1] = -1
k = 0
continue
else:
j = suffix_array[pos[i] + 1]
while max([i + k, j + k]) < n and s[i + k] == s[j + k]:
k += 1
lcp[pos[i]] = k
return lcp
def get_suffix_array(word):
suffix_array = [("", len(word))]
for position in range(len(word)):
sliced = word[len(word) - position - 1 :]
suffix_array.append((sliced, len(word) - position - 1))
suffix_array.sort(key=lambda x: x[0])
return [item[1] for item in suffix_array]
def get_ints():
return map(int, sys.stdin.readline().strip().split())
def bin_search(collection, element):
i = bisect_left(collection, element)
if i != len(collection) and collection[i] == element:
return i
else:
return -1
def main():
t = int(input())
for _ in range(t):
n = int(input())
a = []
edge_minx = list()
edge_maxx = list()
edge_miny = list()
edge_maxy = list()
for i in range(n):
a.append(str(input()))
edge_minx.append(defaultdict(lambda: -1))
edge_maxx.append(defaultdict(lambda: -1))
edge_miny.append(defaultdict(lambda: -1))
edge_maxy.append(defaultdict(lambda: -1))
ans = defaultdict(int)
for y in range(n):
for x in range(n):
d = int(a[y][x])
if edge_minx[y][d] == -1:
edge_minx[y][d] = x
if edge_miny[x][d] == -1:
edge_miny[x][d] = y
edge_maxx[y][d] = max(edge_maxx[y][d], x)
edge_maxy[x][d] = max(edge_maxy[x][d], y)
for i in range(n):
for d in range(10):
if 0 <= edge_minx[i][d] < edge_maxx[i][d]:
ans[d] = max(ans[d], (edge_maxx[i][d] - edge_minx[i][d]) * max(i, n - 1 - i))
if 0 <= edge_miny[i][d] < edge_maxy[i][d]:
ans[d] = max(ans[d], (edge_maxy[i][d] - edge_miny[i][d]) * max(i, n - 1 - i))
if 0 <= edge_minx[i][d]:
l1 = max(edge_minx[i][d], n - 1 - edge_minx[i][d])
l2 = max(edge_maxx[i][d], n - 1 - edge_maxx[i][d])
l = max(l1, l2)
ans[d] = max(ans[d], l * max(i - edge_miny[i][d], n - 1 - edge_maxy[i][d]))
if 0 <= edge_miny[i][d]:
l1 = max(edge_miny[i][d], n - 1 - edge_miny[i][d])
l2 = max(edge_maxy[i][d], n - 1 - edge_maxy[i][d])
l = max(l1, l2)
ans[d] = max(ans[d], l * max(i - edge_minx[i][d], n - 1 - edge_maxx[i][d]))
for d in range(10):
print(ans[d], end=' ')
print()
if __name__ == "__main__":
main()
```
No
| 99,658 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gildong has a square board consisting of n rows and n columns of square cells, each consisting of a single digit (from 0 to 9). The cell at the j-th column of the i-th row can be represented as (i, j), and the length of the side of each cell is 1. Gildong likes big things, so for each digit d, he wants to find a triangle such that:
* Each vertex of the triangle is in the center of a cell.
* The digit of every vertex of the triangle is d.
* At least one side of the triangle is parallel to one of the sides of the board. You may assume that a side of length 0 is parallel to both sides of the board.
* The area of the triangle is maximized.
Of course, he can't just be happy with finding these triangles as is. Therefore, for each digit d, he's going to change the digit of exactly one cell of the board to d, then find such a triangle. He changes it back to its original digit after he is done with each digit. Find the maximum area of the triangle he can make for each digit.
Note that he can put multiple vertices of the triangle on the same cell, and the triangle can be a [degenerate triangle](https://cutt.ly/NhbjZ2l); i.e. the area of the triangle can be 0. Also, note that he is allowed to change the digit of a cell from d to d.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
The first line of each test case contains one integer n (1 ≤ n ≤ 2000) — the number of rows and columns of the board.
The next n lines of each test case each contain a string of n digits without spaces. The j-th digit of the i-th line is the digit of the cell at (i, j). Each digit is one of the characters from 0 to 9.
It is guaranteed that the sum of n^2 in all test cases doesn't exceed 4 ⋅ 10^6.
Output
For each test case, print one line with 10 integers. The i-th integer is the maximum area of triangle Gildong can make when d = i-1, multiplied by 2.
Example
Input
5
3
000
122
001
2
57
75
4
0123
4012
3401
2340
1
9
8
42987101
98289412
38949562
87599023
92834718
83917348
19823743
38947912
Output
4 4 1 0 0 0 0 0 0 0
0 0 0 0 0 1 0 1 0 0
9 6 9 9 6 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
18 49 49 49 49 15 0 30 42 42
Note
In the first case, for d=0, no matter which cell he chooses to use, the triangle with vertices at (1, 1), (1, 3), and (3, 1) is the biggest triangle with area of \cfrac{2 ⋅ 2}{2} = 2. Since we should print it multiplied by 2, the answer for d=0 is 4.
For d=1, Gildong can change the digit of the cell at (1, 3) into 1, making a triangle with vertices on all three 1's that has an area of 2.
For d=2, Gildong can change the digit of one of the following six cells into 2 to make a triangle with an area of \cfrac{1}{2}: (1, 1), (1, 2), (1, 3), (3, 1), (3, 2), and (3, 3).
For the remaining digits (from 3 to 9), the cell Gildong chooses to change will be the only cell that contains that digit. Therefore the triangle will always be a degenerate triangle with an area of 0.
In the third case, for d=4, note that the triangle will be bigger than the answer if Gildong changes the digit of the cell at (1, 4) and use it along with the cells at (2, 1) and (4, 3), but this is invalid because it violates the condition that at least one side of the triangle must be parallel to one of the sides of the board.
Submitted Solution:
```
###pyrival template for fast IO
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().rstrip("\r\n")
t=int(input())
def func(a,b,n):
rowdiff=abs(a[0]-b[0])
coldiff=abs(a[1]-b[1])
a1=max([a[0],(n-1-a[0]),b[0],(n-1-b[0])])*coldiff
a2=max([b[1],(n-1-b[1]),a[1],(n-1-a[1])])*rowdiff
return max(a1,a2)
def app(x,a):
if x not in a:
a.append(x)
while t>0:
t-=1
n=int(input())
arr=[];maxi=(n-1)**2
dict={0:[],1:[],2:[],3:[],4:[],5:[],6:[],7:[],8:[],9:[]}
area=[0 for x in range(0,10)]
for i in range(n):
a=input();b=[]
for j in range(n):
b.append(int(a[j]))
dict[int(a[j])].append([i,j])
arr.append(b)
for num,val in dict.items():
l=len(val)
if l>1:
a=[]
rmin=val[0][0];rmax=val[-1][0]
#for rowwise maxarea
i=0;rmincolmax=-float("inf")
while i<l:
if val[i][0]==rmin:
rmincolmax=max(rmincolmax,val[i][1])
else:
break
i+=1
i=l-1;rmaxcolmin=float("inf")
while i>=0:
if val[i][0]==rmax:
rmaxcolmin=min(rmaxcolmin,val[i][1])
else:
break
i-=1
rmincolmin=val[0][1]
rmaxcolmax=val[-1][1]
cmin=float("inf");cmax=-float("inf")
cminrowmin=float("inf");cmaxrowmax=-float("inf")
cminrowmax=-float("inf");cmaxrowmin=float("inf")
for i in range(l):
cmin=min(cmin,val[i][1])
cmax=max(cmax,val[i][1])
for i in range(l):
if val[i][1]==cmin:
cminrowmax=max(cminrowmax,val[i][0])
cminrowmin=min(cminrowmin,val[i][0])
elif val[i][1]==cmax:
cmaxrowmin=min(cmaxrowmin,val[i][0])
cmaxrowmax=max(cmaxrowmax,val[i][0])
app([rmin,rmincolmin],a)
app([rmin,rmincolmax],a)
app([rmax,rmaxcolmin],a)
app([rmax,rmaxcolmax],a)
app([cminrowmin,cmin],a)
app([cminrowmax,cmin],a)
app([cmaxrowmin,cmax],a)
app([cmaxrowmax,cmax],a)
for i in range(len(a)):
for j in range(i+1,len(a)):
area[num]=max(area[num],func(a[i],a[j],n))
print(*area)
```
No
| 99,659 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gildong has a square board consisting of n rows and n columns of square cells, each consisting of a single digit (from 0 to 9). The cell at the j-th column of the i-th row can be represented as (i, j), and the length of the side of each cell is 1. Gildong likes big things, so for each digit d, he wants to find a triangle such that:
* Each vertex of the triangle is in the center of a cell.
* The digit of every vertex of the triangle is d.
* At least one side of the triangle is parallel to one of the sides of the board. You may assume that a side of length 0 is parallel to both sides of the board.
* The area of the triangle is maximized.
Of course, he can't just be happy with finding these triangles as is. Therefore, for each digit d, he's going to change the digit of exactly one cell of the board to d, then find such a triangle. He changes it back to its original digit after he is done with each digit. Find the maximum area of the triangle he can make for each digit.
Note that he can put multiple vertices of the triangle on the same cell, and the triangle can be a [degenerate triangle](https://cutt.ly/NhbjZ2l); i.e. the area of the triangle can be 0. Also, note that he is allowed to change the digit of a cell from d to d.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
The first line of each test case contains one integer n (1 ≤ n ≤ 2000) — the number of rows and columns of the board.
The next n lines of each test case each contain a string of n digits without spaces. The j-th digit of the i-th line is the digit of the cell at (i, j). Each digit is one of the characters from 0 to 9.
It is guaranteed that the sum of n^2 in all test cases doesn't exceed 4 ⋅ 10^6.
Output
For each test case, print one line with 10 integers. The i-th integer is the maximum area of triangle Gildong can make when d = i-1, multiplied by 2.
Example
Input
5
3
000
122
001
2
57
75
4
0123
4012
3401
2340
1
9
8
42987101
98289412
38949562
87599023
92834718
83917348
19823743
38947912
Output
4 4 1 0 0 0 0 0 0 0
0 0 0 0 0 1 0 1 0 0
9 6 9 9 6 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
18 49 49 49 49 15 0 30 42 42
Note
In the first case, for d=0, no matter which cell he chooses to use, the triangle with vertices at (1, 1), (1, 3), and (3, 1) is the biggest triangle with area of \cfrac{2 ⋅ 2}{2} = 2. Since we should print it multiplied by 2, the answer for d=0 is 4.
For d=1, Gildong can change the digit of the cell at (1, 3) into 1, making a triangle with vertices on all three 1's that has an area of 2.
For d=2, Gildong can change the digit of one of the following six cells into 2 to make a triangle with an area of \cfrac{1}{2}: (1, 1), (1, 2), (1, 3), (3, 1), (3, 2), and (3, 3).
For the remaining digits (from 3 to 9), the cell Gildong chooses to change will be the only cell that contains that digit. Therefore the triangle will always be a degenerate triangle with an area of 0.
In the third case, for d=4, note that the triangle will be bigger than the answer if Gildong changes the digit of the cell at (1, 4) and use it along with the cells at (2, 1) and (4, 3), but this is invalid because it violates the condition that at least one side of the triangle must be parallel to one of the sides of the board.
Submitted Solution:
```
t = int(input())
while t!=0:
n = int(input())
list1 = []
for i in range(n):
s = list(input())
list1.append(s)
# print(list1)
h = [[[-1,float('inf')],[-1,float('-inf')]] for i in range(10)]
v = [[[float('inf'),-1],[float('-inf'),-1]] for i in range(10)]
for i in range(n):
for j in range(n):
if h[int(list1[i][j])][0][1] > j:
h[int(list1[i][j])][0][1] = j
h[int(list1[i][j])][0][0] = i
if h[int(list1[i][j])][1][1] < j:
h[int(list1[i][j])][1][1] = j
h[int(list1[i][j])][1][0] = i
ans = 0
# print(h)
# print(v)
n-=1
fa = [0 for i in range(10)]
# print(h[3])
# print(v[3])
for i in range(len(list1)):
for j in range(len(list1[i])):
pa = i
pb = j
a1 = h[int(list1[i][j])][0][0]
b1 = h[int(list1[i][j])][0][1]
a2 = h[int(list1[i][j])][1][0]
b2 = h[int(list1[i][j])][1][1]
temp = 0
temp = max(max(abs(pa - a1) * max((n - pb), (n - b1), max(b1, pb)),
abs(pb - b1) * (max((n - a1), (n - pa), max(a1, pa)))), temp)
temp = max(max(abs(a2 - pa) * max((n - pb), (n - b2), max(b2, pb)),
abs(pb - b2) * (max((n - a2), (n - pa), max(a2, pa)))), temp)
# if int(list1[i][j])==2:
# print(temp,i,j,pa,pb,a1,b1,a2)
# if int(list1[i][j])==2:
# print(temp,i,j)
fa[int(list1[i][j])] = max(temp,fa[int(list1[i][j])])
#
# for i in range(len(h)):
# a1 = h[i][0][0]
# b1 = h[i][0][1]
# a2 = h[i][1][0]
# b2 = h[i][1][1]
#
# temp = 0
#
# if a1==float('inf') or a2==float('-inf'):
# pass
# else:
# temp = max(max(abs(a2-a1)*max((n-b2),(n-b1),max(b1,b2)), abs(b2-b1)*(max((n-a1),(n-a2),max(a1,a2)))),temp)
#
# print("sgsdj",temp)
#
# a1 = v[i][0][0]
# b1 = v[i][0][1]
# a2 = v[i][1][0]
# b2 = v[i][1][1]
#
# if a1 == float('inf') or a2 == float('-inf'):
# pass
# else:
#
# print("here->",max(abs(a2 - a1) * max((n - b2), (n - b1)), abs(b2 - b1) * (max((n - a1), (n - a2)))))
#
# temp = max(max(abs(a2-a1)*max((n-b2),(n-b1),max(b1,b2)), abs(b2-b1)*(max((n-a1),(n-a2),max(a1,a2)))),temp)
#
#
#
#
#
#
# fa.append(temp)
print(*fa)
#
# print(v)
#
t-=1
```
No
| 99,660 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gildong has a square board consisting of n rows and n columns of square cells, each consisting of a single digit (from 0 to 9). The cell at the j-th column of the i-th row can be represented as (i, j), and the length of the side of each cell is 1. Gildong likes big things, so for each digit d, he wants to find a triangle such that:
* Each vertex of the triangle is in the center of a cell.
* The digit of every vertex of the triangle is d.
* At least one side of the triangle is parallel to one of the sides of the board. You may assume that a side of length 0 is parallel to both sides of the board.
* The area of the triangle is maximized.
Of course, he can't just be happy with finding these triangles as is. Therefore, for each digit d, he's going to change the digit of exactly one cell of the board to d, then find such a triangle. He changes it back to its original digit after he is done with each digit. Find the maximum area of the triangle he can make for each digit.
Note that he can put multiple vertices of the triangle on the same cell, and the triangle can be a [degenerate triangle](https://cutt.ly/NhbjZ2l); i.e. the area of the triangle can be 0. Also, note that he is allowed to change the digit of a cell from d to d.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
The first line of each test case contains one integer n (1 ≤ n ≤ 2000) — the number of rows and columns of the board.
The next n lines of each test case each contain a string of n digits without spaces. The j-th digit of the i-th line is the digit of the cell at (i, j). Each digit is one of the characters from 0 to 9.
It is guaranteed that the sum of n^2 in all test cases doesn't exceed 4 ⋅ 10^6.
Output
For each test case, print one line with 10 integers. The i-th integer is the maximum area of triangle Gildong can make when d = i-1, multiplied by 2.
Example
Input
5
3
000
122
001
2
57
75
4
0123
4012
3401
2340
1
9
8
42987101
98289412
38949562
87599023
92834718
83917348
19823743
38947912
Output
4 4 1 0 0 0 0 0 0 0
0 0 0 0 0 1 0 1 0 0
9 6 9 9 6 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
18 49 49 49 49 15 0 30 42 42
Note
In the first case, for d=0, no matter which cell he chooses to use, the triangle with vertices at (1, 1), (1, 3), and (3, 1) is the biggest triangle with area of \cfrac{2 ⋅ 2}{2} = 2. Since we should print it multiplied by 2, the answer for d=0 is 4.
For d=1, Gildong can change the digit of the cell at (1, 3) into 1, making a triangle with vertices on all three 1's that has an area of 2.
For d=2, Gildong can change the digit of one of the following six cells into 2 to make a triangle with an area of \cfrac{1}{2}: (1, 1), (1, 2), (1, 3), (3, 1), (3, 2), and (3, 3).
For the remaining digits (from 3 to 9), the cell Gildong chooses to change will be the only cell that contains that digit. Therefore the triangle will always be a degenerate triangle with an area of 0.
In the third case, for d=4, note that the triangle will be bigger than the answer if Gildong changes the digit of the cell at (1, 4) and use it along with the cells at (2, 1) and (4, 3), but this is invalid because it violates the condition that at least one side of the triangle must be parallel to one of the sides of the board.
Submitted Solution:
```
#!/usr/bin/env python3
# created : 2020. 12. 31. 23:59
import os
from sys import stdin, stdout
def solve(tc):
n = int(stdin.readline().strip())
mat = [[] for i in range(n)]
for i in range(n):
mat[i] = list(stdin.readline().strip())
cell = [[] for i in range(10)]
for i in range(n):
for j in range(n):
val = int(ord(mat[i][j])-ord('0'))
cell[val].append([i, j])
ans = [0 for i in range(10)]
for i in range(10):
if len(cell[i]) < 2:
continue
top, bottom = [-1, -1], [-1, -1]
left, right = [-1, -1], [-1, -1]
tv, bv = n+1, -1
lv, rv = n+1, -1
for j in range(len(cell[i])):
if tv > cell[i][j][0]:
tv = cell[i][j][0]
top = [j, j]
elif tv == cell[i][j][0]:
top[1] = j
if bv < cell[i][j][0]:
bv = cell[i][j][0]
bottom = [j, j]
elif bv == cell[i][j][0]:
bottom[1] = j
if lv > cell[i][j][1]:
lv = cell[i][j][1]
left = [j, j]
elif lv == cell[i][j][1]:
left[1] = j
if rv < cell[i][j][1]:
rv = cell[i][j][1]
right = [j, j]
elif rv == cell[i][j][1]:
right[1] = j
dy = abs(cell[i][top[0]][0] - cell[i][bottom[0]][0])
dx = max(cell[i][top[0]][1], n-1-cell[i][top[0]][1])
dx = max(dx, max(cell[i][top[1]][1], n-1-cell[i][top[1]][1]))
dx = max(dx, max(cell[i][bottom[0]][1], n-1-cell[i][bottom[0]][1]))
dx = max(dx, max(cell[i][bottom[1]][1], n-1-cell[i][bottom[1]][1]))
ans[i] = max(ans[i], dy*dx)
dx = abs(cell[i][left[0]][1] - cell[i][right[0]][1])
dy = max(cell[i][left[0]][0], n-1-cell[i][left[0]][0])
dy = max(dy, max(cell[i][left[1]][0], n-1-cell[i][left[1]][0]))
dy = max(dy, max(cell[i][right[0]][0], n-1-cell[i][right[0]][0]))
dy = max(dy, max(cell[i][right[1]][0], n-1-cell[i][right[1]][0]))
ans[i] = max(ans[i], dy*dx)
print(*ans)
tcs = 1
tcs = int(stdin.readline().strip())
tc = 1
while tc <= tcs:
solve(tc)
tc += 1
```
No
| 99,661 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n distinct integers x_1,x_2,…,x_n are written on the board. Nezzar can perform the following operation multiple times.
* Select two integers x,y (not necessarily distinct) on the board, and write down 2x-y. Note that you don't remove selected numbers.
Now, Nezzar wonders if it is possible to have his favorite number k on the board after applying above operation multiple times.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
The first line of each test case contains two integers n,k (2 ≤ n ≤ 2 ⋅ 10^5, -10^{18} ≤ k ≤ 10^{18}).
The second line of each test case contains n distinct integers x_1,x_2,…,x_n (-10^{18} ≤ x_i ≤ 10^{18}).
It is guaranteed that the sum of n for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print "YES" on a single line if it is possible to have k on the board. Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
2 1
1 2
3 0
2 3 7
2 -1
31415926 27182818
2 1000000000000000000
1 1000000000000000000
2 -1000000000000000000
-1000000000000000000 123
6 80
-5 -20 13 -14 -2 -11
Output
YES
YES
NO
YES
YES
NO
Note
In the first test case, the number 1 is already on the board.
In the second test case, Nezzar could perform the following operations to write down k=0 on the board:
* Select x=3 and y=2 and write down 4 on the board.
* Select x=4 and y=7 and write down 1 on the board.
* Select x=1 and y=2 and write down 0 on the board.
In the third test case, it is impossible to have the number k = -1 on the board.
Tags: constructive algorithms, math, number theory
Correct Solution:
```
import math
def gcd(a,b):
return math.gcd(a,b)
for _ in range(int(input())):
n,k=map(int,input().split())
l=list(map(int,input().split()))
g=0
l.sort()
for i in range(1,n):
g=gcd(g,l[i]-l[0])
if (k-l[0])%g==0:
print('YES')
else:
print('NO')
```
| 99,662 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n distinct integers x_1,x_2,…,x_n are written on the board. Nezzar can perform the following operation multiple times.
* Select two integers x,y (not necessarily distinct) on the board, and write down 2x-y. Note that you don't remove selected numbers.
Now, Nezzar wonders if it is possible to have his favorite number k on the board after applying above operation multiple times.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
The first line of each test case contains two integers n,k (2 ≤ n ≤ 2 ⋅ 10^5, -10^{18} ≤ k ≤ 10^{18}).
The second line of each test case contains n distinct integers x_1,x_2,…,x_n (-10^{18} ≤ x_i ≤ 10^{18}).
It is guaranteed that the sum of n for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print "YES" on a single line if it is possible to have k on the board. Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
2 1
1 2
3 0
2 3 7
2 -1
31415926 27182818
2 1000000000000000000
1 1000000000000000000
2 -1000000000000000000
-1000000000000000000 123
6 80
-5 -20 13 -14 -2 -11
Output
YES
YES
NO
YES
YES
NO
Note
In the first test case, the number 1 is already on the board.
In the second test case, Nezzar could perform the following operations to write down k=0 on the board:
* Select x=3 and y=2 and write down 4 on the board.
* Select x=4 and y=7 and write down 1 on the board.
* Select x=1 and y=2 and write down 0 on the board.
In the third test case, it is impossible to have the number k = -1 on the board.
Tags: constructive algorithms, math, number theory
Correct Solution:
```
import sys,math
r=sys.stdin.readline
for _ in range(int(r())):
n,k=map(int,r().split())
lst=list(map(int,r().split()))
st=set(lst)
if k in st:
print("YES")
continue
lst.sort()
g=0
for i in range(len(lst)):
g=math.gcd(g,lst[i]-lst[0])
if (k-lst[0])%g==0:
print("YES")
else:
print("NO")
```
| 99,663 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n distinct integers x_1,x_2,…,x_n are written on the board. Nezzar can perform the following operation multiple times.
* Select two integers x,y (not necessarily distinct) on the board, and write down 2x-y. Note that you don't remove selected numbers.
Now, Nezzar wonders if it is possible to have his favorite number k on the board after applying above operation multiple times.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
The first line of each test case contains two integers n,k (2 ≤ n ≤ 2 ⋅ 10^5, -10^{18} ≤ k ≤ 10^{18}).
The second line of each test case contains n distinct integers x_1,x_2,…,x_n (-10^{18} ≤ x_i ≤ 10^{18}).
It is guaranteed that the sum of n for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print "YES" on a single line if it is possible to have k on the board. Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
2 1
1 2
3 0
2 3 7
2 -1
31415926 27182818
2 1000000000000000000
1 1000000000000000000
2 -1000000000000000000
-1000000000000000000 123
6 80
-5 -20 13 -14 -2 -11
Output
YES
YES
NO
YES
YES
NO
Note
In the first test case, the number 1 is already on the board.
In the second test case, Nezzar could perform the following operations to write down k=0 on the board:
* Select x=3 and y=2 and write down 4 on the board.
* Select x=4 and y=7 and write down 1 on the board.
* Select x=1 and y=2 and write down 0 on the board.
In the third test case, it is impossible to have the number k = -1 on the board.
Tags: constructive algorithms, math, number theory
Correct Solution:
```
def gcd(x, y):
while y != 0:
(x, y) = (y, x % y)
return x
def main():
t=int(input())
allAns=[]
for _ in range(t):
n,k=readIntArr()
a=readIntArr()
cumugcd=0
for i in range(1,n):
cumugcd=gcd(cumugcd,abs(a[i]-a[0]))
if abs(k-a[0])%cumugcd==0:
ans='YES'
else:
ans='NO'
allAns.append(ans)
multiLineArrayPrint(allAns)
return
import sys
input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
#import sys
#input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.
def oneLineArrayPrint(arr):
print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))
def readIntArr():
return [int(x) for x in input().split()]
inf=float('inf')
MOD=10**9+7
main()
```
| 99,664 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n distinct integers x_1,x_2,…,x_n are written on the board. Nezzar can perform the following operation multiple times.
* Select two integers x,y (not necessarily distinct) on the board, and write down 2x-y. Note that you don't remove selected numbers.
Now, Nezzar wonders if it is possible to have his favorite number k on the board after applying above operation multiple times.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
The first line of each test case contains two integers n,k (2 ≤ n ≤ 2 ⋅ 10^5, -10^{18} ≤ k ≤ 10^{18}).
The second line of each test case contains n distinct integers x_1,x_2,…,x_n (-10^{18} ≤ x_i ≤ 10^{18}).
It is guaranteed that the sum of n for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print "YES" on a single line if it is possible to have k on the board. Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
2 1
1 2
3 0
2 3 7
2 -1
31415926 27182818
2 1000000000000000000
1 1000000000000000000
2 -1000000000000000000
-1000000000000000000 123
6 80
-5 -20 13 -14 -2 -11
Output
YES
YES
NO
YES
YES
NO
Note
In the first test case, the number 1 is already on the board.
In the second test case, Nezzar could perform the following operations to write down k=0 on the board:
* Select x=3 and y=2 and write down 4 on the board.
* Select x=4 and y=7 and write down 1 on the board.
* Select x=1 and y=2 and write down 0 on the board.
In the third test case, it is impossible to have the number k = -1 on the board.
Tags: constructive algorithms, math, number theory
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO,IOBase
from math import gcd
def solve(n,k,x):
if k in x:
return 'YES'
y = x[1]-x[0]
for i in range(1,n):
y = gcd(y,x[i]-x[0])
if (k-x[0])%y:
return 'NO'
else:
return 'YES'
def main():
for _ in range(int(input())):
n,k = map(int,input().split())
x = list(map(int,input().split()))
print(solve(n,k,x))
#Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == '__main__':
main()
```
| 99,665 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n distinct integers x_1,x_2,…,x_n are written on the board. Nezzar can perform the following operation multiple times.
* Select two integers x,y (not necessarily distinct) on the board, and write down 2x-y. Note that you don't remove selected numbers.
Now, Nezzar wonders if it is possible to have his favorite number k on the board after applying above operation multiple times.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
The first line of each test case contains two integers n,k (2 ≤ n ≤ 2 ⋅ 10^5, -10^{18} ≤ k ≤ 10^{18}).
The second line of each test case contains n distinct integers x_1,x_2,…,x_n (-10^{18} ≤ x_i ≤ 10^{18}).
It is guaranteed that the sum of n for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print "YES" on a single line if it is possible to have k on the board. Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
2 1
1 2
3 0
2 3 7
2 -1
31415926 27182818
2 1000000000000000000
1 1000000000000000000
2 -1000000000000000000
-1000000000000000000 123
6 80
-5 -20 13 -14 -2 -11
Output
YES
YES
NO
YES
YES
NO
Note
In the first test case, the number 1 is already on the board.
In the second test case, Nezzar could perform the following operations to write down k=0 on the board:
* Select x=3 and y=2 and write down 4 on the board.
* Select x=4 and y=7 and write down 1 on the board.
* Select x=1 and y=2 and write down 0 on the board.
In the third test case, it is impossible to have the number k = -1 on the board.
Tags: constructive algorithms, math, number theory
Correct Solution:
```
from math import gcd
import sys
input = sys.stdin.buffer.readline
def prog():
for _ in range(int(input())):
n,k = map(int,input().split())
a = list(map(int,input().split()))
a.sort()
d = 0
for i in range(n-1):
d = gcd(d,a[i+1]-a[i])
print("YES" if (k - a[0])%d == 0 else "NO")
prog()
```
| 99,666 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n distinct integers x_1,x_2,…,x_n are written on the board. Nezzar can perform the following operation multiple times.
* Select two integers x,y (not necessarily distinct) on the board, and write down 2x-y. Note that you don't remove selected numbers.
Now, Nezzar wonders if it is possible to have his favorite number k on the board after applying above operation multiple times.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
The first line of each test case contains two integers n,k (2 ≤ n ≤ 2 ⋅ 10^5, -10^{18} ≤ k ≤ 10^{18}).
The second line of each test case contains n distinct integers x_1,x_2,…,x_n (-10^{18} ≤ x_i ≤ 10^{18}).
It is guaranteed that the sum of n for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print "YES" on a single line if it is possible to have k on the board. Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
2 1
1 2
3 0
2 3 7
2 -1
31415926 27182818
2 1000000000000000000
1 1000000000000000000
2 -1000000000000000000
-1000000000000000000 123
6 80
-5 -20 13 -14 -2 -11
Output
YES
YES
NO
YES
YES
NO
Note
In the first test case, the number 1 is already on the board.
In the second test case, Nezzar could perform the following operations to write down k=0 on the board:
* Select x=3 and y=2 and write down 4 on the board.
* Select x=4 and y=7 and write down 1 on the board.
* Select x=1 and y=2 and write down 0 on the board.
In the third test case, it is impossible to have the number k = -1 on the board.
Tags: constructive algorithms, math, number theory
Correct Solution:
```
import sys
input = sys.stdin.readline
from math import gcd
t=int(input())
for tests in range(t):
n,k=map(int,input().split())
X=list(map(int,input().split()))
G=0
for i in range(1,n):
G=gcd(G,X[i]-X[i-1])
#print(G)
if k%G==X[0]%G:
print("YES")
else:
print("NO")
```
| 99,667 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n distinct integers x_1,x_2,…,x_n are written on the board. Nezzar can perform the following operation multiple times.
* Select two integers x,y (not necessarily distinct) on the board, and write down 2x-y. Note that you don't remove selected numbers.
Now, Nezzar wonders if it is possible to have his favorite number k on the board after applying above operation multiple times.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
The first line of each test case contains two integers n,k (2 ≤ n ≤ 2 ⋅ 10^5, -10^{18} ≤ k ≤ 10^{18}).
The second line of each test case contains n distinct integers x_1,x_2,…,x_n (-10^{18} ≤ x_i ≤ 10^{18}).
It is guaranteed that the sum of n for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print "YES" on a single line if it is possible to have k on the board. Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
2 1
1 2
3 0
2 3 7
2 -1
31415926 27182818
2 1000000000000000000
1 1000000000000000000
2 -1000000000000000000
-1000000000000000000 123
6 80
-5 -20 13 -14 -2 -11
Output
YES
YES
NO
YES
YES
NO
Note
In the first test case, the number 1 is already on the board.
In the second test case, Nezzar could perform the following operations to write down k=0 on the board:
* Select x=3 and y=2 and write down 4 on the board.
* Select x=4 and y=7 and write down 1 on the board.
* Select x=1 and y=2 and write down 0 on the board.
In the third test case, it is impossible to have the number k = -1 on the board.
Tags: constructive algorithms, math, number theory
Correct Solution:
```
"""
#If FastIO not needed, use this and don't forget to strip
#import sys, math
#input = sys.stdin.readline
"""
import os
import sys
from io import BytesIO, IOBase
import heapq as h
from bisect import bisect_left, bisect_right
import time
from types import GeneratorType
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
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 = self.os.read(self._fd, max(self.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 = self.os.read(self._fd, max(self.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:
self.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")
from collections import defaultdict as dd, deque as dq, Counter as dc
import math, string
#start_time = time.time()
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
def getMat(n):
return [getInts() for _ in range(n)]
def isInt(s):
return '0' <= s[0] <= '9'
MOD = 10**9 + 7
"""
If the diffs have GCD 1, we definitely can reach
"""
def solve():
N, K = getInts()
A = getInts()
A.sort()
G = A[1]-A[0]
for i in range(1,N-1):
G = math.gcd(G,A[i+1]-A[i])
if G == 1: return "YES"
for i in range(N):
if (A[i] - K) % G == 0: return "YES"
return "NO"
for _ in range(getInt()):
print(solve())
#solve()
#print(time.time()-start_time)
```
| 99,668 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n distinct integers x_1,x_2,…,x_n are written on the board. Nezzar can perform the following operation multiple times.
* Select two integers x,y (not necessarily distinct) on the board, and write down 2x-y. Note that you don't remove selected numbers.
Now, Nezzar wonders if it is possible to have his favorite number k on the board after applying above operation multiple times.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
The first line of each test case contains two integers n,k (2 ≤ n ≤ 2 ⋅ 10^5, -10^{18} ≤ k ≤ 10^{18}).
The second line of each test case contains n distinct integers x_1,x_2,…,x_n (-10^{18} ≤ x_i ≤ 10^{18}).
It is guaranteed that the sum of n for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print "YES" on a single line if it is possible to have k on the board. Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
2 1
1 2
3 0
2 3 7
2 -1
31415926 27182818
2 1000000000000000000
1 1000000000000000000
2 -1000000000000000000
-1000000000000000000 123
6 80
-5 -20 13 -14 -2 -11
Output
YES
YES
NO
YES
YES
NO
Note
In the first test case, the number 1 is already on the board.
In the second test case, Nezzar could perform the following operations to write down k=0 on the board:
* Select x=3 and y=2 and write down 4 on the board.
* Select x=4 and y=7 and write down 1 on the board.
* Select x=1 and y=2 and write down 0 on the board.
In the third test case, it is impossible to have the number k = -1 on the board.
Tags: constructive algorithms, math, number theory
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
def __init__(self, file):
self.newlines = 0
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(200000)
# 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()):
_, k = RL()
a = RLL()
print('YES' if (k - a[0]) % reduce(math.gcd, [v - a[0] for v in a[1:]]) == 0 else 'NO')
```
| 99,669 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n distinct integers x_1,x_2,…,x_n are written on the board. Nezzar can perform the following operation multiple times.
* Select two integers x,y (not necessarily distinct) on the board, and write down 2x-y. Note that you don't remove selected numbers.
Now, Nezzar wonders if it is possible to have his favorite number k on the board after applying above operation multiple times.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
The first line of each test case contains two integers n,k (2 ≤ n ≤ 2 ⋅ 10^5, -10^{18} ≤ k ≤ 10^{18}).
The second line of each test case contains n distinct integers x_1,x_2,…,x_n (-10^{18} ≤ x_i ≤ 10^{18}).
It is guaranteed that the sum of n for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print "YES" on a single line if it is possible to have k on the board. Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
2 1
1 2
3 0
2 3 7
2 -1
31415926 27182818
2 1000000000000000000
1 1000000000000000000
2 -1000000000000000000
-1000000000000000000 123
6 80
-5 -20 13 -14 -2 -11
Output
YES
YES
NO
YES
YES
NO
Note
In the first test case, the number 1 is already on the board.
In the second test case, Nezzar could perform the following operations to write down k=0 on the board:
* Select x=3 and y=2 and write down 4 on the board.
* Select x=4 and y=7 and write down 1 on the board.
* Select x=1 and y=2 and write down 0 on the board.
In the third test case, it is impossible to have the number k = -1 on the board.
Submitted 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().rstrip("\r\n")
from math import gcd
def solve_case():
n, k = [int(x) for x in input().split()]
a = list(sorted([int(x) for x in input().split()]))
g = 0
for i in range(1, n):
g = gcd(g, a[i] - a[i - 1])
for i in range(n):
if (k - a[i]) % g == 0:
print('YES')
return
print('NO')
def main():
for _ in range(int(input())):
solve_case()
main()
```
Yes
| 99,670 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n distinct integers x_1,x_2,…,x_n are written on the board. Nezzar can perform the following operation multiple times.
* Select two integers x,y (not necessarily distinct) on the board, and write down 2x-y. Note that you don't remove selected numbers.
Now, Nezzar wonders if it is possible to have his favorite number k on the board after applying above operation multiple times.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
The first line of each test case contains two integers n,k (2 ≤ n ≤ 2 ⋅ 10^5, -10^{18} ≤ k ≤ 10^{18}).
The second line of each test case contains n distinct integers x_1,x_2,…,x_n (-10^{18} ≤ x_i ≤ 10^{18}).
It is guaranteed that the sum of n for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print "YES" on a single line if it is possible to have k on the board. Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
2 1
1 2
3 0
2 3 7
2 -1
31415926 27182818
2 1000000000000000000
1 1000000000000000000
2 -1000000000000000000
-1000000000000000000 123
6 80
-5 -20 13 -14 -2 -11
Output
YES
YES
NO
YES
YES
NO
Note
In the first test case, the number 1 is already on the board.
In the second test case, Nezzar could perform the following operations to write down k=0 on the board:
* Select x=3 and y=2 and write down 4 on the board.
* Select x=4 and y=7 and write down 1 on the board.
* Select x=1 and y=2 and write down 0 on the board.
In the third test case, it is impossible to have the number k = -1 on the board.
Submitted Solution:
```
import math, sys
from functools import reduce
input = sys.stdin.readline
for _ in range(int(input())):
_, k = map(int, input().split())
a = list(map(int, input().split()))
print('NO' if (k - a[0]) % reduce(math.gcd, [v - a[0] for v in a[1:]]) else 'YES')
```
Yes
| 99,671 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n distinct integers x_1,x_2,…,x_n are written on the board. Nezzar can perform the following operation multiple times.
* Select two integers x,y (not necessarily distinct) on the board, and write down 2x-y. Note that you don't remove selected numbers.
Now, Nezzar wonders if it is possible to have his favorite number k on the board after applying above operation multiple times.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
The first line of each test case contains two integers n,k (2 ≤ n ≤ 2 ⋅ 10^5, -10^{18} ≤ k ≤ 10^{18}).
The second line of each test case contains n distinct integers x_1,x_2,…,x_n (-10^{18} ≤ x_i ≤ 10^{18}).
It is guaranteed that the sum of n for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print "YES" on a single line if it is possible to have k on the board. Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
2 1
1 2
3 0
2 3 7
2 -1
31415926 27182818
2 1000000000000000000
1 1000000000000000000
2 -1000000000000000000
-1000000000000000000 123
6 80
-5 -20 13 -14 -2 -11
Output
YES
YES
NO
YES
YES
NO
Note
In the first test case, the number 1 is already on the board.
In the second test case, Nezzar could perform the following operations to write down k=0 on the board:
* Select x=3 and y=2 and write down 4 on the board.
* Select x=4 and y=7 and write down 1 on the board.
* Select x=1 and y=2 and write down 0 on the board.
In the third test case, it is impossible to have the number k = -1 on the board.
Submitted Solution:
```
def gcd(x, y):
if y == 0:
return x
return gcd(y, x % y)
t = int(input())
for i in range(t):
n, k = map(int, input().split())
xlist = list(map(int, input().split()))
lm = 0
for i in xlist:
lm = gcd(lm, i-xlist[0])
flag = False
for x in xlist:
if abs(x - k) % lm == 0:
print("YES")
flag = True
break
if not flag:
print("NO")
```
Yes
| 99,672 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n distinct integers x_1,x_2,…,x_n are written on the board. Nezzar can perform the following operation multiple times.
* Select two integers x,y (not necessarily distinct) on the board, and write down 2x-y. Note that you don't remove selected numbers.
Now, Nezzar wonders if it is possible to have his favorite number k on the board after applying above operation multiple times.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
The first line of each test case contains two integers n,k (2 ≤ n ≤ 2 ⋅ 10^5, -10^{18} ≤ k ≤ 10^{18}).
The second line of each test case contains n distinct integers x_1,x_2,…,x_n (-10^{18} ≤ x_i ≤ 10^{18}).
It is guaranteed that the sum of n for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print "YES" on a single line if it is possible to have k on the board. Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
2 1
1 2
3 0
2 3 7
2 -1
31415926 27182818
2 1000000000000000000
1 1000000000000000000
2 -1000000000000000000
-1000000000000000000 123
6 80
-5 -20 13 -14 -2 -11
Output
YES
YES
NO
YES
YES
NO
Note
In the first test case, the number 1 is already on the board.
In the second test case, Nezzar could perform the following operations to write down k=0 on the board:
* Select x=3 and y=2 and write down 4 on the board.
* Select x=4 and y=7 and write down 1 on the board.
* Select x=1 and y=2 and write down 0 on the board.
In the third test case, it is impossible to have the number k = -1 on the board.
Submitted Solution:
```
def gcd(x, y):
while y != 0:
(x, y) = (y, x % y)
return x
def main():
t=int(input())
allAns=[]
for _ in range(t):
n,k=readIntArr()
a=readIntArr()
cumugcd=0
for i in range(1,n):
cumugcd=gcd(cumugcd,abs(a[i]-a[0]))
ans='NO'
for x in a:
if abs(k-x)%cumugcd==0:
ans='YES'
break
allAns.append(ans)
multiLineArrayPrint(allAns)
return
import sys
input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
#import sys
#input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.
def oneLineArrayPrint(arr):
print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))
def readIntArr():
return [int(x) for x in input().split()]
inf=float('inf')
MOD=10**9+7
main()
```
Yes
| 99,673 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n distinct integers x_1,x_2,…,x_n are written on the board. Nezzar can perform the following operation multiple times.
* Select two integers x,y (not necessarily distinct) on the board, and write down 2x-y. Note that you don't remove selected numbers.
Now, Nezzar wonders if it is possible to have his favorite number k on the board after applying above operation multiple times.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
The first line of each test case contains two integers n,k (2 ≤ n ≤ 2 ⋅ 10^5, -10^{18} ≤ k ≤ 10^{18}).
The second line of each test case contains n distinct integers x_1,x_2,…,x_n (-10^{18} ≤ x_i ≤ 10^{18}).
It is guaranteed that the sum of n for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print "YES" on a single line if it is possible to have k on the board. Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
2 1
1 2
3 0
2 3 7
2 -1
31415926 27182818
2 1000000000000000000
1 1000000000000000000
2 -1000000000000000000
-1000000000000000000 123
6 80
-5 -20 13 -14 -2 -11
Output
YES
YES
NO
YES
YES
NO
Note
In the first test case, the number 1 is already on the board.
In the second test case, Nezzar could perform the following operations to write down k=0 on the board:
* Select x=3 and y=2 and write down 4 on the board.
* Select x=4 and y=7 and write down 1 on the board.
* Select x=1 and y=2 and write down 0 on the board.
In the third test case, it is impossible to have the number k = -1 on the board.
Submitted Solution:
```
#1800
import sys
input = sys.stdin.readline
getint = lambda: int(input())
getints = lambda: [int(a) for a in input().split()]
def calc_gcd(big, small):
if small == 0:
return big
return calc_gcd(small, big % small)
def solve():
n, k = getints()
x = getints()
a = min(x)
gcd = x[0] - a
if gcd == 0:
gcd = x[1] - 1
for xvalue in x:
if xvalue == a:
continue
comparer = gcd, xvalue - a
gcd = calc_gcd(max(comparer), min(comparer))
k -= a
if k % gcd == 0:
print("YES")
else:
print("NO")
if __name__ == '__main__':
t = getint()
for i in range(t):
solve()
```
No
| 99,674 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n distinct integers x_1,x_2,…,x_n are written on the board. Nezzar can perform the following operation multiple times.
* Select two integers x,y (not necessarily distinct) on the board, and write down 2x-y. Note that you don't remove selected numbers.
Now, Nezzar wonders if it is possible to have his favorite number k on the board after applying above operation multiple times.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
The first line of each test case contains two integers n,k (2 ≤ n ≤ 2 ⋅ 10^5, -10^{18} ≤ k ≤ 10^{18}).
The second line of each test case contains n distinct integers x_1,x_2,…,x_n (-10^{18} ≤ x_i ≤ 10^{18}).
It is guaranteed that the sum of n for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print "YES" on a single line if it is possible to have k on the board. Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
2 1
1 2
3 0
2 3 7
2 -1
31415926 27182818
2 1000000000000000000
1 1000000000000000000
2 -1000000000000000000
-1000000000000000000 123
6 80
-5 -20 13 -14 -2 -11
Output
YES
YES
NO
YES
YES
NO
Note
In the first test case, the number 1 is already on the board.
In the second test case, Nezzar could perform the following operations to write down k=0 on the board:
* Select x=3 and y=2 and write down 4 on the board.
* Select x=4 and y=7 and write down 1 on the board.
* Select x=1 and y=2 and write down 0 on the board.
In the third test case, it is impossible to have the number k = -1 on the board.
Submitted Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO,IOBase
from math import gcd
def solve(n,k,x):
if k in x:
return 'YES'
y = x[1]-x[0]
for i in range(1,n):
y = gcd(y,x[i]-x[0])
if k%y:
return 'NO'
else:
return 'YES'
def main():
for _ in range(int(input())):
n,k = map(int,input().split())
x = list(map(int,input().split()))
print(solve(n,k,x))
#Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == '__main__':
main()
```
No
| 99,675 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n distinct integers x_1,x_2,…,x_n are written on the board. Nezzar can perform the following operation multiple times.
* Select two integers x,y (not necessarily distinct) on the board, and write down 2x-y. Note that you don't remove selected numbers.
Now, Nezzar wonders if it is possible to have his favorite number k on the board after applying above operation multiple times.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
The first line of each test case contains two integers n,k (2 ≤ n ≤ 2 ⋅ 10^5, -10^{18} ≤ k ≤ 10^{18}).
The second line of each test case contains n distinct integers x_1,x_2,…,x_n (-10^{18} ≤ x_i ≤ 10^{18}).
It is guaranteed that the sum of n for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print "YES" on a single line if it is possible to have k on the board. Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
2 1
1 2
3 0
2 3 7
2 -1
31415926 27182818
2 1000000000000000000
1 1000000000000000000
2 -1000000000000000000
-1000000000000000000 123
6 80
-5 -20 13 -14 -2 -11
Output
YES
YES
NO
YES
YES
NO
Note
In the first test case, the number 1 is already on the board.
In the second test case, Nezzar could perform the following operations to write down k=0 on the board:
* Select x=3 and y=2 and write down 4 on the board.
* Select x=4 and y=7 and write down 1 on the board.
* Select x=1 and y=2 and write down 0 on the board.
In the third test case, it is impossible to have the number k = -1 on the board.
Submitted Solution:
```
cases=int(input())
inp=[]
for i in range(cases*2):
inp.append([int(x) for x in input().split(" ")])
print(inp)
for i in range(0,len(inp),2):
k=inp[i][1]
board=inp[i+1]
true=True if k in board else False
even=0
odd=0
for i in board:
if i>=0 and i%2==0:
even+=1
elif i>=0:
odd=1
if true:
print("Yes")
elif even>=1 and odd>=1:
print("Yes")
else:
print("No")
```
No
| 99,676 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n distinct integers x_1,x_2,…,x_n are written on the board. Nezzar can perform the following operation multiple times.
* Select two integers x,y (not necessarily distinct) on the board, and write down 2x-y. Note that you don't remove selected numbers.
Now, Nezzar wonders if it is possible to have his favorite number k on the board after applying above operation multiple times.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
The first line of each test case contains two integers n,k (2 ≤ n ≤ 2 ⋅ 10^5, -10^{18} ≤ k ≤ 10^{18}).
The second line of each test case contains n distinct integers x_1,x_2,…,x_n (-10^{18} ≤ x_i ≤ 10^{18}).
It is guaranteed that the sum of n for all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print "YES" on a single line if it is possible to have k on the board. Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Example
Input
6
2 1
1 2
3 0
2 3 7
2 -1
31415926 27182818
2 1000000000000000000
1 1000000000000000000
2 -1000000000000000000
-1000000000000000000 123
6 80
-5 -20 13 -14 -2 -11
Output
YES
YES
NO
YES
YES
NO
Note
In the first test case, the number 1 is already on the board.
In the second test case, Nezzar could perform the following operations to write down k=0 on the board:
* Select x=3 and y=2 and write down 4 on the board.
* Select x=4 and y=7 and write down 1 on the board.
* Select x=1 and y=2 and write down 0 on the board.
In the third test case, it is impossible to have the number k = -1 on the board.
Submitted Solution:
```
def lcd(x, y):
if y == 0:
return x
return lcd(y, x % y)
t = int(input())
for i in range(t):
n, k = map(int, input().split())
xlist = list(map(int, input().split()))
# print("~~~~~~~~~",n,k,xlist)
mi = min(min(xlist), k-1)
k -= mi
if k == 0:
print("YES")
continue
xlist = [x - mi for x in xlist if x - mi != 0]
if len(xlist) == 0:
print("NO")
continue
lm = xlist[0]
for i in xlist:
lm = lcd(lm, i)
if k % lm == 0:
print("YES")
else:
print("NO")
```
No
| 99,677 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a grid with n rows and m columns. Every cell of the grid should be colored either blue or yellow.
A coloring of the grid is called stupid if every row has exactly one segment of blue cells and every column has exactly one segment of yellow cells.
In other words, every row must have at least one blue cell, and all blue cells in a row must be consecutive. Similarly, every column must have at least one yellow cell, and all yellow cells in a column must be consecutive.
<image> An example of a stupid coloring. <image> Examples of clever colorings. The first coloring is missing a blue cell in the second row, and the second coloring has two yellow segments in the second column.
How many stupid colorings of the grid are there? Two colorings are considered different if there is some cell that is colored differently.
Input
The only line contains two integers n, m (1≤ n, m≤ 2021).
Output
Output a single integer — the number of stupid colorings modulo 998244353.
Examples
Input
2 2
Output
2
Input
4 3
Output
294
Input
2020 2021
Output
50657649
Note
In the first test case, these are the only two stupid 2× 2 colorings.
<image>
Tags: combinatorics, dp, math
Correct Solution:
```
M=998244353;N=4042
try:
import __pypy__
int_add=__pypy__.intop.int_add
int_sub=__pypy__.intop.int_sub
int_mul=__pypy__.intop.int_mul
def make_mod_mul(mod=M):
fmod_inv=1.0/mod
def mod_mul(a,b,c=0):
res=int_sub(
int_add(int_mul(a,b),c),
int_mul(mod,int(fmod_inv*a*b+fmod_inv*c)),
)
if res>=mod:return res-mod
elif res<0:return res+mod
else:return res
return mod_mul
mod_mul=make_mod_mul()
except:
def mod_mul(a,b):return(a*b)%M
def mod_add(a,b):
v=a+b
if v>=M:v-=M
if v<0:v+=M
return v
def mod_sum(a):
v=0
for i in a:v=mod_add(v,i)
return v
f1=[1]
for i in range(N):f1.append(mod_mul(f1[-1],i+1))
f2=[pow(f1[-1],M-2,M)]
for i in range(N):f2.append(mod_mul(f2[-1],N-i))
f2=f2[::-1]
C=lambda a,b:mod_mul(mod_mul(f1[a],f2[b]),f2[a-b])
A=lambda a,b,w:mod_mul(C(a+b,a),C(w+b-a-2,b-1))
def V(h,W,H):
s=p=0
for i in range(W-1):
p=mod_add(p,A(i,H-h,W));s=mod_add(s,mod_mul(p,A(W-2-i,h,W)))
return s
H,W=map(int,input().split())
Y=mod_sum(mod_mul(A(s,h,W),A(W-2-s,H-h,W))for s in range(W-1)for h in range(1,H))
X=mod_add(mod_sum(V(h,W,H)for h in range(1,H)),mod_sum(V(w,H,W)for w in range(1,W)))
print((X+X-Y-Y)%M)
```
| 99,678 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer — the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Tags: hashing, implementation, math
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
arr=list(map(int,input().split()))
d={}
ans=0
tmp=0
for i in range(n):
if arr[i] in d:
tmp+=d[arr[i]]
else:
d[arr[i]]=0
d[arr[i]]+=i+1
ans+=tmp
print(ans)
```
| 99,679 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer — the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Tags: hashing, implementation, math
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
import sys
from io import BytesIO, IOBase
from collections import defaultdict
def main():
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
b = defaultdict(list)
for i, v in enumerate(a):
b[v].append(i)
ans = 0
for i in b:
z = b[i]
c = [0] * (len(z) + 1)
for j in range(len(z) - 1, -1, -1):
c[j] = c[j + 1] + (n - z[j])
for j in range(len(z) - 1):
ans += c[j + 1] * (z[j] + 1)
print(ans)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
```
| 99,680 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer — the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Tags: hashing, implementation, math
Correct Solution:
```
import bisect
import collections
import copy
import functools
import heapq
import itertools
import math
import sys
import string
import random
from typing import List
sys.setrecursionlimit(99999)
for _ in range(int(input())):
n = int(input())
arr = list(map(int,input().split()))
mp= collections.defaultdict(int)
cnt= collections.defaultdict(int)
ans = 0
pre = 0
for i,c in enumerate(arr):
ans+=mp[c]*(n-i)
mp[c]+=(i+1)
cnt[c]+=1
print(ans)
```
| 99,681 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer — the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Tags: hashing, implementation, math
Correct Solution:
```
import math
for t in range(int(input())):
n=int(input())
#n,k=map(int,input().split())
a=list(map(int,input().split()))
dp=[0 for i in range(n+1)]
store={}
for i in range(1,n+1):
dp[i]=dp[i-1]
if a[i-1] in store:
dp[i]+=store[a[i-1]]
else:
store[a[i-1]]=0
store[a[i-1]]+=i
print(sum(dp))
```
| 99,682 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer — the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Tags: hashing, implementation, math
Correct Solution:
```
import sys
input=sys.stdin.readline
from collections import *
a=int(input())
for i in range(a):
s=int(input())
z=list(map(int,input().split()))
al=defaultdict(list)
for i in range(len(z)):
al[z[i]].append(i+1)
total=0
for i in al:
ans=al[i]
t=[0 for i in range(len(ans))]
if(len(ans)<=1):
continue;
for i in range(len(ans)-1,-1,-1):
if(i==len(ans)-1):
continue;
else:
t[i]=t[i+1]+ans[i+1]-1
for i in range(len(ans)):
g1=(len(z)*(len(ans)-(i+1)))-(t[i])
total+=g1*ans[i]
print(total)
```
| 99,683 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer — the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Tags: hashing, implementation, math
Correct Solution:
```
from sys import stdin,stdout
from collections import defaultdict
from itertools import accumulate
nmbr = lambda: int(input())
lst = lambda: list(map(int, input().split()))
for _ in range(nmbr()):
n=nmbr()
a=lst()
g=defaultdict(list)
for i in range(n):
g[a[i]]+=[i]
ans=0
for k,l in g.items():
ps=list(accumulate(l))
c=1
nn=len(ps)
for i in range(nn-1):
ans+=(l[i]+1)*((nn-c)*n-ps[-1]+ps[i])
c+=1
print(ans)
```
| 99,684 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer — the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Tags: hashing, implementation, math
Correct Solution:
```
def fun(n,ls):
dp=[0 for i in range(n)]
dct={i:0 for i in ls}
ans=0
for i in range(n):
if(i>0):
dp[i]=dp[i-1]
if(ls[i] in dct):
dp[i]+=dct.get(ls[i])
dct[ls[i]]+=i+1
ans+=dp[i]
print(ans)
T = int(input())
for i in range(T):
n=int(input())
ls= list(map(int, input().split()))
fun(n,ls)
```
| 99,685 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer — the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Tags: hashing, implementation, math
Correct Solution:
```
#!/usr/bin/env pypy
from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
MOD = 10**9 + 7
# 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")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
from collections import Counter
def main():
for _ in range(int(input())):
n = int(input())
a = [*map(int, input().split())]
s = 0
cnt = Counter()
for i , ai in reversed(list(enumerate(a))):
s += cnt[ai] * (i+1)
cnt[ai] += n-i
print(s)
if __name__ == '__main__':
main()
```
| 99,686 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer — the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Submitted Solution:
```
def fun(n,ls):
dp=[0 for i in range(n)]
dct={i:0 for i in ls}
ans=0
for i in range(n):
if(i>0):
dp[i]=dp[i-1]
if(ls[i] in dct):
dp[i]+=dct.get(ls[i])
dct[ls[i]]+=i+1
ans+=dp[i]
print(ans)
T = int(input())
# T=1
for i in range(T):
# var=input()
n=int(input())
# st=input()
# ks= list(map(int, input().split()))
# ms= list(map(int, input().split()))
# n=int(input())
ls= list(map(int, input().split()))
fun(n,ls)
```
Yes
| 99,687 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer — the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Submitted Solution:
```
from collections import defaultdict
import sys
input = sys.stdin.readline
def solve(n,a):
ctr = defaultdict(int)
ans = 0
for i in range(n):
ans += (n-i)*ctr[a[i]]
ctr[a[i]] += i+1
print(ans)
return
for nt in range(int(input())):
n = int(input())
a = list(map(int,input().split()))
solve(n,a)
```
Yes
| 99,688 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer — the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Submitted Solution:
```
from collections import defaultdict, deque
from heapq import heappush, heappop
from math import inf
ri = lambda : map(int, input().split())
def solve():
n = int(input())
A = list(ri())
indexes = defaultdict(list)
for i in range(n):
indexes[A[i]].append(i)
ans = 0
for val in indexes:
pref = 0
for i in indexes[val]:
ans += pref * (n - i)
pref += (i + 1)
print(ans)
t = 1
t = int(input())
while t:
t -= 1
solve()
```
Yes
| 99,689 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer — the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
d = {}
for i in range(n):
if a[i] not in d:
d[a[i]] = [i]
else:
d[a[i]].append(i)
ans = 0
for el in d:
if len(d[el]) > 1:
sp = [n - d[el][-1]]
for i in range(2, len(d[el])):
sp.append(sp[-1] + (n - d[el][-i]))
for i in range(len(d[el])-1):
ans += sp[-(i+1)]*(d[el][i]+1)
print(ans)
```
Yes
| 99,690 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer — the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Submitted Solution:
```
def cost(s):
retval = 0
cnt = dict()
for x in s:
cnt[x] = cnt.get(x, 0) + 1
for (num, count) in cnt.items():
retval += (count-1)*count//2
return retval
def solve(s):
retval = 0
i = 0
j = 2
while j < len(s):
retval += cost(s[i:j])
j += 1
while i < j:
retval += cost(s[i:j])
i += 1
return retval
count = int(input())
for _ in range(count):
input()
print(solve(list(map(int, input().split()))))
```
No
| 99,691 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer — the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Submitted Solution:
```
for _ in range(int(input())):
l=int(input())
loi = list(map(int,input().split()))
ans=0
for i in range(1,len(loi)):
temp=0
for j in range(0,i):
if loi[j]==loi[i]:
temp+=(j+1)
ans+=temp
print(ans)
```
No
| 99,692 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer — the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Submitted Solution:
```
import sys,os,io
import math,bisect,operator,itertools
inf,mod = float('inf'),10**9+7
# sys.setrecursionlimit(10 ** 6)
from itertools import groupby,accumulate
from heapq import heapify,heappop,heappush
from collections import deque,Counter,defaultdict
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
Neo = lambda : list(map(int,input().split()))
test, = Neo()
for _ in range(test):
n, = Neo()
A = Neo()
C = Counter(A)
t = 0
Ans = 0
for i in C:
t += max(0,C[i]*(C[i]-1)//2)
c = t
D = C.copy()
for i in A[::-1]:
Ans += t
t -= max(0,C[i]*(C[i]-1)//2)
C[i] -= 1
t += max(0,C[i]*(C[i]-1)//2)
t = c
C = D
for i in A:
Ans += t
t -= max(0,C[i]*(C[i]-1)//2)
C[i] -= 1
t += max(0,C[i]*(C[i]-1)//2)
print(Ans-c)
```
No
| 99,693 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i < j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).
You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a.
A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^5). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a single integer — the sum of the weight of all subsegments of a.
Example
Input
2
4
1 2 1 1
4
1 2 3 4
Output
6
0
Note
* In test case 1, all possible subsegments of sequence [1, 2, 1, 1] having size more than 1 are:
1. [1, 2] having 0 valid unordered pairs;
2. [2, 1] having 0 valid unordered pairs;
3. [1, 1] having 1 valid unordered pair;
4. [1, 2, 1] having 1 valid unordered pairs;
5. [2, 1, 1] having 1 valid unordered pair;
6. [1, 2, 1, 1] having 3 valid unordered pairs.
Answer is 6.
* In test case 2, all elements of the sequence are distinct. So, there is no valid unordered pair with the same value for any subarray. Answer is 0.
Submitted Solution:
```
from sys import stdin,stdout
from heapq import heapify,heappush,heappop,heappushpop
from collections import defaultdict as dd, deque as dq,Counter as C
from bisect import bisect_left as bl ,bisect_right as br
from itertools import combinations as cmb,permutations as pmb
from math import factorial as f ,ceil,gcd,sqrt,log,inf
mi = lambda : map(int,input().split())
ii = lambda: int(input())
li = lambda : list(map(int,input().split()))
mati = lambda r : [ li() for _ in range(r)]
lcm = lambda a,b : (a*b)//gcd(a,b)
def solve():
n=ii()
arr=li()
d={}
for x in range(n):
try:
d[arr[x]].append(x+1)
except:
d[arr[x]]=[x+1]
#print(d)
ans=0
for x in d:
p=len(d[x])
temp=[0 for x in range(p)]
temp[0]=d[x][0]
for y in range(1,p):
temp[y]=temp[y-1]+d[x][y]
for y in range(p-1,0,-1):
ans+=(n-d[x][y])*temp[y-1]+1
print(ans*2)
for _ in range(ii()):
solve()
```
No
| 99,694 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus has n markers and m marker caps. Each marker is described by two numbers: xi is the color and yi is the diameter. Correspondingly, each cap is described by two numbers: aj is the color and bj is the diameter. Cap (aj, bj) can close marker (xi, yi) only if their diameters match, that is, bj = yi. Besides, a marker is considered to be beautifully closed, if the cap color and the marker color match, that is, aj = xi.
Find the way to close the maximum number of markers. If there are several such ways, then choose the one that has the maximum number of beautifully closed markers.
Input
The first input line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the number of markers and the number of caps, correspondingly.
Next n lines describe the markers. The i-th line contains two space-separated integers xi, yi (1 ≤ xi, yi ≤ 1000) — the i-th marker's color and diameter, correspondingly.
Next m lines describe the caps. The j-th line contains two space-separated integers aj, bj (1 ≤ aj, bj ≤ 1000) — the color and diameter of the j-th cap, correspondingly.
Output
Print two space-separated integers u, v, where u is the number of closed markers and v is the number of beautifully closed markers in the sought optimal way. Remember that you have to find the way to close the maximum number of markers, and if there are several such ways, you should choose the one where the number of beautifully closed markers is maximum.
Examples
Input
3 4
1 2
3 4
2 4
5 4
2 4
1 1
1 2
Output
3 2
Input
2 2
1 2
2 1
3 4
5 1
Output
1 0
Note
In the first test sample the first marker should be closed by the fourth cap, the second marker should be closed by the first cap and the third marker should be closed by the second cap. Thus, three markers will be closed, and two of them will be beautifully closed — the first and the third markers.
Tags: *special, greedy, sortings
Correct Solution:
```
from functools import cmp_to_key
def main():
n, m = map(int, input().split())
markers = []
caps = []
for _ in range(n):
x, y = map(int, input().split())
markers.append((x, y))
for _ in range(m):
x, y = map(int, input().split())
caps.append((x, y))
marker_sizes = dict()
cap_sizes = dict()
marker_dict = dict()
cap_dict = dict()
for m in markers:
if marker_sizes.get(m[1]):
marker_sizes[m[1]] += 1
else:
marker_sizes[m[1]] = 1
if marker_dict.get(m):
marker_dict[m]+=1
else:
marker_dict[m]=1
for c in caps:
if cap_sizes.get(c[1]):
cap_sizes[c[1]] += 1
else:
cap_sizes[c[1]] = 1
if cap_dict.get(c):
cap_dict[c]+=1
else:
cap_dict[c]=1
ans1 = 0
for s, c1 in marker_sizes.items():
c2 = cap_sizes.get(s)
if c2:
ans1 += min(c1, c2)
ans2 = 0
for val, freq in marker_dict.items():
x = cap_dict.get(val)
if x:
ans2+=min(freq, x)
return '{} {}'.format(ans1, ans2)
if __name__ == '__main__':
print(main())
```
| 99,695 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus has n markers and m marker caps. Each marker is described by two numbers: xi is the color and yi is the diameter. Correspondingly, each cap is described by two numbers: aj is the color and bj is the diameter. Cap (aj, bj) can close marker (xi, yi) only if their diameters match, that is, bj = yi. Besides, a marker is considered to be beautifully closed, if the cap color and the marker color match, that is, aj = xi.
Find the way to close the maximum number of markers. If there are several such ways, then choose the one that has the maximum number of beautifully closed markers.
Input
The first input line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the number of markers and the number of caps, correspondingly.
Next n lines describe the markers. The i-th line contains two space-separated integers xi, yi (1 ≤ xi, yi ≤ 1000) — the i-th marker's color and diameter, correspondingly.
Next m lines describe the caps. The j-th line contains two space-separated integers aj, bj (1 ≤ aj, bj ≤ 1000) — the color and diameter of the j-th cap, correspondingly.
Output
Print two space-separated integers u, v, where u is the number of closed markers and v is the number of beautifully closed markers in the sought optimal way. Remember that you have to find the way to close the maximum number of markers, and if there are several such ways, you should choose the one where the number of beautifully closed markers is maximum.
Examples
Input
3 4
1 2
3 4
2 4
5 4
2 4
1 1
1 2
Output
3 2
Input
2 2
1 2
2 1
3 4
5 1
Output
1 0
Note
In the first test sample the first marker should be closed by the fourth cap, the second marker should be closed by the first cap and the third marker should be closed by the second cap. Thus, three markers will be closed, and two of them will be beautifully closed — the first and the third markers.
Tags: *special, greedy, sortings
Correct Solution:
```
import sys
import time
import math
from collections import defaultdict
from functools import lru_cache
INF = 10 ** 18 + 3
EPS = 1e-10
MAX_CACHE = 10 ** 9
def time_it(function, output=sys.stderr):
def wrapped(*args, **kwargs):
start = time.time()
res = function(*args, **kwargs)
elapsed_time = time.time() - start
print('"%s" took %f ms' % (function.__name__, elapsed_time * 1000),
file=output)
return res
return wrapped
@time_it
def main():
n, m = map(int, input().split())
closed_count = 0
nice_closed_count = 0
markers = defaultdict(lambda: defaultdict(lambda: 0))
caps = defaultdict(lambda: defaultdict(lambda: 0))
for _ in range(n):
color, size = map(int, input().split())
markers[size][color] += 1
for _ in range(m):
color, size = map(int, input().split())
if markers[size][color] > 0:
markers[size][color] -= 1
closed_count += 1
nice_closed_count += 1
else:
caps[size][color] += 1
for size in caps.keys():
closed_count += min(sum(markers[size].values()), sum(caps[size].values()))
print(closed_count, nice_closed_count)
def set_input(file):
global input
input = lambda: file.readline().strip()
def set_output(file):
global print
local_print = print
def print(*args, **kwargs):
kwargs["file"] = kwargs.get("file", file)
return local_print(*args, **kwargs)
if __name__ == '__main__':
set_input(open("input.txt", "r") if "MINE" in sys.argv else sys.stdin)
set_output(sys.stdout)
main()
```
| 99,696 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus has n markers and m marker caps. Each marker is described by two numbers: xi is the color and yi is the diameter. Correspondingly, each cap is described by two numbers: aj is the color and bj is the diameter. Cap (aj, bj) can close marker (xi, yi) only if their diameters match, that is, bj = yi. Besides, a marker is considered to be beautifully closed, if the cap color and the marker color match, that is, aj = xi.
Find the way to close the maximum number of markers. If there are several such ways, then choose the one that has the maximum number of beautifully closed markers.
Input
The first input line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the number of markers and the number of caps, correspondingly.
Next n lines describe the markers. The i-th line contains two space-separated integers xi, yi (1 ≤ xi, yi ≤ 1000) — the i-th marker's color and diameter, correspondingly.
Next m lines describe the caps. The j-th line contains two space-separated integers aj, bj (1 ≤ aj, bj ≤ 1000) — the color and diameter of the j-th cap, correspondingly.
Output
Print two space-separated integers u, v, where u is the number of closed markers and v is the number of beautifully closed markers in the sought optimal way. Remember that you have to find the way to close the maximum number of markers, and if there are several such ways, you should choose the one where the number of beautifully closed markers is maximum.
Examples
Input
3 4
1 2
3 4
2 4
5 4
2 4
1 1
1 2
Output
3 2
Input
2 2
1 2
2 1
3 4
5 1
Output
1 0
Note
In the first test sample the first marker should be closed by the fourth cap, the second marker should be closed by the first cap and the third marker should be closed by the second cap. Thus, three markers will be closed, and two of them will be beautifully closed — the first and the third markers.
Tags: *special, greedy, sortings
Correct Solution:
```
n, m = map(int, input().split())
x, y, u, v = {}, {}, 0, 0
for i in range(n):
a, b = input().split()
if b in x: x[b][a] = x[b].get(a, 0) + 1
else: x[b] = {a: 1}
for i in range(m):
a, b = input().split()
if b in y: y[b][a] = y[b].get(a, 0) + 1
else: y[b] = {a: 1}
for b in x.keys() & y.keys():
u += min(sum(x[b].values()), sum(y[b].values()))
v += sum(min(x[b][a], y[b][a]) for a in x[b].keys() & y[b].keys())
print(u, v)
# Made By Mostafa_Khaled
```
| 99,697 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus has n markers and m marker caps. Each marker is described by two numbers: xi is the color and yi is the diameter. Correspondingly, each cap is described by two numbers: aj is the color and bj is the diameter. Cap (aj, bj) can close marker (xi, yi) only if their diameters match, that is, bj = yi. Besides, a marker is considered to be beautifully closed, if the cap color and the marker color match, that is, aj = xi.
Find the way to close the maximum number of markers. If there are several such ways, then choose the one that has the maximum number of beautifully closed markers.
Input
The first input line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the number of markers and the number of caps, correspondingly.
Next n lines describe the markers. The i-th line contains two space-separated integers xi, yi (1 ≤ xi, yi ≤ 1000) — the i-th marker's color and diameter, correspondingly.
Next m lines describe the caps. The j-th line contains two space-separated integers aj, bj (1 ≤ aj, bj ≤ 1000) — the color and diameter of the j-th cap, correspondingly.
Output
Print two space-separated integers u, v, where u is the number of closed markers and v is the number of beautifully closed markers in the sought optimal way. Remember that you have to find the way to close the maximum number of markers, and if there are several such ways, you should choose the one where the number of beautifully closed markers is maximum.
Examples
Input
3 4
1 2
3 4
2 4
5 4
2 4
1 1
1 2
Output
3 2
Input
2 2
1 2
2 1
3 4
5 1
Output
1 0
Note
In the first test sample the first marker should be closed by the fourth cap, the second marker should be closed by the first cap and the third marker should be closed by the second cap. Thus, three markers will be closed, and two of them will be beautifully closed — the first and the third markers.
Tags: *special, greedy, sortings
Correct Solution:
```
n,m=map(int,input().split())
m1={}
m2={}
c1={}
c2={}
for i in range(n):
x,y=(map(int,input().split()))
m1[y]=m1.get(y,0)+1
m2[(x,y)]=m2.get((x,y),0)+1
for i in range(m):
x,y=(map(int,input().split()))
c1[y]=c1.get(y,0)+1
c2[(x,y)]=c2.get((x,y),0)+1
r1=0
r2=0
for i in m1.keys():
if i in c1.keys():
t1=m1[i]
t2=c1[i]
r1=r1+(min(t1,t2))
for i in m2.keys():
if i in c2.keys():
t1=m2[i]
t2=c2[i]
r2=r2+(min(t1,t2))
print(r1,r2)
```
| 99,698 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus has n markers and m marker caps. Each marker is described by two numbers: xi is the color and yi is the diameter. Correspondingly, each cap is described by two numbers: aj is the color and bj is the diameter. Cap (aj, bj) can close marker (xi, yi) only if their diameters match, that is, bj = yi. Besides, a marker is considered to be beautifully closed, if the cap color and the marker color match, that is, aj = xi.
Find the way to close the maximum number of markers. If there are several such ways, then choose the one that has the maximum number of beautifully closed markers.
Input
The first input line contains two space-separated integers n and m (1 ≤ n, m ≤ 105) — the number of markers and the number of caps, correspondingly.
Next n lines describe the markers. The i-th line contains two space-separated integers xi, yi (1 ≤ xi, yi ≤ 1000) — the i-th marker's color and diameter, correspondingly.
Next m lines describe the caps. The j-th line contains two space-separated integers aj, bj (1 ≤ aj, bj ≤ 1000) — the color and diameter of the j-th cap, correspondingly.
Output
Print two space-separated integers u, v, where u is the number of closed markers and v is the number of beautifully closed markers in the sought optimal way. Remember that you have to find the way to close the maximum number of markers, and if there are several such ways, you should choose the one where the number of beautifully closed markers is maximum.
Examples
Input
3 4
1 2
3 4
2 4
5 4
2 4
1 1
1 2
Output
3 2
Input
2 2
1 2
2 1
3 4
5 1
Output
1 0
Note
In the first test sample the first marker should be closed by the fourth cap, the second marker should be closed by the first cap and the third marker should be closed by the second cap. Thus, three markers will be closed, and two of them will be beautifully closed — the first and the third markers.
Tags: *special, greedy, sortings
Correct Solution:
```
# n=int(input())
# n,k=map(int,input().split())
# arr=list(map(int,input().split()))
#ls=list(map(int,input().split()))
#for i in range(m):
# for _ in range(int(input())):
#from collections import Counter
#from fractions import Fraction
#s=iter(input())
#from collections import deque
from collections import Counter
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")
##########################################################
from collections import defaultdict
m=defaultdict(list)
c=defaultdict(list)
n,k=map(int, input().split())
for i in range(n):
u,v=map(int,input().split())
m[v].append(u)
for i in range(k):
u, v = map(int, input().split())
c[v].append(u)
#print(m)
#print(c)
t=0
b=0
for j in sorted(m.keys()):
if j in c:
t += min(len(c[j]), len(m[j]))
var = Counter(c[j])
ans=Counter(m[j])
for k in (ans.keys()):
if k in var:
b+=min(var[k],ans[k])
print(t ,b)
```
| 99,699 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.