TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
import numpy as np
N,K,Q=list(map(int,input().split()))
res=np.array([K-Q for _ in range(N)])
for _ in range(Q):
    i=int(input())
    res[i-1]+=2
for i in res:
    if i>0:
        print("Yes")
    else:
        print("No")

n,k,q=list(map(int,input().split()))
a=[int(input()) for _ in range(q)]
c=q-k
if c<0:
    for _ in range(n):
        print("Yes")

    exit()
cal=[0 for _ in range(n)]
for i in a:
    cal[i-1]+=1
for i in range(n):
    if cal[i]>c:
        print("Yes")
    else:
        print("No")

Verdicts: Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
from collections import Counter
n, k, q = map(int, input().split())
a = [int(input()) for _ in range(q)]
a_cnt = Counter(a)
ans = [k+a_cnt[i+1]-q for i in range(n)]
print(ans)
for i in range(n):
    if ans[i] > 0:
        print('Yes')
    else:
        print('No')

from collections import Counter
n, k, q = map(int, input().split())
a = [int(input()) for _ in range(q)]
a_cnt = Counter(a)
ans = [k+a_cnt[i+1]-q for i in range(n)]
for i in range(n):
    if ans[i] > 0:
        print('Yes')
    else:
        print('No')

Verdicts: Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
n, k, q = map(int, input().split())

answers = []
for i in range(q):
    a = int(input())
    answers.append(a)

players = []
for i in range(n):
    players.append(0)

for i in range(q):
    players[answers[i] - 1] += 1

ans_list = []
for i in range(n):
    if k - q + players[i] <= 0:
        ans_list.append('No')
    else:
        ans_list.append('Yes')

print(ans_list)


n, k, q = map(int, input().split())

answers = []
for i in range(q):
    a = int(input())
    answers.append(a)

players = []
for i in range(n):
    players.append(0)

for i in range(q):
    players[answers[i] - 1] += 1


for i in range(n):
    if k - q + players[i] <= 0:
        print('No')
    else:
        print('Yes')



Verdicts: Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
n,k,q = map(int,input().split())
points = [0 for _ in range(n)]
for _ in range(q):
  a = int(input())
  points[a-1] += 1
for i in range(n):
  if points[i] > q-n:
    print("Yes")
  else:
    print("No")

n,k,q = map(int,input().split())
points = [0 for _ in range(n)]
for _ in range(q):
  a = int(input())
  points[a-1] += 1
for i in range(n):
  if points[i] > k-n:
    print("Yes")
  else:
    print("No")

n,k,q = map(int,input().split())
points = [0 for _ in range(n)]
for _ in range(q):
  a = int(input())
  points[a-1] += 1
for i in range(n):
  if points[i] > q-k:
    print("Yes")
  else:
    print("No")

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
n, k, q = map(int, input().split())
#print(n,k,q)
l = [0] * n
#print(l)
katen = [0] * q
my_append = katen.append
for i in range(q):
    my_append(int(input()))


my_pop = l.pop
my_insert = l.insert
for j in katen:
    x = my_pop(j-1)
    my_insert(j-1, x+1) 
#print(l)

for y in range(n):
    if l[y] > q-k:
        print('Yes')
    else:
        print('No')


n, k, q = map(int,input().split())
l = [int(input()) for _ in range(q)]

score = [k-q] * n
for i in l:
    score[i-1] += 1

for j in score:
    if j > 0:
        print('Yes')
    else:
        print('No')

Verdicts: Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
n,k,q=map(int,input().split())
need=q-k+1
anstimes=[0 for i in range(n)]
if k>q:
  print("Yes")
else:
  L = [int(input()) for i in range(q)]
  anstimes=[0 for i in range(n)]
  for i in range(q):
    anstimes[L[i]-1]+=1
  print(anstimes)
  for i in range(n):
    if anstimes[i]>=need:
      print("Yes")
    else:
      print("No")
  
  

n,k,q=map(int,input().split())
need=q-k+1
anstimes=[0 for i in range(n)]
if k>q:
  for i in range(n):
    print("Yes")
else:
  L = [int(input()) for i in range(q)]
  anstimes=[0 for i in range(n)]
  for i in range(q):
    anstimes[L[i]-1]+=1
  for i in range(n):
    if anstimes[i]>=need:
      print("Yes")
    else:
      print("No")
  

Verdicts: Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
N, K, Q = map(int, input().split())
As = [ int(input()) for _ in range(Q) ]
Points = [ 0 ] * (N + 1)

for A in As:
  if A == 1:
    Points[1] = Points[1]  + 1
  elif A == N:
    Points[0] = Points[0] + 1
    Points[N-1] = Points[N-1] - 1
  else:
    Points[0] = Points[0] + 1
    Points[A-1] = Points[A-1] - 1
    Points[A] = Points[A] + 1

for i in range(N):
  Points[i+1] = Points[i+1] + Points[i]
print(Points)

for i in range(N):
  if Points[i] >= K:
    print("No")
  else:
    print("Yes")

N, K, Q = map(int, input().split())
As = [ int(input()) for _ in range(Q) ]
Points = [ 0 ] * (N + 1)

for A in As:
  if A == 1:
    Points[1] = Points[1]  + 1
  elif A == N:
    Points[0] = Points[0] + 1
    Points[N-1] = Points[N-1] - 1
  else:
    Points[0] = Points[0] + 1
    Points[A-1] = Points[A-1] - 1
    Points[A] = Points[A] + 1

for i in range(N):
  Points[i+1] = Points[i+1] + Points[i]

for i in range(N):
  if Points[i] >= K:
    print("No")
  else:
    print("Yes")

Verdicts: Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
# coding: UTF-8
import sys

import heapq
import re
import bisect
import random
import math
import itertools
from collections import defaultdict, deque
from copy import deepcopy
from decimal import *

readl= lambda: list(map(int, sys.stdin.readline().split()))
readt= lambda: tuple(map(int, sys.stdin.readline().split()))
read = lambda: sys.stdin.readline().rstrip()
readi = lambda: int(read())
readmi = lambda: map(int, sys.stdin.readline().split())
readms = lambda: map(str, sys.stdin.readline().split())

n,k,q = readmi()
t = [0] * n
for i in range(q):
    s = readi()
    t[s - 1] += 1
print(t)
for i in t:
    p = k - q + i
    if p >= 1:
        print("Yes")
    else:
        print("No")


# coding: UTF-8
import sys

import heapq
import re
import bisect
import random
import math
import itertools
from collections import defaultdict, deque
from copy import deepcopy
from decimal import *

readl= lambda: list(map(int, sys.stdin.readline().split()))
readt= lambda: tuple(map(int, sys.stdin.readline().split()))
read = lambda: sys.stdin.readline().rstrip()
readi = lambda: int(read())
readmi = lambda: map(int, sys.stdin.readline().split())
readms = lambda: map(str, sys.stdin.readline().split())

n,k,q = readmi()
t = [0] * n
for i in range(q):
    s = readi()
    t[s - 1] += 1
for i in t:
    p = k - q + i
    if p >= 1:
        print("Yes")
    else:
        print("No")


Verdicts: Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
n, k, q = list(map(int, input().split()))
answer = [0 for i in range(n)]

for i in range(q):
  answer[int(input())] += 1
  
for i in range(n):
  if q - answer[i] < k:
    print('Yes')
  else:
    print('No')

n, k, q = list(map(int, input().split()))
answer = [0 for i in range(n)]
 
for i in range(q):
  answer[int(input()) - 1] += 1
  
for i in range(n):
  if q - answer[i] < k:
    print('Yes')
  else:
    print('No')

Verdicts: Runtime Error

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
n,k,q =map(int,input().split())
ans=[0]*n
for i in range(q):
    a=int(input())
    ans[a-1]+=1
for i in range(n):
    if k+q-ans[i]>0:
        print("Yes")
    else:
        print("No")


n,k,q =map(int,input().split())
ans=[0]*n
for i in range(q):
    a=int(input())
    ans[a-1]+=1
for i in range(n):
    if 0< ans[i]<=q-k and q-k>0:
        print("No")
    else:
        print("Yes")


n,k,q =map(int,input().split())
ans=[0]*n
for i in range(q):
    a=int(input())
    ans[a-1]+=1
for i in range(n):
    if ans[i]<=q-k and q-k>=0:
        print("No")
    else:
        print("Yes")


Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
import numpy as np
N, K, Q  = map(int, input().split())
score = np.zeros(N)
for i in range(Q):
  num = int(input())
  score[num] += 1

for i in range(N):
  if score[i] > Q-K:
    print('Yes')
  else:
    print('No')

import numpy as np
N, K, Q  = map(int, input().split())
score = np.zeros(N)
for i in range(Q):
  num = int(input())
  score[num-1] += 1

for i in range(N):
  if score[i] > Q-K:
    print('Yes')
  else:
    print('No')

Verdicts: Runtime Error

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
N, K, Q = map(int, input().split())
a = [int(input()) for _ in range(Q)]

count = []
for i in range(N):
    count.append(K)

for i in range(Q):
    for j in range(N):
        if j != a[i]:
            count[j] = count[j] - 1
for i in range(N):
    if count[i] <= 0:
        print('No')
    else:
        print('Yes')

N, K, Q = map(int, input().split())
a = [int(input()) for _ in range(Q)]

count = []
for i in range(N):
    count.append(K-Q)

for i in range(Q):
    count[a[i]-1] += 1
for i in range(N):
    if count[i] <= 0:
        print('No')
    else:
        print('Yes')

Verdicts: Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
N, K, Q = map(int, input().split())
S = [K-Q]*N

for i in range(Q):
  A = int(input())
  S[A-1] += 1

C = [str(i+1) for i, s in enumerate(S) if s > 0]

print("\n".join(C))

N, K, Q = map(int, input().split())
S = [K-Q]*N

for i in range(Q):
  A = int(input())
  S[A-1] += 1

for s in S:
  if s > 0:
    print("Yes")
  else:
    print("No")

Verdicts: Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
import numpy as np
N,K,Q=map(int,input().split())
A=[]
for i in range(Q):
    a=int(input())
    A.append(a)
    

P=[K]*N
P1=np.array(P)
for i in A:
    P1=P1-1
    P1[i-1]=P1[i-1]+1
    print(P1)
for i in range(len(P1)):
    if P1[i]>0:
        print('Yes')
    else:
        print('No')

import numpy as np
N,K,Q=map(int,input().split())
A=[0]*N
P=[K-Q]*N
for i in range(Q):
    a=int(input())
    A[a-1]=A[a-1]+1
A=np.array(A)
P=np.array(P)
for i in range(N):
    if A[i]+P[i]>0:
        print('Yes')
    else:
        print('No')

Verdicts: Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
n,k,q = map(int,(input().split()))

an = [0] * n

for i in range(q):
    an[int(input())] += 1

ans = ["No","Yes"]

for j in range(n):
    print(ans[k-q+an[j]>0])

n,k,q = map(int,(input().split()))

an = [0] * n

for i in range(q):
    an[int(input())-1] += 1

ans = ["No","Yes"]
#print(an)
for j in range(n):
    print(ans[k-q+an[j]>0])

Verdicts: Runtime Error

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
def minus(n):
    return n - 1

n,k,q = map(int,input().split())
a = [0] * q
b = [0] * n

for i in range(q):
    a[i] = int(input())

print(a)
member = [k]*n

for j in range(q):
    member[a[j]-1] = member[a[j]-1] + 1
    member = list(map(minus,member))
    print(member)

for k in range(n):
    if member[k] <= 0:
        print("No")
    else:
        print("Yes")

n,k,q = map(int,input().split())
a = [0] * q

member = [k] * n

for i in range(q):
    a[i] = int(input())
    member[a[i]-1] = member[a[i]-1] + 1

for j in range(n):
    if member[j] - q <= 0:
        print("No")
    else:
        print("Yes")

Verdicts: Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
n, k, q = map(int, input().split())
a = []
for i in range(q):
    a[i] = int(input()) - 1
score = [0 for _ in range(n)]

for a_i in a:
    score[a_i] += 1

for i in range(n):
    result = k - q + score[i]
    print("YES" if result > 0 else "NO")


n, k, q = map(int, input().split())
a = []
for i in range(q):
    a[i] = int(input()) - 1
score = [0 for _ in range(n)]

for a_i in a:
    score[a_i] += 1

for i in range(n):
    result = k - q + score[i]
    print("Yes" if result > 0 else "No")


n, k, q = map(int, input().split())
a = [int(input())-1 for _ in range(q)]
score = [0 for _ in range(n)]

for a_i in a:
    score[a_i] += 1

for i in range(n):
    result = k - q + score[i]
    print("YES" if result > 0 else "NO")


n, k, q = map(int, input().split())
a = []
for i in range(q):
    a.append(int(input()) - 1)
score = [0 for _ in range(n)]

for a_i in a:
    score[a_i] += 1

for i in range(n):
    result = k - q + score[i]
    print("Yes" if result > 0 else "No")


Verdicts: Runtime Error

Runtime Error

Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
n,k,q = map(int,input().split())

S=[0]*n
for i in range(q):
    a = int(input())
    S[a-1]+=1
    
print( S, max(S) )

for i in range(n):
    if S[i]>q-k :
        print("Yes")
    else:
        print("No")


n,k,q = map(int,input().split())

S=[0]*n
for i in range(q):
    a = int(input())
    S[a-1]+=1
    
for i in range(n):
    if S[i]>q-k :
        print("Yes")
    else:
        print("No")


Verdicts: Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
N, K, Q = map(int, input().split())
A = []
for _ in range(Q):
    A.append(int(input()))

point = [K] * N

for i in range(Q):
    if A[i] == i:
        break
    else:
        point[i] -= 1

for j in range(N):
    if point[j] > 0:
        print('Yes')
    else:
        print('No')

N, K, Q = map(int, input().split())
A = [K-Q] * N
for _ in range(Q):
    i = int(input())
    A[i-1] += 1
cnt = 0
for i in range(N):
    if A[i] > 0:
        ans = 'Yes'
    else:
        ans = 'No'
    print(ans)

Verdicts: Runtime Error

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
n,k,q = tuple(map(int,input().split()))

check = []

for _ in [0]*q:
  check[int(input())-1]+=1
  
for i in range(n):
  judge = k-(q-check[i])
  if judge<=0:
    print("No")
  else:
    print("Yes")

n,k,q = tuple(map(int,input().split()))

check = [0]*n

for _ in [0]*q:
  check[int(input())-1]+=1
  
for i in range(n):
  judge = k-(q-check[i])
  if judge<=0:
    print("No")
  else:
    print("Yes")


Verdicts: Runtime Error

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
import numpy as np

N,K,Q = map(int, input().split())
A = [K] * N

A_np = np.array(A)

for i in range(Q):
	a = int(input())
	A_np -= 1
	A_np[a-1] += 1
	print(A_np)


for j in range(N):
	if A_np[j] > 0:
		print("Yes")
	else:
		print("No")

N,K,Q = map(int, input().split())
#A = [K] * N

A = [0] * N

for i in range(Q):
	a = int(input())
	A[a-1] += 1

sm = sum(A)

for j in range(N):
	if K - (sm-A[j]) > 0:
		print("Yes")
	else:
		print("No")


Verdicts: Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
N,K,Q = map(int,input().split())

lis = []
point = []

for i in range(N+1):
    point[i] = K

for x in range(int(input())):
    lis.append(input())

for i in lis:
    for j in range(N+1):
        if i == j :
            point[j] += 1
        else:
            point[i] -= 1

for i in range(N+1):
    if point[i] >= 1:
        print("Yes")
    else:
        print("No")


N,K,Q = map(int,input().split())

lis = []
for _ in range(Q):
    lis.append(int(input()))

point = [K] * N

for i in range(Q):
    num = lis[i]
    point[num-1] += 1

for j in range(N):
    point[j] -= Q



for i in range(N):
    if point[i] > 0:
        print('Yes')
    else:
        print('No')


Verdicts: Runtime Error

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
n, k, q = map(int, input().split())
a = [input() for i in range(q)]
point = []
one = []
ans = []

for j in range(n):
  point.append(k)
  one.append(1)
  
for x in range(q):
  point = [p-o for (p,o) in zip(point, one)] 
  point[int(a[x])] += 1

for y in range(n):
  if point[y] <= 0:
    ans.append('No')
  else:
    ans.append('Yes')

for z in range(n):
  print(ans[z])

n, k, q = map(int, input().split())
a = [input() for i in range(q)]
point = []
ans = []

for z in range(n):
  point.append(0)

for j in range(q):
  point[int(a[j])-1] += 1
  
for x in range(n):
  if point[x] > q-k:
    ans.append('Yes')
  else:
    ans.append('No')
  print(ans[x])

Verdicts: Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
import sys
pos=input()
pos=pos.split()
N=int(pos[0])
P=int(pos[1])
T=int(pos[2])
point={P}*N

for i in range(0,T):
    c=input()
    point={p-1 for p in point}
    point{int(c)-1}+=1

for i in range(0,N):
    if(point{i}>0):
        print('Yes')
    else:
        print('No')

pos=input()
pos=pos.split()
N=int(pos[0])
P=int(pos[1])
T=int(pos[2])
point=[0]*N

for i in range(0,T):
    c=input()
    point[int(c)-1]+=1
point=[P-T+d for d in point]
print(point)
for i in range(0,N):
    if(point[i]>0):
        print('Yes')
    else:
        print('No')

pos=input()
pos=pos.split()
N=int(pos[0])
P=int(pos[1])
T=int(pos[2])
point=[0]*N

for i in range(0,T):
    c=input()
    point[int(c)-1]+=1
point=[P- d for d in point]
for i in range(0,N):
    if(point[i]>0):
        print('Yes')
    else:
        print('No')

pos=input()
pos=pos.split()
N=int(pos[0])
P=int(pos[1])
T=int(pos[2])
point=[0]*N

for i in range(0,T):
    c=input()
    point[int(c)-1]+=1
point=[P-T+d for d in point]
for i in range(0,N):
    if(point[i]>0):
        print('Yes')
    else:
        print('No')

Verdicts: Runtime Error

Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
n, k, q = map(int, input().split())
A = []
for _ in range(q):
    a = int(input())
    A.append(a)

p = [k]*n
for i in range(len(A)):
    ele = A[i]-1
    print(ele)
    for j in range(len(p)):
        if j != ele:
            p[j] = p[j]-1
    
for l in range(len(p)):
    if p[l] > 0:
        print('Yes')
    elif p[l] <= 0:
        print('No')

n, k, q = map(int, input().split())
A = []
for _ in range(q):
    a = int(input())
    A.append(a)
    
p = [k-q]*n
for i in range(len(A)):
    val = A[i]-1
    p[val] += 1

for l in range(len(p)):
    if p[l] > 0:
        print('Yes')
    elif p[l] <= 0:
        print('No')

Verdicts: Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
N,K,Q = map(int,input().split())
A=[0]*Q
for i in range(Q):
    A[i]=int(input())

sanka=[0]*N
for i in range(Q):
    sanka[A[i]-1] +=1

for j in range(N):
    sanka[j]=sanka[j]+K-Q

print(sanka)

for k in range(N):
    if sanka[k]>=1:
        print('Yes')
    else:
        print('No')


N,K,Q = map(int,input().split())
A=[0]*Q
for i in range(Q):
    A[i]=int(input())

sanka=[0]*N
for i in range(Q):
    sanka[A[i]-1] +=1

for j in range(N):
    sanka[j]=sanka[j]+K-Q

for k in range(N):
    if sanka[k]>=1:
        print('Yes')
    else:
        print('No')


Verdicts: Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
n,k,q = map(int,input().split())
a = []
for _ in range(q):
    a.append(int(input()))
#
point_get = [0] * n
for i in range(q):
    point_get[a[i]-1] += 1
#
print(point_get)
for j in range(n):
    if k - q + point_get[j] >= 1:
        print('Yes')
    else:
        print('No')


n,k,q = map(int,input().split())
a = []
for _ in range(q):
    a.append(int(input()))
#
point_get = [0] * n
for i in range(q):
    point_get[a[i]-1] += 1
#
for j in range(n):
    if k - q + point_get[j] >= 1:
        print('Yes')
    else:
        print('No')


Verdicts: Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
N,K,Q=map(int,input().split())
A=[K]*N

for q in range(Q):
  win=int(input())
  for i in range(N):
    if i!=win:
      A[i]-=1

def hantei(x):
    if x >0:
        return('Yes')
    else:
        return('No')
      
for answer in map(hantei,A):
    print(answer)

N,K,Q=map(int,input().split())
A=[0]*N
for i in range(Q):
    A[int(input())-1]+=1
for j in range(N):
    if K-Q+A[j]>0:
        print('Yes')
    else:
        print('No')

Verdicts: Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
N,K,Q = map(int,input().split())
S=[int(input()) for i in range(Q)]
Point=[int(K-Q) for i in range(N)]
for x in range(Q):
    Point[S[x]]+=1

for x in range(N):
    if Point[x]<1:
        print("No")
    else:
        print("Yes")

N,K,Q = map(int,input().split())
S=[int(input()) for i in range(Q)]
Point=[int(K-Q) for i in range(N)]
for x in range(Q):
    Point[S[x]-1]+=1

for x in range(N):
    if Point[x]<1:
        print("No")
    else:
        print("Yes")

Verdicts: Runtime Error

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
n,k,q = map(int,input().split())

ans=[-q]*n
for i in range(q):
    ans[int(input())-1] += 2
print(ans)
for i in ans:
    if i>0:
        print("Yes")
    else:
        print("No")

n,k,q = map(int,input().split())

ans=[k-q]*n
for i in range(q):
    ans[int(input())-1] += 1
# print(ans)
for i in ans:
    if i>0:
        print("Yes")
    else:
        print("No")

Verdicts: Wrong Answer

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
N, K, Q = list(map(lambda n: int(n), input().split(" ")))
point = [K - Q] * N
for i in range(Q):
  c = int(input())
  point[c - 1] += 1

print("\n".join(["YES" if p > 0 else "NO" for p in point]))

N, K, Q = list(map(lambda n: int(n), input().split(" ")))
point = [K - Q] * N
for i in range(N):
  c = int(input())
  point[c - 1] += 1

print("\n".join(["YES" if p > 0 else "NO" for p in point]))

N, K, Q = list(map(lambda n: int(n), input().split(" ")))
point = [K - Q] * N
for i in range(Q):
  c = int(input())
  point[c - 1] += 1

print("\n".join(["Yes" if p > 0 else "No" for p in point]))

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
from collections import Counter
n,k,q = map(int,input().split())
a = [int(input) for _ in range(n)]
a = Counter(a)
for i in range(1,n+1):
    if a[i] > q-k:
        print('Yes')
    else:
        print('No')

from collections import Counter
n,k,q = map(int,input().split())
a = [int(input()) for _ in range(q)]
a = Counter(a)
for i in range(1,n+1):
    if a[i] > q-k:
        print('Yes')
    else:
        print('No')

Verdicts: Runtime Error

Accepted
Problem: Takahashi has decided to hold fastest-finger-fast quiz games. Kizahashi, who is in charge of making the scoreboard, is struggling to write the program that manages the players' scores in a game, which proceeds as follows.  A game is played by N players, numbered 1 to N. At the beginning of a game, each player has K points.  When a player correctly answers a question, each of the other N-1 players receives minus one (-1) point. There is no other factor that affects the players' scores.  At the end of a game, the players with 0 points or lower are eliminated, and the remaining players survive.  In the last game, the players gave a total of Q correct answers, the i-th of which was given by Player A_i. For Kizahashi, write a program that determines whether each of the N players survived this game.

Submission attempts (in order):
n, k, q = map(int, input().split())
A = [k-q]*n
for i in range(q):
    ans = int(input())
    A[ans] += 1
for i in A:
    print('Yes' if i>0 else 'No')

N, K, Q = map(int, input().split())
points = [K-Q]*N
for i in range(Q):
    points[int(input())-1] += 1

for p in points:
    print('Yes' if p>0 else 'No')

Verdicts: Runtime Error

Accepted