import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Scanner;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.IdentityHashMap;
			
			
/**
 * for competitive programming
 * @author BrolyCode
 * @version 1.0.0
 */
			
			public class Main {
				static Random random;
				private static void mySort(int[] s) {
			        for (int i = 0; i < s.length; ++i) {
			            int j = random.nextInt(i + 1);
			            int t = s[i];
			            s[i] = s[j];
			            s[j] = t;
			        }
			        Arrays.sort(s);
			    }
				
				static class Pair{
					int x;
					int y;
					
					public Pair(int x, int y) {
						this.x=x;
						this.y=y;
					}
				}
				
				public static void sortPairX(Pair[] p) {
					Arrays.sort(p, new Comparator<Pair>() {
						public int compare(Pair o1, Pair o2) {
							return o1.x-o2.x;
						}			
					});
				}
				
				public static void sortPairY(Pair[] p) {
					Arrays.sort(p, new Comparator<Pair>() {
						public int compare(Pair o1, Pair o2) {
							return o1.y-o2.y;
						}			
					});
				}
				
				
			
				public static void main(String[] args) {
					random = new Random(543534151132L + System.currentTimeMillis());
					InputStream inputStream = System.in;
			        OutputStream outputStream = System.out;
			        InputReader in = new InputReader(inputStream);
			        PrintWriter out = new PrintWriter(outputStream);
			        
			        task(in,out);
			        
					out.close();
					
				}
				
			
				private static void task(InputReader in, PrintWriter out) {
					
					int n=in.nextInt();
					double ans=0;
					for(int i=0;i<n;i++) {
						int x=in.nextInt();
						ans+=1.0/x;
					}
					int res=(int)(1/ans);
					if((1./ans)==res)out.println(res);
					else out.println(1./ans);
				}	
				

				public static int gcd(int a, int b)  
			    { 
			        BigInteger b1 = BigInteger.valueOf(a); 
			        BigInteger b2 = BigInteger.valueOf(b); 
			        BigInteger gcd = b1.gcd(b2); 
			            return gcd.intValue(); 
			    } 
			      
			    public static long gcd(long a, long b)  
			    { 
			        BigInteger b1 = BigInteger.valueOf(a); 
			        BigInteger b2 = BigInteger.valueOf(b); 
			        BigInteger gcd = b1.gcd(b2); 
			            return gcd.longValue(); 
			    } 
				
				static class InputReader {
			        public BufferedReader reader;
			        public StringTokenizer tokenizer;
			
			        public InputReader(InputStream stream) {
			            reader = new BufferedReader(new InputStreamReader(stream), 32768);
			            tokenizer = null;
			        }
			
			        public String next() {
			            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			                try {
			                    tokenizer = new StringTokenizer(reader.readLine());
			                } catch (IOException e) {
			                    throw new RuntimeException(e);
			                }
			            }
			            return tokenizer.nextToken();
			        }
			
			        public int nextInt() {
			            return Integer.parseInt(next());
			        }
			        
			        public long nextLong() {
			            return Long.parseLong(next());
			        }
			        
			        public double nextDouble() {
			            return Double.parseDouble(next());
			        }
			        
			        public float nextFloat() {
			            return Float.parseFloat(next());
			        }
			        
			    }
			
			}
			
		  
		   Comparator<Pair>() {
						public int compare(Pair o1, Pair o2) {
							return o1.y-o2.y;
						}			
					} public int compare(Pair o1, Pair o2) {
							return o1.y-o2.y;
						} compare {
							return o1.y-o2.y;
						} return o1.y-o2.y; o1.y-o2.y o1.y o1 o1.y o2.y o2 o2.y Pair o1 o1 Pair o2 o2 Comparator<Pair>() {
						public int compare(Pair o1, Pair o2) {
							return o1.x-o2.x;
						}			
					} public int compare(Pair o1, Pair o2) {
							return o1.x-o2.x;
						} compare {
							return o1.x-o2.x;
						} return o1.x-o2.x; o1.x-o2.x o1.x o1 o1.x o2.x o2 o2.x Pair o1 o1 Pair o2 o2 import java.io.BufferedReader; BufferedReader java.io import java.io.IOException; IOException java.io import java.io.InputStream; InputStream java.io import java.io.InputStreamReader; InputStreamReader java.io import java.io.OutputStream; OutputStream java.io import java.io.PrintWriter; PrintWriter java.io import java.math.BigInteger; BigInteger java.math import java.util.ArrayList; ArrayList java.util import java.util.Arrays; Arrays java.util import java.util.BitSet; BitSet java.util import java.util.Collection; Collection java.util import java.util.Collections; Collections java.util import java.util.Comparator; Comparator java.util import java.util.Deque; Deque java.util import java.util.HashMap; HashMap java.util import java.util.HashSet; HashSet java.util import java.util.Iterator; Iterator java.util import java.util.LinkedHashMap; LinkedHashMap java.util import java.util.LinkedList; LinkedList java.util import java.util.List; List java.util import java.util.Map; Map java.util import java.util.PriorityQueue; PriorityQueue java.util import java.util.Queue; Queue java.util import java.util.Random; Random java.util import java.util.Scanner; Scanner java.util import java.util.Stack; Stack java.util import java.util.StringTokenizer; StringTokenizer java.util import java.util.TreeMap; TreeMap java.util import java.util.TreeSet; TreeSet java.util import java.util.IdentityHashMap; IdentityHashMap java.util 			public class Main {
				static Random random;
				private static void mySort(int[] s) {
			        for (int i = 0; i < s.length; ++i) {
			            int j = random.nextInt(i + 1);
			            int t = s[i];
			            s[i] = s[j];
			            s[j] = t;
			        }
			        Arrays.sort(s);
			    }
				
				static class Pair{
					int x;
					int y;
					
					public Pair(int x, int y) {
						this.x=x;
						this.y=y;
					}
				}
				
				public static void sortPairX(Pair[] p) {
					Arrays.sort(p, new Comparator<Pair>() {
						public int compare(Pair o1, Pair o2) {
							return o1.x-o2.x;
						}			
					});
				}
				
				public static void sortPairY(Pair[] p) {
					Arrays.sort(p, new Comparator<Pair>() {
						public int compare(Pair o1, Pair o2) {
							return o1.y-o2.y;
						}			
					});
				}
				
				
			
				public static void main(String[] args) {
					random = new Random(543534151132L + System.currentTimeMillis());
					InputStream inputStream = System.in;
			        OutputStream outputStream = System.out;
			        InputReader in = new InputReader(inputStream);
			        PrintWriter out = new PrintWriter(outputStream);
			        
			        task(in,out);
			        
					out.close();
					
				}
				
			
				private static void task(InputReader in, PrintWriter out) {
					
					int n=in.nextInt();
					double ans=0;
					for(int i=0;i<n;i++) {
						int x=in.nextInt();
						ans+=1.0/x;
					}
					int res=(int)(1/ans);
					if((1./ans)==res)out.println(res);
					else out.println(1./ans);
				}	
				

				public static int gcd(int a, int b)  
			    { 
			        BigInteger b1 = BigInteger.valueOf(a); 
			        BigInteger b2 = BigInteger.valueOf(b); 
			        BigInteger gcd = b1.gcd(b2); 
			            return gcd.intValue(); 
			    } 
			      
			    public static long gcd(long a, long b)  
			    { 
			        BigInteger b1 = BigInteger.valueOf(a); 
			        BigInteger b2 = BigInteger.valueOf(b); 
			        BigInteger gcd = b1.gcd(b2); 
			            return gcd.longValue(); 
			    } 
				
				static class InputReader {
			        public BufferedReader reader;
			        public StringTokenizer tokenizer;
			
			        public InputReader(InputStream stream) {
			            reader = new BufferedReader(new InputStreamReader(stream), 32768);
			            tokenizer = null;
			        }
			
			        public String next() {
			            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			                try {
			                    tokenizer = new StringTokenizer(reader.readLine());
			                } catch (IOException e) {
			                    throw new RuntimeException(e);
			                }
			            }
			            return tokenizer.nextToken();
			        }
			
			        public int nextInt() {
			            return Integer.parseInt(next());
			        }
			        
			        public long nextLong() {
			            return Long.parseLong(next());
			        }
			        
			        public double nextDouble() {
			            return Double.parseDouble(next());
			        }
			        
			        public float nextFloat() {
			            return Float.parseFloat(next());
			        }
			        
			    }
			
			} Main static Random random; random private static void mySort(int[] s) {
			        for (int i = 0; i < s.length; ++i) {
			            int j = random.nextInt(i + 1);
			            int t = s[i];
			            s[i] = s[j];
			            s[j] = t;
			        }
			        Arrays.sort(s);
			    } mySort {
			        for (int i = 0; i < s.length; ++i) {
			            int j = random.nextInt(i + 1);
			            int t = s[i];
			            s[i] = s[j];
			            s[j] = t;
			        }
			        Arrays.sort(s);
			    } for (int i = 0; i < s.length; ++i) {
			            int j = random.nextInt(i + 1);
			            int t = s[i];
			            s[i] = s[j];
			            s[j] = t;
			        } int i = 0; int i = 0; i 0 i < s.length i s.length s s.length ++i ++i i {
			            int j = random.nextInt(i + 1);
			            int t = s[i];
			            s[i] = s[j];
			            s[j] = t;
			        } {
			            int j = random.nextInt(i + 1);
			            int t = s[i];
			            s[i] = s[j];
			            s[j] = t;
			        } int j = random.nextInt(i + 1); j random.nextInt(i + 1) random.nextInt random i + 1 i 1 int t = s[i]; t s[i] s i s[i] = s[j] s[i] s i s[j] s j s[j] = t s[j] s j t Arrays.sort(s) Arrays.sort Arrays s int[] s s public static void sortPairX(Pair[] p) {
					Arrays.sort(p, new Comparator<Pair>() {
						public int compare(Pair o1, Pair o2) {
							return o1.x-o2.x;
						}			
					});
				} sortPairX {
					Arrays.sort(p, new Comparator<Pair>() {
						public int compare(Pair o1, Pair o2) {
							return o1.x-o2.x;
						}			
					});
				} Arrays.sort(p, new Comparator<Pair>() {
						public int compare(Pair o1, Pair o2) {
							return o1.x-o2.x;
						}			
					}) Arrays.sort Arrays p new Comparator<Pair>() {
						public int compare(Pair o1, Pair o2) {
							return o1.x-o2.x;
						}			
					} Pair[] p p public static void sortPairY(Pair[] p) {
					Arrays.sort(p, new Comparator<Pair>() {
						public int compare(Pair o1, Pair o2) {
							return o1.y-o2.y;
						}			
					});
				} sortPairY {
					Arrays.sort(p, new Comparator<Pair>() {
						public int compare(Pair o1, Pair o2) {
							return o1.y-o2.y;
						}			
					});
				} Arrays.sort(p, new Comparator<Pair>() {
						public int compare(Pair o1, Pair o2) {
							return o1.y-o2.y;
						}			
					}) Arrays.sort Arrays p new Comparator<Pair>() {
						public int compare(Pair o1, Pair o2) {
							return o1.y-o2.y;
						}			
					} Pair[] p p public static void main(String[] args) {
					random = new Random(543534151132L + System.currentTimeMillis());
					InputStream inputStream = System.in;
			        OutputStream outputStream = System.out;
			        InputReader in = new InputReader(inputStream);
			        PrintWriter out = new PrintWriter(outputStream);
			        
			        task(in,out);
			        
					out.close();
					
				} main {
					random = new Random(543534151132L + System.currentTimeMillis());
					InputStream inputStream = System.in;
			        OutputStream outputStream = System.out;
			        InputReader in = new InputReader(inputStream);
			        PrintWriter out = new PrintWriter(outputStream);
			        
			        task(in,out);
			        
					out.close();
					
				} random = new Random(543534151132L + System.currentTimeMillis()) random new Random(543534151132L + System.currentTimeMillis()) InputStream inputStream = System.in; inputStream System.in System System.in OutputStream outputStream = System.out; outputStream System.out System System.out InputReader in = new InputReader(inputStream); in new InputReader(inputStream) PrintWriter out = new PrintWriter(outputStream); out new PrintWriter(outputStream) task(in,out) task in out out.close() out.close out String[] args args private static void task(InputReader in, PrintWriter out) {
					
					int n=in.nextInt();
					double ans=0;
					for(int i=0;i<n;i++) {
						int x=in.nextInt();
						ans+=1.0/x;
					}
					int res=(int)(1/ans);
					if((1./ans)==res)out.println(res);
					else out.println(1./ans);
				} task {
					
					int n=in.nextInt();
					double ans=0;
					for(int i=0;i<n;i++) {
						int x=in.nextInt();
						ans+=1.0/x;
					}
					int res=(int)(1/ans);
					if((1./ans)==res)out.println(res);
					else out.println(1./ans);
				} int n=in.nextInt(); n in.nextInt() in.nextInt in double ans=0; ans 0 for(int i=0;i<n;i++) {
						int x=in.nextInt();
						ans+=1.0/x;
					} int i=0; int i=0; i 0 i<n i n i++ i++ i {
						int x=in.nextInt();
						ans+=1.0/x;
					} {
						int x=in.nextInt();
						ans+=1.0/x;
					} int x=in.nextInt(); x in.nextInt() in.nextInt in ans+=1.0/x ans 1.0/x 1.0 x int res=(int)(1/ans); res (int)(1/ans) 1 ans if((1./ans)==res)out.println(res);
					else out.println(1./ans); (1./ans)==res (1./ans) 1. ans res out.println(res) out.println out res out.println(1./ans) out.println out 1./ans 1. ans InputReader in in PrintWriter out out public static int gcd(int a, int b)  
			    { 
			        BigInteger b1 = BigInteger.valueOf(a); 
			        BigInteger b2 = BigInteger.valueOf(b); 
			        BigInteger gcd = b1.gcd(b2); 
			            return gcd.intValue(); 
			    } gcd { 
			        BigInteger b1 = BigInteger.valueOf(a); 
			        BigInteger b2 = BigInteger.valueOf(b); 
			        BigInteger gcd = b1.gcd(b2); 
			            return gcd.intValue(); 
			    } BigInteger b1 = BigInteger.valueOf(a); b1 BigInteger.valueOf(a) BigInteger.valueOf BigInteger a BigInteger b2 = BigInteger.valueOf(b); b2 BigInteger.valueOf(b) BigInteger.valueOf BigInteger b BigInteger gcd = b1.gcd(b2); gcd b1.gcd(b2) b1.gcd b1 b2 return gcd.intValue(); gcd.intValue() gcd.intValue gcd int a a int b b public static long gcd(long a, long b)  
			    { 
			        BigInteger b1 = BigInteger.valueOf(a); 
			        BigInteger b2 = BigInteger.valueOf(b); 
			        BigInteger gcd = b1.gcd(b2); 
			            return gcd.longValue(); 
			    } gcd { 
			        BigInteger b1 = BigInteger.valueOf(a); 
			        BigInteger b2 = BigInteger.valueOf(b); 
			        BigInteger gcd = b1.gcd(b2); 
			            return gcd.longValue(); 
			    } BigInteger b1 = BigInteger.valueOf(a); b1 BigInteger.valueOf(a) BigInteger.valueOf BigInteger a BigInteger b2 = BigInteger.valueOf(b); b2 BigInteger.valueOf(b) BigInteger.valueOf BigInteger b BigInteger gcd = b1.gcd(b2); gcd b1.gcd(b2) b1.gcd b1 b2 return gcd.longValue(); gcd.longValue() gcd.longValue gcd long a a long b b static class Pair{
					int x;
					int y;
					
					public Pair(int x, int y) {
						this.x=x;
						this.y=y;
					}
				} Pair int x; x int y; y public Pair(int x, int y) {
						this.x=x;
						this.y=y;
					} Pair {
						this.x=x;
						this.y=y;
					} this.x=x this.x this this.x x this.y=y this.y this this.y y int x x int y y static class InputReader {
			        public BufferedReader reader;
			        public StringTokenizer tokenizer;
			
			        public InputReader(InputStream stream) {
			            reader = new BufferedReader(new InputStreamReader(stream), 32768);
			            tokenizer = null;
			        }
			
			        public String next() {
			            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			                try {
			                    tokenizer = new StringTokenizer(reader.readLine());
			                } catch (IOException e) {
			                    throw new RuntimeException(e);
			                }
			            }
			            return tokenizer.nextToken();
			        }
			
			        public int nextInt() {
			            return Integer.parseInt(next());
			        }
			        
			        public long nextLong() {
			            return Long.parseLong(next());
			        }
			        
			        public double nextDouble() {
			            return Double.parseDouble(next());
			        }
			        
			        public float nextFloat() {
			            return Float.parseFloat(next());
			        }
			        
			    } InputReader public BufferedReader reader; reader public StringTokenizer tokenizer; tokenizer public InputReader(InputStream stream) {
			            reader = new BufferedReader(new InputStreamReader(stream), 32768);
			            tokenizer = null;
			        } InputReader {
			            reader = new BufferedReader(new InputStreamReader(stream), 32768);
			            tokenizer = null;
			        } reader = new BufferedReader(new InputStreamReader(stream), 32768) reader new BufferedReader(new InputStreamReader(stream), 32768) tokenizer = null tokenizer null InputStream stream stream public String next() {
			            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			                try {
			                    tokenizer = new StringTokenizer(reader.readLine());
			                } catch (IOException e) {
			                    throw new RuntimeException(e);
			                }
			            }
			            return tokenizer.nextToken();
			        } next {
			            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			                try {
			                    tokenizer = new StringTokenizer(reader.readLine());
			                } catch (IOException e) {
			                    throw new RuntimeException(e);
			                }
			            }
			            return tokenizer.nextToken();
			        } while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			                try {
			                    tokenizer = new StringTokenizer(reader.readLine());
			                } catch (IOException e) {
			                    throw new RuntimeException(e);
			                }
			            } tokenizer == null || !tokenizer.hasMoreTokens() tokenizer == null tokenizer null !tokenizer.hasMoreTokens() tokenizer.hasMoreTokens() tokenizer.hasMoreTokens tokenizer {
			                try {
			                    tokenizer = new StringTokenizer(reader.readLine());
			                } catch (IOException e) {
			                    throw new RuntimeException(e);
			                }
			            } try {
			                    tokenizer = new StringTokenizer(reader.readLine());
			                } catch (IOException e) {
			                    throw new RuntimeException(e);
			                } catch (IOException e) {
			                    throw new RuntimeException(e);
			                } IOException e {
			                    throw new RuntimeException(e);
			                } throw new RuntimeException(e); new RuntimeException(e) {
			                    tokenizer = new StringTokenizer(reader.readLine());
			                } tokenizer = new StringTokenizer(reader.readLine()) tokenizer new StringTokenizer(reader.readLine()) return tokenizer.nextToken(); tokenizer.nextToken() tokenizer.nextToken tokenizer public int nextInt() {
			            return Integer.parseInt(next());
			        } nextInt {
			            return Integer.parseInt(next());
			        } return Integer.parseInt(next()); Integer.parseInt(next()) Integer.parseInt Integer next() next public long nextLong() {
			            return Long.parseLong(next());
			        } nextLong {
			            return Long.parseLong(next());
			        } return Long.parseLong(next()); Long.parseLong(next()) Long.parseLong Long next() next public double nextDouble() {
			            return Double.parseDouble(next());
			        } nextDouble {
			            return Double.parseDouble(next());
			        } return Double.parseDouble(next()); Double.parseDouble(next()) Double.parseDouble Double next() next public float nextFloat() {
			            return Float.parseFloat(next());
			        } nextFloat {
			            return Float.parseFloat(next());
			        } return Float.parseFloat(next()); Float.parseFloat(next()) Float.parseFloat Float next() next 			public class Main {
				static Random random;
				private static void mySort(int[] s) {
			        for (int i = 0; i < s.length; ++i) {
			            int j = random.nextInt(i + 1);
			            int t = s[i];
			            s[i] = s[j];
			            s[j] = t;
			        }
			        Arrays.sort(s);
			    }
				
				static class Pair{
					int x;
					int y;
					
					public Pair(int x, int y) {
						this.x=x;
						this.y=y;
					}
				}
				
				public static void sortPairX(Pair[] p) {
					Arrays.sort(p, new Comparator<Pair>() {
						public int compare(Pair o1, Pair o2) {
							return o1.x-o2.x;
						}			
					});
				}
				
				public static void sortPairY(Pair[] p) {
					Arrays.sort(p, new Comparator<Pair>() {
						public int compare(Pair o1, Pair o2) {
							return o1.y-o2.y;
						}			
					});
				}
				
				
			
				public static void main(String[] args) {
					random = new Random(543534151132L + System.currentTimeMillis());
					InputStream inputStream = System.in;
			        OutputStream outputStream = System.out;
			        InputReader in = new InputReader(inputStream);
			        PrintWriter out = new PrintWriter(outputStream);
			        
			        task(in,out);
			        
					out.close();
					
				}
				
			
				private static void task(InputReader in, PrintWriter out) {
					
					int n=in.nextInt();
					double ans=0;
					for(int i=0;i<n;i++) {
						int x=in.nextInt();
						ans+=1.0/x;
					}
					int res=(int)(1/ans);
					if((1./ans)==res)out.println(res);
					else out.println(1./ans);
				}	
				

				public static int gcd(int a, int b)  
			    { 
			        BigInteger b1 = BigInteger.valueOf(a); 
			        BigInteger b2 = BigInteger.valueOf(b); 
			        BigInteger gcd = b1.gcd(b2); 
			            return gcd.intValue(); 
			    } 
			      
			    public static long gcd(long a, long b)  
			    { 
			        BigInteger b1 = BigInteger.valueOf(a); 
			        BigInteger b2 = BigInteger.valueOf(b); 
			        BigInteger gcd = b1.gcd(b2); 
			            return gcd.longValue(); 
			    } 
				
				static class InputReader {
			        public BufferedReader reader;
			        public StringTokenizer tokenizer;
			
			        public InputReader(InputStream stream) {
			            reader = new BufferedReader(new InputStreamReader(stream), 32768);
			            tokenizer = null;
			        }
			
			        public String next() {
			            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			                try {
			                    tokenizer = new StringTokenizer(reader.readLine());
			                } catch (IOException e) {
			                    throw new RuntimeException(e);
			                }
			            }
			            return tokenizer.nextToken();
			        }
			
			        public int nextInt() {
			            return Integer.parseInt(next());
			        }
			        
			        public long nextLong() {
			            return Long.parseLong(next());
			        }
			        
			        public double nextDouble() {
			            return Double.parseDouble(next());
			        }
			        
			        public float nextFloat() {
			            return Float.parseFloat(next());
			        }
			        
			    }
			
			} 			public class Main {
				static Random random;
				private static void mySort(int[] s) {
			        for (int i = 0; i < s.length; ++i) {
			            int j = random.nextInt(i + 1);
			            int t = s[i];
			            s[i] = s[j];
			            s[j] = t;
			        }
			        Arrays.sort(s);
			    }
				
				static class Pair{
					int x;
					int y;
					
					public Pair(int x, int y) {
						this.x=x;
						this.y=y;
					}
				}
				
				public static void sortPairX(Pair[] p) {
					Arrays.sort(p, new Comparator<Pair>() {
						public int compare(Pair o1, Pair o2) {
							return o1.x-o2.x;
						}			
					});
				}
				
				public static void sortPairY(Pair[] p) {
					Arrays.sort(p, new Comparator<Pair>() {
						public int compare(Pair o1, Pair o2) {
							return o1.y-o2.y;
						}			
					});
				}
				
				
			
				public static void main(String[] args) {
					random = new Random(543534151132L + System.currentTimeMillis());
					InputStream inputStream = System.in;
			        OutputStream outputStream = System.out;
			        InputReader in = new InputReader(inputStream);
			        PrintWriter out = new PrintWriter(outputStream);
			        
			        task(in,out);
			        
					out.close();
					
				}
				
			
				private static void task(InputReader in, PrintWriter out) {
					
					int n=in.nextInt();
					double ans=0;
					for(int i=0;i<n;i++) {
						int x=in.nextInt();
						ans+=1.0/x;
					}
					int res=(int)(1/ans);
					if((1./ans)==res)out.println(res);
					else out.println(1./ans);
				}	
				

				public static int gcd(int a, int b)  
			    { 
			        BigInteger b1 = BigInteger.valueOf(a); 
			        BigInteger b2 = BigInteger.valueOf(b); 
			        BigInteger gcd = b1.gcd(b2); 
			            return gcd.intValue(); 
			    } 
			      
			    public static long gcd(long a, long b)  
			    { 
			        BigInteger b1 = BigInteger.valueOf(a); 
			        BigInteger b2 = BigInteger.valueOf(b); 
			        BigInteger gcd = b1.gcd(b2); 
			            return gcd.longValue(); 
			    } 
				
				static class InputReader {
			        public BufferedReader reader;
			        public StringTokenizer tokenizer;
			
			        public InputReader(InputStream stream) {
			            reader = new BufferedReader(new InputStreamReader(stream), 32768);
			            tokenizer = null;
			        }
			
			        public String next() {
			            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			                try {
			                    tokenizer = new StringTokenizer(reader.readLine());
			                } catch (IOException e) {
			                    throw new RuntimeException(e);
			                }
			            }
			            return tokenizer.nextToken();
			        }
			
			        public int nextInt() {
			            return Integer.parseInt(next());
			        }
			        
			        public long nextLong() {
			            return Long.parseLong(next());
			        }
			        
			        public double nextDouble() {
			            return Double.parseDouble(next());
			        }
			        
			        public float nextFloat() {
			            return Float.parseFloat(next());
			        }
			        
			    }
			
			} Main
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Scanner;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.IdentityHashMap;
			
			
/**
 * for competitive programming
 * @author BrolyCode
 * @version 1.0.0
 */
			
			public class Main {
				static Random random;
				private static void mySort(int[] s) {
			        for (int i = 0; i < s.length; ++i) {
			            int j = random.nextInt(i + 1);
			            int t = s[i];
			            s[i] = s[j];
			            s[j] = t;
			        }
			        Arrays.sort(s);
			    }
				
				static class Pair{
					int x;
					int y;
					
					public Pair(int x, int y) {
						this.x=x;
						this.y=y;
					}
				}
				
				public static void sortPairX(Pair[] p) {
					Arrays.sort(p, new Comparator<Pair>() {
						public int compare(Pair o1, Pair o2) {
							return o1.x-o2.x;
						}			
					});
				}
				
				public static void sortPairY(Pair[] p) {
					Arrays.sort(p, new Comparator<Pair>() {
						public int compare(Pair o1, Pair o2) {
							return o1.y-o2.y;
						}			
					});
				}
				
				
			
				public static void main(String[] args) {
					random = new Random(543534151132L + System.currentTimeMillis());
					InputStream inputStream = System.in;
			        OutputStream outputStream = System.out;
			        InputReader in = new InputReader(inputStream);
			        PrintWriter out = new PrintWriter(outputStream);
			        
			        task(in,out);
			        
					out.close();
					
				}
				
			
				private static void task(InputReader in, PrintWriter out) {
					
					int n=in.nextInt();
					double ans=0;
					for(int i=0;i<n;i++) {
						int x=in.nextInt();
						ans+=1.0/x;
					}
					int res=(int)(1/ans);
					if((1./ans)==res)out.println(res);
					else out.println(1./ans);
				}	
				

				public static int gcd(int a, int b)  
			    { 
			        BigInteger b1 = BigInteger.valueOf(a); 
			        BigInteger b2 = BigInteger.valueOf(b); 
			        BigInteger gcd = b1.gcd(b2); 
			            return gcd.intValue(); 
			    } 
			      
			    public static long gcd(long a, long b)  
			    { 
			        BigInteger b1 = BigInteger.valueOf(a); 
			        BigInteger b2 = BigInteger.valueOf(b); 
			        BigInteger gcd = b1.gcd(b2); 
			            return gcd.longValue(); 
			    } 
				
				static class InputReader {
			        public BufferedReader reader;
			        public StringTokenizer tokenizer;
			
			        public InputReader(InputStream stream) {
			            reader = new BufferedReader(new InputStreamReader(stream), 32768);
			            tokenizer = null;
			        }
			
			        public String next() {
			            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			                try {
			                    tokenizer = new StringTokenizer(reader.readLine());
			                } catch (IOException e) {
			                    throw new RuntimeException(e);
			                }
			            }
			            return tokenizer.nextToken();
			        }
			
			        public int nextInt() {
			            return Integer.parseInt(next());
			        }
			        
			        public long nextLong() {
			            return Long.parseLong(next());
			        }
			        
			        public double nextDouble() {
			            return Double.parseDouble(next());
			        }
			        
			        public float nextFloat() {
			            return Float.parseFloat(next());
			        }
			        
			    }
			
			}
			
		  
		  