#include <cstdio>
#include <cstring>
#include <algorithm>
#define FILL(a, n, x) memset((a), (x), sizeof ((a)[0]) * (n))
#define COPY(a, n, b) memcpy((b), (a), sizeof ((a)[0]) * (n))
using namespace std;

typedef long long li;

// const int mod = 1e9 + 7, inv2 = mod + 1 >> 1;
// inline int Add(int x) { return x >= mod ? x - mod : x; }
// inline void Add(int &x, int y) { x += y; if (x >= mod) x -= mod; }
// inline int Sub(int x) { return x < 0 ? x + mod : x; }
// inline void Sub(int &x, int y) { x -= y; if (x < 0) x += mod; }
// inline int Mul(int x, int y) { return (li)x * y % mod; }

// int Pow(int x, int y) {
//   int z = 1;
//   for (; y; y >>= 1) {
//     if (y & 1) z = Mul(z, x);
//     x = Mul(x, x);
//   }
//   return z;
// }

// ----------------------------------------

const int maxn = 6, maxm = 50;

int n, m;
int L[maxn], L2[maxn];
int S[maxn];
li tot, ans;
li dp[maxm + 1][maxn][maxm][maxn][1 << maxn - 1];

bool Check(int pos1, int id1, int pos2, int id2) {
  if (pos1 + L2[id1] != pos2) return pos1 + L2[id1] > pos2;
  return id1 > id2;
}

void Max(int &pos, int &id, int pos1, int id1, int pos2, int id2) {
  if (pos1 + L2[id1] > pos2 + L2[id2]) {
    pos = pos1;
    id = id1;
    return;
  }
  if (pos1 + L2[id1] < pos2 + L2[id2]) {
    pos = pos2;
    id = id2;
    return;
  }
  if (id1 > id2) {
    pos = pos1;
    id = id1;
  } else {
    pos = pos2;
    id = id2;
  }
}

void Solve(void) {
  // puts("solve");

  li tmp = 1;
  for (int i = 1; i < n; ++i) tmp *= m;
  tot += tmp;
  for (int i = 0; i < n; ++i) L2[i] = L[S[i]];

  memset(dp, 0, sizeof dp);
  dp[0][0][0][0][0] = 1;
  for (int pos = 0; pos < m; ++pos) {
    for (int id = 0; id < n; ++id) {
      for (int pos0 = 0; pos0 <= pos; ++pos0) {
        for (int id0 = 0; id0 < n; ++id0) {
          for (int s = 0; s < 1 << n - 1; ++s) {
            li val = dp[pos][id][pos0][id0][s];
            if (val == 0) continue;
            // printf("dp[%d][%d][%d][%d][%d] = %lld\n", pos, id, pos0, id0, s, val);

            int pos2 = pos, id2 = id + 1;
            if (id2 == n) {
              pos2 += 1;
              id2 = 0;
            }

            // cannot place it
            if (id == 0 || s >> (id - 1) & 1) {
              if (Check(pos0, id0, pos2, id2)) {
                dp[pos2][id2][pos0][id0][s] += val;
              }
              continue;
            }

            int pos3, id3;
            Max(pos3, id3, pos, id, pos0, id0);
            // printf("max (%d %d %d %d) = (%d %d)\n", pos, id, pos0, id0, pos3, id3);

            // do not place it
            if (Check(pos0, id0, pos2, id2)) {
              dp[pos2][id2][pos0][id0][s] += val;
              // printf("upd %d %d %d %d %d\n", pos2, id2, pos0, id0, s);
            }

            // place it
            if (Check(pos, id, pos2, id2)) {
              dp[pos2][id2][pos3][id3][s | 1 << (id - 1)] += val;
            }
          }
        }
      }
    }
  }

  // dp[m][0][..][..][U]
  for (int pos0 = 0; pos0 < m; ++pos0) {
    for (int id0 = 0; id0 < n; ++id0) {
      if (pos0 + L2[id0] >= m) {
        // printf("query dp[%d][%d][%d][%d][%d] = %lld\n", m, 0, pos0, id0, (1 << n - 1) - 1, dp[m][0][pos0][id0][(1 << n - 1) - 1]);
        ans += dp[m][0][pos0][id0][(1 << n - 1) - 1];
      }
    }
  }
}

int main(void) {
  scanf("%d%d", &n, &m);
  for (int i = 0; i < n; ++i) scanf("%d", L + i);
  swap(*max_element(L, L + n), L[0]);
  if (L[0] >= m) {
    puts("1");
    return 0;
  }
  for (int i = 0; i < n; ++i) S[i] = i;
  do Solve(); while (next_permutation(S + 1, S + n));
  printf("%.20Lf\n", (long double)ans / tot);
  return 0;
}


Measured memory_bytes: 23168