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.*;
  import java.util.*;
  import java.math.*;
  import static java.lang.Math.*;
  import static java.util.Map.*;
  import static java.util.Arrays.*;
  import static java.util.Collections.*;
  import static java.lang.System.*;
  public class Main
  {
      public void tq() throws Exception
      {
          st=new StringTokenizer(bq.readLine());
          int tq=i();
          sb=new StringBuilder(2000000);
          o:
          while(tq-->0)
          {
              int n=i();
              long k=l();
              int ar[]=ari(n);
              int m=max;
              long s=0l;
              for(int x:ar)
              {
                  s+=x;
                  m=min(m,x);
              }
              if(s<=k)
              {
                  sl(0);
                  continue;
              }
              so(ar);
              long c=maxl;
              long r=0l;
              int i=1;
              if(n==1)
              {
                  sl(ar[0]-k);
                  continue;
              }
              for(int x=n-1;x>=1;x--)
              {
                  i++;
                  c=min(c,r+max(0,s-k));
                  s-=(ar[x]-m);
                  r++;
                  c=min(c,r+max(0,((s-k+(i-1))/i)));
              }
              sl(c);
          }
          p(sb);
      }
      long mod=1000000007l;
      int max=Integer.MAX_VALUE,min=Integer.MIN_VALUE;long maxl=Long.MAX_VALUE,minl=Long.MIN_VALUE;
      BufferedReader bq = new BufferedReader(new InputStreamReader(in));StringTokenizer st;StringBuilder sb;
      public static void main(String[] a)throws Exception{new Main().tq();}
      int di[][]={{-1,0},{1,0},{0,-1},{0,1}};
      int de[][]={{-1,0},{1,0},{0,-1},{0,1},{-1,-1},{1,1},{-1,1},{1,-1}};
      void f(){out.flush();}
      boolean c(int x,int y,int n,int m){return x>=0&&x<n&&y>=0&&y<m;}
      int[] so(int ar[])
      {
          Integer r[] = new Integer[ar.length];
          for (int x = 0; x < ar.length; x++) r[x] = ar[x];
          sort(r);
          for (int x = 0; x < ar.length; x++) ar[x] = r[x];
          return ar;
      }
      long[] so(long ar[])
      {
          Long r[] = new Long[ar.length];
          for (int x = 0; x < ar.length; x++) r[x] = ar[x];
          sort(r);
          for (int x = 0; x < ar.length; x++) ar[x] = r[x];
          return ar;
      }
      char[] so(char ar[])
      {
          Character r[] = new Character[ar.length];
          for (int x = 0; x < ar.length; x++) r[x] = ar[x];
          sort(r);
          for (int x = 0; x < ar.length; x++) ar[x] = r[x];
          return ar;
      }
      void p(Object p) {out.print(p);}void pl(Object p) {out.println(p);}void pl() {out.println();}
      void s(String s) {sb.append(s);}
      void s(int s) {sb.append(s);}
      void s(long s) {sb.append(s);}
      void s(char s) {sb.append(s);}
      void s(double s) {sb.append(s);}
      void ss() {sb.append(' ');}
      void sl(String s) {s(s);sb.append("\n");}
      void sl(int s) {s(s);sb.append("\n");}
      void sl(long s) {s(s);sb.append("\n");}
      void sl(char s) {s(s);sb.append("\n");}
      void sl(double s) {s(s);sb.append("\n");}
      void sl() {sb.append("\n");}
      int l(int v) {return 31 - Integer.numberOfLeadingZeros(v);}
      long l(long v) {return 63 - Long.numberOfLeadingZeros(v);}
      int sq(int a) {return (int) sqrt(a);}
      long sq(long a) {return (long) sqrt(a);}
      int gcd(int a, int b)
      {
          while (b > 0)
          {
              int c = a % b;
              a = b;
              b = c;
          }
          return a;
      }
      long gcd(long a, long b)
      {
          while (b > 0l)
          {
              long c = a % b;
              a = b;
              b = c;
          }
          return a;
      }
      boolean pa(String s, int i, int j)
      {
          while (i < j) if (s.charAt(i++) != s.charAt(j--)) return false;
          return true;
      }
      boolean[] si(int n)
      {
          boolean bo[] = new boolean[n + 1];
          bo[0] = bo[1] = true;
          for (int x = 4; x <= n; x += 2) bo[x] = true;
          for (int x = 3; x * x <= n; x += 2)
          {
              if (!bo[x])
              {
                  int vv = (x << 1);
                  for (int y = x * x; y <= n; y += vv) bo[y] = true;
              }
          }
          return bo;
      }
      long mul(long a, long b, long m)
      {
          long r = 1l;
          a %= m;
          while (b > 0)
          {
              if ((b & 1) == 1) r = (r * a) % m;
              b >>= 1;
              a = (a * a) % m;
          }
          return r;
      }
      int i() throws IOException
      {
          if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
          return Integer.parseInt(st.nextToken());
      }
      long l() throws IOException
      {
          if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
          return Long.parseLong(st.nextToken());
      }
      String s() throws IOException
      {
          if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
          return st.nextToken();
      }
      double d() throws IOException
      {
          if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
          return Double.parseDouble(st.nextToken());
      }
      void s(int a[])
      {
          for (int e : a){sb.append(e);sb.append(' ');}
          sb.append("\n");
      }
      void s(long a[])
      {
          for (long e : a){sb.append(e);sb.append(' ');}
          sb.append("\n");
      }
      void s(char a[])
      {
          for (char e : a){sb.append(e);sb.append(' ');}
          sb.append("\n");
      }
      void s(int ar[][]) {for (int a[] : ar) s(a);}
      void s(long ar[][]) {for (long a[] : ar) s(a);}
      void s(char ar[][]) {for (char a[] : ar) s(a);}
      int[] ari(int n) throws IOException
      {
          int ar[] = new int[n];
          if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
          for (int x = 0; x < n; x++) ar[x] = Integer.parseInt(st.nextToken());
          return ar;
      }
      long[] arl(int n) throws IOException
      {
          long ar[] = new long[n];
          if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
          for (int x = 0; x < n; x++) ar[x] = Long.parseLong(st.nextToken());
          return ar;
      }
      char[] arc(int n) throws IOException
      {
          char ar[] = new char[n];
          if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
          for (int x = 0; x < n; x++) ar[x] = st.nextToken().charAt(0);
          return ar;
      }
      double[] ard(int n) throws IOException
      {
          double ar[] = new double[n];
          if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
          for (int x = 0; x < n; x++) ar[x] = Double.parseDouble(st.nextToken());
          return ar;
      }
      String[] ars(int n) throws IOException
      {
          String ar[] = new String[n];
          if (!st.hasMoreTokens()) st = new StringTokenizer(bq.readLine());
          for (int x = 0; x < n; x++) ar[x] = st.nextToken();
          return ar;
      }
      int[][] ari(int n, int m) throws IOException
      {
          int ar[][] = new int[n][m];
          for (int x = 0; x < n; x++)ar[x]=ari(m);
          return ar;
      }
      long[][] arl(int n, int m) throws IOException
      {
          long ar[][] = new long[n][m];
          for (int x = 0; x < n; x++)ar[x]=arl(m);
          return ar;
      }
      char[][] arc(int n, int m) throws IOException
      {
          char ar[][] = new char[n][m];
          for (int x = 0; x < n; x++)ar[x]=arc(m);
          return ar;
      }
      double[][] ard(int n, int m) throws IOException
      {
          double ar[][] = new double[n][m];
          for (int x = 0; x < n; x++)ar[x]=ard(m);
          return ar;
      }
      void p(int ar[])
      {
          sb = new StringBuilder(11 * ar.length);
          for (int a : ar) {sb.append(a);sb.append(' ');}
          out.println(sb);
      }
      void p(long ar[])
      {
          StringBuilder sb = new StringBuilder(20 * ar.length);
          for (long a : ar){sb.append(a);sb.append(' ');}
          out.println(sb);
      }
      void p(double ar[])
      {
          StringBuilder sb = new StringBuilder(22 * ar.length);
          for (double a : ar){sb.append(a);sb.append(' ');}
          out.println(sb);
      }
      void p(char ar[])
      {
          StringBuilder sb = new StringBuilder(2 * ar.length);
          for (char aa : ar){sb.append(aa);sb.append(' ');}
          out.println(sb);
      }
      void p(String ar[])
      {
          int c = 0;
          for (String s : ar) c += s.length() + 1;
          StringBuilder sb = new StringBuilder(c);
          for (String a : ar){sb.append(a);sb.append(' ');}
          out.println(sb);
      }
      void p(int ar[][])
      {
          StringBuilder sb = new StringBuilder(11 * ar.length * ar[0].length);
          for (int a[] : ar)
          {
              for (int aa : a){sb.append(aa);sb.append(' ');}
              sb.append("\n");
          }
          p(sb);
      }
      void p(long ar[][])
      {
          StringBuilder sb = new StringBuilder(20 * ar.length * ar[0].length);
          for (long a[] : ar)
          {
              for (long aa : a){sb.append(aa);sb.append(' ');}
              sb.append("\n");
          }
          p(sb);
      }
      void p(double ar[][])
      {
          StringBuilder sb = new StringBuilder(22 * ar.length * ar[0].length);
          for (double a[] : ar)
          {
              for (double aa : a){sb.append(aa);sb.append(' ');}
              sb.append("\n");
          }
          p(sb);
      }
      void p(char ar[][])
      {
          StringBuilder sb = new StringBuilder(2 * ar.length * ar[0].length);
          for (char a[] : ar)
          {
              for (char aa : a){sb.append(aa);sb.append(' ');}
              sb.append("\n");
          }
          p(sb);
      }
      void pl(Object... ar) {for (Object e : ar) p(e + " ");pl();}
  }