Problem:
Score : 300 points

Problem Statement

Snuke has a fair N-sided die that shows the integers from 1 to N with equal probability and a fair coin. He will play the following game with them:

Throw the die. The current score is the result of the die.

As long as the score is between 1 and K-1 (inclusive), keep flipping the coin. The score is doubled each time the coin lands heads up, and the score becomes 0 if the coin lands tails up.

The game ends when the score becomes 0 or becomes K or above. Snuke wins if the score is K or above, and loses if the score is 0.

You are given N and K. Find the probability that Snuke wins the game.

Constraints

1 ≤ N ≤ 10^5

1 ≤ K ≤ 10^5

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N K

Output

Print the probability that Snuke wins the game. The output is considered correct when the absolute or relative error is at most 10^{-9}.

Sample Input 1

3 10

Sample Output 1

0.145833333333

If the die shows 1, Snuke needs to get four consecutive heads from four coin flips to obtain a score of 10 or above. The probability of this happening is \frac{1}{3} \times (\frac{1}{2})^4 = \frac{1}{48}.

If the die shows 2, Snuke needs to get three consecutive heads from three coin flips to obtain a score of 10 or above. The probability of this happening is \frac{1}{3} \times (\frac{1}{2})^3 = \frac{1}{24}.

If the die shows 3, Snuke needs to get two consecutive heads from two coin flips to obtain a score of 10 or above. The probability of this happening is \frac{1}{3} \times (\frac{1}{2})^2 = \frac{1}{12}.

Thus, the probability that Snuke wins is \frac{1}{48} + \frac{1}{24} + \frac{1}{12} = \frac{7}{48} \simeq 0.1458333333.

Sample Input 2

100000 5

Sample Output 2

0.999973749998

Solution in Scala (2.11.7) (judge verdict: Wrong Answer)

object Main {

  def main(args: Array[String]): Unit = {
    import scala.io.StdIn._

    val Array(n, k) = readLine().split(" ").map(_.toInt)

    // i 連続でコインが2倍になって行くと、目 * point(i) 点
    val point = (0 to 17).map(i => Math.pow(1/2.0, i))

    // log 2 x = Math.log(x) - Math.log(2)
    // 1/N *
    val p = (1 to Math.min(n, k-1)).foldLeft(0.0) { (b, i) =>
      val x = k / i
      val nx = Math.ceil(Math.log(x) / Math.log(2)).toInt
      b + point(nx)
    }
    // k以上の目が出る場合には常に勝利する
    // k以上の目が常に出ない場合には、
    if (n >= k) {
      println((p + (n - k + 1))/n)
    } else {
      println(p / n)
    }
  }

  // 勝つためには連続で表が出る必要がある。
  // サイコロの出る可能性がある全ての目に対して、確率を足し合わせたもの
  // サイコロのある目の出る確率は、1/可能性、*出た目を何倍すればいいか

  // 常に勝てないケース？コーナーケースを考える
  // N = 1, K = 10^5
  // N = 1, K = 1
  // N = 10^5, K = 1
  // N = 10^5, K = 10^5
}