CodeChef admins went on shopping at a shopping mall. 

There are N shops in the mall where the i^{th} shop has a capacity of A_{i} people. In other words, at any point in time, there can be at most A_{i} number of people in the i^{th} shop.

There are X admins. Each admin wants to visit each of the N shops exactly once. It is known that an admin takes exactly one hour for shopping at any particular shop. Find the minimum time (in hours) in which all the admins can complete their shopping.

Note: 
1. An admin can visit the shops in any order.
2. It is possible that at some point in time, an admin sits idle and does not visit any shop while others are shopping.

------ Input Format ------ 

- First line will contain T, the number of test cases. Then the test cases follow.
- The first line of each test case contains two integers N and X - the number of shops and the number of admins.
- The second line of each test case contains N integers A_{1}, A_{2}, \ldots, A_{N} - the capacity of the shops.

------ Output Format ------ 

For each test case, output in a single line the minimum time (in hours) in which all the admins can complete their shopping.

------ Constraints ------ 

$1 ≤ T ≤ 10^{5}$
$1 ≤ N ≤ 10^{5}$
$1 ≤ X, A_{i} ≤ 10^{9}$
- Sum of $N$ over all test cases does not exceed $2\cdot 10^{5}$.

----- Sample Input 1 ------ 
3
2 3
3 3
4 2
1 2 3 4
1 6
2
----- Sample Output 1 ------ 
2
4
3
----- explanation 1 ------ 
Test case $1$: Minimum time required to complete the shopping is two hours. A possible way to complete shopping in $2$ hours is :
- $1^{st}$ hour: All $3$ admins visit shop $1$. This is possible as the capacity of the shop is $3 ≥ 3$.
- $2^{nd}$ hour: All $3$ admins visit shop $2$. This is possible as the capacity of the shop is $3 ≥ 3$.

Test case $2$: Minimum time required to complete the shopping is $4$ hours. A possible way to complete shopping in $4$ hours is :
- $1^{st}$ hour: Admin $1$ visits shop $1$ and admin $2$ visits shop $4$.
- $2^{nd}$ hour: Admin $1$ visits shop $2$ and admin $2$ visits shop $3$.
- $3^{rd}$ hour: Admin $1$ visits shop $3$ and admin $2$ visits shop $2$.
- $4^{th}$ hour: Admin $1$ visits shop $4$ and admin $2$ visits shop $1$.

Test case $3$: Minimum time required to complete the shopping is $3$ hours. A possible way to complete shopping in $3$ hours is :
- $1^{st}$ hour: Admins $1$ and $2$ visits shop $1$. All other admins sit idle.
- $2^{nd}$ hour: Admins $3$ and $4$ visits shop $1$. All other admins sit idle.
- $3^{rd}$ hour: Admins $5$ and $6$ visits shop $1$. All other admins sit idle.  
Note that, since the capacity of shop is $2$, maximum $2$ admins visit the shop at once.

Difficulty: MEDIUM
Tags: Greedy algorithms
Skill types: Greedy algorithms

Starter code:

Solutions:
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	a = map(int, input().split())
	a1 = min(a)
	ans = x // a1
	if x % a1 != 0:
		ans += 1
	print(max(ans, n))


import os, sys, io, math
from re import *
from math import *
from array import *
from heapq import *
from bisect import *
from functools import *
from itertools import *
from statistics import *
from collections import *
I = lambda : [*map(int, sys.stdin.readline().split())]
IP = lambda : map(int, input().split())
IS = lambda : input()
IN = lambda : int(input())
IF = lambda : float(input())

def f():
	(n, x) = IP()
	l = I()
	m = min(l)
	res = x // m
	if x % m:
		res += 1
	return max(res, n)
for _ in range(IN()):
	print(f())


n = int(input())
while n:
	n -= 1
	(N, x) = map(int, input().split())
	l = [int(k) for k in input().split()]
	mini = min(l)
	a = x // mini
	if x % mini != 0:
		a += 1
	print(max(a, N))


import math
t = int(input())
for i in range(t):
	(n, x) = map(int, input().split(' '))
	l = list(map(int, input().split(' ')))
	mn = min(l)
	mn = math.ceil(x / mn)
	print(max(mn, n))


import sys, threading
import math
from os import path
from collections import defaultdict, Counter, deque
from bisect import *
from string import ascii_lowercase
from functools import cmp_to_key
import heapq

def lcm(a, b):
	return a * b // math.gcd(a, b)

def solve(t):
	(N, X) = map(int, input().split())
	A = list(map(int, input().split()))
	ans = max(N, math.ceil(X / min(A)))
	return ans

def main():
	t = 1
	if path.exists('/Users/nitishkumar/Documents/Template_Codes/Python/CP/Codechef/input.txt'):
		sys.stdin = open('/Users/nitishkumar/Documents/Template_Codes/Python/CP/Codechef/input.txt', 'r')
		sys.stdout = open('/Users/nitishkumar/Documents/Template_Codes/Python/CP/Codechef/output.txt', 'w')
	sys.setrecursionlimit(10 ** 5)
	t = int(input())
	for i in range(t):
		z = solve(i + 1)
		print(z)
main()


import math
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	arr = list(map(int, input().split()))
	a = min(arr)
	print(max(n, math.ceil(x / a)))


from math import ceil
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = list(map(int, input().split()))
	a.sort()
	print(max(ceil(m / min(a)), n))


import math
tests = int(input())
for i in range(tests):
	(n, x) = map(int, input().split())
	arr = list(map(int, input().split()))
	minimum_time = math.ceil(x / min(arr))
	print(max(minimum_time, n))


import math
inps = int(input())
for i in range(inps):
	inp1 = input().split(' ')
	inp2 = input().split(' ')
	shops = int(inp1[0])
	admins = int(inp1[1])
	capacity = []
	for i in inp2:
		capacity.append(int(i))
	print(max(shops, math.ceil(admins / min(capacity))))


from math import gcd, sqrt, ceil, floor, log
from heapq import heapify, heappop, heappush, nsmallest, nlargest
from collections import Counter, deque, OrderedDict, defaultdict
from itertools import combinations, permutations, zip_longest
from bisect import bisect_left, bisect_right
from functools import lru_cache, reduce
import sys
import time
import string
import operator
RECURSION_LIMIT = int(10000000.0)
INT_MAX = float('inf')
INT_MIN = float('-inf')
MOD = int(10000000.0) + 9
NEWLINE = '\n'
SPACE = ' '
sys.setrecursionlimit(RECURSION_LIMIT)
inp = lambda fn: fn(input())
inp_vars = lambda fn, delim, convert_to=list: convert_to(map(fn, input().split(delim)))
enum = lambda itr, start: enumerate(itr, start)

def toposort(graph, n):
	degree = [0] * n
	for node in graph:
		for adj in graph[node]:
			degree[adj] += 1
	bfs_queue = [node for node in range(n) if not degree[node]]
	for node in bfs_queue:
		for adj in graph[node]:
			degree[adj] -= 1
			if not degree[adj]:
				bfs_queue.append(adj)
	return (bfs_queue, degree)

def dfs(graph, node, visited):
	visited.add(node)
	for adj in graph[node]:
		if adj in visited:
			continue
		dfs(graph, adj, visited)

def seive(n):
	is_prime = [True] * (n + 1)
	is_prime[0] = is_prime[1] = False
	for i in range(2, int(n ** 0.5) + 1):
		if is_prime[i]:
			for j in range(i * i, n + 1, i):
				is_prime[j] = False
	return is_prime[n]

def bin_pow(x, y):
	if y == 0:
		return 1
	res = bin_pow(x, y >> 1)
	if y & 1 == 0:
		return res * res
	return x * res * res

def solve(*args, **kwargs):
	(n, k, arr) = args
	min_ = min(arr)
	time = k // min_ if k % min_ == 0 else k // min_ + 1
	return max(time, n)

def main(*args, **kwargs):
	for _ in range(int(input())):
		arg2 = inp_vars(int, SPACE)
		arg3 = inp_vars(int, SPACE)
		res = solve(*(*arg2, arg3))
		if type(res) in {list, tuple, set}:
			print(*res, sep=SPACE)
		else:
			print(res)
main()


t = int(input())
for i in range(t):
	(n, x) = map(int, input().split())
	arr = [int(x) for x in input().split()]
	mn = min(arr)
	if x % mn == 0:
		ans = x // mn
	else:
		ans = x // mn + 1
	print(max(ans, n))


import math as mt
for _ in range(int(input())):
	(n, k) = [int(x) for x in input().split()]
	a = [int(x) for x in input().split()]
	m = min(a)
	print(max(n, mt.ceil(k / m)))


import math
T = int(input())
for i in range(T):
	(n, x) = map(int, input().split())
	A = list(map(int, input().split()))
	min_element = min(A)
	print(max(math.ceil(x / min_element), n))


t = int(input())
while t > 0:
	(n, x) = map(int, input().split())
	l = list(map(int, input().split()))
	t -= 1
	a = min(l)
	b = x / a
	if b % 1 == 0:
		b = int(b)
	else:
		b = int(b) + 1
	if b > n:
		print(b)
	else:
		print(n)


import math
t = int(input())
for _ in range(t):
	(n, c) = map(int, input().split())
	arr = list(map(int, input().split()))
	print(max(math.ceil(c / min(arr)), n))


import math
try:
	for _ in range(int(input())):
		(n, x) = list(map(int, input().split()))
		arr = list(map(int, input().split()))
		mn = min(arr)
		ans = math.ceil(x / mn)
		print(max(n, ans))
except:
	pass


t = int(input())
import math
for _ in range(t):
	(n, x) = map(int, input().split())
	c_o_s = list(map(int, input().split()))
	m = min(c_o_s)
	time = math.ceil(x / m)
	print(max(time, n))


import math
t = int(input())
for tc in range(t):
	(n, x) = map(int, input().split())
	ans = n
	a = list(map(int, input().split()))
	m = min(a)
	ans = max(ans, math.ceil(x / m))
	print(ans)


test = int(input())
for i in range(test):
	(n, x) = map(int, input().split())
	array = list(map(int, input().split()))
	array.sort()
	maa = array[0]
	answer = x // maa + (x % maa != 0)
	if n >= answer:
		print(n)
	else:
		print(answer)


import math

def sol():
	(N, X) = map(int, input().split())
	A = list(map(int, input().split()))
	x = min(A)
	y = math.ceil(X / x)
	print(max(N, y))
for _ in range(int(input())):
	sol()


for T in range(int(input())):
	(N, X) = map(int, input().split())
	a = list(map(int, input().split()))
	minn = min(a)
	ans1 = N
	ans2 = X // minn if X % minn == 0 else X // minn + 1
	ans = max(ans1, ans2)
	print(ans)


import math
for _ in range(int(input())):
	(n, p) = map(int, input().split())
	ans = n
	a = list(map(int, input().split()))
	m = min(a)
	ans = max(ans, math.ceil(p / m))
	print(ans)


t = int(input())

def ceil(a, b):
	if a % b == 0:
		return a // b
	else:
		return a // b + 1
while t:
	t -= 1
	(n, x) = map(int, input().split())
	ls = list(map(int, input().split()))
	res = ceil(x, min(ls))
	print(max(res, n))


import math
T = int(input())
for _ in range(T):
	(N, X) = map(int, input().split())
	lst = list(map(int, input().split()))
	val = max(N, math.ceil(X / min(lst)))
	print(val)


import math
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	lst = list(map(int, input().split()))
	m = min(lst)
	ans = math.ceil(x / m)
	print(max(ans, n))


import math
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	Min = (1 << 32) - 1
	for ele in map(int, input().split()):
		if ele < Min:
			Min = ele
	if Min < x:
		ans = math.ceil(x / Min)
		if ans < n:
			ans = n
	else:
		ans = n
	print(ans)


for _ in range(int(input())):
	(N, X) = map(int, input().split())
	l = list(map(int, input().split()))
	min_ = min(l)
	print(max(X // min_ + (X % min_ != 0), N))


import math
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	print(max(n, math.ceil(x / min(map(int, input().split())))))


import math
for i in range(int(input())):
	(a, b) = map(int, input().split())
	l = list(map(int, input().split()))
	p = min(l)
	s = max(a, math.ceil(b / p))
	print(s)


def minimum_time_required(activity, n, x):
	min_capacity = min(capacity)
	if x % min_capacity == 0:
		result = x / min_capacity
	else:
		result = x / min_capacity + 1
	return max(result, n)
t = int(input())
while t:
	n_and_x = list(map(int, input().split()))
	n = n_and_x[0]
	x = n_and_x[1]
	capacity = list(map(int, input().split()))
	print(int(minimum_time_required(capacity, n, x)))
	t = t - 1


import sys
import math
input = sys.stdin.readline
T = int(input())
for j in range(T):
	(N, X) = map(int, input().split())
	A_i = list(set(map(int, input().split())))
	ai = min(A_i)
	r = math.ceil(X / ai)
	print(max(N, r))


import math
for i in range(int(input())):
	(n, x) = map(int, input().split())
	l = list(map(int, input().split()))
	c = 0
	l = sorted(l)
	a = max(l)
	b = min(l)
	print(max(n, math.ceil(x / b)))


import math
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = list(map(int, input().split()))
	minn = min(l)
	print(max(math.ceil(m / minn), n))


for t in range(int(input())):
	(n, x) = map(int, input().split())
	A = [int(i) for i in input().split()]
	if x <= n or x <= min(A):
		ans = n
	else:
		ans = x / min(A)
		if ans != int(ans):
			ans = int(ans) + 1
		ans = int(ans)
	print(max(n, ans))


import math

def Haptprogram():
	(n, x) = map(int, input().split())
	a = list(map(int, input().split()))
	mini = math.ceil(float(x) / min(a))
	print(max(mini, n))
t = int(input())
while t > 0:
	Haptprogram()
	t = t - 1


test = int(input())
while test:
	(n, x) = map(int, input().split())
	a = [int(x) for x in input().split()]
	print(max((x - 1) // min(a) + 1, n))
	test -= 1


t = int(input())
import math
for i in range(t):
	(n, x) = map(int, input().split(' '))
	s = input()
	l1 = list(map(int, s.split(' ')))
	value = max(n, math.ceil(x / min(l1)))
	print(value)


t = int(input())
for i in range(t):
	(n, x) = map(int, input().split())
	a = list(map(int, input().split()))
	res = 0
	if x % min(a) == 0:
		res = x // min(a)
	else:
		res = x // min(a) + 1
	print(max(n, res))


import math
z = int(input())
for i in range(z):
	(shop, admin) = list(map(int, input().split()))
	cap = list(map(int, input().split()))
	x = min(cap)
	y = math.ceil(admin / x)
	print(max(shop, y))


import math as m
k = int(input())
while k > 0:
	k -= 1
	(n, x) = map(int, input().split())
	l = list(map(int, input().split()))
	mn = min(l)
	print(max(n, m.ceil(x / mn)))


import math
for i in range(int(input())):
	(n, x) = map(int, input().split(' '))
	arr = list(map(int, input().split(' ')))
	ai = min(arr)
	A = math.ceil(x / ai)
	print(max(n, A))


import math
t = int(input())
while t > 0:
	(n, x) = map(int, input().split())
	arr = list(map(int, input().split()))
	m = min(arr)
	ans = math.ceil(x / m)
	print(max(n, ans))
	t -= 1


def ubounddiv(n, m):
	if n % m == 0:
		return int(n / m)
	else:
		return int(n / m + 1)
t = int(input())
for i in range(t):
	(n, x) = map(int, input().split())
	tmp = list(input().split())
	lst = [int(v) for v in tmp]
	z = ubounddiv(x, min(lst))
	print(max(n, z))


try:
	import math
	t = int(input())
	for _ in range(t):
		(n, x) = map(int, input().split())
		arr = map(int, input().split())
		minn = min(arr)
		ans = math.ceil(x / minn)
		print(max(n, ans))
except:
	pass


import math
for _ in range(int(input())):
	(N, X) = map(int, input().split())
	A = list(map(int, input().split()))
	print(max(N, math.ceil(X / min(A))))


def p():
	(n, x) = map(int, input().split())
	z = min(map(int, input().split()))
	m = max(n, x // z + (x % z != 0))
	print(m)
t = int(input())
while t:
	t -= 1
	p()


import math
T = int(input())
for i in range(T):
	(N, X) = map(int, input().split())
	a = min([int(i) for i in input().split()])
	time = max(N, math.ceil(X / a))
	print(time)


import math

def ans(arr, x):
	return max(math.ceil(x / min(arr)), len(arr))
for _ in range(int(input())):
	(N, X) = [int(i) for i in input().split()]
	arr = [int(i) for i in input().split()]
	print(ans(arr, X))


import math

def solve(arr, n, x):
	mini = min(arr)
	answer = math.ceil(x / mini)
	return max(n, answer)
t = int(input())
for i in range(t):
	(n, x) = map(int, input().split())
	arr = [int(i) for i in input().split()]
	print(solve(arr, n, x))


import math
for _ in range(int(input())):
	(n, x) = input().split()
	n = int(n)
	x = int(x)
	l = list(map(int, input().split()))
	m = x
	for i in l:
		if i < m:
			m = i
	m = math.ceil(x / m)
	if m > n:
		res = m
	else:
		res = n
	print(res)


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	arr = list(map(int, input().split()))
	minimum = min(arr)
	print(int(max(n, x / minimum + (x % minimum != 0))))


for _ in range(int(input())):
	(lan, chu) = map(int, input().split())
	n = min(map(int, input().split()))
	m = max(lan, chu // n + (chu % n != 0))
	print(m)


for i in range(int(input())):
	(n, x) = map(int, input().split())
	a = list(map(int, input().split()))
	if min(a) * n >= x:
		print(n)
	else:
		print((x + min(a) - 1) // min(a))


import math
T = int(input())
for a in range(0, T):
	(N, X) = map(int, input().split())
	b = [int(n) for n in input().split()]
	c = min(b)
	if X % c == 0:
		ans = max(N, math.ceil(X // c))
	else:
		ans = max(N, math.ceil(X // c) + 1)
	print(ans)


import sys
inp = sys.stdin.readline
for _ in range(int(inp())):
	(n, x) = map(int, input().split())
	a = [int(i) for i in input().split()]
	m = min(a)
	print(max(n, (x + m - 1) // m))


import sys
import bisect
inp = sys.stdin.readline

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def lcm(a, b):
	return a * b // gcd(a, b)
for _ in range(int(inp())):
	(n, x) = map(int, input().split())
	a = [int(i) for i in input().split()]
	m = min(a)
	print(max(n, (x + m - 1) // m))


import math
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	l = list(map(int, input().split()))
	mini = min(l)
	print(max(math.ceil(x / mini), n))


import math
t = int(input())
for tc in range(t):
	(n, x) = map(int, input().split())
	arr = list(map(int, input().split()))
	mini = min(arr)
	print(max(math.ceil(x / mini), n))


import math
T = int(input())
for tc in range(T):
	(n, x) = map(int, input().split())
	arr = list(map(int, input().split()))
	sm = min(arr)
	ans = math.ceil(x / sm)
	ans = max(ans, n)
	print(ans)


import math

def solve():
	(n, x) = (int(i) for i in input().split())
	a = [int(i) for i in input().split()]
	minimum = min(a)
	num_groups = math.ceil(x / minimum)
	print(max(n, num_groups))

def main():
	T = int(input())
	for _ in range(T):
		solve()
main()


import math
T = int(input())
for t in range(1, T + 1):
	inp = input().split()
	N = int(inp[0])
	X = int(inp[1])
	A = list(map(int, input().split()))
	mina = min(A)
	time_taken = max(N, math.ceil(X / mina))
	print(time_taken)


import math
for _ in range(int(input())):
	(nshops, nadmins) = list(map(int, input().split()))
	shopsCapa = list(map(int, input().split(' ')))
	ans = min(shopsCapa)
	print(max(nshops, math.floor((nadmins + ans - 1) / ans)))


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	arr = list(map(int, input().split()))
	minn = min(arr)
	tmp = x // minn if x % minn == 0 else x // minn + 1
	print(max(tmp, n))


from math import ceil
for _ in range(int(input())):
	(n, k) = map(int, input().split())
	s = min(map(int, input().split()))
	print(max(n, ceil(k / s)))


import math
t = int(input())
ans = []
for i in range(t):
	a = input().split()
	n = int(a[0])
	x = int(a[1])
	a = input().split()
	for j in range(n):
		a[j] = int(a[j])
	min_hr = int(math.ceil(x / min(a)))
	k = max(min_hr, n)
	ans.append(k)
if t == 1:
	print(ans[0], end='')
else:
	for i in range(t - 1):
		print(ans[i])
	print(ans[i + 1], end='')


for i in range(int(input())):
	(n, x) = map(int, input().split())
	a = min(map(int, input().split()))
	print(max(n, x // a + (x % a != 0)))