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: #include <bits/stdc++.h>
  using namespace std;
  vector<bool> seive;
  int fact[100005];
  int powerr[100005];
  int mod = (int)(1e9 + 7);
  long long powerf(long long a, long long b, long long mod);
  void precomputeFactorial() {
    fact[0] = 1;
    fact[1] = 1;
    powerr[0] = 1;
    for (int i = 1; i <= 100005; i++) {
      fact[i] = i * fact[i - 1];
      powerr[i] = powerf(i, mod - 2, mod);
    }
  }
  int nCr(int n, int r) { return fact[n] / (fact[r] * fact[n - r]); }
  long long gcd(long long a, long long b) {
    if (b == 0) return a;
    return gcd(b, a % b);
  }
  long long powerf(long long a, long long b, long long mod) {
    if (b == 0) {
      return 1;
    }
    if (b % 2 == 0) {
      return powerf((a * a) % mod, b / 2, mod);
    }
    return (a * powerf((a * a) % mod, b / 2, mod)) % mod;
  }
  bool cmp(pair<int, int> p1, pair<int, int> p2) {
    if (p1.first < p2.first) {
      return true;
    } else if (p1.first == p2.first) {
      if (p1.second < p2.second) return true;
      return false;
    }
    return false;
  }
  int minChanges(string a, string b) {
    int i = 0;
    int j = 0;
    int same = 0;
    while (i < a.size() && j < b.size()) {
      if (a[i] == b[j]) {
        i++;
        j++;
        same += 2;
      } else {
        i++;
      }
    }
    return a.size() + b.size() - same;
  }
  bool isPrime(int n) {
    if (n <= 1) return false;
    for (int i = 2; i <= sqrt(n); i++)
      if (n % i == 0) return false;
    return true;
  }
  void dfs(vector<int> adj[], int src, vector<bool> &isInc) {
    isInc[src] = true;
    for (int x : adj[src]) {
      if (isInc[x] == false) {
        dfs(adj, x, isInc);
      }
    }
  }
  bool isPerfectSquare(int b) {
    if (float(log2(b)) == ceil(log2(b))) {
      return true;
    }
    return false;
  }
  const int N = 3 * 1e5;
  int xor_arr[N + 10];
  void precompute() {
    xor_arr[0] = 0;
    for (int i = 1; i <= N + 5; i++) xor_arr[i] = (i ^ xor_arr[i - 1]);
  }
  bool comparator(pair<int, int> p1, pair<int, int> p2) {
    if (p1.first > p2.first) {
      return true;
    } else if (p1.first == p2.first) {
      if (p1.second < p2.second) {
        return true;
      } else {
        return false;
      }
    }
    return false;
  }
  bool comp(string s1, string s2) { return s1 + s2 < s2 + s1; }
  bool isPossible(long long mid, long long arr[], long long n, long long h) {
    for (int i = 0; i < n - 1; i++) {
      h -= min(arr[i + 1] - arr[i], mid);
    }
    h -= mid;
    return h <= 0;
  }
  void solve() {
    int n;
    cin >> n;
    int arr[n];
    long long s = 0;
    for (int i = 0; i < n; i++) {
      cin >> arr[i];
      s += arr[i];
    }
    if (s % n == 0) {
      cout << 0 << endl;
    } else {
      cout << 1 << endl;
    }
  }
  signed main() {
    int t;
    cin >> t;
    while (t--) solve();
    return 0;
  }
  