TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
N, M, K =map(int().input().aplit())
bases = list(map(int,input()))
ans=0

for i in range(M):
  A = list(map(int,input().split()))
  tmp=0
  for j in range(3):
    tmp+= bases[j]*A[j]
  if tmp>0:
    ans+=1
    
print(ans)

N, M, K =map(int,input().aplit())
bases = list(map(int,input()))
ans=0

for i in range(M):
  A = list(map(int,input().split()))
  tmp=0
  for j in range(3):
    tmp+= bases[j]*A[j]
  if tmp>0:
    ans+=1
    
print(ans)


N, M, K =map(int,input().aplit())
bases = list(map(int,input().split()))
ans=0

for i in range(M):
  A = list(map(int,input().split()))
  tmp=0
  for j in range(3):
    tmp+= bases[j]*A[j]
  if tmp>0:
    ans+=1
    
print(ans)


N, M, K =map(int,input().split())
bases = list(map(int,input().split()))
ans=0

for i in range(N):
  a= list(map(int,input().split()))
  tmp=0
  for j in range(M):
    tmp+= bases[j]*a[j]
  
  if tmp+K>0:
    ans+=1
    
print(ans)


Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
def is_okay(A, B, C):
    sum = 0
    for i in range(len(B)):
        sum += A[i] * B[i]

    return sum > 0

N, M, C = map(int, input().split())
B = tuple(map(int, input().split()))

answer = 0
for _ in range(N):
    A = tuple(map(int, input().split()))
    answer += is_okay(A, B, C)

print(answer)


def is_okay(A, B, C):
    sum = 0
    for i in range(len(B)):
        sum = sum + A[i] * B[i]

    return sum > C

N, M, C = map(int, input().split())
B = tuple(map(int, input().split()))

answer = 0
for _ in range(N):
    A = tuple(map(int, input().split()))
    answer = answer + is_okay(A, B, C)

print(answer)


def is_okay(A, B, C):
    sum = 0
    for i in range(len(B)):
        sum = sum + A[i] * B[i]

    return sum + C > 0

N, M, C = map(int, input().split())
B = tuple(map(int, input().split()))

answer = 0
for _ in range(N):
    A = tuple(map(int, input().split()))
    answer = answer + is_okay(A, B, C)

print(answer)


Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
N, M, C = map(int,input().split())
B = list(map(int,input().split()))
cnt = 0
for _ in range(N):
    ans = 0
    A = list(map(int,input().split()))
    for i in range(M):
        ans += A[i] * B[i]
        if ans > C:
            cnt += 1
print(cnt)

N, M, C = map(int,input().split())
B = list(map(int,input().split()))
cnt = 0
for _ in range(N):
    ans = 0
    A = list(map(int,input().split()))
    for i in range(M):
        ans += A[i] * B[i]
    ans += C
    if ans > 0:
        cnt += 1
print(cnt)

Verdicts: Wrong Answer

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
N, M, C = map(int, input().split())                                                                                                                         
  2 B = list(map(int, input().split()))
  3  
  4 S = [[0]*M for i in range(N)]
  5 for i in range(N):
  6     S[i] = list(map(int, input().split()))
  7  
  8 b = 0
  9  
 10 for i in range(N):
 11     a = 0
 12     for ii in range(M):
 13         a += S[i][ii] * B[ii]
 14     a += C
 15     if a > 0:
 16         b += 1
 17  
 18 print(str(b))

N, M, C = map(int, input().split())
  2 B = list(map(int, input().split()))
  3  
  4 S = [[0]*M for i in range(N)]
  5 for i in range(N):                                                                                                                                          
  6     S[i] = list(map(int, input().split()))
  7  
  8 b = 0
  9  
 10 for i in range(N):
 11     a = 0
 12     for ii in range(M):
 13         a += S[i][ii] * B[ii]
 14     a += C
 15     if a > 0:
 16         b += 1
 17  
 18 print(str(b))

N, M, C = map(int, input().split())                                                                                                                         
B = list(map(int, input().split()))
 
S = [[0]*M for i in range(N)]
for i in range(N):
    S[i] = list(map(int, input().split()))
  
b = 0
  
for i in range(N):
    a = 0
    for ii in range(M):
        a += S[i][ii] * B[ii]
    a += C
    if a > 0:
        b += 1
print(str(b))

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
[[source]]
name = "pypi"
url = "https://pypi.org/simple"
verify_ssl = true

[dev-packages]

[packages]
pandas = "*"
numpy = "*"

[requires]
python_version = "3.7"


import numpy as np

n, m, c = map(int, input().split())
b = list(map(int, input().split()))

b = np.array(b)

count = 0
for _ in range(n):
    a = list(map(int, input().split()))
    a = np.array(a)

    if np.dot(a, b) + c > 0:
        count += 1
else:
    print(count)

Verdicts: Runtime Error

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
N,M,C=map(int,input().split())
B=list(map(int,input().split()))
ans=0
for i in range(N):
  A=list(map(int,input().split()))
  if sum([a*b for a in A for b in B])+C>0:
    ans+=1
print(ans)

N,M,C=map(int,input().split())
B=list(map(int,input().split()))
ans=0
for i in range(N):
  A=list(map(int,input().split()))
  if sum([a*b for a,b in zip(A,B)])+C>0:
    ans+=1
print(ans)

Verdicts: Wrong Answer

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
"""Boot-camp-for-Beginners_Easy005_B_Can-you-solve-this_25-August-2020.py"""

N, M, C = map(int, input().split())
B = list(map(int, input().split()))
A = list(list(map(int, input().split())) for i in range(N))

count=0
for i in range(N):
    s=0
    for j in range(len(B)):
        s+=B[j]*A[i][j]
    print(s)
    if s+C>0:
        count+=1
print(count)

"""Boot-camp-for-Beginners_Easy005_B_Can-you-solve-this_25-August-2020.py"""

N, M, C = map(int, input().split())
B = list(map(int, input().split()))
A = list(list(map(int, input().split())) for i in range(N))

count=0
for i in range(N):
    s=0
    for j in range(len(B)):
        s+=B[j]*A[i][j]
    if s+C>0:
        count+=1
print(count)

Verdicts: Wrong Answer

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
cnt = 0
for i in range(M):
  A = list(map(int, input().split()))
  tmp = 0
  for j in range(N):
    tmp += A[j]*B[j]
  tmp += C
  if tmp > 0:
    cnt += 1
    
print(cnt)
               

N, M, C = map(int, input().split())
B = list(map(int, input().split()))
cnt = 0
for i in range(N):
  A = list(map(int, input().split()))
  tmp = 0
  for j in range(M):
    tmp += A[j]*B[j]
  tmp += C
  if tmp > 0:
    cnt += 1
    
print(cnt)
               



Verdicts: Runtime Error

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
import numpy as np

N, M, C = map(int,input().split())

B = list(map(int,input().split()))

count = 0
for i in range (N):
    A = list(map(int,input().split()))
    if np.array(A)*np.array(B) > 0:
        count += 1
print(count)

import numpy as np
 
N, M, C = map(int,input().split())
 
B = list(map(int,input().split()))
 
count = 0
for i in range (N):
    A = list(map(int,input().split()))
    if np.sum(np.array(A)*np.array(B)) + C> 0:
        count += 1
print(count)

Verdicts: Runtime Error

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
n,m,c=map(int,input().split())
b=list(map(int,input().split()))
a=[list(map(int,input().split())) for _ in range(n)]
count=0
for i in range(n-1):
    for j in range(m-1):
        total+=b[j]*a[i][j]
    if total>-c:
        count+=1
print(count)

n,m,c=map(int,input().split())
b=list(map(int,input().split()))
a=[list(map(int,input().split())) for _ in range(n)]
count=0
for i in range(n):
    total=0
    for j in range(m):
        total+=b[j]*a[i][j]
    if total>-c:
        count+=1
print(count)

Verdicts: Runtime Error

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
s=input().split()
n=int(s[0]);m=int(s[1]);c=int(s[2])
b=input().split();a=[];ans=0
for i in range n : a.append(input().split())
for i in range n :
  temp=0
  for j in range m : temp+=int(a[i][j])*int(b[j])
  if temp+c>0 : ans+=1
print(ans)

s=input().split()
n=int(s[0]);m=int(s[1]);c=int(s[2])
b=input().split();a=[];ans=0
for i in range(n) : a.append(input().split())
for i in range(n) :
  temp=0
  for j in range(m) : temp+=int(a[i][j])*int(b[j])
  if temp+c>0 : ans+=1
print(ans)

Verdicts: Runtime Error

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
n, m, c = map(int, input().split())
b = map(int, input().split())
count = 0

for i in range(n):
  a = map(int, input().split())
  for j in range(m):
    if 0 < a[m] * b[m] + c:
      count += 1
print(count)

n, m, c = map(int, input().split())
b = map(int, input().split())
count = 0
 
for i in range(n):
  a = map(int, input().split())
  for j in range(m):
    if 0 < a[j] * b[j] + c:
      count += 1
print(count)

n, m, c = map(int, input().split())
b = list(map(int, input().split()))
count = 0
 
for i in range(n):
  a = list(map(int, input().split()))
  p = c
  for j in range(m):
  	p += a[j] + b[j]
  if 0 < p:
    count += 1
print(count)

n, m, c = map(int, input().split())
b = map(int, input().split())
counter = 0
for i in range(n):
  a = map(int, input().split())
  if sum([b[i]*a[i] for i in range(m)]) + c > 0:
    counter += 1
print(counter)

n, m, c = map(int, input().split())
b = map(int, input().split())
count = 0
 
for i in range(n):
  a = map(int, input().split())
  for j in range(m):
    if 0 < (a[j] * b[j] + c):
      count += 1
print(count)

n, m, c = map(int, input().split())
b = list(map(int, input().split()))
count = 0
 
for i in range(n):
  a = list(map(int, input().split()))
  p = c
  for j in range(m):
  p += a[j] + b[j]
  if 0 < p:
    count += 1
print(count)

n, m, c = map(int, input().split())
b = list(map(int, input().split()))
count = 0
 
for i in range(n):
  a = list(map(int, input().split()))
  for j in range(m):
    if 0 < a[m] * b[m] + c:
      count += 1
print(count)

n, m, c = map(int, input().split())
b = list(map(int, input().split()))
counter = 0
for i in range(n):
  a = list(map(int, input().split()))
  if sum([b[i]*a[i] for i in range(m)]) + c > 0:
    counter += 1
print(counter)


Verdicts: Runtime Error

Runtime Error

Wrong Answer

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
n,m,c = map(int,input().split())
ans = 0
for i in range(m):
    current = 0
    a = list(map(int,input().split()))
    for k,j in enumerate(a):
        current += j*(k+1)
    ans += 1 if c+current else 0
print(ans)

n,m,c = map(int,input().split())
b = list(map(int,input().split()))
ans = 0
for i in range(n):
    a = list(map(int,input().split()))
    ans += 1 if 0 < c+sum([a[j]*b[j] for j in range(m)]) else 0
print(ans)

Verdicts: Runtime Error

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
N, M, C = map(int, input().split())
B = [int(input()) for i in range(M)]
A = [[int(input()) for i in range(M)] for j in range(N)]
cnt = 0
for i in range(N):
    ans = 0
    for j in range(M):
        ans += A[j][i] * B[j]
    if ans + C > 0:
        cnt += 1
print(cnt)


N, M, C = map(int, input().split())
B = [int(input()) for i in range(M)]
A = [[int(input()) for i in range(M)] for j in range(N)]
cnt = 0
for i in range(N):
    ans = 0
    for j in range(M):
        ans += A[i][j] * B[j]
    if ans + C > 0:
        cnt += 1
print(cnt)


N, M, C = map(int, input().split())
B = list(map(int, input().split()))
ans = 0

for i in range(N):
    A = list(map(int, input().split()))
    tmp = C
    for i, j in zip(A, B):
        tmp += i * j
    if tmp > 0:
        ans += 1
print(ans)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
n,m,c = map(int,input().split())
a = input().split()
a = [int(x) for x in a]

d = 0
e = 0
for i in range(n):
    b = input().split()
    b = [int(x) for x in b]
    for j in range(m):
        d += b[j]*a[j]
    print(d)
    if d + c >0:
        e += 1
    d = 0
print(e)

n,m,c = map(int,input().split())
L = list(map(int,input().split()))
cnt = 0
for i in range(n):
    wa = 0
    li = list(map(int,input().split()))
    for j in range(m):
        wa +=L[j]*li[j]
    if wa + c >0:
        cnt +=1
print(cnt)

Verdicts: Wrong Answer

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
N,M,C=map(int, input().split())
B=list(map(int, input().split()))
count = 0
for i in range(N):
  A=list(map(int, input().split()))
  hyoka = 0
  for k in range(M):
    hyoka = hyoka + A[k]*B[k]
  if hyoka+C > 0:
    count = cocunt + 1
print(count)

N,M,C=map(int, input().split())
B=list(map(int, input().split()))
count = 0
for i in range(N):
  A=list(map(int, input().split()))
  hyoka = 0
  for k in range(M):
    hyoka = hyoka + A[k]*B[k]
  if hyoka+C > 0:
    count = count + 1
print(count)

Verdicts: Runtime Error

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
n, m, c = list(map(int, input().split()))
B = list(map(int, input().split()))
count = 0
li = [list(map(int, input().split())) for i in range(n)]

for i in range(n):
    d = 0
    for j in range(m):
        d = li[i][j] * B[j]
    else:
        d += c
        if d > 0:
            count += 1
print(count)

n, m, c = list(map(int, input().split()))
B = list(map(int, input().split()))
count = 0
li = [list(map(int, input().split())) for i in range(n)]

for i in range(n):
    num = 0
    for j in range(m):
        d = li[i][j] * B[j]
    else:
        d += c
        if d > 0:
            count += 1
print(count)

n, m, c = list(map(int, input().split()))
B = list(map(int, input().split()))
count = 0
li = [list(map(int, input().split())) for i in range(n)]

for i in range(n):
    d = 0
    for j in range(m):
        d += li[i][j] * B[j]
    else:
        d += c
        if d > 0:
            count += 1
print(count)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
import numpy as np
n,m,c=map(int,input().split())
b=np.array(list(map(int,input().split())))
ac=0
for _ in range(n):
    a=np.array(list(map(int,input().split())))
    print(a*b)
    if sum(a*b)+c >0:
        ac+=1
print(ac)


import numpy as np
n,m,c=map(int,input().split())
b=np.array(list(map(int,input().split())))
ac=0
for _ in range(n):
    a=np.array(list(map(int,input().split())))
    if sum(a*b)+c >0:
        ac+=1
print(ac)


Verdicts: Wrong Answer

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
N, M, C = map(int, input().split())
B = [int(_) for _ in input().split()]
for i in range(1, N + 1):
    Ai = [int(_) for _ in input().split()]

right = 0

for j in range(1,N + 1):
  src = 0
  for k in range(M):
    src += Aj[k] * B[k]
  if src + C > 0:
    right += 1

print(right)


N, M, C = map(int, input().split())
B = [int(_) for _ in input().split()]
A = []
for i in range(N):
    A.append([int(_) for _ in input().split()])

right = 0

for i in range(N):
    src = 0
    for j in range(M):
        src += A[i][j]*B[j]
    if src + C >0 :
        right + =1

print(right)

N, M, C = map(int, input().split())
B = [int(_) for _ in input().split()]
A = []
for i in range(N):
    A.append([int(_) for _ in input().split()])

right = 0

for i in range(N):
    src = 0
    for j in range(M):
        src += A[i][j]*B[j]
    if src+C>0:
        right+=1

print(right)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
n, m, c = map(int, input().split())
a = []
b = list(map(int, input().split()))

for i in range(n):
    a.append(list(map(int, input().split())))
    print(a)

count = 0
for i in range(n):
    x = 0
    for j in range(m):
        x += a[i][j] * b[j]
    x += c

    if x > 0:
        count += 1
            
print(count)


n, m, c = map(int, input().split())
a = [[0 for i in range(m)] for j in range(n)]
b = [0 for i in range(m)]
for i in range(m):
    b[i] = int(input())
for i in range(n):
    for j in range(m):
        a[i][j] = int(input())

count = 0
for i in range(n):
    x = 0
    for j in range(m):
        x += a[i][j] * b[j]
    x += c

    if x > 0:
        count += 1
            
print(count)


n, m, c = map(int, input().split())
a = []
b = list(map(int, input().split()))

for i in range(n):
    a.append(list(map(int, input().split())))

count = 0
for i in range(n):
    x = 0
    for j in range(m):
        x += a[i][j] * b[j]
    x += c

    if x > 0:
        count += 1
            
print(count)


Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
i = 0
count = 0
while i < N:
    A = list(map(int, input().split()))
#    print ('A', A)
    j = 1
    ans = C
    while j <= M:
        ans +=  A[j-1] * B[j-1]
        j += 1
#    print (ans)
    if ans > 0:
        count += 1
    i += 1
print ('Count', count) 

N, M, C = map(int, input().split())
B = list(map(int, input().split()))
i = 0
count = 0
while i < N:
    A = list(map(int, input().split()))
#    print ('A', A)
    j = 1
    ans = C
    while j <= M:
        ans +=  A[j-1] * B[j-1]
        j += 1
#    print (ans)
    if ans > 0:
        count += 1
    i += 1
print (count) 

Verdicts: Wrong Answer

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(N)]

count = 0
for n in range(N):
  sum = C
  for m in range(M):
    sum += b[m]*a[n][m]
  if sum > 0:
    count += 1
print(count)

N, M, C = map(int, input().split())
B = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(N)]
count=0
for n in range(N):
    sum = C
    for m in range(M):
        sum += B[m]*A[n][m]
    if sum > 0:
        count+= 1
print(count)

Verdicts: Runtime Error

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
# ABC 121: B – Can you solve this?
n, m, c = [int(s) for s in input().split()]
b = [int(s) for s in input().split()]

a = []
for _ in range(n):
    a.append([int(s) for s in input().split()])

counter = 0

for i in range(n):
    answer = c
    
    for j in range(m):
        answer += a[i][j] * b[j]

    if answer > 0:
        print(i, answer)
        counter += 1

print(counter)

# ABC 121: B – Can you solve this?
N, M, C = [int(s) for s in input().split()]
B = [int(s) for s in input().split()]
A = [[int(s) for s in input().split()] for _ in range(N)]

exacts = 0

for i in range(N):
    value = C
    
    for j in range(M):
        value += A[i][j] * B[j]
    
    if value > 0:
        exacts += 1

print(exacts)

Verdicts: Wrong Answer

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque
from decimal import *


def lcm(x, y):
    return (x * y) // math.gcd(x, y)


if __name__ == '__main__':
    n,m,c = map(int, input().split())
    b = [int(i) for i in input().split()]

    count = 0
    for i in range(n):
        num=0
        a = [int(i) for i in input().split()]
        
        for i in range(m):
            num +=a[i] *b[i]
        if num >c:
            count+=1
    print(count)


import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque
from decimal import *


def lcm(x, y):
    return (x * y) // math.gcd(x, y)


if __name__ == '__main__':
    n,m,c = map(int, input().split())
    b = [int(i) for i in input().split()]

    count = 0
    for i in range(n):
        num=0
        a = [int(i) for i in input().split()]

        for i in range(m):
            num +=a[i] *b[i]
        if num >c*(-1):
            count+=1
    print(count)


Verdicts: Wrong Answer

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
N, M, C = int(input())
B = list(map(int, inpot().split()))
count = 0
for j in range(N)
    A = list(map(int, input().split()))

for i in range(M):
    calc = A[i] * B[i]
    if C + calc > 0
        count+=1

print(count)      
      
  


N, M, C = int(input())
B = list(map(int, inpot().split()))
count = 0
for j in range(N)
    A = list(map(int, input().split()))

for i in range(M):
    calc = A[i] * B[i]
    if C + calc > 0:
        count+=1

print(count)      
      
  


N, M, C = int(input())
B = list(map(int, inpot().split()))
count = 0
for j in range(N)
    A = list(map(int, input().split()))

for i in range(M):
    calc = A[i] * B[i]
    if C + calc > 0
        count+=1

print(count)      
      
  


N, M, C = int(input())
B = list(map(int, inpot().split()))
count = 0
for j in range(N)
    A = list(map(int, input().split()))

for i in range(N):
    calc = A[i] * B[i]
    if C + calc > 0
        count+=1

print(count)      
      
  

N, M, C = int(input())
B = list(map(int, inpot().split()))
count = 0
for j in range(N):
    A = list(map(int, input().split()))
calc = 0
for i in range(M):
    calc = A[i] * B[i]
    if C + calc > 0:
        count+=1

print(count)      
      
  


N, M, C = map(int, input().split())
B = list(map(int, input().split()))
calc = 0
ans = 0

for i in range(N):
    A = list(map(int,input().split()))
    calc = 0
    for j in range(M):
        calc += A[j] * B[j]

    if calc + C > 0:
        ans += 1

print(ans)


Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
# S = input()


n,m,c=map(int,input().split())
b=list(map(int,input().split()))
e = [[int(i) for i in input().split()] for i in range(n)]

total=0
count=0


for j in range(0,n):
	total=0
	for k in range(0,m):
		total+=e[j][k]*b[k]
		print("total is ",total)
	if total+c>0:
		count+=1

print(count)


# S = input()


n,m,c=map(int,input().split())
b=list(map(int,input().split()))
e = [[int(i) for i in input().split()] for i in range(n)]

total=0
count=0


for j in range(0,n):
	total=0
	for k in range(0,m):
		total+=e[j][k]*b[k]
	if total+c>0:
		count+=1

print(count)


Verdicts: Wrong Answer

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
n,m,c = map(int,input().split())
b = list(map(int,input().split()))
cnt = 0
for i in range(n):
  a = list(map(int,input().split()))
  for j in range(m):
    sum = 0
    sum += (a[j]*b[j])
  sum += c
  if sum > 0:
    cnt += 1
  else:
    pass
print(cnt)

n,m,c = map(int,input().split())
b = map(int,input().split())
cnt = 0
sum = 0
for i in range(n):
  a = map(int,input().split())
  for j in range(m):
    sum += (a[j]*b[j])
  sum += c
  if sum > 0:
    cnt += 1
  else:
    pass
print(cnt)

n,m,c = map(int,input().split())
b = map(int,input()split())
cnt = 0
sum = 0
for i in range(n):
  a = map(int,input().split())
  for j in range(m):
    sum += (a[j]*b[j])
    sum += c
  if sum > 0:
    cnt += 1
  else:
    pass
print(cnt)

n,m,c = map(int,input().split())
b = list(map(int,input().split()))
cnt = 0
for i in range(n):
  a = list(map(int,input().split()))
  sum = 0
  for j in range(m):
    sum += (a[j]*b[j])
  sum += c
  if sum > 0:
    cnt += 1
  else:
    pass
print(cnt)

Verdicts: Wrong Answer

Runtime Error

Runtime Error

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
N, M, C = map(int,input().split(' '))
import numpy as np
B = np.array(list(map(int,input().split(' '))))
def f(A, B, C):
    A = np.array(list(map(int,A.split(' '))))
    return np.sum(A*B) +C >  0
print(

N, M, C = map(int,input().split(' '))
import numpy as np
B = np.array(list(map(int,input().split(' '))))
def f(A, B, C):
    A = np.array(list(map(int,A.split(' '))))
    return np.sum(A*B) +C >  0
print(np.sum([f(input(), B, C) for i in range(N)]))

Verdicts: Runtime Error

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
import numpy as np
n, m, c = list(map(int, input().split()))
b = np.array(list(map(int, input().split())))
count = 0
print(b)
for i in range(n):
    a = np.array(list(map(int, input().split())))
    result = sum(a*b) + c
    print(result)
    if result > 0:
        count += 1
print(count)

import numpy as np
n, m, c = list(map(int, input().split()))
b = np.array(list(map(int, input().split())))
count = 0
for i in range(n):
    a = np.array(list(map(int, input().split())))
    result = sum(a*b) + c
    if result > 0:
        count += 1
print(count)

Verdicts: Wrong Answer

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
N,M,C = map(int,input().split())
B = list(map(int,input().split()))
ans = 0
for i in range(N):
  A = list(map(int,input().split()))
  if sum(A*B) + C > 0:
    ans += 1
print(ans)

N,M,C = map(int,input().split())
B = list(map(int,input().split()))
ans = 0
for i in range(N):
  A = list(map(int,input().split()))
  tmp = 0
  for j in range(M):
    tmp += A[j]*B[j]
  if tmp + C > 0:
    ans += 1
print(ans)


Verdicts: Runtime Error

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
n,m,c=map(int,input().split())
b=list(int,input())
a=[list(map(int,input().split())) for i in range(n)]
count=0
for i in range(n):
  sum=c
  for j in range(m):
    sum+=a[i,j]*b[j]
  if sum>0:
    sum+=1
print(sum)

n,m,c=map(int,input().split())
a=[list(map(int,input().split())) for i in range(n+1)]
count=0
for i in range(n):
  sum=c
  for j in range(m):
    sum+=a[i+1][j]*a[0][j]
  if sum>0:
    count+=1
print(count)


Verdicts: Runtime Error

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
NMC = list(map(lambda x: int(x), input().split()))
N = NMC[0]
M = NMC[1]
C = NMC[2]

B = list(map(lambda x: int(x), input().split()))
A = [list(map(lambda x: int(x), input().split())) for i in range(N)]

print("B", B)
print("A", A)
print("N", N)
print("M", M)
print("C", C)

answer = 0

for i in range(len(A)):
  judge = 0
  for m in range(len(A[i])):
    judge += A[i][m] * B[m]

  print("judge", judge)
  if (judge + C > 0):
    answer += 1

print(answer)

NMC = list(map(lambda x: int(x), input().split()))
N = NMC[0]
M = NMC[1]
C = NMC[2]

B = list(map(lambda x: int(x), input().split()))
A = [list(map(lambda x: int(x), input().split())) for i in range(N)]

answer = 0

for i in range(len(A)):
  judge = 0
  for m in range(len(A[i])):
    judge += A[i][m] * B[m]
  if (judge + C > 0):
    answer += 1

print(answer)

Verdicts: Wrong Answer

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
import numpy as np
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
A = [ ]
for i in range(N):
  AA = list(map(int, input().split()))
  A.append(AA)
Bnp = np.array(B)
Anp = np.array(A)
C = np.dot(Anp, Bnp) + 10
D = 0
for i in range(N):
  if C[i] > 0:
    D += 1
print(D)

import numpy as np
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
A = [ ]
for i in range(N):
  AA = list(map(int, input().split()))
  A.append(AA)
Bnp = np.array(B)
Anp = np.array(A)
C = np.dot(Anp, Bnp) - C
D = 0
for i in range(N):
  if C[i] > 0:
    D += 1
print(D)

import numpy as np
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
A = [ ]
for i in range(N):
  AA = list(map(int, input().split()))
  A.append(AA)
Bnp = np.array(B)
Anp = np.array(A)
C = np.dot(Anp, Bnp) + C
D = 0
for i in range(N):
  if C[i] > 0:
    D += 1
print(D)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
n, m, c = map(int, input().split())
b = [int(x) for x in input().split()]
ans = 0
for _ in range(n):
  if sum([b[i] * int(x) for i, x in enumerate(input().split())]) > c:
    ans += 1
print(ans)

n, m, c = map(int, input().split())
b = [int(x) for x in input().split()]
ans = 0
for _ in range(n):
    if sum([b[i] * int(x) for i, x in enumerate(input().split())]) + c > 0:
        ans += 1
print(ans)

Verdicts: Wrong Answer

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
n, m, c = [int(_) for _ in input().split()]
b = [int(_) for _ in input().split()]
a = [[int(_) for _ in input().split()] for i in range(n)]
sum = 0
cnt = 0
for i in range(n):
  sum = 0
  for j in range(m):
    sum = a[i][j] * b[j] + c
  if sum > 0:
    cnt += 1
print(cnt)

n, m, c = [int(_) for _ in input().split()]
b = [int(_) for _ in input().split()]
a = [[int(_) for _ in input().split()] for i in range(n)]
sum = 0
cnt = 0
for i in range(n):
  sum = 0
  for j in range(m):
    sum += a[i][j] * b[j]
  if sum + c > 0:
    cnt += 1
print(cnt)


Verdicts: Wrong Answer

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
n,m,c = map(int,input().split())
b = list(map(int,input().split()))
ans = 0
for i in range(n):
    a = list(map(int,input().split()))
    num = 0
    for j in range(m):
        num += a[j]*b[j]
    num += C
    if num > 0:
        ans += 1
print(ans)

n,m,c = map(int,input().split())
b = list(map(int,input().split()))
ans = 0
for i in range(n):
    a = list(map(int,input().split()))
    num = 0
    for j in range(m):
        num += a[j]*b[j]
    num += c
    if num > 0:
        ans += 1
print(ans)

Verdicts: Runtime Error

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
n,m,c=map(int,input().split())
b=list(map(int,input().split()))
count=0
x=0
for i in range(n):
  lst=list(map(int,input().split()))
  for j in range(m):
    x+=lst[j]*b[j]
  if x-c>0:
    count+=1
print(count)

n,m,c=map(int,input().split())
b=list(map(int,input().split()))
result=0
for i in range(n):
  a=list(map(int,input().split()))
  cnt=c
  for j in range(m):
    cnt+=a[j]*b[j]
  if cnt>0:
    result+=1
print(result)

Verdicts: Wrong Answer

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
N, M, C = map(int, input().split())
B = [int(i) for i in input().split()]
ans = 0
for _ in range(N):
  A = [B[i] * int(j) for i,j in enumerate(input().split())]
  ans += 1 if sum(A) > 0 else 0
print(ans)

N, M, C = map(int, input().split())
B = [int(i) for i in input().split()]
ans = 0
for _ in range(N):
  A = [B[i] * int(j) for i,j in enumerate(input().split())]
  ans += 1 if sum(A) + C > 0 else 0
print(ans)

Verdicts: Wrong Answer

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
n,m,c=map(int, input().split())
B=list(map(int, input().split()))
g=0
for i in range(n):
  A=list(map(int, input().split()))
  for i in range(m):
    t=A[i]*B[i]
    if t+c>0:
      g+=1
print(g)

n,m,c=map(int, input().split())
B=list(map(int, input().split()))
g=0
for i in range(n):
  A=list(map(int, input().split()))
  for i in range(m):
    t+=A[i]*B[i]
  if t+c>0:
    g+=1
  t=0
print(g)

n,m,c=map(int, input().split())
B=list(map(int, input().split()))
g=0
t=0
for i in range(n):
  A=list(map(int, input().split()))
  for i in range(m):
    t+=A[i]*B[i]
  if t+c>0:
    g+=1
  t=0
print(g)


Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
N,M,C = map(int, input().split())
B = [int(_) for _ in input().split()]

count = 0
for i in range(N):
  A = [int(_) for _ in input().split()] 
  sum = 0
  for j in range(M):
    sum = B[j]*A[j]
  if sum-C > 0:
    count += 1

print(count)

N,M,C = map(int, input().split())
B = [int(_) for _ in input().split()]

count = 0
for i in range(len(N)):
  A = [_ for _ in input().split()] 
  sum = 0
  for j in range(M):
    sum = B[j]*A[j]
  if sum-C > 0:
    count += 1

print(count)

N,M,C = map(int, input().split())
B = [int(_) for _ in input().split()]

count = 0
for i in range(len(N)):
  A = [int(_) for _ in input().split()] 
  sum = 0
  for j in range(M):
    sum = B[j]*A[j]
  if sum-C > 0:
    count += 1

print(count)

N,M,C = map(int, input().split())
B = [int(_) for _ in input().split()]

count = 0
for i in range(N):
  A = [int(_) for _ in input().split()] 
  sum = 0
  for j in range(M):
    sum += B[j]*A[j]
  if sum-C > 0:
    count += 1

print(count)

N,M,C = map(int, input().split())
B = [int(_) for _ in input().split()]

count = 0
for i in range(N):
  A = [int(_) for _ in input().split()] 
  sum = 0
  for j in range(M):
    sum += B[j]*A[j]
  if sum+C > 0:
    count += 1

print(count)

Verdicts: Wrong Answer

Runtime Error

Runtime Error

Wrong Answer

Accepted
Problem: There are N pieces of source code. The characteristics of the i-th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM}.  Additionally, you are given integers B_1, B_2, ..., B_M and C.  The i-th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0.  Among the N codes, find the number of codes that correctly solve this problem.

Submission attempts (in order):
n,m,c = map(int,input().split())
b = list(map(int,input().split()))
count = 0
ans = 0
for i in range(n):
  l = list(map(int,input().split()))
  for j in range(m):
    ans += b[j]*a[j]
  if ans +c > 0:
    count += 1
    
  ans = 0
print(count)


n,m,c = map(int,input().split())
b = list(map(int,input().split()))
count = 0
ans = 0
for i in range(n):
  l = list(map(int,input().split()))
  for j in range(m):
    ans += b[j]*a[j]
  if ans +c > 0:
    count += 1
    
  ans = 0
print(count

n,m,c = map(int,input().split())
b = list(map(int,input().split()))
count = 0
ans = 0
for i in range(n):
  l = list(map(int,input().split()))
  for j in range(m):
    ans += b[j]*l[j]
  if ans +c > 0:
    count += 1
    
  ans = 0
print(count)


Verdicts: Runtime Error

Runtime Error

Accepted