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$.

Starter code:

Solutions:
# cook your dish here
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)))

# cook your dish here
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)

# cook your dish here
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)

# cook your dish here
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)))

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)))

# cook your dish here
from math import ceil
for _ in range(int(input())):
    n=int(input())
    a=list(map(int,input().split()))
    print(ceil(n/min(a)))

# cook your dish here
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))

# cook your dish here
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)


# cook your dish here
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)))

# cook your dish here
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))


# your code goes here
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
# sys.setrecursionlimit(10**6) 
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))
# i am noob wanted to be better and trying hard for that
def printDivisors(n): 
    divisors=[]  
    # Note that this loop runs till square root 
    i = 1
    while i <= math.sqrt(n):
        if (n % i == 0):
            # If divisors are equal, print only one 
            if (n//i == i) : 
                divisors.append(i) 
            else : 
                # Otherwise print both 
                divisors.extend((i,n//i)) 
        i = i + 1
    return divisors
def countTotalBits(num):
     binary = bin(num)[2:]
     return(len(binary))
def isPrime(n):
    # Corner cases 
    if (n <= 1) : 
        return False
    if (n <= 3) : 
        return True
    # This is checked so that we can skip  
    # middle five numbers in below loop 
    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
""" mod=10**9+7
def ncr(n,r):
    if n<r:
        return 0
    numer=fact[n]
    # print(numer)
    denm=(fact[n-r]*fact[r])
    # print(denm)
    return numer*pow(denm,mod-2,mod) """
""" def dfs(node):
    nonlocal graph
    mex=0
    size=1
    for i in graph[node]:
        t=dfs(i)
        mex=max(mex,t[0])
        size+=t[1]
    return [mex+size,size] """
""" fact=[1]*(1001)
c=1 
mod=10**9+7
for i in range(1,1001):
    fact[i]=(fact[i-1]*i)%mod """
# print(fact)
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))

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)












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)

# cook your dish here
import math
t=int(input())
while(t):
    n=int(input())
    arr=list(map(int,input().split()))
    print(math.ceil(n/min(arr)))
    
    t-=1