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):
N = int(input())
a = list(map(int, input().split()))
ans = 0
for i, v in enumerate(a):
    if (i+1)%2 and (v)%2:
        ans += 1
print(ans)

Solution (Python):

MOD = 10 ** 9 + 7
INFI = 10**10

import math
from collections import deque
import itertools
import heapq

from fractions import Fraction
import copy
from functools import lru_cache
from collections import defaultdict
import pprint




def sosuhante(n):
    for k in range(2, int(math.sqrt(n))+1):
        if n% k ==0:
            return False
    return True
def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def kingaku(a,b,n):
    keta=len(str(n))
    return a*n+b*keta

def my_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default




def ret(a):
    c=[None]*(len(a)-1)
    if len(a)==1:
        return a[0]
    elif len(a)==0:
        return 0
    for i in range(1,len(a)):
        c[i-1]=abs(a[i]-a[i-1])
    return ret(c)

def soinsubunkai(n):
    a = []
    i = 1
    while i*i <= n:
        if n % i == 0 and i!=1:
            a.append(i)
            n=n//i

        if n% i !=0 or i==1:
            i += 1
    nokori=[n]
    return a + nokori

def make_divisors(n):
    lower_divisors , upper_divisors = [], []
    i = 1
    while i*i <= n:
        if n % i == 0:
            lower_divisors.append(i)
            if i != n // i:
                upper_divisors.append(n//i)
        i += 1
    return lower_divisors + upper_divisors[::-1]

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

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





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 resolve():
    n = int(input())
    a = list(map(int, input().split()))
    ans = 0
    for i in a[0::2]:
        if i % 2 == 1:
            ans += 1
    print(ans)


if __name__ == '__main__':
    resolve()

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):
n=int(input())
a=list(map(int,input().split()))
ans=0
for i in range(0,n,2):
  if a[i]%2!=0:
    ans=ans+1
print(ans)

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

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

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

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

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

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

Solution (Python):
a=int(input())
b=list(map(int,input().split()))
ans=0
for i in range(a):
    if (i+1)%2==1 and b[i]%2==1:
        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 == 1:
        continue
    if A[i] % 2 == 1:
        cnt += 1

print(cnt)

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

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

print(ans)

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
    return ans

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

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

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

print(ans)

Solution (Python):
n = int(input())
alst = list(map(int, input().split()))
ans = 0
for i, num in enumerate(alst):
    if i % 2 == 0 and num % 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 = input()
li = list(map(int, input().split()))

cnt=0
for i, num in enumerate(li):
  if (i%2==0) & (num%2==1):
    cnt+=1
print(cnt)

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

Solution (Python):
N = int(input())
A = list(map(int, input().split()))[::2]
print(len([x for x in A if x%2==1]))

Solution (Python):





import math
import fractions
import sys
import bisect
import heapq  
import collections
from collections import Counter
from collections import deque
import pprint
import itertools

sr = lambda: input()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

"""nを素因数分解"""
"""2以上の整数n => [[素因数, 指数], ...]の2次元リスト"""


def factorization(n):
    arr = []
    temp = n
    if n == 1:
        return arr

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

    if temp != 1:
        arr.append([temp, 1])

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

    return arr



def power(a, n, mod):
    x = 1
    while n:
        if n & 1:
            x *= a % mod
        n >>= 1
        a *= a % mod
    return x % mod



def kaijo(n, l, mod):
    if n == 0:
        return 1
    a = n
    tmp = n - 1
    while (tmp >= l):
        a = a * tmp % mod
        tmp -= 1
    return a


class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())


def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    divisors.sort()
    return divisors


inf = 10 ** 18
mod = 10 ** 9 + 7

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

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

sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inm = lambda: map(int, sys.stdin.readline().split())
inl = lambda: list(inm())
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))

N = ini()
A = inl()


def solve():
    cnt = 0
    for i in range(N):
        if (i + 1) % 2 == 1 and A[i] % 2 == 1:
            cnt += 1

    return cnt


print(solve())

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

print(sum([i%2 == 0 and a%2 == 1 for i, a in enumerate(A)]))

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):
def solve():
    N = int(input())
    A = list(map(int,input().split()))

    ans = 0
    for i in range(N):
        if (i+1) % 2 != 0 and A[i] % 2 != 0:
            ans += 1
    
    print(ans)
if __name__ == '__main__':
    solve()

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())
count=0
A=list(map(int,input().split()))
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 = map(int,input().split())

ans = 0
for ix, v in enumerate(A):
    t = ix + 1
    if t & 1 and v & 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):
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

N = int(input())
As = list(mapint())

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

print(ans)

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

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

answer = 0
for i, el in enumerate(A):
    if not(i & 1) and el & 1:
        answer += 1
print(answer)

Solution (Python):
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

in_n = lambda: int(readline())
in_nn = lambda: map(int, readline().split())
in_s = lambda: readline().rstrip().decode('utf-8')
in_nl = lambda: list(map(int, readline().split()))
in_nl2 = lambda H: [in_nl() for _ in range(H)]
in_map = lambda: [s == ord('.') for s in readline() if s != ord('\n')]
in_map2 = lambda H: [in_map() for _ in range(H)]
in_all = lambda: map(int, read().split())


def main():

    N = in_n()
    A = in_nl()

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

    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
ni = lambda: int(input())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))

n=ni()
a=nl()
cnt=0
for i in range(n):
  if (i+1)%2==1 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%2 == 0 and a[i]%2==1:
        ans +=1
print(ans)

Solution (Python):
n,*a=map(int,open(0).read().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()))
cnt=0
for i,val in enumerate(a):
    if (i+1)%2==1 and val%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: ans -= -1
print(ans)

Solution (Python):
n = int(input())
aa = tuple(map(int, input().split()))

ans = 0
for i, a in enumerate(aa):
    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 and A[i]%2:
        ans+=1

print(ans)

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

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

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

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

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

print(ans)

Solution (Python):
import sys,queue,math,copy,itertools,bisect,collections,heapq

def main():
    sys.setrecursionlimit(10**7)
    INF = 10**18
    MOD = 10**9 + 7
    LI = lambda : [int(x) for x in sys.stdin.readline().split()]
    _LI = lambda : [-int(x) for x in sys.stdin.readline().split()]
    NI = lambda : int(sys.stdin.readline())
    SI = lambda : sys.stdin.readline().rstrip()
    DD = ((1,0),(0,1),(-1,0),(0,-1))

    N = NI()
    a = LI()

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

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

Solution (Python):
N,*a = map(int, open(0).read().split())
ans = 0
for i in range(N):
    if (i+1) % 2 == 1:
        if 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()))

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+1) % 2 == 1 and a % 2 == 1:
    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=cnt+1
print(cnt)

Solution (Python):
from math import gcd

from math import factorial as f

from math import ceil, floor, sqrt
import math

import bisect
import re
import heapq

from copy import deepcopy
import itertools
from itertools import permutations

from sys import exit

ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(map(int, input().split()))

yes = "Yes"
no = "No"


def main():
    n = ii()
    a = li()
    a.insert(0, 0)
    cnt = 0
    for i in range(1, n + 1):
        if i % 2 and a[i] % 2:
            cnt += 1
    print(cnt)


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()))
cnt=0
for i,a_ in enumerate(a):
    if i % 2 == 0 and a_ % 2 == 1:
        cnt+=1

print(cnt)

Solution (Python):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    n=INT()
    a=LIST()
    ct=0
    for i in range(n):
        if (i+1)%2==1 and a[i]%2==1:
            ct+=1
    print(ct)
if __name__ == '__main__':
    do()

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

Solution (Python):




import sys
from io import StringIO
import unittest

def yn(b):
    print("Yes" if b==1 else "No")
    return

def resolve():
    readline=sys.stdin.readline

    
    
    n=int(readline())
    arr=list(map(int, readline().rstrip().split()))
    ans=0
    for i in range(n):
        x=i+1
        if arr[i]%2==1 and x%2==1:
            ans+=1
    print(ans)
    
    

    return

if 'doTest' not in globals():
    resolve()
    sys.exit()

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):
n = int(input())
a = list(map(int, input().split()))

ans = 0

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

print(ans)

Solution (Python):

import sys
from collections import deque, Counter
from heapq import heappop, heappush
from bisect import bisect_right
from itertools import accumulate

sys.setrecursionlimit(10**6)
INF = 10**12
m = 10**9 + 7

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=input()
a=list(map(int, input().split()))

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

Solution (Python):








    






mod = int(1e9+7)

INF = 1<<50

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

def main():
    n = int(input())
    a = readInt()
    ans = 0
    for i in range(n):
        if i%2==0 and a[i]%2==1:
            ans += 1
    print(ans)
    return

if __name__=='__main__':
    main()

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

print(c)

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

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

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

Solution (Python):
import sys
import math
from collections import deque

sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(input())
NMI = lambda: map(int, input().split())
NLI = lambda: list(NMI())
SI = lambda: input()


def make_grid(h, w, num): return [[int(num)] * w for _ in range(h)]


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


if __name__ == "__main__":
    main()

Solution (Python):
n = int(input())
a = [int(i) for i in input().split()]
print(sum([ai % 2 for ai in a[::2]]))

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

count = 0
for i in range(len(listA)):
    if (i+1)%2 == 1 and listA[i]%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):
import sys, bisect, math, itertools, heapq, collections
from operator import itemgetter

from functools import lru_cache

sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
mod = 10**9 + 7
eps = 10**-7


def inp():
    '''
    一つの整数
    '''
    return int(input())


def inpl():
    '''
    一行に複数の整数
    '''
    return list(map(int, input().split()))


def str_inp():
    '''
    文字列をリストとして読み込む
    '''
    return list(input()[:-1])


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

Solution (Python):
ma = lambda :map(int,input().split())
ni = lambda:int(input())
import collections
import math
import itertools
gcd = math.gcd
n = ni()
A  = list(ma())
c = 0
for i in range(n):
    if i%2==0 and A[i] %2==1:
        c+=1
print(c)

Solution (Python):
def INT():
    return int(input())

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

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

N = INT()
a = LI()
ans = 0

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

print(ans)

Solution (Python):
n = int(input())
data = list(map(int, input().split()))
ans = 0
for idx, a in enumerate(data):
    idx += 1
    if idx%2 != 0 and a %2 != 0:
        ans += 1
print(ans)

Solution (Python):
import sys,bisect,string,math,time,functools,random,fractions
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
rep=range
def Golf():n,*t=map(int,open(0).read().split())
def I():return int(input())
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def MI():return map(int,input().split())
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def RA():return map(int,open(0).read().split())
def GI(V,E,ls=None,Directed=False,index=1):
    org_inp=[];g=[[] for i in R(V)]
    FromStdin=True if ls==None else False
    for i in R(E):
        if FromStdin:
            inp=LI()
            org_inp.append(inp)
        else:
            inp=ls[i]
        if len(inp)==2:
            a,b=inp;c=1
        else:
            a,b,c=inp
        if index==1:a-=1;b-=1
        aa=(a,c);bb=(b,c);g[a].append(bb)
        if not Directed:g[b].append(aa)
    return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'
    
    mp=[boundary]*(w+2);found={}
    for i in R(h):
        s=input()
        for char in search:
            if char in s:
                found[char]=((i+1)*(w+2)+s.index(char)+1)
                mp_def[char]=mp_def[replacement_of_found]
        mp+=[boundary]+[mp_def[j] for j in s]+[boundary]
    mp+=[boundary]*(w+2)
    return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def accum(ls):
    rt=[0]
    for i in ls:rt+=[rt[-1]+i]
    return rt
def bit_combination(n,base=2):
    rt=[]
    for tb in R(base**n):s=[tb//(base**bt)%base for bt in R(n)];rt+=[s]
    return rt
def gcd(x,y):
    if y==0:return x
    if x%y==0:return y
    while x%y!=0:x,y=y,x%y
    return y
def YN(x):print(['NO','YES'][x])
def Yn(x):print(['No','Yes'][x])
def show(*inp,end='\n'):
    if show_flg:print(*inp,end=end)

mo=10**9+7
inf=float('inf')
FourNb=[(-1,0),(1,0),(0,1),(0,-1)];EightNb=[(-1,0),(1,0),(0,1),(0,-1),(1,1),(-1,-1),(1,-1),(-1,1)];compas=dict(zip('WENS',FourNb));cursol=dict(zip('LRUD',FourNb))
l_alp=string.ascii_lowercase

read=sys.stdin.buffer.read;readline=sys.stdin.buffer.readline;input=lambda:sys.stdin.readline().rstrip()

show_flg=False
show_flg=True

ans=0

n=I()
a=LI()


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

Solution (Python):
n = int(input())
a = [int(i) for i 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())
a = list(map(int, input().split()))

ans = sum([1 if i % 2 == 0 and a[i] % 2 == 1 else 0 for i in range(n)])
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 i in range(0, N, 2):
    if a[i]%2:
        ans += 1
print(ans)

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

Solution (Python):
import sys
from operator import itemgetter

sys.setrecursionlimit(10**9)
input = sys.stdin.readline

def ii(): return int(input())
def mi(): return map(int, input().split())
def lmi(): return list(map(int, input().split()))
def iif(n): return [int(input()) for _ in range(n)]
def lmif(n): return [list(map(int, input().split())) for _ in range(n)]
def ss(): return input().split()

def main():
    mod = 1000000007
    
    n = ii()
    A = lmi()

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

    print(cnt)
    
    return

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 != 0:
        ans += 1

print(ans)

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

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

    print(ans)


if __name__ == "__main__":
    main()

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

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

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
from collections import defaultdict
from heapq import heappop, heappush
import itertools
import random
from collections import deque
from decimal import *
import queue

input = sys.stdin.readline

def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]

inf = float('inf')
mod = 1000000007




def main():
	N = inputInt()
	A = inputList()

	ans = 0
	for i,val in enumerate(A):
		ii = i+1
		if ii % 2 == 1:
			if val % 2 == 1:
				ans += 1

	print(ans)




if __name__ == "__main__":
	main()

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

Solution (Python):

import sys


def solve(N: int, a: "List[int]"):
    count = 0
    for i in range(N):
        if (i+1)%2 == 1 and a[i]%2 == 1:
            count += 1
    print(count)
    return



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)]  
    solve(N, a)

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):
def main():
    N = int(input())
    A = list(map(int, input().split(' ')))
    ans = 0
    for i, a in enumerate(A):
        if (i + 1) % 2 == a % 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(0,N,2):
    if A[i]%2==1:
        ans+=1
print(ans)

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

print(c)

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

Solution (Python):
import sys
sys.setrecursionlimit(10**8)
stdin = sys.stdin


def ni(): return int(ns())


def na(): return list(map(int, stdin.readline().split()))


def naa(N): return [na() for _ in range(N)]


def ns(): return stdin.readline().rstrip()  


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


print(ans)

Solution (Python):
N = int(input())
*a, = 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(N):
    if i % 2 == 0 and a[i] % 2 == 1:
        count += 1
        
print(count)

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

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

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

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

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

print(ans)

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

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

Solution (Python):




import sys
import heapq, functools, collections
import random
from collections import Counter, defaultdict





k = int(input())





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

res = 0
for i,x in enumerate(lst, start=1):
    if x%2 == 1 and i%2 == 1:
        res += 1

print(res)

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

ans = 0
for i,a in enumerate(A,1):
    if i%2==1 and a%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=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())
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()))
ans=0
for i in range(0,len(a)):
  if i%2==0 and a[i]%2==1:
    ans+=1
print(ans)

Solution (Python):
import bisect
import copy
import heapq
import math
import sys
from collections import *
from functools import lru_cache
from itertools import accumulate, combinations, permutations, product
def input():
    return sys.stdin.readline()[:-1]
def ruiseki(lst):
    return [0]+list(accumulate(lst))
sys.setrecursionlimit(500000)
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]

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()))
cnt = 0
for i in range(1,N+1):
    a = A[i-1]
    if i%2==1 and a%2==1:
        cnt += 1
print(cnt)

Solution (Python):
import sys
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(rs())
def rs_(): return [_ for _ in rs().split()]
def ri_(): return [int(_) for _ in rs().split()]

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