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

Solution (Python):
import math
a = int(input())
print((a - math.floor(a // 2)) / a)

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

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

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

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

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

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

Solution (Python):


n = int(input())

if n % 2 == 0:
    print(0.5)
else:
    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 == 1:
  odd = (n-1) // 2 + 1
  even = (n-1) // 2
  print(odd/(odd+even))
else:
  print(0.5)

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

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

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

Solution (Python):
import sys

N=int(sys.stdin.readline().rstrip())
even=N//2
print(1-(even/N))

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

Solution (Python):
from math import ceil

n = int(input())

print(ceil(n / 2) / n)

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

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

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

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

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

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

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

N = int(input())

OddCount = N // 2 + N % 2
print(OddCount / 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())

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

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

print(c/N)

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

even_qty = n//2
odd_qty = n//2

if n % 2 == 1:
	odd_qty += 1


print("{:.10f}".format(odd_qty/n))

Solution (Python):

n = int(input())
odd_num = n//2
if n % 2 != 0:
    odd_num += 1
print(odd_num/n)

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

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

print (even/(even+odd))

Solution (Python):
n=int(input())
ans=0
for i in range(1,n):
    if i%2: ans+=1
print(1-ans/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())

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

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

Solution (Python):
N = int(input())
odd = 0
count = 0
ans = 0.0
for i in range(N):
    count +=1
    if(count %2 == 1):
        odd += 1
    else:
        continue
ans = odd /count
print(round(ans,6))

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:
    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+1)/(2*n))

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

print(count/N)

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

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

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

odds = len([x for x in range(1, n + 1) if x % 2 == 1])
print(odds / n)

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

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

Solution (Python):
N = int(input())
cnt=0
for n in range(N):
    if (n+1)%2==1:
        cnt+=1

print(cnt/N)

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

Solution (Python):
N = int(input().split()[0])

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

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

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

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

Solution (Python):
N = int(input())
print(str(round(((N+1) // 2) / N, 7)))

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

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

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

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

Solution (Python):
import math
a=int(input())
if(a%2==0):
  print(0.5000)
else:
  print(math.floor(a/2+1)/a)

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

if n%2==0:
    print(1/2)
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%2==1:
  print("{}".format((N//2 + 1) / N))
else:
  print("{}".format((N//2) / N))

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

Solution (Python):

N=float(input())

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

print(float(count/N))

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

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

if a%2 == 0 :
  print("0.5000000000") 
else  :
  temp = a//2 +1 
  temp = temp/a 
  print(temp)

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

answer = 1 - (n // 2) / n 
print(answer)

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

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

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

evens = N//2
odds = N - evens

result = odds / N

print(result)

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

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

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

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-n//2)/n)

Solution (Python):
num = float(input())
num2 = int((num+1)/2)

print(num2/num)

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

if __name__ == '__main__':
    solve()

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

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

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==1):
  print("1.000000")
  exit()
if(n%2==0):
  print("0.500000")
  exit()
print((n//2+1)/n)

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

Solution (Python):
import numpy as np
N = int(input())
print("{0:.10f}".format(np.ceil(N/2) / N))

Solution (Python):


def main():
    N  = int(input())
    count = 0
    for i in range(1,N+1):
        if i%2 == 1: count += 1
    print(count/N)
        
if __name__ == '__main__':
    main()

Solution (Python):
import math

N = int(input())

ans = math.ceil(N / 2.0) / N
print(ans)

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

Solution (Python):
N = int(input())
print(1 - (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())
if n%2==0:
    print(0.5)
else:
    print(float((n+1)//2)/n)

Solution (Python):


N = int(input())

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

Solution (Python):


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

    print('{:.10f}'.format(((N+1)//2)/N))


if __name__ == '__main__':
    main()

Solution (Python):
import math

n = int(input())

ret = math.ceil(n/2)/n

print(ret)

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

count = 0

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

print(count/N)

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

Solution (Python):
import math

N = int(input())

if N % 2 == 0:
    print('0.5', end='')
else:
    print(math.ceil(N/2) / N, end='')

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

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

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

a = 0
b = 0

if n%2 == 0:
		a = n/2
		b = n/2
else:
		b = int(n/2)
		a = n-b

print(a/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())
print(1 - (N // 2) / N)

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

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

print(p)

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

Solution (Python):
from collections import Counter, defaultdict
import sys
sys.setrecursionlimit(10 ** 5 + 10)

from math import factorial
import heapq, bisect
import math
import itertools


import queue
from collections import deque



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






if __name__ == '__main__':
    main()

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

L = list(range(1,N+1))

od = 0
for i in L:
    if i%2 == 1:
        od += 1

print(od/N)

Solution (Python):
A = int(input())
k = 0
for i in range(A):
		if (i + 1) % 2 != 0:
				k += 1

print(k / A)

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)

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

main()

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

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

Solution (Python):
import sys
input = sys.stdin.readline
n = int(input())
if n%2 == 0:
  a = 1/2
  print(a)
else:
  a = ((n-1)//2 + 1)/n
  print(a)

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

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

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

if __name__ == '__main__':
    print(solve())

Solution (Python):
import sys
from collections import deque
import copy
import math
def get_read_func(fileobject):
    if fileobject == None :
        return raw_input
    else:
        return fileobject.readline



def main():
    if len(sys.argv) > 1:
        f = open(sys.argv[1])
    else:
        f = None
    read_func = get_read_func(f);
    input_raw = read_func().strip().split()
    [N] = [int(input_raw[0])]
    print float((N / 2) + (N % 2)) / float(N)


if __name__ == '__main__':
    main()

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

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

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


num_odd = N // 2 + N % 2

print(num_odd / N)

Solution (Python):
N = int(input())
ans = float(0)
d = int(0)

if N%2==1:
    d = N//2 +1
else:
    d = N//2

ans = d/N

print(ans)

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

Solution (Python):


n = int(input())

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

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

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

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

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

list = list(i for i in range(1,n+1))

even = 0
odd = 0

for i in range(n):
  if list[i] % 2 == 0:
    even +=1
  else:
    odd += 1

print(odd / (even + odd))

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

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

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

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

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

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

Solution (Python):

N = int(input())

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

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

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

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

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

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

print((n-(n//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):
n = int(input())

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

print(odd/(even+odd))

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

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

A = list(range(1, N+1))[1::2]
B = list(range(1, N+1))[0::2]


print(len(B)/N)

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

print(k/(k+g))

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

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

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

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

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

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

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

print(ceil((n/2))/n)

Solution (Python):


N = int(input())

count = 0

for _ in range(1, N + 1, 2):
    count += 1

print(count / 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)
elif n%2==0:
  print(0.5)
else:
  print((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):
N = int(input())

lst = [i for i in range(1,N+1)]

cnt = 0

for i in lst:
  if i %2 != 0:
    cnt += 1

print(cnt/N)

Solution (Python):
import sys

n = int(sys.stdin.readline())
odd =0
for i in range(1, n+1):
    if i %2 ==1:
        odd +=1
print(odd/n)

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

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

Solution (Python):


import sys

s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    N = i2n()
    print(1-N//2/N)
    return

main()

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

print(((A + 1) // 2) / A)

Solution (Python):
def main():
  n = int(raw_input())
  ods = 0.0
  for x in xrange(n+1):
    if x % 2 > 0:
      ods += 1.0
  print(ods/n)

main()

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

print(((n + 1) // 2 ) / n)

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

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 == 1:
    print(1)
    exit(0)

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
n=int(input())
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):
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())
ans = 0.5 if N%2 == 0 else ((N//2)+1)/N
print(ans)

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

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

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

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

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


n = int(input())
print( (n-n//2) / n )

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

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

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

print(len([i for i in range(1, N+1) if i % 2 != 0]) / N)

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


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

print(odd / N)

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

a = N // 2 + N % 2

print(a / N)

Solution (Python):
n = int(input())
print(1/2 if n % 2 == 0 else (n + 1) / (2 * 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(1/2)
else:
    print((n+1)/(2*n))

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

mynum = 0

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

print(mynum/N)

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

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

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

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

print((n // 2 + n % 2)/n)

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

kisu = math.ceil((N / 2))
print(kisu / N)

Solution (Python):

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

main()

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

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

ans = 0



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

print(ans/N)

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

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

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

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

print((-(-n // 2) / n))

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

Solution (Python):
from math import ceil
N = int(input())

odd = ceil(N/2)
print(odd/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())
result = 0
for i in range(1,n+1):
    if i % 2 == 1:
        result += 1
print(result/n)

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

import math

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)
elif n==1:
  print(1)
else:
  print(((n-1)//2+1)/n)

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

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

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

import numpy as np

def main():
    n = int(input())
    odd = 0
    even = 0
    for i in range(1, n + 1):
        if i % 2 == 0:
            odd += 1
        else:
            even += 1

    print(even/n)


if __name__ == '__main__':
    main()

Solution (Python):


def readInts():
  return [int(s) for s in input().split(" ")]

def main():
  N = readInts()[0]

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

Solution (Python):
def main():
    N = int(input())
    if N&1:
        odd = (N // 2) + 1
    else:
        odd = N // 2
    print(odd/N)

if __name__ == '__main__':
    main()

Solution (Python):
import sys,queue,copy
sys.setrecursionlimit(10**8)
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())

N = int(input())

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

print(num/N)

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

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

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

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

Solution (Python):













N = int(input())
odds = [i for i in range(1, N + 1) if i % 2 == 1]
print(len(odds) / 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((int(N/2)+1)/N)

Solution (Python):


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

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

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

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

Solution (Python):
def main():
    import math
    n = int(input())
    print(math.ceil(n/2.0)/n)

if __name__ == "__main__":
    main()

Solution (Python):






def main():

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




if __name__ == "__main__":
    main()

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

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

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

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

    print(tmp/N)


if __name__ == "__main__":
    main()

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

Solution (Python):
import sys

n = float(raw_input())

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

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

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

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

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

Solution (Python):
import sys
from io import StringIO
import unittest

class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = """4"""
        output = """0.5000000000"""
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = """5"""
        output = """0.6000000000"""
        self.assertIO(input, output)
    def test_入力例_3(self):
        input = """1"""
        output = """1.0000000000"""
        self.assertIO(input, output)
def resolve():
    n=int(input())
    if n%2==0:
        print(0.5)
    else:
        print((int(n/2)+1)/n)
if __name__ == "__main__":
    resolve()

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

N = int(readline())

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

Solution (Python):
N = int(input())
a = N//2
print((N-a)/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%2==0:
    print(0.5)
else:
    print((n+1)/2/n)

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

Solution (Python):
n=int(input())
if n%2==0:
    print(1/2)
else:
    print((n+1)/(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):
import math
N = float(input())
if (N % 2 == 0):
    print(0.5)
else:
    print(math.ceil(N / 2) / N)

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

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

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

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

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

if n % 2 == 0:
    print(0.5)
else:
    print(len([i for i in range(1, n+1) if i % 2 == 1]) / n)

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

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

Solution (Python):

import sys

import heapq
import re
import bisect
import random
import math
import itertools
from collections import defaultdict, deque
from copy import deepcopy
from decimal import *

readl= lambda: list(map(int, sys.stdin.readline().split()))
readt= lambda: tuple(map(int, sys.stdin.readline().split()))
read = lambda: sys.stdin.readline().rstrip()
readi = lambda: int(read())
readmi = lambda: map(int, sys.stdin.readline().split())
readms = lambda: map(str, sys.stdin.readline().split())


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

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

Solution (Python):
import math, string, itertools, fractions, heapq, collections, re,  array, bisect, sys, random, time, copy, functools, os, pdb
sys.setrecursionlimit(10**7)
from queue import PriorityQueue
inf = 10 ** 20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def 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 _pf(s): return print(s, flush=True)
def perr(s): return print(s, file=sys.stderr)

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

Solution (Python):
n = int(input())
if n%2 == 1:
  k = (n+1)//2
  print(k/n)
else:
  k = n//2
  print(k/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):
from sys import stdin

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

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

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

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

Solution (Python):
n=int(input())
if n==0:
    print(1)
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())
if 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):

import sys


def solve(N: int):
    print(((N+1)//2)/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):



import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

N = int(input())

ans = 0
for n in range(1, N + 1):
    ans += n % 2
print("{:.12f}".format(ans / N))

Solution (Python):

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

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

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

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

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

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

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

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

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

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

Solution (Python):
from sys import stdin
import numpy as np




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


if __name__ == "__main__":
    main()

Solution (Python):
N = int(input())
if N%2 == 0:
  print(1/2)
else:
  print(((N+1)/2)/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):
import math
n = int(input())
print(math.ceil(n/2) / n)

Solution (Python):
import math

n = int(input())

num = math.ceil(n / 2)

print(num / n)

Solution (Python):
from sys import stdin

n = int(stdin.readline().rstrip())
if n == 1:
    print(1)
elif n%2 == 0:
    print(0.5)
else:
    print(1-(n//2)/n)

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
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 II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7

debug = True


def dprint(*objects):
    if debug == True:
        print(*objects)

def solve():
    N = II()
    if N == 1:
        print(1)
        return

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

solve()