10
-405 -230 252 -393 -390 -259 97 163 81 -129
 3
10000 -10000 10000
 1
-10000
 20
-16 -23 29 44 -40 -50 -41 34 -38 30 -12 28 -44 -49 15 50 -28 38 -2 0

702.333333333333712
 10000.000000000016371
 0.000000000000000
 113.875000000000043


import java.util.*;
import java.io.*;

/**
 *
 * @author umang
 * ////////////767C
 */

public class ProblemD {

    public static int mod = (int) (1e9+7);
    public static InputReader in;
    public static PrintWriter out;
    
    static double maxSubArraySum(double a[],double x)
    {
        int size = a.length;
        double max_so_far = Integer.MIN_VALUE, max_ending_here = 0;
 
        for (int i = 0; i < size; i++)
        {
            max_ending_here = max_ending_here + a[i]-x;
            if (max_so_far < max_ending_here)
                max_so_far = max_ending_here;
            if (max_ending_here < 0)
                max_ending_here = 0;
        }
        
        return max_so_far;
    }

    static double minSubArraySum(double a[],double x)
    {
        int size = a.length;
        double min_so_far = Integer.MAX_VALUE, min_ending_here = 0;
 
        for (int i = 0; i < size; i++)
        {
            min_ending_here = min_ending_here + a[i]-x;
            if (min_so_far > min_ending_here)
                min_so_far = min_ending_here;
            if (min_ending_here > 0)
                min_ending_here = 0;
        }
        
        return min_so_far;
    }

    
    public static void solve(){
        in = new InputReader(System.in);
        out = new PrintWriter(System.out);
        
        int n=in.nextInt();
        double[] a=new double[n];
        double min=Integer.MAX_VALUE;
        double max=Integer.MIN_VALUE;

        for(int i=0;i<n;i++){
            a[i]=in.nextInt();
            min=Math.min(min,a[i]);
            max=Math.max(max,a[i]);
        }
        
        double s=min;
        double e=max;
        double ans=Long.MAX_VALUE;
        while(e-s>=0.000001){
            double m=(s+e)/2;
            double x1=maxSubArraySum(a, m);
            x1=Math.max(x1,Math.abs(minSubArraySum(a, m)));
            double x2=maxSubArraySum(a, m+1);
            x2=Math.max(x2,Math.abs(minSubArraySum(a, m+1)));            
            double x3=maxSubArraySum(a, m-1);
            x3=Math.max(x3,Math.abs(minSubArraySum(a, m-1)));            

            //debug(x3,x1,x2,m,s,e,ans);
            if(x2<x1){
                s=m;
                ans=Math.min(ans,x2);
            }
            else{
                e=m;
                ans=Math.min(ans, x1);
            }
            //debug(s,e);
        }
        
        out.println(ans);
        out.close();
    }
    
    public static void main(String[] args) {

        new Thread(null ,new Runnable(){
                   public void run(){
                       try{
                           solve();
                       } catch(Exception e){
                           e.printStackTrace();
                       }
                   }
               },"1",1<<28).start();
        
    }
    
    static class Pair implements Comparable<Pair>{

        String s;
        String x;
        int i;

        public Pair(String s,String x,int i) {
            this.s=s;
            this.x=x;
            this.i=i;
        }
        
        
	public int compareTo(Pair o) {
            return this.s.compareTo(o.s);
        }

    
    } 
    
    public static long add(long x, long y) {
	return (x + y)%mod;
    }
    
    public static long mul(long x, long y) {
	return (x*y)%mod;
    }
    public static boolean isPal(String s){
        for(int i=0, j=s.length()-1;i<=j;i++,j--){
                if(s.charAt(i)!=s.charAt(j)) return false;
        }
        return true;
    }
    public static String rev(String s){
            StringBuilder sb=new StringBuilder(s);
            sb.reverse();
            return sb.toString();
    }

    public static long gcd(long x,long y){
    if(x%y==0)
            return y;
    else
            return gcd(y,x%y);
    }

    public static int gcd(int x,int y){
    if(x%y==0)
            return y;
    else 
            return gcd(y,x%y);
    }

    public static long gcdExtended(long a,long b,long[] x){

        if(a==0){
            x[0]=0;
            x[1]=1;
            return b;
        }
        long[] y=new long[2];
        long gcd=gcdExtended(b%a, a, y);

        x[0]=y[1]-(b/a)*y[0];
        x[1]=y[0];

        return gcd;
    }

    public static int abs(int a,int b){
    return (int)Math.abs(a-b);
    }

    public static long abs(long a,long b){
    return (long)Math.abs(a-b);
    }

    public static int max(int a,int b){
    if(a>b)
            return a;
    else
            return b;
    }

    public static int min(int a,int b){
    if(a>b)
            return b;
    else 
            return a;
    }

    public static long max(long a,long b){
    if(a>b)
            return a;
    else
            return b;
    }

    public static long min(long a,long b){
    if(a>b)
            return b;
    else 
            return a;
    }

    public static long pow(long n,long p,long m){
     long  result = 1;
      if(p==0)
        return 1;
    if (p==1)
        return n;
    while(p!=0)
    {
        if(p%2==1)
            result *= n;
        if(result>=m)
        result%=m;
        p >>=1;
        n*=n;
        if(n>=m)
        n%=m;
    }
    return result;
    }

    public static long pow(long n,long p){
    long  result = 1;
      if(p==0)
        return 1;
    if (p==1)
        return n;
    while(p!=0)
    {
        if(p%2==1)
            result *= n;	    
        p >>=1;
        n*=n;	    
    }
    return result;
    }
     public static void debug(Object... o) {
            System.out.println(Arrays.deepToString(o));
    }

    static class InputReader {

            private final InputStream stream;
            private final byte[] buf = new byte[8192];
            private int curChar, snumChars;
            private SpaceCharFilter filter;

            public InputReader(InputStream stream) {
                    this.stream = stream;
            }

            public int snext() {
                    if (snumChars == -1)
                            throw new InputMismatchException();
                    if (curChar >= snumChars) {
                            curChar = 0;
                            try {
                                    snumChars = stream.read(buf);
                            } catch (IOException e) {
                                    throw new InputMismatchException();
                            }
                            if (snumChars <= 0)
                                    return -1;
                    }
                    return buf[curChar++];
            }

            public int nextInt() {
                    int c = snext();
                    while (isSpaceChar(c)) {
                            c = snext();
                    }
                    int sgn = 1;
                    if (c == '-') {
                            sgn = -1;
                            c = snext();
                    }
                    int res = 0;
                    do {
                            if (c < '0' || c > '9')
                                    throw new InputMismatchException();
                            res *= 10;
                            res += c - '0';
                            c = snext();
                    } while (!isSpaceChar(c));
                    return res * sgn;
            }

            public long nextLong() {
                    int c = snext();
                    while (isSpaceChar(c)) {
                            c = snext();
                    }
                    int sgn = 1;
                    if (c == '-') {
                            sgn = -1;
                            c = snext();
                    }
                    long res = 0;
                    do {
                            if (c < '0' || c > '9')
                                    throw new InputMismatchException();
                            res *= 10;
                            res += c - '0';
                            c = snext();
                    } while (!isSpaceChar(c));
                    return res * sgn;
            }

            public int[] nextIntArray(int n) {
                    int a[] = new int[n];
                    for (int i = 0; i < n; i++) {
                            a[i] = nextInt();
                    }
                    return a;
            }

            public long[] nextLongArray(int n) {
                    long a[] = new long[n];
                    for (int i = 0; i < n; i++) {
                            a[i] = nextInt();
                    }
                    return a;
            }

            public String readString() {
                    int c = snext();
                    while (isSpaceChar(c)) {
                            c = snext();
                    }
                    StringBuilder res = new StringBuilder();
                    do {
                            res.appendCodePoint(c);
                            c = snext();
                    } while (!isSpaceChar(c));
                    return res.toString();
            }

            public String nextLine() {
                    int c = snext();
                    while (isSpaceChar(c))
                            c = snext();
                    StringBuilder res = new StringBuilder();
                    do {
                            res.appendCodePoint(c);
                            c = snext();
                    } while (!isEndOfLine(c));
                    return res.toString();
            }

            public boolean isSpaceChar(int c) {
                    if (filter != null)
                            return filter.isSpaceChar(c);
                    return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
            }

            private boolean isEndOfLine(int c) {
                    return c == '\n' || c == '\r' || c == -1;
            }

            public interface SpaceCharFilter {
                    public boolean isSpaceChar(int ch);
            }
    }
}    

