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.



Sample input:
2 3 -10
1 2 3
3 2 1
1 2 2


Sample output:
1

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(count)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import itertools
import math
import fractions
import functools
import copy
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)

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

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

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

        if tmp + C > 0:
            ans += 1

    print(ans)




if __name__ == '__main__':
    main()

Submission status: Accepted

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

print(cnt)

Submission status: Accepted

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

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

print(ans)

Submission status: Accepted

Solution code:
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_list = np.dot(A, B.T) + C * np.ones(N).T
ans = np.count_nonzero(ans_list > 0)
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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 Ai in A:
    d = 0
    for a, b in zip(Ai, B):
        d += a * b
    d += C
    if d > 0:
        ans += 1
print(ans)

Submission status: Accepted

Solution code:
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
answer = 0
for i in range(n):
    for j in range(m):
        ans = B[j]*A[i][j]
        Ans += ans 
    Ans = Ans + c
    if Ans >0 :
        answer += 1
    Ans = 0
print(answer)

Submission status: Accepted

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

print(count)

Submission status: Accepted

Solution code:
I = lambda: map(int, input().split())
N, _, C = I()
*B, = I()
print(sum(sum(a * b for a, b in zip(I(), B)) > -C for _ in range(N)))

Submission status: Accepted

Solution code:
N, _, C = map(int, input().split())
B = list(map(int, input().split()))
print(sum(sum(a * b for a, b in zip(list(map(int, input().split())), B)) + C > 0 for _ in range(N)))

Submission status: Accepted

Solution code:
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):
    a = np.array([list(map(int,input().split()))])
    if np.sum(a*b) + c > 0:
        ans += 1
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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)]

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

import sys
# import math
# from string import ascii_lowercase, ascii_upper_case, ascii_letters, digits, hexdigits
# import re                                    # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from operator import itemgetter              # itemgetter(1), itemgetter('key')
# from collections import deque                # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict          # subclass of dict. defaultdict(facroty)
# from collections import Counter              # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest        # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat   # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby                # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap                # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations  # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate             # accumulate(iter[, f])
# from functools import reduce                 # reduce(f, iter[, init])
# from functools import lru_cache              # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from copy import deepcopy                    # to copy multi-dimentional matrix without reference
# from fractions import gcd                    # for Python 3.4 (previous contest @AtCoder)


def main():
    mod = 1000000007                # 10^9+7
    inf = float('inf')              # sys.float_info.max = 1.79...e+308
    # inf = 2 ** 64 - 1               # (for fast JIT compile in PyPy) 1.84...e+19
    sys.setrecursionlimit(10**6)    # 1000 -> 1000000
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    
    n, m, c = mi()
    B = lmi()
    cnt = 0
    for _ in range(n):
        A = lmi()
        if sum([A[i] * B[i] for i in range(m)]) + c > 0:
            cnt += 1
    print(cnt)


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

#############
# Libraries #
#############

import sys
input = sys.stdin.readline

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


#############
# Constants #
#############

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

#############
# Functions #
#############

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

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

######Combination######
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

######Factorization######
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

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

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

#############
# Main Code #
#############

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)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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()))
#print(a,b)
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)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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=[]
#print(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
#print(ans)
for i in range(len(ans)):
    ans[i]+=c
#print(ans)
c=0
for i in range(len(ans)):
    if ans[i]>0:
        c+=1
print(c)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
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))  # type: int
    M = int(next(tokens))  # type: int
    C = int(next(tokens))  # type: int
    B = [int(next(tokens)) for _ in range(M)]  # type: "List[int]"
    A = [[int(next(tokens)) for _ in range(M)] for _ in range(N)]  # type: "List[List[int]]"
    solve(N, M, C, B, A)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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()))
#print(a,b,c)
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)
    #print(jj)
    if jj>0:
        ans+=1
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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]))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#print#!/usr/bin/env python3
#%% for atcoder uniittest use
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))
#%%code

#なお、任意の整数 M に対して M の −2 進数表現が一意に定まることが証明できます。
#2桁ごとに見るとよかった（もう実験したよ）
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)

#%%submit!
resolve()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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