import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author AyushKM
 */
public class Main {
   public static void main(String[] args) {
      InputStream inputStream = System.in;
      OutputStream outputStream = System.out;
      InputReader in = new InputReader(inputStream);
      OutputWriter out = new OutputWriter(outputStream);
      BResistorsInParallel solver = new BResistorsInParallel();
      solver.solve(1, in, out);
      out.close();
   }

   static class BResistorsInParallel {
      public void solve(int testNumber, InputReader in, OutputWriter out) {
         int n = in.nextInt();
         double a = 0;
         for (int x = 0; x < n; x++) {
            a += (1.0 / in.nextDouble());
         }
         out.println(1 / a);
      }

   }

   static class InputReader {
      private InputStream stream;
      private byte[] buf = new byte[1024];
      private int curChar;
      private int numChars;
      private InputReader.SpaceCharFilter filter;

      public InputReader(InputStream stream) {
         this.stream = stream;
      }

      public int read() {
         if (numChars == -1) {
            throw new InputMismatchException();
         }
         if (curChar >= numChars) {
            curChar = 0;
            try {
               numChars = stream.read(buf);
            } catch (IOException e) {
               throw new InputMismatchException();
            }
            if (numChars <= 0) {
               return -1;
            }
         }
         return buf[curChar++];
      }

      public int nextInt() {
         int c = read();
         while (isSpaceChar(c)) {
            c = read();
         }
         int sgn = 1;
         if (c == '-') {
            sgn = -1;
            c = read();
         }
         int res = 0;
         do {
            if (c < '0' || c > '9') {
               throw new InputMismatchException();
            }
            res *= 10;
            res += c - '0';
            c = read();
         } while (!isSpaceChar(c));
         return res * sgn;
      }

      public boolean isSpaceChar(int c) {
         if (filter != null) {
            return filter.isSpaceChar(c);
         }
         return isWhitespace(c);
      }

      public static boolean isWhitespace(int c) {
         return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
      }

      public double nextDouble() {
         int c = read();
         while (isSpaceChar(c)) {
            c = read();
         }
         int sgn = 1;
         if (c == '-') {
            sgn = -1;
            c = read();
         }
         double res = 0;
         while (!isSpaceChar(c) && c != '.') {
            if (c == 'e' || c == 'E') {
               return res * Math.pow(10, nextInt());
            }
            if (c < '0' || c > '9') {
               throw new InputMismatchException();
            }
            res *= 10;
            res += c - '0';
            c = read();
         }
         if (c == '.') {
            c = read();
            double m = 1;
            while (!isSpaceChar(c)) {
               if (c == 'e' || c == 'E') {
                  return res * Math.pow(10, nextInt());
               }
               if (c < '0' || c > '9') {
                  throw new InputMismatchException();
               }
               m /= 10;
               res += (c - '0') * m;
               c = read();
            }
         }
         return res * sgn;
      }

      public interface SpaceCharFilter {
         public boolean isSpaceChar(int ch);

      }

   }

   static class OutputWriter {
      private final PrintWriter writer;

      public OutputWriter(OutputStream outputStream) {
         writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
      }

      public OutputWriter(Writer writer) {
         this.writer = new PrintWriter(writer);
      }

      public void print(Object... objects) {
         for (int i = 0; i < objects.length; i++) {
            if (i != 0) {
               writer.print(' ');
            }
            writer.print(objects[i]);
         }
      }

      public void println(Object... objects) {
         print(objects);
         writer.println();
      }

      public void close() {
         writer.close();
      }

   }
}



Measured memory_bytes: 22612