(Note: to view the following problem you need to register for the ITMO course at codeforces edu). This problem is similar to the problem you have asked. The editorial is available in edu as well (here).

Binary search works. I have written code below.

I will just explain def good(x) which checks whether you can make the answer $$$\le x$$$

let s be the prefix array of a (one indexed for convenience)
if we remove a[l...r] the average so that average is $$$\le x$$$

which is the same as

Now, note that the number of terms on the left hand side is $n - r + l - 1$ which is the number of $$$x$$$ is being multiplied with on the right hand side. We can subtract $$$x$$$ from the equation $$$n - r + l - 1$$$ times to get

Define b[i] = a[i] - x. We basically want to choose some prefix and suffix of b which don't overlap and have a sum <= 0. This can be done easily. Let pb be the prefix sum array of b. We want to find l, r such that

which can be rewritten as

Here the left hand side is a constant. We want to make the right handside as big as possible which is easily done using Kadane's algorithm!

(keep in mind the restriction that 1 < l <= r < n)

Here is the code

a = [0] + list(map(int, input().split()))
n = len(a) - 1

def good(x):
    b = [0] * (n + 1)
    for i in range(1, n + 1):
        b[i] = a[i] - x
    dp = [0] * len(b)
    for i in range(2, n):
        if dp[i - 1] >= 0 and i > 2:
            dp[i] = b[i] + dp[i - 1]
        else:
            dp[i] = b[i]

    return sum(b) <= max(dp[2:n])

lo = min(a) - 1
hi = max(a)
// the answer lies in (lo, hi], we will binary search the range  
// when binary searching the double values it's generally a bad idea to use a while loop like  
// while(lo + delta < hi) do something  
// instead just a run a for loop 100 or so times depending on range of search  

for _ in range(100):
    mid = (lo + hi) / 2
    if good(mid):
        hi = mid
    else:
        lo = mid

print(hi)