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 sys
  input = sys.stdin.readline
  def mp():return map(int,input().split())
  def lmp():return list(map(int,input().split()))
  def mps(A):return [tuple(map(int, input().split())) for _ in range(A)]
  import math
  import bisect
  import heapq
  import time
  from copy import copy as cc
  from copy import deepcopy as dc
  from itertools import accumulate
  from collections import Counter, defaultdict, deque
  def ceil(U,V):return (U+V-1)//V
  def modf1(N,MOD):return (N-1)%MOD+1
  inf = int(1e18+20)
  mod = int(1e9+7)
  
  t = int(input())
  for _ in range(t):
      n,k = mp()
      a = lmp()
      if sum(a) <= k:
          print(0)
          continue
      if n == 1:
          print(a[0]-k)
          continue
      sa = sum(a)
      a.sort()
      a0 = dc(a[0])
      for i in range(n):
          a[i] -= a0
      ac = [0]+list(accumulate(a[::-1]))
      ans = sa-k
      now = 1
      #print(ac)
      for i in range(n):
          #print(ceil(sa - k - a[i], now) + i + 1, i)
          ans = min(ans, max(0,ceil(sa-k-ac[i], now))+i)
          now += 1
      print(ans)
  
  
  