text stringlengths 216 39.6k | conversation_id int64 219 108k | embedding list | cluster int64 11 11 |
|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Your program fails again. This time it gets "Wrong answer on test 233"
.
This is the easier version of the problem. In this version 1 ≤ n ≤ 2000. You can hack this problem only if you solve and lock both problems.
The problem is about a test containing n one-choice-questions. Each of the questions contains k options, and only one of them is correct. The answer to the i-th question is h_{i}, and if your answer of the question i is h_{i}, you earn 1 point, otherwise, you earn 0 points for this question. The values h_1, h_2, ..., h_n are known to you in this problem.
However, you have a mistake in your program. It moves the answer clockwise! Consider all the n answers are written in a circle. Due to the mistake in your program, they are shifted by one cyclically.
Formally, the mistake moves the answer for the question i to the question i mod n + 1. So it moves the answer for the question 1 to question 2, the answer for the question 2 to the question 3, ..., the answer for the question n to the question 1.
We call all the n answers together an answer suit. There are k^n possible answer suits in total.
You're wondering, how many answer suits satisfy the following condition: after moving clockwise by 1, the total number of points of the new answer suit is strictly larger than the number of points of the old one. You need to find the answer modulo 998 244 353.
For example, if n = 5, and your answer suit is a=[1,2,3,4,5], it will submitted as a'=[5,1,2,3,4] because of a mistake. If the correct answer suit is h=[5,2,2,3,4], the answer suit a earns 1 point and the answer suite a' earns 4 points. Since 4 > 1, the answer suit a=[1,2,3,4,5] should be counted.
Input
The first line contains two integers n, k (1 ≤ n ≤ 2000, 1 ≤ k ≤ 10^9) — the number of questions and the number of possible answers to each question.
The following line contains n integers h_1, h_2, ..., h_n, (1 ≤ h_{i} ≤ k) — answers to the questions.
Output
Output one integer: the number of answers suits satisfying the given condition, modulo 998 244 353.
Examples
Input
3 3
1 3 1
Output
9
Input
5 5
1 1 4 2 2
Output
1000
Note
For the first example, valid answer suits are [2,1,1], [2,1,2], [2,1,3], [3,1,1], [3,1,2], [3,1,3], [3,2,1], [3,2,2], [3,2,3].
Tags: dp
Correct Solution:
```
M=998244353
class Factorial:
def __init__(self,n):
self.f=f=[0]*(n+1)
f[0]=b=1
for i in range(1,n+1):f[i]=b=b*i%M
self.inv=inv=[0]*(n+1)
inv[n]=b=pow(self.f[n],M-2,M)
for i in range(n,0,-1):inv[i-1]=b=b*i%M
def factorial(self,i):
return self.f[i]
def ifactorial(self,i):
return self.inv[i]
def comb(self,n,k):
if n>=k:return self.f[n]*self.inv[n-k]*self.inv[k]%M
else:return 0
def main():
n,k,*h=map(int,open(0).read().split())
m=sum(i!=j for i,j in zip(h,h[1:]+h[:1]))
comb=Factorial(m).comb
print((pow(k,m,M)-sum(comb(m,i)*comb(m-i,i)*pow(k-2,m-i-i,M)for i in range(m//2+1)))*pow(k,n-m,M)*pow(2,M-2,M)%M)
main()
```
| 69,946 | [
0.71435546875,
0.1090087890625,
-0.276123046875,
0.181640625,
-0.673828125,
-0.38525390625,
0.11553955078125,
0.06756591796875,
0.2509765625,
0.931640625,
0.71826171875,
0.129150390625,
0.465576171875,
-0.7373046875,
-0.341064453125,
-0.11676025390625,
-0.56640625,
-0.677734375,
... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your program fails again. This time it gets "Wrong answer on test 233"
.
This is the easier version of the problem. In this version 1 ≤ n ≤ 2000. You can hack this problem only if you solve and lock both problems.
The problem is about a test containing n one-choice-questions. Each of the questions contains k options, and only one of them is correct. The answer to the i-th question is h_{i}, and if your answer of the question i is h_{i}, you earn 1 point, otherwise, you earn 0 points for this question. The values h_1, h_2, ..., h_n are known to you in this problem.
However, you have a mistake in your program. It moves the answer clockwise! Consider all the n answers are written in a circle. Due to the mistake in your program, they are shifted by one cyclically.
Formally, the mistake moves the answer for the question i to the question i mod n + 1. So it moves the answer for the question 1 to question 2, the answer for the question 2 to the question 3, ..., the answer for the question n to the question 1.
We call all the n answers together an answer suit. There are k^n possible answer suits in total.
You're wondering, how many answer suits satisfy the following condition: after moving clockwise by 1, the total number of points of the new answer suit is strictly larger than the number of points of the old one. You need to find the answer modulo 998 244 353.
For example, if n = 5, and your answer suit is a=[1,2,3,4,5], it will submitted as a'=[5,1,2,3,4] because of a mistake. If the correct answer suit is h=[5,2,2,3,4], the answer suit a earns 1 point and the answer suite a' earns 4 points. Since 4 > 1, the answer suit a=[1,2,3,4,5] should be counted.
Input
The first line contains two integers n, k (1 ≤ n ≤ 2000, 1 ≤ k ≤ 10^9) — the number of questions and the number of possible answers to each question.
The following line contains n integers h_1, h_2, ..., h_n, (1 ≤ h_{i} ≤ k) — answers to the questions.
Output
Output one integer: the number of answers suits satisfying the given condition, modulo 998 244 353.
Examples
Input
3 3
1 3 1
Output
9
Input
5 5
1 1 4 2 2
Output
1000
Note
For the first example, valid answer suits are [2,1,1], [2,1,2], [2,1,3], [3,1,1], [3,1,2], [3,1,3], [3,2,1], [3,2,2], [3,2,3].
Tags: dp
Correct Solution:
```
# Anton Timofeev
import sys
MOD = 998244353
n, k = map(int, sys.stdin.readline().split())
h = list(map(int, sys.stdin.readline().split()))
if k == 1:
print(0)
sys.exit()
dp = [[0] * (2 * n + 2) for _ in range(2)]
dp[0][0] = 1
for i in range(1, n + 1):
m = i & 1
for diff in range(-i, i + 1):
if h[(i - 1) % n] != h[i % n]:
dp[m][diff] = dp[m ^ 1][diff - 1]
dp[m][diff] += dp[m ^ 1][diff + 1]
dp[m][diff] += (dp[m ^ 1][diff] * (k - 2))
dp[m][diff] %= MOD
else:
dp[m][diff] = dp[m ^ 1][diff] * k % MOD
# print(f"i = {i}")
# for diff in range(-i, i + 1):
# print(f"{diff} -> {dp[m][diff]}")
print(sum(dp[n & 1][1:n + 1]) % MOD)
```
| 69,947 | [
0.71435546875,
0.1090087890625,
-0.276123046875,
0.181640625,
-0.673828125,
-0.38525390625,
0.11553955078125,
0.06756591796875,
0.2509765625,
0.931640625,
0.71826171875,
0.129150390625,
0.465576171875,
-0.7373046875,
-0.341064453125,
-0.11676025390625,
-0.56640625,
-0.677734375,
... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your program fails again. This time it gets "Wrong answer on test 233"
.
This is the easier version of the problem. In this version 1 ≤ n ≤ 2000. You can hack this problem only if you solve and lock both problems.
The problem is about a test containing n one-choice-questions. Each of the questions contains k options, and only one of them is correct. The answer to the i-th question is h_{i}, and if your answer of the question i is h_{i}, you earn 1 point, otherwise, you earn 0 points for this question. The values h_1, h_2, ..., h_n are known to you in this problem.
However, you have a mistake in your program. It moves the answer clockwise! Consider all the n answers are written in a circle. Due to the mistake in your program, they are shifted by one cyclically.
Formally, the mistake moves the answer for the question i to the question i mod n + 1. So it moves the answer for the question 1 to question 2, the answer for the question 2 to the question 3, ..., the answer for the question n to the question 1.
We call all the n answers together an answer suit. There are k^n possible answer suits in total.
You're wondering, how many answer suits satisfy the following condition: after moving clockwise by 1, the total number of points of the new answer suit is strictly larger than the number of points of the old one. You need to find the answer modulo 998 244 353.
For example, if n = 5, and your answer suit is a=[1,2,3,4,5], it will submitted as a'=[5,1,2,3,4] because of a mistake. If the correct answer suit is h=[5,2,2,3,4], the answer suit a earns 1 point and the answer suite a' earns 4 points. Since 4 > 1, the answer suit a=[1,2,3,4,5] should be counted.
Input
The first line contains two integers n, k (1 ≤ n ≤ 2000, 1 ≤ k ≤ 10^9) — the number of questions and the number of possible answers to each question.
The following line contains n integers h_1, h_2, ..., h_n, (1 ≤ h_{i} ≤ k) — answers to the questions.
Output
Output one integer: the number of answers suits satisfying the given condition, modulo 998 244 353.
Examples
Input
3 3
1 3 1
Output
9
Input
5 5
1 1 4 2 2
Output
1000
Note
For the first example, valid answer suits are [2,1,1], [2,1,2], [2,1,3], [3,1,1], [3,1,2], [3,1,3], [3,2,1], [3,2,2], [3,2,3].
Tags: dp
Correct Solution:
```
from bisect import *
from collections import *
from math import gcd,ceil,sqrt,floor,inf
from heapq import *
from itertools import *
from operator import add,mul,sub,xor,truediv,floordiv
from functools import *
#------------------------------------------------------------------------
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")
#------------------------------------------------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
#------------------------------------------------------------------------
farr=[1]
ifa=[]
def fact(x,mod=0):
if mod:
while x>=len(farr):
farr.append(farr[-1]*len(farr)%mod)
else:
while x>=len(farr):
farr.append(farr[-1]*len(farr))
return farr[x]
def ifact(x,mod):
global ifa
ifa.append(pow(farr[-1],mod-2,mod))
for i in range(x,0,-1):
ifa.append(ifa[-1]*i%mod)
ifa=ifa[::-1]
def per(i,j,mod=0):
if i<j: return 0
if not mod:
return fact(i)//fact(i-j)
return farr[i]*ifa[i-j]%mod
def com(i,j,mod=0):
if i<j: return 0
if not mod:
return per(i,j)//fact(j)
return per(i,j,mod)*ifa[j]%mod
def catalan(n):
return com(2*n,n)//(n+1)
def linc(f,t,l,r):
while l<r:
mid=(l+r)//2
if t>f(mid):
l=mid+1
else:
r=mid
return l
def rinc(f,t,l,r):
while l<r:
mid=(l+r+1)//2
if t<f(mid):
r=mid-1
else:
l=mid
return l
def ldec(f,t,l,r):
while l<r:
mid=(l+r)//2
if t<f(mid):
l=mid+1
else:
r=mid
return l
def rdec(f,t,l,r):
while l<r:
mid=(l+r+1)//2
if t>f(mid):
r=mid-1
else:
l=mid
return l
def isprime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True
def binfun(x):
c=0
for w in arr:
c+=ceil(w/x)
return c
def lowbit(n):
return n&-n
def inverse(a,m):
a%=m
if a<=1: return a
return ((1-inverse(m,a)*m)//a)%m
class BIT:
def __init__(self,arr):
self.arr=arr
self.n=len(arr)-1
def update(self,x,v):
while x<=self.n:
self.arr[x]+=v
x+=x&-x
def query(self,x):
ans=0
while x:
ans+=self.arr[x]
x&=x-1
return ans
class smt:
def __init__(self,l,r,arr):
self.l=l
self.r=r
self.value=(1<<31)-1 if l<r else arr[l]
mid=(l+r)//2
if(l<r):
self.left=smt(l,mid,arr)
self.right=smt(mid+1,r,arr)
self.value&=self.left.value&self.right.value
#print(l,r,self.value)
def setvalue(self,x,val):
if(self.l==self.r):
self.value=val
return
mid=(self.l+self.r)//2
if(x<=mid):
self.left.setvalue(x,val)
else:
self.right.setvalue(x,val)
self.value=self.left.value&self.right.value
def ask(self,l,r):
if(l<=self.l and r>=self.r):
return self.value
val=(1<<31)-1
mid=(self.l+self.r)//2
if(l<=mid):
val&=self.left.ask(l,r)
if(r>mid):
val&=self.right.ask(l,r)
return val
class DSU:#容量+路径压缩
def __init__(self,n):
self.c=[-1]*n
def same(self,x,y):
return self.find(x)==self.find(y)
def find(self,x):
if self.c[x]<0:
return x
self.c[x]=self.find(self.c[x])
return self.c[x]
def union(self,u,v):
u,v=self.find(u),self.find(v)
if u==v:
return False
if self.c[u]<self.c[v]:
u,v=v,u
self.c[u]+=self.c[v]
self.c[v]=u
return True
def size(self,x): return -self.c[self.find(x)]
class UFS:#秩+路径
def __init__(self,n):
self.parent=[i for i in range(n)]
self.ranks=[0]*n
def find(self,x):
if x!=self.parent[x]:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def union(self,u,v):
pu,pv=self.find(u),self.find(v)
if pu==pv:
return False
if self.ranks[pu]>=self.ranks[pv]:
self.parent[pv]=pu
if self.ranks[pv]==self.ranks[pu]:
self.ranks[pu]+=1
else:
self.parent[pu]=pv
def Prime(n):
c=0
prime=[]
flag=[0]*(n+1)
for i in range(2,n+1):
if not flag[i]:
prime.append(i)
c+=1
for j in range(c):
if i*prime[j]>n: break
flag[i*prime[j]]=prime[j]
if i%prime[j]==0: break
return prime
def dij(s,graph):
d={}
d[s]=0
heap=[(0,s)]
seen=set()
while heap:
dis,u=heappop(heap)
if u in seen:
continue
for v in graph[u]:
if v not in d or d[v]>d[u]+graph[u][v]:
d[v]=d[u]+graph[u][v]
heappush(heap,(d[v],v))
return d
def GP(it): return [(ch,len(list(g))) for ch,g in groupby(it)]
class DLN:
def __init__(self,val):
self.val=val
self.pre=None
self.next=None
t=1
for i in range(t):
mod=998244353
n,k=RL()
h=RLL()
res=GP(h)
c=0
for ch,cnt in res:
c+=cnt-1
n=len(res)
if res[-1][0]==res[0][0]:
c+=1
n-=1
ans=pow(k,c,mod)
tmp=pow(k,n,mod)
fact(n,mod)
ifact(n,mod)
p=[1]
for i in range(n):
p.append(p[-1]*(k-2)%mod)
for x in range(n//2+1):
tmp=(tmp-p[n-2*x]*fact(n,mod)%mod*ifa[x]%mod*ifa[x]%mod*ifa[n-2*x]%mod)%mod
ans=ans*tmp%mod*pow(2,mod-2,mod)%mod
print(ans)
```
| 69,948 | [
0.71435546875,
0.1090087890625,
-0.276123046875,
0.181640625,
-0.673828125,
-0.38525390625,
0.11553955078125,
0.06756591796875,
0.2509765625,
0.931640625,
0.71826171875,
0.129150390625,
0.465576171875,
-0.7373046875,
-0.341064453125,
-0.11676025390625,
-0.56640625,
-0.677734375,
... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your program fails again. This time it gets "Wrong answer on test 233"
.
This is the easier version of the problem. In this version 1 ≤ n ≤ 2000. You can hack this problem only if you solve and lock both problems.
The problem is about a test containing n one-choice-questions. Each of the questions contains k options, and only one of them is correct. The answer to the i-th question is h_{i}, and if your answer of the question i is h_{i}, you earn 1 point, otherwise, you earn 0 points for this question. The values h_1, h_2, ..., h_n are known to you in this problem.
However, you have a mistake in your program. It moves the answer clockwise! Consider all the n answers are written in a circle. Due to the mistake in your program, they are shifted by one cyclically.
Formally, the mistake moves the answer for the question i to the question i mod n + 1. So it moves the answer for the question 1 to question 2, the answer for the question 2 to the question 3, ..., the answer for the question n to the question 1.
We call all the n answers together an answer suit. There are k^n possible answer suits in total.
You're wondering, how many answer suits satisfy the following condition: after moving clockwise by 1, the total number of points of the new answer suit is strictly larger than the number of points of the old one. You need to find the answer modulo 998 244 353.
For example, if n = 5, and your answer suit is a=[1,2,3,4,5], it will submitted as a'=[5,1,2,3,4] because of a mistake. If the correct answer suit is h=[5,2,2,3,4], the answer suit a earns 1 point and the answer suite a' earns 4 points. Since 4 > 1, the answer suit a=[1,2,3,4,5] should be counted.
Input
The first line contains two integers n, k (1 ≤ n ≤ 2000, 1 ≤ k ≤ 10^9) — the number of questions and the number of possible answers to each question.
The following line contains n integers h_1, h_2, ..., h_n, (1 ≤ h_{i} ≤ k) — answers to the questions.
Output
Output one integer: the number of answers suits satisfying the given condition, modulo 998 244 353.
Examples
Input
3 3
1 3 1
Output
9
Input
5 5
1 1 4 2 2
Output
1000
Note
For the first example, valid answer suits are [2,1,1], [2,1,2], [2,1,3], [3,1,1], [3,1,2], [3,1,3], [3,2,1], [3,2,2], [3,2,3].
Tags: dp
Correct Solution:
```
M=998244353
class Factorial:
def __init__(self,n):
self.f=f=[0]*(n+1)
f[0]=b=1
for i in range(1,n+1):f[i]=b=b*i%M
self.inv=inv=[0]*(n+1)
inv[n]=b=pow(self.f[n],M-2,M)
for i in range(n,0,-1):inv[i-1]=b=b*i%M
def factorial(self,i):
return self.f[i]
def ifactorial(self,i):
return self.inv[i]
def comb(self,n,k):
if n>=k:return self.f[n]*self.inv[n-k]*self.inv[k]%M
else:return 0
def main():
n,k,*h=map(int,open(0).read().split())
m=sum(i!=j for i,j in zip(h,h[1:]+h[:1]))
comb=Factorial(m).comb
print((pow(k,m)-sum(comb(m,i)*comb(m-i,i)*pow(k-2,m-i-i,M)for i in range(m//2+1)))*pow(k,n-m,M)*pow(2,M-2,M)%M)
main()
```
| 69,949 | [
0.71435546875,
0.1090087890625,
-0.276123046875,
0.181640625,
-0.673828125,
-0.38525390625,
0.11553955078125,
0.06756591796875,
0.2509765625,
0.931640625,
0.71826171875,
0.129150390625,
0.465576171875,
-0.7373046875,
-0.341064453125,
-0.11676025390625,
-0.56640625,
-0.677734375,
... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your program fails again. This time it gets "Wrong answer on test 233"
.
This is the easier version of the problem. In this version 1 ≤ n ≤ 2000. You can hack this problem only if you solve and lock both problems.
The problem is about a test containing n one-choice-questions. Each of the questions contains k options, and only one of them is correct. The answer to the i-th question is h_{i}, and if your answer of the question i is h_{i}, you earn 1 point, otherwise, you earn 0 points for this question. The values h_1, h_2, ..., h_n are known to you in this problem.
However, you have a mistake in your program. It moves the answer clockwise! Consider all the n answers are written in a circle. Due to the mistake in your program, they are shifted by one cyclically.
Formally, the mistake moves the answer for the question i to the question i mod n + 1. So it moves the answer for the question 1 to question 2, the answer for the question 2 to the question 3, ..., the answer for the question n to the question 1.
We call all the n answers together an answer suit. There are k^n possible answer suits in total.
You're wondering, how many answer suits satisfy the following condition: after moving clockwise by 1, the total number of points of the new answer suit is strictly larger than the number of points of the old one. You need to find the answer modulo 998 244 353.
For example, if n = 5, and your answer suit is a=[1,2,3,4,5], it will submitted as a'=[5,1,2,3,4] because of a mistake. If the correct answer suit is h=[5,2,2,3,4], the answer suit a earns 1 point and the answer suite a' earns 4 points. Since 4 > 1, the answer suit a=[1,2,3,4,5] should be counted.
Input
The first line contains two integers n, k (1 ≤ n ≤ 2000, 1 ≤ k ≤ 10^9) — the number of questions and the number of possible answers to each question.
The following line contains n integers h_1, h_2, ..., h_n, (1 ≤ h_{i} ≤ k) — answers to the questions.
Output
Output one integer: the number of answers suits satisfying the given condition, modulo 998 244 353.
Examples
Input
3 3
1 3 1
Output
9
Input
5 5
1 1 4 2 2
Output
1000
Note
For the first example, valid answer suits are [2,1,1], [2,1,2], [2,1,3], [3,1,1], [3,1,2], [3,1,3], [3,2,1], [3,2,2], [3,2,3].
Tags: dp
Correct Solution:
```
n,k=[int(kk) for kk in input().strip().split(" ")]
h=[int(kk) for kk in input().strip().split(" ")]
fact=[1]*(n+1)
mod=998244353
for i in range(1,n+1):
fact[i]=(fact[i-1]*i)%mod
def inv(x):
return pow(x,mod-2,mod)
def C(n,k):
return (fact[n]*inv(fact[k])*inv(fact[n-k]))%mod
ng=0
for i in range(n):
if (h[i]==h[i-1]):
ng+=1
np=n-ng
totposs=pow(k,np)
possegales=[C(np,kk)*C(np-kk,kk) * pow(k-2,np-2*kk) for kk in range(np//2 +1)]
res=(totposs-sum(possegales)%mod + mod) % mod *inv(2) * pow(k,ng,mod)
res%=mod
print(res)
```
| 69,950 | [
0.71435546875,
0.1090087890625,
-0.276123046875,
0.181640625,
-0.673828125,
-0.38525390625,
0.11553955078125,
0.06756591796875,
0.2509765625,
0.931640625,
0.71826171875,
0.129150390625,
0.465576171875,
-0.7373046875,
-0.341064453125,
-0.11676025390625,
-0.56640625,
-0.677734375,
... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your program fails again. This time it gets "Wrong answer on test 233"
.
This is the easier version of the problem. In this version 1 ≤ n ≤ 2000. You can hack this problem only if you solve and lock both problems.
The problem is about a test containing n one-choice-questions. Each of the questions contains k options, and only one of them is correct. The answer to the i-th question is h_{i}, and if your answer of the question i is h_{i}, you earn 1 point, otherwise, you earn 0 points for this question. The values h_1, h_2, ..., h_n are known to you in this problem.
However, you have a mistake in your program. It moves the answer clockwise! Consider all the n answers are written in a circle. Due to the mistake in your program, they are shifted by one cyclically.
Formally, the mistake moves the answer for the question i to the question i mod n + 1. So it moves the answer for the question 1 to question 2, the answer for the question 2 to the question 3, ..., the answer for the question n to the question 1.
We call all the n answers together an answer suit. There are k^n possible answer suits in total.
You're wondering, how many answer suits satisfy the following condition: after moving clockwise by 1, the total number of points of the new answer suit is strictly larger than the number of points of the old one. You need to find the answer modulo 998 244 353.
For example, if n = 5, and your answer suit is a=[1,2,3,4,5], it will submitted as a'=[5,1,2,3,4] because of a mistake. If the correct answer suit is h=[5,2,2,3,4], the answer suit a earns 1 point and the answer suite a' earns 4 points. Since 4 > 1, the answer suit a=[1,2,3,4,5] should be counted.
Input
The first line contains two integers n, k (1 ≤ n ≤ 2000, 1 ≤ k ≤ 10^9) — the number of questions and the number of possible answers to each question.
The following line contains n integers h_1, h_2, ..., h_n, (1 ≤ h_{i} ≤ k) — answers to the questions.
Output
Output one integer: the number of answers suits satisfying the given condition, modulo 998 244 353.
Examples
Input
3 3
1 3 1
Output
9
Input
5 5
1 1 4 2 2
Output
1000
Note
For the first example, valid answer suits are [2,1,1], [2,1,2], [2,1,3], [3,1,1], [3,1,2], [3,1,3], [3,2,1], [3,2,2], [3,2,3].
Tags: dp
Correct Solution:
```
def main():
M=998244353
n,k,*h=map(int,open(0).read().split())
m=sum(i!=j for i,j in zip(h,h[1:]+h[:1]))
f=[0]*(m+1)
f[0]=b=1
for i in range(1,m+1):f[i]=b=b*i%M
inv=[0]*(m+1)
inv[m]=b=pow(f[m],M-2,M)
for i in range(m,0,-1):inv[i-1]=b=b*i%M
comb=lambda n,k:f[n]*inv[n-k]*inv[k]%M
print((pow(k,m,M)-sum(comb(m,i)*comb(m-i,i)*pow(k-2,m-i-i,M)for i in range(m//2+1)))*pow(k,n-m,M)*pow(2,M-2,M)%M)
main()
```
| 69,951 | [
0.71435546875,
0.1090087890625,
-0.276123046875,
0.181640625,
-0.673828125,
-0.38525390625,
0.11553955078125,
0.06756591796875,
0.2509765625,
0.931640625,
0.71826171875,
0.129150390625,
0.465576171875,
-0.7373046875,
-0.341064453125,
-0.11676025390625,
-0.56640625,
-0.677734375,
... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your program fails again. This time it gets "Wrong answer on test 233"
.
This is the easier version of the problem. In this version 1 ≤ n ≤ 2000. You can hack this problem only if you solve and lock both problems.
The problem is about a test containing n one-choice-questions. Each of the questions contains k options, and only one of them is correct. The answer to the i-th question is h_{i}, and if your answer of the question i is h_{i}, you earn 1 point, otherwise, you earn 0 points for this question. The values h_1, h_2, ..., h_n are known to you in this problem.
However, you have a mistake in your program. It moves the answer clockwise! Consider all the n answers are written in a circle. Due to the mistake in your program, they are shifted by one cyclically.
Formally, the mistake moves the answer for the question i to the question i mod n + 1. So it moves the answer for the question 1 to question 2, the answer for the question 2 to the question 3, ..., the answer for the question n to the question 1.
We call all the n answers together an answer suit. There are k^n possible answer suits in total.
You're wondering, how many answer suits satisfy the following condition: after moving clockwise by 1, the total number of points of the new answer suit is strictly larger than the number of points of the old one. You need to find the answer modulo 998 244 353.
For example, if n = 5, and your answer suit is a=[1,2,3,4,5], it will submitted as a'=[5,1,2,3,4] because of a mistake. If the correct answer suit is h=[5,2,2,3,4], the answer suit a earns 1 point and the answer suite a' earns 4 points. Since 4 > 1, the answer suit a=[1,2,3,4,5] should be counted.
Input
The first line contains two integers n, k (1 ≤ n ≤ 2000, 1 ≤ k ≤ 10^9) — the number of questions and the number of possible answers to each question.
The following line contains n integers h_1, h_2, ..., h_n, (1 ≤ h_{i} ≤ k) — answers to the questions.
Output
Output one integer: the number of answers suits satisfying the given condition, modulo 998 244 353.
Examples
Input
3 3
1 3 1
Output
9
Input
5 5
1 1 4 2 2
Output
1000
Note
For the first example, valid answer suits are [2,1,1], [2,1,2], [2,1,3], [3,1,1], [3,1,2], [3,1,3], [3,2,1], [3,2,2], [3,2,3].
Tags: dp
Correct Solution:
```
n,k=[int(kk) for kk in input().strip().split(" ")]
h=[int(kk) for kk in input().strip().split(" ")]
fact=[1]*(n+1)
mod=998244353
for i in range(1,n+1):
fact[i]=(fact[i-1]*i)%mod
def inv(x):
return pow(x,mod-2,mod)
def C(n,k):
return (fact[n]*inv(fact[k])*inv(fact[n-k]))%mod
ng=0
for i in range(n):
if (h[i]==h[i-1]):
ng+=1
np=n-ng
totposs=pow(k,np)
possegales=[C(np,kk)*C(np-kk,kk) * pow(k-2,np-2*kk,mod) for kk in range(np//2 +1)]
res=(totposs-sum(possegales)%mod + mod) % mod *inv(2) * pow(k,ng,mod)
res%=mod
print(res)
```
| 69,952 | [
0.71435546875,
0.1090087890625,
-0.276123046875,
0.181640625,
-0.673828125,
-0.38525390625,
0.11553955078125,
0.06756591796875,
0.2509765625,
0.931640625,
0.71826171875,
0.129150390625,
0.465576171875,
-0.7373046875,
-0.341064453125,
-0.11676025390625,
-0.56640625,
-0.677734375,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your program fails again. This time it gets "Wrong answer on test 233"
.
This is the easier version of the problem. In this version 1 ≤ n ≤ 2000. You can hack this problem only if you solve and lock both problems.
The problem is about a test containing n one-choice-questions. Each of the questions contains k options, and only one of them is correct. The answer to the i-th question is h_{i}, and if your answer of the question i is h_{i}, you earn 1 point, otherwise, you earn 0 points for this question. The values h_1, h_2, ..., h_n are known to you in this problem.
However, you have a mistake in your program. It moves the answer clockwise! Consider all the n answers are written in a circle. Due to the mistake in your program, they are shifted by one cyclically.
Formally, the mistake moves the answer for the question i to the question i mod n + 1. So it moves the answer for the question 1 to question 2, the answer for the question 2 to the question 3, ..., the answer for the question n to the question 1.
We call all the n answers together an answer suit. There are k^n possible answer suits in total.
You're wondering, how many answer suits satisfy the following condition: after moving clockwise by 1, the total number of points of the new answer suit is strictly larger than the number of points of the old one. You need to find the answer modulo 998 244 353.
For example, if n = 5, and your answer suit is a=[1,2,3,4,5], it will submitted as a'=[5,1,2,3,4] because of a mistake. If the correct answer suit is h=[5,2,2,3,4], the answer suit a earns 1 point and the answer suite a' earns 4 points. Since 4 > 1, the answer suit a=[1,2,3,4,5] should be counted.
Input
The first line contains two integers n, k (1 ≤ n ≤ 2000, 1 ≤ k ≤ 10^9) — the number of questions and the number of possible answers to each question.
The following line contains n integers h_1, h_2, ..., h_n, (1 ≤ h_{i} ≤ k) — answers to the questions.
Output
Output one integer: the number of answers suits satisfying the given condition, modulo 998 244 353.
Examples
Input
3 3
1 3 1
Output
9
Input
5 5
1 1 4 2 2
Output
1000
Note
For the first example, valid answer suits are [2,1,1], [2,1,2], [2,1,3], [3,1,1], [3,1,2], [3,1,3], [3,2,1], [3,2,2], [3,2,3].
Submitted Solution:
```
import copy
s=0
n,k=map(int,input().split())
a=list(map(int,input().split()))
b=copy.deepcopy(a)
#print(b)
p=b[0]
b.pop(0)
b.append(p)
#print(b)
for i in range(0,len(a)):
if a[i]==b[i]:s+=k
print(s**(n-s//k))
```
No
| 69,953 | [
0.67626953125,
0.1588134765625,
-0.3857421875,
0.1173095703125,
-0.69921875,
-0.310302734375,
0.036346435546875,
0.1688232421875,
0.0015716552734375,
0.9423828125,
0.72265625,
0.09490966796875,
0.488037109375,
-0.861328125,
-0.373779296875,
-0.22119140625,
-0.52294921875,
-0.716308... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your program fails again. This time it gets "Wrong answer on test 233"
.
This is the easier version of the problem. In this version 1 ≤ n ≤ 2000. You can hack this problem only if you solve and lock both problems.
The problem is about a test containing n one-choice-questions. Each of the questions contains k options, and only one of them is correct. The answer to the i-th question is h_{i}, and if your answer of the question i is h_{i}, you earn 1 point, otherwise, you earn 0 points for this question. The values h_1, h_2, ..., h_n are known to you in this problem.
However, you have a mistake in your program. It moves the answer clockwise! Consider all the n answers are written in a circle. Due to the mistake in your program, they are shifted by one cyclically.
Formally, the mistake moves the answer for the question i to the question i mod n + 1. So it moves the answer for the question 1 to question 2, the answer for the question 2 to the question 3, ..., the answer for the question n to the question 1.
We call all the n answers together an answer suit. There are k^n possible answer suits in total.
You're wondering, how many answer suits satisfy the following condition: after moving clockwise by 1, the total number of points of the new answer suit is strictly larger than the number of points of the old one. You need to find the answer modulo 998 244 353.
For example, if n = 5, and your answer suit is a=[1,2,3,4,5], it will submitted as a'=[5,1,2,3,4] because of a mistake. If the correct answer suit is h=[5,2,2,3,4], the answer suit a earns 1 point and the answer suite a' earns 4 points. Since 4 > 1, the answer suit a=[1,2,3,4,5] should be counted.
Input
The first line contains two integers n, k (1 ≤ n ≤ 2000, 1 ≤ k ≤ 10^9) — the number of questions and the number of possible answers to each question.
The following line contains n integers h_1, h_2, ..., h_n, (1 ≤ h_{i} ≤ k) — answers to the questions.
Output
Output one integer: the number of answers suits satisfying the given condition, modulo 998 244 353.
Examples
Input
3 3
1 3 1
Output
9
Input
5 5
1 1 4 2 2
Output
1000
Note
For the first example, valid answer suits are [2,1,1], [2,1,2], [2,1,3], [3,1,1], [3,1,2], [3,1,3], [3,2,1], [3,2,2], [3,2,3].
Submitted Solution:
```
from math import factorial
def C(n, k):
return factorial(n) // (factorial(k) * factorial(n - k))
import sys
fin = sys.stdin
n, k = map(int, input().split())
answers = list(map(int, fin.readline().split()))
matches = 0
for i in range(1, n):
if answers[i] == answers[i - 1]:
matches += 1
if answers[0] == answers[-1]:
matches += 1
ans = 0
vacancies = n - matches
for correct in range(1, vacancies + 1):
for original_correct in range(min(correct, vacancies - correct + 1)):
ans += C(vacancies, correct) * C(vacancies - correct, original_correct) * (n - 2) ** (
vacancies - correct - original_correct)
ans *= k ** matches
print(ans % 998244353)
```
No
| 69,954 | [
0.67626953125,
0.1588134765625,
-0.3857421875,
0.1173095703125,
-0.69921875,
-0.310302734375,
0.036346435546875,
0.1688232421875,
0.0015716552734375,
0.9423828125,
0.72265625,
0.09490966796875,
0.488037109375,
-0.861328125,
-0.373779296875,
-0.22119140625,
-0.52294921875,
-0.716308... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your program fails again. This time it gets "Wrong answer on test 233"
.
This is the easier version of the problem. In this version 1 ≤ n ≤ 2000. You can hack this problem only if you solve and lock both problems.
The problem is about a test containing n one-choice-questions. Each of the questions contains k options, and only one of them is correct. The answer to the i-th question is h_{i}, and if your answer of the question i is h_{i}, you earn 1 point, otherwise, you earn 0 points for this question. The values h_1, h_2, ..., h_n are known to you in this problem.
However, you have a mistake in your program. It moves the answer clockwise! Consider all the n answers are written in a circle. Due to the mistake in your program, they are shifted by one cyclically.
Formally, the mistake moves the answer for the question i to the question i mod n + 1. So it moves the answer for the question 1 to question 2, the answer for the question 2 to the question 3, ..., the answer for the question n to the question 1.
We call all the n answers together an answer suit. There are k^n possible answer suits in total.
You're wondering, how many answer suits satisfy the following condition: after moving clockwise by 1, the total number of points of the new answer suit is strictly larger than the number of points of the old one. You need to find the answer modulo 998 244 353.
For example, if n = 5, and your answer suit is a=[1,2,3,4,5], it will submitted as a'=[5,1,2,3,4] because of a mistake. If the correct answer suit is h=[5,2,2,3,4], the answer suit a earns 1 point and the answer suite a' earns 4 points. Since 4 > 1, the answer suit a=[1,2,3,4,5] should be counted.
Input
The first line contains two integers n, k (1 ≤ n ≤ 2000, 1 ≤ k ≤ 10^9) — the number of questions and the number of possible answers to each question.
The following line contains n integers h_1, h_2, ..., h_n, (1 ≤ h_{i} ≤ k) — answers to the questions.
Output
Output one integer: the number of answers suits satisfying the given condition, modulo 998 244 353.
Examples
Input
3 3
1 3 1
Output
9
Input
5 5
1 1 4 2 2
Output
1000
Note
For the first example, valid answer suits are [2,1,1], [2,1,2], [2,1,3], [3,1,1], [3,1,2], [3,1,3], [3,2,1], [3,2,2], [3,2,3].
Submitted Solution:
```
from math import factorial
def C(n, k):
return factorial(n) // (factorial(k) * factorial(n - k))
import sys
fin = sys.stdin
n, k = map(int, input().split())
answers = list(map(int, fin.readline().split()))
matches = 0
for i in range(1, n):
if answers[i] == answers[i - 1]:
matches += 1
if answers[0] == answers[-1]:
matches += 1
ans = 0
vacancies = n - matches
for correct in range(1, vacancies + 1):
if correct > 1:
ans += C(vacancies, correct) * (n - 1) ** (vacancies - correct)
continue
ans += C(vacancies, correct) * (n - 2) ** (vacancies - correct)
ans *= k ** matches
print(ans % 998244353)
```
No
| 69,955 | [
0.67626953125,
0.1588134765625,
-0.3857421875,
0.1173095703125,
-0.69921875,
-0.310302734375,
0.036346435546875,
0.1688232421875,
0.0015716552734375,
0.9423828125,
0.72265625,
0.09490966796875,
0.488037109375,
-0.861328125,
-0.373779296875,
-0.22119140625,
-0.52294921875,
-0.716308... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your program fails again. This time it gets "Wrong answer on test 233"
.
This is the easier version of the problem. In this version 1 ≤ n ≤ 2000. You can hack this problem only if you solve and lock both problems.
The problem is about a test containing n one-choice-questions. Each of the questions contains k options, and only one of them is correct. The answer to the i-th question is h_{i}, and if your answer of the question i is h_{i}, you earn 1 point, otherwise, you earn 0 points for this question. The values h_1, h_2, ..., h_n are known to you in this problem.
However, you have a mistake in your program. It moves the answer clockwise! Consider all the n answers are written in a circle. Due to the mistake in your program, they are shifted by one cyclically.
Formally, the mistake moves the answer for the question i to the question i mod n + 1. So it moves the answer for the question 1 to question 2, the answer for the question 2 to the question 3, ..., the answer for the question n to the question 1.
We call all the n answers together an answer suit. There are k^n possible answer suits in total.
You're wondering, how many answer suits satisfy the following condition: after moving clockwise by 1, the total number of points of the new answer suit is strictly larger than the number of points of the old one. You need to find the answer modulo 998 244 353.
For example, if n = 5, and your answer suit is a=[1,2,3,4,5], it will submitted as a'=[5,1,2,3,4] because of a mistake. If the correct answer suit is h=[5,2,2,3,4], the answer suit a earns 1 point and the answer suite a' earns 4 points. Since 4 > 1, the answer suit a=[1,2,3,4,5] should be counted.
Input
The first line contains two integers n, k (1 ≤ n ≤ 2000, 1 ≤ k ≤ 10^9) — the number of questions and the number of possible answers to each question.
The following line contains n integers h_1, h_2, ..., h_n, (1 ≤ h_{i} ≤ k) — answers to the questions.
Output
Output one integer: the number of answers suits satisfying the given condition, modulo 998 244 353.
Examples
Input
3 3
1 3 1
Output
9
Input
5 5
1 1 4 2 2
Output
1000
Note
For the first example, valid answer suits are [2,1,1], [2,1,2], [2,1,3], [3,1,1], [3,1,2], [3,1,3], [3,2,1], [3,2,2], [3,2,3].
Submitted Solution:
```
478748786
874989
44
6
4
```
No
| 69,956 | [
0.67626953125,
0.1588134765625,
-0.3857421875,
0.1173095703125,
-0.69921875,
-0.310302734375,
0.036346435546875,
0.1688232421875,
0.0015716552734375,
0.9423828125,
0.72265625,
0.09490966796875,
0.488037109375,
-0.861328125,
-0.373779296875,
-0.22119140625,
-0.52294921875,
-0.716308... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a game called "Unique Bid Auction". You can read more about it here: https://en.wikipedia.org/wiki/Unique_bid_auction (though you don't have to do it to solve this problem).
Let's simplify this game a bit. Formally, there are n participants, the i-th participant chose the number a_i. The winner of the game is such a participant that the number he chose is unique (i. e. nobody else chose this number except him) and is minimal (i. e. among all unique values of a the minimum one is the winning one).
Your task is to find the index of the participant who won the game (or -1 if there is no winner). Indexing is 1-based, i. e. the participants are numbered from 1 to n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of participants. The second line of the test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n), where a_i is the i-th participant chosen number.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the index of the participant who won the game (or -1 if there is no winner). Note that the answer is always unique.
Example
Input
6
2
1 1
3
2 1 3
4
2 2 2 3
1
1
5
2 3 2 4 2
6
1 1 5 5 4 4
Output
-1
2
4
1
2
-1
Submitted Solution:
```
t = int(input())
for T in range(t):
n = int(input())
c = list(map(int, input().split()))
d = dict()
# print(c)
for i in range(1, n+1):
d[i] = 0
for o in c:
d[o] += 1
# print(d)
m = n+1
for o in d:
if o < m and d[o] == 1:
m = o
if m < n+1:
print(c.index(m)+1)
else:
print(-1)
```
Yes
| 70,067 | [
0.2080078125,
0.08734130859375,
-0.44384765625,
0.2066650390625,
-0.6494140625,
-0.322265625,
-0.3681640625,
0.1585693359375,
0.252197265625,
0.6640625,
0.6123046875,
-0.14501953125,
0.060943603515625,
-0.458984375,
-0.87158203125,
-0.1011962890625,
-0.455322265625,
-0.63037109375,... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a game called "Unique Bid Auction". You can read more about it here: https://en.wikipedia.org/wiki/Unique_bid_auction (though you don't have to do it to solve this problem).
Let's simplify this game a bit. Formally, there are n participants, the i-th participant chose the number a_i. The winner of the game is such a participant that the number he chose is unique (i. e. nobody else chose this number except him) and is minimal (i. e. among all unique values of a the minimum one is the winning one).
Your task is to find the index of the participant who won the game (or -1 if there is no winner). Indexing is 1-based, i. e. the participants are numbered from 1 to n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of participants. The second line of the test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n), where a_i is the i-th participant chosen number.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the index of the participant who won the game (or -1 if there is no winner). Note that the answer is always unique.
Example
Input
6
2
1 1
3
2 1 3
4
2 2 2 3
1
1
5
2 3 2 4 2
6
1 1 5 5 4 4
Output
-1
2
4
1
2
-1
Submitted Solution:
```
import sys
def getUniqueBid(bids):
bid_counts = {}
for i in bids:
if i not in bid_counts.keys():
bid_counts[i] = 1
else:
bid_counts[i] = bid_counts[i] + 1
inverted_counts = {}
for k, v in bid_counts.items():
if v not in inverted_counts.keys():
inverted_counts[v] = [k]
else:
inverted_counts[v].append(k)
if 1 not in inverted_counts.keys():
return -1
unique_bids = inverted_counts[1]
min_unique_bids = unique_bids[0]
for bid in unique_bids:
if bid < min_unique_bids:
min_unique_bids = bid
return bids.index(min_unique_bids) + 1
testcase_flag = True
count = 0
testCaseCount = 0
costs = []
for line in sys.stdin:
inputs = [x for x in line.strip().split()]
if testcase_flag:
testCaseCount = int(inputs[0])
testcase_flag = False
continue
if count % 2 == 0:
n = int(inputs[0])
count = count + 1
continue
if count % 2 == 1:
bids = []
for i in range(n):
bids.append(int(inputs[i]))
count = count + 1
cost = getUniqueBid(bids)
costs.append(cost)
if count == testCaseCount*2:
break
for i in range(testCaseCount):
print(costs[i])
```
Yes
| 70,068 | [
0.2020263671875,
0.06439208984375,
-0.58349609375,
0.228271484375,
-0.63037109375,
-0.342529296875,
-0.48828125,
0.1690673828125,
0.303466796875,
0.6865234375,
0.7294921875,
-0.189697265625,
0.06243896484375,
-0.41015625,
-0.9521484375,
0.039581298828125,
-0.371826171875,
-0.650878... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a game called "Unique Bid Auction". You can read more about it here: https://en.wikipedia.org/wiki/Unique_bid_auction (though you don't have to do it to solve this problem).
Let's simplify this game a bit. Formally, there are n participants, the i-th participant chose the number a_i. The winner of the game is such a participant that the number he chose is unique (i. e. nobody else chose this number except him) and is minimal (i. e. among all unique values of a the minimum one is the winning one).
Your task is to find the index of the participant who won the game (or -1 if there is no winner). Indexing is 1-based, i. e. the participants are numbered from 1 to n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of participants. The second line of the test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n), where a_i is the i-th participant chosen number.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the index of the participant who won the game (or -1 if there is no winner). Note that the answer is always unique.
Example
Input
6
2
1 1
3
2 1 3
4
2 2 2 3
1
1
5
2 3 2 4 2
6
1 1 5 5 4 4
Output
-1
2
4
1
2
-1
Submitted Solution:
```
input = __import__('sys').stdin.readline
from collections import Counter
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
p = Counter(a)
ind = 10**24
for i in p:
if p[i] == 1:
ind = min(ind, i)
if ind == 10**24:
print(-1)
else:
for i in range(n):
if a[i] == ind:
print(i + 1)
break
```
Yes
| 70,069 | [
0.2047119140625,
0.07647705078125,
-0.4345703125,
0.20703125,
-0.68310546875,
-0.34423828125,
-0.418701171875,
0.1787109375,
0.2470703125,
0.64306640625,
0.62158203125,
-0.1500244140625,
0.09649658203125,
-0.439697265625,
-0.89306640625,
-0.061553955078125,
-0.441162109375,
-0.6337... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a game called "Unique Bid Auction". You can read more about it here: https://en.wikipedia.org/wiki/Unique_bid_auction (though you don't have to do it to solve this problem).
Let's simplify this game a bit. Formally, there are n participants, the i-th participant chose the number a_i. The winner of the game is such a participant that the number he chose is unique (i. e. nobody else chose this number except him) and is minimal (i. e. among all unique values of a the minimum one is the winning one).
Your task is to find the index of the participant who won the game (or -1 if there is no winner). Indexing is 1-based, i. e. the participants are numbered from 1 to n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of participants. The second line of the test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n), where a_i is the i-th participant chosen number.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the index of the participant who won the game (or -1 if there is no winner). Note that the answer is always unique.
Example
Input
6
2
1 1
3
2 1 3
4
2 2 2 3
1
1
5
2 3 2 4 2
6
1 1 5 5 4 4
Output
-1
2
4
1
2
-1
Submitted Solution:
```
for i in range(int(input())):
n = int(input())
t= list(map(int,input().split()))
f={}
for j in t:
if j not in f:
f[j]=1
else:f[j]+=1
ans=9999999999
for k in f.keys():
if f[k]==1:
ans = min(k,ans)
if ans==9999999999:print(-1)
else:
print(t.index(ans)+1)
```
Yes
| 70,070 | [
0.2010498046875,
0.0908203125,
-0.469482421875,
0.25,
-0.6484375,
-0.345458984375,
-0.363037109375,
0.1922607421875,
0.259765625,
0.65869140625,
0.669921875,
-0.1265869140625,
0.07427978515625,
-0.4541015625,
-0.8857421875,
-0.050567626953125,
-0.45361328125,
-0.62646484375,
-0.1... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a game called "Unique Bid Auction". You can read more about it here: https://en.wikipedia.org/wiki/Unique_bid_auction (though you don't have to do it to solve this problem).
Let's simplify this game a bit. Formally, there are n participants, the i-th participant chose the number a_i. The winner of the game is such a participant that the number he chose is unique (i. e. nobody else chose this number except him) and is minimal (i. e. among all unique values of a the minimum one is the winning one).
Your task is to find the index of the participant who won the game (or -1 if there is no winner). Indexing is 1-based, i. e. the participants are numbered from 1 to n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of participants. The second line of the test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n), where a_i is the i-th participant chosen number.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the index of the participant who won the game (or -1 if there is no winner). Note that the answer is always unique.
Example
Input
6
2
1 1
3
2 1 3
4
2 2 2 3
1
1
5
2 3 2 4 2
6
1 1 5 5 4 4
Output
-1
2
4
1
2
-1
Submitted Solution:
```
try:
def fun(n):
d1 = {}
d2 = {}
arr=[int(i) for i in input().split()]
Mymap=set()
for i in arr:
d1.setdefault(i,0)
d1[i] += 1
d2.setdefault(i,0)
d2[i] = arr.index(i) + 1
if d1[i] == 1:
Mymap.add(i)
if d1[i] > 1 and i in Mymap:
Mymap.remove(i)
res = list(Mymap)
if len(res) == 0:
return -1
if sum(arr) == n:
return -1
else:
return arr.index(min(res)) + 1
for _ in range(int(input())):
n = int(input())
print(fun(n))
except:
pass
```
No
| 70,071 | [
0.1904296875,
0.1612548828125,
-0.438720703125,
0.1729736328125,
-0.6279296875,
-0.30712890625,
-0.438720703125,
0.1761474609375,
0.234375,
0.71044921875,
0.68798828125,
-0.10491943359375,
0.19384765625,
-0.390625,
-0.7607421875,
-0.08642578125,
-0.471923828125,
-0.5888671875,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a game called "Unique Bid Auction". You can read more about it here: https://en.wikipedia.org/wiki/Unique_bid_auction (though you don't have to do it to solve this problem).
Let's simplify this game a bit. Formally, there are n participants, the i-th participant chose the number a_i. The winner of the game is such a participant that the number he chose is unique (i. e. nobody else chose this number except him) and is minimal (i. e. among all unique values of a the minimum one is the winning one).
Your task is to find the index of the participant who won the game (or -1 if there is no winner). Indexing is 1-based, i. e. the participants are numbered from 1 to n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of participants. The second line of the test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n), where a_i is the i-th participant chosen number.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the index of the participant who won the game (or -1 if there is no winner). Note that the answer is always unique.
Example
Input
6
2
1 1
3
2 1 3
4
2 2 2 3
1
1
5
2 3 2 4 2
6
1 1 5 5 4 4
Output
-1
2
4
1
2
-1
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
a = [int(i) for i in input().split()]
num = [0]*(n+1)
for i in a:
num[i] +=1
if num.count(1)==0:
print(-1)
else:
for i in num:
if i == 1:
print(i)
break
```
No
| 70,072 | [
0.23095703125,
0.08795166015625,
-0.461669921875,
0.2318115234375,
-0.630859375,
-0.345703125,
-0.38134765625,
0.181396484375,
0.276123046875,
0.6650390625,
0.6552734375,
-0.14453125,
0.052093505859375,
-0.45556640625,
-0.88916015625,
-0.0570068359375,
-0.439453125,
-0.65771484375,... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a game called "Unique Bid Auction". You can read more about it here: https://en.wikipedia.org/wiki/Unique_bid_auction (though you don't have to do it to solve this problem).
Let's simplify this game a bit. Formally, there are n participants, the i-th participant chose the number a_i. The winner of the game is such a participant that the number he chose is unique (i. e. nobody else chose this number except him) and is minimal (i. e. among all unique values of a the minimum one is the winning one).
Your task is to find the index of the participant who won the game (or -1 if there is no winner). Indexing is 1-based, i. e. the participants are numbered from 1 to n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of participants. The second line of the test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n), where a_i is the i-th participant chosen number.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the index of the participant who won the game (or -1 if there is no winner). Note that the answer is always unique.
Example
Input
6
2
1 1
3
2 1 3
4
2 2 2 3
1
1
5
2 3 2 4 2
6
1 1 5 5 4 4
Output
-1
2
4
1
2
-1
Submitted Solution:
```
for t in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
s = list(set(a))
m = max(a)
ind = 0
for i in range(len(s)):
if(len(a) == 1):
ind = 1
break
elif(a.count(s[i]) == 1 and s[i] <= m):
m = s[i]
ind = a.index(m) + 1
break
else:
ind = -1
print(ind)
```
No
| 70,073 | [
0.2012939453125,
0.09051513671875,
-0.439697265625,
0.22119140625,
-0.63720703125,
-0.355224609375,
-0.353759765625,
0.1695556640625,
0.255859375,
0.64404296875,
0.646484375,
-0.125732421875,
0.0819091796875,
-0.46728515625,
-0.87646484375,
-0.08349609375,
-0.45458984375,
-0.629394... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a game called "Unique Bid Auction". You can read more about it here: https://en.wikipedia.org/wiki/Unique_bid_auction (though you don't have to do it to solve this problem).
Let's simplify this game a bit. Formally, there are n participants, the i-th participant chose the number a_i. The winner of the game is such a participant that the number he chose is unique (i. e. nobody else chose this number except him) and is minimal (i. e. among all unique values of a the minimum one is the winning one).
Your task is to find the index of the participant who won the game (or -1 if there is no winner). Indexing is 1-based, i. e. the participants are numbered from 1 to n.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The first line of the test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of participants. The second line of the test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n), where a_i is the i-th participant chosen number.
It is guaranteed that the sum of n does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each test case, print the answer — the index of the participant who won the game (or -1 if there is no winner). Note that the answer is always unique.
Example
Input
6
2
1 1
3
2 1 3
4
2 2 2 3
1
1
5
2 3 2 4 2
6
1 1 5 5 4 4
Output
-1
2
4
1
2
-1
Submitted Solution:
```
testCase = int(input())
stop = 0
while stop < testCase:
participants = int(input())
numbers = input()
numbers = numbers.split()
number = min(numbers)
repeated = 0
posicion = 0
for i in numbers:
if number == i:
repeated = repeated + 1
if repeated == 1:
posicion = numbers.index(number)+1
else :
posicion = -1
print(posicion)
stop = stop + 1
```
No
| 70,074 | [
0.26318359375,
0.131591796875,
-0.440185546875,
0.19580078125,
-0.63916015625,
-0.394287109375,
-0.40625,
0.1612548828125,
0.31494140625,
0.6572265625,
0.66064453125,
-0.1602783203125,
0.061676025390625,
-0.447021484375,
-0.8427734375,
-0.0810546875,
-0.4306640625,
-0.66943359375,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This year, as in previous years, MemSQL is inviting the top 25 competitors from the Start[c]up qualification round to compete onsite for the final round. Not everyone who is eligible to compete onsite can afford to travel to the office, though. Initially the top 25 contestants are invited to come onsite. Each eligible contestant must either accept or decline the invitation. Whenever a contestant declines, the highest ranked contestant not yet invited is invited to take the place of the one that declined. This continues until 25 contestants have accepted invitations.
After the qualifying round completes, you know K of the onsite finalists, as well as their qualifying ranks (which start at 1, there are no ties). Determine the minimum possible number of contestants that declined the invitation to compete onsite in the final round.
Input
The first line of input contains K (1 ≤ K ≤ 25), the number of onsite finalists you know. The second line of input contains r1, r2, ..., rK (1 ≤ ri ≤ 106), the qualifying ranks of the finalists you know. All these ranks are distinct.
Output
Print the minimum possible number of contestants that declined the invitation to compete onsite.
Examples
Input
25
2 3 4 5 6 7 8 9 10 11 12 14 15 16 17 18 19 20 21 22 23 24 25 26 28
Output
3
Input
5
16 23 8 15 4
Output
0
Input
3
14 15 92
Output
67
Note
In the first example, you know all 25 onsite finalists. The contestants who ranked 1-st, 13-th, and 27-th must have declined, so the answer is 3.
Submitted Solution:
```
n=int(input())
a=[]
a=[int(i) for i in input().split()]
a.sort()
p = int(a[n-1])
if p>25:
print(p-25)
else:
print("0")
```
Yes
| 70,410 | [
0.52099609375,
0.044769287109375,
-0.5859375,
0.341064453125,
-0.380859375,
-0.049957275390625,
-0.452880859375,
0.6474609375,
-0.15869140625,
0.75732421875,
0.63330078125,
-0.06768798828125,
0.2261962890625,
-0.59619140625,
-0.7265625,
0.37744140625,
-0.599609375,
-0.9453125,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This year, as in previous years, MemSQL is inviting the top 25 competitors from the Start[c]up qualification round to compete onsite for the final round. Not everyone who is eligible to compete onsite can afford to travel to the office, though. Initially the top 25 contestants are invited to come onsite. Each eligible contestant must either accept or decline the invitation. Whenever a contestant declines, the highest ranked contestant not yet invited is invited to take the place of the one that declined. This continues until 25 contestants have accepted invitations.
After the qualifying round completes, you know K of the onsite finalists, as well as their qualifying ranks (which start at 1, there are no ties). Determine the minimum possible number of contestants that declined the invitation to compete onsite in the final round.
Input
The first line of input contains K (1 ≤ K ≤ 25), the number of onsite finalists you know. The second line of input contains r1, r2, ..., rK (1 ≤ ri ≤ 106), the qualifying ranks of the finalists you know. All these ranks are distinct.
Output
Print the minimum possible number of contestants that declined the invitation to compete onsite.
Examples
Input
25
2 3 4 5 6 7 8 9 10 11 12 14 15 16 17 18 19 20 21 22 23 24 25 26 28
Output
3
Input
5
16 23 8 15 4
Output
0
Input
3
14 15 92
Output
67
Note
In the first example, you know all 25 onsite finalists. The contestants who ranked 1-st, 13-th, and 27-th must have declined, so the answer is 3.
Submitted Solution:
```
t = int(input())
s = [int(x) for x in input().split(" ")]
if max(s) >= 25:
result = min(max(s) - t, max(s) - 25)
else:
result = 0
print(result)
```
Yes
| 70,411 | [
0.5068359375,
0.076416015625,
-0.57763671875,
0.373779296875,
-0.369873046875,
-0.05596923828125,
-0.455078125,
0.63671875,
-0.1551513671875,
0.76611328125,
0.63037109375,
-0.014373779296875,
0.217529296875,
-0.5986328125,
-0.7099609375,
0.386474609375,
-0.58935546875,
-0.939453125... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This year, as in previous years, MemSQL is inviting the top 25 competitors from the Start[c]up qualification round to compete onsite for the final round. Not everyone who is eligible to compete onsite can afford to travel to the office, though. Initially the top 25 contestants are invited to come onsite. Each eligible contestant must either accept or decline the invitation. Whenever a contestant declines, the highest ranked contestant not yet invited is invited to take the place of the one that declined. This continues until 25 contestants have accepted invitations.
After the qualifying round completes, you know K of the onsite finalists, as well as their qualifying ranks (which start at 1, there are no ties). Determine the minimum possible number of contestants that declined the invitation to compete onsite in the final round.
Input
The first line of input contains K (1 ≤ K ≤ 25), the number of onsite finalists you know. The second line of input contains r1, r2, ..., rK (1 ≤ ri ≤ 106), the qualifying ranks of the finalists you know. All these ranks are distinct.
Output
Print the minimum possible number of contestants that declined the invitation to compete onsite.
Examples
Input
25
2 3 4 5 6 7 8 9 10 11 12 14 15 16 17 18 19 20 21 22 23 24 25 26 28
Output
3
Input
5
16 23 8 15 4
Output
0
Input
3
14 15 92
Output
67
Note
In the first example, you know all 25 onsite finalists. The contestants who ranked 1-st, 13-th, and 27-th must have declined, so the answer is 3.
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
a=max(l)
if a>25:
print(a-25)
else:
print(0)
```
Yes
| 70,412 | [
0.533203125,
0.047119140625,
-0.6201171875,
0.369384765625,
-0.38037109375,
-0.035247802734375,
-0.45458984375,
0.6396484375,
-0.1534423828125,
0.74560546875,
0.60986328125,
-0.040985107421875,
0.2352294921875,
-0.6044921875,
-0.708984375,
0.399169921875,
-0.60400390625,
-0.9389648... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This year, as in previous years, MemSQL is inviting the top 25 competitors from the Start[c]up qualification round to compete onsite for the final round. Not everyone who is eligible to compete onsite can afford to travel to the office, though. Initially the top 25 contestants are invited to come onsite. Each eligible contestant must either accept or decline the invitation. Whenever a contestant declines, the highest ranked contestant not yet invited is invited to take the place of the one that declined. This continues until 25 contestants have accepted invitations.
After the qualifying round completes, you know K of the onsite finalists, as well as their qualifying ranks (which start at 1, there are no ties). Determine the minimum possible number of contestants that declined the invitation to compete onsite in the final round.
Input
The first line of input contains K (1 ≤ K ≤ 25), the number of onsite finalists you know. The second line of input contains r1, r2, ..., rK (1 ≤ ri ≤ 106), the qualifying ranks of the finalists you know. All these ranks are distinct.
Output
Print the minimum possible number of contestants that declined the invitation to compete onsite.
Examples
Input
25
2 3 4 5 6 7 8 9 10 11 12 14 15 16 17 18 19 20 21 22 23 24 25 26 28
Output
3
Input
5
16 23 8 15 4
Output
0
Input
3
14 15 92
Output
67
Note
In the first example, you know all 25 onsite finalists. The contestants who ranked 1-st, 13-th, and 27-th must have declined, so the answer is 3.
Submitted Solution:
```
n=int(input())
l=[int(x) for x in input().split()]
m=max(l)
if((m-25)>=0):
print(m-25)
else:
print(0)
```
Yes
| 70,413 | [
0.51806640625,
0.053070068359375,
-0.5986328125,
0.368408203125,
-0.375244140625,
-0.042266845703125,
-0.4541015625,
0.630859375,
-0.16357421875,
0.75341796875,
0.62841796875,
-0.033721923828125,
0.2247314453125,
-0.60400390625,
-0.72509765625,
0.4091796875,
-0.603515625,
-0.944824... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This year, as in previous years, MemSQL is inviting the top 25 competitors from the Start[c]up qualification round to compete onsite for the final round. Not everyone who is eligible to compete onsite can afford to travel to the office, though. Initially the top 25 contestants are invited to come onsite. Each eligible contestant must either accept or decline the invitation. Whenever a contestant declines, the highest ranked contestant not yet invited is invited to take the place of the one that declined. This continues until 25 contestants have accepted invitations.
After the qualifying round completes, you know K of the onsite finalists, as well as their qualifying ranks (which start at 1, there are no ties). Determine the minimum possible number of contestants that declined the invitation to compete onsite in the final round.
Input
The first line of input contains K (1 ≤ K ≤ 25), the number of onsite finalists you know. The second line of input contains r1, r2, ..., rK (1 ≤ ri ≤ 106), the qualifying ranks of the finalists you know. All these ranks are distinct.
Output
Print the minimum possible number of contestants that declined the invitation to compete onsite.
Examples
Input
25
2 3 4 5 6 7 8 9 10 11 12 14 15 16 17 18 19 20 21 22 23 24 25 26 28
Output
3
Input
5
16 23 8 15 4
Output
0
Input
3
14 15 92
Output
67
Note
In the first example, you know all 25 onsite finalists. The contestants who ranked 1-st, 13-th, and 27-th must have declined, so the answer is 3.
Submitted Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
K=int(input())
r=[int(x) for x in input().split()]
print(max(r)-25)
```
No
| 70,414 | [
0.54541015625,
0.046630859375,
-0.62451171875,
0.369384765625,
-0.37744140625,
-0.08502197265625,
-0.428955078125,
0.60400390625,
-0.16748046875,
0.72119140625,
0.6103515625,
-0.06884765625,
0.1812744140625,
-0.5478515625,
-0.71142578125,
0.35595703125,
-0.58642578125,
-0.933105468... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This year, as in previous years, MemSQL is inviting the top 25 competitors from the Start[c]up qualification round to compete onsite for the final round. Not everyone who is eligible to compete onsite can afford to travel to the office, though. Initially the top 25 contestants are invited to come onsite. Each eligible contestant must either accept or decline the invitation. Whenever a contestant declines, the highest ranked contestant not yet invited is invited to take the place of the one that declined. This continues until 25 contestants have accepted invitations.
After the qualifying round completes, you know K of the onsite finalists, as well as their qualifying ranks (which start at 1, there are no ties). Determine the minimum possible number of contestants that declined the invitation to compete onsite in the final round.
Input
The first line of input contains K (1 ≤ K ≤ 25), the number of onsite finalists you know. The second line of input contains r1, r2, ..., rK (1 ≤ ri ≤ 106), the qualifying ranks of the finalists you know. All these ranks are distinct.
Output
Print the minimum possible number of contestants that declined the invitation to compete onsite.
Examples
Input
25
2 3 4 5 6 7 8 9 10 11 12 14 15 16 17 18 19 20 21 22 23 24 25 26 28
Output
3
Input
5
16 23 8 15 4
Output
0
Input
3
14 15 92
Output
67
Note
In the first example, you know all 25 onsite finalists. The contestants who ranked 1-st, 13-th, and 27-th must have declined, so the answer is 3.
Submitted Solution:
```
import math
from fractions import Fraction as frac
MOD = 1e9 + 7
def solve(case_no):
n = int(input())
a = list(map(int, input().split()))
a = sorted(a)
print(a[n - 1] - 25)
t = 1
# t = int(input())
for i in range(1, t + 1):
solve(i)
```
No
| 70,415 | [
0.53466796875,
0.048309326171875,
-0.59033203125,
0.3701171875,
-0.325439453125,
-0.08404541015625,
-0.405517578125,
0.6474609375,
-0.143310546875,
0.8359375,
0.74755859375,
-0.072021484375,
0.25439453125,
-0.6162109375,
-0.70751953125,
0.468505859375,
-0.57763671875,
-0.8862304687... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This year, as in previous years, MemSQL is inviting the top 25 competitors from the Start[c]up qualification round to compete onsite for the final round. Not everyone who is eligible to compete onsite can afford to travel to the office, though. Initially the top 25 contestants are invited to come onsite. Each eligible contestant must either accept or decline the invitation. Whenever a contestant declines, the highest ranked contestant not yet invited is invited to take the place of the one that declined. This continues until 25 contestants have accepted invitations.
After the qualifying round completes, you know K of the onsite finalists, as well as their qualifying ranks (which start at 1, there are no ties). Determine the minimum possible number of contestants that declined the invitation to compete onsite in the final round.
Input
The first line of input contains K (1 ≤ K ≤ 25), the number of onsite finalists you know. The second line of input contains r1, r2, ..., rK (1 ≤ ri ≤ 106), the qualifying ranks of the finalists you know. All these ranks are distinct.
Output
Print the minimum possible number of contestants that declined the invitation to compete onsite.
Examples
Input
25
2 3 4 5 6 7 8 9 10 11 12 14 15 16 17 18 19 20 21 22 23 24 25 26 28
Output
3
Input
5
16 23 8 15 4
Output
0
Input
3
14 15 92
Output
67
Note
In the first example, you know all 25 onsite finalists. The contestants who ranked 1-st, 13-th, and 27-th must have declined, so the answer is 3.
Submitted Solution:
```
input();print(max(0,max(map(int,input().split())))-25)
```
No
| 70,416 | [
0.517578125,
0.07720947265625,
-0.60888671875,
0.3671875,
-0.369384765625,
-0.0731201171875,
-0.48828125,
0.63720703125,
-0.1810302734375,
0.74853515625,
0.63037109375,
-0.0267791748046875,
0.2130126953125,
-0.58642578125,
-0.712890625,
0.3896484375,
-0.58544921875,
-0.9423828125,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This year, as in previous years, MemSQL is inviting the top 25 competitors from the Start[c]up qualification round to compete onsite for the final round. Not everyone who is eligible to compete onsite can afford to travel to the office, though. Initially the top 25 contestants are invited to come onsite. Each eligible contestant must either accept or decline the invitation. Whenever a contestant declines, the highest ranked contestant not yet invited is invited to take the place of the one that declined. This continues until 25 contestants have accepted invitations.
After the qualifying round completes, you know K of the onsite finalists, as well as their qualifying ranks (which start at 1, there are no ties). Determine the minimum possible number of contestants that declined the invitation to compete onsite in the final round.
Input
The first line of input contains K (1 ≤ K ≤ 25), the number of onsite finalists you know. The second line of input contains r1, r2, ..., rK (1 ≤ ri ≤ 106), the qualifying ranks of the finalists you know. All these ranks are distinct.
Output
Print the minimum possible number of contestants that declined the invitation to compete onsite.
Examples
Input
25
2 3 4 5 6 7 8 9 10 11 12 14 15 16 17 18 19 20 21 22 23 24 25 26 28
Output
3
Input
5
16 23 8 15 4
Output
0
Input
3
14 15 92
Output
67
Note
In the first example, you know all 25 onsite finalists. The contestants who ranked 1-st, 13-th, and 27-th must have declined, so the answer is 3.
Submitted Solution:
```
n = int(input())
ranks = [int(x) for x in input().split(" ")]
print (max(ranks) - 25)
```
No
| 70,417 | [
0.552734375,
0.0577392578125,
-0.59033203125,
0.345458984375,
-0.356201171875,
-0.0477294921875,
-0.468017578125,
0.6416015625,
-0.1575927734375,
0.74609375,
0.61572265625,
-0.0296630859375,
0.231201171875,
-0.58544921875,
-0.69580078125,
0.43212890625,
-0.5888671875,
-0.9423828125... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
N problems are proposed for an upcoming contest. Problem i has an initial integer score of A_i points.
M judges are about to vote for problems they like. Each judge will choose exactly V problems, independently from the other judges, and increase the score of each chosen problem by 1.
After all M judges cast their vote, the problems will be sorted in non-increasing order of score, and the first P problems will be chosen for the problemset. Problems with the same score can be ordered arbitrarily, this order is decided by the chief judge.
How many problems out of the given N have a chance to be chosen for the problemset?
Constraints
* 2 \le N \le 10^5
* 1 \le M \le 10^9
* 1 \le V \le N - 1
* 1 \le P \le N - 1
* 0 \le A_i \le 10^9
Input
Input is given from Standard Input in the following format:
N M V P
A_1 A_2 ... A_N
Output
Print the number of problems that have a chance to be chosen for the problemset.
Examples
Input
6 1 2 2
2 1 1 3 0 2
Output
5
Input
6 1 5 2
2 1 1 3 0 2
Output
3
Input
10 4 8 5
7 2 3 6 1 6 5 4 6 5
Output
8
"Correct Solution:
```
n, m, v, p = map(int, input().split())
a = sorted(list(map(int, input().split())), reverse=True)
ans = p
c = [0]
cnt = 0
for i in range(n):
# 累積和
cnt += a[i]
c.append(cnt)
from bisect import bisect_right
for i in range(p,n):
h = a[i]+m
free = v - (p-1) - (n-i)
if free >= 0 and h >= a[p-1]:
d = h * (i-p+1) - (c[i]-c[p-1]) # 余裕
if d >= free*m:
ans += 1
else:
if h >= a[p-1]:
ans += 1
print(ans)
```
| 70,523 | [
0.1512451171875,
-0.0535888671875,
0.10406494140625,
0.0667724609375,
-0.69287109375,
-0.47705078125,
0.1724853515625,
0.09295654296875,
-0.08465576171875,
1.0576171875,
0.734375,
-0.2291259765625,
0.316162109375,
-0.9150390625,
-0.72314453125,
-0.050384521484375,
-0.8603515625,
-0... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
N problems are proposed for an upcoming contest. Problem i has an initial integer score of A_i points.
M judges are about to vote for problems they like. Each judge will choose exactly V problems, independently from the other judges, and increase the score of each chosen problem by 1.
After all M judges cast their vote, the problems will be sorted in non-increasing order of score, and the first P problems will be chosen for the problemset. Problems with the same score can be ordered arbitrarily, this order is decided by the chief judge.
How many problems out of the given N have a chance to be chosen for the problemset?
Constraints
* 2 \le N \le 10^5
* 1 \le M \le 10^9
* 1 \le V \le N - 1
* 1 \le P \le N - 1
* 0 \le A_i \le 10^9
Input
Input is given from Standard Input in the following format:
N M V P
A_1 A_2 ... A_N
Output
Print the number of problems that have a chance to be chosen for the problemset.
Examples
Input
6 1 2 2
2 1 1 3 0 2
Output
5
Input
6 1 5 2
2 1 1 3 0 2
Output
3
Input
10 4 8 5
7 2 3 6 1 6 5 4 6 5
Output
8
"Correct Solution:
```
def judge(a, i, m, n, v, p):
if i <= p: return True
if a[i-1] + m < a[p-1]: return False
check = (p + n - i)*m
for j in range(p, i):
check += a[i-1] + m - a[j-1]
return check >= m*v
n, m, v, p = map(int, input().split())
a = list(map(int, input().split()))
a.sort(reverse=True)
ng = n + 1
ok = 0
while (ng - ok) > 1:
mid = (ok + ng) // 2
if judge(a, mid, m, n, v, p):
ok = mid
else:
ng = mid
print(ok)
```
| 70,524 | [
0.31103515625,
-0.12091064453125,
0.027008056640625,
-0.058349609375,
-0.69677734375,
-0.57568359375,
0.045806884765625,
0.19384765625,
-0.057159423828125,
1.060546875,
0.74462890625,
-0.370361328125,
0.417724609375,
-0.8037109375,
-0.5283203125,
-0.0177764892578125,
-0.89794921875,
... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
N problems are proposed for an upcoming contest. Problem i has an initial integer score of A_i points.
M judges are about to vote for problems they like. Each judge will choose exactly V problems, independently from the other judges, and increase the score of each chosen problem by 1.
After all M judges cast their vote, the problems will be sorted in non-increasing order of score, and the first P problems will be chosen for the problemset. Problems with the same score can be ordered arbitrarily, this order is decided by the chief judge.
How many problems out of the given N have a chance to be chosen for the problemset?
Constraints
* 2 \le N \le 10^5
* 1 \le M \le 10^9
* 1 \le V \le N - 1
* 1 \le P \le N - 1
* 0 \le A_i \le 10^9
Input
Input is given from Standard Input in the following format:
N M V P
A_1 A_2 ... A_N
Output
Print the number of problems that have a chance to be chosen for the problemset.
Examples
Input
6 1 2 2
2 1 1 3 0 2
Output
5
Input
6 1 5 2
2 1 1 3 0 2
Output
3
Input
10 4 8 5
7 2 3 6 1 6 5 4 6 5
Output
8
"Correct Solution:
```
n,m,v,p=map(int,input().split())
a=list(map(int,input().split()))
a.sort(reverse=True)
ans=p
border=a[p-1]
d=0
for i in range(p,n):
# 考察対象はi+1位の問題
if border>a[i]+m:#全員から票を集めてもp位になれない
break
# i+1位の問題をp位にできるパターンを分析
# i+1位からn位の問題にm票投票
vote=m*(n-i)
# 1位からp-1位の問題にm票投票
vote+=m*(p-1)
# p位～i位の問題にi+1位と同じ票数になるように投票。このとき一問あたりの得票数はmを超えない
vote+=d+(a[i]+m-border)*(i-p+1)
# d:p位からi位問題の得票数をp位と同じにするのに必要な票数。一個当たりの票数はmを超えない。
if vote>=v*m:
ans+=1
d+=border-a[i]
print(ans)
```
| 70,525 | [
0.27392578125,
0.049041748046875,
-0.076416015625,
-0.128662109375,
-0.6728515625,
-0.490234375,
0.148193359375,
0.226806640625,
-0.04156494140625,
1,
0.54248046875,
-0.2301025390625,
0.322265625,
-0.67919921875,
-0.65966796875,
-0.12237548828125,
-0.83837890625,
-0.74755859375,
... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
N problems are proposed for an upcoming contest. Problem i has an initial integer score of A_i points.
M judges are about to vote for problems they like. Each judge will choose exactly V problems, independently from the other judges, and increase the score of each chosen problem by 1.
After all M judges cast their vote, the problems will be sorted in non-increasing order of score, and the first P problems will be chosen for the problemset. Problems with the same score can be ordered arbitrarily, this order is decided by the chief judge.
How many problems out of the given N have a chance to be chosen for the problemset?
Constraints
* 2 \le N \le 10^5
* 1 \le M \le 10^9
* 1 \le V \le N - 1
* 1 \le P \le N - 1
* 0 \le A_i \le 10^9
Input
Input is given from Standard Input in the following format:
N M V P
A_1 A_2 ... A_N
Output
Print the number of problems that have a chance to be chosen for the problemset.
Examples
Input
6 1 2 2
2 1 1 3 0 2
Output
5
Input
6 1 5 2
2 1 1 3 0 2
Output
3
Input
10 4 8 5
7 2 3 6 1 6 5 4 6 5
Output
8
"Correct Solution:
```
N, M, V, P = map(int, input().split())
A = list(map(int, input().split()))
A.sort(reverse=True)
p = A[P-1]
#X番目の問題に可能性があるかどうか(0-indexed)
def f(X):
x = A[X]
if x + M < p: return False
votes = M*V
votes -= M * (P-1)
for i in range(P-1,N):
votes -= min(M, x + M - A[i])
return votes <= 0
ok = 0
over = N
while over - ok > 1:
mid = (over + ok) // 2
if f(mid): ok = mid
else: over = mid
print(ok+1)
```
| 70,526 | [
0.31494140625,
-0.0205230712890625,
0.07537841796875,
-0.1380615234375,
-0.6083984375,
-0.473388671875,
0.07525634765625,
0.2255859375,
0.0186920166015625,
1.0107421875,
0.6923828125,
-0.255615234375,
0.354248046875,
-0.75341796875,
-0.71728515625,
0.0645751953125,
-0.8388671875,
-... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
N problems are proposed for an upcoming contest. Problem i has an initial integer score of A_i points.
M judges are about to vote for problems they like. Each judge will choose exactly V problems, independently from the other judges, and increase the score of each chosen problem by 1.
After all M judges cast their vote, the problems will be sorted in non-increasing order of score, and the first P problems will be chosen for the problemset. Problems with the same score can be ordered arbitrarily, this order is decided by the chief judge.
How many problems out of the given N have a chance to be chosen for the problemset?
Constraints
* 2 \le N \le 10^5
* 1 \le M \le 10^9
* 1 \le V \le N - 1
* 1 \le P \le N - 1
* 0 \le A_i \le 10^9
Input
Input is given from Standard Input in the following format:
N M V P
A_1 A_2 ... A_N
Output
Print the number of problems that have a chance to be chosen for the problemset.
Examples
Input
6 1 2 2
2 1 1 3 0 2
Output
5
Input
6 1 5 2
2 1 1 3 0 2
Output
3
Input
10 4 8 5
7 2 3 6 1 6 5 4 6 5
Output
8
"Correct Solution:
```
N, M, V, P = map(int, input().split())
A = sorted([int(a) for a in input().split()])
t = A[-P]
def chk(k):
if A[k] >= t: return 1
u = A[k] + M
if u < t:
return 0
s = sum([min(M, u - A[i]) for i in range(N-P+1)])
if s >= M * (V - P + 1):
return 1
return 0
l, r = -1, N-P
while r - l > 1:
m = (l+r) // 2
if chk(m):
r = m
else:
l = m
print(N - r)
```
| 70,527 | [
0.28125,
-0.055084228515625,
-0.0243072509765625,
-0.057647705078125,
-0.7412109375,
-0.41064453125,
-0.0032291412353515625,
0.166748046875,
-0.1322021484375,
0.93505859375,
0.533203125,
-0.303466796875,
0.274169921875,
-0.7392578125,
-0.5849609375,
-0.03521728515625,
-0.81103515625,... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
N problems are proposed for an upcoming contest. Problem i has an initial integer score of A_i points.
M judges are about to vote for problems they like. Each judge will choose exactly V problems, independently from the other judges, and increase the score of each chosen problem by 1.
After all M judges cast their vote, the problems will be sorted in non-increasing order of score, and the first P problems will be chosen for the problemset. Problems with the same score can be ordered arbitrarily, this order is decided by the chief judge.
How many problems out of the given N have a chance to be chosen for the problemset?
Constraints
* 2 \le N \le 10^5
* 1 \le M \le 10^9
* 1 \le V \le N - 1
* 1 \le P \le N - 1
* 0 \le A_i \le 10^9
Input
Input is given from Standard Input in the following format:
N M V P
A_1 A_2 ... A_N
Output
Print the number of problems that have a chance to be chosen for the problemset.
Examples
Input
6 1 2 2
2 1 1 3 0 2
Output
5
Input
6 1 5 2
2 1 1 3 0 2
Output
3
Input
10 4 8 5
7 2 3 6 1 6 5 4 6 5
Output
8
"Correct Solution:
```
n,m,v,p,*a=map(int,open(0).read().split())
a=sorted(a)[::-1]
ok=p-1
ng=n
while ng-ok>1:
mid=(ok+ng)//2
c=a[mid]+m
s=f=0
for t in a[p-1:mid]:
if t>c:break
s+=c-t
else:f|=(p-1+n-mid)*m+s>=v*m
if f:ok=mid
else:ng=mid
print(ok+1)
```
| 70,528 | [
0.475341796875,
-0.055023193359375,
0.03955078125,
-0.0246429443359375,
-0.70166015625,
-0.51513671875,
0.134033203125,
0.2216796875,
0.0011167526245117188,
1.046875,
0.63671875,
-0.307861328125,
0.408447265625,
-0.7919921875,
-0.5654296875,
-0.05316162109375,
-0.83642578125,
-0.65... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
N problems are proposed for an upcoming contest. Problem i has an initial integer score of A_i points.
M judges are about to vote for problems they like. Each judge will choose exactly V problems, independently from the other judges, and increase the score of each chosen problem by 1.
After all M judges cast their vote, the problems will be sorted in non-increasing order of score, and the first P problems will be chosen for the problemset. Problems with the same score can be ordered arbitrarily, this order is decided by the chief judge.
How many problems out of the given N have a chance to be chosen for the problemset?
Constraints
* 2 \le N \le 10^5
* 1 \le M \le 10^9
* 1 \le V \le N - 1
* 1 \le P \le N - 1
* 0 \le A_i \le 10^9
Input
Input is given from Standard Input in the following format:
N M V P
A_1 A_2 ... A_N
Output
Print the number of problems that have a chance to be chosen for the problemset.
Examples
Input
6 1 2 2
2 1 1 3 0 2
Output
5
Input
6 1 5 2
2 1 1 3 0 2
Output
3
Input
10 4 8 5
7 2 3 6 1 6 5 4 6 5
Output
8
"Correct Solution:
```
n, m, v, p = map(int, input().split())
a = list(map(int, input().split()))
a.sort(reverse=True)
mv = m*max(0, v-p+1)
b = a[p-1:]
l, r = b[0], b[0]+m
while l < r:
md = (l+r)//2
c = 0
for i in b:
c += min(m, md-i)
if mv <= c:
r = md
else:
l = md + 1
result = p
for i in b[1:]:
if i+m >= r:
result += 1
else:
break
print(result)
```
| 70,529 | [
0.291748046875,
-0.11224365234375,
0.0175933837890625,
-0.01422119140625,
-0.65234375,
-0.416015625,
0.074462890625,
0.1854248046875,
-0.132568359375,
0.9296875,
0.615234375,
-0.227783203125,
0.33642578125,
-0.662109375,
-0.51318359375,
0.0165557861328125,
-0.85400390625,
-0.814941... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
N problems are proposed for an upcoming contest. Problem i has an initial integer score of A_i points.
M judges are about to vote for problems they like. Each judge will choose exactly V problems, independently from the other judges, and increase the score of each chosen problem by 1.
After all M judges cast their vote, the problems will be sorted in non-increasing order of score, and the first P problems will be chosen for the problemset. Problems with the same score can be ordered arbitrarily, this order is decided by the chief judge.
How many problems out of the given N have a chance to be chosen for the problemset?
Constraints
* 2 \le N \le 10^5
* 1 \le M \le 10^9
* 1 \le V \le N - 1
* 1 \le P \le N - 1
* 0 \le A_i \le 10^9
Input
Input is given from Standard Input in the following format:
N M V P
A_1 A_2 ... A_N
Output
Print the number of problems that have a chance to be chosen for the problemset.
Examples
Input
6 1 2 2
2 1 1 3 0 2
Output
5
Input
6 1 5 2
2 1 1 3 0 2
Output
3
Input
10 4 8 5
7 2 3 6 1 6 5 4 6 5
Output
8
"Correct Solution:
```
import bisect
n,m,v,p=map(int,input().split())
l=list(map(int,input().split()))
l.sort()
ok=n#idx
ng=-1
def solve(x):
if bisect.bisect_right(l,l[x])>=n-p+1:
return 1
lx=l[x]+m
lxi=bisect.bisect_right(l,lx)-1
if lxi<=n-p-1:
return 0
#n-p-1<lxi
f=0
for i in range(n):
if i<=x or i>n-p:
f+=m
continue
else:
f+=min(lx-l[i],m)
if f>=v*m:
return 2
else:
return 0
#for i in range(n):
#print(solve(i))
while ok-ng>1:
x=(ok+ng)//2
if solve(x):
ok=x
else:
ng=x
#print(x)
print(n-ok)
```
| 70,530 | [
0.3212890625,
0.0240936279296875,
0.047119140625,
0.08587646484375,
-0.76123046875,
-0.53173828125,
0.1407470703125,
0.0185089111328125,
-0.006053924560546875,
1.1103515625,
0.63134765625,
-0.2032470703125,
0.351318359375,
-0.8212890625,
-0.58740234375,
0.00467681884765625,
-0.950683... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N problems are proposed for an upcoming contest. Problem i has an initial integer score of A_i points.
M judges are about to vote for problems they like. Each judge will choose exactly V problems, independently from the other judges, and increase the score of each chosen problem by 1.
After all M judges cast their vote, the problems will be sorted in non-increasing order of score, and the first P problems will be chosen for the problemset. Problems with the same score can be ordered arbitrarily, this order is decided by the chief judge.
How many problems out of the given N have a chance to be chosen for the problemset?
Constraints
* 2 \le N \le 10^5
* 1 \le M \le 10^9
* 1 \le V \le N - 1
* 1 \le P \le N - 1
* 0 \le A_i \le 10^9
Input
Input is given from Standard Input in the following format:
N M V P
A_1 A_2 ... A_N
Output
Print the number of problems that have a chance to be chosen for the problemset.
Examples
Input
6 1 2 2
2 1 1 3 0 2
Output
5
Input
6 1 5 2
2 1 1 3 0 2
Output
3
Input
10 4 8 5
7 2 3 6 1 6 5 4 6 5
Output
8
Submitted Solution:
```
from bisect import bisect_left,bisect_right
N,M,V,P = map(int,input().split())
A = sorted(list(map(int,input().split())))
low = -1
high = A[-1]+M
while high-low>1:
mid = (low+high)//2
indL = bisect_left(A,mid-M)
indR = bisect_right(A,mid)
if indL>N-P:
high = mid
continue
if indR<N-P+1:
low = mid
continue
tot = M*V
i = indL
while i<N-P+1:
if tot-(mid-A[i])<0:break
tot -= mid-A[i]
i += 1
if i<N-P+1 or 0<=tot<=M*(P-1+indL):
high = mid
else:
low = mid
ind = bisect_left(A,high-M)
print(N-ind)
```
Yes
| 70,531 | [
0.212890625,
-0.09136962890625,
-0.0286102294921875,
-0.1256103515625,
-0.73974609375,
-0.58203125,
0.07159423828125,
0.04217529296875,
-0.08935546875,
1.1728515625,
0.498779296875,
-0.1748046875,
0.329345703125,
-0.8740234375,
-0.47412109375,
-0.029388427734375,
-0.79443359375,
-0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N problems are proposed for an upcoming contest. Problem i has an initial integer score of A_i points.
M judges are about to vote for problems they like. Each judge will choose exactly V problems, independently from the other judges, and increase the score of each chosen problem by 1.
After all M judges cast their vote, the problems will be sorted in non-increasing order of score, and the first P problems will be chosen for the problemset. Problems with the same score can be ordered arbitrarily, this order is decided by the chief judge.
How many problems out of the given N have a chance to be chosen for the problemset?
Constraints
* 2 \le N \le 10^5
* 1 \le M \le 10^9
* 1 \le V \le N - 1
* 1 \le P \le N - 1
* 0 \le A_i \le 10^9
Input
Input is given from Standard Input in the following format:
N M V P
A_1 A_2 ... A_N
Output
Print the number of problems that have a chance to be chosen for the problemset.
Examples
Input
6 1 2 2
2 1 1 3 0 2
Output
5
Input
6 1 5 2
2 1 1 3 0 2
Output
3
Input
10 4 8 5
7 2 3 6 1 6 5 4 6 5
Output
8
Submitted Solution:
```
N,M,V,P = map(int,input().split())
A = sorted([int(i) for i in input().split()],reverse = True)
pps = 0
con = P
for i in range(P,N):
#P以降でi番目に大きい数を加算
pps += A[i - 1]
#xの上限が順位に入らない
if A[i] + M < A[P - 1]:
break
#点数をいくら振り分けてもいいスコアの数
fv = min(P - 1 + N - i, V)
#左辺第二項は、P以降とi以前の、点数の振り分け可能数に上限がある数
#左辺は振り分けた後にA[i]がP入りを果たせる区間の総和の上限を示す
#右辺第一項は、振り分け可能数に上限がある数の総和
#右辺第二項は、振り分けないといけない数の残り
#右辺は、点数を振り分けた後の値の区間の総和を示すため、
#右辺が左辺を上回った場合、ループは終了となる
if (A[i] + M) * (i - P + 1) < pps + M * (V - fv):
break
con += 1
print(con)
```
Yes
| 70,532 | [
0.265380859375,
-0.046722412109375,
0.07183837890625,
-0.079833984375,
-0.63623046875,
-0.325439453125,
-0.07196044921875,
0.379150390625,
-0.11077880859375,
0.87744140625,
0.689453125,
-0.219482421875,
0.2294921875,
-0.6318359375,
-0.73291015625,
-0.12164306640625,
-0.6484375,
-0.... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N problems are proposed for an upcoming contest. Problem i has an initial integer score of A_i points.
M judges are about to vote for problems they like. Each judge will choose exactly V problems, independently from the other judges, and increase the score of each chosen problem by 1.
After all M judges cast their vote, the problems will be sorted in non-increasing order of score, and the first P problems will be chosen for the problemset. Problems with the same score can be ordered arbitrarily, this order is decided by the chief judge.
How many problems out of the given N have a chance to be chosen for the problemset?
Constraints
* 2 \le N \le 10^5
* 1 \le M \le 10^9
* 1 \le V \le N - 1
* 1 \le P \le N - 1
* 0 \le A_i \le 10^9
Input
Input is given from Standard Input in the following format:
N M V P
A_1 A_2 ... A_N
Output
Print the number of problems that have a chance to be chosen for the problemset.
Examples
Input
6 1 2 2
2 1 1 3 0 2
Output
5
Input
6 1 5 2
2 1 1 3 0 2
Output
3
Input
10 4 8 5
7 2 3 6 1 6 5 4 6 5
Output
8
Submitted Solution:
```
n,m,v,p = map(int,input().split())
lis = list(map(int,input().split()))
lis.sort(reverse=True)
ans = 0
trash = 0
for i in range(n):
if i+1 <= p:
ans += 1
else:
if lis[i] + m >= lis[p-1]:
if (lis[i]+m)*(i-(p-1))-trash >= m * (v-(p-1)-(n-i)):
# print(lis[i]+m,i-(p-1)-trash,m*(v-(p-1)-(n-i)))
ans += 1
if i+1 >= p:
trash += lis[i]
print(ans)
```
Yes
| 70,533 | [
0.1431884765625,
-0.034027099609375,
0.11358642578125,
-0.0017032623291015625,
-0.75048828125,
-0.354736328125,
-0.05120849609375,
0.26708984375,
-0.048370361328125,
1.0146484375,
0.57421875,
-0.1221923828125,
0.406982421875,
-0.67138671875,
-0.736328125,
-0.177734375,
-0.7783203125,... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N problems are proposed for an upcoming contest. Problem i has an initial integer score of A_i points.
M judges are about to vote for problems they like. Each judge will choose exactly V problems, independently from the other judges, and increase the score of each chosen problem by 1.
After all M judges cast their vote, the problems will be sorted in non-increasing order of score, and the first P problems will be chosen for the problemset. Problems with the same score can be ordered arbitrarily, this order is decided by the chief judge.
How many problems out of the given N have a chance to be chosen for the problemset?
Constraints
* 2 \le N \le 10^5
* 1 \le M \le 10^9
* 1 \le V \le N - 1
* 1 \le P \le N - 1
* 0 \le A_i \le 10^9
Input
Input is given from Standard Input in the following format:
N M V P
A_1 A_2 ... A_N
Output
Print the number of problems that have a chance to be chosen for the problemset.
Examples
Input
6 1 2 2
2 1 1 3 0 2
Output
5
Input
6 1 5 2
2 1 1 3 0 2
Output
3
Input
10 4 8 5
7 2 3 6 1 6 5 4 6 5
Output
8
Submitted Solution:
```
inpl = lambda: list(map(int,input().split()))
N, M, V, P = inpl()
A = inpl()
A.sort(reverse=True)
s = 0
S = []
for i in range(N):
s += A[i]
S.append(s)
S.append(0)
OK = P-1
NG = N
while NG - OK > 1:
x = (NG+OK)//2
if A[P-1] > A[x] + M:
NG = x
elif P + (N-1-x) >= V:
OK = x
else:
remain = M * (V-P-(N-1-x))
space = (x-P+1)*(A[x]+M) - (S[x-1] - S[P-2])
if remain <= space:
OK = x
else:
NG = x
print(OK+1)
```
Yes
| 70,534 | [
0.362548828125,
-0.06341552734375,
0.09808349609375,
0.06451416015625,
-0.6884765625,
-0.424072265625,
0.08612060546875,
0.319580078125,
-0.1217041015625,
1.0966796875,
0.7724609375,
-0.1820068359375,
0.25048828125,
-0.6416015625,
-0.56005859375,
-0.0440673828125,
-0.744140625,
-0.... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N problems are proposed for an upcoming contest. Problem i has an initial integer score of A_i points.
M judges are about to vote for problems they like. Each judge will choose exactly V problems, independently from the other judges, and increase the score of each chosen problem by 1.
After all M judges cast their vote, the problems will be sorted in non-increasing order of score, and the first P problems will be chosen for the problemset. Problems with the same score can be ordered arbitrarily, this order is decided by the chief judge.
How many problems out of the given N have a chance to be chosen for the problemset?
Constraints
* 2 \le N \le 10^5
* 1 \le M \le 10^9
* 1 \le V \le N - 1
* 1 \le P \le N - 1
* 0 \le A_i \le 10^9
Input
Input is given from Standard Input in the following format:
N M V P
A_1 A_2 ... A_N
Output
Print the number of problems that have a chance to be chosen for the problemset.
Examples
Input
6 1 2 2
2 1 1 3 0 2
Output
5
Input
6 1 5 2
2 1 1 3 0 2
Output
3
Input
10 4 8 5
7 2 3 6 1 6 5 4 6 5
Output
8
Submitted Solution:
```
import sys
from collections import defaultdict
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
N, M, V, P = map(int, input().split())
A = list(map(int, input().split()))
A.sort(reverse=True)
#NUM = [0] * N
#ACN = [0] * N
NUM = {}
ACN = {}
cnt = 0
mx = A[0]
# cnt and accumulation
for a in A:
d = mx - a
cnt += 1
if d in NUM:
NUM[d] += 1
else:
NUM[d] = 1
ACN[d] = cnt
# P Number Problem
PROBLEM_P = 0
p = P
for i in range(0, A[0]+1):
if NUM[i] == 0:
continue
p -= NUM[i]
if p < 0:
PROBLEM_P = i
break
if i == (A[0]+1) and p > 0:
print(N)
exit()
#print("NUM", NUM)
#print("PROBLEM_P", PROBLEM_P)
# R Number Problem
R = PROBLEM_P + M
# P-1 Problem
ans = 0
NG_POINT = (P-1) * M
NG_POINT += (N - ACN[R]) * M
MV = M * V
# p problem num
num_p = ACN[PROBLEM_P] - P
for r in range(R, -1, -1):
need_point = M
total = (need_point * NUM[r]) + NG_POINT
for q in range(r-1, PROBLEM_P, -1):
if NUM[q] == 0:
continue
total += NUM[q] * (q - r + M)
total += num_p * (PROBLEM_P - r + M)
if total >= MV:
ans = r
break
else:
NG_POINT += NUM[r] * M
print(ACN[ans])
```
No
| 70,535 | [
0.216064453125,
-0.1053466796875,
0.0306396484375,
-0.042144775390625,
-0.60400390625,
-0.280517578125,
-0.026458740234375,
0.1451416015625,
-0.07403564453125,
1.1181640625,
0.578125,
-0.30078125,
0.2423095703125,
-0.671875,
-0.6337890625,
-0.1650390625,
-0.7626953125,
-0.772949218... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N problems are proposed for an upcoming contest. Problem i has an initial integer score of A_i points.
M judges are about to vote for problems they like. Each judge will choose exactly V problems, independently from the other judges, and increase the score of each chosen problem by 1.
After all M judges cast their vote, the problems will be sorted in non-increasing order of score, and the first P problems will be chosen for the problemset. Problems with the same score can be ordered arbitrarily, this order is decided by the chief judge.
How many problems out of the given N have a chance to be chosen for the problemset?
Constraints
* 2 \le N \le 10^5
* 1 \le M \le 10^9
* 1 \le V \le N - 1
* 1 \le P \le N - 1
* 0 \le A_i \le 10^9
Input
Input is given from Standard Input in the following format:
N M V P
A_1 A_2 ... A_N
Output
Print the number of problems that have a chance to be chosen for the problemset.
Examples
Input
6 1 2 2
2 1 1 3 0 2
Output
5
Input
6 1 5 2
2 1 1 3 0 2
Output
3
Input
10 4 8 5
7 2 3 6 1 6 5 4 6 5
Output
8
Submitted Solution:
```
n,m,v,p = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
def solve(ind):
thr = a[ind] + m
votes=[]
for i in range(n):
if i<=ind or i>n-p:
votes.append(m)
else:
votes.append(thr-a[i])
sm = sum(votes)
return sm >= m*v
ok=n-1
ng=0
while abs(ng - ok) > 1:
mid = (ng + ok)//2
if solve(mid):
ok = mid
else:
ng = mid
print(n-ok)
```
No
| 70,536 | [
0.3359375,
-0.12078857421875,
-0.0623779296875,
-0.08831787109375,
-0.7080078125,
-0.432373046875,
0.143310546875,
0.30126953125,
-0.10308837890625,
1.009765625,
0.62548828125,
-0.2177734375,
0.327392578125,
-0.68408203125,
-0.5771484375,
-0.01390838623046875,
-0.77392578125,
-0.82... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N problems are proposed for an upcoming contest. Problem i has an initial integer score of A_i points.
M judges are about to vote for problems they like. Each judge will choose exactly V problems, independently from the other judges, and increase the score of each chosen problem by 1.
After all M judges cast their vote, the problems will be sorted in non-increasing order of score, and the first P problems will be chosen for the problemset. Problems with the same score can be ordered arbitrarily, this order is decided by the chief judge.
How many problems out of the given N have a chance to be chosen for the problemset?
Constraints
* 2 \le N \le 10^5
* 1 \le M \le 10^9
* 1 \le V \le N - 1
* 1 \le P \le N - 1
* 0 \le A_i \le 10^9
Input
Input is given from Standard Input in the following format:
N M V P
A_1 A_2 ... A_N
Output
Print the number of problems that have a chance to be chosen for the problemset.
Examples
Input
6 1 2 2
2 1 1 3 0 2
Output
5
Input
6 1 5 2
2 1 1 3 0 2
Output
3
Input
10 4 8 5
7 2 3 6 1 6 5 4 6 5
Output
8
Submitted Solution:
```
N, M, V, P = map(int, input().split())
A = list(map(int, input().split()))
Asorted = sorted(A)
start=-1
end = N-P
Ap = A[-P]
total = V*M
while start < end -1:
#print(start, end)
i = (start+end-1)//2
Ai = Asorted[i]
if Ai + M < Ap:
start = i+1
continue
limit = (Ai + M)*(N-P-i-1) - sum(Asorted[i+1:N-P]) + (i+P)*M
if limit >= total:
end = i+1
else:
start = i+1
print(N-start)
```
No
| 70,537 | [
0.2115478515625,
-0.00792694091796875,
-0.10064697265625,
-0.05218505859375,
-0.6416015625,
-0.378173828125,
-0.0164337158203125,
0.31396484375,
-0.08544921875,
0.9052734375,
0.5361328125,
-0.344482421875,
0.2257080078125,
-0.765625,
-0.50732421875,
0.003177642822265625,
-0.680664062... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N problems are proposed for an upcoming contest. Problem i has an initial integer score of A_i points.
M judges are about to vote for problems they like. Each judge will choose exactly V problems, independently from the other judges, and increase the score of each chosen problem by 1.
After all M judges cast their vote, the problems will be sorted in non-increasing order of score, and the first P problems will be chosen for the problemset. Problems with the same score can be ordered arbitrarily, this order is decided by the chief judge.
How many problems out of the given N have a chance to be chosen for the problemset?
Constraints
* 2 \le N \le 10^5
* 1 \le M \le 10^9
* 1 \le V \le N - 1
* 1 \le P \le N - 1
* 0 \le A_i \le 10^9
Input
Input is given from Standard Input in the following format:
N M V P
A_1 A_2 ... A_N
Output
Print the number of problems that have a chance to be chosen for the problemset.
Examples
Input
6 1 2 2
2 1 1 3 0 2
Output
5
Input
6 1 5 2
2 1 1 3 0 2
Output
3
Input
10 4 8 5
7 2 3 6 1 6 5 4 6 5
Output
8
Submitted Solution:
```
N,M,V,P = map(int, input().split())
As = list(map(int, input().split()))
As.sort(reverse=True)
# print(As)
"""
M人がV問のスコアを1挙げられる
N問のうち降順に並べたP問が採用される
6 1 2 2
2 1 1 3 0 2
方針
最小の数(-1)にVを足す
上からP-1番目までの数にMを足す
P番目の数がVを超えているかどうか判定
最小の数からindex-1
"""
x = N - (P-1)
y = max(0, V - P - 1) #除外対象
# print(P-1,y)
if y == 0:
As = As[P-1:]
else:
As = As[P-1:-y]
# 同じは弾く
As = [a for a in As if a > As[y]]
# print(As)
mx = max(As)
cnt = 0
for a in As:
if a + M >= mx:cnt+=1
print(P-1+cnt)
```
No
| 70,538 | [
0.2281494140625,
-0.03704833984375,
0.030364990234375,
-0.00963592529296875,
-0.6943359375,
-0.370849609375,
0.045379638671875,
0.326416015625,
-0.1033935546875,
1.005859375,
0.640625,
-0.1785888671875,
0.331298828125,
-0.6748046875,
-0.595703125,
-0.08551025390625,
-0.689453125,
-... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ito joined the Kyudo club after entering high school. At first, I had a hard time because the arrow didn't reach the target, but in the fall of my first year of high school, I managed to improve to the point where the arrow reached the target.
One day, my senior Kato suggested, "Why don't you participate in a recent Kyudo competition?" Ito is ready to take on the challenge of the first tournament.
In the near-field competition, four lines are shot (shooting arrows) at a time, and the number of hits (the number of hits) is recorded. Repeat this multiple times to compete for the total number of hits.
For Ito-kun, who is practicing hard for the tournament, Kato-kun decided to create a program that can calculate the total middle number assuming the actual performance.
This program reads the total number of shots n and the number of hits each time, and outputs the total number of hits.
For example, if the total number of shots is 20, then 4 lines are shot 5 times at a time, so enter the number of hits 5 times.
Input
Multiple datasets are given as input.
The first line of each dataset is given n (an integer that is a multiple of 4). Then n / 4 integers are given on each line to indicate the number of hits each time.
When n is 0, it indicates the end of input. Do not output to this input.
Output
For each dataset, print the total middle number on one line.
Example
Input
20
4
3
2
1
3
8
2
0
0
Output
13
2
Submitted Solution:
```
while True:
n = int(input())
if n == 0: break
print(sum([int(input()) for _ in range(n//4)]))
```
Yes
| 70,685 | [
0.117919921875,
0.3173828125,
-0.31689453125,
-0.0594482421875,
-0.462890625,
-0.494140625,
-0.1746826171875,
0.294921875,
0.419677734375,
0.86962890625,
0.70947265625,
0.2279052734375,
0.1846923828125,
-0.693359375,
-0.59521484375,
0.2396240234375,
-0.59326171875,
-0.67333984375,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ito joined the Kyudo club after entering high school. At first, I had a hard time because the arrow didn't reach the target, but in the fall of my first year of high school, I managed to improve to the point where the arrow reached the target.
One day, my senior Kato suggested, "Why don't you participate in a recent Kyudo competition?" Ito is ready to take on the challenge of the first tournament.
In the near-field competition, four lines are shot (shooting arrows) at a time, and the number of hits (the number of hits) is recorded. Repeat this multiple times to compete for the total number of hits.
For Ito-kun, who is practicing hard for the tournament, Kato-kun decided to create a program that can calculate the total middle number assuming the actual performance.
This program reads the total number of shots n and the number of hits each time, and outputs the total number of hits.
For example, if the total number of shots is 20, then 4 lines are shot 5 times at a time, so enter the number of hits 5 times.
Input
Multiple datasets are given as input.
The first line of each dataset is given n (an integer that is a multiple of 4). Then n / 4 integers are given on each line to indicate the number of hits each time.
When n is 0, it indicates the end of input. Do not output to this input.
Output
For each dataset, print the total middle number on one line.
Example
Input
20
4
3
2
1
3
8
2
0
0
Output
13
2
Submitted Solution:
```
import sys
n=int(input())
A=[]
def kyuudou(n):
sum=0
for i in range(n//4):
hit=int(input())
sum+=hit
A.append(sum)
ni=int(input())
if ni==0:
sys.exit
else:
kyuudou(ni)
kyuudou(n)
for j in range(len(A)):
print(A[j])
```
Yes
| 70,686 | [
0.10247802734375,
0.2900390625,
-0.34423828125,
-0.0906982421875,
-0.5205078125,
-0.4580078125,
-0.2041015625,
0.32861328125,
0.46337890625,
0.87646484375,
0.654296875,
0.2037353515625,
0.2154541015625,
-0.6298828125,
-0.61083984375,
0.28076171875,
-0.60693359375,
-0.7080078125,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ito joined the Kyudo club after entering high school. At first, I had a hard time because the arrow didn't reach the target, but in the fall of my first year of high school, I managed to improve to the point where the arrow reached the target.
One day, my senior Kato suggested, "Why don't you participate in a recent Kyudo competition?" Ito is ready to take on the challenge of the first tournament.
In the near-field competition, four lines are shot (shooting arrows) at a time, and the number of hits (the number of hits) is recorded. Repeat this multiple times to compete for the total number of hits.
For Ito-kun, who is practicing hard for the tournament, Kato-kun decided to create a program that can calculate the total middle number assuming the actual performance.
This program reads the total number of shots n and the number of hits each time, and outputs the total number of hits.
For example, if the total number of shots is 20, then 4 lines are shot 5 times at a time, so enter the number of hits 5 times.
Input
Multiple datasets are given as input.
The first line of each dataset is given n (an integer that is a multiple of 4). Then n / 4 integers are given on each line to indicate the number of hits each time.
When n is 0, it indicates the end of input. Do not output to this input.
Output
For each dataset, print the total middle number on one line.
Example
Input
20
4
3
2
1
3
8
2
0
0
Output
13
2
Submitted Solution:
```
while 1:
s,n=0,int(input())
if n==0:break
print(sum([int(input()) for _ in range(n//4)]))
```
Yes
| 70,687 | [
0.11572265625,
0.337158203125,
-0.3291015625,
-0.0675048828125,
-0.457275390625,
-0.498291015625,
-0.178466796875,
0.29541015625,
0.4208984375,
0.86572265625,
0.70068359375,
0.229248046875,
0.192626953125,
-0.7001953125,
-0.591796875,
0.2412109375,
-0.5947265625,
-0.67626953125,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ito joined the Kyudo club after entering high school. At first, I had a hard time because the arrow didn't reach the target, but in the fall of my first year of high school, I managed to improve to the point where the arrow reached the target.
One day, my senior Kato suggested, "Why don't you participate in a recent Kyudo competition?" Ito is ready to take on the challenge of the first tournament.
In the near-field competition, four lines are shot (shooting arrows) at a time, and the number of hits (the number of hits) is recorded. Repeat this multiple times to compete for the total number of hits.
For Ito-kun, who is practicing hard for the tournament, Kato-kun decided to create a program that can calculate the total middle number assuming the actual performance.
This program reads the total number of shots n and the number of hits each time, and outputs the total number of hits.
For example, if the total number of shots is 20, then 4 lines are shot 5 times at a time, so enter the number of hits 5 times.
Input
Multiple datasets are given as input.
The first line of each dataset is given n (an integer that is a multiple of 4). Then n / 4 integers are given on each line to indicate the number of hits each time.
When n is 0, it indicates the end of input. Do not output to this input.
Output
For each dataset, print the total middle number on one line.
Example
Input
20
4
3
2
1
3
8
2
0
0
Output
13
2
Submitted Solution:
```
while 1:
n = int(input())
if (n == 0):
break
cnt=[int(input()) for i in range(int(n/4))]
print(sum(cnt))
```
Yes
| 70,688 | [
0.126220703125,
0.31298828125,
-0.319091796875,
-0.07733154296875,
-0.435546875,
-0.5,
-0.1700439453125,
0.28076171875,
0.42626953125,
0.8916015625,
0.689453125,
0.2313232421875,
0.1829833984375,
-0.69677734375,
-0.60009765625,
0.211669921875,
-0.6083984375,
-0.685546875,
-0.5283... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ito joined the Kyudo club after entering high school. At first, I had a hard time because the arrow didn't reach the target, but in the fall of my first year of high school, I managed to improve to the point where the arrow reached the target.
One day, my senior Kato suggested, "Why don't you participate in a recent Kyudo competition?" Ito is ready to take on the challenge of the first tournament.
In the near-field competition, four lines are shot (shooting arrows) at a time, and the number of hits (the number of hits) is recorded. Repeat this multiple times to compete for the total number of hits.
For Ito-kun, who is practicing hard for the tournament, Kato-kun decided to create a program that can calculate the total middle number assuming the actual performance.
This program reads the total number of shots n and the number of hits each time, and outputs the total number of hits.
For example, if the total number of shots is 20, then 4 lines are shot 5 times at a time, so enter the number of hits 5 times.
Input
Multiple datasets are given as input.
The first line of each dataset is given n (an integer that is a multiple of 4). Then n / 4 integers are given on each line to indicate the number of hits each time.
When n is 0, it indicates the end of input. Do not output to this input.
Output
For each dataset, print the total middle number on one line.
Example
Input
20
4
3
2
1
3
8
2
0
0
Output
13
2
Submitted Solution:
```
while True:
n = int(input())
if n == 0: break
print(sum([int(input()) for _ in range(n)]))
```
No
| 70,689 | [
0.1142578125,
0.31884765625,
-0.312255859375,
-0.056427001953125,
-0.459228515625,
-0.50048828125,
-0.1688232421875,
0.296875,
0.41943359375,
0.87939453125,
0.7109375,
0.2301025390625,
0.1766357421875,
-0.6953125,
-0.59375,
0.234375,
-0.59912109375,
-0.6669921875,
-0.51318359375,... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ito joined the Kyudo club after entering high school. At first, I had a hard time because the arrow didn't reach the target, but in the fall of my first year of high school, I managed to improve to the point where the arrow reached the target.
One day, my senior Kato suggested, "Why don't you participate in a recent Kyudo competition?" Ito is ready to take on the challenge of the first tournament.
In the near-field competition, four lines are shot (shooting arrows) at a time, and the number of hits (the number of hits) is recorded. Repeat this multiple times to compete for the total number of hits.
For Ito-kun, who is practicing hard for the tournament, Kato-kun decided to create a program that can calculate the total middle number assuming the actual performance.
This program reads the total number of shots n and the number of hits each time, and outputs the total number of hits.
For example, if the total number of shots is 20, then 4 lines are shot 5 times at a time, so enter the number of hits 5 times.
Input
Multiple datasets are given as input.
The first line of each dataset is given n (an integer that is a multiple of 4). Then n / 4 integers are given on each line to indicate the number of hits each time.
When n is 0, it indicates the end of input. Do not output to this input.
Output
For each dataset, print the total middle number on one line.
Example
Input
20
4
3
2
1
3
8
2
0
0
Output
13
2
Submitted Solution:
```
while True:
n = int(input())
if n == 0: break
print(sum([int(input()) for _ in range(n//5)]))
```
No
| 70,690 | [
0.1138916015625,
0.31884765625,
-0.31298828125,
-0.061553955078125,
-0.4599609375,
-0.497314453125,
-0.16845703125,
0.2919921875,
0.41552734375,
0.87646484375,
0.70947265625,
0.2265625,
0.1849365234375,
-0.69189453125,
-0.5927734375,
0.232666015625,
-0.6044921875,
-0.6748046875,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the game of Mastermind, there are two players — Alice and Bob. Alice has a secret code, which Bob tries to guess. Here, a code is defined as a sequence of n colors. There are exactly n+1 colors in the entire universe, numbered from 1 to n+1 inclusive.
When Bob guesses a code, Alice tells him some information about how good of a guess it is, in the form of two integers x and y.
The first integer x is the number of indices where Bob's guess correctly matches Alice's code. The second integer y is the size of the intersection of the two codes as multisets. That is, if Bob were to change the order of the colors in his guess, y is the maximum number of indices he could get correct.
For example, suppose n=5, Alice's code is [3,1,6,1,2], and Bob's guess is [3,1,1,2,5]. At indices 1 and 2 colors are equal, while in the other indices they are not equal. So x=2. And the two codes have the four colors 1,1,2,3 in common, so y=4.
<image> Solid lines denote a matched color for the same index. Dashed lines denote a matched color at a different index. x is the number of solid lines, and y is the total number of lines.
You are given Bob's guess and two values x and y. Can you find one possibility of Alice's code so that the values of x and y are correct?
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains three integers n,x,y (1≤ n≤ 10^5, 0≤ x≤ y≤ n) — the length of the codes, and two values Alice responds with.
The second line of each test case contains n integers b_1,…,b_n (1≤ b_i≤ n+1) — Bob's guess, where b_i is the i-th color of the guess.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, on the first line, output "YES" if there is a solution, or "NO" if there is no possible secret code consistent with the described situation. You can print each character in any case (upper or lower).
If the answer is "YES", on the next line output n integers a_1,…,a_n (1≤ a_i≤ n+1) — Alice's secret code, where a_i is the i-th color of the code.
If there are multiple solutions, output any.
Example
Input
7
5 2 4
3 1 1 2 5
5 3 4
1 1 2 1 2
4 0 4
5 5 3 3
4 1 4
2 3 2 3
6 1 2
3 2 1 1 1 1
6 2 4
3 3 2 1 1 1
6 2 6
1 1 3 2 1 1
Output
YES
3 1 6 1 2
YES
3 1 1 1 2
YES
3 3 5 5
NO
YES
4 4 4 4 3 1
YES
3 1 3 1 7 7
YES
2 3 1 1 1 1
Note
The first test case is described in the statement.
In the second test case, x=3 because the colors are equal at indices 2,4,5. And y=4 because they share the colors 1,1,1,2.
In the third test case, x=0 because there is no index where the colors are the same. But y=4 because they share the colors 3,3,5,5.
In the fourth test case, it can be proved that no solution exists.
Submitted Solution:
```
from sys import stdin, stdout
from collections import defaultdict
from heapq import heapify, heappop, heappush
def solve():
n, s, y = map(int, stdin.readline().split())
a = stdin.readline().split()
d = defaultdict(list)
for i, x in enumerate(a):
d[x].append(i)
for i in range(1, n + 2):
e = str(i)
if e not in d:
break
q = [(-len(d[x]), x) for x in d.keys()]
heapify(q)
ans = [0] * n
for i in range(s):
l, x = heappop(q)
ans[d[x].pop()] = x
l += 1
if l:
heappush(q, (l, x))
p = []
while q:
l, x = heappop(q)
p.extend(d[x])
if p:
h = (n - s) // 2
y = n - y
q = p[h:] + p[:h]
for x, z in zip(p, q):
if a[x] == a[z]:
if y:
ans[x] = e
y -= 1
else:
stdout.write("NO\n")
return
else:
ans[x] = a[z]
for i in range(n - s):
if y and ans[p[i]] != e:
ans[p[i]] = e
y -= 1
stdout.write("YES\n")
stdout.write(' '.join(ans))
stdout.write("\n")
T = int(stdin.readline())
for t in range(T):
solve()
```
Yes
| 70,906 | [
0.466552734375,
-0.27001953125,
-0.0017576217651367188,
0.1588134765625,
-0.4599609375,
-0.6708984375,
-0.06756591796875,
-0.03875732421875,
0.081787109375,
1.1787109375,
0.701171875,
-0.057525634765625,
0.272216796875,
-0.662109375,
-0.343994140625,
0.049774169921875,
-0.49194335937... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the game of Mastermind, there are two players — Alice and Bob. Alice has a secret code, which Bob tries to guess. Here, a code is defined as a sequence of n colors. There are exactly n+1 colors in the entire universe, numbered from 1 to n+1 inclusive.
When Bob guesses a code, Alice tells him some information about how good of a guess it is, in the form of two integers x and y.
The first integer x is the number of indices where Bob's guess correctly matches Alice's code. The second integer y is the size of the intersection of the two codes as multisets. That is, if Bob were to change the order of the colors in his guess, y is the maximum number of indices he could get correct.
For example, suppose n=5, Alice's code is [3,1,6,1,2], and Bob's guess is [3,1,1,2,5]. At indices 1 and 2 colors are equal, while in the other indices they are not equal. So x=2. And the two codes have the four colors 1,1,2,3 in common, so y=4.
<image> Solid lines denote a matched color for the same index. Dashed lines denote a matched color at a different index. x is the number of solid lines, and y is the total number of lines.
You are given Bob's guess and two values x and y. Can you find one possibility of Alice's code so that the values of x and y are correct?
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains three integers n,x,y (1≤ n≤ 10^5, 0≤ x≤ y≤ n) — the length of the codes, and two values Alice responds with.
The second line of each test case contains n integers b_1,…,b_n (1≤ b_i≤ n+1) — Bob's guess, where b_i is the i-th color of the guess.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, on the first line, output "YES" if there is a solution, or "NO" if there is no possible secret code consistent with the described situation. You can print each character in any case (upper or lower).
If the answer is "YES", on the next line output n integers a_1,…,a_n (1≤ a_i≤ n+1) — Alice's secret code, where a_i is the i-th color of the code.
If there are multiple solutions, output any.
Example
Input
7
5 2 4
3 1 1 2 5
5 3 4
1 1 2 1 2
4 0 4
5 5 3 3
4 1 4
2 3 2 3
6 1 2
3 2 1 1 1 1
6 2 4
3 3 2 1 1 1
6 2 6
1 1 3 2 1 1
Output
YES
3 1 6 1 2
YES
3 1 1 1 2
YES
3 3 5 5
NO
YES
4 4 4 4 3 1
YES
3 1 3 1 7 7
YES
2 3 1 1 1 1
Note
The first test case is described in the statement.
In the second test case, x=3 because the colors are equal at indices 2,4,5. And y=4 because they share the colors 1,1,1,2.
In the third test case, x=0 because there is no index where the colors are the same. But y=4 because they share the colors 3,3,5,5.
In the fourth test case, it can be proved that no solution exists.
Submitted Solution:
```
from collections import defaultdict
from heapq import heapify, heappop, heappush
def solve():
n, s, y = map(int, input().split())
a = input().split()
d = defaultdict(list)
for i, x in enumerate(a):
d[x].append(i)
for i in range(1, n + 2):
e = str(i)
if e not in d:
break
q = [(-len(d[x]), x) for x in d.keys()]
heapify(q)
ans = [0] * n
for i in range(s):
l, x = heappop(q)
ans[d[x].pop()] = x
l += 1
if l:
heappush(q, (l, x))
p = []
while q:
l, x = heappop(q)
p.extend(d[x])
if p:
h = (n - s) // 2
y = n - y
q = p[h:] + p[:h]
for x, z in zip(p, q):
if a[x] == a[z]:
if y:ans[x] = e;y -= 1
else:print("NO");return
else:ans[x] = a[z]
for i in range(n - s):
if y and ans[p[i]] != e:ans[p[i]] = e;y -= 1
print("YES");print(' '.join(ans))
for t in range(int(input())):solve()
```
Yes
| 70,907 | [
0.466552734375,
-0.27001953125,
-0.0017576217651367188,
0.1588134765625,
-0.4599609375,
-0.6708984375,
-0.06756591796875,
-0.03875732421875,
0.081787109375,
1.1787109375,
0.701171875,
-0.057525634765625,
0.272216796875,
-0.662109375,
-0.343994140625,
0.049774169921875,
-0.49194335937... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the game of Mastermind, there are two players — Alice and Bob. Alice has a secret code, which Bob tries to guess. Here, a code is defined as a sequence of n colors. There are exactly n+1 colors in the entire universe, numbered from 1 to n+1 inclusive.
When Bob guesses a code, Alice tells him some information about how good of a guess it is, in the form of two integers x and y.
The first integer x is the number of indices where Bob's guess correctly matches Alice's code. The second integer y is the size of the intersection of the two codes as multisets. That is, if Bob were to change the order of the colors in his guess, y is the maximum number of indices he could get correct.
For example, suppose n=5, Alice's code is [3,1,6,1,2], and Bob's guess is [3,1,1,2,5]. At indices 1 and 2 colors are equal, while in the other indices they are not equal. So x=2. And the two codes have the four colors 1,1,2,3 in common, so y=4.
<image> Solid lines denote a matched color for the same index. Dashed lines denote a matched color at a different index. x is the number of solid lines, and y is the total number of lines.
You are given Bob's guess and two values x and y. Can you find one possibility of Alice's code so that the values of x and y are correct?
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains three integers n,x,y (1≤ n≤ 10^5, 0≤ x≤ y≤ n) — the length of the codes, and two values Alice responds with.
The second line of each test case contains n integers b_1,…,b_n (1≤ b_i≤ n+1) — Bob's guess, where b_i is the i-th color of the guess.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, on the first line, output "YES" if there is a solution, or "NO" if there is no possible secret code consistent with the described situation. You can print each character in any case (upper or lower).
If the answer is "YES", on the next line output n integers a_1,…,a_n (1≤ a_i≤ n+1) — Alice's secret code, where a_i is the i-th color of the code.
If there are multiple solutions, output any.
Example
Input
7
5 2 4
3 1 1 2 5
5 3 4
1 1 2 1 2
4 0 4
5 5 3 3
4 1 4
2 3 2 3
6 1 2
3 2 1 1 1 1
6 2 4
3 3 2 1 1 1
6 2 6
1 1 3 2 1 1
Output
YES
3 1 6 1 2
YES
3 1 1 1 2
YES
3 3 5 5
NO
YES
4 4 4 4 3 1
YES
3 1 3 1 7 7
YES
2 3 1 1 1 1
Note
The first test case is described in the statement.
In the second test case, x=3 because the colors are equal at indices 2,4,5. And y=4 because they share the colors 1,1,1,2.
In the third test case, x=0 because there is no index where the colors are the same. But y=4 because they share the colors 3,3,5,5.
In the fourth test case, it can be proved that no solution exists.
Submitted Solution:
```
from collections import defaultdict
from heapq import heapify, heappop, heappush
def solve():
n, s, y = map(int, input().split())
a = input().split()
d = defaultdict(list)
for i, x in enumerate(a):
d[x].append(i)
for i in range(1, n + 2):
e = str(i)
if e not in d:break
q = [(-len(d[x]), x) for x in d.keys()]
heapify(q)
ans,p = [0] * n,[]
for i in range(s):
l, x = heappop(q);ans[d[x].pop()] = x;l += 1
if l:heappush(q, (l, x))
while q:l, x = heappop(q);p.extend(d[x])
if p:
h = (n - s) // 2;y = n - y;q = p[h:] + p[:h]
for x, z in zip(p, q):
if a[x] == a[z]:
if y:ans[x] = e;y -= 1
else:print("NO");return
else:ans[x] = a[z]
for i in range(n - s):
if y and ans[p[i]] != e:ans[p[i]] = e;y -= 1
print("YES");print(' '.join(ans))
for t in range(int(input())):solve()
```
Yes
| 70,908 | [
0.466552734375,
-0.27001953125,
-0.0017576217651367188,
0.1588134765625,
-0.4599609375,
-0.6708984375,
-0.06756591796875,
-0.03875732421875,
0.081787109375,
1.1787109375,
0.701171875,
-0.057525634765625,
0.272216796875,
-0.662109375,
-0.343994140625,
0.049774169921875,
-0.49194335937... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the game of Mastermind, there are two players — Alice and Bob. Alice has a secret code, which Bob tries to guess. Here, a code is defined as a sequence of n colors. There are exactly n+1 colors in the entire universe, numbered from 1 to n+1 inclusive.
When Bob guesses a code, Alice tells him some information about how good of a guess it is, in the form of two integers x and y.
The first integer x is the number of indices where Bob's guess correctly matches Alice's code. The second integer y is the size of the intersection of the two codes as multisets. That is, if Bob were to change the order of the colors in his guess, y is the maximum number of indices he could get correct.
For example, suppose n=5, Alice's code is [3,1,6,1,2], and Bob's guess is [3,1,1,2,5]. At indices 1 and 2 colors are equal, while in the other indices they are not equal. So x=2. And the two codes have the four colors 1,1,2,3 in common, so y=4.
<image> Solid lines denote a matched color for the same index. Dashed lines denote a matched color at a different index. x is the number of solid lines, and y is the total number of lines.
You are given Bob's guess and two values x and y. Can you find one possibility of Alice's code so that the values of x and y are correct?
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains three integers n,x,y (1≤ n≤ 10^5, 0≤ x≤ y≤ n) — the length of the codes, and two values Alice responds with.
The second line of each test case contains n integers b_1,…,b_n (1≤ b_i≤ n+1) — Bob's guess, where b_i is the i-th color of the guess.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, on the first line, output "YES" if there is a solution, or "NO" if there is no possible secret code consistent with the described situation. You can print each character in any case (upper or lower).
If the answer is "YES", on the next line output n integers a_1,…,a_n (1≤ a_i≤ n+1) — Alice's secret code, where a_i is the i-th color of the code.
If there are multiple solutions, output any.
Example
Input
7
5 2 4
3 1 1 2 5
5 3 4
1 1 2 1 2
4 0 4
5 5 3 3
4 1 4
2 3 2 3
6 1 2
3 2 1 1 1 1
6 2 4
3 3 2 1 1 1
6 2 6
1 1 3 2 1 1
Output
YES
3 1 6 1 2
YES
3 1 1 1 2
YES
3 3 5 5
NO
YES
4 4 4 4 3 1
YES
3 1 3 1 7 7
YES
2 3 1 1 1 1
Note
The first test case is described in the statement.
In the second test case, x=3 because the colors are equal at indices 2,4,5. And y=4 because they share the colors 1,1,1,2.
In the third test case, x=0 because there is no index where the colors are the same. But y=4 because they share the colors 3,3,5,5.
In the fourth test case, it can be proved that no solution exists.
Submitted Solution:
```
import collections
t = int(input())
for _ in range(t):
# print('time', _)
n, x, y = map(int, input().split())
b = [int(i) for i in input().split()]
if t == 1000 and _ != 39:
continue
if t == 1000:
print(n, x, y)
print(b)
if x == n:
print("YES")
for i in b:
print(b, end = '')
print()
continue
setB = set(b)
noin = 1
while noin in setB:
noin += 1
cnt = collections.deque([i, j] for i, j in collections.Counter(b).most_common())
cnt2 = collections.deque()
pos = [set() for _ in range(n + 2)]
for i in range(len(b)):
pos[b[i]].add(i)
res=[-1] * n
l = x
while l > 0:
i = cnt.popleft()
i[1] -= 1
if i[1] != 0:
cnt2.appendleft(i)
while not cnt or cnt2 and cnt2[0][1] >= cnt[0][1]:
cnt.appendleft(cnt2.popleft())
p = pos[i[0]].pop()
res[p] = i[0]
l -= 1
ml = cnt[0][1]
remain = []
while cnt:
i, j = cnt.popleft()
remain += [i] * j
while cnt2:
i, j =cnt2.popleft()
remain += [i] * j
if y - x > (len(remain) - ml) * 2 :
print('No')
continue
i = 0
match = [0] * len(remain)
for i in range(ml, ml + y - x):
match[i % len(remain)] = remain[(i + ml) % len(remain)]
for i in range(ml + y - x, ml + len(remain)):
match[i % len(remain)] = noin
# print(match, remain)
for i in range(len(match)):
p = pos[remain[i]].pop()
res[p] = match[i]
if l == 0:
print("YES")
for i in res:
print(i, end=' ')
print()
else:
print("No")
```
No
| 70,909 | [
0.466552734375,
-0.27001953125,
-0.0017576217651367188,
0.1588134765625,
-0.4599609375,
-0.6708984375,
-0.06756591796875,
-0.03875732421875,
0.081787109375,
1.1787109375,
0.701171875,
-0.057525634765625,
0.272216796875,
-0.662109375,
-0.343994140625,
0.049774169921875,
-0.49194335937... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the game of Mastermind, there are two players — Alice and Bob. Alice has a secret code, which Bob tries to guess. Here, a code is defined as a sequence of n colors. There are exactly n+1 colors in the entire universe, numbered from 1 to n+1 inclusive.
When Bob guesses a code, Alice tells him some information about how good of a guess it is, in the form of two integers x and y.
The first integer x is the number of indices where Bob's guess correctly matches Alice's code. The second integer y is the size of the intersection of the two codes as multisets. That is, if Bob were to change the order of the colors in his guess, y is the maximum number of indices he could get correct.
For example, suppose n=5, Alice's code is [3,1,6,1,2], and Bob's guess is [3,1,1,2,5]. At indices 1 and 2 colors are equal, while in the other indices they are not equal. So x=2. And the two codes have the four colors 1,1,2,3 in common, so y=4.
<image> Solid lines denote a matched color for the same index. Dashed lines denote a matched color at a different index. x is the number of solid lines, and y is the total number of lines.
You are given Bob's guess and two values x and y. Can you find one possibility of Alice's code so that the values of x and y are correct?
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains three integers n,x,y (1≤ n≤ 10^5, 0≤ x≤ y≤ n) — the length of the codes, and two values Alice responds with.
The second line of each test case contains n integers b_1,…,b_n (1≤ b_i≤ n+1) — Bob's guess, where b_i is the i-th color of the guess.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, on the first line, output "YES" if there is a solution, or "NO" if there is no possible secret code consistent with the described situation. You can print each character in any case (upper or lower).
If the answer is "YES", on the next line output n integers a_1,…,a_n (1≤ a_i≤ n+1) — Alice's secret code, where a_i is the i-th color of the code.
If there are multiple solutions, output any.
Example
Input
7
5 2 4
3 1 1 2 5
5 3 4
1 1 2 1 2
4 0 4
5 5 3 3
4 1 4
2 3 2 3
6 1 2
3 2 1 1 1 1
6 2 4
3 3 2 1 1 1
6 2 6
1 1 3 2 1 1
Output
YES
3 1 6 1 2
YES
3 1 1 1 2
YES
3 3 5 5
NO
YES
4 4 4 4 3 1
YES
3 1 3 1 7 7
YES
2 3 1 1 1 1
Note
The first test case is described in the statement.
In the second test case, x=3 because the colors are equal at indices 2,4,5. And y=4 because they share the colors 1,1,1,2.
In the third test case, x=0 because there is no index where the colors are the same. But y=4 because they share the colors 3,3,5,5.
In the fourth test case, it can be proved that no solution exists.
Submitted Solution:
```
import collections
t = int(input())
for _ in range(t):
# print('time', _)
n, x, y = map(int, input().split())
b = [int(i) for i in input().split()]
if x == n:
print("YES")
for i in b:
print(i, end = '')
print()
continue
setB = set(b)
noin = 1
while noin in setB:
noin += 1
cnt = collections.deque([i, j] for i, j in collections.Counter(b).most_common())
cnt2 = collections.deque()
pos = [set() for _ in range(n + 2)]
for i in range(len(b)):
pos[b[i]].add(i)
res=[-1] * n
l = x
while l > 0:
i = cnt.popleft()
i[1] -= 1
if i[1] != 0:
cnt2.appendleft(i)
while not cnt or cnt2 and cnt2[0][1] >= cnt[0][1]:
cnt.appendleft(cnt2.popleft())
p = pos[i[0]].pop()
res[p] = i[0]
l -= 1
ml = cnt[0][1]
remain = []
while cnt:
i, j = cnt.popleft()
remain += [i] * j
while cnt2:
i, j =cnt2.popleft()
remain += [i] * j
if y - x > (len(remain) - ml) * 2 :
print('No')
continue
i = 0
match = [0] * len(remain)
for i in range(ml, ml + y - x):
match[i % len(remain)] = remain[(i + ml) % len(remain)]
for i in range(ml + y - x, ml + len(remain)):
match[i % len(remain)] = noin
# print(match, remain)
for i in range(len(match)):
p = pos[remain[i]].pop()
res[p] = match[i]
if l == 0:
print("YES")
for i in res:
print(i, end=' ')
print()
else:
print("No")
```
No
| 70,910 | [
0.466552734375,
-0.27001953125,
-0.0017576217651367188,
0.1588134765625,
-0.4599609375,
-0.6708984375,
-0.06756591796875,
-0.03875732421875,
0.081787109375,
1.1787109375,
0.701171875,
-0.057525634765625,
0.272216796875,
-0.662109375,
-0.343994140625,
0.049774169921875,
-0.49194335937... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the game of Mastermind, there are two players — Alice and Bob. Alice has a secret code, which Bob tries to guess. Here, a code is defined as a sequence of n colors. There are exactly n+1 colors in the entire universe, numbered from 1 to n+1 inclusive.
When Bob guesses a code, Alice tells him some information about how good of a guess it is, in the form of two integers x and y.
The first integer x is the number of indices where Bob's guess correctly matches Alice's code. The second integer y is the size of the intersection of the two codes as multisets. That is, if Bob were to change the order of the colors in his guess, y is the maximum number of indices he could get correct.
For example, suppose n=5, Alice's code is [3,1,6,1,2], and Bob's guess is [3,1,1,2,5]. At indices 1 and 2 colors are equal, while in the other indices they are not equal. So x=2. And the two codes have the four colors 1,1,2,3 in common, so y=4.
<image> Solid lines denote a matched color for the same index. Dashed lines denote a matched color at a different index. x is the number of solid lines, and y is the total number of lines.
You are given Bob's guess and two values x and y. Can you find one possibility of Alice's code so that the values of x and y are correct?
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains three integers n,x,y (1≤ n≤ 10^5, 0≤ x≤ y≤ n) — the length of the codes, and two values Alice responds with.
The second line of each test case contains n integers b_1,…,b_n (1≤ b_i≤ n+1) — Bob's guess, where b_i is the i-th color of the guess.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, on the first line, output "YES" if there is a solution, or "NO" if there is no possible secret code consistent with the described situation. You can print each character in any case (upper or lower).
If the answer is "YES", on the next line output n integers a_1,…,a_n (1≤ a_i≤ n+1) — Alice's secret code, where a_i is the i-th color of the code.
If there are multiple solutions, output any.
Example
Input
7
5 2 4
3 1 1 2 5
5 3 4
1 1 2 1 2
4 0 4
5 5 3 3
4 1 4
2 3 2 3
6 1 2
3 2 1 1 1 1
6 2 4
3 3 2 1 1 1
6 2 6
1 1 3 2 1 1
Output
YES
3 1 6 1 2
YES
3 1 1 1 2
YES
3 3 5 5
NO
YES
4 4 4 4 3 1
YES
3 1 3 1 7 7
YES
2 3 1 1 1 1
Note
The first test case is described in the statement.
In the second test case, x=3 because the colors are equal at indices 2,4,5. And y=4 because they share the colors 1,1,1,2.
In the third test case, x=0 because there is no index where the colors are the same. But y=4 because they share the colors 3,3,5,5.
In the fourth test case, it can be proved that no solution exists.
Submitted Solution:
```
import collections
t = int(input())
for _ in range(t):
# print('time', _)
n, x, y = map(int, input().split())
b = [int(i) for i in input().split()]
if x == n:
print("YES")
for i in b:
print(b, end = '')
print()
continue
setB = set(b)
noin = 1
while noin in setB:
noin += 1
cnt = collections.deque([i, j] for i, j in collections.Counter(b).most_common())
cnt2 = collections.deque()
pos = [set() for _ in range(n + 2)]
for i in range(len(b)):
pos[b[i]].add(i)
res=[-1] * n
l = x
while l > 0:
i = cnt.popleft()
i[1] -= 1
if i[1] != 0:
cnt2.appendleft(i)
while not cnt or cnt2 and cnt2[0][1] >= cnt[0][1]:
cnt.appendleft(cnt2.popleft())
p = pos[i[0]].pop()
res[p] = i[0]
l -= 1
ml = cnt[0][1]
remain = []
while cnt:
i, j = cnt.popleft()
remain += [i] * j
while cnt2:
i, j =cnt2.popleft()
remain += [i] * j
if y - x > (len(remain) - ml) * 2:
print('No')
continue
i = 0
match = [0] * len(remain)
for i in range(ml, ml + y - x):
match[i % len(remain)] = remain[(i + ml) % len(remain)]
for i in range(ml + y - x, ml + len(remain)):
match[i % len(remain)] = noin
# print(match, remain)
for i in range(len(match)):
p = pos[remain[i]].pop()
res[p] = match[i]
if l == 0:
print("YES")
for i in res:
print(i, end=' ')
print()
else:
print("No")
```
No
| 70,911 | [
0.466552734375,
-0.27001953125,
-0.0017576217651367188,
0.1588134765625,
-0.4599609375,
-0.6708984375,
-0.06756591796875,
-0.03875732421875,
0.081787109375,
1.1787109375,
0.701171875,
-0.057525634765625,
0.272216796875,
-0.662109375,
-0.343994140625,
0.049774169921875,
-0.49194335937... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the game of Mastermind, there are two players — Alice and Bob. Alice has a secret code, which Bob tries to guess. Here, a code is defined as a sequence of n colors. There are exactly n+1 colors in the entire universe, numbered from 1 to n+1 inclusive.
When Bob guesses a code, Alice tells him some information about how good of a guess it is, in the form of two integers x and y.
The first integer x is the number of indices where Bob's guess correctly matches Alice's code. The second integer y is the size of the intersection of the two codes as multisets. That is, if Bob were to change the order of the colors in his guess, y is the maximum number of indices he could get correct.
For example, suppose n=5, Alice's code is [3,1,6,1,2], and Bob's guess is [3,1,1,2,5]. At indices 1 and 2 colors are equal, while in the other indices they are not equal. So x=2. And the two codes have the four colors 1,1,2,3 in common, so y=4.
<image> Solid lines denote a matched color for the same index. Dashed lines denote a matched color at a different index. x is the number of solid lines, and y is the total number of lines.
You are given Bob's guess and two values x and y. Can you find one possibility of Alice's code so that the values of x and y are correct?
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains three integers n,x,y (1≤ n≤ 10^5, 0≤ x≤ y≤ n) — the length of the codes, and two values Alice responds with.
The second line of each test case contains n integers b_1,…,b_n (1≤ b_i≤ n+1) — Bob's guess, where b_i is the i-th color of the guess.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, on the first line, output "YES" if there is a solution, or "NO" if there is no possible secret code consistent with the described situation. You can print each character in any case (upper or lower).
If the answer is "YES", on the next line output n integers a_1,…,a_n (1≤ a_i≤ n+1) — Alice's secret code, where a_i is the i-th color of the code.
If there are multiple solutions, output any.
Example
Input
7
5 2 4
3 1 1 2 5
5 3 4
1 1 2 1 2
4 0 4
5 5 3 3
4 1 4
2 3 2 3
6 1 2
3 2 1 1 1 1
6 2 4
3 3 2 1 1 1
6 2 6
1 1 3 2 1 1
Output
YES
3 1 6 1 2
YES
3 1 1 1 2
YES
3 3 5 5
NO
YES
4 4 4 4 3 1
YES
3 1 3 1 7 7
YES
2 3 1 1 1 1
Note
The first test case is described in the statement.
In the second test case, x=3 because the colors are equal at indices 2,4,5. And y=4 because they share the colors 1,1,1,2.
In the third test case, x=0 because there is no index where the colors are the same. But y=4 because they share the colors 3,3,5,5.
In the fourth test case, it can be proved that no solution exists.
Submitted Solution:
```
from collections import defaultdict
import heapq
T = int(input())
for _ in range(T):
N, X, Y = [int(x) for x in input().split(' ')]
b = [(i, int(x)) for i, x in enumerate(input().split(' '))]
freq = defaultdict(int)
for _, x in b:
freq[x] += 1
b.sort(key=lambda x: (x[1], x[0]))
heap = [(-y, x) for x, y in freq.items()]
heapq.heapify(heap)
c = []
for _ in range(X):
x, y = heapq.heappop(heap)
c.append(y)
if x != 0:
heapq.heappush(heap, (x+1, y))
d = []
for x, y in heap:
for _ in range(-x):
d.append(y)
d.sort()
freq = defaultdict(int)
for x in d:
freq[x] += 1
rot = max(freq.values())
c += d[-rot:] + d[:-rot]
unused = list(set(range(1, N+2)) - set(c))[0]
for i in range(X, N-Y+X):
c[i] = unused
#print(b)
#print(c)
#print()
bad = False
for i in range(N-Y+X, N):
if c[i] == b[i][1]:
print('NO')
bad = True
break
if not bad:
print('YES')
a = [0 for _ in range(N)]
for i, x in enumerate(c):
a[b[i][0]] = x
print(' '.join(str(x) for x in a))
```
No
| 70,912 | [
0.466552734375,
-0.27001953125,
-0.0017576217651367188,
0.1588134765625,
-0.4599609375,
-0.6708984375,
-0.06756591796875,
-0.03875732421875,
0.081787109375,
1.1787109375,
0.701171875,
-0.057525634765625,
0.272216796875,
-0.662109375,
-0.343994140625,
0.049774169921875,
-0.49194335937... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Tags: implementation
Correct Solution:
```
a, b, c, d = map(int, input().split())
m = max(3 * a // 10, a - a // 250 * c)
v = max(3 * b // 10, b - b // 250 * d)
print("Tie" if m == v else "Misha" if m > v else "Vasya")
```
| 71,151 | [
0.35888671875,
0.13037109375,
-0.53466796875,
0.27587890625,
-0.56494140625,
-0.46826171875,
-0.11468505859375,
0.032867431640625,
-0.1070556640625,
0.625,
0.45751953125,
0.0303497314453125,
0.35498046875,
-0.84326171875,
-0.30419921875,
0.11346435546875,
-0.54248046875,
-0.8554687... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Tags: implementation
Correct Solution:
```
a,b,c,d=map(int,input().split())
if max((3*a)/10,a-(a//250)*c)>max((3*b)/10,b-(b//250)*d):
print("Misha")
elif max((3*a)/10,a-(a//250)*c)<max((3*b)/10,b-(b//250)*d):
print("Vasya")
else:
print("Tie")
```
| 71,152 | [
0.337646484375,
0.148193359375,
-0.484375,
0.330322265625,
-0.5703125,
-0.521484375,
-0.1007080078125,
0.06878662109375,
-0.10223388671875,
0.66796875,
0.40380859375,
0.09906005859375,
0.360107421875,
-0.8408203125,
-0.274169921875,
0.1416015625,
-0.5908203125,
-0.83056640625,
-0... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Tags: implementation
Correct Solution:
```
arr = list(map(int, input().split()))
misha = max(3*arr[0]/10, arr[0] - arr[0]*arr[2]/250)
vasya = max(3*arr[1]/10, arr[1] - arr[1]*arr[3]/250)
if misha == vasya:
print("Tie")
elif misha < vasya:
print("Vasya")
else:
print("Misha")
```
| 71,153 | [
0.405517578125,
0.2274169921875,
-0.53466796875,
0.339111328125,
-0.53076171875,
-0.4970703125,
-0.1324462890625,
0.03570556640625,
-0.118896484375,
0.60400390625,
0.45947265625,
0.034332275390625,
0.324462890625,
-0.9208984375,
-0.347900390625,
0.1654052734375,
-0.56005859375,
-0.... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Tags: implementation
Correct Solution:
```
m,v,tm,tv = map(int,input().split())
bm = max(3*m/10,m - m/250*tm)
bv = max(3*v/10,v - v/250*tv)
if bm == bv:
print("Tie")
elif bm >= bv:
print("Misha")
else:
print("Vasya")
```
| 71,154 | [
0.404052734375,
0.1878662109375,
-0.576171875,
0.362060546875,
-0.5439453125,
-0.455810546875,
-0.08087158203125,
0.0059814453125,
-0.09637451171875,
0.5634765625,
0.38134765625,
0.0015897750854492188,
0.379638671875,
-0.85009765625,
-0.333984375,
0.07281494140625,
-0.56689453125,
... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Tags: implementation
Correct Solution:
```
z=list(map(int,input().split()))
vanya=0
misha=0
misha=max((3*z[0]/10),(z[0]-(z[0]/250)*z[2]))
vanya=max((3*z[1]/10),(z[1]-(z[1]/250)*z[3]))
if misha==vanya :
print("Tie")
elif misha < vanya :
print("Vasya")
else :
print("Misha")
```
| 71,155 | [
0.3447265625,
0.1827392578125,
-0.46484375,
0.33642578125,
-0.56103515625,
-0.505859375,
-0.0810546875,
0.06689453125,
-0.189453125,
0.5595703125,
0.321533203125,
0.0877685546875,
0.38818359375,
-0.82666015625,
-0.2109375,
0.0535888671875,
-0.548828125,
-0.876953125,
-0.579589843... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Tags: implementation
Correct Solution:
```
a,b,c,d=map(int,input().split())
m=max(((a//10)*3),(a-(a*c)//250))
v=max(((b//10)*3),(b-(b*d)//250))
if m>v:
print('Misha')
elif m<v:
print('Vasya')
else:
print('Tie')
```
| 71,156 | [
0.36376953125,
0.134765625,
-0.53369140625,
0.29736328125,
-0.56005859375,
-0.46337890625,
-0.1168212890625,
0.03338623046875,
-0.07855224609375,
0.65771484375,
0.439208984375,
0.0567626953125,
0.36328125,
-0.83154296875,
-0.2958984375,
0.1407470703125,
-0.583984375,
-0.86328125,
... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Tags: implementation
Correct Solution:
```
a, b, c, d = map(int,input().split())
m = max((3 * a)/10, a-(a/250) * c)
v = max((3 * b)/10, b-(b/250) * d)
if m > v:
print("Misha")
elif m < v:
print("Vasya")
else:
print("Tie")
```
| 71,157 | [
0.35888671875,
0.14306640625,
-0.54931640625,
0.2939453125,
-0.5625,
-0.464111328125,
-0.11419677734375,
0.037994384765625,
-0.081787109375,
0.62353515625,
0.417236328125,
0.036773681640625,
0.345947265625,
-0.8251953125,
-0.297607421875,
0.1329345703125,
-0.552734375,
-0.849121093... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Tags: implementation
Correct Solution:
```
def point(p,t):
return max(3*p/10,p-p/250*t)
a,b,c,d = map(int,input().split())
mi = point(a,c)
va = point(b,d)
if mi > va:
print("Misha")
elif va > mi:
print("Vasya")
else:
print("Tie")
```
| 71,158 | [
0.34814453125,
0.1964111328125,
-0.54833984375,
0.304443359375,
-0.59814453125,
-0.51513671875,
-0.0828857421875,
0.037322998046875,
-0.05645751953125,
0.587890625,
0.38916015625,
0.029327392578125,
0.337646484375,
-0.7880859375,
-0.2529296875,
0.15234375,
-0.5654296875,
-0.8403320... | 11 |
Evaluate the correctness of the submitted Python 2 solution to the coding contest problem. Provide a "Yes" or "No" response.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Submitted Solution:
```
# Author : code_marshal
# cmp is not available in python 3.x
a,b,c,d=map(int,raw_input().split())
ch=cmp(max(a*3//10,a-a*c//250),max(b*3//10,b-b*d//250))
if not ch:print "Tie"
elif ch==1:print "Misha"
else:print "Vasya"
```
Yes
| 71,159 | [
0.412109375,
0.09307861328125,
-0.476318359375,
0.301513671875,
-0.69287109375,
-0.29833984375,
-0.2017822265625,
0.080078125,
-0.18310546875,
0.7578125,
0.414306640625,
0.07110595703125,
0.2313232421875,
-0.85791015625,
-0.422119140625,
0.13427734375,
-0.46875,
-0.91650390625,
-... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Submitted Solution:
```
a,b,c,d=map(int,input().split())
f=lambda p,t:max(3*p/10,p-p/250*t)
df=f(a,c)-f(b,d)
print('Vasya' if df<0 else ['Tie', 'Misha'][df>0])
```
Yes
| 71,160 | [
0.44189453125,
0.1868896484375,
-0.4716796875,
0.1905517578125,
-0.70556640625,
-0.2174072265625,
-0.205810546875,
0.1781005859375,
-0.260498046875,
0.6669921875,
0.40283203125,
-0.004840850830078125,
0.2159423828125,
-0.8076171875,
-0.368896484375,
-0.0372314453125,
-0.46044921875,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Submitted Solution:
```
a,b,c,d=list(map(int,input().split()))
t=max((3*a)//10,a-(a//250)*c)
p=max((3*b)//10,b-(b//250)*d)
if t>p:
print("Misha")
elif t==p:
print("Tie")
else:
print("Vasya")
```
Yes
| 71,161 | [
0.43212890625,
0.134521484375,
-0.48876953125,
0.1962890625,
-0.701171875,
-0.28955078125,
-0.1920166015625,
0.169921875,
-0.2144775390625,
0.666015625,
0.369873046875,
0.0157623291015625,
0.283203125,
-0.880859375,
-0.374267578125,
0.007659912109375,
-0.4296875,
-0.82421875,
-0.... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Submitted Solution:
```
import sys
import math
a, b, c, d = [int(x) for x in (sys.stdin.readline()).split()]
vmax1 = max(3 * a / 10, a - a / 250 * c)
vmax2 = max(3 * b / 10, b - b / 250 * d)
if(vmax1 > vmax2):
print("Misha")
elif(vmax1 < vmax2):
print("Vasya")
else:
print("Tie")
```
Yes
| 71,162 | [
0.404541015625,
0.1649169921875,
-0.44677734375,
0.23486328125,
-0.67822265625,
-0.31884765625,
-0.2054443359375,
0.1485595703125,
-0.20947265625,
0.70263671875,
0.37646484375,
0.0108489990234375,
0.20849609375,
-0.85595703125,
-0.300048828125,
0.0123748779296875,
-0.46923828125,
-... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Submitted Solution:
```
a, b, c, d = map(int, input().split())
m = max(3 * a // 10, a - c * a // 250)
v = max(3 * b // 10, b - d * b // 250)
if m > v:
print('Misha')
elif v > m:
print('Vasya')
else:
print('Tie')
```
Yes
| 71,163 | [
0.43603515625,
0.1715087890625,
-0.50830078125,
0.1737060546875,
-0.70849609375,
-0.284912109375,
-0.205078125,
0.1446533203125,
-0.2113037109375,
0.66650390625,
0.393310546875,
0.00579833984375,
0.239501953125,
-0.8525390625,
-0.34326171875,
-0.031524658203125,
-0.45751953125,
-0.... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Submitted Solution:
```
a,b,c,d = [int(item) for item in input().split()]
x = max(3*a/10 , (a-(a*c/250)))
y = max(3*b/10 , (b-(b*c/250)))
if x>y:
print("Misha")
elif x<y:
print("Vasya")
else:
print("Tie")
```
No
| 71,164 | [
0.402099609375,
0.1732177734375,
-0.5048828125,
0.200439453125,
-0.69384765625,
-0.284423828125,
-0.2098388671875,
0.1614990234375,
-0.195556640625,
0.6494140625,
0.39794921875,
-0.0012903213500976562,
0.23681640625,
-0.873046875,
-0.3701171875,
-0.0192718505859375,
-0.4404296875,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Submitted Solution:
```
a, b, c, d = map(int, input().split())
x = max(a / 10, a - (a / 250) * c)
y = max(b / 10, b - (b / 250) * d)
if x < y:
print('Misha')
elif y < x:
print('Vasya')
else: print('Tie')
```
No
| 71,165 | [
0.448974609375,
0.181396484375,
-0.50146484375,
0.2091064453125,
-0.69140625,
-0.290771484375,
-0.20849609375,
0.1612548828125,
-0.2254638671875,
0.681640625,
0.40185546875,
0.0212860107421875,
0.2420654296875,
-0.8564453125,
-0.3388671875,
-0.0189056396484375,
-0.45703125,
-0.8461... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Submitted Solution:
```
a,b,c,d=list(map(int,input().split()))
if(a==b and c==d):
print("Tie")
elif(a==b and c>d):
print("Misha")
else:
if((a-b)%250==0 and a>b):
print("Misha")
else:
print("Vasya")
```
No
| 71,166 | [
0.387451171875,
0.158447265625,
-0.51953125,
0.1602783203125,
-0.703125,
-0.28759765625,
-0.19921875,
0.166015625,
-0.19970703125,
0.658203125,
0.423828125,
-0.01739501953125,
0.27685546875,
-0.8828125,
-0.387451171875,
-0.040130615234375,
-0.4853515625,
-0.8271484375,
-0.4238281... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Submitted Solution:
```
a,b,c,d=map(int,input().split())
p1=max(3*a/10,a*c/250)
p2=max(3*b/10,b*d/250)
if p1>p2:
print("Misha")
elif p1<p2:
print("Vasya")
else:
print("Tie")
```
No
| 71,167 | [
0.455322265625,
0.182373046875,
-0.497314453125,
0.1885986328125,
-0.70849609375,
-0.299560546875,
-0.2164306640625,
0.148681640625,
-0.216064453125,
0.658203125,
0.39208984375,
-0.0016813278198242188,
0.251708984375,
-0.8408203125,
-0.364990234375,
-0.0018415451049804688,
-0.4348144... | 11 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
Alice and Bob are competing in the 50m dash.
However, in this world, the higher the AOJ rate is, the better, so the higher the AOJ rate wins.
If there is no AOJ rate on either side, there is no comparison, so there is no choice but to compete in the 50m sprint time. In this case, the one with the shorter time wins.
If the AOJ rates are the same, it is a draw, and if you have to compete in the 50m time, it is a draw if the times are the same.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq T_1, T_2 \ lt 100 $
* $ -1 \ leq R_1, R_2 \ lt 2850 $
* All inputs are integers
Input
The input is given in the following format.
$ T_1 $ $ T_2 $ $ R_1 $ $ R_2 $
Each element is given separated by blanks.
$ T_1 and T_2 $ represent the time of Alice and Bob's 50m run, respectively, and $ R_1 and R_2 $ represent the rates of Alice and Bob's AOJ, respectively.
However, $ R_1 = -1 $ indicates that there is no Alice rate, and $ R_2 = -1 $ indicates that there is no Bob rate.
Output
Print "Alice" if Alice wins, "Bob" if Bob wins, and "Draw" if it's a draw on the $ 1 $ line.
Examples
Input
9 8 1000 999
Output
Alice
Input
9 8 1000 1000
Output
Draw
Input
9 8 2849 -1
Output
Bob
"Correct Solution:
```
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
T1, T2, R1, R2 = LI()
if (R1 == -1 or R2 == -1) :
if (T1 < T2):
print("Alice")
elif (T2 < T1) :
print("Bob")
else :
print("Draw")
else :
if (R1 > R2):
print("Alice")
elif (R2 > R1) :
print("Bob")
else :
print("Draw")
return
if __name__ == "__main__":
solve()
```
| 71,594 | [
0.47705078125,
0.5576171875,
-0.32275390625,
0.16748046875,
-0.483642578125,
-0.599609375,
0.1455078125,
-0.022674560546875,
0.61572265625,
0.75,
0.259521484375,
0.130615234375,
-0.032196044921875,
-1.2373046875,
-0.08001708984375,
-0.100830078125,
-0.4853515625,
-0.73583984375,
... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Tags: implementation
Correct Solution:
```
input()
print('EASY' if set(input().split())=={'0'} else 'HARD')
```
| 71,640 | [
0.339599609375,
-0.01116943359375,
0.08233642578125,
-0.1085205078125,
-0.6123046875,
-0.7880859375,
-0.0513916015625,
-0.1458740234375,
0.3037109375,
0.7919921875,
0.7685546875,
-0.252685546875,
0.18994140625,
-0.81982421875,
-0.5771484375,
-0.2646484375,
-0.6572265625,
-0.6977539... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Tags: implementation
Correct Solution:
```
n = int(input())
s = input()
if s.count('1') == 0:
print('EASY')
else:
print('HARD')
```
| 71,641 | [
0.345947265625,
-0.0279388427734375,
0.055084228515625,
-0.048675537109375,
-0.5732421875,
-0.78271484375,
-0.07745361328125,
-0.172607421875,
0.324462890625,
0.78759765625,
0.81201171875,
-0.275390625,
0.18603515625,
-0.76025390625,
-0.55517578125,
-0.2498779296875,
-0.6826171875,
... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Tags: implementation
Correct Solution:
```
a=input()
a=input().split()
b=False
i=0
while i<len(a):
if a[i]=='1':
print ('Hard')
b=True
break
i+=1
if not b:
print ('Easy')
```
| 71,642 | [
0.373779296875,
0.007122039794921875,
0.0687255859375,
-0.1146240234375,
-0.5673828125,
-0.81689453125,
-0.055908203125,
-0.1849365234375,
0.3330078125,
0.84375,
0.73095703125,
-0.267333984375,
0.167724609375,
-0.80517578125,
-0.5576171875,
-0.2705078125,
-0.64892578125,
-0.7080078... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Tags: implementation
Correct Solution:
```
b=int(input())
x=input()
m=x.split(' ')
n=[ ]
hard=0
for i in m:
n.append(int(i))
for i in n:
if i==1:
hard+=1
if hard>0:
print("HARD")
else:
print("EASY")
```
| 71,643 | [
0.331298828125,
-0.039581298828125,
0.06201171875,
-0.1126708984375,
-0.5810546875,
-0.806640625,
-0.10064697265625,
-0.161376953125,
0.300048828125,
0.8203125,
0.7998046875,
-0.235595703125,
0.18798828125,
-0.76220703125,
-0.548828125,
-0.24267578125,
-0.68701171875,
-0.7353515625... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Tags: implementation
Correct Solution:
```
blah = int(input(''))
bloo = input('').strip()
if '1' in bloo:
print('HARD')
else:
print('EASY')
```
| 71,644 | [
0.427490234375,
-0.061981201171875,
0.05584716796875,
0.019195556640625,
-0.5634765625,
-0.73828125,
0.1416015625,
-0.2164306640625,
0.3525390625,
0.8232421875,
0.716796875,
-0.2239990234375,
0.161376953125,
-0.77685546875,
-0.61572265625,
-0.2344970703125,
-0.673828125,
-0.6840820... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Tags: implementation
Correct Solution:
```
n = int(input())
S=[0]*n
sum = 0
S=map(int, input().split())
S=list(S)
for i in range(0, n):
sum+=S[i]
if sum == 0:
print("EASY")
else:
print("HARD")
```
| 71,645 | [
0.281494140625,
0.055267333984375,
0.031982421875,
-0.128173828125,
-0.54443359375,
-0.83349609375,
-0.039642333984375,
-0.118896484375,
0.281005859375,
0.70654296875,
0.79345703125,
-0.23046875,
0.2705078125,
-0.75048828125,
-0.591796875,
-0.2666015625,
-0.689453125,
-0.6987304687... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Tags: implementation
Correct Solution:
```
n = int(input())
A = list(map(int,input().split()))
flag = 0
for i in range(len(A)):
if A[i] == 1:
print('HARD')
flag += 1
break
if flag == 0:
print('EASY')
```
| 71,646 | [
0.339599609375,
-0.08062744140625,
0.0364990234375,
-0.09686279296875,
-0.552734375,
-0.8203125,
-0.045654296875,
-0.1298828125,
0.322021484375,
0.8896484375,
0.75390625,
-0.23486328125,
0.2481689453125,
-0.7919921875,
-0.4482421875,
-0.2261962890625,
-0.67236328125,
-0.7119140625,... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Tags: implementation
Correct Solution:
```
n = int(input())
x = input()
x = x.split(" ")
k = 0
for i in x:
if i == "1":
k += 1
if k >= 1:
print("HARD")
else:
print("EASY")
```
| 71,647 | [
0.39013671875,
-0.01666259765625,
0.07208251953125,
-0.08074951171875,
-0.57275390625,
-0.81005859375,
-0.11883544921875,
-0.178955078125,
0.29248046875,
0.8134765625,
0.82275390625,
-0.23974609375,
0.181396484375,
-0.796875,
-0.53564453125,
-0.23974609375,
-0.6689453125,
-0.739257... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Submitted Solution:
```
a=int(input())
x=[int(num) for num in input().split()]
r=sum(x)
if r>0:
print('HARD')
else:
print('EASY')
```
Yes
| 71,648 | [
0.40673828125,
0.06768798828125,
-0.03564453125,
-0.2279052734375,
-0.6455078125,
-0.51513671875,
-0.207763671875,
0.01258087158203125,
0.135498046875,
0.67041015625,
0.685546875,
-0.18701171875,
0.07904052734375,
-0.78369140625,
-0.55126953125,
-0.444091796875,
-0.6181640625,
-0.6... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
if(sum(l)>0):
print('HARD')
else:
print('EASY')
```
Yes
| 71,649 | [
0.382080078125,
0.07696533203125,
-0.055877685546875,
-0.2283935546875,
-0.65576171875,
-0.51953125,
-0.1959228515625,
0.0262603759765625,
0.12347412109375,
0.6494140625,
0.658203125,
-0.190185546875,
0.1268310546875,
-0.78955078125,
-0.546875,
-0.434326171875,
-0.63330078125,
-0.6... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Submitted Solution:
```
n = int(input())
lis = map(int, input().split(" "))
lis = list(filter(lambda x: x,lis))
if len(lis) > 0:
print("HARD")
else:
print("EASY")
```
Yes
| 71,650 | [
0.34375,
0.1302490234375,
0.038482666015625,
-0.21533203125,
-0.69921875,
-0.53173828125,
-0.300537109375,
0.046051025390625,
0.1431884765625,
0.703125,
0.56689453125,
-0.127197265625,
0.1932373046875,
-0.74072265625,
-0.58935546875,
-0.4716796875,
-0.619140625,
-0.54833984375,
-... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Submitted Solution:
```
n = int(input())
k = [int(i) for i in input().split()]
if 1 in k:
print('HARD')
else:
print('EASY')
```
Yes
| 71,651 | [
0.4140625,
0.054840087890625,
-0.06561279296875,
-0.2020263671875,
-0.6884765625,
-0.517578125,
-0.224365234375,
-0.0068359375,
0.1148681640625,
0.69677734375,
0.650390625,
-0.24609375,
0.08135986328125,
-0.77978515625,
-0.5400390625,
-0.421142578125,
-0.62255859375,
-0.673828125,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Submitted Solution:
```
n=4
arr=[0,1,0,]
if(max(arr)==0):
print("easy")
else:
print("hard")
```
No
| 71,652 | [
0.400146484375,
0.08062744140625,
-0.062744140625,
-0.1416015625,
-0.64404296875,
-0.5361328125,
-0.2042236328125,
-0.00525665283203125,
0.143310546875,
0.693359375,
0.71044921875,
-0.238525390625,
0.0975341796875,
-0.8203125,
-0.5634765625,
-0.434326171875,
-0.59521484375,
-0.6381... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Submitted Solution:
```
n = int(input())
lis = [int(i) for i in input().split()]
count = 0
for i in range(n):
if(lis[i] == 1):
count = count + 1
if(count == 1):
print("HARD");
else:
print("EASY");
```
No
| 71,653 | [
0.331298828125,
0.0989990234375,
0.02734375,
-0.184814453125,
-0.69189453125,
-0.54931640625,
-0.2587890625,
0.039459228515625,
0.1717529296875,
0.6865234375,
0.60009765625,
-0.178466796875,
0.138916015625,
-0.775390625,
-0.60302734375,
-0.47119140625,
-0.64697265625,
-0.6000976562... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Submitted Solution:
```
n=int(input())
lt=list(map(int,input().split()))
if 1 in lt:
print("HARD")
```
No
| 71,654 | [
0.400634765625,
0.05853271484375,
-0.07171630859375,
-0.221923828125,
-0.66259765625,
-0.5390625,
-0.2213134765625,
0.0204925537109375,
0.08428955078125,
0.68603515625,
0.6650390625,
-0.1893310546875,
0.111572265625,
-0.77294921875,
-0.51220703125,
-0.44677734375,
-0.58544921875,
-... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Submitted Solution:
```
persone = input()
verdetto_persone = input().split(" ")
print(verdetto_persone)
for persona in verdetto_persone:
if persona == "1":
print("HARD")
break
```
No
| 71,655 | [
0.397705078125,
0.04974365234375,
-0.148681640625,
-0.136474609375,
-0.6328125,
-0.51220703125,
-0.249267578125,
0.1285400390625,
0.192626953125,
0.60107421875,
0.69482421875,
-0.1917724609375,
0.166015625,
-0.74365234375,
-0.53662109375,
-0.451416015625,
-0.677734375,
-0.628417968... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On the well-known testing system MathForces, a draw of n rating units is arranged. The rating will be distributed according to the following algorithm: if k participants take part in this event, then the n rating is evenly distributed between them and rounded to the nearest lower integer, At the end of the drawing, an unused rating may remain — it is not given to any of the participants.
For example, if n = 5 and k = 3, then each participant will recieve an 1 rating unit, and also 2 rating units will remain unused. If n = 5, and k = 6, then none of the participants will increase their rating.
Vasya participates in this rating draw but does not have information on the total number of participants in this event. Therefore, he wants to know what different values of the rating increment are possible to get as a result of this draw and asks you for help.
For example, if n=5, then the answer is equal to the sequence 0, 1, 2, 5. Each of the sequence values (and only them) can be obtained as ⌊ n/k ⌋ for some positive integer k (where ⌊ x ⌋ is the value of x rounded down): 0 = ⌊ 5/7 ⌋, 1 = ⌊ 5/5 ⌋, 2 = ⌊ 5/2 ⌋, 5 = ⌊ 5/1 ⌋.
Write a program that, for a given n, finds a sequence of all possible rating increments.
Input
The first line contains integer number t (1 ≤ t ≤ 10) — the number of test cases in the input. Then t test cases follow.
Each line contains an integer n (1 ≤ n ≤ 10^9) — the total number of the rating units being drawn.
Output
Output the answers for each of t test cases. Each answer should be contained in two lines.
In the first line print a single integer m — the number of different rating increment values that Vasya can get.
In the following line print m integers in ascending order — the values of possible rating increments.
Example
Input
4
5
11
1
3
Output
4
0 1 2 5
6
0 1 2 3 5 11
2
0 1
3
0 1 3
Tags: binary search, math, meet-in-the-middle, number theory
Correct Solution:
```
# https://codeforces.com/contest/1263/problem/C
t = int(input())
for i in range(t):
ans = 0
n = int(input())
s = set([0])
ans = [0]
i = n
while i > 0:
tmp = n // i
if tmp not in s:
s.add(tmp)
ans.append(tmp)
i = min(n//(tmp+1), i-1)
print(len(ans))
print(*ans)
```
| 71,776 | [
0.1842041015625,
-0.0111083984375,
-0.399658203125,
0.3525390625,
-0.41162109375,
-0.72412109375,
0.0384521484375,
-0.1405029296875,
-0.2227783203125,
0.8037109375,
0.59228515625,
0.042938232421875,
0.544921875,
-0.98876953125,
-0.369873046875,
-0.206787109375,
-0.5908203125,
-0.97... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On the well-known testing system MathForces, a draw of n rating units is arranged. The rating will be distributed according to the following algorithm: if k participants take part in this event, then the n rating is evenly distributed between them and rounded to the nearest lower integer, At the end of the drawing, an unused rating may remain — it is not given to any of the participants.
For example, if n = 5 and k = 3, then each participant will recieve an 1 rating unit, and also 2 rating units will remain unused. If n = 5, and k = 6, then none of the participants will increase their rating.
Vasya participates in this rating draw but does not have information on the total number of participants in this event. Therefore, he wants to know what different values of the rating increment are possible to get as a result of this draw and asks you for help.
For example, if n=5, then the answer is equal to the sequence 0, 1, 2, 5. Each of the sequence values (and only them) can be obtained as ⌊ n/k ⌋ for some positive integer k (where ⌊ x ⌋ is the value of x rounded down): 0 = ⌊ 5/7 ⌋, 1 = ⌊ 5/5 ⌋, 2 = ⌊ 5/2 ⌋, 5 = ⌊ 5/1 ⌋.
Write a program that, for a given n, finds a sequence of all possible rating increments.
Input
The first line contains integer number t (1 ≤ t ≤ 10) — the number of test cases in the input. Then t test cases follow.
Each line contains an integer n (1 ≤ n ≤ 10^9) — the total number of the rating units being drawn.
Output
Output the answers for each of t test cases. Each answer should be contained in two lines.
In the first line print a single integer m — the number of different rating increment values that Vasya can get.
In the following line print m integers in ascending order — the values of possible rating increments.
Example
Input
4
5
11
1
3
Output
4
0 1 2 5
6
0 1 2 3 5 11
2
0 1
3
0 1 3
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
ret = {0}
d = 1
while d * d <= n:
ret.update((n // d, d))
d += 1
print('%d\n%s' % (len(ret), ' '.join(map(str, sorted(ret)))))
```
Yes
| 71,778 | [
0.333251953125,
0.037689208984375,
-0.43115234375,
0.34619140625,
-0.6171875,
-0.497314453125,
-0.07452392578125,
0.0307769775390625,
-0.281982421875,
0.8818359375,
0.42041015625,
0.06146240234375,
0.50830078125,
-0.97119140625,
-0.372314453125,
-0.2293701171875,
-0.58837890625,
-1... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On the well-known testing system MathForces, a draw of n rating units is arranged. The rating will be distributed according to the following algorithm: if k participants take part in this event, then the n rating is evenly distributed between them and rounded to the nearest lower integer, At the end of the drawing, an unused rating may remain — it is not given to any of the participants.
For example, if n = 5 and k = 3, then each participant will recieve an 1 rating unit, and also 2 rating units will remain unused. If n = 5, and k = 6, then none of the participants will increase their rating.
Vasya participates in this rating draw but does not have information on the total number of participants in this event. Therefore, he wants to know what different values of the rating increment are possible to get as a result of this draw and asks you for help.
For example, if n=5, then the answer is equal to the sequence 0, 1, 2, 5. Each of the sequence values (and only them) can be obtained as ⌊ n/k ⌋ for some positive integer k (where ⌊ x ⌋ is the value of x rounded down): 0 = ⌊ 5/7 ⌋, 1 = ⌊ 5/5 ⌋, 2 = ⌊ 5/2 ⌋, 5 = ⌊ 5/1 ⌋.
Write a program that, for a given n, finds a sequence of all possible rating increments.
Input
The first line contains integer number t (1 ≤ t ≤ 10) — the number of test cases in the input. Then t test cases follow.
Each line contains an integer n (1 ≤ n ≤ 10^9) — the total number of the rating units being drawn.
Output
Output the answers for each of t test cases. Each answer should be contained in two lines.
In the first line print a single integer m — the number of different rating increment values that Vasya can get.
In the following line print m integers in ascending order — the values of possible rating increments.
Example
Input
4
5
11
1
3
Output
4
0 1 2 5
6
0 1 2 3 5 11
2
0 1
3
0 1 3
Submitted Solution:
```
import math
t = int(input())
for _ in range(t):
n = int(input())
s = set()
s.add(0)
limit = math.ceil(math.sqrt(n))
for i in range(1,limit+10):
tmp = len(s)
s.add(n // i)
if len(s) > tmp:
s.add(i)
s = sorted(list(s))
print(len(s))
print(*s)
```
Yes
| 71,779 | [
0.353271484375,
0.07080078125,
-0.46826171875,
0.3671875,
-0.63134765625,
-0.478515625,
-0.061553955078125,
0.05712890625,
-0.2705078125,
0.8876953125,
0.422607421875,
0.06561279296875,
0.525390625,
-0.99853515625,
-0.358642578125,
-0.2110595703125,
-0.5673828125,
-1.0341796875,
... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On the well-known testing system MathForces, a draw of n rating units is arranged. The rating will be distributed according to the following algorithm: if k participants take part in this event, then the n rating is evenly distributed between them and rounded to the nearest lower integer, At the end of the drawing, an unused rating may remain — it is not given to any of the participants.
For example, if n = 5 and k = 3, then each participant will recieve an 1 rating unit, and also 2 rating units will remain unused. If n = 5, and k = 6, then none of the participants will increase their rating.
Vasya participates in this rating draw but does not have information on the total number of participants in this event. Therefore, he wants to know what different values of the rating increment are possible to get as a result of this draw and asks you for help.
For example, if n=5, then the answer is equal to the sequence 0, 1, 2, 5. Each of the sequence values (and only them) can be obtained as ⌊ n/k ⌋ for some positive integer k (where ⌊ x ⌋ is the value of x rounded down): 0 = ⌊ 5/7 ⌋, 1 = ⌊ 5/5 ⌋, 2 = ⌊ 5/2 ⌋, 5 = ⌊ 5/1 ⌋.
Write a program that, for a given n, finds a sequence of all possible rating increments.
Input
The first line contains integer number t (1 ≤ t ≤ 10) — the number of test cases in the input. Then t test cases follow.
Each line contains an integer n (1 ≤ n ≤ 10^9) — the total number of the rating units being drawn.
Output
Output the answers for each of t test cases. Each answer should be contained in two lines.
In the first line print a single integer m — the number of different rating increment values that Vasya can get.
In the following line print m integers in ascending order — the values of possible rating increments.
Example
Input
4
5
11
1
3
Output
4
0 1 2 5
6
0 1 2 3 5 11
2
0 1
3
0 1 3
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
x=set()
for i in range(1,int(n**0.5)+1):
x.add(n//i)
x.add(i)
x.add(0)
print(len(x))
print(" ".join(map(str,sorted(x))))
```
Yes
| 71,780 | [
0.337890625,
0.0513916015625,
-0.428955078125,
0.366943359375,
-0.61376953125,
-0.5009765625,
-0.07965087890625,
0.042022705078125,
-0.28173828125,
0.87548828125,
0.435791015625,
0.0687255859375,
0.509765625,
-0.98876953125,
-0.3720703125,
-0.2305908203125,
-0.5810546875,
-1.040039... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On the well-known testing system MathForces, a draw of n rating units is arranged. The rating will be distributed according to the following algorithm: if k participants take part in this event, then the n rating is evenly distributed between them and rounded to the nearest lower integer, At the end of the drawing, an unused rating may remain — it is not given to any of the participants.
For example, if n = 5 and k = 3, then each participant will recieve an 1 rating unit, and also 2 rating units will remain unused. If n = 5, and k = 6, then none of the participants will increase their rating.
Vasya participates in this rating draw but does not have information on the total number of participants in this event. Therefore, he wants to know what different values of the rating increment are possible to get as a result of this draw and asks you for help.
For example, if n=5, then the answer is equal to the sequence 0, 1, 2, 5. Each of the sequence values (and only them) can be obtained as ⌊ n/k ⌋ for some positive integer k (where ⌊ x ⌋ is the value of x rounded down): 0 = ⌊ 5/7 ⌋, 1 = ⌊ 5/5 ⌋, 2 = ⌊ 5/2 ⌋, 5 = ⌊ 5/1 ⌋.
Write a program that, for a given n, finds a sequence of all possible rating increments.
Input
The first line contains integer number t (1 ≤ t ≤ 10) — the number of test cases in the input. Then t test cases follow.
Each line contains an integer n (1 ≤ n ≤ 10^9) — the total number of the rating units being drawn.
Output
Output the answers for each of t test cases. Each answer should be contained in two lines.
In the first line print a single integer m — the number of different rating increment values that Vasya can get.
In the following line print m integers in ascending order — the values of possible rating increments.
Example
Input
4
5
11
1
3
Output
4
0 1 2 5
6
0 1 2 3 5 11
2
0 1
3
0 1 3
Submitted Solution:
```
di = {}
for _ in range(int(input())):
n = int(input())
if n in di:
print(di[n][0])
print(di[n][1])
continue
s1 = set()
s1.add(1)
s1.add(n)
s1.add(0)
min = n
i = 2
while i <= min:
next = n//i
min = next
s1.add(next)
if n//next == i:
s1.add(i)
i += 1
s = ""
ans = " ".join(str(k) for k in sorted(list(s1)))
print(len(s1))
print(ans)
di[n] = [len(s1), ans]
```
Yes
| 71,781 | [
0.326904296875,
0.06634521484375,
-0.447265625,
0.373291015625,
-0.62060546875,
-0.498779296875,
-0.060943603515625,
0.059478759765625,
-0.28466796875,
0.87548828125,
0.435546875,
0.0633544921875,
0.52197265625,
-1.0009765625,
-0.369873046875,
-0.2213134765625,
-0.56201171875,
-1.0... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On the well-known testing system MathForces, a draw of n rating units is arranged. The rating will be distributed according to the following algorithm: if k participants take part in this event, then the n rating is evenly distributed between them and rounded to the nearest lower integer, At the end of the drawing, an unused rating may remain — it is not given to any of the participants.
For example, if n = 5 and k = 3, then each participant will recieve an 1 rating unit, and also 2 rating units will remain unused. If n = 5, and k = 6, then none of the participants will increase their rating.
Vasya participates in this rating draw but does not have information on the total number of participants in this event. Therefore, he wants to know what different values of the rating increment are possible to get as a result of this draw and asks you for help.
For example, if n=5, then the answer is equal to the sequence 0, 1, 2, 5. Each of the sequence values (and only them) can be obtained as ⌊ n/k ⌋ for some positive integer k (where ⌊ x ⌋ is the value of x rounded down): 0 = ⌊ 5/7 ⌋, 1 = ⌊ 5/5 ⌋, 2 = ⌊ 5/2 ⌋, 5 = ⌊ 5/1 ⌋.
Write a program that, for a given n, finds a sequence of all possible rating increments.
Input
The first line contains integer number t (1 ≤ t ≤ 10) — the number of test cases in the input. Then t test cases follow.
Each line contains an integer n (1 ≤ n ≤ 10^9) — the total number of the rating units being drawn.
Output
Output the answers for each of t test cases. Each answer should be contained in two lines.
In the first line print a single integer m — the number of different rating increment values that Vasya can get.
In the following line print m integers in ascending order — the values of possible rating increments.
Example
Input
4
5
11
1
3
Output
4
0 1 2 5
6
0 1 2 3 5 11
2
0 1
3
0 1 3
Submitted Solution:
```
import math
t = int(input())
while(t!=0):
n = int(input())
k = n + 1
a = [0]
b = []
for i in range(1, (int)(n**0.5 )+1 ) :
a.append(i)
if(i != n//i):
b.append(n//i)
a = a + b
print(len(a))
print(*a)
t -= 1
```
No
| 71,782 | [
0.360107421875,
0.07232666015625,
-0.4775390625,
0.361572265625,
-0.63427734375,
-0.4736328125,
-0.060943603515625,
0.0645751953125,
-0.27099609375,
0.8896484375,
0.413818359375,
0.0775146484375,
0.5263671875,
-0.9990234375,
-0.35791015625,
-0.212646484375,
-0.560546875,
-1.0351562... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On the well-known testing system MathForces, a draw of n rating units is arranged. The rating will be distributed according to the following algorithm: if k participants take part in this event, then the n rating is evenly distributed between them and rounded to the nearest lower integer, At the end of the drawing, an unused rating may remain — it is not given to any of the participants.
For example, if n = 5 and k = 3, then each participant will recieve an 1 rating unit, and also 2 rating units will remain unused. If n = 5, and k = 6, then none of the participants will increase their rating.
Vasya participates in this rating draw but does not have information on the total number of participants in this event. Therefore, he wants to know what different values of the rating increment are possible to get as a result of this draw and asks you for help.
For example, if n=5, then the answer is equal to the sequence 0, 1, 2, 5. Each of the sequence values (and only them) can be obtained as ⌊ n/k ⌋ for some positive integer k (where ⌊ x ⌋ is the value of x rounded down): 0 = ⌊ 5/7 ⌋, 1 = ⌊ 5/5 ⌋, 2 = ⌊ 5/2 ⌋, 5 = ⌊ 5/1 ⌋.
Write a program that, for a given n, finds a sequence of all possible rating increments.
Input
The first line contains integer number t (1 ≤ t ≤ 10) — the number of test cases in the input. Then t test cases follow.
Each line contains an integer n (1 ≤ n ≤ 10^9) — the total number of the rating units being drawn.
Output
Output the answers for each of t test cases. Each answer should be contained in two lines.
In the first line print a single integer m — the number of different rating increment values that Vasya can get.
In the following line print m integers in ascending order — the values of possible rating increments.
Example
Input
4
5
11
1
3
Output
4
0 1 2 5
6
0 1 2 3 5 11
2
0 1
3
0 1 3
Submitted Solution:
```
T = int(input())
for t in range(T):
N = int(input())
V = {0}
def look(l, u, f = 0, i = 0):
#print(' ' * i, l, u, f)
m = (l + u) // 2
if u != l:
t = N // m
if t in V:
if f: look(l, m, 0, i+1)
else: look(m+1, u, 1, i+1)
else:
V.add(t)
look(l, m, 0, i + 1)
look(m+1, u, 1, i + 1)
look(1, N+1)
print(len(V))
print(*sorted(V))
```
No
| 71,783 | [
0.344970703125,
0.047027587890625,
-0.437255859375,
0.349365234375,
-0.61572265625,
-0.490234375,
-0.0762939453125,
0.042694091796875,
-0.28125,
0.87060546875,
0.41748046875,
0.0657958984375,
0.5166015625,
-0.9638671875,
-0.368408203125,
-0.233642578125,
-0.58056640625,
-1.04394531... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On the well-known testing system MathForces, a draw of n rating units is arranged. The rating will be distributed according to the following algorithm: if k participants take part in this event, then the n rating is evenly distributed between them and rounded to the nearest lower integer, At the end of the drawing, an unused rating may remain — it is not given to any of the participants.
For example, if n = 5 and k = 3, then each participant will recieve an 1 rating unit, and also 2 rating units will remain unused. If n = 5, and k = 6, then none of the participants will increase their rating.
Vasya participates in this rating draw but does not have information on the total number of participants in this event. Therefore, he wants to know what different values of the rating increment are possible to get as a result of this draw and asks you for help.
For example, if n=5, then the answer is equal to the sequence 0, 1, 2, 5. Each of the sequence values (and only them) can be obtained as ⌊ n/k ⌋ for some positive integer k (where ⌊ x ⌋ is the value of x rounded down): 0 = ⌊ 5/7 ⌋, 1 = ⌊ 5/5 ⌋, 2 = ⌊ 5/2 ⌋, 5 = ⌊ 5/1 ⌋.
Write a program that, for a given n, finds a sequence of all possible rating increments.
Input
The first line contains integer number t (1 ≤ t ≤ 10) — the number of test cases in the input. Then t test cases follow.
Each line contains an integer n (1 ≤ n ≤ 10^9) — the total number of the rating units being drawn.
Output
Output the answers for each of t test cases. Each answer should be contained in two lines.
In the first line print a single integer m — the number of different rating increment values that Vasya can get.
In the following line print m integers in ascending order — the values of possible rating increments.
Example
Input
4
5
11
1
3
Output
4
0 1 2 5
6
0 1 2 3 5 11
2
0 1
3
0 1 3
Submitted Solution:
```
from math import floor
T=int(input())
for _ in range(T):
n=int(input())
i=1;s=set();s.add(0);d={};s.add(1)
while True:
k=n//i
if d.get(k,0)>0:break
s.add(k);d[k]=1
i+=1
for j in range(n//2,i,-2):
s.add(n//j)
ans=list(s)
print(len(ans))
print(*sorted(ans))
```
No
| 71,784 | [
0.3349609375,
0.041473388671875,
-0.4501953125,
0.357666015625,
-0.61328125,
-0.494384765625,
-0.06439208984375,
0.044281005859375,
-0.2685546875,
0.8779296875,
0.41796875,
0.0712890625,
0.4921875,
-0.9765625,
-0.35107421875,
-0.2069091796875,
-0.6005859375,
-1.03515625,
-0.18432... | 11 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On the well-known testing system MathForces, a draw of n rating units is arranged. The rating will be distributed according to the following algorithm: if k participants take part in this event, then the n rating is evenly distributed between them and rounded to the nearest lower integer, At the end of the drawing, an unused rating may remain — it is not given to any of the participants.
For example, if n = 5 and k = 3, then each participant will recieve an 1 rating unit, and also 2 rating units will remain unused. If n = 5, and k = 6, then none of the participants will increase their rating.
Vasya participates in this rating draw but does not have information on the total number of participants in this event. Therefore, he wants to know what different values of the rating increment are possible to get as a result of this draw and asks you for help.
For example, if n=5, then the answer is equal to the sequence 0, 1, 2, 5. Each of the sequence values (and only them) can be obtained as ⌊ n/k ⌋ for some positive integer k (where ⌊ x ⌋ is the value of x rounded down): 0 = ⌊ 5/7 ⌋, 1 = ⌊ 5/5 ⌋, 2 = ⌊ 5/2 ⌋, 5 = ⌊ 5/1 ⌋.
Write a program that, for a given n, finds a sequence of all possible rating increments.
Input
The first line contains integer number t (1 ≤ t ≤ 10) — the number of test cases in the input. Then t test cases follow.
Each line contains an integer n (1 ≤ n ≤ 10^9) — the total number of the rating units being drawn.
Output
Output the answers for each of t test cases. Each answer should be contained in two lines.
In the first line print a single integer m — the number of different rating increment values that Vasya can get.
In the following line print m integers in ascending order — the values of possible rating increments.
Example
Input
4
5
11
1
3
Output
4
0 1 2 5
6
0 1 2 3 5 11
2
0 1
3
0 1 3
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
##########################################################
# from collections import Counter
for i in range(int(input())):
n=int(input())
#ans=[0,1,n]
#if n//2>1:
#ans.append(2)
'''l=1
r=n
while l<=r:
mid=(l+r)//2
if n//mid>1:
l=mid+1
else:
r=mid-1
val=l'''
ans=set()
for i in range(1,n+1):
if n//i<=1:
break
ans.add(n//i)
ans.add(0)
ans.add(n)
print(len(ans))
print(*sorted(ans))
```
No
| 71,785 | [
0.359619140625,
-0.031768798828125,
-0.458740234375,
0.38623046875,
-0.66015625,
-0.5263671875,
-0.07086181640625,
0.04876708984375,
-0.20458984375,
0.9384765625,
0.431884765625,
0.056121826171875,
0.5390625,
-0.95947265625,
-0.34130859375,
-0.1424560546875,
-0.53857421875,
-1.0957... | 11 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A boy Valera registered on site Codeforces as Valera, and wrote his first Codeforces Round #300. He boasted to a friend Arkady about winning as much as x points for his first contest. But Arkady did not believe his friend's words and decided to check whether Valera could have shown such a result.
He knows that the contest number 300 was unusual because there were only two problems. The contest lasted for t minutes, the minutes are numbered starting from zero. The first problem had the initial cost of a points, and every minute its cost reduced by da points. The second problem had the initial cost of b points, and every minute this cost reduced by db points. Thus, as soon as the zero minute of the contest is over, the first problem will cost a - da points, and the second problem will cost b - db points. It is guaranteed that at any moment of the contest each problem has a non-negative cost.
Arkady asks you to find out whether Valera could have got exactly x points for this contest. You should assume that Valera could have solved any number of the offered problems. You should also assume that for each problem Valera made no more than one attempt, besides, he could have submitted both problems at the same minute of the contest, starting with minute 0 and ending with minute number t - 1. Please note that Valera can't submit a solution exactly t minutes after the start of the contest or later.
Input
The single line of the input contains six integers x, t, a, b, da, db (0 ≤ x ≤ 600; 1 ≤ t, a, b, da, db ≤ 300) — Valera's result, the contest's duration, the initial cost of the first problem, the initial cost of the second problem, the number of points that the first and the second problem lose per minute, correspondingly.
It is guaranteed that at each minute of the contest each problem has a non-negative cost, that is, a - i·da ≥ 0 and b - i·db ≥ 0 for all 0 ≤ i ≤ t - 1.
Output
If Valera could have earned exactly x points at a contest, print "YES", otherwise print "NO" (without the quotes).
Examples
Input
30 5 20 20 3 5
Output
YES
Input
10 4 100 5 5 1
Output
NO
Note
In the first sample Valera could have acted like this: he could have submitted the first problem at minute 0 and the second problem — at minute 2. Then the first problem brings him 20 points and the second problem brings him 10 points, that in total gives the required 30 points.
Tags: brute force, implementation
Correct Solution:
```
x, t, a, b, da, db = map(int, input().split())
A, B = [0] + [a - da * i for i in range(t)], set([0] + [b - db * i for i in range(t)])
print('YES' if any(x - i in B for i in A) else 'NO')
```
| 71,935 | [
0.41259765625,
0.08319091796875,
-0.2056884765625,
0.11285400390625,
-0.35107421875,
-0.205078125,
-0.330810546875,
0.297607421875,
-0.23193359375,
0.92138671875,
0.767578125,
0.0323486328125,
0.2059326171875,
-0.515625,
-0.048553466796875,
0.28564453125,
-0.53173828125,
-0.4980468... | 11 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.