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.util.*;
  
  
  import java.io.*;
  
  public class Solution {
  	static FastScanner scr=new FastScanner();
  //	static Scanner scr=new Scanner(System.in);
  	 static PrintStream out=new PrintStream(System.out);
  	 static StringBuilder sb=new StringBuilder();
  	 static  class FastScanner {
  		 BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  		StringTokenizer st=new StringTokenizer("");
  	 	String next() {
  	 		while (!st.hasMoreTokens())
  	 			try {
  	 				st=new StringTokenizer(br.readLine());
  	 			} catch (IOException e) {
  	 				e.printStackTrace();
  	 			}
  	 			return st.nextToken();
  		} long gcd(long a,long b){
  			if(b==0) {
  				return a;
  			}
  				
  			return gcd(b,a%b);
  		}
  		int gcd(int a,int b) {
  			if(a*b==0) {
  				return a+b;
  			}
  			return gcd(b,a%b);
  		}
  	 	 long modPow(long base,long exp) {
  			if(exp==0) {
  				return 1;
  			}
  			if(exp%2==0) {
  				long res=(modPow(base,exp/2));
  				return (res*res);
  			}
  			return (base*modPow(base,exp-1));
  		}
  	 	long []reverse(long[] count){
  			long b[]=new long[count.length];
  			int index=0;
  			for(int i=count.length-1;i>=0;i--) {
  				b[index++]=count[i];
  			}
  			return b;
  		}
  	 	int []reverse(int[] count){
  			int b[]=new int[count.length];
  			int index=0;
  			for(int i=count.length-1;i>=0;i--) {
  				b[index++]=count[i];
  			}
  			return b;
  		}
  		int nextInt() {
  			return Integer.parseInt(next());
  		}
  		long getMax(long a[],int n) {
  			long max=Long.MIN_VALUE;
  			for(int i=0;i<n;i++) {
  				max=Math.max(a[i], max);
  			}
  				return max;
  		}
  		long[] readLongArray(int n) {
  			long  [] a=new long  [n];
  			for (int i=0; i<n; i++) a[i]=nextLong();
  			return a;
  		}int[] readArray(int n) {
  			int  [] a=new int  [n];
  			for (int i=0; i<n; i++) a[i]=nextInt();
  			return a;
  		}
  		long nextLong() {
  			return Long.parseLong(next());
  		}
  		 boolean isPrime(long n)  {
  	          if(n < 2) return false;
  	          if(n == 2 || n == 3) return true;
  	          if(n%2 == 0 || n%3 == 0) return false;
  	          long sqrtN = (long)Math.sqrt(n)+1;
  	          for(long i = 6L; i <= sqrtN; i += 6) {
  	              if(n%(i-1) == 0 || n%(i+1) == 0) return false;
  	          }
  	          return true;
  	      }
  		 int sum(int a[]) {
  			 int s=0;
  			 for(int i=0;i<a.length;i++)s+=a[i];
  			 return s;
  		 }
  		 long sum(long a[]) {
  			 long s=0;
  			 for(int i=0;i<a.length;i++)s+=a[i];
  			 return s;
  		 }
  		
  	}
  
  	 static class triplet{
  		int x;
  		int y;
  		int z;
  		triplet(int x,int y,int z){
  			this.x=x;
  			this.y=y;
  			this.z=z;
  		}
  	} 
  	 static class pair{
  			int x;
  			int y;
  			pair( int x,int y){
  				this.x=x;
  				this.y=y;
  			}
  	 }
  	 static Solve s=new Solve();
  	public static  void main(String []args) {
  		int t=scr.nextInt();
  //		int t=1;
  		while(t-->0) {
  			s.solve();
  		}
  		out.println(sb);
  	}
  	static class Solve {
  		int MAX=Integer.MAX_VALUE;
  		int MIN=Integer.MIN_VALUE;
  		ArrayList<Integer>list[];
  		long mod=998244353;
  		long time[];
  		boolean visited[];
  		void solve() {
  			int n=scr.nextInt();
  			int []a=scr.readArray(n);
  			int sum=0;
  			for(int i=0;i<n;i++) {
  				sum+=a[i];
  			}
  			int ans=sum%n;
  			if(ans==0) {
  				out.println(ans);
  			}else {
  				out.println(1);
  			}
  				
  		}
  	}
  }
  	
  