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):
N = int(input())
print((N // 2) * ((N + 1) // 2))

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

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

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

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

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

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

e=k//2
o=(k+1)//2

print(e*o)

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

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

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

Solution (Python):
import math
k=int(input())
print(k//2*(math.ceil((k/2))))

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

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

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

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

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

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

Solution (Python):
n = int(input())
odd = list()
even = list()

for i in range(n):
    if i % 2 == 0:
        even.append(i)
    elif i % 2 != 0:
        odd.append(i)

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

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

if N & 1:
  print((N // 2 + 1) * (N // 2))
else:
  print((N // 2) ** 2)

Solution (Python):
from itertools import combinations


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

    ans = 0
    for a, b in (list(combinations(range(1, n+1), 2))):
        if (a%2==0 and b%2 != 0) or (b%2==0 and a%2!=0):
            ans += 1

    print(ans)


main()

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

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

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

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

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

DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
     
def main():
    K = I()
    a = K // 2
    b = K - a
    print(a*b)

main()

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

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

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

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

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

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

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

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

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

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

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

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

even_count = num // 2

if num % 2 == 0:
    odd_count = even_count
else:
    odd_count = even_count + 1

print(odd_count * even_count)

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

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

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

print(odd * even)

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

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

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

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

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

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


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

    x = K // 2
    y = (K + 1) // 2

    print(x * y)


if __name__ == '__main__':
    main()

Solution (Python):
def main():
    k = int(input())
    if k % 2 == 0:
        even = k // 2
        odd = even
    else:
        even = k // 2
        odd = k - even

    print(even * odd)


if __name__ == "__main__":
    main()

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

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

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

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

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

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

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

cnt = 0
for i in range(1, k+ 1):
    for j in range(2, k + 1):
        if i % 2 == 1 and j % 2 == 0:
            cnt += 1

print(cnt)

Solution (Python):

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

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

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

print(int(ans))

Solution (Python):
import sys
def I(): return int(sys.stdin.readline().rstrip())


K = I()
print((K//2)*(K-K//2))

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

Solution (Python):
k=int(input());print(k*k//4)

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

Solution (Python):
import sys

K = int(sys.stdin.readline())
print((K - K // 2) * (K // 2))

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

cnt= 0
for i in range(K, 1, -1):
    for _ in range(i-1, 0, -2):
        cnt += 1
print(cnt)

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

e_n = K // 2
o_n = K - e_n

print(e_n * o_n)

Solution (Python):
K=int(input())
sum=0
i=1
while i<=K:
    i+=2
    j=2
    while j<=K:
        j+=2
        sum+=1
print(sum)

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

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

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

print(ans)

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

Solution (Python):
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

n = inp()
print(n//2 * ((n+1)//2))

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

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

Solution (Python):
K = int(input())
if K % 2 == 0:
    ans = (K//2)*(K//2)
else:
    K -= 1
    ans = (K//2)*(K//2+1)
print(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):
def main():
    K = int(input())
    oddnum = K//2
    evennum = K//2 + K%2
    ans = oddnum*evennum
    return ans
print(main())

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

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

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

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

Solution (Python):
import sys

sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int,sys.stdin.readline().rstrip().split())
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())  


K = I()
a = K//2
b = K-a
print(a*b)

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

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

print((K>>1)*((K+1)>>1))

Solution (Python):
from math import ceil
k = int(input())
print(k//2*ceil(k/2))

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

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

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())
m=n//2
if n%2==1:
  print(m*(m+1))
else:
  print(m**2)

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

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

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

Solution (Python):
import math

K = int(input())
print(math.ceil(K / 2) * math.floor(K / 2))

Solution (Python):
import sys 

k = int(input())
x=0;y=0
if k%2==0:
    x=int(k/2);y=int(k/2)
else:
    x=int(k/2)+1;y=int(k/2)
print(x*y)

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

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

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

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

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

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

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

Solution (Python):
n = int(input())
m = n % 2
o = n //2

if m ==1:
    print(o*(o+1))
else:
    print(o*o)

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

Solution (Python):
k = int(input())
s = 0
for x in range(1, k + 1):
  for y in range(1, k + 1):
    if y % 2 == 1 and x % 2 == 0:
      s = s + 1
print(s)

Solution (Python):
from math import ceil
K = int(input())
print(K//2*ceil(K/2))

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:
    ans = (k//2)*(k//2)
else:
    k += 1
    ans = (k//2)*((k-1)//2)
print(ans)

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

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

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

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

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

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

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

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())
if k%2==0:
    print((k//2)**2)
else:
    print((k//2)*(k//2+1))

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

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())
if k%2 == 0:
  print(int(k**2/4))
else:
  print(int((k**2-1)/4))

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

Solution (Python):
a = int(input())
odd = 0
even = 0
for i in range(1, a+1):
  if i%2 == 1:
    odd += 1
  if i%2 == 0:
    even += 1

print(odd*even)

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

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

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

print(res)

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

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

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

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

print(even*odd)

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():
    K = int(readline())

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

    return


if __name__ == '__main__':
    main()

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

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

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

for i in range(k + 1)[1:]:
  if i % 2 == 0:
    even += 1
  elif i % 2 == 1:
    odd += 1
print(odd * even)

Solution (Python):








K = int(input())
ans = 0
for i in range(1, K+1):
    for j in range(i+1, K+1):
        if (i % 2 == 0 and j % 2 != 0):
            ans += 1
        elif (i % 2 != 0 and j % 2 == 0):
            ans += 1
print(ans)

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

Solution (Python):
from sys import stdin, stdout


def main():
    line = stdin.readline()
    parts = line.split()
    a = int(parts[0])

    even = int(a/2)
    odd = a - even
    rta = even * odd
    stdout.write(str(rta))


main()

Solution (Python):
from sys import stdin,stdout

def main():
    line=stdin.readline()
    parts=line.split()
    a=int(parts[0])
    par=int(a/2)
    impar=int(a/2)+a%2
    stdout.write(str(par*impar))
main()

Solution (Python):
from sys import stdin, stdout

def main():
    line = stdin.readline()
    parts = line.split()
    par = int(int(parts[0])/2)
    impar = int(int(parts[0])/2) + int(parts[0])%2

    stdout.write(str(par * impar))

main()

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

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

num=k//2

if k%2==0:
    print(num**2)

else:
    print(num*(num+1))

Solution (Python):
import sys, bisect, math, itertools, string, queue, copy
import numpy as np
import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush
from fractions import gcd
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

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

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

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

Solution (Python):
import sys


stdin = sys.stdin
def ns(): return stdin.readline().rstrip()
def ni(): return int(stdin.readline().rstrip())
def nm(): return map(int, stdin.readline().split())
def nl(): return list(map(int, stdin.readline().split()))


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


if __name__ == '__main__':
    main()

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

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

g = K // 2

k = K // 2
if K % 2 != 0:
    k += 1

print(g * k)

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

Solution (Python):

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


if __name__ == "__main__":
    main()

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

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

a = K // 2 
b = a + 1 if K % 2 != 0 else a

print(a * b)

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

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

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

if k % 2 == 0:
    n = k // 2
    print(n**2)
else:
    n = k // 2
    l = n + 1
    print(n*l)

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

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

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

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

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

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

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

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

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

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

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

print(ans)

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import sys
def I(): return int(sys.stdin.readline().rstrip())

K = I()
print((K//2)**2 if K % 2 == 0 else (K**2-1)//4)

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

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

import math
n_even = math.floor(K/2)
n_odd = math.ceil(K/2)

print(n_even * n_odd)

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

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

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

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

ans = (N // 2) * ((N // 2) + (N % 2))
print(ans)

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

Solution (Python):
if __name__ == '__main__':
	n = int(input())

	tmp = n // 2
	print(tmp * (n - tmp))

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

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

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

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

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

print(int(ans))

Solution (Python):


k = int(input())

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

Solution (Python):
N = int(input())
n = -(-N // 2)
ans = n * n
if N % 2 != 0:
    ans -= n
print(ans)

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

Solution (Python):
















































def calculation(lines):
    
    N = int(lines[0])
    if N%2 == 0:
        ans = (N/2)**2
    else:
        ans = ((N+1)/2 * (N-1)/2)
    return [int(ans)]



def get_input_lines(lines_count):
    lines = list()
    for _ in range(lines_count):
        lines.append(input())
    return lines



def get_testdata(pattern):
    if pattern == 1:
        lines_input = ['3']
        lines_export = [2]
    if pattern == 2:
        lines_input = ['6']
        lines_export = [9]
    if pattern == 3:
        lines_input = ['11']
        lines_export = [30]
    if pattern == 4:
        lines_input = ['50']
        lines_export = [625]
    return lines_input, lines_export



def get_mode():
    import sys
    args = sys.argv
    if len(args) == 1:
        mode = 0
    else:
        mode = int(args[1])
    return mode



def main():
    mode = get_mode()
    if mode == 0:
        lines_input = get_input_lines(1)
    else:
        lines_input, lines_export = get_testdata(mode)

    lines_result = calculation(lines_input)

    for line_result in lines_result:
        print(line_result)

    
    
    
    
    
    
    
    



if __name__ == '__main__':
    main()

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

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

Solution (Python):
import math
k = int(input())
print(math.floor(k/2)*math.ceil(k/2))

Solution (Python):

import sys


K = int(input())
od =(K+1)//2
ev =K//2
ans =od *ev
print(ans)

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

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

e = k // 2

print(e * (k - e))

Solution (Python):
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    K = I()

    ans = (K // 2) * (K - K // 2)
    print(ans)

if __name__ == '__main__':
    resolve()

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

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

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

even_num = K//2
odd_num = K - K//2

print(even_num*odd_num)

Solution (Python):
def even(num):
	return num//2

def odd(num):
	return num//2+num%2


K=int(input())

print(even(K)*odd(K))

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

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

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

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

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

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

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

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

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

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):
k = int(input())
even = k//2
odd = k//2 + k%2
print(even * odd)

Solution (Python):
import itertools
k = int(input())
p = []
for i in range(1, k+1):
    p.append(i)
ans = 0
for v in itertools.combinations(p, 2):
    if v[0] % 2 == 0 and v[1] % 2 == 1 or v[1] % 2 == 0 and v[0] % 2 == 1:
        ans += 1
print(ans)

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

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

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

l = [0]
for i in range(1, k + 1):
    l.append(l[-1] + i // 2)


print(l[-1])

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

Solution (Python):
def main():
    k=int(input())
    k1 = len([i for i in range(k) if i % 2 == 0])
    print(k1*(k-k1))
    
if __name__ == "__main__":
    main()

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

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

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

    K = ii()
    e = K // 2
    o = (K + 1) // 2
    print(e * o)


if __name__ == '__main__':
    main()

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

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

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

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

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

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

e = k // 2
o = 0

if k%2 == 0:
    o = k//2
else:
    o = (k+1)//2
    
print(e*o)

Solution (Python):
a = int(raw_input())
odds = (a + 1)/2
even = a/2

print even * odds

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

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

E = N//2
O = N//2 + N%2

print(E*O)

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

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

print(odd * even)

Solution (Python):
import sys
K = int(input())
if not (2 <= K <= 100):
    sys.exit()

array_all = [ all for all in range(K) ]
array_even = array_all[0::2]
array_odd = array_all[1::2]

count = 0
for I in array_even:
    for J in array_odd:
        count += 1
print(count)

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

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 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)
def gcd(*numbers): reduce(math.gcd, numbers)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
count = 0
ans = 0
inf = float("inf")

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

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

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

Solution (Python):
import sys
ri = lambda: int(sys.stdin.readline())

n = ri()
a = n//2
print(a * (n-a))

Solution (Python):
import itertools 
k=int(input());ans=0
l=list(itertools.combinations([i for i in range(1,k+1)], 2));
for i in l:
  if (i[0]%2!=0 and i[1]%2==0) or (i[0]%2==0 and i[1]%2!=0):ans+=1
print(ans)

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

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

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())
if k % 2 == 0:
    print((k // 2)**2)
else:
    print(((k+1) // 2)*(k // 2))

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

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

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

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

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

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

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

Solution (Python):

def resolve():
    K = int(input())
    a = K//2
    b = K//2 if K%2!=1 else (K//2)+1
    print(a*b)

        

if '__main__' == __name__:
    resolve()

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

Solution (Python):

def even(num):
	return num//2

def odd(num):
	return num//2+num%2
K=int(input())

print(even(K)*odd(K))

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

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

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

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

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

Solution (Python):
K = int(input())    
count = 0
i = 0
j = 0

if K == 2:
    count = 1

elif K == 3:
    count = 2

elif K > 3:
    while i < K:
        i += 1
        j = i + 1

        while j <= K:
            
            count += 1
            
            j += 2
            
print(count)

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

odd = 0
eve = 0
for i in range(1,K+1):
    if i % 2 == 0:
        eve += 1
    else:
        odd += 1

print(eve * odd)

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==0:
  print((k*k)//4)
else:
  print(((k+1)*(k-1))//4)

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

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

Solution (Python):
import math
k=int(input())
print(k//2*math.ceil(k/2))

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