Problem:
 Score : 200 points    Problem Statement 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.      Constraints  All values in input are integers.  1 \leq N, M \leq 20  -100 \leq A_{ij} \leq 100  -100 \leq B_i \leq 100  -100 \leq C \leq 100         Input Input is given from Standard Input in the following format:  N  M  C  B_1  B_2  ...  B_M  A_{11}  A_{12}  ...  A_{1M}  A_{21}  A_{22}  ...  A_{2M}  \vdots  A_{N1}  A_{N2}  ...  A_{NM}       Output Print the number of codes among the given N codes that correctly solve this problem.        Sample Input 1 2 3 -10
1 2 3
3 2 1
1 2 2      Sample Output 1 1  Only the second code correctly solves this problem, as follows:   Since 3 \times 1 + 2 \times 2 + 1 \times 3 + (-10) = 0 \leq 0 , the first code does not solve this problem.  1 \times 1 + 2 \times 2 + 2 \times 3 + (-10) = 1 > 0 , the second code solves this problem.        Sample Input 2 5 2 -4
-2 5
100 41
100 40
-3 0
-6 -2
18 -13      Sample Output 2 2       Sample Input 3 3 3 0
100 -100 0
0 100 100
100 100 100
-100 100 100      Sample Output 3 0  All of them are Wrong Answer . Except yours.

Solution (Python):
n, m, c = map(int, input().split())
B = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(n)]
ans = 0
for i in range(n):
    total = c
    for j in range(m):
        total += A[i][j] * B[j]
    if total > 0:
        ans += 1
print(ans)

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

Solution (Python):
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)

Solution (Python):
from sys import stdin
N, M, C = map(int, input().split())
B = list(map(int, input().split()))

A = [stdin.readline().rstrip().split() for _ in range(N)]

ans = []
for i in range(N):
    L = []
    for j, v in enumerate(B):
        L.append(int(A[i][j]) * B[j])
    ans.append(sum(L) + C)


count = 0
for i in ans:
    if (i > 0):
        count += 1

print(count)

Solution (Python):
nmc = list(map(int,input().split()))
b = list(map(int,input().split()))
cnt = 0
for i in range(nmc[0]):
    a = list(map(int,input().split()))
    
    t = 0
    for j in range(len(a)):
        t += a[j]*b[j]        
    
    if t + nmc[2] >0:
        cnt += 1
print(cnt)

Solution (Python):
import numpy as np
n, m, c = map(int, input().split())
b = np.array(list(map(int, input().split())))

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

Solution (Python):
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):
    point = 0
    for j in range(M):
        point += A[i][j]*B[j]
    point += C
    if point > 0:
        count += 1

print(count)

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

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

Solution (Python):
N,M,C=map(int,input().split())
b = input().rstrip().split(' ')
count = 0
for i in range(N):
  t = input().rstrip().split(' ')
  total = 0
  for j in range(M):
    total += int(t[j]) * int(b[j])
  total += C
  if total > 0:
    count += 1
print(count)

Solution (Python):
n, m, c = map(int, input().split())
*B, = map(int, input().split())
cnt = 0
for i in range(n):
    *A, = map(int, input().split())
    if sum([A[j]*B[j] for j in range(m)])+c > 0:
        cnt += 1
print(cnt)

Solution (Python):
n,m,c = map(int,raw_input().split())
b = map(int,raw_input().split())
 
res = 0
for i in range(n):
    ai = map(int,raw_input().split())
    ab = [ai[j] * b[j] for j in range(m)]
    if sum(ab) +c > 0:
        res +=1
print res

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

Solution (Python):

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

cnt = 0

for i in range(n):
    tmp = 0
    for j in range(m):
        tmp += a[i][j] * b[j]
        
    tmp += c
    if tmp > 0:
        cnt += 1
        
print(cnt)

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

B = list(map(int,input().split()))
A=[]
for i in range(N):
    a = list(map(int,input().split()))
    A.append(a)
c=0

for i in range(N):
    ans=0
    for j in range(M):
        ans += A[i][j] * B[j]

    if ans + C > 0:
        c+=1
print(c)

Solution (Python):
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(N)]
Answer = 0
count = 0

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

print(count)

Solution (Python):
import numpy as np
a,b,c = map(int,input().split())
b_list = list(map(int,input().split()))
a_list =[]
for _ in range(a):
  a_list.append(list(map(int,input().split())))

ans = 0
for i in range(a):
  if sum((np.array(b_list) * np.array(a_list[i])).tolist()) + c > 0:
    ans +=1
    
print(ans)

Solution (Python):
n, m, c = map(int, input().split())
B_list = list(map(int, input().split()))
A_list = [list(map(int, input().split())) for _ in range(n)]
ans = 0
for i in range(n):
    temp_n = 0
    for j in range(m):
        temp_n += A_list[i][j] * B_list[j]
    if temp_n + c > 0:
        ans += 1

print(ans)

Solution (Python):

import sys
import numpy as np

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

N, M, C = lr()
B = np.array(lr())
A = np.array([lr() for _ in range(N)])
answer = ((A*B).sum(axis=1) + C > 0).sum()
print(answer)

Solution (Python):

import sys
import numpy as np

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

N, M, C = lr()
B = np.array(lr())
answer = 0
for i in range(N):
    A = np.array(lr())
    bl = (A * B).sum() + C > 0
    if bl:
        answer += 1

print(answer)

Solution (Python):
N, M ,C = map(int, input().split())
B = list(map(int,input().split()))

ans = 0

for n in range(N):
    A = list(map(int,input().split()))
    tmp_n = C
    for a,b in zip(A,B):
        tmp_n += a*b

    if tmp_n>0:
        ans +=1

print(ans)

Solution (Python):
N, M, C = map(int,input().split())
B = list(map(int,input().split()))

ans = 0


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

Solution (Python):
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 sum([A[j]*B[j] for j in range(M)])+C > 0:
    count+=1
print(count)

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

print(ans)

Solution (Python):
N,M,C = list(map(int, input().split()))
B = list(input().split())
A = list([input().split() for i in range(N)])
count = 0
for i in range(N):
    D_list =[] 
    for j in range(M):
        D =  int(A[i][j])*int(B[j])
        D_list.append(D)
    Sum = sum(D_list)
    if Sum + C > 0:
        count = count + 1
print(count)

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

ans = 0 
for a in A:
    c = C
    for i, j in zip(a, B):
        c += i*j
    if c > 0:
        ans += 1

print(ans)

Solution (Python):
n,m,c=map(int,input().split())
bl=list(map(int,input().split()))
ans=0
for i in range(n):
  al=list(map(int,input().split()))
  if sum([x * y for (x, y) in zip(al,bl)])+c > 0:
    ans+=1
print(ans)

Solution (Python):
n,m,c=map(int,input().split())
blist=list(map(int,input().split()))
ans=0
for i in range(n):
    tmpSum=c
    tmpList=list(map(int,input().split()))
    for j in range(m):
        tmpSum+=tmpList[j]*blist[j]
    if tmpSum>0:
        ans+=1
print (ans)

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

Solution (Python):


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

ans=0
tmp=0
for i in range(n):
    for j in range(m):
        tmp+=a[i][j]*b[j]
    tmp+=c
    if tmp>0:
        ans+=1
    tmp=0

print(ans)

Solution (Python):
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)

Solution (Python):
N, M, C = map(int, input().split())
lb = list(map(int, input().split()))
la = list()

for i in range(N):
    la.append(list(map(int, input().split())))

lailb = list()
ans = 0
for i in range(N):
    lailb = [la[i][k] * lb[k] for k in range(M)]
    
    if sum(lailb) + C > 0:
        ans += 1
    
print(ans)

Solution (Python):
icase=0
if icase==0:
    n,m,c=map(int,input().split())
    b=list(map(int,input().split()))
    icnt=0
    for i in range(n):
        ai=list(map(int,input().split()))
        ab=0
        for ii in range(m):
            ab+=ai[ii]*b[ii]
        if 0<ab+c:
            icnt+=1
    print(icnt)

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

ans = 0
l = []

for i in range(n):
  for j in range(m):
    l.append(a[i][j] * b[j]) 
  if sum(l) + c > 0:
      ans += 1
      l.clear()
  else:
      l.clear()

print(ans)

Solution (Python):
n, m, c = map(int, input().split())
b = list(map(int, input().split()))
cord = []
accept = 0
for i in range(n):
    a = list(map(int, input().split()))
    cord.append(a)
for i in cord:
    a = 0
    for j in range(m):
        x = i[j] * b[j]
        a += x
    if a + c > 0:
        accept += 1
print(accept)

Solution (Python):
import numpy as np
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**8)
INF = float('inf')
MOD = 10**9+7


def main():
  N, M, C = map(int, readline().split())
  B = np.array(readline().split(), np.int64)
  A = list(list(map(int, readline().split()))for _ in range(N))
  A = np.array(A, np.int64)
  ABC = np.dot(A,B) + C
  print(np.where(ABC>0, 1, 0).sum())
  
  
  
  
if __name__ == '__main__':
  main()

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

Solution (Python):
n, m, c = map(int,input().split())
b_list = list(map(int,input().split()))
a_list = []
for i in range(n):
    a_list.append(list(map(int,input().split())))
count = 0

for i in range(n):
    sum = 0
    for j in range(m):
        sum += a_list[i][j] * b_list[j]
    if sum + c > 0:
        count += 1

print(count)

Solution (Python):
def resolve():
    N, M, C = map(int, input().split())
    Blist = [int(i) for i in input().split()]
    count = 0
    for i in range(N):
        Alist = [int(j) for j in input().split()]
        if sum(Alist[j] * Blist[j] for j in range(M)) + C > 0:
            count += 1
    print(count)


if __name__ == "__main__":
    resolve()

Solution (Python):
n, m, c = map(int, input().split())
ans = 0
b = list(map(int, input().split()))

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

Solution (Python):
def main():
    N, M, C = map(int, input().split())
    B = [int(a) for a in input().split()] 
    A = [[int(a) for a in input().split()] for m in range(N)]
    count = 0
    for i in range(N):
        s = 0
        for j in range(M):
            s += B[j]*A[i][j]
        if s + C > 0:
            count += 1
    print(count)
main()

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline


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 += b[j]*a[j]
    if tmp + c > 0:
        ans+=1

print(ans)

Solution (Python):

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

B = [int(i) for i in input().split()]
codes = []
for _ in range(n):
    row = [int(i) for i in input().split()]
    codes.append(row)

ans = 0
for i in range(n):
    code = codes[i]
    t = c
    for a, b in zip(code, B):
        t += a * b
    if t > 0:
        ans += 1
print(ans)

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

Solution (Python):

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)

Solution (Python):
n,m,c = map(int,input().split())
b_line = [int(b) for b in input().split()]
a_lines = [[int(j) for j in input().split()] for i in range(n)]

count = 0
for a_line in a_lines:
    result = c
    for a,b in zip(a_line,b_line):
        result += a*b
    if result>0:
        count+=1
print(count)

Solution (Python):
import numpy as np

N, M, C = map(int, input().split())
B = np.array(input().split(), dtype=np.int32)
A = np.array([input().split() for _ in range(N)], dtype=np.int32)
print(((A * B).sum(axis=1) + C > 0).sum())

Solution (Python):
def main():
    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[j] * B[j] for j in range(M)]) + C > 0:
            ans += 1
    print(ans)


if __name__ == '__main__':
    main()

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

import numpy as np
count = 0
b = np.array(b)
for i in range(n):
  ai = np.array(a[i])
  if np.dot(ai,b)+c > 0: count += 1
print(count)

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

Solution (Python):
n, m, c = map(int, input().split())
B = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(n)]
ans = 0

for i in range(n):
    sum = 0

    for j in range(m):
        sum = sum + A[i][j] * B[j]

    sum = sum + c

    if sum > 0:
        ans = ans + 1

print(ans)

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

Solution (Python):
import io

nim, mike, kite = map(int, input().split(' '))
tim = list(map(int, input().split(' ')))
data = 0
for _ in range(nim):
    a = list(map(int, input().split(' ')))
    if sum([x * y for x, y in zip(a, tim)]) + kite > 0:
        data += 1
print(data)

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

for i in range(n):
  ans = 0
  for j in range(m):
    ans += a[i][j]*b[j]
  ans += c
  if ans > 0:
    cnt += 1
print(cnt)

Solution (Python):
import sys
input = sys.stdin.readline
import numpy as np


def read():
    N, M, C = map(int, input().strip().split())
    B = np.empty(M, dtype=np.int)
    A = np.empty((N, M), dtype=np.int)
    B[:] = input().strip().split()
    for i in range(N):
        A[i] = input().strip().split()
    return N, M, C, B, A

def solve(N, M, C, B, A):
    return np.count_nonzero(np.sum(A*B, axis=1) + C > 0)

if __name__ == '__main__':
    inputs = read()
    print(solve(*inputs))

Solution (Python):
import math

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

passed = 0
for i in range(n):
    a_list = list(map(int, input().split()))
    total = 0
    for j in range(len(a_list)):
        total += a_list[j] * b_list[j]
    if (total + c > 0):
        passed += 1

print(passed)

Solution (Python):
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()))
    d = c
    for k in range(m):
        d+=a[k]*b[k]
    if d>0:
        ans+=1
print(ans)

Solution (Python):
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()))
    d = c
    for k in range(m):
        d+=a[k]*b[k]
    if d>0:
        ans+=1
print(ans)

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

Solution (Python):
import sys,os
from collections import defaultdict, deque
from math import ceil, floor
if sys.version_info[1] >= 5:
    from math import gcd
else:
    from fractions import gcd
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in os.environ else lambda *x: 0
def main(given=sys.stdin.readline):
    input = lambda: given().rstrip()
    LMIIS = lambda: list(map(int,input().split()))
    II = lambda: int(input())
    MOD = 10**9+7
    
    N,M,C = LMIIS()
    B = LMIIS()
    A = [LMIIS() for _ in range(N)]

    ans = 0
    for i in range(N):
        dot = C
        for a,b in zip(A[i],B):
            dot += a*b
        if dot > 0:
            ans += 1
    print(ans)

    

if __name__ == '__main__':
    main()

Solution (Python):

import sys,os
from collections import defaultdict, deque
from math import ceil, floor
if sys.version_info[1] >= 5:
    from math import gcd
else:
    from fractions import gcd
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in os.environ else lambda *x: 0
def main(given=sys.stdin.readline):
    input = lambda: given().rstrip()
    LMIIS = lambda: list(map(int,input().split()))
    II = lambda: int(input())
    MOD = 10**9+7
    
    N,M,C = LMIIS()
    B = LMIIS()
    A = [LMIIS() for _ in range(N)]

    ans = 0
    for i in range(N):
        dot = C
        for a,b in zip(A[i],B):
            dot += a*b
        if dot > 0:
            ans += 1
    print(ans)

    

if __name__ == '__main__':
    main()

Solution (Python):
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
ans = 0
for _ in range(N):
    A = list(map(int, input().split()))
    total = 0
    for a, b in zip(A, B):
        total += a*b
    total += C
    if total > 0:
        ans += 1
print(ans)

Solution (Python):
N, M, C=map(int, input().split())
b=list(map(int, input().split()))
a=[list(map(int, input().split())) for i in range(N)]
cnt=0
judge=0
for i in range(N):
    for j in range(M):
        judge+=a[i][j]*b[j]
    if judge+C>0:
        cnt+=1
    judge=0
print(cnt)

Solution (Python):
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()))
    tmp = 0
    for j in range(M):
        tmp += A[j]*B[j]
    if tmp+C > 0 :
        counter += 1
print(counter)

Solution (Python):
import bisect
import copy
import heapq
import sys
import itertools
import queue
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 10 ** 9 + 7

def read_values(): return map(int, input().split())
def read_index(): return map(lambda x: int(x) - 1, input().split())
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]


class V:
    def __init__(self, f, v=None):
        self.f = f
        self.v = v
 
    def __str__(self):
        return str(self.v)
 
    def ud(self, n):
        if n is None:
            return

        if self.v is None:
            self.v = n
            return
        self.v = self.f(self.v, n) 


def main():
    N, M, C = read_values()
    B = read_list()

    res = 0
    for _ in range(N):
        A = read_list()
        if sum(a * b for a, b in zip(A, B)) + C > 0:
            res += 1

    print(res)


if __name__ == "__main__":
    main()

Solution (Python):
n , m , c = map(int,input().split())
b = list(map(int,input().split()))
a = []
count = 0
x = 0

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



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

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

Solution (Python):
n,m,c = map(int,input().split())
B = list(map(int,input().split()))
A = []
while True:
  try:
    tmp = list(map(int,input().split()))
    A.append(tmp)
  except:
    break
correct = 0
for i in range(n):
  eq = 0
  for j in range(len(B)):
    eq += A[i][j]*B[j]
  if eq>-c:
    correct +=1
print(correct)

Solution (Python):
if __name__ == "__main__":
    n, m, c = map(int, input().split())
    b = list(map(int, input().split()))
    a = [list(map(int, input().split())) for _ in range(n)]

    ans = 0
    for i in range(n):
        tmp = c
        for j in range(m):
            tmp += a[i][j] * b[j]
        if tmp > 0:
            ans += 1

    print(ans)

Solution (Python):
import numpy as np
N,M,C=[int(i)for i in input().split()]
B=np.array([int(b)for b in input().split()])
A=np.array([[int(a)for a in input().split()]for _ in range(N)])


ans=sum([c+C>0 for c in np.dot(A,B)])



print(ans)

Solution (Python):

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

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

Solution (Python):
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)

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

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

Solution (Python):
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)

N, M, C = map(int, readline().split())
B = list(map(int, readline().split()))

ans = 0
for _ in range(N):
    A = map(int, readline().split())
    code_sum = C
    for a, b in zip(A, B):
        code_sum += a*b
    if code_sum > 0:
        ans += 1

print(ans)

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

Solution (Python):

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

b = [int(i) for i in input().split()]


cnt = 0

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

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

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

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

Solution (Python):
n,m,c=map(int,input().split())
b=list(map(int,input().split()))
a=[]
for _ in range(n):
    ai=list(map(int,input().split()))
    a.append(ai)
ans = 0
for i in range(n):
    t=c
    for j in range(m):
        t+=a[i][j]*b[j]
    ans += 1 if t > 0 else 0
print(ans)

Solution (Python):

import sys
input = sys.stdin.readline









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

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

print(ans)

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

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

B = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(N)]

ans = 0
for i in range(N):
    sm = C
    for j in range(M):
        sm += A[i][j] * B[j]

    if sm > 0:
        ans += 1

print(ans)

Solution (Python):
from operator import mul
def p(): return map(int, input().split())
n, _, c = p()
b = list(p())
u = 0
for _ in range(n):
    v = sum(map(mul, b, list(p()))) + c
    if v>0:
        u += 1
print(u)

Solution (Python):
from sys import stdin
input = stdin.readline

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

ans = 0

for _ in range(N):
    A = list(map(int, input().split()))
    s = 0

    for i in range(M):
        s += A[i] * B[i]

    if s > -C:
        ans += 1

print(ans)

Solution (Python):
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
A = []
for i in range(N):
    A.append(list(map(int, input().split())))
total = 0
cnt = 0

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

print(cnt)

Solution (Python):
import numpy as np
n, m, c = map(int, input().strip().split())
bs = np.array(list(map(int, input().strip().split())))
as_ = np.array([list(map(int, input().strip().split())) for _ in range(n)])

result = np.dot(as_, bs) + c
counts = np.ones_like(result)
ans = np.sum(counts[result > 0])

print(ans)

Solution (Python):
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
cal = 0
for i in range(N):
    for k in range(M):
        cal += A[i][k]*B[k]
    if cal + C > 0:
        count += 1
        cal = 0
    else: 
    	cal =0
print(count)

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

Solution (Python):
import numpy as np
N, M, C = map(int, input().split())
B = np.array(list(map(int, input().split())))
A = np.array([list(map(int, input().split())) for _ in range(N)])

ans = 0

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

print(ans)

Solution (Python):
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()))
    solve = c

    for j in range(m):
        solve += A[j]*B[j]
        
        if j == m-1 and solve > 0:
            ans += 1
            
print(ans)

Solution (Python):
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 i in range(n):
  s=c
  for j in range(m):
    s+=a[i][j]*b[j]
  if s>0:
    count+=1
      
print(count)

Solution (Python):
n,m,c = map(int,input().split())
b = list(map(int,input().split()))
a = [list(map(int,input().split())) for i in range(n)]
ans = 0
x = 0
for code in a:
    x+=sum([b[k]*i for k,i in zip(range(m),code)])
    if x+c>0:
        ans+=1
    x=0
print(ans)

Solution (Python):
n,m,c = map(int,input().split())
b = list(map(int,input().split()))
a = [list(map(int,input().split())) for i in range(n)]
ans = 0
x = 0
for code in a:
    for k,i in zip(range(m),code):
        x+=(b[k]*i)
    if x+c>0:
        ans+=1
    x=0
print(ans)

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

Solution (Python):

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()))
    ans = 0
    for j in range(M):
        ans += A[j]*B[j]
    ans += C
    if ans > 0:
        cnt += 1
print(cnt)