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 in range(N):
    if (i + 1) % 2 == 1 and A[i] % 2 == 1:
        ans += 1

print(ans)

Solution (Python):



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

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

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


if __name__ == '__main__':
    main()

Solution (Python):



import sys
from collections import defaultdict, deque
from heapq import heappush, heappop
import math
import bisect
input = sys.stdin.readline




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

ans = 0
for idx, a in enumerate(A):
    idx += 1
    if idx % 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):


LI = lambda: list(map(int, input().split()))


N = int(input())
A = LI()


def main():
    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 = list(map(int, input().split(' ')))
ans = 0
for n, i in enumerate(A, 1):
    if i % 2 == n % 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 = tuple(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):
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate, product, combinations_with_replacement
import sys
import bisect
import string
import math
import time


def I(): return int(input())
def S(): return input()
def MI(): return map(int, input().split())
def MS(): return map(str, input().split())
def LI(): return [int(i) for i in input().split()]
def LI_(): return [int(i)-1 for i in input().split()]
def StoI(): return [ord(i)-97 for i in input()]
def ItoS(nn): return chr(nn+97)
def input(): return sys.stdin.readline().rstrip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def print_matrix(mat):
    for i in range(len(mat)):
        print(*['IINF' if v == IINF else "{:0=4}".format(v) for v in mat[i]])


yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**19
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
show_flg = False



def main():
    N = I()
    a = LI()
    ans = 0

    for i in range(1, len(a)+1):
        v = a[i-1]

        if i % 2 == 1 and v % 2 == 1:
            ans += 1

    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
def examA():
    L, R, D = LI()
    ans = R//D - (L-1)//D
    print(ans)
    return

def examB():
    N = I()
    A = LI()
    ans = 0
    for i,a in enumerate(A):
        if i%2==0:
            if a%2==1:
                ans += 1
    print(ans)
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    ans = 0
    print(ans)
    return

def examF():
    ans = 0
    print(ans)
    return

from decimal import getcontext,Decimal as dec
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(input())
def LI(): return list(map(int,sys.stdin.readline().split()))
def DI(): return dec(input())
def LDI(): return list(map(dec,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = dec("0.000000000001")
alphabet = [chr(ord('a') + i) for i in range(26)]
alphabet_convert = {chr(ord('a') + i): i for i in range(26)}

getcontext().prec = 28

sys.setrecursionlimit(2*10**6)

if __name__ == '__main__':
    examB()

"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
"""

Solution (Python):
import sys

N = int(input())
A = list(map(int, sys.stdin.readline().rsplit()))

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

Solution (Python):


'''
Author: andyli
Time: 2020-07-11 19:58:52
'''

import os
from io import BytesIO, IOBase
import sys


def main():
    n = int(input())
    a = list(map(int,input().split()))
    ans=0
    for i in range(1,n+1):
        if (i&1) and (a[i-1]&1):
            ans += 1
    print(ans)
    return



BUFSIZE = 1048576


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


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def input(): return sys.stdin.readline().rstrip('\r\n')




if __name__ == '__main__':
    main()

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

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

Solution (Python):
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()))
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, e in enumerate(a, 1):
    if i % 2 and e % 2:
        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(n):
    if (i+1)%2 == 1 and a[i]%2 == 1:
        ans += 1
print(ans)

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


main()

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

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

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())
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 math
import time
from collections import defaultdict, deque
from sys import stdin, stdout
from bisect import bisect_left, bisect_right
n=int(input())
a=list(map(int,stdin.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, = 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 = sum([a % 2 == 1 for a in A[::2]])
print(ans)

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

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

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

print(cnt)

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

def int1(x): return int(x) - 1
def II(): return int(input())
def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(input())
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print(k.join(list(map(str, lst))))
INF = float('inf')







def solve():
    N = II()
    A = LI()

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

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

readline = sys.stdin.buffer.readline
def readstr():return readline().rstrip().decode()
def readstrs():return list(readline().decode().split())
def readint():return int(readline())
def readints():return list(map(int,readline().split()))
def printrows(x):print('\n'.join(map(str,x)))
def printline(x):print(' '.join(map(str,x)))

n = readint()
a = readints()


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

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

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

Solution (Python):
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, = 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):
N = int(input())
A = list(map(int, input().split()))
res = 0
for a in A[::2]:
    if a % 2:
        res += 1
print(res)

Solution (Python):
import sys
import heapq
import math
import fractions
import bisect
import itertools
from collections import Counter
from collections import deque
from operator import itemgetter
def input(): return sys.stdin.readline().strip()
def mp(): return map(int,input().split())
def lmp(): return list(map(int,input().split()))

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

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

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

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

import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from collections import deque
from functools import lru_cache
import bisect
import re
import queue
import copy
import decimal


class Scanner():
    @staticmethod
    def int():
        return int(sys.stdin.readline().rstrip())

    @staticmethod
    def string():
        return sys.stdin.readline().rstrip()

    @staticmethod
    def map_int():
        return [int(x) for x in Scanner.string().split()]

    @staticmethod
    def string_list(n):
        return [Scanner.string() for i in range(n)]

    @staticmethod
    def int_list_list(n):
        return [Scanner.map_int() for i in range(n)]

    @staticmethod
    def int_cols_list(n):
        return [Scanner.int() for i in range(n)]


def pop_count(x):
    x = x - ((x >> 1) & 0x5555555555555555)
    x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
    x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
    x = x + (x >> 8)
    x = x + (x >> 16)
    x = x + (x >> 32)
    return x & 0x0000007f


def solve():
    N = Scanner.int()
    A = Scanner.map_int()
    ans = 0
    for i in range(N):
        if (i + 1) % 2 == 1 and A[i] % 2 == 1:
            ans += 1

    print(ans)


def main():
    
    
    
    
    
    
    solve()


if __name__ == "__main__":
    main()

Solution (Python):


import sys

class BAnOddProblem:
    def solve(self, tc=0):
        n = int(input())
        a = [int(_) for _ in input().split()]
        ans = 0
        for i, x in enumerate(a):
            i += 1
            ans += (i % 2) and (a[i - 1] % 2)

        print(ans)

solver = BAnOddProblem()
input = sys.stdin.readline

solver.solve()

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

Solution (Python):

import sys
input = sys.stdin.readline

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

Solution (Python):

import sys


def solve(N: int, a: "List[int]"):
    ans = 0
    for i, ai in enumerate(a):
        if (i%2 == 0) and (ai % 2 ==1): ans+=1
    print(ans)
    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(0, n, 2):
    if 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 in range(0, n, 2):
        if a[i] % 2 == 1:
            ans += 1

    print(ans)

if __name__ == '__main__':
    main()

Solution (Python):
from sys import stdin
from sys import setrecursionlimit
setrecursionlimit(10 ** 7)

n = int(stdin.readline().rstrip())
a = list(map(int,stdin.readline().rstrip().split()))

point = 0

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

print(point)

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

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

print(ans)

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

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

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

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

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

Solution (Python):
def main():
    N = int(input())
    A = list(map(int, input().split()))
    count = 0
    for i, a in enumerate(A, 1):
        if i % 2 * a % 2:
            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(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 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()))
cnt = 0
for i in range(N):
    if i % 2 == 0 and a[i] % 2 != 0:
        cnt += 1
print(cnt)

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

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

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

sys.setrecursionlimit(1000000)

import bisect
import math
import collections
import heapq


def solve(N, As):
    c = 0
    for i in range(N):
        if (i + 1) % 2 == 1 and As[i] % 2 == 1:
            c += 1
    return c


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

    print(solve(N, As))

Solution (Python):
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, a in enumerate(A):
    if (i+1)%2 == 1 and a%2 == 1:
        ans += 1
print(ans)

Solution (Python):




import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi,factorial
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7
n=I()
count=0
lis=LI()
for i in range(n):
    if i%2==0 and lis[i]%2==1:
        count+=1
print(count)

Solution (Python):



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


print(main())

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

print(len([i for i, v in enumerate(arr) if i % 2 == 0 and v % 2 == 1]))

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 = [int(x) for x in input().split()]
c = 0
for i in range(n):
  if not i%2 and a[i]%2:
    c += 1
print(c)

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

Solution (Python):


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

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

print(ret)

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(0, len(a), 2):
    if a[i] % 2 == 1:
        ans += 1

print(ans)

Solution (Python):
n = int(input())
A = [int(x) for x in 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):
import sys

sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))  
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))  
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())  
def LS2(): return list(sys.stdin.readline().rstrip())  

N = I()
a = LI()

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(n):
    if a[i]%2 == 1 and (i+1)%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 A[i]%2 == 1 and (i+1)%2 == 1:
        ans += 1
print(ans)

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]

n=II()
aa=LI()
ans=0
for i,a in enumerate(aa,1):
    if i&1 and a&1:ans+=1
print(ans)

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

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

print(ans)

Solution (Python):

import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial
from bisect import bisect_left, bisect_right 
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep='\n')

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

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

print(cnt)

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
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def s(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")

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

Solution (Python):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

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

Solution (Python):
from math import ceil,floor,comb,factorial,gcd,pow,sqrt,log2,cos,sin,tan,acos,asin,atan,degrees,radians,pi,inf
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from collections import deque,defaultdict,Counter
from bisect import bisect_left,bisect_right
from operator import itemgetter
from heapq import heapify,heappop,heappush
from copy import deepcopy
from time import time
import string
import sys
sys.setrecursionlimit(10 ** 7)
def input() : return sys.stdin.readline().strip()
def INT()   : return int(input())
def MAP()   : return map(int,input().split())
def LIST()  : return list(MAP())

n = INT()
a = LIST()

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

Solution (Python):
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
count = 0
ans = 0

N = i()
a = l()

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

    if ind%2==1 and num%2==1:
        ans+=1
print(ans)

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

    ans = 0
    for i, x in enumerate(A, start=1):
        if (i & 1) and (x & 1):
            ans += 1

    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7


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

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


if __name__ == '__main__':
    resolve()

Solution (Python):
n = int(input())
la = [int(w) for w in input().split()]

ans = 0

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


if __name__ == "__main__":
    main()

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from heapq import heapify, heappop, heappush
 
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
 
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

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

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

print(ans)

Solution (Python):
import sys
input = sys.stdin.readline
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):
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
INF = 10**9
mod = 10**9+7

N = i()
a = l()
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())

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


count=0

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

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

if __name__ == '__main__':
    main()

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