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.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.io.PrintWriter;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.StringTokenizer;
  import java.util.*;
  
  public class cp {
      public static void main(String args[]) throws Exception {
          FastScanner sc = new FastScanner();
          int T = 1;
          T = sc.nextInt();
          PrintWriter pw = new PrintWriter(System.out);
          StringBuilder sb = new StringBuilder();
          while (T-- > 0) {
              solve(sc, pw, sb);
          }
          pw.print(sb);
          pw.close();
      }
      public static void solve(FastScanner sc, PrintWriter pw, StringBuilder sb) throws Exception {
          int n=sc.nextInt();
          long k=sc.nextLong();
          long[] arr = new long[n+1];
          for(int i=1;i<=n;i++){
              arr[i]=sc.nextLong();
          }
          Arrays.sort(arr);
          // pw.println(Arrays.toString(arr));
          long[] ps = new long[n+1];
          for(int i=1;i<=n;i++){
              ps[i]=ps[i-1]+arr[i];
          }
          // 1 2 3 4 5 6 (x=3)
          // -       - -
          long count=(long)1e12;
          for(int x=1;x<=n;x++){
              // first element and X-1 elements from last
              // index of last element we want to reduce is n-x+1
              // prefix sum in range[2,n-x+1]
              long sum=ps[n-x+1]-ps[1];
              long req=k-sum;
              long value=req/(x);
              if(value*x>req) value--; // this is required because if we don't do this we will not be able to decrease the sum for the remainder(value*x....req)
              count=Math.min(count,Math.max(0L,arr[1]-value)+x-1);
          }
          sb.append(count+"\n");
      }
      /*
      Observations and Solutions:
      1. We will decrease only the min element
      2. We will set (let's say X number of elements equal to new min element) after decreasing the min element
  
      So now the question is "How much the min element should be decrease?"
      I was trying to find the answer for it which I couldn't find by binary search too.
  
      The way to solve ths problem after binary search didn't work is by looking at other possibilites that might happen.
      The other thing certain about in this problem is the number of elements that we might decrease.
  
      So let's say we decrease X number of elements.
      We don't know by how much we shall have decreased these elements. Look for other things we might know.
      Since we have decreased X elements, the min element would also have been decrease hence decreasing (X+1)elements and N-(X+1) elements remain the same.
      Since the N-(X+1) numbers are not changed, let their sum be S
      Hence the want the sum for these (X+1) elements to be decreased by K-S
      
      What can be the minimum value for each of these elements-> (K-S)/X+1 -> rounded down
      
      Hence we must decrease the min element(first element) by (K-S)/(X+1) times
      */
  
      public static long[]  sort(long[] arr){
          ArrayList<Long> temp = new ArrayList<>();
          for(long x:arr) temp.add(x);
          Collections.sort(temp);
          int i=0;
          for(long x:temp){
              arr[i++]=x;
          }
          return arr;
      }
      public static int gcd(int a,int b){
          if(b==0) return a;
          return gcd(b,a%b);
      }
      static class FastScanner {
          public BufferedReader reader;
          public StringTokenizer tokenizer;
  
          public FastScanner() {
              reader = new BufferedReader(new InputStreamReader(System.in), 32768);
              tokenizer = null;
          }
  
          public String next() {
              while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                  try {
                      tokenizer = new StringTokenizer(reader.readLine());
                  } catch (IOException e) {
                      throw new RuntimeException(e);
                  }
              }
              return tokenizer.nextToken();
          }
  
          public int nextInt() {
              return Integer.parseInt(next());
          }
  
          public long nextLong() {
              return Long.parseLong(next());
          }
  
          public double nextDouble() {
              return Double.parseDouble(next());
          }
  
          public String nextLine() {
              try {
                  return reader.readLine();
              } catch (IOException e) {
                  throw new RuntimeException(e);
              }
          }
  
          public int[] readIntArray(int n){
              int[] arr=new int[n];
              for(int i=0;i<n;i++){
                  arr[i]=nextInt();
              }
              return arr;
          }
  
          public long[] readLongArray(int n){
              long[] arr=new long[n];
              for(int i=0;i<n;i++){
                  arr[i]=nextLong();
              }
              return arr;
          }
      }
  }
  