Problem:
 Score : 100 points    Problem Statement Given is an integer N .  Takahashi chooses an integer a from the positive integers not greater than N with equal probability.  Find the probability that a is odd.      Constraints  1 \leq N \leq 100         Input Input is given from Standard Input in the following format:  N       Output Print the probability that a is odd.
Your output will be considered correct when its absolute or relative error from the judge's output is at most 10^{-6} .        Sample Input 1 4      Sample Output 1 0.5000000000  There are four positive integers not greater than 4 : 1 , 2 , 3 , and 4 . Among them, we have two odd numbers: 1 and 3 . Thus, the answer is \frac{2}{4} = 0.5 .       Sample Input 2 5      Sample Output 2 0.6000000000       Sample Input 3 1      Sample Output 3 1.0000000000

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

if N == 1:
    print(1.0000000000)

elif N % 2 == 0:
    print(0.5000000000)

elif N % 2 == 1:
    b = N // 2 + 1
    print(float(b / N))

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

n=int(input())
print((n//2+1)/n if n%2==1 else 1/2)

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

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

print(ans)

Solution (Python):
import math
a = int(input())
print('{:.10f}'.format((math.floor(a/2)+a%2)/a))

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

if N%2==0:
    print('{:.6f}'.format(1/2))
else:
    print('{:.6f}'.format(((N+1)/2)/N))

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

b=-(-a//2)

print(b/a)

Solution (Python):

n = (int)(input())


if n % 2 == 0:
    print('{:.10f}'.format(1 / 2))
else:
    print('{:.10f}'.format((n + 1) / n / 2))

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

if   n%2 == 1:
    print((n//2+1)/n)
else:
    print(0.5)

Solution (Python):
import math

n = int(input())

if n % 2 == 0:
    print(0.5)
else:
    print(math.ceil(n/2 ) / n)

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




if(n % 2 == 0):
    print(0.5)
else:
    print((n//2+1) / n)

Solution (Python):
n=int(input())
if n==1:
  print('{:.10f}'.format(1))
else:
  cnt2=n//2
  cnt3=n-cnt2
  print('{:.10f}'.format(cnt3/n))

Solution (Python):
n = int(input())
li = []
for i in range(n):
    li.append(i+1)

odd = []
for i in range(n):
    if(li[i]%2==1):
        odd.append(li[i])

print(format(len(odd)/n, '.10f'))

Solution (Python):
n = int(input())
print('{:0<10}'.format(((n+1)//2)/n))

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

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

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

a = (n+1)//2

print(a/n)

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

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

Solution (Python):
N = int(input())
p = 1 - (N // 2) / float(N)
print(p)

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

Solution (Python):
n = int(input())
m = sum(1 for i in range(1,n+1) if i%2 == 1)
print(m/n)

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

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

Solution (Python):
n = int(input())
li = []
for i in range(1,n+1):
    li.append(i)
ki = li[::2]
print(len(ki)/len(li))

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

Solution (Python):
n=int(input())
a=list(range(1,n+1))
on=a[0::2]

print(len(on) / n)

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


n=int(input())

def evenjudge(obj):
    if obj %2!=0:
        return False
    else:
        return True

if evenjudge(n)== True:
    print(0.5)
else:
    print(((n+1)/2)/n)

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

def getN():
    return int(input())
def getList():
    return list(map(int, input().split()))
import math
from bisect import bisect_left

n = getN()

ans = n // 2 + (n % 2 == 1)

print(ans/n)

Solution (Python):
X = int(input())
a = 0
i =1
for i in range(X):
    if i%2==0:
        a = a+1
print(a/X)

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

for i in range(1,n+1):
    if i%2!=0:
        odd+=1
print(odd/n)

Solution (Python):
N = int(input())
if N%2 == 0:
  print('{:.10f}'.format((0.5)))
else:
  print('{:.10f}'.format((N//2+1)/N))

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

Solution (Python):
if __name__ == '__main__':
    a = int(input())
    if a == 1:
        print(1)
    else:
        if (a%2) == 1:
            b = a//2 +1
            print(b/a)
        else:
            b = a//2
            print(b/a)

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

if N % 2 == 0:
  print(N/2/N)
else:
  print((N - N//2)/N)

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

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


if __name__ == "__main__":
    main()

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

Solution (Python):


def solve():
    N = int(input())
    odd_num = (N+1)//2
    print(odd_num/N)

if __name__ == "__main__":
    solve()

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

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

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

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

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

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

a = int(n / 2)
b = n % 2

c = a + b

print(c/n)

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

print(a)

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

if N % 2 == 1:
    print((N + 1) / (N * 2))
else:
    print('0.5')

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

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

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

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

print(cnt/n)

Solution (Python):

import sys
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = lambda *something : print(*something) if DEBUG else 0
DEBUG = False
def main(given = sys.stdin.readline):
    input = lambda : given().rstrip()
    LMIIS = lambda : list(map(int,input().split()))
    II = lambda : int(input())
    XLMIIS = lambda x : [LMIIS() for _ in range(x)]


    N = II()
    if N % 2 == 0:
        print(0.5)
    else:

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

if __name__ == '__main__':
    main()

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

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

if N % 2 == 0:
    print((N / 2) / N)

else:
    print(((N + 1) / 2) / N)

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

if N % 2 == 0:
    a = N // 2
    b = a / N
    print(b)
else:
    a = N // 2 + 1
    b = a / N
    print(b)

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


if n % 2 == 0:
    print(0.5)
else:
    print((n - math.floor(n/2))/n)

Solution (Python):
n = int(input())
l = [i for i in range(1,n+1)]
odd = l[::2]
print(len(odd) / len(l))

Solution (Python):
import math
n = int(input())
child = math.ceil(n / 2)
print(child/n)

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

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

if n % 2 == 0:
    print(1/2)
else :
    cnt = 0
    for i in range(1,n+1):
        if i % 2 == 1:
            cnt += 1
    print(cnt/n)

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

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

if N % 2 == 0:
  
  print( 0.5 )
  
else :
   print( (((N-1)/2)+1) / N )

Solution (Python):
x=int(input())
print(1.0-(x//2)/x)

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

if N%2==0:
    print(0.5)
else:
    n = int((N+1)/2)
    print(n/N)

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

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

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





print((int(N / 2) + (N % 2)) / N)

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

if n%2 == 0:
    print(0.5)
else:
    print((n+1)/2/n)

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

Solution (Python):
A = int(input())
mod = A%2


if mod==0:
  print("0.5")
else:
  print((A+1)/(A*2))

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

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

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

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

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

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

Solution (Python):
def prob(n):
    if n%2==0:
        count=n/2
    else:
        count=(n+1)/2
    return count/n
a=int(input())
p=prob(a)
print("{0:.10f}".format(p))

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

if x == 1:
  print(1)
elif x % 2 == 0:
  print((x / 2) / x)
else:
  print((int(x/2)+1) / x)

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

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

Solution (Python):
import math
N = int(input())
odd_num = math.ceil(N / 2)
print(odd_num / N)

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

if n % 2 == 1:
  half = (n-1) / 2
  child = half+1
else:
  child = n / 2
  
print(child/n)

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

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

print(ans / n)

Solution (Python):
N  = int(input())
s = [float(i) for i in range(1,N + 1)]
cnt =0.0
for i in s:
    if i % 2 != 0:
        cnt += 1
tmp = float(len(s))
print(float(cnt/tmp))

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

if (N % 2) != 0:
    odd_num = (N - 1) / 2
    odd_p = (odd_num + 1)/N
    print(odd_p)
else:
    odd_num = N/2
    odd_p = odd_num/N
    print(odd_p)

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

Solution (Python):
n = int(input())
if n % 2 == 0:
    print(str.format('{0:.9f}', (n//2)/n))
else:
    print(str.format('{0:.9f}', ((n//2)+1)/n))

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

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

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

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

Solution (Python):

import sys


def solve(N: int):
    if N % 2 == 0:
        return 0.5
    else:
        return ((N+1) // 2 )/ N


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    p=solve(N)
    print(p)

if __name__ == '__main__':
    main()

Solution (Python):

n = int(input())
p = (n+1) // 2
print(float(p)/float(n))

Solution (Python):
N = float(input())
odd = (N+1) // 2
print(odd/N)

Solution (Python):
N = int(input())
n = [i for i in range(N + 1)]
notodds = n[1::2]
ans = len(notodds) / N

print("{:.10f}".format(ans))

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

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

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

print(ans)

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

Solution (Python):
import numpy as np

a=int(input())
print(str((float((a+1)//2)/a)))

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

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

Solution (Python):
N = int(input())
count = 0
for i in range(1, N+1):
    if i % 2 != 0:
        count += 1

print(count/N)

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

count = 0
for i in range(1,N+1):
  if i%2 != 0:
    count += 1
    
print(count/N)

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

if n%2==0:
  print(0.5)
else:
  print(math.ceil(n/2)/n)

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

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

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

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

count=0
for i in range(1,a+1):
    if i%2 == 1:
        count +=1

print(count/a)

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

if n % 2 == 0:
  print(0.500000)
else:
  print((n - n // 2) / n)

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

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

odd = 0
for i in n:
    if i % 2 == 1:
        odd += 1

print(odd/N)

Solution (Python):
import sys

N = int(sys.stdin.readline())

odds = N//2 + 1 if N&1 else N//2
s = "{:.8f}".format(odds/N)
print(s)

Solution (Python):


def main():
    N = int(input())
    print(((N + N%2) // 2) / N)
main()

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

Solution (Python):
N=int(input())
L=range(1,N+1)
G=list(filter(lambda x:x%2==0,L))

print(1-len(G)/len(L))

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

if N % 2 == 0:
    print((N/2)/N)

else:
    print(((N+1)/2)/N)

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

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

if N == 1:
    res = 1
else:
    bunsi = N // 2 + 1 if N % 2 == 1 else N // 2
    res = bunsi / N

print(res)

Solution (Python):
N = int(input())
count = 0
for i in range(N+1):
  if i%2:
    count +=1
print(count/N)

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

ev = N // 2
od = N - ev

print(od / N)

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

Solution (Python):
def main():
    n, = map(int, open(0).read().split())

    ans = ((n+1) // 2) / n
    print(ans)
    return()

if __name__ == '__main__':
    main()

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

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

Solution (Python):
n = int(input())
sum = 0
for i in range(1,n+1):
  if(i%2==1):
    sum+=1
ans = sum / n
print(ans)

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

print((n//2+1)/n if n%2==1 else (n//2)/n)

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

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

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

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

N = int(input())
sm = 0
num = 0
for i in range(1, N+1):
    sm += 1
    if i % 2 == 1:
        num += 1

print(num / sm)

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

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

Solution (Python):
import sys

input = sys.stdin.readline


def main():
    n = list(range(1, int(input()) + 1))
    print(len([i for i in n if i % 2 == 1]) / len(n))


if __name__ == "__main__":
    main()

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

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

Solution (Python):
N=int(input())
N2=N/2
if N%2==1:
  N2=(N-1)/2
print('{:.10f}'.format(1-N2/N))

Solution (Python):
def test():
    n = int(input())
    if n%2 != 0:
        print("{:.6f}".format(((n//2)+1)/n))
    else:
        print("{:.6f}".format((n//2)/n))


if __name__ == "__main__":
    test()

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

Solution (Python):
n = int(input())
count = 0
for i in range(1,n+1):
    if i % 2 == 1:
        count += 1

print(count / n)

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



if n == 1:
    print(1)
if n >=2:
    if n%2 == 0:
        print(1/2)
    elif n%2 ==1:
        print((n+1)/(2*n))

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

cnt = 0
for i in range(1, N + 1):
    if i % 2 != 0: 
        cnt += 1

print(cnt / N)

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

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

if n % 2 == 0:
    print(n/2/n)
else:
    print(-(-n//2)/n)

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

    if n % 2 == 0:
        print(0.5)
    else:
        print(float(int(n / 2)+1) / n)

if __name__ == "__main__":
    main()

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

Solution (Python):
n = int(input())
num = [x+1 for x in range(n) if x%2 != 1]
print(len(num)/n)

Solution (Python):
N = int(input())
count = 0
for i in range(N + 1):
    if i % 2 == 1:
        count = count + 1
print(count / N)

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

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

print(a/n)

Solution (Python):

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

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

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

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

print(x/N)

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

if(N%2==0):
    print(0.5)
else:
    half=N//2
    print((half+1)/N)

Solution (Python):
import math
n = int(input())
x = math.ceil(n/2)
print('%.10f'%(x/n))

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

if N % 2 == 0:
    print(0.5)
else:
    n_oddnums = (N // 2) + 1
    print(n_oddnums / N)

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

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

Solution (Python):

N = int(input())

result = 0
if (N % 2 == 0):
    result = (N // 2) / N
else:
    result = (N // 2 + 1) / N

print(result)

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

Solution (Python):
import sys


def input(): return sys.stdin.readline().strip()


def main():
    N = int(input())
    odds = (N+1) // 2
    print(odds / N)


if __name__ == "__main__":
    main()

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

if N % 2 == 0:
    print('0.5000000000')
else:
    print(round((int(N / 2) + 1) / N, 10))

Solution (Python):

import sys


def solve(N: int):
    count = 0

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

    print('{:0<12}'.format(count / N))
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    solve(N)


if __name__ == '__main__':
    main()

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

if N % 2 == 0:
    print((N//2)/N)

else:
    print((N//2+1)/N)

Solution (Python):
N=float(input());
print(1-((N//2)/N))

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

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

print(ans/n)

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

if N % 2 == 0:
    odd = N / 2
else:
    odd = (N - 1) / 2 + 1

print(odd / N)

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

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

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

Solution (Python):
def main():
    n = int(input())
    odds = 0

    for i in range(1, n+1):
        if i % 2 != 0:
            odds += 1
    print(odds/n)


if __name__ == "__main__":
    main()

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

Solution (Python):
if __name__ == "__main__":
    n = int(input())
    if n % 2 == 0:
        print(0.5)
    else:
        p = (n + 1) / (2 * n)
        print(p)

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

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

Solution (Python):

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

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

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

Solution (Python):

n = int(input())

b = 0

for i in range(n):
    if (i+1) % 2 != 0:
        b += 1

print(b/n)

Solution (Python):
import numpy as np
N=int(input())
print((N//2+N%2)/N)

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


if __name__ == "__main__":
    resolve()

Solution (Python):
def q_A(N):
	kisuu = 0
	for i in range(N):
		n = i + 1
		if n % 2 == 1:
			kisuu += 1
	density = kisuu / N
	print(density)


q_A(int(input()))

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

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

if N%2 == 0:
  print(0.5)
else:
  print(float(((N-1)/2 + 1)/N))

Solution (Python):
a=int(input())
b=sum([1 for a in range(1,a+1,2)])
print(b/a)

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

a = range(1,N+1)

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

print("{:.10f}".format(count / N))

Solution (Python):
n = int(input())
if n % 2 == 0:
    print("0.5")
elif n == 1:
    print("1")
else:
    a = n // 2 + 1
    print(a / n)

Solution (Python):
N = int(input())
n = 0
i = 1
while i <= N:
    if i % 2 == 1:
        n += 1
    i += 1
print(n/N)

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

if N % 2 == 0:
  odd_num = N // 2
else:
  odd_num = N // 2 + 1

print(odd_num / N)

Solution (Python):

N = int(input())
if N % 2 == 0:
    ans = 0.5000000000
else:
    ans = (N // 2 +1) / N
print(ans)

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

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

cnt=0

for i in range(N):
  if i%2==1:
    cnt += 1
print(1-(cnt/N))

Solution (Python):






from sys import stdin,setrecursionlimit





setrecursionlimit(10**6)
input=stdin.readline

n=int(input().rstrip())
now=0
for i in range(1,n+1):
    if i%2==1:
        now+=1
print(now/n)

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

Solution (Python):
N = int(input())
count=0
for i in range(N+1):
  if i%2 == 1:
    count += 1
odd = count/N    
print(odd)

Solution (Python):
N = int(input())
mod = N % 2

if N == 1:
    print(1.0000000)
elif mod == 0:
    print(0.500000)
elif mod == 1:
    print((float((N//2)+1)/float(N)))

Solution (Python):
n = int(input())
if n % 2 == 0: print(0.5)
elif n == 1: print(1.0)
else:
    odd = (n - 1) / 2 + 1
    print(odd / n)

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

Solution (Python):
n = int(input())
ans = [i for i in range(1,n+1,2)]
print(len(ans)/n)

Solution (Python):

from functools import reduce


n = int(input())
m = n/2
p = 1./2.
if not m.is_integer():
    p = p + 1/(2*n)
print("{0:.10f}".format(p))

Solution (Python):
import math

N = int(input())

a = math.ceil(N/2)
ans = a/N

print(ans)

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

count = 0
for x in range(1,N+1):
    if x%2==1:
        count += 1

print(count / N)

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

if (n % 2) == 0:
  print("0.5")
elif n == 1:
  print("1.0")
else:
  print(str(((n-1)/2+1)/n))

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

kisu = 0
gusu = 0

for i in range(a):
    if (i + 1) % 2 == 0:
        gusu += 1
    else:
        kisu += 1

print(kisu / a)

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

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

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

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

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

Solution (Python):
import math

N = int(input())
odds_num = math.ceil(N / 2)
print(odds_num / N)

Solution (Python):
import math

n = int(input())
print(math.ceil(n / 2) / n)

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

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

if n == 1:
    print(1)
elif n % 2 == 0:
    print(0.5)
else:
    print((n // 2 + 1 ) / n)

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

a = N if N % 2 == 0 else N+1

print((a/2)/N)

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

Solution (Python):
a, = [list(map(int, s.split())) for s in open(0)][0]
if a % 2 == 0:
    print(0.5)
else:
    print((a//2+1)/a)

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

Solution (Python):
from decimal import *

n = int(input())

if n % 2 == 0:
    print(0.5)
else:
    print(Decimal(n // 2 + 1) / Decimal(n))

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

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

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

if N == 1:
    print("{0:.10f}".format(1/1))
elif N % 2 == 0:
    print("{0:.10f}".format(1/2))
else:
    print("{0:.10f}".format((N // 2 + 1) / N))

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

Solution (Python):
from collections import defaultdict, deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys
import random
import itertools
import math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt


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


def LF(): return list(map(float, input().split()))


def LI_(): return list(map(lambda x: int(x)-1, input().split()))


def II(): return int(input())


def IF(): return float(input())


def LS(): return list(map(list, input().split()))


def S(): return list(input().rstrip())


def IR(n): return [II() for _ in range(n)]


def LIR(n): return [LI() for _ in range(n)]


def FR(n): return [IF() for _ in range(n)]


def LFR(n): return [LI() for _ in range(n)]


def LIR_(n): return [LI_() for _ in range(n)]


def SR(n): return [S() for _ in range(n)]


def LSR(n): return [LS() for _ in range(n)]


mod = 1000000007
inf = float('INF')


def A():
    a = II()
    b = a//2
    p = b/a
    if a % 2:
        print(1-p)
    else:
        print(p)

    return




def B():
    s = S()
    for i, si in enumerate(s):
        if i % 2:
            if si == "R":
                print("No")
                return
        else:
            if si == "L":
                print("No")
                return
    print("Yes")
    return




def C():
    n, k, q = LI()
    d = [0] * n
    for _ in range(q):
        a = II() - 1
        d[a] += 1
    for a in d:
        if k - (q - a) > 0:
            print("Yes")
        else:
            print("No")
    return




def D():
    n, = LI()
    a = LI()
    q = []
    for ai in a:
        heappush(q, ai)
    for _ in range(m):
        heappush(q, heappop(q) / 2)
    ans = 0
    while q:
        ans += int(heappop(q))
    print(ans)
    return




def E():
    return




def F():
    return



if __name__ == '__main__':
    A()

Solution (Python):
import math
a=int(input())
s=math.ceil(a/2)
ans=s/a
print(ans)

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

Solution (Python):


''' 
------------------------
author : iiou16
------------------------
'''
import math
def main():
    N = int(input())

    odd = (math.ceil(N / 2))
    print("{0:.10f}".format(odd / N))


if __name__ == '__main__':
    main()

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

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

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

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(odd/n)

Solution (Python):



n = int(input())

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

print(ans)

Solution (Python):
import numpy as np

N = int(input())

nums_list = np.arange(1,N+1)
odd_list = nums_list[nums_list%2==1]
print(len(odd_list)/len(nums_list))

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

Solution (Python):
n = int(input())
o, e = 0, 0
for i in range(1, n + 1):
    if i % 2 == 1:
        o += 1
    else:
        e += 1
print(o/n)

Solution (Python):

from math import floor
n = int(input())
if n == 1:
    print(1)
elif n % 2 == 0:
    print(0.5)
else:
    print((floor(n/2) + 1)/n)

Solution (Python):
import sys
sys.setrecursionlimit(int(1e6))

N = int(input())

if (N % 2):
    odd_num = N // 2 + 1
    print(odd_num/N)
else:
    print("0.5")

Solution (Python):
N = int(input())
ans = -(-N // 2) / N
print("{:.9f}".format(ans))

Solution (Python):
N = int(input())
print(len([1 for i in range(N) if (i+1)%2==1])/N)

Solution (Python):
n = int(input())
li = range(1, n+1)
odd = 0
for i in li:
    if i % 2 == 1:
        odd += 1
ans = odd / n
print(ans)

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

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

if N%2==0:
  print(1/2)

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

Solution (Python):
import numpy as np

N = int(input())

if(N % 2 == 0):
    print(float(0.5))
else:
    print((N // 2 + 1) / N)

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

Solution (Python):

import sys


def solve(N: int):
    print(len([i for i in range(1,N+1) if i%2 == 1])/N)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    solve(N)

if __name__ == '__main__':
    main()

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

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

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

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

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

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

if n == 1:
    print(1.0)
elif n % 2 == 0:
    print(0.5)
else:
    print((n//2+1)/n)

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

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

Solution (Python):
N = int(input())
l = list(range(1, N + 1))
n = 0
for i in l:
    if i % 2 == 1:
        n +=1
print(n / N)

Solution (Python):
import math as m
N = int(input())

print(m.ceil((N/2))/N)

Solution (Python):

import sys


def solve(N: int):
    count = 0
    for i in range(1, N + 1):
        if i % 2 != 0:
            count += 1
        else:
            pass

    result = count / N

    print(result)

    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word

    tokens = iterate_tokens()
    N = int(next(tokens))  
    solve(N)


if __name__ == "__main__":
    main()

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

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