Problem:
 Score : 200 points    Problem Statement Given is a sequence of N integers A_1, \ldots, A_N .  Find the (multiplicative) inverse of the sum of the inverses of these numbers, \frac{1}{\frac{1}{A_1} + \ldots + \frac{1}{A_N}} .      Constraints  1 \leq N \leq 100  1 \leq A_i \leq 1000         Input Input is given from Standard Input in the following format:  N  A_1  A_2  \ldots  A_N       Output Print a decimal number (or an integer) representing the value of \frac{1}{\frac{1}{A_1} + \ldots + \frac{1}{A_N}} .  Your output will be judged correct when its absolute or relative error from the judge's output is at most 10^{-5} .        Sample Input 1 2
10 30      Sample Output 1 7.5  \frac{1}{\frac{1}{10} + \frac{1}{30}} = \frac{1}{\frac{4}{30}} = \frac{30}{4} = 7.5 .  Printing 7.50001 , 7.49999 , and so on will also be accepted.       Sample Input 2 3
200 200 200      Sample Output 2 66.66666666666667  \frac{1}{\frac{1}{200} + \frac{1}{200} + \frac{1}{200}} = \frac{1}{\frac{3}{200}} = \frac{200}{3} = 66.6666... .  Printing 6.66666e+1 and so on will also be accepted.       Sample Input 3 1
1000      Sample Output 3 1000  \frac{1}{\frac{1}{1000}} = 1000 .  Printing +1000.0 and so on will also be accepted.

Solution (Python):
import sys 
stdin = sys.stdin
 
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
s = lambda h: [list(map(int, stdin.readline().split())) for i in range(h)]

n = ni()
a = na()
bunbo = 0
for ai in a:
     bunbo += 1/ai
print(1/bunbo)

Solution (Python):
a=int(input())
M = list(map(lambda x: int(x),input().split()))
s=0
for i in M:
  
  s += 1/i

print(1/s)

Solution (Python):
import decimal


n = int(input())
As = list(map(lambda x: decimal.Decimal(int(x)), input().split()))
As_inv = list(map(lambda x: decimal.Decimal(1) / x, As))
print(decimal.Decimal(1) / sum(As_inv))

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

print(1 / sum([1/ a for a in A]))

Solution (Python):
n=int(input())
l=list(map(int,input().split()))
k=1
s=0
for i in l:
  k*=i
for q in l:
  s+=(k//q)
print(k/s)

Solution (Python):
def main():
    N = int(input())
    A = [int(s) for s in input().split()]
    print(1 / sum(1 / a for a in A))


if __name__ == '__main__':
    main()

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
d=sum(1/a[i] for i in range(n))
print(1/d)

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

print(1 / sum(1 / x for x in a))

Solution (Python):

N = int(input())
A = list(map(int,input().split()))
sum = 0
for i in range(N):
    sum += 1/A[i]

print(1/sum)

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

sigma = 0
for i in range(n):
    sigma += 1/(a[i])
print(1/sigma)

Solution (Python):


import copy
import sys
import math

n = int(input())
tmp = input().split()
hoge = list(map(lambda a: int(a), tmp))

total=1
for i in range(0,n):
	total*=hoge[i]

ret=0
for i in range(0,n):
	ret+=total/hoge[i]

print(total/ret)

Solution (Python):

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

power = 1
for n in range(len(A)):
	power *= A[n]
sum = 0
for n in range(len(A)):
	sum += power/A[n]

print(power/sum)

Solution (Python):
a=[]
b=int(input())
c=0
for x in input().split(" "):
    a.append(int(x))

for x in a:
    c+=1/x
print(1/c)

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

for i in A:
    ans += 1/i

print(1/ans)

Solution (Python):
n=int(input())
su = 0
lista = [int(i) for i in input().split()]
for i in range(n):
    a=lista[i]
    su += 1/a
print(1/su)

Solution (Python):
N = int(input())
A = [int(i) for i in input().split()]
tmp = 0
for i in range(N):
  tmp += 1/A[i]
ans = 1 / tmp
print(ans)

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

aux = 0.0

for i in arr:
    aux += 1.0/i

aux = 1/aux

print(aux)

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

m = 1
for i in ls:
  m*=i

j =0
for i in ls:
  j += m/i
print(m/j)

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

arr = []
for i in a:
    arr.append(1 / i)

print(1 / sum(arr))

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

A_inv = [1/x for x in A]
A_sum = sum(A_inv)
print(1/A_sum)

Solution (Python):


N = int(input())

A = list(map(int,input().split()))

head = 0

for i in A:

    head += 1 / i

print (1 / head)

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

lst = list(map(int, input().split()))

low = 0
for i in range(N):
  low += 1 / lst[i]

print(1 / low)

Solution (Python):
import numpy as np

N=int(input())
A=np.array(input().split(),dtype=np.int32)

S=0
for a in A:
    S+=1.0/a

print(1.0/S)

Solution (Python):
n = int(input())
A = [int(i) for i in input().split()]
total = 0
for a in A:
    total += 1/a
ans = 1 / total
print(ans)

Solution (Python):
n=int(input())
s=0
L=list(map(int,input().split()))




for i in range(n):
  s+=1/L[i]
  
print(1/s)

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
ans = 1
for i in a:
    ans *= i

k = [ans/a[i] for i in range(n)]
ans /=sum(k)
print(ans)

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
A_inv = [1/a for a in A]
print(1/sum(A_inv))

Solution (Python):

import sys


def solve(N: int, A: "List[int]"):
    ans = sum([1/i for i in A])
    print(1/ans)
    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))  
    A = [ int(next(tokens)) for _ in range(N) ]  
    solve(N, A)

if __name__ == '__main__':
    main()

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

k = 0
for i in range(n):
    k+=(1/a[i])

print(1/k)

Solution (Python):
wa=0
A = int(input())
x = list(map(int, input().split()))
for i in range(A):
    wa=wa+(1/x[i])
kotae=1/wa
print(kotae)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
sum = 0
for i in a:
    sum += 1.0 / i
    
print( 1.0 / sum)

Solution (Python):
num = int(input())
box1 = [int(s) for s in input().split()]
box = []
for i in box1:
  box.append(1/i)
print(1/sum(box))

Solution (Python):
import math

n = int(input())
a = list(map(int, input().split()))
ans = 0
for i in range(n):
  ans += 1.0/a[i]
  
ans = 1.0/ans
print(ans)

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

for a in A:
    A_gyakusu.append(1/a)

print(1/sum(A_gyakusu))

Solution (Python):
def main():
  n=int(input())
  a=list(map(int,input().split()))
  total=0
  for i in range(n):
    total+=1/a[i]
    
  print(1/total)  
if __name__ == "__main__":
    main()

Solution (Python):
N = int(input())
a_list = input().split()
r_sum = 0
for a in a_list:
    fa = float(a)
    r_sum += 1.0 / fa
print(1.0 / r_sum)

Solution (Python):
from fractions import Fraction

n = int(input())

inputs = [int(i) for i in raw_input().split()]

print(float(Fraction(1, sum([Fraction(1, x) for x in inputs]))))

Solution (Python):
N = int(input())
A = input().split()
Ad = [1/int(i) for i in A]
b=0
for i in Ad:
  b=b+i
print(1/b)

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

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

s, m = 0, 1
for a in A:
    s += 1.0/a

print(1/s)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
ans = 0
for i in range(len(a)):
    ans += 1/a[i]

print(1/ans)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
Z = 0
for i in A:
    Z += 1 / i
print(1 / Z)

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

Solution (Python):
from scipy import stats
import sys
def main():
    input = sys.stdin.readline
    n = int(input())
    As = list(map(int, input().split()))

    """
    ansinv = 0
    for i in range(n):
        ansinv += 1 / as[i]

    ans = 1 / ansinv
    """
    ans = stats.hmean(As) / n
    print(ans)
 
if __name__ == '__main__':
    main()

Solution (Python):
n=int(input())
hoge=list(map(int,input().split()))
bunb=0
for i in hoge:
  bunb+=1/i
  
print(1/bunb)

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

ua = 0

for a in A:
    ua += (1/a)

print(1/ua)

Solution (Python):
def solve(N, As):
    m = 1
    for a in As:
        m *= a
    k = 0
    for a in As:
        k += m / a
    return m / k

if __name__ == "__main__":
    N = int(input())
    As = list(map(int, input().split(" ")))
    print(solve(N, As))

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

ue = 1
for i in A:
    ue *= i

shita = 0
for i in range(N):
    tmp = 1
    for j in range(N):
        if i == j: continue
        tmp *= A[j]
    shita += tmp

print(ue/shita)

Solution (Python):
def main():
    n= int(input())
    ls = [int(x) for x in input().split()]
    bunsi = 1
    for i in range(n):
        bunsi *= ls[i]
    bunbo = 0

    for i in range(n):
        bunbo += bunsi/ls[i]
    print(bunsi/bunbo)

if __name__ =="__main__":
    main()

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

def gyaku(num):
  return 1 / num
bunbo = 0
for i in range(n):
  bunbo += gyaku(A[i])
print(1 / bunbo)

Solution (Python):

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

r = 0
for i in a:
    r += 1 / i

print(1/r)

Solution (Python):
n = int(input())
a = list(map(int , input().split()))
ans = 0
for i in a:
  ans += float(1 / i)

ans = float(1/ans)
print(ans)

Solution (Python):
n=int(input())
a=list(map(float,input().split()))
z=0
for i in range(n):
    z += 1/a[i]
print(1/z)

Solution (Python):
def main():
  Nums = int(input())
  numbersList = map(int,input().split())
  
  sum_inv = sum((1.0/num for num in numbersList))

  print(1.0/sum_inv)

if __name__ == "__main__":
  main()

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
r = 0
for i in a:
    r += 1 / i
print(1 / r)

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

r = 0
for a in A:
    r += 1 / a

result = 1 / r

print(result)

Solution (Python):
N=int(input())
a=list(input().split())
s=0
for i in range(N):
    a[i]=int(a[i])
for i in range(N):
    s+=1/a[i]
ans=1/s
print(ans)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
B = 0
for i in A:
    B += 1/i

print(1/B)

Solution (Python):
import numpy as np
n = int(input())
a = np.array(list(map(int,input().split())))
a = 1/a
print(1/sum(a))

Solution (Python):
N = int(input())
A = [int(x) for x in input().split()]
ans = 0
for a in A:
    ans += 1/a
print(1/ans)

Solution (Python):

"""
Spyder Editor

This is a temporary script file.
"""
n = int(input())
a = input().split()
sp = 0
for r in a:
    r = int(r)
    sp += (1 / r)
print(1 / sp)

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

bunbo = 0
for i in range(n):
	bunbo += (1/a[i])

print(1/bunbo)

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

bunbo = 0
for i in a:
    bunbo += 1/i
    
print(1/bunbo)

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

gyaku_A=0
for a in A:
    gyaku_A+=1/a
    
ans=1/gyaku_A

print(str(ans))

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

sum = 0
for i in args:
    sum = sum + 1/i

print(1/sum)

Solution (Python):






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





sum_ = 0
for n in A:
    sum_ += 1/n
print(1/sum_)

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
total = 0
for a in A:
    total += 1/a
print(1/total)

Solution (Python):
import numpy as np
N = int(input())
A = 1 / np.sum(1/np.array(list(map(int,input().split()))))
print(A)

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


mother = 0
for i in range(N):
    mother += 1/A[i]

print(1/mother)

Solution (Python):
n=int(input())
A=list(map(int,input().split()))
print(1/sum(1/A[i] for i in range(n)))

Solution (Python):
num = int(input())
list = input().split()
goukei = 0
for i in range(num):
  goukei = goukei + (1/int(list[i]))

print(1/goukei)

Solution (Python):



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


ans = 0
for i in range(N):
    ans += 1 / A[i]


print(1 / ans)

Solution (Python):
N = int(input())
a = list(map(float, input().split(" ")))

r = 0
for b in a:
  r = r + 1/b

print(1/r)

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

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

print(1/sum([1/x for x in a]))

Solution (Python):
N=int(input())
A=map(int, input().split())
Ainv=[1.0/float(a) for a in A]
Ainvsum=sum(Ainv)
print("{}".format(1.0/Ainvsum))

Solution (Python):
def calc_reverse(n):
    return n ** (-1)

n = int(input())
a = [int(inp) for inp in input().split()]
*a, = map(calc_reverse, a)
print(sum(a) ** (-1))

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

reverse_A = []
for i in range(N):
  reverse_A.append(1/A[i])

print(1/sum(reverse_A))

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

A = [int(i) for i in input().split()]
sum = 0
for a in A:
    sum += 1 / a

print(1/sum)

Solution (Python):


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

A = [1 / x for x in A]

print(1/sum(A))

Solution (Python):
n = int(input())
a = map(int,input().split())
s = 0
for i in a:
    s +=1/i
print(1/s)

Solution (Python):
from sys import stdin


def main():
    _ = int(stdin.readline().rstrip())
    As = [int(x) for x in stdin.readline().rstrip().split()]
    sum_ = sum([1 / x for x in As])
    print(1 / sum_)


if __name__ == '__main__':
    main()

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

denomi = 0
for a in al:
    denomi += 1/a

print(1/denomi)

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

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
b=0.0
for i in a:
  b+=1/i
print(1/b)

Solution (Python):
N = int(input())
A = list(map(lambda x: 1 / int(x), input().split()))
print(1 / sum(A))

Solution (Python):
def resolve():
    n = int(input())
    a = list(map(int, input().split()))
    res = 0

    for i in range(n):
        res += 1 / a[i]

    print(1/res)
resolve()

Solution (Python):
n = int(input())
A = list(map(int, input().split()))
denom = 0
for a in A:
    denom += 1/a
print(1/denom)

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

A = list(map(int, input().split()))


ans = 0

for a in A:
    ans += (1/a)

print(1/ans)

Solution (Python):
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  

n = ni()
aaa = na()
m = 1
for a in aaa:
    m *= a
s= 0
for a in aaa:
    s += (m/a)
print(m/s)

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

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
ans = 0
for i in a:
    ans += 1 / i
ans = 1 / ans
print(ans)

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

for i in a:
    a2+=1/i

print(1/a2)

Solution (Python):
n=int(input())
print(1/sum(1/int(i) for i in input().split()))

Solution (Python):
N=int(input())
A=list(map(int, input().split()))
s = 0.0
for a in A:
  s += (1 / a)
print(1 / s)

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

n2 = [int(i) for i in input().split()]

t1 = 0

for i1 in range(n1):
    t1 += 1 / n2[i1]

r1 = 1 / t1

print(r1)

Solution (Python):
n = int(input())
print(1.0/sum([1.0/float(i) for i in input().split()]))

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

sum=0

for i in range(N):
    sum+=(1/l[i])
    
print(1/sum)

Solution (Python):
N = int(input())
As = [int(i) for i in input().split()]

reverse_list = []

for A in As:
    reverse_list.append(1/A)

print(1/sum(reverse_list))

Solution (Python):



n = int(input())

a = map(int,input().split())

a = [1/i for i in a]

a = 1/sum(a)

print(a)

Solution (Python):
def solve():
    a = read()
    result = think(a)
    write(result)


def read():
    n = read_int(1)[0]
    return read_int(n)


def read_int(n):
    return list(map(lambda x: int(x), read_line().split(' ')))[:n]


def read_float(n):
    return list(map(lambda x: float(x), read_line().split(' ')))[:n]


def read_line(n=0):
    if n == 0:
        return input().rstrip()
    else:
        return input().rstrip()[:n]


def think(a):
    buf = 0
    for d in a:
        buf += 1 / d
    return 1 / buf


def write(result):
    print(result)


if __name__ == '__main__':
    solve()

Solution (Python):



import sys
input = sys.stdin.readline


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

    for i in map(int, input().split()):
        a.append(i)

    tmp = 0
    for i in a:
        tmp += 1 / i

    print(1 / tmp)


if __name__ == '__main__':
    main()

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
s=sum(1/a[i] for i in range(n))
print(1/s)

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
b = [1/a[i] for i in range(n)]
print(1/sum(b))

Solution (Python):
from math import fsum
N=int(input())
A=[int(x) for x in input().split()]
print(1/fsum(1/a for a in A))

Solution (Python):
def main():
    _ = int(input())
    A = [int(x) for x in input().split()]
    ans = 0.0
    for a in A:
        ans += (1 / a)
    
    print(1 / ans)

if __name__ == "__main__":
    main()

Solution (Python):
N= int(input())
A=list(map(int, input().split()))
ans=0
for a in A:
    ans+=1/a
print(1/ans)

Solution (Python):
n = int(input())
a = map(int,input().split())
su = 0
for i in a:
    su += 1.0 / i
print(1.0/su)

Solution (Python):
n=int(input())
A=list(map(int, input().split( )))
sm=0
for i in range(n):
    sm+=1/A[i]
ans=1/sm
print(ans)

Solution (Python):
N=int(input())
a=list(map(int,input().split()))
b=[0]*N
for i in range(N):
    b[i]=1/a[i]
print(1/sum(b))

Solution (Python):
N = int(input())
A_list = list(map(int,input().split()))
A_gyakusu = [1/i for i in A_list]
A_gyakusu_souwa = sum(A_gyakusu)
print(1/A_gyakusu_souwa)

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

def main():
    n = int(input())
    a_list = list(map(lambda x: 1 / x, map(int, input().split())))

    print(1 / sum(a_list))

if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
s = 0
for i in range(N):
    s = s + 1 / A[i]

print(1 / s)

Solution (Python):
N = int(input())
a = list(1/int(i) for i in input().split())

print(1/sum(a))

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

for i in range(N):
    tmp += 1/(A[i])

print(1/tmp)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
ans = sum([1 / i for i in a])
print(1 / ans)

Solution (Python):
import math
import sys
import queue
from collections import Counter
from itertools import accumulate
from fractions import gcd
from functools import reduce


def lcm(a, b):
    return a * b // gcd(a, b)

def combination_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

def permutations_count(n, r):
    return math.factorial(n) // math.factorial(n - r)

sys.setrecursionlimit(10000)

mod = 1000000007

"""

a = 100
b = 0.987654321
print("{0:06d}-{1:6f}".format(a,b))
000100-0.987654


char_list = list("abcd") 



    = sys.stdin.readline().rstrip()
    = list(sys.stdin.readline().rstrip())


    = int(sys.stdin.readline())
    = map(int, sys.stdin.readline().split())
    = list(map(int, sys.stdin.readline().split()))
    = [list(map(int,list(sys.stdin.readline().split()))) for i in range(N)]
"""

if __name__ == "__main__":
    n= int(sys.stdin.readline())
    a= list(map(float, sys.stdin.readline().split()))
    l=[]
    for i in a:
        t=1/i
        l.append(t)
    ans=1/sum(l)
    print(ans)

Solution (Python):
N=int(input())
xs = list(map(int, input().split()))
xs = 1/sum([1/x for x in xs])
print(xs)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
bunbo = 0
for i in A:
  bunbo += 1 / i
print(1 / bunbo)

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

bo = 0

for ai in a:
    bo += 1/ai

si = 1 / bo

print(si)

Solution (Python):
n = int(input())
li = list(map(int,input().split()))
ans1 = 0
for i in li:
  ans1 += 1/i
print(1/ans1)

Solution (Python):
import numpy as np
N = int(input())
A = np.array(list(map(int, input().split())))
B = sum(1/A)
print(1/B)

Solution (Python):
import sys
input = sys.stdin.readline
n = input()
a = list(map(int, input().split()))
print(1/sum([1/ai for ai in a]))

Solution (Python):
N=int(input())
A=list(map(int,input().split()))
B=[]
for i in range(N):
    x=1/A[i]
    B.append(x)
C=sum(B)
print(1/C)

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

for ai in a:
  ans += 1 / ai

print(1 / ans)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
ans = 0
for e in a:
  ans += 1/e
print(1/ans)

Solution (Python):

N = int(input())
A = list(map(int, input().split(" ")))

A_rev = 0
for i in range(N):
    A_rev += 1 / A[i]

print(1 / A_rev)

Solution (Python):
n = int(input())
a = [int(e) for e in input().split()]
v = 0
for i in range(n):
  v += 1 / a[i]
print(1 / v)

Solution (Python):


if __name__ == '__main__':
    N = int(input())
    A = list(map(int, input().split()))

    sum = 0
    for i in range(N):
        sum += 1/A[i]

    sum = 1/sum

    print(sum)

Solution (Python):
import sys
N = int(sys.stdin.readline())
a_inv = 0
for a in sys.stdin.readline().split():
  a_inv += 1/int(a)
print(1/a_inv)

Solution (Python):
n = int(input())
A = list(map(int, input().split()))
ans = 0
for a in A:
    ans += 1/a

print(1/ans)

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

ans = 1 / A[0]
for i in range(1, N):
    ans += 1 / A[i]

print(1/ans)

Solution (Python):
from sys import stdin,stdout
I = lambda : map(int,stdin.readline().split())

n = input()
A = I()
med = 0.0
for i in A:
	med+=(1/float(i))
print 1/med

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

rsum=0
for i in range(n):
  rsum+=1/a[i]
print(1/rsum)

Solution (Python):
N=int(input())
a=[ 1/x for x in list( map(int,input().split()) ) ]
print( 1/sum(a) )

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

tmp = 0
for i in range(n):
    tmp += 1 / a_list[i]

print(1 / tmp)

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
b = a
for i in range(n):
    b[i] = 1/a[i]

print(1/sum(b))

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

for i in range(0,n):
    sum += 1/a[i]

print(1/sum)

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

Solution (Python):
n=int(input())
box=list(map(int,input().split()))
count=0
for i in box:
    count +=1/i

print(1/count)

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

c = 0
for i in l:
    c += 1/i
    
print(1/c)

Solution (Python):
N = int(input())
li = list(map(int,input().split()))
li2 = []
for i in li:
    li2.append(1/i)
print(1/sum(li2))

Solution (Python):
import sys

sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return list(map(int, sys.stdin.readline().split()))
def II(): return int(sys.stdin.readline())
def LS(): return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]

def main():
    n = II()
    as_ = LI()
    ans = 0
    ans = sum([1/a for a in as_])
    print(1/ans)
if __name__ == '__main__':
    main()

Solution (Python):
"""
 // Author : snape_here - Susanta Mukherjee

"""
from __future__ import division, print_function
import os,sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
else:
    _str = str
    str = lambda x=b"": x if type(x) is bytes else _str(x).encode()

    


from math import ceil,floor,log,sqrt,factorial,pow,pi





def ii(): return int(input())
def fi(): return float(input())
def si(): return input()
def mi(): return map(int,input().split())
def li(): return list(mi())

import math
 
def find_gcd(x, y): 
      
    while(y): 
        x, y = y, x % y 
      
    return x
 
def main():
 
    n=ii()
    l=li()
    a=0
    for i in range(n):
        a+=1/l[i]
    a=1/a 
    print(a)
    


BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def _fill(self):
        s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
        self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
        return s

    def read(self):
        if self.buffer.tell():
            return self.buffer.read()
        return os.read(self._fd, os.fstat(self._fd).st_size)

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", b" "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", b"\n"))
    if kwargs.pop("flush", False):
        file.flush()


sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
input = lambda: sys.stdin.readline().rstrip(b"\r\n")



if __name__ == "__main__":
    main()

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

ans=float(0)
for i in range(N):
    ans += float(1/A[i])

print(1/ans)

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

sum = 0

for i in range(N):
    sum += 1/A[i]
    
print(1/sum)

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
total = 0
for x in a:
    total += 1 / x
print(1 / total)

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

ans = 0
for i in range(n):
  ans += 1/A[i]
  
print(1/ans)

Solution (Python):
n = int(input())
l = [1 / float(i) for i in input().split()]
ans = 1 / sum(l)
print(ans)

Solution (Python):
N = int(input())
para = [int(i) for i in input().split()]
l_val = 0
for i in range(N):
    l_val += (1/para[i])

print("{}".format(1/l_val))

Solution (Python):


n = int(input())

a = list(map(int, input().split()))

inv_sum = 0
for i in range(n):
    inv_sum += 1 / a[i]

result = 1 / inv_sum

print(str(result))

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

num = 0
for a in A:
    num += 1 / a

print(1 / num)

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

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

sum = 0
for i in range(n):
    sum += 1/a[i]
print(1/sum)

Solution (Python):
N = int(input())
print(1/sum(map(lambda x: 1/int(x), input().split())))

Solution (Python):
n = int(input())
alist = list(map(int, input().split()))
tmp = 0
for i in alist:
  tmp += 1/i
print(1/tmp)

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

inv_ans = 0.0
for A_i in A:
    inv_ans += 1/A_i
print(1/inv_ans)

Solution (Python):


def main():
	N = int(input())
	A = [int(f) for f in input().split()]
	
	counter = 0.0
	for a in A:
		counter += 1.0/a
	print(1.0 / counter)
	
if __name__ == "__main__":
	main()

Solution (Python):
import numpy as np

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

tmp=0
for i in range(N):
	tmp+=1/A[i]

print(1/tmp)

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
sum = 0
for i in range(n):
    sum += 1/a[i]
print(1/sum)

Solution (Python):
n = int(input())
a = input().split()
for i in range(n):
  a[i] = int(a[i])

sum = 0
for i in range(n):
  sum = sum + 1/a[i]

print(1/sum)

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
tmp = 0
for i in a:
  tmp += 1/i
ans = 1/tmp
print(ans)

Solution (Python):
N = int(input())
hoge = input().split()
A = []
for i in range(N):
  A.append(1/int(hoge[i]))
  
print(1/sum(A))

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

for i in range(0,n):
    k=k+(1/(a[i]))

print(1/k)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
res = 0
for i in a:
  res += 1/i
print(1/res)

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

for i in range(n):
    bunbo += 1/a[i]
print(1/bunbo)

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
sum = 0
for i in A:
    sum += 1/i
print(1/sum)

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


sita = 0
for i in A_list:
    sita += 1/i

print(1/sita)

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

ans = 0.0
b = 0.0

for i in range(n):
    b += 1.0/(a[i])

ans = 1.0/(b)

print(ans)

Solution (Python):
n = int(input())
x = list(map(int,input().split()))
s=0
for i in range(n):
  s+= (1/x[i])
print(1/s)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
sum_ = 0
for i in range(n):
    sum_ = sum_ + 1/a[i]

print(1/sum_)

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

print(1/sum([1/i for i in line]))

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

print(1/sum([1/a for a in A]))

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

n = int(input())
a = list(map(int, input().split()))
s = 0

for i in range(n):
        s += 1/a[i]
print(1/s)

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

for value in a:
  a2 += 1/value

print(1/a2)

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

v = sum([1 / x for x in A])
print(1/v)

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

total = 0.0
for a in a_list:
    total += 1.0 / a

print(1.0 / total)

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

Solution (Python):
input()
nums = list(map(int, input().split()))
s = 0
for n in nums:
    s += (1 / n)
print(1 / s)

Solution (Python):
N = int(input())
l = []
l = list(map(int, input().split()))
result = 0
for i in range(len(l)):
        result += 1/(l[i])
print(1/result)

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

temp=0.0
for i in range(n):
    temp+=1/a[i]

print(1/temp)

Solution (Python):
n = int(input())
*A, = map(int, input().split())
A = [1/a for a in A]
print(1/sum(A))

Solution (Python):
n=int(input())
a=list(map(int, input().split()))
sum=0
for i in range(n):
    sum+=1/a[i]
print(1/sum)

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