Problem:
 Score : 200 points    Problem Statement We have N squares assigned the numbers 1,2,3,\ldots,N . Each square has an integer written on it, and the integer written on Square i is a_i .  How many squares i satisfy both of the following conditions?   The assigned number, i , is odd.  The written integer is odd.       Constraints  All values in input are integers.  1 \leq N, a_i \leq 100         Input Input is given from Standard Input in the following format:  N  a_1  a_2  \cdots  a_N       Output Print the number of squares that satisfy both of the conditions.        Sample Input 1 5
1 3 4 5 7      Sample Output 1 2   Two squares, Square 1 and 5 , satisfy both of the conditions.  For Square 2 and 4 , the assigned numbers are not odd.  For Square 3 , the written integer is not odd.        Sample Input 2 15
13 76 46 15 50 98 93 77 31 43 84 90 6 24 14      Sample Output 2 3

Solution (Python):
def resolve():
    N = int(input())
    A = [int(i) for i in input().split()]
    cnt = 0
    for a in A[::2]:
        if a % 2 == 1:
            cnt += 1
    print(cnt)

resolve()

Solution (Python):
n = int(input())
a = [int(x) for x in input().strip().split()]


res=0
for i in range(n):
    if i%2==0 and a[i]%2==1:
        res+=1

print(res)

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

counter = 0
for i in range(N):
    if i%2==0 and a[i]%2==1:
        counter += 1
print(counter)

Solution (Python):
n=int(input())

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

cnt=0

for i in range(n):
    if (i+1)%2!=0 and a[i]%2!=0:
        cnt+=1

print(cnt)

Solution (Python):
import sys 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(readline())
A = list(map(int,readline().split()))
ans = 0
for i in range(N):
    if i % 2 ==0 and A[i] % 2 ==1:
        ans += 1
print(ans)

Solution (Python):
N = int(input())
a = list(map(int, input().split()))
ans = 0

for i in range(N):
    if i % 2 == 0 and a[i] % 2 == 1:
        ans += 1
print(ans)

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

cnt = 0
for i in range(n):
    if l[i] % 2 == 1 and i % 2 == 0:
        cnt += 1
print(cnt)

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

count = 0
for i, a in enumerate(vs):
    if (i+1) % 2 == 0:
        continue

    if a % 2 == 1:
        count += 1
print(count)

Solution (Python):
n = int(input())
l = list(map(int,input().split()))
cnt = 0
for i in range(n):
    if (i+1)%2==1 and l[i] %2 == 1:
        cnt += 1
print(cnt)

Solution (Python):
N = int(input())
A = [0] + list(map(int, input().split()))
cnt = 0
for i in range(1, N+1):
    if i%2 == 1 and A[i]%2 == 1:
        cnt += 1
print(cnt)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
def Main(N, A):
    ans = 0
    for i in range(0, N, 2):
        if A[i] % 2 != 0:
            ans += 1
    return ans
        
    
res = Main(N, A)
print(res)

Solution (Python):
n=int(input())
b=0
a=list(map(int,input().split()))
for i in range(n):
    if a[i]%2==1 and (i+1)%2==1:
        b+=1
print(b)

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

ans=0

for a in range(0,N,2):
  if A[a]%2==1:
    ans+=1
    
print(ans)

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




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

n=int(input())
cnt=0
a=list(map(int, input().split()))
for i in range(0,n,2):
    if a[i]%2==1:
        cnt+=1
print(cnt)

Solution (Python):
def resolve():
    N = int(input())
    A = list(map(int,input().split()))
    count = 0
    for i in range(N):
        if i % 2 == 0 and A[i]%2==1:
            count+=1
    print(count)
resolve()

Solution (Python):
from sys import exit
import math
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

n=ii()
a=li()

cnt=0
for i in range(n):
    if(i%2==0 and a[i]%2==1):
        cnt+=1
print(cnt)

Solution (Python):

import sys
import numpy as np
input = sys.stdin.readline

 
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))

n = I()
mylist = LI()
result = 0
for i, num in enumerate(mylist):
    if i % 2 == 0 and num % 2 == 1:
        result+=1
print(result)

Solution (Python):
n = int(input())
A = list(map(int, input().split()))
ans = 0
for i in range(n):
    if i % 2 == 0 and A[i] % 2 == 1:
        ans += 1

print(ans)

Solution (Python):
N=int(input())
a=list(map(int,input().split()))
ans=0
for i in range(0,N,2):
    if a[i]%2==1:
        ans+=1
print(ans)

Solution (Python):
N = int(input())

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

count = 0
for i, a in enumerate(A):
  if i % 2 == 0 and a % 2 == 1:
    count += 1

print(count)

Solution (Python):
import sys
sys.setrecursionlimit(700000)

def s_in():
    return input()

def n_in():
    return int(input())

def l_in():
    return list(map(int, input().split()))

n = n_in()
A = l_in()

print(sum(A[i]%2 ==1 for i in range(0,n,2)))

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
ans=0
for i in range(n):
    ans+=(i%2==0 and a[i]%2==1)
print(ans)

Solution (Python):
N = int(input())
A = [0] + list(map(int, input().split()))

ans = 0
for i in range(1, len(A), 2):
    if A[i] % 2 == 1:
        ans += 1
print(ans)

Solution (Python):
import sys

n = int(input())
a = [int(x) for x in input().split()]

ans = 0
for i in range(0, n,2):
    if a[i] % 2 == 1:
        ans += 1

print(ans)

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

ans = 0
for i, a in enumerate(A):
    if i % 2 == 0 and a % 2 == 1:
        ans += 1
print(ans)

Solution (Python):

def main():
    N = int(input())
    lst = [0] + list(map(int,input().split()))
    counter = 0
    for i in range(1,N+1):
        if i % 2 == 1:
            if lst[i] % 2 == 1:
                counter += 1

    print(counter)



if __name__ == '__main__':
    main()

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

ans = 0
for i in range(N):
    num = i + 1
    if num % 2 == 1 and A[i] % 2 == 1:
        ans += 1

print(ans)

Solution (Python):
N = int(input())
a = list(map(int, input().split()))
num = 0
for i in range(N):
  if (i+1) % 2 == 1 and a[i] % 2 == 1:
    num += 1
print(num)

Solution (Python):


N = int(input())
A = list(map(int,input().split()))

count = 0

for i in range(1,N+1):
    if i%2 == 1 and A[i-1]%2 == 1:
        count += 1

print(count)

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

count = 0
for i in range(N):
    if (i + 1) % 2 == 1 and a[i] % 2 == 1:
        count += 1
print(count)

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
res = 0
for i, j in enumerate(a):
    if i % 2 == 0 and j % 2 == 1:
        res += 1
print(res)

Solution (Python):



def solve(*args: str) -> str:
    n = int(args[0])
    A = list(map(int, args[1].split()))

    count = 0
    for i in range(0, n, 2):
        if A[i] % 2 != 0:
            count += 1

    return str(count)


if __name__ == "__main__":
    print(solve(*(open(0).read().splitlines())))

Solution (Python):

import sys

sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read


sys.setrecursionlimit(10**7)









def run():
    N, *A = map(int, read().split())
    ans = 0
    for i in range(0, N, 2):
        if A[i] % 2:
            ans += 1

    print(ans)



if __name__ == "__main__":
    run()

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
a=a[::2]
ans=0
for i in range(len(a)):
  if a[i]%2==1:
    ans+=1
print(ans)

Solution (Python):
n = int(input())
count = 0
line = list(map(int, input().split()))
for i in range(n):
  if i % 2 == 0:
    if line[i] % 2 != 0:
      count += 1
print(count)

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

count = 0
for i in range(n):
    if(i%2 == 0 and a[i]%2 == 1):
        count += 1
print(count)

Solution (Python):
n=int(input())
l=list(map(int,input().split()))
print(sum(1 for i in range(n) if i%2==0 and l[i]%2==1))

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

def solve():
    N = int(readline())
    A = list(map(int, readline().split()))

    ans = 0
    for i, a in enumerate(A):
        if (i + 1) % 2 == 1 and a % 2 == 1:
            ans += 1
    
    print(ans)


solve()

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
count = 0
for i, v in enumerate(a):
    if (i+1)%2 == 1 and v%2 == 1:
        count += 1
print(count)

Solution (Python):
N=int(input())
a=list(map(int, input().split()))
ans = 0
for i in range(N):
  if i%2==0 and a[i]%2==1:
    ans += 1
print(ans)

Solution (Python):
N = int(input())
a = list(map(int, input().split()))
count = 0
for i in range(len(a)):
    if a[i] % 2 == 1 and (i + 1) % 2 == 1:
        count += 1

print(count)

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

def main():
    N = int(readline())
    A = list(map(int, readline().split()))

    ans = 0
    for i in range(0,N,2):
        if A[i]%2==1:
            ans += 1

    print(ans)
if __name__ == '__main__':
    main()

Solution (Python):

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

cnt = 0
for i, a in enumerate(A):
    if i % 2 == 0 and a%2 == 1:
        cnt +=1
print(cnt)

Solution (Python):
def main():
    n = int(input())
    A = list(map(int,input().split()))
    cnt = 0

    for i,a in enumerate(A):
        if (i+1)%2 == 1 and a%2 == 1:
            cnt += 1


    print(cnt)

main()

Solution (Python):
n = int(input())
arr = list(map(int, input().split()))
answer = 0
for i in range(0, n, 2):
    if arr[i] & 1:
        answer += 1
print(answer)

Solution (Python):
N = int(input())
A= list(map(int,input().split()))
ans = 0
for i,a in enumerate(A):
  if (i+1)%2 == 1 and a%2==1:
    ans += 1

print(ans)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
ans = 0
for i in range(N):
    if (i+1)%2 == 1 and A[i]%2 == 1:
        ans += 1
print(ans)

Solution (Python):
n = int(input())
a = [int(_) for _ in input().split()]
ans = 0
for i in range(n):
    if (i+1) % 2 == 1:
        if a[i] % 2 == 1:
            ans += 1
print(ans)

Solution (Python):
import sys
from collections import defaultdict, deque, Counter
import math


from bisect import bisect_left, bisect_right





input = sys.stdin.readline

getS = lambda: input().strip()
getN = lambda: int(input())
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]

INF = 10 ** 20
MOD = 10**9 + 7
divide = lambda x: pow(x, MOD-2, MOD)

def era(n):
    ret = [1 for i in range(n + 2)]
    for i in range(2, int(math.sqrt(n) +3)):
        if ret[i] != 0:
            for j in range(2, n//i + 1):
                ret[i * j] = 0
    rret = []
    for i, r in enumerate(ret):
        if r == 1 and i != 0:
            rret.append(i)

    return rret


def houjyo(n, m, k, kaijyo):
    
    
    if k == n:
        return 1
    else:
        
        ret = nck(n,k,kaijyo) * npk(m-k, n-k, kaijyo) 
        
        return ret % MOD


def nck(n, k, kaijyo):
    return (npk(n, k, kaijyo) * divide(kaijyo[k])) % MOD


def npk(n, k, kaijyo):
    if k == 0 or k == n:
        return n % MOD
    return (kaijyo[n] * divide(kaijyo[n-k])) % MOD


def kaijyo(n):
    ret = [1]
    for i in range(1, n + 1):
        ret.append((ret[-1] * i)% MOD)
    return ret


def solve():
    n = getN()
    nums = getList()
    ans = 0
    for i,num in enumerate(nums):
        if i % 2 == 0 and num % 2 == 1:
            ans += 1

    print(ans)



def main():
    n = getN()
    for _ in range(n):
        solve()


if __name__ == "__main__":
    
    solve()

Solution (Python):
def main():
    N = int(input())
    A = list(map(int, input().split()))
    ans = 0
    for i in range(N):
        if (i + 1) % 2 == 1 and A[i] % 2 == 1:
            ans += 1

    print(ans)



if __name__ == "__main__":
    main()

Solution (Python):
import numpy as np
import math
import scipy as sp
import queue
import collections

MOD = 10 ** 9 + 7
INF = 10 ** 9

def main(kwargs):
    n = kwargs["n"]
    A = kwargs["A"]
    res = 0

    for i, a in enumerate(A):
        if (i + 1) * A[i] % 2 == 1:
            res += 1

    return res

if __name__ == "__main__":
    kwargs = {}

    cin = input().split()
    kwargs["n"] = [int(i) for i in cin][0]
    cin = input().split()
    kwargs["A"] = [int(i) for i in cin]

    cout = main(kwargs)
    print(cout)

Solution (Python):
n = int(input())
arr = [int(j) for j in input().split()]
count = 0
for i in range(1, n+1):
  if i%2 == 1 and arr[i-1]%2 == 1:
    count += 1
print(count)

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

ans = 0
for i, ai in enumerate(a):
    i += 1
    if i % 2 == 1 and ai % 2 == 1:
        ans += 1
print(ans)

Solution (Python):
n, *A = map(int, open(0).read().split())
print(len([a for i, a in enumerate(A, 1) if i%2 == a%2 == 1]))

Solution (Python):
import sys

def input():
    return sys.stdin.readline()[:-1]

n = int(input())
a_li = list(map(int, input().split()))

print(len([x for x in a_li[::2] if x%2==1]))

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

x = sum(1 if i % 2 == 1 and a % 2 == 1 else 0 for i, a in enumerate(an, 1))
print(x)

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

ans = 0
for i in range(n):
    if (i + 1) % 2 == 1 and a[i] % 2 == 1:
        ans += 1

print(ans)

Solution (Python):

import sys


def solve(N: int, a: "List[int]"):
    ans = 0
    for aa in a[::2]:
        if aa % 2 == 1:
            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))  
    a = [int(next(tokens)) for _ in range(N)]  
    print(solve(N, a))

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

if __name__ == '__main__':
    
    main()

Solution (Python):
n=int(input())
A=[int(i) for i in input().split()]

ans=0
for i in range(0,n,2):
    if A[i]%2==1:
        ans+=1

print(ans)

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

total = 0
for i, a in enumerate(A):
  if a % 2 == 1 and (i + 1) % 2 == 1:
    total += 1
    
print(total)

Solution (Python):
import sys
import math
import bisect

def main():
    n = int(input())
    A = list(map(int, input().split()))
    ans = 0
    for i in range(n):
        if i % 2 == 0 and A[i] % 2 == 1:
            ans += 1
    print(ans)

if __name__ == "__main__":
    main()

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
ans = 0
for i in range(n):
  if i%2 == 0 and a[i]%2 == 1:
    ans += 1
print(ans)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
ans = 0
for i in range(0, n, 2):
    if a[i] % 2 != 0:
        ans += 1
print(ans)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
ans = 0
for i in range(n):
      if i % 2 == 0 and a[i] % 2 == 1:
            ans += 1
print(ans)

Solution (Python):
N = int(input())


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


count= 0

for i in range(N):
    if (i+1) %2 ==1:
        if a[i] %2 == 1:
            count += 1


print(count)

Solution (Python):
import sys, io, os, re
from bisect import bisect, bisect_left, bisect_right, insort, insort_left, insort_right
from pprint import pprint
from math import sin, cos, pi, radians, sqrt, floor, ceil
from copy import copy, deepcopy
from collections import deque
from fractions import gcd
from functools import reduce
from itertools import groupby
from heapq import heapify, heappush, heappop



n1 = lambda: int(sys.stdin.readline().strip())
nn = lambda: list(map(int, sys.stdin.readline().strip().split()))
f1 = lambda: float(sys.stdin.readline().strip())
fn = lambda: list(map(float, sys.stdin.readline().strip().split()))
s1 = lambda: sys.stdin.readline().strip()
sn = lambda: list(sys.stdin.readline().strip().split())
nl = lambda n: [n1() for _ in range(n)]
fl = lambda n: [f1() for _ in range(n)]
sl = lambda n: [s1() for _ in range(n)]
nm = lambda n: [nn() for _ in range(n)]
fm = lambda n: [fn() for _ in range(n)]
sm = lambda n: [sn() for _ in range(n)]

def array1(n, d=0): return [d] * n
def array2(n, m, d=0): return [[d] * m for x in range(n)]
def array3(n, m, l, d=0): return [[[d] * l for y in xrange(m)] for x in xrange(n)]
def linc(A, d=1): return map(lambda x: x + d, A)
def ldec(A, d=1): return map(lambda x: x - d, A)

N = n1()
a = nn()

ans = 0
for i in range(N):
    if i % 2 == 0 and a[i] % 2 == 1:
        ans += 1

print(ans)

Solution (Python):
def main():
    N = input()
    A = list(map(int, input().split()))
    cnt = 0
    for i in range(len(A)):
        if (i+1) % 2 != 0:
            if A[i] % 2 != 0:
                cnt += 1
    print(cnt)


if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
A = list(map(int,input().split()))
ans = 0
for i in range(0,n,2):
  if A[i] % 2 == 1:
    ans +=1
print(ans)

Solution (Python):

def submit():
    n = int(input())
    a = list(map(int, input().split()))

    cnt = 0
    for i in range(1, n + 1):
        if i % 2:
            if a[i - 1] % 2:
                cnt += 1

    print(cnt)


submit()

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
ans=0
for i in range(n):
  if (i+1)%2==1 and a[i]%2==1:
    ans+=1
print(ans)

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

ans=0
for i in range(n):
    if i%2==0 and a[i]%2==1:
        ans+=1
print(ans)

Solution (Python):
N = int(input())
a = list(map(int,input().split()))
res = 0
for i,v in enumerate(a,1):
    if i % 2 and v % 2:
        res += 1
print(res)

Solution (Python):
import sys
sys.setrecursionlimit(10**6)

n = int(input())
A = list(map(int, input().split()))









ID = [i for i in range(1,n+1)]

ans = 0

for i,a in zip(ID, A):
    if i%2 == 1 and a%2 == 1:
        ans += 1
        
print(ans)

Solution (Python):









def solve():
    N = int(input())
    As = list(map(int, input().split()))

    count = 0
    for i, a in enumerate(As):
        if (i+1) % 2 == 0:
            continue
        if a % 2 == 0:
            continue

        count += 1

    return count


def main():
    print(solve())


if __name__ == "__main__":
    main()

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

ans = 0

for i in range(n):
  if (i+1)%2 == 1 and a[i]%2 == 1:
    ans += 1
print(ans)

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
ans=0
for i in range(0,n,2):
    if a[i]%2==1:
        ans+=1

print(ans)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
ans = 0
for i, a in enumerate(A, start=1):
    if i % 2 == 1 and a % 2 == 1:
        ans += 1
print(ans)

Solution (Python):
N=int(input())
a=list(map(int,input().split()))
ans=0
for i in range(N):
    if (i+1)%2==1 and a[i]%2==1:ans+=1
print(ans)

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
ans = 0

for n in range(N):
  if n%2==0 and A[n]%2==1:
    ans+=1

print(ans)

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

count = 0

for i in range(n):
    if (i + 1) % 2 == 1 and a[i] % 2 == 1:
        count += 1

print(count)

Solution (Python):
N = map(int, input().split())
A = list(map(int, input().split()))
ans = 0
for i, a in enumerate(A):
    ans += (i+1)%2==1 and a%2==1
print(ans)

Solution (Python):
N=int(input())
a=list(map(int,input().split()))
ans=0
for i in range(N):
    if i%2==0:
        if a[i]%2==1:
            ans+=1
print(ans)

Solution (Python):
import sys
import bisect
import itertools
import collections
import fractions
import heapq
import math
from operator import mul
from functools import reduce
from functools import lru_cache


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7

    N = int(input())
    A = list(map(int, input().split()))
    ans = 0
    for i, a in enumerate(A):
        i += 1
        if i % 2 != 0 and a % 2 != 0:
            ans += 1
    print(ans)



if __name__ == '__main__':
    solve()

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

cnt = 0
for i, a in enumerate(a_list, 1):
    if i%2==1 and a%2==1:
        cnt += 1
print(cnt)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
cnt = 0
for i in range(0, n, 2):
    if a[i]%2 == 1:
        cnt += 1
print(cnt)

Solution (Python):
N= int(input())
l=list(map(int,input().split()))
ans=0
for i in range(N):
   if i%2==0 and l[i]%2==1:
      ans+=1
print(ans)

Solution (Python):
import sys, re
from math import ceil, floor, sqrt, pi, factorial, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left, bisect_right
from functools import reduce
from decimal import Decimal, getcontext

def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
MOD = 10 ** 9 + 7
num_list = []
str_list = []

def main():
    n = i_input()
    num_list = i_list()

    count = 0

    for i in range(1,n+1):
        if i % 2 == 0:
            continue
        if num_list[i-1] % 2 == 0:
            continue
        count += 1

    print(count)

if __name__ == '__main__':
    main()

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
count=0
for i in range(n):
    if i%2==0 and a[i]%2!=0:
        count+=1

print(count)

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
ans=0
for i in range(n):
    if i%2==0 and a[i]%2==1:
        ans+=1
print(ans)

Solution (Python):
"""
// Author : snape_here - Susanta Mukherjee
     
 """
 
from __future__ import division, print_function
 
import os,sys
from io import BytesIO, IOBase
 
if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
 
def ii(): return int(input())
def fi(): return float(input())
def si(): return input()
def msi(): return map(str,input().split())
def mi(): return map(int,input().split())
def li(): return list(mi())
 
 
def read():
    sys.stdin = open('input.txt', 'r')  
    sys.stdout = open('output.txt', 'w') 
 
def gcd(x, y):
    while y:
        x, y = y, x % y
    return x

mod=1000000007

from math import log,sqrt,factorial,cos,tan,sin,radians,ceil,floor

import bisect

from decimal import *

getcontext().prec = 25

abc="abcdefghijklmnopqrstuvwxyz"

pi=3.141592653589793238


def main():

    n=ii()
    a=li()
    ans=0 
    for i in range(n):
        if i%2==0 and a[i]%2:
            ans+=1 
    print(ans)



 
BUFSIZE = 8192
 
 
class FastIO(IOBase):
    newlines = 0
 
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
 
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
 
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
 
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
 
 
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
 
 
def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()
 
 
if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
 
input = lambda: sys.stdin.readline().rstrip("\r\n")
 

 
 
if __name__ == "__main__":
    
    main()

Solution (Python):

N = int(input())
A = list(map(int, input().split()))
cnt = 0
for i in range(0,N,2):
    if A[i]%2==1:
        cnt +=1
print(cnt)

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

res = 0
for i in range(N):
    if i % 2 == 0 and a[i] % 2 == 1:
        res += 1
print(res)

Solution (Python):
n = int(input())
A = list(map(int, input().split()))
cnt = 0
i = 1
for a in A:
    if i % 2 == 1 and a % 2 == 1:
        cnt += 1
    i += 1

print(cnt)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
ans = 0
for i, x in enumerate(A, start=1):
    
    if i % 2 == 1 and x % 2 == 1:
        ans += 1
print(ans)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
cnt = 0
for i in range(n):
    cnt += ( (i + 1) % 2 == 1 and a[i] % 2 == 1 )
print(cnt)

Solution (Python):
import sys
import time
import math
def inpl():
    return list(map(int, input().split()))
st = time.perf_counter()


N = int(input())
a = inpl()
ans = 0
for i in range(0, N, 2):
	if a[i]%2==1:
		ans+=1
print(ans)



ed = time.perf_counter()
print('time:', ed-st, file=sys.stderr)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
ans = 0

for i in range(1, N + 1, 2):
    if A[i - 1] % 2:
        ans += 1
print(ans)

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

cnt=0

for i in range(n):
    if i % 2==0 and a[i]%2==1:
        cnt+=1

print(cnt)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
ans = 0
for i in range(N):
  if((i+1)%2==1 and A[i]%2==1):
    ans += 1
print(ans)

Solution (Python):
import math  
from collections import deque  
from typing import Deque, Dict, List, Optional, Tuple, Union  


def main(N: int, A: List[int]):
    print(sum([a % 2 == 1 for a in A[::2]]))


if __name__ == "__main__":
    N = int(input())
    A = list(map(int, input().split()))
    main(N, A)

Solution (Python):
def main():
    N = int(input())
    A = list(map(int, input().split()))
    cnt = 0
    for i in range(N):
        if i%2==0 and A[i]%2==1:
            cnt += 1

    print(cnt)



if __name__ == '__main__':
    main()

Solution (Python):
import sys
import itertools

import time
import math
import heapq
from collections import defaultdict
sys.setrecursionlimit(10 ** 7)
 
INF = 10 ** 9 + 7
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines



N = int(input())
A = list(map(int, input().split()))
ans = 0
for i,a in enumerate(A):
    if (i + 1) % 2 == 1 and a % 2 == 1:
        ans += 1
print(ans)

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
k=0
for i in range((
    n+1)//2):
    k+=(a[2*i]%2==1)
print(k)

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
ans = 0
for i in range(1,n+1):
    if i % 2 == 1and a[i-1] % 2 == 1:
        ans += 1
print(ans)

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

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

DR = [1, -1, 0, 0]
DC = [0, 0, 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 main():
    n = I()
    A = LI()
    cnt = 0
    for i, a in enumerate(A):
        if (i+1) % 2 == 1 and a % 2 == 1:
            cnt += 1
    print(cnt)



main()

Solution (Python):
def main():
    n = int(input())
    a = list(map(int, input().split()))

    ret = 0
    for i in range(n):
        if i % 2 == 0 and a[i] % 2 == 1:
            ret += 1
    print(ret)

if __name__ == "__main__":
    main()

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

count = 0
for i in range(N):
    if i % 2 == 0:
        if a[i] % 2 != 0:
            count += 1

print(count)

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

N=int(input())

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

count=0
for i in range(N):
    if (i+1)%2!=0 and T[i]%2!=0:
       count+=1
print(count)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
ans=0
for i in range(n):
  if i%2==0 and a[i]%2==1:
    ans+=1
print(ans)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
ans = 0
for i in range(n):
    if i % 2 == 0 and a[i] % 2 == 1:
        ans += 1
print(ans)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
result = 0
for i in range(n):
	if i % 2 == 0 and a[i] % 2 == 1:
		result += 1

print(result)

Solution (Python):
n = int(input())

a = [int(x) for x in input().split()]

count = 0

for i in range(n):
    if i%2 == 0 and a[i]%2 == 1:
        count += 1

print(count)

Solution (Python):
n=int(input())

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

c=0

for i in l[0::2]:
    if i%2==1:
        c+=1

print(c)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
ans = 0
for i in range(n):
    if (i + 1) % 2 == 1 and a[i] % 2 == 1:
        ans += 1
print(ans)

Solution (Python):
N=int(input())
A=list(map(int,input().split()))
count=0
for i in range(0,N,2):
    if i%2==0 and A[i]%2==1:
        count+=1
print(count)

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

count = 0
for i in range(n):
  if (i+1) % 2 == 1 and a[i] % 2 == 1:
    count += 1
    
print(count)

Solution (Python):
n = int(input())
a = [int(i) for i in input().split()]
cnt = 0
for i in range(n):
  if i % 2 == 0 and a[i] % 2 == 1:
    cnt += 1
print(cnt)

Solution (Python):
N = int(input())

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

result = 0

for i in range(N):
    if (i+1)%2 ==1 and a[i]%2 ==1:
        result +=1

print(result)

Solution (Python):


N = int(input())
a = list(map(int, input().split()))

count = 0
for i in range(0,N,2):
  if a[i]%2==1:
    count+= 1
    
print(count)

Solution (Python):
N = int(input())
a = [int(s) for s in input().split()]

ans = 0
for i in range(len(a)):
    if (i + 1) % 2 == 1 and a[i] % 2 == 1:
        ans += 1
print(ans)