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.util.*;
  import java.lang.*;
  import java.io.*;
   
  public class Main
  {
      static long mod = (int)1e9+7;
      public static void main (String[] args) throws java.lang.Exception
      {
          FastReader sc =new FastReader();
   
          int t=sc.nextInt();
     
       // int t=1;
     
          while(t-->0)
          {
              int n=sc.nextInt();
              int a[]=new int[n];
              for(int i=0;i<n;i++)
              {
                  a[i]=sc.nextInt();
              }
              int b[]=new int[n/2+1];
              int c[]=new int[n-(n/2)-1];
              for(int i=0;i<n-1;i++)
              {
                  if(a[i]>a[i+1])
                  {
                      int temp=a[i];
                      a[i]=a[i+1];
                      a[i+1]=temp;
                  }
              }
              double sum=0.0;
              for(int i=0;i<n-1;i++)
              {
                  sum=sum+a[i];
              }
              double z=sum/(n-1)+a[n-1];
              System.out.println(z);
          }
      }
   
   
   
  static class FastReader {
          BufferedReader br;
          StringTokenizer st;
   
          public FastReader()
          {
              br = new BufferedReader(
                  new InputStreamReader(System.in));
          }
   
          String next()
          {
              while (st == null || !st.hasMoreElements()) {
                  try {
                      st = new StringTokenizer(br.readLine());
                  }
                  catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              return st.nextToken();
          }
   
          int nextInt() { return Integer.parseInt(next()); }
   
          long nextLong() { return Long.parseLong(next()); }
   
          double nextDouble()
          {
              return Double.parseDouble(next());
          }
         
          float nextFloat()
          {
              return Float.parseFloat(next());
          }
   
          String nextLine()
          {
              String str = "";
              try {
                  str = br.readLine();
              }
              catch (IOException e) {
                  e.printStackTrace();
              }
              return str;
          }
         
          int[] readArray(int n) {
  int[] a=new int[n];
  for (int i=0; i<n; i++) a[i]=nextInt();
  return a;
  }
   
  long[] readArrayLong(int n) {
  long[] a=new long[n];
  for (int i=0; i<n; i++) a[i]=nextLong();
  return a;
  }
   
      }
     
      public static int[] radixSort2(int[] a)
  {
  int n = a.length;
  int[] c0 = new int[0x101];
  int[] c1 = new int[0x101];
  int[] c2 = new int[0x101];
  int[] c3 = new int[0x101];
  for(int v : a) {
  c0[(v&0xff)+1]++;
  c1[(v>>>8&0xff)+1]++;
  c2[(v>>>16&0xff)+1]++;
  c3[(v>>>24^0x80)+1]++;
  }
  for(int i = 0;i < 0xff;i++) {
  c0[i+1] += c0[i];
  c1[i+1] += c1[i];
  c2[i+1] += c2[i];
  c3[i+1] += c3[i];
  }
  int[] t = new int[n];
  for(int v : a)t[c0[v&0xff]++] = v;
  for(int v : t)a[c1[v>>>8&0xff]++] = v;
  for(int v : a)t[c2[v>>>16&0xff]++] = v;
  for(int v : t)a[c3[v>>>24^0x80]++] = v;
  return a;
  }
   
   
     
      public static HashMap<Integer, Integer> sortByValue(HashMap<Integer, Integer> hm)
      {
          // Create a list from elements of HashMap
          List<Map.Entry<Integer, Integer> > list =
                 new LinkedList<Map.Entry<Integer, Integer> >(hm.entrySet());
   
          // Sort the list
          Collections.sort(list, new Comparator<Map.Entry<Integer, Integer> >() {
              public int compare(Map.Entry<Integer, Integer> o1,
                                 Map.Entry<Integer, Integer> o2)
              {
                  return (o1.getValue()).compareTo(o2.getValue());
              }
          });
           
          // put data from sorted list to hashmap
          HashMap<Integer, Integer> temp = new LinkedHashMap<Integer, Integer>();
          for (Map.Entry<Integer, Integer> aa : list) {
              temp.put(aa.getKey(), aa.getValue());
          }
          return temp;
      }
  }