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 in Scala (2.11.7) (judge verdict: Wrong Answer)


object Main {
  def main(args: Array[String]): Unit = {
    val sc = new java.util.Scanner(System.in)
    val k = sc.nextInt
    val ra =
      (0 until k).foldLeft(Rational(0, 1))(
        (acc, _) => acc + Rational(1, sc.nextInt)
      )
    sc.close()

    println(BigDecimal(ra.denom) / BigDecimal(ra.numer))
  }

  class Rational(n: Int, d: Int) extends Ordered[Rational] {
    require(d != 0)

    private val g = Rational.gcd(n.abs, d.abs)
    val numer: Int = n / g * d.signum
    val denom: Int = d.abs / g

    def this(n: Int) = this(n, 1)

    override def toString = numer + (if (denom == 1) "" else ("/" + denom))

    // default methods
    def +(that: Rational): Rational =
      new Rational(numer * that.denom + that.numer * denom, denom * that.denom)
    def -(that: Rational): Rational = this + (-that)
    def unary_- = new Rational(-numer, denom)
    def abs = new Rational(numer.abs, denom)
    def signum = new Rational(numer.signum)

    def *(that: Rational): Rational =
      new Rational(this.numer * that.numer, this.denom * that.denom)
    def /(that: Rational): Rational = this * that.inverse
    def inverse = new Rational(denom, numer)

    def compare(that: Rational) =
      this.numer * that.denom - that.numer * this.denom
    def equals(that: Rational) =
      this.numer == that.numer && this.denom == that.denom

  }

  object Rational {
    implicit def intToRational(x: Int) = new Rational(x)
    private def gcd(a: Int, b: Int): Int = if (b == 0) a else gcd(b, a % b)

    def apply(numer: Int, denom: Int) = new Rational(numer, denom)
    def apply(numer: Int) = new Rational(numer)
  }
}