description: You are given an integer array a_1, a_2, ..., a_n and integer k.
  
  In one step you can 
  
    * either choose some index i and decrease a_i by one (make a_i = a_i - 1); 
    * or choose two indices i and j and set a_i equal to a_j (make a_i = a_j). 
  
  
  
  What is the minimum number of steps you need to make the sum of array ∑_{i=1}^{n}{a_i} ≤ k? (You are allowed to make values of array negative).
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
  
  The first line of each test case contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5; 1 ≤ k ≤ 10^{15}) — the size of array a and upper bound on its sum.
  
  The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the array itself.
  
  It's guaranteed that the sum of n over all test cases doesn't exceed 2 ⋅ 10^5.
  
  Output
  
  For each test case, print one integer — the minimum number of steps to make ∑_{i=1}^{n}{a_i} ≤ k.
  
  Example
  
  Input
  
  
  4
  1 10
  20
  2 69
  6 9
  7 8
  1 2 1 3 1 2 1
  10 1
  1 2 3 1 2 6 1 6 8 10
  
  
  Output
  
  
  10
  0
  2
  7
  
  Note
  
  In the first test case, you should decrease a_1 10 times to get the sum lower or equal to k = 10.
  
  In the second test case, the sum of array a is already less or equal to 69, so you don't need to change it.
  
  In the third test case, you can, for example: 
  
    1. set a_4 = a_3 = 1; 
    2. decrease a_4 by one, and get a_4 = 0. 
  
  As a result, you'll get array [1, 2, 1, 0, 1, 2, 1] with sum less or equal to 8 in 1 + 1 = 2 steps.
  
  In the fourth test case, you can, for example: 
  
    1. choose a_7 and decrease in by one 3 times; you'll get a_7 = -2; 
    2. choose 4 elements a_6, a_8, a_9 and a_{10} and them equal to a_7 = -2. 
  
  As a result, you'll get array [1, 2, 3, 1, 2, -2, -2, -2, -2, -2] with sum less or equal to 1 in 3 + 4 = 7 steps.
solution: import java.util.Scanner;
  import java.util.Arrays;
  public class B {
      public static int[] sort(int[] arr,int low,int high){
          int[] sortedArray;
          if (low==high) {
              sortedArray=new int[]{arr[low]};
              return sortedArray;
          }
          int mid=(low+high)/2;
          int[] arr1=sort(arr,low,mid);
          int[] arr2=sort(arr,mid+1,high);
  
          sortedArray=merge(arr1,low,mid,arr2,mid+1,high);
          return sortedArray;
  
      }
  
      public static int[] merge(int[] arr1,int low1,int high1,int[] arr2,int low2,int high2){
  
          int size1=high1-low1+1;
          int size2=high2-low2+1;
          
          int[] arr=new int[size1+size2];
          int pointer=0;
          low1=0;low2=0;
          while (low1<size1 && low2<size2){
              if (arr1[low1] <= arr2[low2]) {
                  arr[pointer++]=arr1[low1++];
              }
              else{
                  arr[pointer++]=arr2[low2++];
              }
  
          }
  
          while(low1<size1) arr[pointer++]=arr1[low1++];
          while(low2<size2) arr[pointer++]=arr2[low2++];
          return arr;
      }
      
      public static void main(String[] args){
          Scanner sc=new Scanner(System.in);
          int t=sc.nextInt();
          while(t-- > 0){
              int n=sc.nextInt();
              long k=sc.nextLong();
              int[] arr=new int[n];
              long sum=0;
              for(int i=0;i<n;i++) {
                  arr[i]=sc.nextInt();
                  sum+=arr[i];
              }
              if (sum<=k){
                  System.out.println(0);
                  continue;
              }
              long s[]=new long[n];
              arr=sort(arr,0,n-1);
              s[n-1]=arr[n-1]-arr[0];
              long ans=sum-k;
          
              for(int i=n-2;i>=0;i--) s[i]=s[i+1]+arr[i]-arr[0];
             
              for(int i=n-1;i>=1;i--) {
                  
                  long caseAns=(sum-k-s[i]+n-i)/(n-i+1);
                  
                  caseAns=Math.max(caseAns,0);
                  caseAns+=n-i;
                  ans=Math.min(caseAns,ans);
              }
              System.out.println(ans);
          }
          sc.close();
      }
  }
  