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.*;
  import java.lang.*;
  
  
  public class A {
  	static class FastReader{
          BufferedReader br;
          StringTokenizer st;
          public FastReader(){
              br=new BufferedReader(new InputStreamReader(System.in));
          }
          String next(){
              while(st==null || !st.hasMoreTokens()){
                  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());
          }
          String nextLine(){
              String str="";
              try {
                  str=br.readLine().trim();
              } catch (Exception e) {
                  e.printStackTrace();
              }
              return str;
          }
      }
      static class FastWriter {
  		private final BufferedWriter bw;
   
  		public FastWriter() {
  			this.bw = new BufferedWriter(new OutputStreamWriter(System.out));
  		}
   
  		public void print(Object object) throws IOException {
  			bw.append(" " + object);
  		}
   
  		public void println(Object object) throws IOException {
  			print(object);
  			bw.append("\n");
  		}
   
  		public void close() throws IOException {
  			bw.close();
  		}
  	}
  
  	 static void swap(int x,int y)
  	 {
  		 int temp=x;
  		 x=y;
  		 y=temp;
  	 }
  	
  	static Boolean isSquare(int n)
  	{
  		int y= (int)Math.sqrt(n);
  		return y*y==n;
  	}
  	static int highestPowerof2(int x)
      {
         
          x |= x >> 1;
          x |= x >> 2;
          x |= x >> 4;
          x |= x >> 8;
          x |= x >> 16;
           
          return x ^ (x >> 1); 
      }
  	static boolean check_pow (long x)
  	{
  	    
  	      return x!=0 && ((x&(x-1)) == 0);   
  	}
  	static int digits(int n)
  	{
  		if(n==0)
  			return 1;
  		return (int)(Math.floor(Math.log10(n))+1);
  	}
  	static boolean isPalindrome(String str)
      {
   
          int i = 0, j = str.length() - 1; 
          while (i < j) {
  
              if (str.charAt(i) != str.charAt(j))
                  return false;
   
              i++;j--;
          }
   
          return true;
      }
  	
  	public static boolean IsPrime(int number)
      {
  		
          if (number < 2) return false;
          if (number % 2 == 0) return (number == 2);
          int root = (int)Math.sqrt((double)number);
          for (int i = 3; i <= root; i += 2)
          {
              if (number % i == 0) return false;
          }
          return true;
      }
  	static int gcd(int a, int b)
  	{
  	    if (b == 0)
  	        return a;
  	    return gcd(b, a % b);
  	     
  	}
  	
  	static int lcm(int a, int b)
      {
          return (a / gcd(a, b)) * b;
      }
  	static int sieve(int n)
      {
  		int c=0;
          for (int i=1; i<=Math.sqrt(n); i++)
          {
              if (n%i==0)
              {
                  if (n/i == i)
                      c++;
                  else
                      c+=2;
              }
          }
          return c;
      }
  	
  	public static void main(String[] args) throws Exception{
  		// TODO Auto-generated method stub
  
  		FastReader sc= new FastReader();
  	    //FastWriter out = new FastWriter();
  		//StringBuilder sb=new StringBuilder("");
  		//PrintWriter out= new PrintWriter(System.out);
  	    //Collections.sort(A, (a, b) -> Integer.compare(b[1], a[1]));
  		int t= sc.nextInt();
  		while(t-->0)
  		{
  			int n=sc.nextInt();
  			int arr[]= new int[n];
  			long sum=0;
  			for(int i=0;i<n;i++)
  			{
  				arr[i]=sc.nextInt();
  				sum+=arr[i];
  			}
  			long temp=sum%n;
  			if(temp==0)
  				System.out.println(temp);
  			else
  				System.out.println(1);
  			
  		}
  				
  		//System.out.println(sb);
  		
  		//out.close();
  		
     }
  }