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




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

all_sum = 0
for a in A:
	all_sum += all_product / a

answer = all_product / all_sum

print(answer)

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

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

print("%.5f" % (1/s))

Solution (Python):
from fractions import Fraction
def inverse(f):
    return Fraction(f.denominator,f.numerator)

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

all=0
if 1 <= n <=100:
    for i in a[0:n]:    
        b=Fraction(i,1)
        all=all+inverse(b)
    print(float(inverse(all)))

Solution (Python):



n = int(raw_input())
arr = []
arr = [int(x) for x in raw_input().split()] 
num = 1.0
den = 0
for val in arr:
    num = num * val
for val in arr:
    den = den + num/val
print(num/den)

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

Solution (Python):
n = int(input())
p = input()
p = p.split()
prod = 1
for i in p:
  prod *=int(i)
num = 0;
for i in p:
  num += prod/int(i)
ans = prod/num;
print(ans)

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

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

Solution (Python):

from fractions import Fraction
n=int(input())
m=input().split()
tmp =0

for x in range(0,n):
  a = Fraction(1, int(m[x]))
  tmp+=a
  
a_f = float(Fraction(1, tmp))
print(a_f)

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

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

print(1/X)

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

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()))
for i in range(0,n):
  l[i] = 1/l[i]
s = sum(l)
print(1/s)

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

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

A = 0
B = 0
for j in range(N):
    B = 1 / array[j]
    A += B

print(1 / A)

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

for i in a:
    con += 1 / i

con = 1 / con

print(con)

Solution (Python):
N=int(input())
A=(int(x) for x in 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(' ')))
base = 0
for i in range (n):
  b = 1/a[i]
  base = base + b
ans = 1/base
print(ans)

Solution (Python):
import math, string, itertools, fractions, heapq, collections, re, array, bisect, copy, functools, random
import sys
from collections import deque, defaultdict, Counter; from heapq import heappush, heappop
from itertools import permutations, combinations, product, accumulate, groupby
from bisect import bisect_left, bisect_right, insort_left, insort_right
from operator import itemgetter as ig
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20; INF = float("INF"); ans = 0; tmp = 0; cnt = 0; ansli = []; tmpli = []; candili = []; stillset = set()
eps = 1.0 / 10 ** 10; mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]; ddn = dd + [(-1, 1), (1, 1), (1, -1), (-1, -1)]; ddn9 = ddn + [(0, 0)]
"""for dx, dy in dd:
        nx = j + dx; ny = i + dy
            if 0 <= nx < w and 0 <= ny < h:"""
def wi(): return list(map(int, sys.stdin.readline().split()))
def wip(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def ws(): return sys.stdin.readline().split()
def i(): return int(sys.stdin.readline())
def s(): return input()
def s_list(): return list(input())
def hi(n): return [i() for _ in range(n)]
def hs(n): return [s() for _ in range(n)]
def mi(n): return [wi() for _ in range(n)]
def num__grid(n): return [[int(i) for i in sys.stdin.readline().split()[0]] for _ in range(n)]
def mip(n): return [wip() for _ in range(n)]
def ms(n): return [ws() for _ in range(n)]
def grid(n): return [s_list() for _ in range(n)]

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

print(1 / k)

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

Solution (Python):
a = int(input())
list = [int(i) for i in input().split()]
mama = 1
for item in list:
    mama = mama*item
sum = 0
for item in list:
    sum = sum + (mama/item)
print(mama/sum)

Solution (Python):
n=0

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

print(1/total)

Solution (Python):
import math
import fractions

def gcd_list(numbers):
    for i in range(1, len(numbers)):
        ans = fractions.gcd(ans, numbers[i])
    return ans

def lcm_list(numbers):
    ans = numbers[0]
    for i in range(1, len(numbers)):
        ans = ans * numbers[i] // fractions.gcd(ans, numbers[i])
    return ans



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

lcm = lcm_list(A_line)
mother = sum(map(lambda x: lcm//x, A_line))

print(lcm/mother)

Solution (Python):
import sys


		
def main():
	a=int((input()))
	l = list(map(int, input().split()))
	pp=1
	for i in l:
		pp=pp*i
		
	kk=0
	for i in l:
		kk+=pp/i

	print(pp/kk)
	
	


if __name__ == "__main__":
	if sys.platform =='ios':
		sys.stdin=open('inputFile.txt')
	else:
		pass
		
			
	ret = main()
	if ret is not None:
		print(ret)

Solution (Python):
num = int(input())
lines = input().split(" ")
itr = iter([int(i) for i in lines])
result = 0

for j in itr:
  result += 1 / j

result = 1 / result
print(result)

Solution (Python):
import numpy as np
n=int(input())
a=list(map(int,input().split()))

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

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

for i in range(N):
    sum = sum + ((A[i])**-1)
    ans = sum**-1

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

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

Solution (Python):
n=int(input())
num=input()
num=num.split( )

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

mother=0

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

print(1/mother)

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

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

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

tmp = 0.0
for n in A:
    tmp += (1/n)
else:
    print(1/tmp)

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

Solution (Python):
import fractions

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

print(float(1 / sum(fractions.Fraction(1, x) for x in a)))

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

for v in a:
    ans += (1/v)
print(1/ans)

Solution (Python):
a = int(input())
A = list(map(int,input().split()))
B = []
ans = 0

for i in A:
    B.append(1/i)
for i in B:
    ans += i
    
print(1/ans)

Solution (Python):
def rev(i):
    rev_i = 1 / i
    return rev_i

n = int(input())
num_ls = input().split()

total_num = 0

for _n in num_ls:
    rev_num = rev(int(_n))
    total_num += rev_num

print(rev(total_num))

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

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

div = 0
for a in a_s:
  div += 1 / a
ans = 1 / div
print(ans)

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

Solution (Python):
s = 0

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

for i in a:
    s += 1 / i

s = 1 / s
print(s)

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

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

A = [1/a for a in A]

print(1/sum(A))

Solution (Python):
_,a=open(0);print(1/sum(1/int(i)for i in a.split()))

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

Solution (Python):


n = int(input())
a = list(map(int, input().split()))
r_a = ["" for _ in range(n)]


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

print(1/sum)

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

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

print(1/c)

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):
A = 0
N = int(input())
num = input().split()

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

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

while N > 1:
  b = []
  for i in range(0,N-1,2):
    c = (a[i] * a[i+1])/(a[i] + a[i+1])
    b.append(c)
    
  if N % 2 != 0:
    b.append(a[N-1])
    
  a = b
  N = len(a)

print(a[0])

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

Solution (Python):

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

a_sum = 0
for i in range(len(a_list)):
    a_sum += 1 / a_list[i]

print(1 / a_sum)

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

M = 0
for l in range(N):
  M += 1/A[l]
print(1/M)

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

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

m = 0
for a in A:
  m += (1/a)

print(1/m)

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

Solution (Python):
N = int(input())
A_n = map(int, input().split())
a = 0
for A in A_n:
    a += 1.0/A

print(1/a)

Solution (Python):
n=int(input())
a=input().split()
b=0
x=0
while b<=n-1:
  y=a[b]
  z=float(1)/float(y)
  x=x+z
  b=b+1
w=1/x 
print(w)

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

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

inv_a = [1.0/ai for ai in a]
print(1.0/sum(inv_a))

Solution (Python):
n=input()
arr=map(float,raw_input().split())
t=0
for i in arr:
        t+=(1/i)
print 1/t

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

ar=sum([1/i for i in a])
print(1/ar)

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

import numpy as np
N = int(input())
A = np.array(input().split(), dtype=np.float64)

answer = 1/(1/A).sum()
print(answer)

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

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

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

Solution (Python):

import copy
from functools import reduce
N=int(input())
A=list(map(int,input().split()))



den=reduce(lambda x,y:x*y,A)

num=0
for i in range(0,N):
    B=copy.deepcopy(A)
    B[i]=1.0
    num+=reduce(lambda x,y:x*y,B)


print(den/num)

Solution (Python):
n = int(input())
a = {}

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

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

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

Solution (Python):
total_number = int(input())
numbers = list(map(int,input().split()))
reversed = 0
for i in range(total_number):
  reversed += 1 / numbers[i]
sol = 1/reversed
print(sol)

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

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):
import numpy as np
s=0
n=int(input())
l=list(map(float,input().split()))
la=np.reciprocal(l)
for i in la:
  s=s+i
d=np.reciprocal(s)
print(d)

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

sum = 0
for el in a:
    sum += 1/el

print(1/sum)

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

Solution (Python):



N = int(raw_input())

li = map(int, raw_input().split())

res = 0

for i in xrange(0,N):
	res += 1/float(li[i])

print 1/res

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

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

Solution (Python):
_, a = int(input()), input()
inv_a = map(lambda x: 1 / int(x), a.split())
print(1 / sum(inv_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):
A = int(input())
B = list()
tmp = 0

B= input().split()
C = list(map(int, B))
for i in range(A):
    tmp += 1 / C[i]
print(1 / tmp)

Solution (Python):
N=int(input())
As=[int(x) for x in input().strip().split(" ")]
x=1
for a in As:
    x*=a
rm = 0
for a in As:
    rm+=(x//a)
print(x/rm)

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

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

for i in range(N):
    A[i] = round((1 / A[i]), 7)


ans = 0

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

ans = round((1 / ans), 7)

print(ans)

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

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

s = 0

for num in a:
  s += 1 / num
  
print(1 / s)

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


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


  ans = 1/inv
  print(ans)


if __name__ == '__main__':
  main()

Solution (Python):
n = int(input())
a = input().split()
sum = 0
for l in a:
    sum += (1 / int(l))

print(1 / sum)

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

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

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

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

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

res = prod / s
print(res)

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

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

bunbo = [int(e) for e in input().split()]

wa = 0
for i in bunbo :
    wa = wa + 1 / i

print (1/wa)

Solution (Python):
n = int(input())
resistors = [int(i) for i in input().split()]
reverse = []
for i in range(len(resistors)):
    reverse.append(1 / resistors[i])
print(1 / sum(reverse))

Solution (Python):
from copy import deepcopy
from sys import exit,setrecursionlimit
import math
from collections import defaultdict,Counter,deque
from fractions import Fraction as frac

setrecursionlimit(1000000)


def main():
	n = int(input())
	a = list(map(int,input().split()))
	ans = 0
	for i in a:
		ans += frac(1,i)
	print(1/float(ans))

def zip(a):
	mae = a[0]
	ziparray = [mae]
	for i in range(1,len(a)):
		if(mae != a[i]):
			ziparray.append(a[i])
			mae = a[i]
	return ziparray

def is_prime(n):
	if n < 2: return False

	for k in range(2, int(math.sqrt(n)) + 1):
		if n % k == 0:
			return False

	return True

def list_replace(n,f,t):
	return [t if i==f else i for i in n]

def base_10_to_n(X, n):
	X_dumy = X
	out = ''
	while X_dumy>0:
		out = str(X_dumy%n)+out
		X_dumy = int(X_dumy/n)
	if(out == ''): return '0'
	return out

def gcd(l):
	x = l.pop()
	y = l.pop()
	while(x%y!=0):
		z = x%y
		x = y
		y = z
	l.append(min(x,y))
	return gcd(l) if len(l) > 1 else l[0]

class Queue():
	def __init__(self):
		self.q = deque([])
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.popleft()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class Stack():
	def __init__(self):
		self.q = []
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.pop()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class graph():
	def __init__(self):
		self.graph = defaultdict(list)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
		self.graph[t].append(f)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
		self.graph[t].remove(f)
	def linked(self,f):
		return self.graph[f]

class dgraph():
	def __init__(self):
		self.graph = defaultdict(set)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
	def linked(self,f):
		return self.graph[f]

main()

Solution (Python):
import fractions

def get_lcm(x, y):
    return (x * y) // fractions.gcd(x, y)

def get_num(a, lcm):
    return lcm // a


N_str = input()
a_str = input()
a_str_list = a_str.split(" ")
a_list = list(map(lambda x: int(x), a_str_list))
lcm = 1
for a in a_list:
    lcm = get_lcm(lcm, a)

sum_a = 0
for a in a_list:
    sum_a += get_num(a, lcm)

result = lcm / sum_a
print(result)

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

print(1 / den_sum)

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

t = list(map(lambda x: 1/x, b))
k = sum(t)

print(1/k)

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

bunbo=0

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

print(1/bunbo)

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

for i in list:
  x = x + 1/i

print(1/x)

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

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

A_inverse = [1 / a for a in A]

ans = 1 / sum(A_inverse)

print(ans)

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

Solution (Python):

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

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

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

sum = 1/sum
print(sum)

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

sum_gyaku = 0

for aa in a:
    sum_gyaku += (1.0 / aa)

print( '{:.10f}'.format(1.0 / sum_gyaku) )

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

for i in range(n):
    a_sum += a_sup / a[i]

print(a_sup/a_sum)

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

ans = 0
s = [int(i) for i in input().split()]

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

print(1/ans)

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

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

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

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

Solution (Python):
rep = int(input())
num_list = list(map(int, input().split()))
emp = []
for nums in num_list:
    nums = 1 / nums
    emp.append(nums)
print(1 / sum(emp))

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

denominator = 0
for a in map(int, input().split()):
  denominator += 1 / a

print(1 / denominator)

Solution (Python):
import numpy as np
a = int(input())
s = [int(i) for i in input().split()] 
s = np.array(s)
ans = 1/sum(1/s)
print(ans)

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

x = 0

for i in t:
  x += 1 / i

print(1 / x)

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

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

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

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

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

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


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

bunbo = list(map(lambda a:bunshi//a,A))
    

bunbo1 = sum(bunbo)


ans = bunshi/bunbo1

print(ans)

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

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



S = 0

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

print(1/S)

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

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

Solution (Python):
a = 0
b = int(input())
c = list(map(int,input().split()))
for i in range(b):
  a += 1/c[i]
b = 1/a
print(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())
l=list(map(int,input().split()))
s=1
for i in l:
    s*=i
q=0
for i in l:
    q+=s//i
print(s/q)

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

arr = [1/arr[i] for i in range(n)]
print(1 / sum(arr))

Solution (Python):
if __name__ == '__main__':
    n = int(input())
    a = [int(k) for k in input().split()]
    p = sum([1 / k for k in a])
    print(1 / p)

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

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

print(1 / sum)

Solution (Python):
from decimal import Decimal

n = int(input())
aaa = list(map(int, input().split()))
div = Decimal(0)
for a in aaa:
    div += Decimal(1) / Decimal(a)
print(Decimal(1) / div)

Solution (Python):
import sys
p = [r for r in sys.stdin.read().split('\n') if r != '']
n = int(p[0])
a = [int(c) for c in p[1].split()]
t = 0
for i in a:
    t += 1 / i
print(1 / t)

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

rev_sum = 0

for a_part in A:
  if a_part != 0:
    rev_sum += 1 / a_part

if rev_sum != 0:
  print(1 / rev_sum)
else:
  print(0)

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

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

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

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

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

su = 0
for i in Lists:
    su += 1/i

print(1/su)

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

bn = list(map(lambda x:1/x, an))

print(1/sum(bn))

Solution (Python):
from fractions import Fraction

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

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

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

Solution (Python):
import numpy
N = int(input())
A = list(map(float, input().split()))
print(numpy.reciprocal(numpy.sum(numpy.reciprocal(A))))

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

print(1/r_ans)

Solution (Python):
from collections import defaultdict
import sys
import math
from datetime import datetime

def sol(n, S):
    ret = 0
    for s in S:
        
        ret += (1.0 / s)
        
    return (1.0/ret)



do_submit = True


def input_parse(input_str):
    lines = [x.strip() for x in input_str.split("\n") if x.strip()]
    parsed_lines = [list(map(str, line.split())) for line in lines]
    print(parsed_lines)
    n = int(parsed_lines[0][0])
    S = list(map(int, parsed_lines[1]))
    
    
    return n, S


if not do_submit:
    n, S = input_parse("""
    2
    10 30
    """)
    print(sol(n, S))

    n, S = input_parse("""
    3
    200 200 200
    """)
    print(sol(n, S))

    n, S = input_parse("""
    1
    1000
    """)
    print(sol(n, S))



else:
    n = int(input().strip())
    S = list(map(int, input().split()))
    
    

    
    
    print(sol(n, S))

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

AAAinved = [1/a for a in AAA]

print(1/sum(AAAinved))

Solution (Python):
x=int(input())
a=[]
n=input().split(" ")
for i in range(0,x):
    a.append(int(n[i]))
s=1
for j in range(0,len(a)):
    s = s * a[j]
t=1
sum=0
for k in range(0,len(a)):
    t=s/a[k]
    sum=sum+t
print(s/sum)

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

print(float(Fraction(1,sum(a))))

Solution (Python):
import functools
import fractions

def gcd_list(numbers):
    return functools.reduce(fractions.gcd, numbers)


N = int(input())
a_list = [int(i) for i in input().split(' ')]

gcd = gcd_list(a_list)
div = sum(map(lambda x: (gcd / x), a_list))
print (gcd / div )

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

Solution (Python):
x=int(input())
a=[]
n=input().split(" ")
for i in range(0,x):
    a.append(int(n[i]))
s=1
for j in range(0,len(a)):
    s = s * a[j]
t=1
sum=0
for k in range(0,len(a)):
    t=s/a[k]
    sum=sum+t
print(s/sum)

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

g = 0


for a in aa:
    g += 1 / a

print(1 / g)

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())
s = input().split()
l = list()
for i in range(n):
  a = int(s[i-1])
  a = 1/a
  l.append(a)
l = map(float,l)
l = sum(l)
r = 1/l
print(r)

Solution (Python):
from fractions import Fraction

n = int(input())

num_list = [Fraction(1,int(i)) for i in input().split()]

temp_list = 0
for fr in num_list:
    temp_list += fr

print(float(Fraction(temp_list.denominator,temp_list.numerator)))

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

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):
from fractions import Fraction

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

summ = 0

for i in range(N):
    summ += Fraction(1, A[i])

print(float(Fraction(1, summ)))

Solution (Python):
import fractions
N = int(input())
T = list(map(int, input().split()))
ans = T[0]
for i in range(1, N):
    ans = ans * T[i] // fractions.gcd(ans, T[i])


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

print(ans / sum)

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

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

Solution (Python):
from fractions import Fraction
N = int(input())
aLst = list(map(int, input().split()))
ansLst = []
for i in range(N):
    ansLst.append(Fraction(1, aLst[i]))

print(float(Fraction(1, sum(ansLst))))

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

print(1/num)

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

num = 0
test = []
for i in range(n):
    test.append(1 / a[i])
    
    num = (1 / (sum(test)))

print(num)

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

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

print float(s)/float(b)

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

print (1 / k)

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

A=[i for i in range(N)]

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

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

print(1/sum)

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

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

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

print "%.10f"%(1 / ans )

Solution (Python):
N = int(input())
data = list(map(int, input().split()))
multi = 1
each = 0
for num in data:
    multi *= num

for num in data:
    each += multi/num

print(multi/each)

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

t = [1 / i for i in a]
result = 1 / sum(t)

print(result)

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

sum=A[0]
if N==1:
    sum=float(sum)

for i in range(1,N):
    new=A[i]
    sum=float((new+sum)/(new*sum))
    sum=float(1/sum)

sum_end=float(sum)
print(sum_end)

Solution (Python):

n = int(input())
arr = list(map(int, input().split()))
wa = 1.0/arr[0]
for i in range(1, n):
  wa += 1.0/arr[i]

print(1/wa)