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


import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

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

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

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

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

print(ans)

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

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

n = readInt()
a = readInts()

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 ** 8)

def Z(): return int(input())
def ZZ(): return [int(_) for _ in input().split()]

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


    return

if __name__ == '__main__':
    main()

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

from collections import defaultdict, deque, Counter, OrderedDict
from functools import reduce, lru_cache
import collections, heapq, itertools, bisect
import math, fractions
import sys, copy

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline().rstrip())
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def S(): return list(sys.stdin.readline().rstrip())
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
MOD = 1000000007

def main():
    N = I()
    A = LI()

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

if __name__ == '__main__':
    main()

Solution (Python):
import sys
readline = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7

INF = 10**18
eps = 10**-7

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):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7 

from decimal import *



N = INT()
a = [0] + LIST()

ans = 0

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

print(ans)

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
N = int(input())
A = list(map(int,input().split()))
ans = 0
for i in range(N):
    if (i+1)&1 and A[i]&1:
        ans += 1
print(ans)

Solution (Python):
import sys
input=lambda: sys.stdin.readline().rstrip()
n=int(input())
A=[int(i) for i 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):
def main():
    N = int(input())
    A = [int(i) for i in input().split()]
    ans = 0
    for i, a in enumerate(A, start=1):
        if i % 2 == 1 and 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(n):
    if i % 2 == 0 and a[i] % 2 == 1:
        ans += 1
print(ans)

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

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

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

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

Solution (Python):
import sys
import heapq
import re
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from math import factorial, sqrt, ceil, gcd
from functools import lru_cache, reduce
from decimal import Decimal
INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)


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 dijkstra_heap(s, edge, n):
    
    d = [10**20] * n
    used = [True] * n 
    d[s] = 0
    used[s] = False
    edgelist = []
    for a,b in edge[s]:
        heapq.heappush(edgelist,a*(10**6)+b)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        
        if not used[minedge%(10**6)]:
            continue
        v = minedge%(10**6)
        d[v] = minedge//(10**6)
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
    return d


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

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

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

    return arr


def lcm(x, y):
    return (x * y) // gcd(x, y)


def lcm_list(numbers):
    return reduce(lcm, numbers, 1)


def gcd_list(numbers):
    return reduce(gcd, numbers)


def is_prime(n):
    if n <= 1:
        return False
    p = 2
    while True:
        if p ** 2 > n:
            break
        if n % p == 0:
            return False
        p += 1
    return True



def eratosthenes(limit):
    A = [i for i in range(2, limit+1)]
    P = []

    while True:
        prime = min(A)
        
        if prime > sqrt(limit):
            break
            
        P.append(prime)
            
        i = 0
        while i < len(A):
            if A[i] % prime == 0:
                A.pop(i)
                continue
            i += 1
            
    for a in A:
        P.append(a)
            
    return P


def permutation_with_duplicates(L):

    if L == []:
        return [[]]

    else:
        ret = []

        
        S = sorted(set(L))

        for i in S:

            data = L[:]
            data.remove(i)

            for j in permutation_with_duplicates(data):
                ret.append([i] + j)

        return ret



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

Solution (Python):
import sys
sys.setrecursionlimit(10000000)
MOD = 10 ** 9 + 7
INF = 10 ** 15

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

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

res = 0
for v in a[::2]:
    if v % 2 == 1:
        res += 1

print(res)

Solution (Python):



from fractions import gcd
from itertools import combinations,permutations,accumulate 

from collections import deque,defaultdict,Counter
import decimal
import re











import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7

def readInts():
  return list(map(int,input().split()))
def I():
  return int(input())
n = I()
A = readInts()
cnt = 0
for i in range(0,len(A),2):
    if A[i]%2:
        cnt += 1
print(cnt)

Solution (Python):
import sys; input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
from collections import defaultdict
con = 10 ** 9 + 7; INF = float("inf")

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


def main():
	N = int(input())
	A = getlist()
	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()))
print(sum(ai%2==1 for ai in a[::2]))

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

ans = 0
for i, a in enumerate(A, 1):
    if i & 1 and a & 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):
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
import math
from copy import deepcopy
import queue


Mod = 1000000007
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1] 
for i in range(2, 10**5 + 1):
    fact.append((fact[-1] * i) % Mod)
    inv.append((-inv[Mod % i] * (Mod // i)) % Mod)
    factinv.append((factinv[-1] * inv[-1]) % Mod)
    
def cmb(n, r, p):
    if (r < 0) or (n < r):
        return 0
    r = min(r, n - r)
    return fact[n] * factinv[r] * factinv[n - r] % p
    
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[y] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)
import string
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 sys

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


def main():
    N = int(input())
    A = [int(x) for x in 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()))

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

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

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


import sys
input=sys.stdin.readline

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

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

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


import sys
input=sys.stdin.readline

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

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

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

Solution (Python):
import sys

def solve():
    input = sys.stdin.readline
    N = int(input())
    A = [int(a) for a in input().split()]
    count = 0
    for i in range(N):
        if i % 2 == 0 and A[i] % 2 == 1:
            count += 1
    print(count)

    return 0

if __name__ == "__main__":
    solve()

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

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

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

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

def LI(): return [int(x) for x in sys.stdin.readline().split()]

def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  n=I()
  l=LI()
  ans=0

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

  return ans


print(main())

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline

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

readline = sys.stdin.readline
readall = sys.stdin.read
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')

def solve():
    n = ni()
    a = nl()
    print(sum(1 for i in range(0, n, 2) if a[i] & 1))
    return

solve()

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")

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

cnt = 0

for i in range(1, n + 1):
    if i % 2 == 1 and a[i - 1] % 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):
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):
import sys
sys.setrecursionlimit(10**7) 
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right

from collections import deque, defaultdict


from collections import Counter

from itertools import accumulate,combinations,permutations,product

from heapq import heapify,heappop,heappush


from functools import reduce,lru_cache

from decimal import Decimal

def input(): 
    x=sys.stdin.readline()
    return x[:-1] if x[-1]=="\n" else x
def printe(*x):print("
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False): 
    inds=sorted(range(len(s)), key=lambda k: s[k])
    if return_sorted: return inds, [s[i] for i in inds]
    return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
    K,N,M=len(B),len(A),len(B[0])
    return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
    N,size=len(v),len(M)
    return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
    n,m=len(M),len(M[0])
    return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
    mod = 1000000007
    

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

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



if __name__ == "__main__":
    main()

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

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

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

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

def resolve():
    
    n=int(input())
    A=list(map(int,input().split()))
    cnt=0
    for k,v in enumerate(A):
        if k%2==0 and v%2==1:
            cnt+=1
    print(cnt)
    
resolve()

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 = [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
input = sys.stdin.readline
from collections import *

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

input = sys.stdin.readline


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


if __name__ == "__main__":
    main()

Solution (Python):
import math

import itertools
import queue
import bisect
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit


ipt = stdin.readline
setrecursionlimit(10**7)

def main():
    n = int(ipt())
    a = [int(i) for i in ipt().split()]
    num = 0
    for i,ai in enumerate(a):
        if i%2 == 0 and ai%2:
            num += 1
    print(num)

    return None

if __name__ == '__main__':
    main()

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

from decimal import Decimal
from collections import defaultdict, deque

sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)

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


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    N = ii()
    A = il()

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


if __name__ == '__main__':
    main()

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

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(2 * 10**6)


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


def main():
    N = int(input())
    A = inpl()
    print(len([i for i, a in enumerate(A) if i % 2 == 0 and a % 2 == 1]))

    return


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

Solution (Python):
from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().split()))

n=int(input())
a=lnii()

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

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

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

ans=0
for i,v in enumerate(A,1):
    if i%2==1 and v%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(n):
    if (i+1) % 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):
  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()))

res = 0

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

print(res)

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    N, *A = map(int, read().split())

    ans = 0
    for a in A[::2]:
        if a % 2 == 1:
            ans += 1

    print(ans)
    return


if __name__ == '__main__':
    main()

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

Solution (Python):
import sys
sys.setrecursionlimit(500000)
MOD = 10**9+7

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

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

def ii():
    return int(input())

def i2(n):
    tmp = [list(mi()) for i in range(n)]
    return [list(i) for i in zip(*tmp)]


def main():
    N = ii()
    a = list(mi())
    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
sys.setrecursionlimit(10**8)
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return [LIST() for _ in range(n)]
def NSTR(n): return [input() for _ in range(n)]


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


def main():
    N = INT()
    A = LIST()
    count = 0
    for i, a in enumerate(A, start=1):
        if i % 2 == 1 and a % 2 == 1:
            count += 1
    print(count)

    return


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 = [int(hoge) for hoge in input().split()]
print(sum([x%2 for n,x in enumerate(A) if n%2 == 0 ]))

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.buffer.readline()[:-1]
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

N = INT()
a = LIST()

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

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

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

Solution (Python):
N, *A = map(int, open(0).read().split())
cnt = 0
for i, a in enumerate(A):
    if (i+1) & 1 and a & 1:
        cnt += 1
print(cnt)

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

Solution (Python):
S=lambda:input()
I=lambda:int(input())
L=lambda:list(map(int,input().split()))
LS=lambda:list(map(str,input().split()))

n=I()
a=L()
ans=0
for i in range(n):
    if i+1&1 and a[i]&1:
        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 % 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:
        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)