/*
⠀⠀⠀⠀⣠⣶⡾⠏⠉⠙⠳⢦⡀⠀⠀⠀⢠⠞⠉⠙⠲⡀⠀
⠀⠀⠀⣴⠿⠏⠀⠀⠀⠀⠀⠀⢳⡀⠀⡏⠀⠀Y⠀⠀⢷
⠀⠀⢠⣟⣋⡀⢀⣀⣀⡀⠀⣀⡀⣧⠀⢸⠀⠀A⠀⠀ ⡇
⠀⠀⢸⣯⡭⠁⠸⣛⣟⠆⡴⣻⡲⣿⠀⣸⠀⠀S⠀  ⡇
⠀⠀⣟⣿⡭⠀⠀⠀⠀⠀⢱⠀⠀⣿⠀⢹⠀⠀H⠀⠀ ⡇
⠀⠀⠙⢿⣯⠄⠀⠀⠀⢀⡀⠀⠀⡿⠀⠀⡇⠀⠀⠀⠀⡼
⠀⠀⠀⠀⠹⣶⠆⠀⠀⠀⠀⠀⡴⠃⠀⠀⠘⠤⣄⣠⠞⠀
⠀⠀⠀⠀⠀⢸⣷⡦⢤⡤⢤⣞⣁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⢀⣤⣴⣿⣏⠁⠀⠀⠸⣏⢯⣷⣖⣦⡀⠀⠀⠀⠀⠀⠀
⢀⣾⣽⣿⣿⣿⣿⠛⢲⣶⣾⢉⡷⣿⣿⠵⣿⠀⠀⠀⠀⠀⠀
⣼⣿⠍⠉⣿⡭⠉⠙⢺⣇⣼⡏⠀⠀⠀⣄⢸⠀⠀⠀⠀⠀⠀
⣿⣿⣧⣀⣿………⣀⣰⣏⣘⣆⣀⠀⠀
 */

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter; // System.out is a PrintStream
// import java.util.Arrays;
// import java.util.ArrayDeque;
// import java.util.ArrayList;
// import java.util.Collections;    //  for sorting ArrayList mainly
// import java.util.HashMap;
// import java.util.TreeMap;
// import java.util.HashSet;
// import java.util.TreeSet;
// import java.util.Random;
import java.util.StringTokenizer;

public class B {
    public static void main(String[] args) throws IOException {
        FastScanner scn = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);
        for (int tc = scn.nextInt(); tc > 0; tc--) {
            int N = scn.nextInt();
            long sm = 0;
            int[] arr = new int[N];
            for (int i = 0; i < N; i++) {
                sm += arr[i] = scn.nextInt();
            }
            int rem = (int)(sm % N);
            if (rem == 0) {
                out.println(0);
            } else {
                long ans = rem * (N - rem);
                out.println(ans);
            }
        }
        out.close();
    }
    
    /* ------------------- Sorting ------------------- */
    private static void ruffleSort(int[] arr) {
        // int N = arr.length;
        // Random rand = new Random();
        // for (int i = 0; i < N; i++) {
            //     int oi = rand.nextInt(N), temp = arr[i];
            //     arr[i] = arr[oi];
            //     arr[oi] = temp;
        // }
        // Arrays.sort(arr);
    }
    
    /* ------------------- Pair class ------------------- */
    private static class Pair implements Comparable<Pair> {
		int x, y;
		Pair(int x, int y) {
			this.x = x;
			this.y = y;
		}
		public int compareTo(Pair o) {
			return this.x == o.x ? this.y - o.y : this.x - o.x;
		}
	}

    /* ------------------- HCF and LCM ------------------- */
    private static int gcd(int num1, int num2) {
        int temp = 0;
        while (num2 != 0) {
            temp = num1;
            num1 = num2;
            num2 = temp % num2;
        }
        return num1;
    }
    
    private static int lcm(int num1, int num2) {
        return (int)((1L * num1 * num2) / gcd(num1, num2));
    }
    
    /* ------------------- primes and prime factorization ------------------- */
    private static boolean[] seive(int N) {
        // true means not prime, false means is a prime number :)
        boolean[] notPrimes = new boolean[N + 1];
        notPrimes[0] = notPrimes[1] = true;
        for (int i = 2; i * i <= N; i++) {
            if (notPrimes[i]) continue;
            for (int j = i * i; j <= N; j += i) {
                notPrimes[j] = true;
            }
        }
        return notPrimes;
    }

	/* private static TreeMap<Integer, Integer> primeFactors(long N) {
		TreeMap<Integer, Integer> primeFact = new TreeMap<>();
		for (int i = 2; i <= Math.sqrt(N); i++) {
            int count = 0;
            while (N % i == 0) {
                N /= i;
                count++;
            }
            if (count != 0) {
                primeFact.put(i, count);
            }
		}
		if (N != 1) {
            primeFact.put((int)N, 1);
        }
		return primeFact;
	} */

    /* ------------------- Binary Search ------------------- */
    private static long factorial(int N) {
        long ans = 1L;
        for (int i = 2; i <= N; i++) {
            ans *= i;
        }
        return ans;
    }

    private static long[] factorialDP(int N) {
        long[] factDP = new long[N + 1];
        factDP[0] = factDP[1] = 1;
        for (int i = 2; i <= N; i++) {
            factDP[i] = factDP[i - 1] * i;
        }
        return factDP;
    }

    private static long factorialMod(int N, int mod) {
        long ans = 1L;
        for (int i = 2; i <= N; i++) {
            ans = ((ans % mod) * (i % mod)) % mod;
        }
        return ans;
    }

    /* ------------------- Binary Search ------------------- */
    private static int lowerbound(int[] arr, int st, int ed, int tar) {
        int ans = -1;
        while (st <= ed) {
            int mid = ((ed - st) >> 1) + st;
            if (arr[mid] <= tar) {
                ans = mid;
                st = mid + 1;
            } else {
                ed = mid - 1;
            }
        }
        return ans;
    }
    
    private static int upperbound(int[] arr, int st, int ed, int tar) {
        int ans = -1;
        while (st <= ed) {
            int mid = ((ed - st) >> 1) + st;
            if (arr[mid] < tar) {
                st = mid + 1;
            } else {
                ans = mid;
                ed = mid - 1;
            }
        }
        return ans;
    }
    
    /* ------------------- Power Function ------------------- */
    public static long pow(long x, long y) {
        long res = 1;
		while (y > 0) {
            if ((y & 1) != 0) {
                res = (res * x);
				y--;
			}
			x = (x * x);
			y >>= 1;
		}
		return res;
	}
    
	public static long powMod(long x, long y, int mod) {
        long res = 1;
		while (y > 0) {
            if ((y & 1) != 0) {
                res = (res * x) % mod;
				y--;
			}
			x = (x * x) % mod;
			y >>= 1;
		}
		return res % mod;
	}

    /* ------------------- Disjoint Set(Union and Find) ------------------- */
    private static class DSU {
		public int[] parent, size;
		DSU(int n) {
			parent = new int[n];
			for (int i = 0; i < n; i++) {
				parent[i] = i;
                size[i] = 1;
            }
		}
		public int find(int a) {
			if (parent[a] == a) {
				return a;
            }
            return parent[a] = find(parent[a]);
		}
		public void merge(int a, int b) {
			int parA = find(a), parB = find(b);
			if (parA == parB) return;
			if (size[parA] < size[parB]) {
                parent[parB] = parA;
                size[parA] += size[parB];
            } else {
                parent[parA] = parB;
                size[parB] += size[parA];
            }
		}
	}
    
    /* ------------------- Scanner class for input ------------------- */
    private static class FastScanner {
        BufferedReader br;
        StringTokenizer st;
        
        FastScanner() {
            this.br = new BufferedReader(new InputStreamReader(System.in));
            this.st = new StringTokenizer("");
        }
        
        public String next() {
            while (!st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException err) {
                    err.printStackTrace();
                }
            }
            return st.nextToken();
        }

        public String nextLine() {
            if (st.hasMoreTokens()) {
                return st.nextToken("").trim();
            }
            try {
                return br.readLine().trim();
            } catch (IOException err) {
                err.printStackTrace();
            }
            return "";
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}
