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

n = int(input())
a = map(int, input().split())
x = 1.0 / sum(1 / x for x in a)
print(x)

Solution (Python):

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

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

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

invert = list(map(lambda x: 1/x, a))
total = sum(invert)
print(1/total)

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

sum_num = 0

for i in A:
    sum_num += 1 / i

print(1/sum_num)

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

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

print(ans)

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

for i in range(len(a)):
    a[i] = 1/a[i]

print(1/sum(a))

Solution (Python):
n = int(input())
al = list(map(int, input().split()))
a_inv = 0

for a in al:
    a_inv += 1/a

print(1/a_inv)

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

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 functools import reduce
N = int(input())
*A, = map(int, input().split())

a = reduce(lambda x,y:x*y, A)
b = sum(map(lambda x:a//x,A))
print(a/b)

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

acc = 0.0
for a in A:
    acc += 1 / a

print(1 / acc)

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

reverse_list = []
for a in al:
    reverse_list.append(1/a)

print(1/sum(reverse_list))

Solution (Python):
import numpy as np

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

reverse_list = []
for a in al:
    reverse_list.append(1/a)

print(1/sum(reverse_list))

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

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

print(1/R)

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

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

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

Solution (Python):
N = int(input())
a = map(int, input().split())
b = []
for i in a:
    b.append(1/i)
c = sum(b)
result = 1 / c
print(result)

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

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

print(1 / sum(map(lambda x : 1/x, a)))

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

print(1/ans)

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

print(1/sum)

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

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




def solve(inp):
    N = int(inp.readline().strip())
    A = list(map(int, inp.readline().strip().split(' ')))
    s = 0
    for a in A:
        s += 1 / a
    return str(1 / s)


def main():
    import sys
    result = solve(sys.stdin)
    if result is not None and result != '':
        print(result)


if __name__ == '__main__':
    main()

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

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())
a = list(map(int,input().split()))
p = 1
s = 0
for i in a:
    p *= i
for i in a:
    s += p/i
print(p/s)

Solution (Python):

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


sm=0
for x in l:
  sm+=1/x
  

print(1/sm)

Solution (Python):
n=int(input())
a=list(map(float,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()))
c=0.0
for x in a:
    c+=1/x
print(1/c)

Solution (Python):
n = input()
lst_A = map(int, input().split())
lst_A_inv = [1/x for x in lst_A]
print(1/sum(lst_A_inv))

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

sum=0
result=0

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

result=1/sum
print(result)

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

Solution (Python):
n = int(input().rstrip())
s = map(int, input().rstrip().split(" "))

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

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

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

print(1/b)

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

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

print(1/sum(a))

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(int,input().split()))

s=0
for x in a:
    s+=1/x
ans=1/s

print(ans)

Solution (Python):

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

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

sum = 0
for A in A_list:
    sum += (1 / A)

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())
l = list(map(int,input().split()))
b = sum([1/x for x in l])
print(1/b)

Solution (Python):
N = int(input())
A = [int(a)**(-1) for a in input().split()]
print(sum(A)**(-1))

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
b = list(map(lambda x: 1/x, a))
print(1/sum(b))

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

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

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

print(1/ans)

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

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

print(float(1 / bunbo))

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

lstSub = list()
for i in range(len(lstMain)):
    lstSub.append(float(1/lstMain[i]))

print(str(1/sum(lstSub)))

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

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

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

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 = map(int, input().split())

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

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

a=[int(x) for x in input().split()]

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

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

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

print(1/c)

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

print(1/c)

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

answer = 1 / sum(1/x for x in An)
print(answer)

Solution (Python):
N = int(input())
An = list(map(int, input().split()))
sum = 0

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

print(1/sum)

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

bumbo = 0

for i in A:
  bumbo += (1 / i)

print(1/bumbo)

Solution (Python):
n = int(input())
an = [int(i) for i in input().split()]
denominator = 0
for ai in an:
    denominator += 1 / ai
print(1 / denominator)

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 = map(int, input().split())
print(1 / sum(map(lambda x: 1 / x, A)))

Solution (Python):
import math

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

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

print(float(product/sum))

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

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

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

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

print(1 / sum_inverse)

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):
_ = int(input())
A = map(int, input().split())

S = 0
for j in A:
  S += 1/j
print(1/S)

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

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

print(1 / denomi)

Solution (Python):
a = int(input())
lia = list(map(float, input().split()))
sum_under = 0

for i in lia:
  sum_under += 1/i
  
print(1/sum_under)

Solution (Python):
n=int(input())
a=input().split()
rev=0

for i in a:
    rev+=1/int(i)

print(1/rev)

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

calc = 0
for i in range(n):
  calc += 1/aList[i]

print(1/calc)

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

A = list(map(int, input().split()))
B = [1 / A[i] for i in range(n)]
S = sum(B)

print(1 / S)

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

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

Solution (Python):
def LI():
  return [int(s) for s in input().split()]

N = int(input())
A_s = LI()
 
total = 0
for a in A_s:
  total+=(1/a)
  
print(1/total)

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

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

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

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

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

Solution (Python):
def main():
    n = int(input())
    num_list = list(map(int, input().split()))

    sum = 0
    tmp = 0

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

    
    result = 1 / tmp

    print(result)

if __name__ == '__main__':
    main()

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

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

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 range(len(A)):
  sum+=(1/A[i])
print(1/sum)

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

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())
A= list(map(int,input().split()))
S=0

for i in A:
    S+=1/i

print(1/S)

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

Solution (Python):
from fractions import Fraction


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

total = Fraction(0, 1)
for a in a_list:
    total = total + Fraction(1, a)

print(total.denominator / total.numerator)

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

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

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

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

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

print(1 / temp)

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

for g in range(N):
    Re_sum += (1 / A[g])

print(1 / Re_sum)

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

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

print(1 / sum(a))

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

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

print(ans)

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

b = map(lambda x: 1/x, a)
c = sum(b)

print(1/c)

Solution (Python):
import sys
import math
import heapq
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, m=DVSR): return pow(x, m - 2, m)
def DIV(x, y, m=DVSR): return (x * INV(y, m)) % m
def LI(): return [int(x) for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()
def II(): return int(input())
def FLIST(n):
    res = [1]
    for i in range(1, n+1): res.append(res[i-1]*i%DVSR)
    return res
def gcd(x, y):
    if x < y: x, y = y, x
    div = x % y
    while div != 0:
        x, y = y, div
        div = x % y
    return y

N=II()
DS=LI()

res = 0.0
for n in DS:
    res += 1/n

print(1/res)

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())
a=[int(x) for x in input().split()]

ans=0

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

print(1/ans)

Solution (Python):
def main():
    n = int(input())
    a = list(map(int, input().split()))
    
    res = 0.0
    for i in a:
        res += (1/i)
    print(1/res)
    
if __name__ == '__main__':
    main()

Solution (Python):
"""
author : halo2halo
date : 9, Jan, 2020
"""

import sys
import numpy as np

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

N, *A = map(int, read().split())
Aarr = np.array(A)
At = 1 / Aarr
print(1 / sum(At))

Solution (Python):
N = int(input())
A = (int(s) for s in input().split(' '))

denom = 0
for i in A:
    denom += 1/i

ans = 1/denom
print(ans)

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

Solution (Python):
from fractions import Fraction

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

asum = 0
for i in a:
  asum += Fraction(1, i)

print(float(1/asum))

Solution (Python):
import sys
input = sys.stdin.readline
N = int(input())
li = [int(i) for i in input().split()]
suma = 0
sum = 0
for i in range(N) :
    suma += 1/li[i]
sum = 1 / suma
print(sum)

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


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

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

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

Solution (Python):
import numpy as np

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

sum_rec = 0

for i in range(len(a)):
    sum_rec += np.reciprocal(float(a[i]))

print(np.reciprocal(sum_rec))

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

denominator = 0

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

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

if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())
a = [1/i for i in map(int,input().split())]
dv = sum(a)
print("%.10f"%(1.0/dv))

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

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):
import numpy as np

n = int(input())
a = np.array([int(x) for x in input().split()])
print(1/sum(1/a))

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

aa = list(map(lambda t: 1/t, a))
print(1/sum(aa))

Solution (Python):
n = input()
r = 0
for s in input().split():
    r +=1/int(s)
print(1/r)

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
 
import numpy as np
N = int(input())
A = np.array(input().split(),np.int32)
 
answer = 1/(1/A).sum()
print(answer)

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

ans = 0.0
num = input().split(" ")
num = [int(i) for i in num]
for i in num:
  ans += 1.0/i
print(1/ans)

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):
def main():
    N = int(input())
    A = list(map(int, input().split(" ")))
    result = 0
    for a in A:
        result += 1 / a
    print(1 / result)


if __name__ == '__main__':
    main()

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

s = 0
for A in As:
    s += 1 / A

print(1/s)

Solution (Python):
N = input()
R = 0
for s in input().split():
    R += 1/int(s)
print(1/R)

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

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())
print(1 / sum([1/int(_) for _ in input().split()]))

Solution (Python):
def main():
	n = int(input())
	a = list(map(int,input().split()))
	
	def re(n):
		return 1/n

	n_r = list(map(re,a))

	print(1/sum(n_r))

 
if __name__ == '__main__':
	main()

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

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

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 = map(int,input().split())

suma = 0

for a in A:
    suma += 1/a

print(1/suma)

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

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

tmp = 0

for i in A:
    tmp += 1 / i

print(1 / tmp)

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

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

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(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()))
reverse=0
for i in range(n):
  reverse+=1/A[i]
ans=1/reverse
print(ans)

Solution (Python):

import numpy as np


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


res = 1 / np.sum(1 / A)


print(res)

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

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

print("{:.16g}".format(1/sum(1/ x for x in a)))

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

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

re_total=0

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

print(1/re_total)

Solution (Python):
N=int(input().strip())
A = list(map(int, input().strip().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()))

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

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

Solution (Python):

import sys
sys.setrecursionlimit(10000000)
INF = 1<<32


def solve(N: int, A: "List[int]"):
    b = 1
    def mul(x: "List"):
        r = 1
        for i in x:
            r *= i

        return r
    
    u = 0
    for i in range(N):
        t = [A[j] for j in range(N) if j != i] 
        u += mul(t)

    print(mul(A)/u)
    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()))
S = 0
for i in range(N):
    S += (1 / A[i])

print(1/S)

Solution (Python):
import numpy as np

n = int(input())
a = np.array([int(i) for i in input().split()])

print(1 / sum(1 / a))

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

product=1
for a in A:
    product *= a

bunsi=product
bunbo=0

for a in A:
    bunbo+=product/a
print(bunsi/bunbo)

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())
a=list(map(int,input().split()))
ans = 0
for i in range(n):
  ans+=1/a[i]
print(1/ans)

Solution (Python):
from fractions import Fraction

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

sum = 0
for i in range(len(A)):
    a = Fraction(1, A[i])
    sum += a
sum = Fraction(sum.denominator, sum.numerator)

print(float(sum))

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

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

print(1/s)

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

print(1/ans)

Solution (Python):
import numpy as np

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

lst = np.array(A)
lst = 1 / lst
print(1/lst.sum())

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

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

s = 0
for i in A:
    s += 1/i
print(1/s)

Solution (Python):
from sys import stdin

n = int(stdin.readline().rstrip())
arr = [int(x) for x in stdin.readline().rstrip().split()]

under = 0
for i in arr:
    under += 1/i

print(1/under)

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

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

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

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

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

c = 0

for i in a:
    c += 1/i

print(1/c)

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

for i in range(n):
    tmp *= a[i]

lst = []

for i in range(n):
    lst.append(tmp//a[i])

print(tmp/sum(lst))

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

r = 0

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

Solution (Python):
def main(n: int, a: list):
    l = 0
    for _a in a:
        l += 1 / _a

    print(1 / l)


if __name__ == '__main__':
    n = int(input())
    a = list(map(int, input().split()))

    main(n, a)

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

Solution (Python):
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
def resolve():
    n=int(input())
    ans=0
    for a in map(int,input().split()):
        ans+=1/a
    print(1/ans)
resolve()

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

res = 0
for Ai in A:
  res += 1/Ai

print(1/res)

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(int, input().split()))

denominator = 0

for a in A:
  denominator += 1/a

print(1/denominator)

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

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

for i in num:
  res += 1/i
  
print("{:.16}".format(1/res))

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

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)

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

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

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

Solution (Python):
N = int(input())
A = [int(i) for i in input().split()]
ans = 0.0
for a in A:
    ans += 1.0 / a
ans = 1.0 / ans
print("{}".format(ans))

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

Solution (Python):



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

R = 0
for i in range(N):
    R += 1.0 / A[i]

print(1.0 / R)

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

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

def main():
    n = int(input())
    a_tuple = tuple(map(int, input().split()))
    print(1 / sum([1 / a for a in a_tuple]))

if __name__ == '__main__':
    main()

Solution (Python):
import sys
from functools import reduce
def input(): return sys.stdin.readline().rstrip()

def main():
    n = int(input())
    a_tuple = tuple(map(int, input().split()))
    a_mul = reduce(lambda a, b: a*b, a_tuple)
    print(a_mul / sum([a_mul / a for a in a_tuple]))

if __name__ == '__main__':
    main()

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

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

print(1/total)

Solution (Python):
import sys

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

ans = 1/(denom)
print(ans)

Solution (Python):
def gyaku(n) :
	return 1 / int(n)
N = int(input())
A = list(map(gyaku, input().split()))
print(1/ sum(A))

Solution (Python):
N, *L,  = [list(map(int, s.split())) for s in open(0)]
N, L = N[0], L[0]
nums = []
for i in range(N):
    nums.append(1/L[i])
print(1/sum(nums))

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(int, input().split()))
b=[1/i for i in a]

print(1/sum(b))

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

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

a_=0
for i in range(N):
    a_+=1/a[i]

print(1/a_)

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

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

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

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

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())
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 = map(int, input().split())

Ainv = map(lambda x: 1/x, A)
print(1 / sum(Ainv))

Solution (Python):
_ = int(input())
print(1/sum([1/int(x) for x in input().split()]))

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

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

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

cnt = 0
for i in L:
    cnt += 1 / i

print(1 / cnt)

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

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

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

Solution (Python):
import numpy as np

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

print(1 / np.sum(1 / A))

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()))
x=0
for i in range(N):
    x+=1/A[i]
x=1/x
print(x)

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

import numpy as np
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()))
b=0
for i in range(n):
  b+=1/A[i]

print(1/b)

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

divided_nums = [1/i for i in numbers]

output = 1 / (sum(divided_nums))

print(output)

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

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

ans = 1 / wrk

print(ans)