description: There are n block towers in a row, where tower i has a height of a_i. You're part of a building crew, and you want to make the buildings look as nice as possible. In a single day, you can perform the following operation:
  
    * Choose two indices i and j (1 ≤ i, j ≤ n; i ≠ j), and move a block from tower i to tower j. This essentially decreases a_i by 1 and increases a_j by 1. 
  
  
  
  You think the ugliness of the buildings is the height difference between the tallest and shortest buildings. Formally, the ugliness is defined as max(a)-min(a). 
  
  What's the minimum possible ugliness you can achieve, after any number of days?
  
  Input
  
  The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t cases follow.
  
  The first line of each test case contains one integer n (2 ≤ n ≤ 100) — the number of buildings.
  
  The second line of each test case contains n space separated integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7) — the heights of the buildings.
  
  Output
  
  For each test case, output a single integer — the minimum possible ugliness of the buildings.
  
  Example
  
  Input
  
  
  3
  3
  10 10 10
  4
  3 2 1 2
  5
  1 2 3 1 5
  
  
  Output
  
  
  0
  0
  1
  
  Note
  
  In the first test case, the ugliness is already 0.
  
  In the second test case, you should do one operation, with i = 1 and j = 3. The new heights will now be [2, 2, 2, 2], with an ugliness of 0.
  
  In the third test case, you may do three operations: 
  
    1. with i = 3 and j = 1. The new array will now be [2, 2, 2, 1, 5], 
    2. with i = 5 and j = 4. The new array will now be [2, 2, 2, 2, 4], 
    3. with i = 5 and j = 3. The new array will now be [2, 2, 3, 2, 3]. 
  
  The resulting ugliness is 1. It can be proven that this is the minimum possible ugliness for this test.
solution: import java.io.*;
  import java.util.*;
  
  public class q1 {
      public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  //    public static long mod = 1000000007;
  
      public static void solve() throws Exception {
          String[] parts = br.readLine().split(" ");
          int n = Integer.parseInt(parts[0]);
  
          int[] arr = new int[n];
  
          int sum = 0;
          parts = br.readLine().split(" ");
          for(int i = 0;i < n;i++){
              arr[i] = Integer.parseInt(parts[i]);
              sum += arr[i];
          }
  
          if(sum % n == 0) System.out.println(0);
          else System.out.println(1);
  
  
      }
  
      public static void main(String[] args) throws Exception {
          int tests = Integer.parseInt(br.readLine());
          for (int test = 1; test <= tests; test++) {
              solve();
          }
      }
  
  //    public static ArrayList<Integer> primes;
  //    public static void seive(int n){
  //        primes = new ArrayList<>();
  //        boolean[] arr = new boolean[n + 1];
  //        Arrays.fill(arr,true);
  //
  //        for(int i = 2;i * i <= n;i++){
  //            if(arr[i]) {
  //                for (int j = i * i; j <= n; j += i) {
  //                    arr[j] = false;
  //                }
  //            }
  //        }
  //        for(int i = 2;i <= n;i++) if(arr[i]) primes.add(i);
  //    }
  
  
  //    public static void sort(int[] arr){
  //        ArrayList<Integer> temp = new ArrayList<>();
  //        for(int val : arr) temp.add(val);
  //
  //        Collections.sort(temp);
  //
  //        for(int i = 0;i < arr.length;i++) arr[i] = temp.get(i);
  //    }
  
  //    public static void sort(long[] arr){
  //        ArrayList<Long> temp = new ArrayList<>();
  //        for(long val : arr) temp.add(val);
  //
  //        Collections.sort(temp);
  //
  //        for(int i = 0;i < arr.length;i++) arr[i] = temp.get(i);
  //    }
  //
  //    public static long power(long a,long b,long mod){
  //        if(b == 0) return 1;
  //
  //        long p = power(a,b / 2,mod);
  //        p = (p * p) % mod;
  //
  //        if(b % 2 == 1) return (p * a) % mod;
  //        return p;
  //    }
  //    public static long modDivide(long a,long b,long mod){
  //        return ((a % mod) * (power(b,mod - 2,mod) % mod)) % mod;
  //    }
  //
  //    public static int GCD(int a,int b){
  //        return b == 0 ? a : GCD(b,a % b);
  //    }
  //    public static long GCD(long a,long b){
  //        return b == 0 ? a : GCD(b,a % b);
  //    }
  //
  //    public static int LCM(int a,int b){
  //        return a * b / GCD(a,b);
  //    }
  //    public static long LCM(long a,long b){
  //        return a * b / GCD(a,b);
  //    }
  }
  