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):
    tmp=c
    for j in range(m):
        tmp+=b[j]*a[i][j]
    if tmp>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):
    A =  [int(i) for i in input().split()]
    if sum([A[i]*B[i] for i in range(m)]) + c > 0:
        cnt+=1

print(cnt)

Solution (Python):






import sys
input = sys.stdin.readline

import math
import bisect
from collections import deque
from fractions import gcd
from functools import lru_cache






MOD = 10**9+7
INF = float('inf')






def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]


def inv(n): return pow(n, MOD-2, MOD)


kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret


def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr


def lcm(a, b):
    return a * b // gcd (a, b)


def bit_count(n):
  count = 0
  while n:
    n &= n -1
    count += 1
  return count





N,M,C = inputIL()
B = inputIL()

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

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):
    tmp = np.sum(A[i] * B) + C
    if tmp > 0:
        ans = ans + 1

print(ans)

Solution (Python):
S=lambda:input()
I=lambda:int(input())
L=lambda:list(map(int,input().split()))
def main():
    n,m,c=L()
    b=L()
    a=[]
    for i in range(n):
        ai=L()
        a.append(ai)
    sum=0
    ans=0
    for i in range(n):
        sum=0
        for j in range(m):
            sum+=a[i][j]*b[j]
        sum+=c
        if sum>0: ans+=1
    print(ans)
    

if __name__ == '__main__':
    main()

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)])
ab = a*b

ans = 0
for i in ab:
    if sum(i) + c > 0:
        ans += 1
        
print(ans)

Solution (Python):
N, M, C = [int(i) for i in input().split()]
B = [int(i) for i in input().split()]
res = 0
for _ in range(N):
    if sum([x*y for x, y in zip([int(i) for i in input().split()], B)]) + C > 0:
        res += 1
print(res)

Solution (Python):
x = list(map(int,input().split()))

n = x[0]
m = x[1]
c = x[2]

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

a = [0]*n

for i in range(0,n):
  a[i] = list(map(int,input().split()))

cn = 0

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

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

Solution (Python):
import numpy as np
N, M, C = map(int, input().split())
B = np.array(list(map(int, input().split())))

ans = 0

for i in range(N):
    tmp = np.dot(np.array(list(map(int, input().split()))), B)
    if (tmp.sum() + C) > 0:
        ans += 1

print(ans)

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

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())) 

    tmp = 0

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

    if tmp > 0:
        ans += 1

print(ans)

Solution (Python):
n,m,c = map(int, input().split())
B = list(map(int,input().split()))
ans = 0
for _ in range(n):
    A = [int(i)*j for i,j in zip(input().split(),B)]
    if sum(A)+c>0:
        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())))

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

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)]
s = c
count = 0

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

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)
    A=[]

sum=0
ans=[]
for i in range(n):
    for j in range(m):
        sum+=a[i][j]*b[j]
    ans.append(sum)
    sum=0

for i in range(len(ans)):
    ans[i]+=c

c=0
for i in range(len(ans)):
    if ans[i]>0:
        c+=1
print(c)

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

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from itertools import permutations, accumulate, combinations, combinations_with_replacement
from math import sqrt, ceil, floor, factorial
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy
from operator import itemgetter
from functools import reduce
from fractions import gcd
import sys
def input(): return sys.stdin.readline().rstrip()
def I(): return int(input())
def Is(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def TI(): return tuple(map(int, input().split()))
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def TIR(n): return [TI() for _ in range(n)]
def S(): return input()
def Ss(): return input().split()
def LS(): return list(input())
def SR(n): return [S() for _ in range(n)]
def SsR(n): return [Ss() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
sys.setrecursionlimit(10**6)
MOD = 10**9+7
INF = float('inf')


n, m, c = Is()
B = LI()
A = LIR(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):
n, m, c = map(int, input().split())
b = list(map(int, input().split()))
code_list = [list(map(int, input().split())) for _ in range(n)]
ans = 0
for code in code_list:
  total = 0
  for i, j in zip(code, b):
    total += i * j 
  if (total + c) > 0:
    ans += 1
print(ans)

Solution (Python):

import sys
try:
    from typing import List
except ImportError:
    pass


def solve(N: int, M: int, C: int, B: "List[int]", A: "List[List[int]]"):
    print(sum(
        1 for Ai in A
        if sum(Aij * Bj for Aij, Bj in zip(Ai, B)) + C > 0
    ))


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    M = int(next(tokens))  
    C = int(next(tokens))  
    B = [int(next(tokens)) for _ in range(M)]  
    A = [[int(next(tokens)) for _ in range(M)] for _ in range(N)]  
    solve(N, M, C, B, A)


if __name__ == '__main__':
    main()

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()

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


if __name__ == "__main__":
    main()

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

Solution (Python):
n, m, c = map(int, input().split())
b = list(map(int, input().split()))
count = 0
for i in range(n):
    ans = 0
    a = list(map(int, input().split()))
    for j in range(m):
        ans += a[j] * b[j]
    if ans + 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):
    p = 0
    for j in range(m):
        p += a[i][j] * b[j]
    if p + c > 0:
        ans += 1
print(ans)

Solution (Python):
import sys
import math
import bisect

def main():
    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())))
    ans = 0
    for i in range(n):
        val = 0
        for j in range(m):
            val += A[i][j] * B[j]
        val += c
        if val > 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 i in range(N):
  tmp = 0
  A = list(map(int,input().split()))
  for k in range(M):
    tmp = tmp + (A[k] * B[k])
  tmp = tmp + C
  if(tmp > 0):
    ans += 1
print(str(ans))

Solution (Python):
import sys

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

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

print(res)

Solution (Python):
import numpy as np
N, M, C = map(int, input().split())
B = np.array(list(map(int, input().split())))

ans = 0

for i in range(N):
    tmp = np.dot(np.array(list(map(int, input().split()))), B)
    if (tmp.sum() + C) > 0:
        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)]
for i in range(n):
    a[i]=list(map(int,input().split()))

def judge(x,y,z):
    rt=0
    for i in range(len(x)):
        rt+=x[i]*y[i]
    return rt+z
ans=0
for i in range(n):
    jj=judge(a[i],b,c)
    
    if jj>0:
        ans+=1
print(ans)

Solution (Python):
import numpy as np
from functools import reduce
n,m,c=map(int,input().split())
a=np.array(list(map(int,input().split())))
b=np.empty((n,m),dtype=int)
for i in range(n):
  b[i,:]=np.array(list(map(int,input().split())))
d=np.dot(b,a)

def func(a,b):
  return a+1 if b>-c else a

answer=reduce(func,d,0)
print(answer)

Solution (Python):
import numpy as np
from functools import reduce
n,m,c=map(int,input().split())
a=np.array(list(map(int,input().split())))
b=np.empty((n,m),dtype=int)
for i in range(n):
  b[i,:]=np.array(list(map(int,input().split())))
d=np.dot(b,a)
ans=[1 if i>-c else 0 for i in d]
answer=reduce(lambda a,b:a+b,ans)
print(answer)

Solution (Python):
n, m, c = list(map(int, input().split()))
B = list(map(int, input().split()))
A = []


count = 0

for i in range(n):
    A.append(list(map(int, input().split())))
    sum = 0

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

    sum = sum + c
    if 0 < sum:
        count = count + 1


print(count)

Solution (Python):
N,M,C=list(map(int,input().split()))
ans=0
B_list=list(map(int,input().split()))
for i in range(N):
    l=0
    A_list=list(map(int,input().split()))
    for j,k in zip(A_list,B_list):
        l+=j*k
    l+=C
    if l > 0:
        ans+=1
print(ans)

Solution (Python):
n,m,c = map(int,input().split())
b_list = list(map(int,input().split()))
ans = 0
for i in range(n):
    a = list(map(int,input().split()))
    dum = 0
    for j in range(m):
        dum += a[j] * b_list[j]
    if dum+c > 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())))

ans = 0
for i in range(n):
    sum = 0
    A = np.array(list(map(int, input().split())))
    sum += np.dot(A, B)
    if sum > -c: ans += 1
print(ans)

Solution (Python):
import math
def py():
    print("Yes")
def pn():
    print("No")
def iin():
    x = int(input())
    return x

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

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

count = 0
for A in As:
    A = list(A)
    mapped = list(map(lambda x: x[0]*x[1], zip(A, B)))
    result = sum(mapped) + C
    cond = result > 0
    count = count+1 if cond else count
print(count)

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

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

Solution (Python):
mi = lambda: map(int, input().split())
n, m, c = mi()
b = list(mi())
a = [list(mi()) for _ in range(n)]
print(sum([sum(aij * bj for aij, bj in zip(ai, b)) + c > 0 for ai in a]))

Solution (Python):
n,m,c = map(int,input().split())
b = list(map(int,input().split()))
a = [0]*n
for i in range(n):
    a[i] = 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]
    if x + c > 0:
        count += 1
print(count)

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

for i in range(N):
    tmp = 0
    for j in range(M):
        tmp += int(B[j])*int(code[i][j])
    tmp += C
    if tmp > 0:
        AC_num += 1
    else:
        continue
        
print(AC_num)

Solution (Python):
N, M, C = list(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 = 0
    for j in range(M):
        total += B[j]*A[i][j]
    total += C
    if total > 0:
        ans += 1
print(ans)

Solution (Python):
N, M, C = map(int, input().split())
B, *A = [list(map(int, input().split())) for i in range(N+1)]
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)

Solution (Python):
n, m, c = map(int, input().split())
num = list(map(int, input().split()))
code_list = []
ans = 0

for _ in range(n):
    code_list.append(list(map(int, input().split())))

for code in code_list:
    result = 0
    for i, co in enumerate(code):
        result += co * num[i]
    if result + c > 0:
        ans += 1

print(ans)

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

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

Solution (Python):


import sys
input= lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**9)
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))
def lispin(t=int):return list(pin(t))




def resolve():
    N,M,C=pin()
    B=lispin()
    cnt=0
    for n in range(N):
        
        A=tupin()
        temp=0
        for i in range(M):
            temp+=B[i]*A[i]
        
        if temp+C>0:cnt+=1
    print(cnt)


resolve()

Solution (Python):
n, m, c = map(int, input().split())
b = list(map(int, input().split()))
a_list = list(list(map(int, input().split())) for _ in range(n))
ans = 0

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

Solution (Python):
import sys

input = sys.stdin.readline

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

if __name__ == '__main__':
    main()

Solution (Python):
import sys

input = sys.stdin.readline

def main():
    ans = 0
    n,m,c = map(int, input().split())
    b = list(map(int, input().split()))
    for _ in range(n):
        temp = 0
        a = list(map(int, input().split()))
        for j in range(m):
            temp += a[j]*b[j]
        if temp + 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=[]
cnt=0
for i in range(N):
    A+=[list(map(int,input().split()))]
    sum=0
    for j in range(M):
        sum+=A[i][j]*B[j]
    if sum+C > 0:
        cnt+=1
    
print(cnt)

Solution (Python):
N, M, C = map(int, input().split())
B = [int(i) for i in input().split()]
count = 0
for i in range(N):
    score = 0
    for a, b in zip(input().split(), B):
        score += int(a)*b
    if score + 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)]
count = 0
for i in range(n):
    tmp = c
    for j in range(m):
        tmp += a[i][j] * b[j]
    if tmp > 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):
    sum=0
    for j in range(m):
        sum+=b[j]*a[i][j]
    if sum+c>0:
        ans+=1
print(ans)

Solution (Python):
def main():
    n,m,c = tuple([int(t)for t in input().split()])
    b = tuple([int(t)for t in input().split()]) 
    ans = 0
    for _ in [0]*n:
      t = tuple([int(t)for t in input().split()])
      v = c
      for i in range(m):
        v+=b[i]*t[i]
      if v>0:
          ans+=1
    print(ans)
if __name__ == "__main__":
    main()

Solution (Python):

import numpy as np
N,M,C = list(map(int, input().split()))
B_list = np.array(list(map(int, input().split())))

cnt = 0
for _ in range(N):
    A_list = np.array(list(map(int, input().split())))
    if sum(A_list * B_list) > -C:
        cnt += 1
print(cnt)

Solution (Python):
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
A = []
cnt = 0

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

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()))
    x=C
    for j in range(len(B)):
        x+=A[j]*B[j]
    if x>0:
        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())))

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

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

res=0

for i in range(n):
	cnt=c
	for j in range(m):
		cnt+=A[i][j]*B[j]
	if cnt>0:
		res+=1
		
print(res)

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

def main():
    N, M, C = map(int, readline().rstrip().split())
    B = list(map(int, readline().rstrip().split()))
    ans = 0
    for _ in range(N):
        A = list(map(int, readline().rstrip().split()))
        if sum([a*b for a, b in zip(A, B)]) + 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()))
cnt = 0
for i in range(n):
    A_i = list(map(int, input().split()))
    chk = 0
    for j in range(m):
        chk += (A_i[j]*B[j])
    chk += c
    if chk > 0:
        cnt += 1
    else:
        pass
print(cnt)

Solution (Python):
import sys

readline = sys.stdin.readline

def culc(A, B, C):
    ans = 0
    for i in range(len(B)):
        ans += A[i]*B[i]
    ans += C
    return ans

def main():
    N, M, C = map(int, readline().split())
    B = list(map(int, readline().split()))
    ans = 0
    for _ in range(N):
        A = list(map(int, readline().split()))
        ans += culc(A, B, C)>0
    print(ans)


if __name__ == "__main__":
    main()

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

Solution (Python):
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
A = []
cnt = 0

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

Solution (Python):
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
A = []
cnt = 0

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

Solution (Python):
N,M,C=map(int,input().split())
B=[int(x) for x in input().split()]
A=[]
for i in range(N):
    a=[int(x) for x in input().split()]
    A.append(a)
cnt=0
check=0
for i in range(N):
    for j in range(M):
        check+=B[j]*A[i][j]
    if check>-C:
        cnt+=1
    else:
        pass
    check=0
print(cnt)

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()))
  result = c
  for i in range(m):
    result += a[i] * b[i]
  if result > 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)]


count = 0
for i in A:
  t = C
  for a,b in zip(i, B):
      t += a * b
  if t > 0:
      count += 1
print(count)

Solution (Python):
n, m, c = list(map(int, input().split()))
b_list = list(map(int, input().split()))
a_lists = [list(map(int, input().split())) for _ in range(n)]

ans = 0
for a_list in a_lists:

    v = c
    for i in range(len(a_list)):
        v += a_list[i] * b_list[i]

    if v > 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):
    s = 0
    a = list(map(int,input().split()))
    for i in range(m):
        s += a[i] * b[i]
    if s + c > 0:
        ans += 1
print(ans)

Solution (Python):

import sys


def solve(N: int, M: int, C: int, B: "List[int]", A: "List[List[int]]"):
    ans = 0
    for a in A:
        if sum(aa*bb for aa, bb in zip(a, B)) + C > 0:
            ans += 1
    return ans



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    M = int(next(tokens))  
    C = int(next(tokens))  
    B = [int(next(tokens)) for _ in range(M)]  
    A = [[int(next(tokens)) for _ in range(M)] for _ in range(N)]  
    print(solve(N, M, C, B, A))

def test():
    import doctest
    doctest.testmod()

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 j in range(n)]

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

Solution (Python):
N,M,C = map(int,input().split())
b = list(map(int,input().split()))
cord = [list(map(int,input().split())) for c in range(N)]
ans = 0
for c in cord:
	tmp = 0
	for i in range(M):
		tmp += b[i] * c[i]
	if tmp + C > 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):
    test = 0
    a = list(map(int, input().split()))
    for j in range(m):
        test += a[j]*b[j]
    if test+c > 0:
        count += 1
print(count)

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

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

def test(l,c,m):
    case = list(map(int,input().split()))
    k = 0
    for i in range(m):
        k += l[i]*case[i]
    if k+c>0:
        return 1
    else:
        return 0
        
cnt = 0

for i in range(n):
    cnt += test(x,c,m)
    
print(cnt)

Solution (Python):
import numpy as np
N, M ,C = map(int, input().split())
a = []
for i in range(N+1):
    a.append(list(map(int, input().split())))
all = np.array(a)
sum = 0
num = 0

for i in range(N):
    mul = np.sum(all[0] * all[i+1]) + C
    if mul > 0:
        num += 1
    mul = 0

print(num)

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

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

print(count)

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

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

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

    ans = 0
    for _ in range(n):
        a = [int(i) for i in input().split()]
        _ans = 0
        for _a, _b in zip(a, b):
            _ans += (_a * _b)
        if _ans + c > 0:
            ans += 1

    print(ans)


resolve()

Solution (Python):
N,M,C = map(int,input().split())
B = list(map(int,input().split()))
cnt = 0
for _ in range(N):
  A = list(map(int,input().split()))
  if sum([a*b for a,b in zip(A,B)]) + C > 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 i in range(n)] 
cnt=0
for i in range(n):
    total=0
    for j in range(m):
        total+=B[j]*A[i][j]
    total+=c
    if 0<total:
        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 i in range(n)] 
    

count = 0
for i in A:
    numberSum = c
    for a, b in zip(i, B):
      numberSum += (a * b)  
    if numberSum > 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):
    x = 0
    for j in range(m):
        x += a[i][j] * b[j]
    if x + c > 0:
        ans += 1
print(ans)

Solution (Python):
def resolve():
  N, M, C = [int(i) for i in input().split()]
  B = [int(i) for i in input().split()]
  cnt = 0
  for i in range(N):
    A = list(int(item) for item in input().split())
    condition = sum([a*b for a, b in zip(A, B)]) + C
    if condition > 0:
      cnt += 1
  print(cnt)

resolve()

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

Solution (Python):
N,M,C = map(int,input().split())
B =  [0]*M
A = [[0]*M]*N

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

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

cnt =0

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

print(cnt)