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.*;
  import java.util.*;
   
  public class Main{
      public static long mod = (long)1e9+7;
      public static ArrayList<Integer>[] graph;
      public static void sort(int[] arr){
          ArrayList<Integer> list = new ArrayList<>();
          for(int u:arr) list.add(u);
          Collections.sort(list);
          for (int i = 0; i < arr.length; i++) {
              arr[i] = list.get(i);
          }
      }
      public static void sort(long[] arr){
          ArrayList<Long> list = new ArrayList<>();
          for(long u:arr) list.add(u);
          Collections.sort(list);
          for (int i = 0; i < arr.length; i++) {
              arr[i] = list.get(i);
          }
      }
      public static void main(String[] args) {
          InputStream inputStream = System.in;
  		OutputStream outputStream = System.out;
  		InputReader in = new InputReader(inputStream);
  		PrintWriter out = new PrintWriter(outputStream);
          int t = 1;
           t = in.nextInt();
          for(int i = 1;i<=t ;i++){
              solve(in,out);
          }
          out.close();
      }
   
      private static void solve(InputReader in, PrintWriter out) {
         int n = in.nextInt();
         int[] list = in.readIntArray(n);
         sort(list);
         long sum = 0;
         for(int u:list) sum+=u;
         double max = Integer.MIN_VALUE;
         long run = 0;
         for (int i = 0; i < list.length-1; i++) {
             run += list[i];
             double av1 = run/(double)(i+1);
             double av2 = (sum-run)/(double)(list.length-i-1);
             //System.out.println(av1+" "+av2+" "+i);
             max = Math.max(max,av1 + av2);
         }
         out.println(max);
      }
      private static boolean possible(long w, long h, long mid, long n) {
          return ((mid/h) * (mid/w)) >= n;
      }
      public static boolean find(int[] list, int target){
          int lo = 0;
          int hi = list.length-1;
          while(lo<=hi){
              int mid = lo +(hi-lo)/2;
              if(list[mid]==target) return true;
              else if(list[mid]<target) lo = mid+1;
              else hi = mid-1;
          }
          return false;
      }
  }
  class InputReader {
      public BufferedReader reader;
      public StringTokenizer tokenizer;
   
      public InputReader(InputStream stream) {
          reader = new BufferedReader(new InputStreamReader(stream), 32768);
          tokenizer = null;
      }
   
      public String next() {
          while (tokenizer == null || !tokenizer.hasMoreTokens()) {
              try {
                  tokenizer = new StringTokenizer(reader.readLine());
              } catch (IOException e) {
                  throw new RuntimeException(e);
              }
          }
          return tokenizer.nextToken();
      }
   
      public int nextInt() {
          return Integer.parseInt(next());
      }
   
      public long nextLong() {
          return Long.parseLong(next());
      }
      public double nextDouble(){
          return Double.parseDouble(next());
      }
      public int[] readIntArray(int size){
          int[] list = new int[size];
          for(int i = 0;i<size;i++) list[i] = nextInt();
          return list;
      }
      public long[] readLongArray(int size){
          long[] list = new long[size];
          for(int i = 0;i<size;i++) list[i] = nextLong();
          return list;
      }
      public double[] readDoubleArray(int size){
          double[] list = new double[size];
          for(int i = 0;i<size;i++) list[i] = nextDouble();
          return list;
      }
      public String linereader() {
          String s = null;
          try{
              s = reader.readLine();
          }
          catch (IOException e) {
              throw new RuntimeException(e);
          }
          return s;
      }
   
  }
  class Pair<T extends Comparable<T>,K extends Comparable<K> > implements Comparable<Pair<T,K>>{
      T first;
      K second;
      public Pair(T first, K second){
          this.first  = first;
          this.second = second;
      }
      @Override
      public String toString(){
          return first+" "+second;
      }
      @Override
      public int compareTo(Pair<T,K> o) {
          // TODO Auto-generated method stub
          if((first).compareTo(o.first)!=0) return first.compareTo(o.first);
          else return second.compareTo(o.second);
      }
   
  }