Problem:
 Score : 100 points    Problem Statement Find the number of ways to choose a pair of an even number and an odd number from the positive integers between 1 and K (inclusive). The order does not matter.      Constraints  2\leq K\leq 100  K is an integer.         Input Input is given from Standard Input in the following format:  K       Output Print the number of ways to choose a pair of an even number and an odd number from the positive integers between 1 and K (inclusive).        Sample Input 1 3      Sample Output 1 2  Two pairs can be chosen: (2,1) and (2,3) .       Sample Input 2 6      Sample Output 2 9       Sample Input 3 11      Sample Output 3 30       Sample Input 4 50      Sample Output 4 625

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

if K%2 == 0:
  even_num = odd_num = K//2
else:
  even_num = K//2
  odd_num = even_num + 1

print(even_num * odd_num)

Solution (Python):
from math import ceil

K = int(input())
odds = int(ceil(K / 2))
evens = K // 2

print(odds * evens)

Solution (Python):

import math,string,itertools,fractions,heapq,collections,re,array,bisect

def s():
    return input()
def n():
    return int(input())
def d():
    return float(input())

def ls():
    return input().split()
def ln():
    return map(int, input().split())
def ld():
    return map(float, input().split())

def fs():
    return [input() for i in range(input())]
def fn():
    return [int(input()) for i in range(input())]
def fd():
    return [float(input()) for i in range(input())]

K = n()

if K%2 == 0:
    ans = K//2 * K//2
else:
    ans = K//2 * (K//2 + 1)
print(ans)

Solution (Python):
K = int(input())
if K%2 == 0:
    print(int((K/2)*(K/2)))
else:
    print(int(((K-1)/2)*((K+1)/2)))

Solution (Python):
K = int(input())
out = (K // 2) * (K // 2 + K % 2)

print(int(out))

Solution (Python):
K = int(input())
a = 0
b = 0
for i in range(1, K + 1):
    if i % 2 == 0:
        a +=1
    else:
        b += 1
print(a * b)

Solution (Python):
K = int(input())
print(int((K/2)*(K/2)))

Solution (Python):
k=input()
k=int(k)
print(int(k/2+0.5)*(int(k/2)))

Solution (Python):
K = int(input())
if K%2 == 0: 
  print(int((K/2)*(K/2)))
else:
  print(int((K//2)*(K//2+1)))

Solution (Python):


k = int(input())
print((k//2)*((k+1)//2))

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

B = A // 2

C = A - B

print(B*C)

Solution (Python):
print(int(input())**2//4)

Solution (Python):
K = int(input())
e = K//2
o = (K+1)//2
print(e*o)

Solution (Python):
K = int(input())
print((K//2)*((K+1)//2))

Solution (Python):



import sys

def main():
    k = int(sys.stdin.readline())
    r, q = divmod(k, 2)
    print(r * (r + q))

if __name__ == '__main__':
    main()

Solution (Python):
K = int(input())
if K % 2 == 0:
    print(int(K / 2) ** 2)
elif K % 2 == 1:
    print(int(K // 2) * (int(K // 2) + 1))
else:
    pass

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

print(k//2 * ((k-1)//2+1))

Solution (Python):
k = int(input())
k_int = int(k/2) 
if k%2 == 1:
  print(k_int*(k_int+1))
else:
  print((k_int)**2)

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

print((K + 1) // 2 * (K // 2))

Solution (Python):



def main():
    k = int(input())
    res = 0

    if k % 2 == 0:
        res = (k // 2) ** 2
    else:
        res = (k // 2) * ((k // 2) + 1)

    print(res)


if __name__ == '__main__':
    main()

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

g = k//2
kk = k//2
if k % 2 != 0:
    kk+=1

print(g*kk)

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

print(int(K/2)*(K - int(K/2)))

Solution (Python):
K = int(input())
m = K//2
print(m*(K-m))

Solution (Python):
def calcPairOddAndEven(num):
    if num % 2 == 0:
        return int((num / 2))**2
    else:
        return int(num / 2)*int(num / 2 + 1)


def main():
    numArray = [3, 6, 11, 50]
    for num in numArray:
        print(num, ":", calcPairOddAndEven(num))


def contest():
    print(calcPairOddAndEven(int(input())))

if __name__ == '__main__':
    contest()

Solution (Python):
def main():
    K = int(input())

    ans = editorial(K)
    assert ans == AC(K)
    print(ans)


def editorial(K):
    return (K // 2) * ((K + 1) // 2)


def AC(K):
    d = {}
    for i in range(1, K+1):
        for j in range(i+1, K+1):
            p = tuple(sorted((i, j)))
            if i % 2 == 1 and j % 2 == 0:
                d[p] = 1
            elif i % 2 == 0 and j % 2 == 1:
                d[p] = 1

    ans = len(d)
    return ans


if __name__ == '__main__':
    main()

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

n = k //2 
print(n*(n+k%2))

Solution (Python):
n = int(input())
even = n // 2
odd = n - even
print(even * odd)

Solution (Python):
K = int(input())
print((K//2)*(K//2) if K%2==0 else ((K//2)*(1+K//2)))

Solution (Python):
K = int(input())
if K % 2 == 0:
    print((K // 2) ** 2)
else:
    print(((K - 1) // 2) * ((K - 1) // 2 + 1))

Solution (Python):
i = int(input())
if i % 2 == 0:
    print(int((i / 2) ** 2))
else:
    i = i + 1
    a = i / 2
    print(int(a * (a - 1)))

Solution (Python):
k=int(input())
print((k//2)*(k//2+k%2))

Solution (Python):
K = int(raw_input())
if K%2 ==0:
  a = (K/2)**2
else:
  a = ((K+1)/2)*((K-1)/2)
print a

Solution (Python):
n=int(input())
print((n//2)*(n-n//2))

Solution (Python):
n = int(input())
print(n//2*(n-n//2))

Solution (Python):
num = int(input())
even = num//2
print(even*(num-even))

Solution (Python):



K = int(input())
if K % 2 == 0:
    print((K//2)**2)
else:
    print((K//2)*(K//2 +1))

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

even = K // 2
odd = K - even

print(even*odd)

Solution (Python):
K = int(input())
print((K//2) * ((K+1)//2))

Solution (Python):
k = int(input())
od = k//2 + k%2
ev = k - od
print(od*ev)

Solution (Python):
N = int(input())
if N % 2 == 0:
    print((N // 2) ** 2)
else:
    print((N // 2) * (N // 2 + 1))

Solution (Python):
k = int(input())
print((k // 2) * (k - k // 2))

Solution (Python):


K = int(input())

print(((K+1) // 2) * (K // 2))

Solution (Python):
K = int(input())
if K % 2 == 0:
    K = K // 2
    print(K * K)
else:
    K = K // 2
    print(K * (K+1))

Solution (Python):
k=int(input())
even=int(k//2)
odd=k-even
print(odd*even)

Solution (Python):
K=int(input())
print(int(K/2)*int((K+1)/2))

Solution (Python):
def run(k):
    return (k // 2)*(k // 2 + k % 2)


def read_line():
    k = int(input())
    return k


def main():
    k = read_line()
    print(run(k))


if __name__ == '__main__':
    main()

Solution (Python):
N=int(input())
E=N//2
if N%2==1:
    O=N//2+1
else:
    O=N//2
print(E*O)

Solution (Python):
N = int(input())
if N % 2 == 0:
  print((N//2)**2)
else:
  print((N//2)*(N//2+1))

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

odd = (K + 1) // 2
even = K // 2

print(odd * even)

Solution (Python):
print input()**2/4

Solution (Python):


k=int(raw_input())
if k%2:
 print k/2*(k/2+1)
else:
 print (k/2)**2

Solution (Python):
k = int(input())
print((k//2)*((k+1)//2))

Solution (Python):
import math


K = int(input())

if K % 2 == 1:
    print(math.trunc(K / 2) * (math.trunc(K /2) + 1))
else:
    print(math.trunc(K / 2) ** 2)

Solution (Python):
print(int(input())**2//4)

Solution (Python):
K = int(input())
print((K // 2+ K % 2) * (K // 2))

Solution (Python):
n=int(input())
print(n//2*(n-n//2))

Solution (Python):
print(int(input())**2//4)

Solution (Python):
k = int(input())
is_odd = k % 2 == 1
even_count = int(k / 2)
odd_count = int(k / 2)
if is_odd:
	odd_count += 1
print(even_count * odd_count)

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

print((k//2) * (k + k%2)//2)

Solution (Python):


def main():
    k = int(input())
    if k % 2 == 0:
        ans = (k // 2) ** 2
    else:
        ans = (k // 2) * ((k // 2) + 1)
    print(ans)

if __name__ == '__main__':
    main()

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

print(N//2 * ((N+1)//2))

Solution (Python):
print input()**2>>2

Solution (Python):
print int((input()*1.0/2)**2)

Solution (Python):
n=int(input());print([(n//2)**2,n//2*(n//2+1)][n%2])

Solution (Python):
print(int((int(input())/2)**2))

Solution (Python):
n=int(input());print([(n//2)**2,n//2*(n//2+1)][n%2])

Solution (Python):
print(int((int(input())/2)**2))

Solution (Python):
n = int(input())
if n%2: print((n//2)*(n//2+1))
else: print((n//2)**2)

Solution (Python):
K = int(input())
e = K // 2
o = (K + 2 - 1) // 2
if e + o == K:
    print(e * o)

Solution (Python):
print((lambda x:(x//2)*(x-x//2))(int(input())))

Solution (Python):
k = int(input())
print((k // 2) * ((k + 1) // 2))

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

odd = K // 2 if K % 2 == 0 else K // 2 + 1
even = K // 2

R = odd * even

print(R)

Solution (Python):
print(int(input())**2>>2)

Solution (Python):
k = int(input())
if k % 2 == 0:
    print((k//2)**2)
else:
    print((k//2)*(k//2+1))

Solution (Python):
a=int(input())/2;print(int(a**2))

Solution (Python):
K=int(input())
A=0
B=0
for i in range(1,K+1):
    if i%2==0:
        A+=1
    else:
        B+=1
print(A*B)

Solution (Python):
n=int(input());print(int((n/2)**2))

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

even = k // 2
odd = k - even
print(even * odd)

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

print(((K+1)//2)*(K//2))

Solution (Python):
a=int(input());x=a//2;print((a-x)*x)

Solution (Python):
a=int(input());print((a//2)*((a+1)//2))

Solution (Python):
K = int(input())
if K % 2 == 1:
    print(int(((K - 1) / 2 ) * ((K + 1) / 2)))
    
else:
    print(int((K / 2)**2))

Solution (Python):
a=int(input())
print((a//2)*((a+1)//2))

Solution (Python):
n=int(raw_input())
e=n/2
o=(n+1)/2
print e*o

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

result = (K // 2) * ((K+1) // 2)

print(result)

Solution (Python):
def get(n):
  if(n%2==0):
    return ((n//2)**2)
  elif(n==1):
    return (0)  
  else:
    return (((n//2)**2)+(n-1)//2)

n=int(input())
z=get(n)
print (z)

Solution (Python):
K = int(input())
odd = []
even = []
count = 0

for i in range(1, K+1):
    if i % 2 == 0:
        even.append(i)
    else:
        odd.append(i)
for i in even:
    for j in odd:
        count += 1

print(count)

Solution (Python):
K = int(input())
out= 0
if K%2 == 0:
    out = (K/2)**2
else:
    out =((K-1)/2)*((K+1)/2)
print(int(out))

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


if K%2 == 1:
    P=(K+1)/2
    print(int(P*(P-1)))
else:
    O=K/2
    print(int(O*O))

Solution (Python):
K = int(input())
N = K - 1
count = 0
for i in range(K):
    I = i + 1
    for j in range(N):
        J = j + 1
        if I % 2 != 0 & J % 2 == 0:
            count += 1
        elif I % 2 == 0 & J % 2 != 0:
            count += 1
    N -= 1
print(count)

Solution (Python):
a=input()
if a%2==0:
 ans=(a/2)**2
 print ans
else:
 ans=((a-1)/2)*((a+1)/2)
 print ans

Solution (Python):

k = int(input())        

if (k%2) == 1:
    o = (k-1) * (k+1) / 8
    
    print(int(2*o))

else:
    o = k * (k+2) / 8
    e = k * (k-2) / 8
    print(int(o+e))

Solution (Python):
def get(n):
    z=((n//2)**2)+(n-1)//2
    if(n%2==0):
        return (n//2)**2
    elif(n==1):
        return 0
    else:
        return z
    
n=int(input())
x=get(n)
print(x)

Solution (Python):
K = int(input())
if K  % 2 == 0:
    print(int((K/2) ** 2))
else:
    print(int((K-1)/2 * ((K-1)/2 + 1)))

Solution (Python):
K=int(input())
if K%2:
    print((K//2)*(K//2+1))
else: print((K//2)**2)

Solution (Python):
import math
K = int(input())
all_number =  K * K
even_number =  math.floor(K/2) * math.floor(K/2)
odd_number = math.ceil(K/2) * math.ceil(K/2)
answer = (all_number - even_number - odd_number)/2
print(int(answer))

Solution (Python):
K = int(input())
if K % 2 == 0:
    print(int((K/2)**2))
else:
    print(int((K+1)/2 * ((K+1)/2 - 1)))

Solution (Python):
k = int(input())
if k % 2 != 0:
    print(int((k -1) **2 * 0.25 + (k-1) * 0.5))
else:
    print(int(k * k * 0.25))

Solution (Python):
K=int(input())
L=int((K+1)/2)
M=int(K/2)
print(L*M)

Solution (Python):
import math

K = int(input())
if K % 2 == 0:
    print(int((K / 2) ** 2))
else:
    print(math.floor(K / 2) * (math.floor(K / 2) + 1))

Solution (Python):
k = int(input())
if k&1==1:
	odds = ((k-1)//2) + 1
	evens = odds-1
	print(odds*evens)
else:	
	odds = ((k)//2)
	evens = odds
	print(odds*evens)

Solution (Python):
N= int(input())
print(N//2 * (N-N//2))

Solution (Python):
K = int(input())
if(K % 2==0):
    ans = (K/2)**2
else:
    ans = (K-1)*(K+1)/4
print(int(ans))

Solution (Python):
k = int(input())
print((k//2)*(k//2+k%2))

Solution (Python):
k = int(input())
half_k = k // 2
print(half_k * (half_k + k % 2))

Solution (Python):


k = int(raw_input())

if k % 2 is 0:
    print str((k/2)*(k/2))
else:
    print str(((k-1)/2)*(k+1)/2)

Solution (Python):
K = int(input())
f = 2
count = 0
while True:
  s = 1
  while True:
    count += 1
    s += 2
    if s > K:
      break
  f += 2
  if f > K:
    break
print(count)

Solution (Python):


K = int(input())
Odd = 0
Even = 0

for i in range(K):
    if(i % 2 ==0):
        Odd = Odd + 1

    else:
        Even = Even + 1

total = Odd * Even
print(total)

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

if K % 2 == 0:
    a = K // 2
    c = a**2 
else: 
    a = K // 2
    b = K // 2 + 1
    c = a * b

print(c)

Solution (Python):
K = int(input())
print(K//2*(-(-K//2)))

Solution (Python):
asdf = int(input())
if asdf % 2 == 0:
  k1 = asdf / 2
  Ans = k1 * k1
else:
  k2 = (asdf + 1) / 2
  k3 = k2 - 1
  Ans = k2 * k3
print(int(Ans))

Solution (Python):
n=int(input())
j=int(n/2)
if n%2==1:
    k=int(n/2)+1
else:
    k=int(n/2)
print(j*k)

Solution (Python):
i = int(input())
if i % 2 == 0:
    print((i // 2)*(i // 2))
else:
    print((i // 2)*(i // 2 + 1))

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

mod = K % 2

if mod == 0:
    n_even = K // 2
    n_odd = K // 2 
else:
    n_even = K // 2
    n_odd = K // 2 + 1

print(n_even*n_odd)

Solution (Python):
K=int(input())
print((K//2)*(K//2+int(K%2)))

Solution (Python):
def getinputdata():

    array_result = []    
    array_result.append(input().split(" "))

    flg = True

    try:
        while flg:

            data = input()

            if(data != ""):
                
                array_result.append(data.split(" "))

                flg = True

            else:

                flg = False
    finally:

        return array_result

arr_data = getinputdata()

k = int(arr_data[0][0])

if k % 2==0:
    
    print((k // 2 ) ** 2 )
    
else:

    print((k // 2 ) * ((k // 2) + 1 ))

Solution (Python):
K = int(input())
if K % 2 == 0:
    print(int((K/2)*(K/2)))
else:
    print(int(((K-1)/2)*(((K-1)/2)+1)))

Solution (Python):
n=int(input())
print (((n>>1)+(1 if n&1 else 0))*(n>>1))

Solution (Python):
k = int(input())
n = k // 2
nn = n
amari = k % 2
if amari:
  nn += 1
print(n * nn)

Solution (Python):
k = int(input())
ans = (k/2)**2 if k%2==0 else (k+1)/2 * ((k+1)/2 -1)
print(int(ans))

Solution (Python):
k = input()
a = k/2*(k-k/2)
print a

Solution (Python):
K=int(input())
if K % 2 ==0:
  print((K//2)**2)
else:
  print((K+1)*(K-1)//4)

Solution (Python):
n=int(input())
if n%2:
  a=n//2
  b=1+n//2
else:
  a=n//2
  b=n//2
print(a*b)

Solution (Python):
from sys import stdin

k = int(stdin.readline().rstrip())

num = range(1, k + 1)
add = len([i for i in num if i % 2 != 0])
even = len([i for i in num if i % 2 == 0])
ans = add * even
print(ans)

Solution (Python):

k=int(input())
ans=0
if k%2!=0:
    for i in range(1,k//2+1):
        ans+=i
    print(ans*2)
else:
    for j in range(1,k//2):
        ans+=j
       
    print(ans*2+k//2)

Solution (Python):
a = int(input())
print((a//2)*(a-(a//2)))

Solution (Python):
n = int(input())
a = b = n//2
if n %2==1:
    a += 1
print(a*b)

Solution (Python):
n = int(input())
if n % 2 == 0:
    ans = n//2
    print(ans * ans)
else:
    ans = (n-1)//2
    print(ans * (ans+1))

Solution (Python):
K =  int(input())
print((K//2)*(K//2+K%2))

Solution (Python):




def main():
    k = int(input())

    ans = k // 2 * ((k+1)//2)
    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):


k = int(input())

evens = k // 2
odds = k - evens

print(evens * odds)

Solution (Python):
import math
k = int(input())

if k % 2 == 0:
    comb = pow((math.factorial(k//2))/(math.factorial(k//2-1)), 2)
    print(int(comb))
else:
    comb = (math.factorial(k//2))/(math.factorial(k//2-1)) * (math.factorial(k//2 + 1))/(math.factorial(k//2))
    print(int(comb))

Solution (Python):
def main():
	n = int(input())
	if n % 2 == 0:
		ans = (n / 2) ** 2
	else:
		tmp = n / 2
		ans = int(tmp) * (int(tmp) + 1)
	print(int(ans))
if __name__ == "__main__":
	main()

Solution (Python):
K = int(input())
if K%2 == 0:
    print(int(K/2)**2)
else:
    print(int((K+1)/2*((K+1)/2-1)))

Solution (Python):
def main():
    K = int(input())

    d = {}
    for i in range(1, K+1):
        for j in range(i+1, K+1):
            p = tuple(sorted((i, j)))
            if i % 2 == 1 and j % 2 == 0:
                d[p] = 1
            elif i % 2 == 0 and j % 2 == 1:
                d[p] = 1

    ans = len(d)
    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
k = raw_input()
k=int(k)
if k%2==0:

    x=k/2
    x=x*x
    print x
else:
    y=k/2
    y=y*(y+1)
    print y

Solution (Python):
k = int(input())
o = k // 2
mod = k % 2
if mod == 0:
  print(o*o)
else:
  print((o+1)*o)

Solution (Python):
import math

n = int(input())
even = int((n / 2))
odd = n - even
print(even * odd)

Solution (Python):
K=int(input())
if K%2==0:
    print(int((K/2)**2))
else:
    print((int(K/2)*(int(K/2)+1)))

Solution (Python):
import math

K = input()

D = int(K) / 2

f, i = math.modf(D)

if f == 0: 
    answer =  i * i
else: 
    p1 = i
    p2 = i + 1
    answer = p1 * p2

print(int(answer))

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

if (k % 2==0):
  print(int(k/2*k/2))
else:
  print(int((k-1)/2*(k+1)/2))

Solution (Python):


def pair(n):
    even = n // 2
    odd = n // 2 + n % 2
    return even * odd

def main():
    n = int(input())
    print(pair(n))


main()

Solution (Python):
import math;

K = int(input());

print(math.floor(K/2)*math.ceil(K/2));

Solution (Python):


K = int(input())

ans = 0

if K % 2 == 0:
    ans = sum(range(1,K,2))

elif K % 2 == 1:
    ans = sum(range(0,K,2))


print(ans)

Solution (Python):
K = int(input())
print((K//2)*((K+1)//2))

Solution (Python):
k = int(input())
m = (k-1)/2
n = (k-1)/2 + 1
if k % 2 == 0:
  print(int((k/2)**2))
else :
  print(int(m*n))

Solution (Python):
import math

k = int(input())
even = math.floor(k/2)
odd = math.floor(k/2)

if k%2 != 0:
    even += 1

print(even * odd)

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

ans = 0
for i in range(1,N+1):
    ans += i//2

print(ans)

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

even = 0
odd = 0
for i in range(K):
    if i % 2 == 0:
        even += 1
    else:
        odd += 1
print("{}".format(even*odd))

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


g =0
k =0

if (K % 2) == 0:
    g=K/2
    k=K/2
else:
    g=(K-1)/2
    k=g+1

print(int(g*k))

Solution (Python):
K = int(input())
ans = 0
for i in range(1,K+1):
    j = i
    while(j > 1):
        j -= 2
        ans += 1
print(ans)

Solution (Python):
def Pair(K):
    n = 0
    even = []
    odd = []
    K = int(K)
    k = K + 1
    for p in range(1,k):
        if p%2 == 0:
            even.append(p)
        if p%2 == 1:
            odd.append(p)
    n = len(even) * len(odd)
    print (n)

Pair(input())

Solution (Python):
k = int(input())
val = [i for i in range(1, k+1)]

even = 0
odd = 0

for i in val:
    if i % 2 == 0:
        even += 1
    else:
        odd += 1
        
print(even*odd)

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

a = data // 2

if data % 2 == 0:
    print(a*a)
else:
    print(a*(a+1))

Solution (Python):
def main(n):
	if n%2 ==1:
		
		return int(n/2)*(int(n/2)+1)
		
	elif n%2 ==0:
		
		return int(n/2)*int(n/2)


n = int(input())
print(main(n))

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

k = int(K/2+0.5)
g = int(K/2)

print(k*g)

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

if K % 2 == 1:
    print((K // 2) * (K // 2 + 1))
else:
    print((K // 2) ** 2)

Solution (Python):
k = int(input())
if k % 2 == 0:
  print(int(k*k/4))
else :
  print(int((k+1)*(k-1)/4))

Solution (Python):
import math
n = int(input())
if(n%2==0):
  print(int(math.pow(int(n/2),2)))
else:
  print(int(n/2) * int((n+1)/2))

Solution (Python):

import math
K = int(input())

ans = 0

if K%2 == 0:
    ans = pow(K, 2)/4
else :
    ans = math.floor(K/2) * round(K/2)

print (int(ans))

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

ans = 0

for i in range(1, k + 1, 2):
    for j in range(2, k + 1, 2):
        ans += 1

print(ans)

Solution (Python):
k=int(input())
if k%2==1:
    x=k//2
    print((x+1)*x)
else:
    x=int(k/2)
    print(x*x)

Solution (Python):

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

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

ans = int(K/2) * int(K/2)

if K % 2 == 0:
    ans = (K/2)**2
else:
    ans = (int(K/2) + 1) * int(K/2)

print(int(ans))

Solution (Python):
import numpy


K = int(input())

cnt = 0
for i in range(1, K):
    for j in range(i+1, K+1):
        if (i % 2 == 0 and j % 2 != 0) or (i % 2 != 0 and j % 2 == 0):
            cnt += 1
print(cnt)

Solution (Python):
import math
k = int(input())

print(math.ceil(k/2) * math.ceil((k-1)/2))

Solution (Python):


 
def main():
	K = int(input())
	if K % 2 == 0:
		n = K / 2
		x = round(n**2)
	else:
		n = (K + 1) / 2
		x = round(n * (n-1))
	print(x)

if __name__ == '__main__':
	main()

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

if K % 2 == 0:
    print((K//2)**2)
else:
    print((K + 1)//2 * (K - 1)//2)

Solution (Python):
K = int(input())
if K % 2 == 0:
  print(int(K * K / 4))
else:
  print(int((K * K - 1) / 4))

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

if a % 2 == 0:
    b = a / 2
    c = b * b
else:
    b = a // 2
    c = b * (b + 1)

print(int(c))

Solution (Python):
K = int(input())
even = int(K/2)
odd = int((K-1)/2) + 1
print(odd*even)

Solution (Python):
import math
K = int(input())
guusuu = ((K-(K%2))/2)
kisuu = math.floor((K+1)/2)
print(int(guusuu * kisuu))

Solution (Python):
k = int(input())
q = k // 2
m = k %  2

k_odd  = q + m
k_even = q

ans = k_odd * k_even
print(ans)

Solution (Python):
from sys import stdin, stdout

input = lambda: stdin.readline().rstrip()
write = stdout.write

def main():
    K = int(input())

    if K % 2:
        odd = K // 2 + 1
        even = K // 2
    else:
        odd = even = K // 2
    print(odd * even)

main()

Solution (Python):
a = int(input())
if(a%2 == 0):
    print(int((a/2)*(a/2)))
else:
    print(int((int((a/2))+1)*int((a/2))))

Solution (Python):
K = int(input())
num = 0
gu = []
ki = []
for i in range(K):
  if i%2 == 0:
    gu.append(i)
  else:
    ki.append(i)
  a = len(gu)
  b = len(ki)
  num = a*b
  
print(num)

Solution (Python):
def solve():
  x = int(input())
  count = 0

  for i in reversed(range(x)):
    i += 1

    if i % 2 ==0:
      count += i / 2
    else:
      count += i // 2
      
  
  print(int(count))

solve()

Solution (Python):
K = int(input())
if K%2 == 0:
    print(K//2*K//2)
else:
    print(K//2*(K//2+1))

Solution (Python):
a=int(input())
if a%2==0:
    print(int((a/2)*(a/2)))
else:
    print(int(((a//2)+1)*(a//2)))

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


C=0

for i in range(1,K+1,2):
    for j in range(K):
        if j%2==1:
            C=C+1
        else:
            pass

print(C)

Solution (Python):
k = int(input())
res = 0
for i in range(1, k+1):
    res += i//2
print(res)

Solution (Python):
K = int(input())
if K%2 == 0:
    A = (K/2)*(K/2)
else:
    A = ((K-1)/2)*((K+1)/2)

print(int(A))

Solution (Python):
K=int(input())
if K%2==0:
    print(int((K/2)**2))
else:
    print(int((K+1)/2*((K+1)/2-1)))

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

ev=k//2
od=k-ev

print(ev*od)

Solution (Python):
k = int(input())
base = list(range(1,k+1))
x = [[a,b] for a in base for b in base if (a+b)%2==1 ]
ans = len(x)//2
print(ans)

Solution (Python):
K = int(input())
if K%2 == 0:
  print(round(K/2*K/2))
else:
  print( round((K+1)/2*(K-1)/2) )

Solution (Python):
def main():
  K = int(input())
  odd = K // 2 + K % 2
  even = K // 2
  print(odd * even)

if __name__ == '__main__':
  main()

Solution (Python):


K = int(input())

if K % 2 == 0:
    print((K // 2) ** 2)
else:
    print((K//2 + 1) * (K//2))

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

N1 = int(N/2)
if N%2 == 1:
    print(N1*(N1+1))
else:
    print(N1*N1)

Solution (Python):
k = int(input())
even = []
odd = []
for i in range(1,k+1):
  if i % 2 == 1:
    odd.append(i)
  else:
    even.append(i)
print(len(odd) * len(even))

Solution (Python):
import itertools
k = int(input())
a =[]
for i in range(k):
    a.append(i+1)
c = list(itertools.combinations(a,2))
cnt=0
for i in c:
    if i[0]%2==1 and i[1]%2==0:
        cnt+=1
    elif i[0]%2==0 and i[1]%2==1:
        cnt+=1
print(cnt)

Solution (Python):
import math
K = input()
gu = K/2
ki = K/2
ki += 1 if K%2 else 0
print gu * ki

Solution (Python):
K = int(input())
if K % 2 == 0:
    A = (K // 2) * (K // 2)
    print(A)
else:
    B = ((K // 2) + 1) * (K // 2)
    print(B)

Solution (Python):
k = int(input())
res = 0
even = list()
odd = list()

for i in range(k):
    if (i+1) % 2 == 0:
        even.append(i+1)
    else:
        odd.append(i+1)

print(len(odd)*len(even))

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

count=0
for i in range(1,K):
    for j in range(i+1,K+1):
        
        if i%2!=0:
            if j%2==0:
                count+=1
        else:
            if j%2==1:
                count+=1

print(count)

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

if k % 2 == 0:
    out = (k/2)*(k/2)
else:
    out = int(k/2) *  (int(k/2) + 1)

print(int(out))

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

even_num = int(k/2)

if(k%2==0):
    odd_num = even_num
else:
    odd_num = even_num+1

product_num = even_num * odd_num

print(product_num)

Solution (Python):
k = int(input())
m = k//2
n = k//2 + k % 2
print(m * n)

Solution (Python):
K=int(input())
if K%2==0:
  print(int((K/2)*(K/2)))
else:
  print(int(((K+1)/2)*((K-1)/2)))

Solution (Python):
import math

s = int(input())

print(math.ceil(s/2)*math.floor(s/2))

Solution (Python):
import sys, math
from sys import stdin, stdout
rem = 10 ** 9 + 7
sys.setrecursionlimit(10 ** 6+5)

take = lambda: map(int, stdin.readline().strip().split())
from bisect import bisect_left,bisect_right

k=input()
print (k/2*(k-k/2))

Solution (Python):
def chance(x: int) -> int:
    return (x//2) ** 2 if x % 2 == 0 else ((x-1)//2) * ((x+1)//2)








if __name__ == '__main__':
    x = int(input())
    print(chance(x))

Solution (Python):
t=int(input())
if t%2==0:
    res=int(t/2)
    print(res*res)
else:
    res=int(t/2)
    print(res*(res+1))

Solution (Python):

def main():
    n = int(input())
    if n %2 ==0:
        print(int((n/2)**2))
    else:
        print(int((n//2) * ((n//2)+1)))


if __name__ == "__main__":
        main()

Solution (Python):
K = int(raw_input().replace("\n", ""))
print (K ** 2) / 4 if K % 2 == 0 else (K - 1) * (K + 1) / 4

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

if (N % 2) == 0:
    ans = (N/2) ** 2
else:
    ans = int(N/2) * int(N/2 + 1)

print(int(ans))

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

if K % 2 == 0:
    pair = (K/2) ** 2
else:
    pair = (K+1)/2 * (K-1)/2

print(int(pair))

Solution (Python):
n = input()

if n % 2 == 0:
    even = int(n / 2)
    odd = int(n / 2)
else:
    even = int(n / 2)
    odd = int(n / 2) + 1
print(even*odd)

Solution (Python):
n=int(input())
k=n//2
m=n-k
print(k*m)

Solution (Python):
K = int(input())
if K % 2 ==0:
    print(int((K/2)**2))
else:
    print((K//2)*(K//2+1))

Solution (Python):
MOD = 10**9 + 7
I = lambda:list(map(int,input().split()))

k , = I()
even = k//2
odd = (k + 1)//2
print(even*odd)

Solution (Python):
import math
instr = input()
K = int(instr)

COdd = math.ceil(K / 2)
CEven = int(K / 2)

ans = COdd * CEven
print(ans)

Solution (Python):
k = int(input())
if k % 2 == 1:
    n_odd = int(k/2)+1
    n_even = int(k/2)
else:
    n_odd = int(k/2)
    n_even = int(k/2)
print(n_odd*n_even)

Solution (Python):
k = input()
a = k/2*(k-k/2)
print a

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

even = n//2

if n % 2 == 0 :
    odd = n//2
else:
    odd = n//2+ 1

ans = odd * even

print(int(ans))

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

a = s % 2

if a == 0:
    K = s / 2
    print( int(K ** 2) )
else:
    L = (s-1) / 2
    x = int((L + 1) * L)
    print(x)

Solution (Python):
K = int(input())
even = 0
odd = 0
for i in range(K):
    if i % 2 == 0:
        even += 1
    else:
        odd += 1
print(even * odd)

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

if K%2 == 0:
    print((K//2)**2)
else:
    print(((K+1)//2)*(K//2))

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

c = 0
for i in range(1, K):
  for j in range(i+1, K+1):
    if i%2 == 0 and j%2 == 1:
     	c += 1
    if i%2 == 1 and j%2 == 0:
      	c += 1
print (c)

Solution (Python):
k = int(input())
import math
if k%2==0:
    ans = (k/2)**2
    print(int(ans))
else:
    ans = (math.ceil(k/2)-1)*math.ceil(k/2)
    print(int(ans))

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

import math


def solve1(N):
    n1 = N//2
    n2 = N - n1
    return n1*n2

print(solve1(N))

Solution (Python):
k = int(input())
ki, gu = 0, 0
for x in range(1, k+1):
    if x % 2 == 0:
        gu += 1
    else:
        ki += 1
print(ki * gu)

Solution (Python):
K = int(input().strip())

print((K // 2) * ((K // 2) + (K % 2)))

Solution (Python):
k = [i for i in range(1, int(input()) + 1)]

odd = k[1::2]
even = k[0::2]

print(len(odd) * len(even))

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

a = [i for i in range(1,K+1)]

odd = list( filter(lambda x: x % 2 == 1, a) )
even = list ( filter(lambda x: x % 2 == 0, a) )

print(len(odd)*len(even))

Solution (Python):
K = int(input())
a = round(K/2)
if(K%2 == 0):
    print(a*a)
else:
    print(a*(a-1))

Solution (Python):


K = int(input().strip())

Neven = K // 2
Nodd = K // 2 
if K % 2 != 0:
    Nodd = Nodd + 1
print(Nodd*Neven)

Solution (Python):
K = int(input())
if K % 2 == 1:
    ans = ((K-1)/2)*((K+1)/2)
else:
    ans = K*K*(1/4)
ANS = int(ans)
print(ANS)

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

if n % 2 == 0:
    print(int((n/2) * (n/2)))
else:
    print(int(((n-1)/2) * ((n+1)/2)))

Solution (Python):


from math import ceil

k = int(input())

print(k // 2 * ceil(k / 2))

Solution (Python):
K = int(input())
print((K-K//2)*(K//2))

Solution (Python):
K = int(input())
 
if K%2 == 0:
  print(int((K/2)**2))
else:
  print(int(K/2)*int(K/2+1))

Solution (Python):
k = int(input())
c = 0
for i in range(1, k+1):
    for j in range(1, k+1):
        if (i + j) % 2 == 1:
            c += 1
print(c // 2)

Solution (Python):
k = int(input())
if k % 2 == 0:
    print(str((k//2)**2))
else:
    print(str((k//2) * (k//2+1)))

Solution (Python):
K = int(raw_input())
n_odd = 0
n_even = 0
if K % 2 == 0:
    n_odd = K/2
    n_even = K/2
else:
    n_odd = K/2 + 1
    n_even = K/2
print n_odd * n_even

Solution (Python):
K = int(input())
ans = 0
if K%2 == 1:
    ans = int(K/2) * int(K/2 + 1)
else:
    ans = int(K/2) * int(K/2)
print(ans)

Solution (Python):
x = int(input(""))

i = x // 2
j = (x - 1) // 2 + 1

print(i * j)

Solution (Python):
K=int(input())
x=K//2
if K&1:
    print(-~x*x)
else:
    print(x*x)

Solution (Python):
s=int(input())
if s%2:
	print(s//2*(s+1)//2)
else:
	print((s//2)**2)

Solution (Python):
import math

K = int(input())

o = math.ceil(K/2)
e = math.floor(K/2)

print(o*e)

Solution (Python):
def m():
    k = int(input())
    if k % 2 == 0:
        return (k//2) **2
    else:
        return (k//2)*((k//2)+1)

print(m())

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

if k%2==0 :
   print(k*k//4)
else :
   print((k+1)*(k-1)//4)

Solution (Python):


K=int(input())
if K%2==1:
    print((int(K/2))*(int(K/2)+1))
else:
    print(int(K*K/4))

Solution (Python):
K = int(input())
even = 0
odd = 0
if K % 2 == 0:
    even = odd = K / 2
else:
    even = (K - 1) / 2
    odd = (K + 1) / 2
print(int(even * odd))

Solution (Python):


k = int(input())

if k%2 == 0:
    print(int((k/2)**2))
else:
    print(int((k+1)/2*(k-1)/2))

Solution (Python):
k = int(input())
sum = 0

for i in range(1,k+1):
    if i % 2 == 0:
        for x in range(1,k+1):
            if x % 2 == 1:
                sum += 1

print(sum)