description: Ezzat has an array of n integers (maybe negative). He wants to split it into two non-empty subsequences a and b, such that every element from the array belongs to exactly one subsequence, and the value of f(a) + f(b) is the maximum possible value, where f(x) is the average of the subsequence x. 
  
  A sequence x is a subsequence of a sequence y if x can be obtained from y by deletion of several (possibly, zero or all) elements.
  
  The average of a subsequence is the sum of the numbers of this subsequence divided by the size of the subsequence.
  
  For example, the average of [1,5,6] is (1+5+6)/3 = 12/3 = 4, so f([1,5,6]) = 4.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 10^3)— the number of test cases. Each test case consists of two lines.
  
  The first line contains a single integer n (2 ≤ n ≤ 10^5).
  
  The second line contains n integers a_1, a_2, …, a_n (-10^9 ≤ a_i ≤ 10^9).
  
  It is guaranteed that the sum of n over all test cases does not exceed 3⋅10^5.
  
  Output
  
  For each test case, print a single value — the maximum value that Ezzat can achieve.
  
  Your answer is considered correct if its absolute or relative error does not exceed 10^{-6}.
  
  Formally, let your answer be a, and the jury's answer be b. Your answer is accepted if and only if \frac{|a - b|}{max{(1, |b|)}} ≤ 10^{-6}.
  
  Example
  
  Input
  
  
  4
  3
  3 1 2
  3
  -7 -6 -6
  3
  2 2 2
  4
  17 3 5 -3
  
  
  Output
  
  
  4.500000000
  -12.500000000
  4.000000000
  18.666666667
  
  Note
  
  In the first test case, the array is [3, 1, 2]. These are all the possible ways to split this array: 
  
    * a = [3], b = [1,2], so the value of f(a) + f(b) = 3 + 1.5 = 4.5. 
    * a = [3,1], b = [2], so the value of f(a) + f(b) = 2 + 2 = 4. 
    * a = [3,2], b = [1], so the value of f(a) + f(b) = 2.5 + 1 = 3.5. 
  
  Therefore, the maximum possible value 4.5.
  
  In the second test case, the array is [-7, -6, -6]. These are all the possible ways to split this array: 
  
    * a = [-7], b = [-6,-6], so the value of f(a) + f(b) = (-7) + (-6) = -13. 
    * a = [-7,-6], b = [-6], so the value of f(a) + f(b) = (-6.5) + (-6) = -12.5. 
  
  Therefore, the maximum possible value -12.5.
solution: import java.io.DataInputStream;
  import java.io.IOException;
  import java.io.PrintWriter;
  import java.util.Arrays;
  
  public class Q4{
  
  	static class InputReader{
  		final private int BUFFER_SIZE = 1 << 16;
  		private DataInputStream din;
  		private byte[] buffer;
  		private int bufferPointer, bytesRead;
  
  		public InputReader(){
  			din = new DataInputStream(System.in);
  			buffer = new byte[BUFFER_SIZE];
  			bufferPointer = bytesRead = 0;
  		}
  		private void fillBuffer() throws IOException{
  			bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
  			if (bytesRead == -1)
  				buffer[0] = -1;
  		}
  
  		private byte read() throws IOException{
  			if (bufferPointer == bytesRead)
  				fillBuffer();
  			return buffer[bufferPointer++];
  		}
  
  		public void close() throws IOException{
  			if (din == null)
  				return;
  			din.close();
  		}
  		public int nextInt() throws IOException{
  			int ret = 0;
  			byte c = read();
  			while (c <= ' ')
  				c = read();
  			boolean neg = (c == '-');
  			if (neg)
  				c = read();
  			do{
  				ret = ret * 10 + c - '0';
  			}  while ((c = read()) >= '0' && c <= '9');
  
  			if (neg)
  				return -ret;
  			return ret;
  		}
  	}
  	public static void main(String args[] ) throws Exception {
  		InputReader  sc=new InputReader();
  		PrintWriter out=new PrintWriter(System.out);
  		int n,t=sc.nextInt();
  		int[] nums;
  		while(t-->0) {
  			n=sc.nextInt();
  			nums=new int[n];
  			
  			for(int i=0;i<n;i++) {
  				nums[i]=sc.nextInt();
  			}
  			Arrays.sort(nums);
  			long[] pref=new long[n];
  			pref[0]=nums[0];
  			for(int i=1;i<n;i++)pref[i]=pref[i-1]+nums[i];
  			long[] suff=new long[n];
  			suff[n-1]=nums[n-1];
  			for(int i=n-2;i>=0;i--)suff[i]=suff[i+1]+nums[i];
  			
  			double ans=Double.NEGATIVE_INFINITY;
  			for(int i=0;i<n-1;i++) {
  				ans=Math.max(ans, (pref[i]/(i+1.0))+(suff[i+1]/(n-(i+1.0))));
  			}
  			ans=Math.max(ans, (pref[n-2]/(n-1.0))+suff[n-1]);
  			
  			out.println(String.format("%.9f", ans));
  		}
  		out.flush();
  	}
  }
  
  
  
  
  