The activity of a panipuri seller is "making a panipuri and putting it on the palte of his customer".    
$N$ customers are eating panipuri, Given an array $A$ of length $N$, $i^{th}$ customer takes $A_i$ seconds to eat a panipuri.     
The Speed of Panipuri seller refers to the number of customers served per second. Determine the minimum speed of panipuri seller so that no customer has to wait for panipuri after getting his/her first panipuri.    
Assume that the plate can hold infinite panipuris, and customer starts eating next panipuri just after finishing the current one.    You would be provided with the time taken by each customer to eat a panipuri.
Panpuri seller serves panipuri in round robin manner (first to last and then again first).

-----Input:-----
- First line will contain $T$, number of testcases. Then the test cases follow.
- For each test case, the first line contains $N$ number of customers.
- Then the second line will contain $N$ space separated integers, $A_1$ to $A_N$, eating time taken by each customer(in seconds).

-----Output:-----
- For each test case, print a single line containing the minimum integral speed of panipuri seller so that no customer has to wait. 

-----Constraints-----
- $0 < T \leq 100$
- $0 < N \leq 10^6$
- $0 < A_i \leq 10^9$
- Sum of $N$ over all test cases does not exceed $10^6$

-----Sample Input:-----
2
4
2 4 6 3
5
2 3 4 6 5

-----Sample Output:-----
2

3

-----EXPLANATION:-----
$Test case$ $1$:

Let's assume speed of panipuri seller be 1.

So starting from $0^{th}$ second, in $0$ to $1$ second seller make a panipuri and put it into the plate of first customer, and first customer completely eat it in $1$ to $3$ second as he takes $2$ second to eat a panipuri. But in $3$ to $4$ second panipuri seller is serving to $4^{th}$ customer, and hence first customer have to wait, so 1 cannot be our answer.

Next possible speed can be $2$ .

Starting from $0^{th}$ second, at half second seller make a panipuri and put it into the plate of first customer,  first customer completely eat it on $2.5$ second as he takes $2$ second to eat a panipuri. In $0.5$ to $1$ second, seller serve the second customer. similarly in $1$ to $2$ second $3^{rd}$ and $4^{th}$ customer will be serve, in $2$ to $2.5$ second, seller will again serve the first customer so at $2.5$ sec $1^{st}$ customer will have a panipuri to eat.

Similarly proceeding further we will find that no customer have to wait when speed is $2$.

Difficulty: UNKNOWN_DIFFICULTY

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


from math import *
for i in range(int(input())):
	n = int(input())
	arr = [int(i) for i in input().split()]
	print(ceil(n / min(arr)))


import math
t = int(input())
while t:
	t = t - 1
	n = int(input())
	a = list(map(int, input().split()))
	print(math.ceil(n / min(a)))


for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	mi = min(l)
	ans = n / mi
	if ans == int(ans):
		print(int(ans))
	else:
		print(int(ans) + 1)


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


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


try:
	t = int(input())
	for _ in range(t):
		n = int(input())
		l = list(map(int, input().split()))
		x = min(l)
		if n // x == n / x:
			print(n // x)
		else:
			print(n // x + 1)
except:
	pass


from math import ceil
g = int(input())
for i in range(g):
	a = int(input())
	l = list(map(int, input().split()))
	print(ceil(a / min(l)))


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


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


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


for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	l = []
	for i in range(n):
		t = n / arr[i]
		if t == int(t):
			l.append(int(t))
		else:
			l.append(int(t + 1))
	print(max(l))


import math
t = int(input())
while t:
	t -= 1
	n = int(input())
	l = input().split()
	l = [int(i) for i in l]
	print(math.ceil(n / min(l)))


t = int(input())
while t:
	n = int(input())
	arr = list(map(int, input().split()))
	m = 0
	for i in arr:
		k = n / i
		if k != int(k):
			k = int(k) + 1
		if k > m:
			m = k
	print(int(m))
	t -= 1


import math
t = int(input())
for _ in range(0, t):
	n = int(input())
	a = list(map(int, input().split()))
	val = a[0]
	index = 0
	for i in range(0, len(a)):
		if a[i] < val:
			val = a[i]
			index = i
	print(math.ceil(n / val))


import math
t = int(input())
for i in range(t):
	a = int(input())
	val = input().split()
	val = [int(x) for x in val]
	ans = a / min(val)
	print(math.ceil(ans))


from collections import Counter
import string
import math
import sys
from fractions import Fraction

def array_int():
	return [int(i) for i in sys.stdin.readline().split()]

def vary(arrber_of_variables):
	if arrber_of_variables == 1:
		return int(sys.stdin.readline())
	if arrber_of_variables >= 2:
		return list(map(int, sys.stdin.readline().split()))

def makedict(var):
	return dict(Counter(var))

def printDivisors(n):
	divisors = []
	i = 1
	while i <= math.sqrt(n):
		if n % i == 0:
			if n // i == i:
				divisors.append(i)
			else:
				divisors.extend((i, n // i))
		i = i + 1
	return divisors

def countTotalBits(num):
	binary = bin(num)[2:]
	return len(binary)

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def comp(x):
	return x[1]
for _ in range(vary(1)):
	n = vary(1)
	num = array_int()
	print(math.ceil(n / min(num)))


import math
for test in range(int(input())):
	length = int(input())
	smallest = min([int(x) for x in input().split()])
	print(math.ceil(length / smallest))


import math
T = int(input())
for i in range(T):
	n = int(input())
	l = [int(x) for x in input().split()]
	s = math.ceil(n / min(l))
	print(s)