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


def read_ints():
    return [int(i) for i in input().split()]

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

correct = sum(
    sum(i * j for i, j in zip(read_ints(), B)) + C > 0 
    for k in range(N)
    )

print(correct)

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

Solution (Python):
N, M, C = [int(x) for x in input().split(' ')]
B = [float(x) for x in input().split(' ')]
ALIS = []
for i in range(N):
  ta = [float(x) for x in input().split(' ')]
  ALIS.append(ta)
  
ans = 0
for i in range(N):
  s = float(C)
  for a,b in zip(ALIS[i],B):
    s += a*b
  if s > 0:
    ans+=1
  
print(ans)

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

ans = 0

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

    if(sum(ar) + c > 0):
        ans += 1

print(ans)

Solution (Python):



import numpy as np

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

print(((np.dot(A, B) + C) > 0).sum())

Solution (Python):

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

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

B=[input().split() for i in range(N+1)]

T=0
b=B.pop(0)



for a in range(N):

    su=0+C
    for c in range(M):
        x=int(B[a][c])*int(b[c])
        su+=x

        if c+1==M:
            if su>0:
                T=T+1
print(T)

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

Solution (Python):
n, m, c = map(int, input().split())
bl = [int(i) for i in input().split()]
ans = 0
for i in range(n):
  al = [int(j) for j in input().split()]
  ans += sum([bl[j] * al[j] for j in range(m)]) + c > 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 _ in range(n)]
cnt = 0
for i in range(n):
  if sum(map(lambda x, y:x*y, a[i], b)) + c > 0:
    cnt += 1
print(cnt)

Solution (Python):
I=lambda:map(int,input().split());n,m,c=I();*b,=I();print(sum(-c<sum(x*y for x,y in zip(I(),b))for _ in[0]*n))

Solution (Python):
N, M, C = input().split()
N = int(N)
M = int(M)
C = int(C)
B_list = list(map(int, input().split()))
A_matrix = [list(map(int, input().split())) for i in range(N)]
answer = 0
for i in range(N):
    AB = 0
    for j in range(M):
        AB_j = B_list[j] * A_matrix[i][j]
        AB += AB_j
    if AB + C > 0:
        answer += 1
print(answer)

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

ans = 0
for a_row in A:
    tmp = C
    for a, b in zip(a_row, B):
        tmp += a * b
    if tmp > 0:
        ans += 1
print(ans)

Solution (Python):
n,m,c = map(int,input().split())
b=list(map(int,input().split()))
ret = 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:
        ret+=1
print(ret)

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

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

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

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

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











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

arrA = np.array(A)

D = np.empty((0,M), int)
for i in range(N):
    D = np.append(D, arrB*arrA[i], axis=0)



F = np.empty((0,N), int)
for i in range(N):
    F = np.append(F, np.sum(D[i]))

E = F + C
t=0
for i in range(N):
    if E[i]>0:
        t = t+1
    else:
        t =t








print(t)

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)


def main():
    n,m,c = LI()
    b = LI()
    aa = [LI() for _ in range(n)]

    r = 0
    for a in aa:
        t = c
        for d,e in zip(a,b):
            t += d * e
        if t > 0:
            r += 1


    return r


print(main())

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



import numpy as np

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

print(((A.dot(B) + C) > 0).sum())

Solution (Python):
n, m, C = map(int, input().split())
B = list(map(int, input().split()))
source = []
score  = 0
for i in range(n):
    source.append([int(x) for x in input().split()])

for j in range(n):
    pre = 0
    for k in range(m):
        pre += source[j][k]*B[k]
    else:
        if pre + C > 0:
            score += 1
print(score)

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

correct_answer_num = 0
for A in As:
    result = 0

    for j in range(M):
        result += A[j] * B[j]

    result += C
    if result > 0:
        correct_answer_num += 1

print("{}".format(correct_answer_num))

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 a:
  SUM = c
  for j,k in zip(i,b):
    SUM += j*k
  if SUM > 0:
    ans += 1
print(ans)

Solution (Python):
from functools import reduce

n, _, c = map(int, input().split())
bs = tuple(map(int, input().split()))

count = 0
for i in range(n):
    if reduce(
        lambda x, y: x + y[0] * y[1],
        zip(bs, map(int, input().split())),
        0,
    ) + c > 0:
        count += 1

print(count)

Solution (Python):
I=lambda:map(int,input().split());n,m,c=I();*b,=I();print(sum(-c<sum(x*y for x,y in zip(I(),b))for _ in[0]*n))

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

Solution (Python):
import copy

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

correct_answer_num = 0
for A in As:
    result = 0

    for j in range(M):
        result += A[j] * B[j]

    result += C
    if result > 0:
        correct_answer_num += 1

print("{}".format(correct_answer_num))

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

cnt = 0
for i in range(N):



    ev = 0
    for j in range(M):
        ev = ev + A[i][j] * B[j]
    ev = ev + C
    if(ev > 0):
        cnt = 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.append(list(map(int, input().split())))
sum = 0
count = 0

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


    if(sum+c>0):
        count = count + 1
    sum = 0

print(count)

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

for i in range(N):
  src.append(list(map(int, input().split()))) 
  
for i in range(N):
  d = C
  for n in range(M):
    d += src[i][n]*B[n]
  if (d > 0):
    ans+= 1

print(ans)

Solution (Python):










if __name__ == '__main__':
	N,M,C = map(int,input().strip().split(' '))
	blist = list(map(int,input().strip().split(' ')))
	counter = 0
	for _ in range(0,N,+1):
		saiten = 0
		alist = list(map(int,input().strip().split(' ')))
		for i in range(0,M,+1):
			saiten = saiten + blist[i]*alist[i]
		saiten = saiten + C
		if 0 < saiten :
			counter = counter + 1

	solution = counter
	print("{}".format(solution))

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

A=dict()
for i in range(1,N+1):
    A[i]=[int(x) for x in input().split()]

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

print(count)

Solution (Python):
import numpy as np

def read_ints():
    return [int(x) for x in input().split()]

def solve(N, M, C, b, a):
    ab = np.dot(a, b) + C
    return np.sum(ab > 0)

N,M,C = map(int, input().split())
b = np.array(read_ints(), dtype=int)
a = np.array([read_ints() for i in range(N)], dtype=int)

print(solve(N,M,C,b,a))

Solution (Python):
lx = list(map(int,input().split(" ")))
lb = list(map(int,input().split(" ")))

la = []
cnt = 0

for i in range(0, lx[0]):
    tmp = lx[2]
    la.append(list(map(int,input().split(" "))))
    for j in range(0, lx[1]):
        tmp += la[i][j] * lb[j]
    if (tmp > 0):
        cnt += 1

print(cnt)

Solution (Python):
N, M, C = map(int,input().split())
b = list(map(int,input().split()))
x=0
a=[[0]*20]*20
for i in range(N):
	a[i]=list(map(int,input().split()))
for i in range(N):
	work=0
	for h in range(M):
		work += a[i][h] * b[h]
	x += (1 if work + C > 0 else 0)
print(x)

Solution (Python):
lx = list(map(int,input().split(" ")))
lb = list(map(int,input().split(" ")))

la = []
for i in range(0, lx[0]):
    la.append(list(map(int,input().split(" "))))

cnt = 0

for i in range(0,lx[0]):
    tmp = lx[2]
    for j in range(0, lx[1]):
        tmp += la[i][j] * lb[j]
    if (tmp > 0):
        cnt += 1

print(cnt)

Solution (Python):
import sys

if __name__ == "__main__":
    para_list = list(map(int, input().split()))
    n = para_list[0]
    m = para_list[1]
    c = para_list[2]

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

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

for l in ls:
    total = c
    for i in range(m):
        total += l[i] * b[i]
    if total > 0:
        ans += 1

print(ans)

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

Solution (Python):
n,m,c = map(int,input().split())
b_lis = list(map(int,input().split()))
num = 0
for i in range(n):
    to = 0
    a_lis = list(map(int,input().split()))  
    for s in range(m):
        to += a_lis[s]*b_lis[s]
        if s == m-1:
            to += c
            if to>0:
                num += 1
print(num)

Solution (Python):
import numpy as np

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

flag = 0
for n in range(N):
    sum_calc = 0
    for m in range(M):
        calc = A[n][m] * B[m]
        sum_calc+=calc
    result = sum_calc + C
    if result>0:
        flag+=1
print(flag)

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

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

ALL = []
for _ in range(N):
    ALL.append(list(map(int, input().split())))

R = 0
for al in ALL:
    if sum([a * b for (a, b) in zip(al, BL)]) + C > 0:
        R += 1

print(R)

Solution (Python):

"""
Created on Sat Mar  9 22:02:12 2019

@author: yuta
"""

NMC = list(map(int,input().split()))
N = NMC[0]
M = NMC[1]
C = NMC[2]
AB = [list(map(int,input().split())) for _ in range(N+1)]

def main(n,m,c,ab):
    b = ab[0]
    count = 0
    for i in range(1,(n+1)):
        naiseki = 0
        for j in range(m):
            naiseki += b[j]*ab[i][j]
            takoushiki = naiseki + c
        if takoushiki > 0:
            count += 1
    print(count)

main(N,M,C,AB)

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

for i in range(N):
    SUM = C
    A_list = list(map(int,input().split()))
    for j in range(M):
        SUM += A_list[j] * B_list[j]
    if SUM > 0:
      counter += 1

print(counter)

Solution (Python):
n,m,c=map(int,input().split())
b=list(map(int,input().split()))
ans=0
ab=[]
for i in range(n):
  a=list(map(int,input().split()))
  for j in range(m):
    ab+=[a[j]*b[j]]
ab=[sum(ab[k:k+m]) for k in range(0,len(ab),m)]
for l in range(n):
  if ab[l]+c>0:
    ans+=1
  else:
    pass
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 j in A:
    ans=C
    for i in range(M):
        ans+=B[i]*j[i]
    if ans >0:
        count+=1
print(count)

Solution (Python):
import numpy as np

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

for i in range(N):
    nlist.append([int(x) for x in input().split()])

nlist=np.array(nlist)
M= np.array(M)
ans=(nlist*M).sum(axis=1)+C
print((ans>0).sum())

Solution (Python):
N, M, C = (int(i) for i in input().split())
B = [int(i) for i in input().split()]
ans = 0
for i in range(N):
  s = C
  A = [int(j) for j in input().split()]
  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())
ans = 0
b = [int(x) for x in input().split()]
for i in range(N):
    tmp = []
    a = [int(x) for x in input().split()]
    for j in range(M):
      tmp.append(a[j] * b[j])
    if sum(tmp) + 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()))
    t = 0
    for j in range(m):
        t += a[j]*b[j]
    if t + 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()))
    t = c
    for j in range(m):
        t += a[j]*b[j]
    if t > 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())))


cnt =0
for a in A:
    c = 0
    for j in range(len(a)):
        c += a[j]*B[j]
    if c+C > 0:
        cnt += 1

print(cnt)

Solution (Python):
N,M,C = map(int,input().split())
b = [int(i) for i in input().split()]
a = []
ret = 0
for i in range(N):
    a.append([int(j) for j in input().split()])

for i in range(N):
    s = 0
    for j in range(M):
        s += a[i][j] * b[j]
    if s + C > 0:
        ret += 1
print(ret)

Solution (Python):
r = 0
a,b,c = map(int,input().split())
moto = list(map(int,input().split()))
for i in range(a):
    if r == 0:
        sosu =0
    else:
        if f+c<=0:
            sosu += 0
        else:
            sosu +=1
    tasu = list(map(int,input().split()))
    r +=1
    for q in range(b):
        if q == 0:
            f = moto[q]*tasu[q]
        else :
            f +=moto[q]*tasu[q]
if f+c<=0:
    sosu += 0
else:
     sosu +=1
print(sosu)

Solution (Python):
import sys
from collections import deque
import copy
import math
def get_read_func(fileobject):
    if fileobject == None :
        return raw_input
    else:
        return fileobject.readline

def main():
    if len(sys.argv) > 1:
        f = open(sys.argv[1])
    else:
        f = None
    read_func = get_read_func(f);
    input_raw = read_func().strip().split()
    [N, M, C] = [int(input_raw[0]), int(input_raw[1]), int(input_raw[2])]
    input_raw = read_func().strip().split()
    B = [int(input_raw[i]) for i in range(M)]


    count = 0
    for i in range(N):
        input_raw = read_func().strip().split()
        s = 0
        for j in range(M):
            s += int(input_raw[j]) * B[j]
        s += C
        if s > 0:
            count += 1

    print count


if __name__ == '__main__':
    main()

Solution (Python):
n,m,c,*a=map(int,open(0).read().split())
b=a[:m]
print(sum(-c<sum(x*y for x,y in zip(b,a[i*m:-~i*m]))for i in range(1,n+1)))

Solution (Python):
import numpy as np
N, M, C = [int(i) for i in input().split()]
B = np.array([int(i) for i in input().split()])
A = []
cor = 0
for i in range(N):
    A = np.array([int(j) for j in input().split()])
    if (sum(A*B) + C) > 0:
        cor += 1
        A = []
    else:
        A = []
print(cor)

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

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

num = 0
for n in range(0, N):
  acc = C
  for m in range(0, M):
    acc = acc + A[n][m] * B[m]
  if acc > 0:
    num = num + 1

print(num)

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

Solution (Python):


import numpy as np

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

cnt = 0
for i in range(len(A)):
    result = np.dot(A[i], B) + C
    if result > 0:
        cnt += 1
print(cnt)

Solution (Python):
f=lambda:list(map(int,input().split()))
n,m,c=f()
b=f()
print(sum(-c<sum(x*y for x,y in zip(b,f()))for _ in[0]*n))

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

Solution (Python):

NMC=input().split()
N=int(NMC[0])
M=int(NMC[1])
C=int(NMC[2])

Bs=input().split()

count=0
dict={}

for i in range(N):
  dict[i]=input().split()

for j in range(N):
  atai=0
  for k,s in zip(dict[j],range(M)):
    atai+=int(k)*int(Bs[s])
  if (atai+C)>0:
    count+=1
print(str(count))

Solution (Python):
n, m, c = map(int, input().split())
blist = [int(i) for i in input().split()]
codes = [input().split() for i in range(n)]
codes = [[int(j) for j in i] for i in codes]
sum_1 = 0
ans = 0
for code in codes:
    for num in range(m):
        sum_1 += code[num]*blist[num]
    sum_1 += c
    if sum_1 >0:
        ans += 1
        sum_1 = 0
    else:
        sum_1 = 0

print(ans)

Solution (Python):
N, M, C = map(int, input().rstrip().split(' '))
bt = list(map(int, input().rstrip().split(' ')))
r = 0
for i in range(N):
    at = list(map(int, input().rstrip().split(' ')))
    sum = 0
    for j in range(M):
        sum += at[j] * bt[j]

    sum += C
    if sum > 0:
        r += 1


print(r)

Solution (Python):
n, m, c = map(int, raw_input().split())
b = map(int, raw_input().split())
ret = 0
for i in range(n):
    a = map(int, raw_input().split())
    if sum([t[0] * t[1] for t in zip(a, b)]) + c > 0:
        ret += 1
print ret

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

Solution (Python):


def io_generator():
	return input()



def main(io):
	n,m,c= map(int, io().split())
	bs= list(map(int, io().split()))
	ret=0
	for _ in range(n):
		a_s= list(map(int, io().split()))
		ll=[a*b for a,b in zip(a_s,bs)]
		if sum(ll)+c>0:
			ret +=1
		
	return ret



if __name__ == "__main__":
	io= lambda : io_generator()
	print (main(io))

Solution (Python):
import numpy as np
I=lambda:list(map(int,input().split()))
n,m,c=I()
b=np.array(I())
s=0
for _ in range(n):
  d=np.array(I())
  s+=1 if sum(d*b)+c>0 else 0
print(s)

Solution (Python):

"""
Created on Sat Mar  9 20:14:08 2019

@author: USER
"""

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

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

Solution (Python):

import sys

def main():
	B = []
	N, M, C = map(int, input().split(" "))
	tmp = input().split(" ")
	B = [int(s) for s in tmp]
	
	src = []
	for _ in range(N):
		tmp = input().split(" ")
		src.append([int(s) for s in tmp])
		
	ans = 0
	for i, val in enumerate(src):
		total = 0
		for j, vol in enumerate(val):
			total = total + (vol * B[j])
		total = total + C
		
		if total > 0: ans = ans + 1
	
	print(ans)
			
if __name__ == "__main__":
	main()

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

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

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

count = 0
F = []
for i in range(N):
    formula = 0
    for j in range(M):
        formula = formula + A_all[i][j]*B[j]
    F.append(formula + C)
    if F[i] > 0:
        count += 1
print(count)

Solution (Python):



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)

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

Solution (Python):


import sys
import math

import array
import bisect
import collections
from collections import Counter, defaultdict
import fractions
import heapq
import re

sys.setrecursionlimit(1000000)


def array2d(dim1, dim2, init=None):
    return [[init for _ in range(dim2)] for _ in range(dim1)]

def argsort(l, reverse=False):
    return sorted(range(len(l)), key=lambda i: l[i], reverse=reverse)

def argmin(l):
    return l.index(min(l))

def YESNO(ans, yes="YES", no="NO"):
    print([no, yes][ans])

II = lambda: int(input())
MI = lambda: map(int, input().split())
MIL = lambda: list(MI())
MIS = lambda: input().split()


def check(B, C):
    def _check(A):
        return sum([A[i] * B[i] for i in range(len(B))]) + C > 0
    return _check


def main():
    N, M, C = MI()
    B = MIL()
    A = []
    for i in range(N):
        A.append(MIL())
    return sum(map(check(B, C), A))


if __name__ == "__main__":
    print(main())

Solution (Python):
import sys

if __name__ == "__main__":
    para_list = list(map(int, input().split()))
    n = para_list[0]
    m = para_list[1]
    c = para_list[2]

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

Solution (Python):


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

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

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

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

print(CA)

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

Solution (Python):
num_code, num_character, const_correct = map(int, input().split(' '))
multiplier = [int(x) for x in input().split(' ')]

num_correct = 0
for i in range(0, num_code):
    numbers = [int(y) for y in input().split(' ')]
    multiplied = [x*y for x, y in zip(multiplier, numbers)]

    if sum(multiplied) + const_correct > 0:
        num_correct += 1

print(num_correct)
exit(0)

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

t = 0

for a_i in a:
    k = 0
    for i, a_ii in enumerate(a_i):
        k += a_ii * b[i]
    if k + c > 0:
        t += 1

print(t)

Solution (Python):
def can_you_solve_this(
        N: int, M: int, A: list, B: list, C: int)->int:
    AB = [0] * N
    for i in range(N):
        for j in range(M):
            AB[i] += A[i][j] * B[j]
        AB[i] += C
    return sum(1 for ab in AB if ab > 0)


if __name__ == "__main__":
    N = 0
    N, M, C = map(int, input().split())
    B = list(map(int, input().split()))
    A = [[int(s) for s in input().split()] for _ in range(N)]
    ans = can_you_solve_this(N, M, A, B, C)
    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(" ")))
	s = 0
	for i in range(m):
		s += a[i]*b[i]
	if(s+c>0):
		count += 1



print(count)

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

Solution (Python):

import numpy as np
N,M,C = map(int, input().split())
i = [list(map(int, input().split())) for _ in range(N+1)]
i = np.array(i)
B = i[0,0:M]
A = i[1:,0:M]
AA = A * B
BB = np.sum(AA,axis=1)+C
ANS = np.where(BB > 0,1,0).sum()
print(ANS)

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

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

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

count = 0

for i in range(N):
    sum = 0
    A = input().rstrip().split(" ")
    A = list(map(int, A))
    for i in zip(A, B):
        sum += i[0] * i[1]
    if sum + 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 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)