#include <bits/stdc++.h>

using std::cin, std::cout, std::endl, std::flush, std::cerr;
using std::min, std::max;
using std::pair, std::tuple;
using std::set, std::map, std::multiset;
using std::vector, std::array, std::queue, std::deque;
using std::views::iota, std::views::reverse;

template <class A> constexpr int sz(A&& a) {
    return int(std::size(std::forward<A>(a)));
}

using i64 = int64_t;

template <class T> using Vec = std::vector<T>;

int main() {
    std::ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << std::fixed << std::setprecision(20);

    int N, K;
    cin >> N >> K;
    auto A = Vec<int>(N);
    for (int& a : A) cin >> a;

    using F = double;

    auto is_good = [&](F target) -> bool {
        auto pref = Vec<F>(N + 1);
        pref[0] = 0;
        for (int i : iota(0, N)) {
            pref[i + 1] = pref[i] + (A[i] - target);
        }

        auto vals = pref;
        std::sort(begin(vals), end(vals));
        vals.erase(std::unique(begin(vals), end(vals)), end(vals));
        int V = sz(vals);
        auto lookup = [&](F x) -> int {
            return int(std::lower_bound(begin(vals), end(vals), x) -
                       begin(vals));
        };

        int S = std::bit_ceil<uint32_t>(V);
        auto seg = Vec<int>(2 * S, -1);
        seg[S + lookup(F(0))] = 0;
        auto update = [&](int a) -> void {
            seg[a] = max(seg[2 * a + 0], seg[2 * a + 1]);
        };
        for (int a : iota(1, S) | reverse) {
            update(a);
        }

        for (int i : iota(1, N + 1)) {
            int v = lookup(pref[i]);
            int dp = -1;
            for (int a = S + 0, b = S + (v + 1); a < b; a /= 2, b /= 2) {
                if (a & 1) dp = max(dp, seg[a++]);
                if (b & 1) dp = max(dp, seg[--b]);
            }
            if (dp >= 0) {
                dp++;
                for (int a = S + v; a > 0; a /= 2) {
                    seg[a] = max(seg[a], dp);
                }
            }
            if (i == N) {
                return dp >= K;
            }
        }
        assert(false);
    };

    F mi = 0, ma = 2e3;
    for (int z = 0; z < 66; z++) {
        F md = (mi + ma) / 2;
        if (is_good(md)) {
            mi = md;
        } else {
            ma = md;
        }
    }
    cout << mi << '\n';

    return 0;
}