#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }


/*
  f: ans
  g[i]: when i is pickup
  f = \sum[i] P[i] g[i]
  g[i] = 1 + q[i] 0 + (1-q[i]) C f + (1-q[i]) (1-C) g[i]
  
  g[i] = (1 + (1-q[i]) C f) / (1 - (1-q[i]) (1-C))
  f = (\sum[i] P[i] / (1 - (1-q[i]) (1-C))) / (1 - \sum[i] P[i] (1-q[i]) C / (1 - (1-q[i]) (1-C)))
    = (\sum[i] P[i] / (1 - (1-q[i]) (1-C))) / (\sum[i] P[i] q[i] / (1 - (1-q[i]) (1-C)))
  (\because \sum[i] P[i] = 1)
  
  df/dq[i] = ((-P[i] (1-C) / (1 - (1-q[i]) (1-C))^2) denom - numer (-P[i] C / (1 - (1-q[i]) (1-C))^2)) / denom^2
           = (P[i] / (1 - (1-q[i]) (1-C))^2) ((-(1-C) denom + C numer) / denom^2)
  
  P[i] / (1 - (1-q[i]) (1-C))^2 = const.
  or boundary
  q[i] = 1 - (1 - a sqrt(P[i])) / (1-C)
       = (a sqrt(P[i]) - C) / (1-C)
*/

using Double = double;

int N;
Double C;
vector<Double> P;

int main() {
  int tmp;
  for (; ~scanf("%d%d", &N, &tmp); ) {
    C = tmp / 100.0;
    P.resize(N);
    for (int i = 0; i < N; ++i) {
      scanf("%d", &tmp);
      P[i] = tmp;
    }
    sort(P.begin(), P.end());
    {
      Double sumP = 0.0;
      for (int i = 0; i < N; ++i) sumP += P[i];
      for (int i = 0; i < N; ++i) P[i] /= sumP;
    }
    
    Double ans;
    if (C == 1) {
      // go for max
      ans = 1.0 / P[N - 1];
    } else {
      vector<Double> ss(N);
      for (int i = 0; i < N; ++i) {
        ss[i] = sqrt(P[i]);
      }
      vector<Double> qs(N);
      Double lo = 0.0, hi = C / ss[0] + 1.0;
      auto check = [&](Double a) -> bool {
        Double sum = 0.0;
        for (int i = 0; i < N; ++i) {
          sum += qs[i] = max<Double>((a * ss[i] - C) / (1 - C), 0.0);
        }
        return (sum <= 1.0);
      };
      for (int iter = 0; iter < 100; ++iter) {
        const Double mid = (lo + hi) / 2;
        (check(mid) ? lo : hi) = mid;
      }
      check(lo);
      Double numer = 0.0, denom = 0.0;
      for (int i = 0; i < N; ++i) {
        const Double t = P[i] / (1 - (1 - qs[i]) * (1 - C));
        numer += t;
        denom += t * qs[i];
      }
      ans = numer / denom;
    }
    printf("%.12f\n", (double)ans);
  }
  return 0;
}