You are both a shop keeper and a shop assistant at a small nearby shop. You have $n$ goods, the $i$-th good costs $a_i$ coins.

You got tired of remembering the price of each product when customers ask for it, thus you decided to simplify your life. More precisely you decided to set the same price for all $n$ goods you have.

However, you don't want to lose any money so you want to choose the price in such a way that the sum of new prices is not less than the sum of the initial prices. It means that if you sell all $n$ goods for the new price, you will receive at least the same (or greater) amount of money as if you sell them for their initial prices.

On the other hand, you don't want to lose customers because of big prices so among all prices you can choose you need to choose the minimum one.

So you need to find the minimum possible equal price of all $n$ goods so if you sell them for this price, you will receive at least the same (or greater) amount of money as if you sell them for their initial prices.

You have to answer $q$ independent queries.


-----Input-----

The first line of the input contains one integer $q$ ($1 \le q \le 100$) — the number of queries. Then $q$ queries follow.

The first line of the query contains one integer $n$ ($1 \le n \le 100)$ — the number of goods. The second line of the query contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^7$), where $a_i$ is the price of the $i$-th good.


-----Output-----

For each query, print the answer for it — the minimum possible equal price of all $n$ goods so if you sell them for this price, you will receive at least the same (or greater) amount of money as if you sell them for their initial prices.


-----Example-----
Input
3
5
1 2 3 4 5
3
1 2 2
4
1 1 1 1

Output
3
2
1

Source: codeforces | Difficulty: EASY
Tags: Mathematics


Solutions:
from math import ceil
for i in range(int(input())):
	n = int(input())
	print(ceil(sum(map(int, input().split())) / n))


q = int(input())
for _ in range(q):
	n = int(input())
	array = [int(_) for _ in input().split(' ')]
	if sum(array) % len(array) > 0:
		flat = sum(array) // len(array) + 1
	else:
		flat = sum(array) // len(array)
	print(flat)


for _ in range(int(input())):
	n = int(input())
	a = sorted(list(map(int, input().split())))
	print((sum(a) + (n - 1)) // n)


import math
for _ in range(int(input())):
	a = []
	n = int(input())
	a[0:n] = list(map(int, input().strip().split()))
	print(math.ceil(sum(a) / n))


import math
for _ in range(int(input())):
	n = int(input())
	list1 = list(map(int, input().split()))
	sum = 0
	for item in list1:
		sum = sum + item
	print(math.ceil(sum / n))


q = int(input())
for qi in range(q):
	n = int(input())
	li = [int(ii) for ii in input().split(' ')]
	s = 0
	for i in li:
		s += i
	if s // n < s / n:
		print(s // n + 1)
	else:
		print(s // n)


for t in range(int(input())):
	n = int(input())
	summe = sum(list(map(int, input().split())))
	print((summe + n - 1) // n)


import math
for _ in range(int(input())):
	n = int(input())
	p = list(map(int, input().split()))
	print(math.ceil(sum(p) / n))


steps = int(input())
for _ in range(steps):
	count = int(input())
	numbers = [int(i) for i in input().split()]
	ans = sum(numbers) / len(numbers)
	if int(ans) < ans:
		ans = int(ans) + 1
	else:
		ans = int(ans)
	print(ans)


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


t = int(input())
while t > 0:
	n = int(input())
	a = map(int, input().split())
	s = 0
	for i in a:
		s = s + i
	if s % n > 0:
		print(s // n + 1)
	else:
		print(s // n)
	t -= 1


from math import ceil
loops = int(input())
for _ in range(loops):
	num_goods = int(input())
	prices = list(map(int, input().split(' ')))
	print(ceil(sum(prices) / num_goods))


t = int(input())
for i in range(t):
	n = int(input())
	s = sum(list(map(int, input().split())))
	if s % n == 0:
		print(s // n)
	else:
		print(s // n + 1)


from math import *
tc = int(input())
outs = []
for i in range(tc):
	n = int(input())
	lis = [int(x) for x in input().split()]
	ans = ceil(sum(lis) / n)
	outs.append(ans)
for i in outs:
	print(i)


from math import *
for _ in range(int(input())):
	n = int(input())
	x = sum(list(map(int, input().split())))
	print(int(ceil(x / n)))


q = int(input())
h = []
for i in range(q):
	n = int(input())
	s = input()
	l = s.split()
	l1 = [int(j) for j in l]
	x = sum(l1) // len(l1)
	if sum(l1) % len(l1) != 0:
		x += 1
	h.append(x)
for i in range(len(h)):
	print(h[i])


import math
t = int(input())
while t:
	n = int(input())
	arr = list(map(int, input().split()))
	sum = 0
	for i in range(n):
		sum = sum + arr[i]
	print(math.ceil(sum / n))
	t = t - 1


from math import ceil
for _ in range(1, int(input()) + 1):
	n = int(input())
	a = list(map(int, input().split()))
	print(ceil(sum(a) / n))


import functools
from math import ceil
for x in range(int(input())):
	a = int(input())
	b = list(map(int, input().split()))
	c = functools.reduce(lambda a, b: a + b, b)
	print(ceil(c / a))


n = int(input())
for i in range(n):
	x = int(input())
	l = sum(list(map(int, input().split())))
	if l % x != 0:
		print(l // x + 1)
	else:
		print(l // x)


from collections import deque
import sys
import math

def inp():
	return sys.stdin.readline().strip()
for _ in range(int(inp())):
	n = int(inp())
	a = list(map(int, inp().split()))
	print(math.ceil(sum(a) / n))


import math
nb_queries = int(input())
for q in range(nb_queries):
	n = int(input())
	a = [int(x) for x in input().split()]
	print(math.ceil(sum(a) / n))


t = int(input())
for _ in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	summ = sum(arr)
	t = summ / n
	if t == int(t):
		print(int(t))
	else:
		print(int(t) + 1)


from math import ceil
from typing import Iterator

def get_num_input() -> Iterator[int]:
	return map(int, input().split())

def main() -> None:
	length: int = int(input())
	print(ceil(sum(get_num_input()) / length))
ONLY_ONCE: bool = False
for _ in range(1 if ONLY_ONCE else int(input())):
	main()


t = int(input())
for _ in range(t):
	n = int(input())
	print((sum(map(int, input().split())) + n - 1) // n)


class Request:

	def __init__(self, _n, _summ):
		self.n = _n
		self.summ = _summ
requests = []
q = int(input())
for i in range(q):
	n = int(input())
	ai = input().split()
	summ = 0
	for j in ai:
		summ += int(j)
	requests.append(Request(n, summ))
for i in requests:
	if i.summ % i.n == 0:
		print(int(i.summ / i.n))
	else:
		print(int(i.summ / i.n) + 1)


import math
for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	floor = math.floor(sum(arr) / n)
	ceil = math.ceil(sum(arr) / n)
	print(ceil if ceil * n >= sum(arr) else floor)


import math

def price(a, n):
	x = sum(a)
	z = math.ceil(x / n)
	return z
q = int(input())
for _ in range(q):
	n = int(input())
	a = list(map(int, input().split()))
	print(price(a, n))


def z1():
	amOfQuerries = int(input())
	i = 0
	while i < amOfQuerries:
		i += 1
		amOfGoods = int(input())
		print((sum(map(int, input().split())) + amOfGoods - 1) // amOfGoods)
z1()


q = int(input())
ans = []
for i in range(q):
	n = int(input())
	a = list(map(int, input().split()))
	ans.append((sum(a) + (n - 1)) // n)
for i in range(q):
	print(ans[i])


t = int(input())
while t > 0:
	n = int(input())
	l = list((int(x) for x in input().split()))
	c1 = sum(l)
	if c1 % n == 0:
		print(c1 // n)
	else:
		print(c1 // n + 1)
	t = t - 1


q = int(input())
for v in range(0, q):
	n = int(input())
	a = list(map(int, input().split()))
	sum = 0
	for i in range(0, n):
		sum += a[i]
	f = sum / n
	if f - int(f) == 0:
		print(int(f))
	else:
		print(int(f) + 1)


from math import *
t = int(input())
while t > 0:
	k = int(input())
	n = input()
	l = [int(i) for i in n.split()]
	sum = 0
	for i in l:
		sum += i
	sol = sum / k
	sol = ceil(sol)
	print(sol)
	t -= 1


import math
q = int(input())
s = 0
for i in range(0, q):
	n = int(input())
	list1 = input().split(' ')
	for k in range(0, n):
		s += int(list1[k])
	s = math.ceil(s / n)
	print(s)
	s = 0


for x in range(int(input())):
	n = int(input())
	m = list(map(int, input().split()))
	z = sum(m)
	if z % n == 0:
		print(z // n)
	else:
		print(z // n + 1)


import math
t = int(input())
while t > 0:
	n = int(input())
	_list = list(map(int, input().split()))
	ans = 0
	for i in _list:
		ans += i
	print(math.ceil(ans / len(_list)))
	t -= 1


import math
n = int(input())
for i in range(n):
	a = int(input())
	b = [int(i) for i in input().split()]
	e = sum(b)
	print(math.ceil(e / a))


q = int(input())
for i in range(q):
	list = []
	n = int(input())
	s = input().split()
	s = [int(i) for i in s]
	for i in range(len(s)):
		list.append(s[i])
	sm = sum(list)
	if sm % n == 0:
		print(sm // n)
	else:
		t = sm % n
		sm = sm + (n - t)
		print(sm // n)


from math import ceil
for tc in range(int(input())):
	input()
	vals = [int(x) for x in input().split()]
	print(ceil(sum(vals) / len(vals)))


import math
for i in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	store = sum(arr)
	x = math.ceil(store / n)
	print(x)


import math

def solve():
	n = int(input())
	prices_str = input()
	prices = [int(x) for x in prices_str.split(' ')]
	print(math.ceil(sum(prices) / n))
q = int(input())
for i in range(q):
	solve()


for i in range(int(input())):
	n = int(input())
	A = list(map(int, input().split(' ')))
	avg = sum(A) // n
	t = avg
	for i in range(avg, max(A) + 1):
		if i * n >= sum(A):
			t = i
			break
	print(t)


import math
t = int(input())
while t > 0:
	t -= 1
	n = int(input())
	h = list(map(int, input().split()))
	d = math.ceil(sum(h) / n)
	print(d)


n = int(input())
import math
for i in range(n):
	sum = 0
	b = []
	m = int(input())
	a = input().split()
	for j in range(m):
		a[j] = int(a[j])
		b.append(a[j])
	for k in range(m):
		sum = sum + b[k]
	ans = math.ceil(sum / m)
	print(ans)


for _ in range(int(input())):
	input()
	a = [int(i) for i in input().split()]
	e = sum(a) // len(a)
	if e * len(a) == sum(a):
		print(e)
	else:
		print(e + 1)


from math import ceil
q = int(input())
for _ in range(q):
	x = int(input())
	a = list(map(int, input().split()))
	x = ceil(sum(a) / x)
	print(x)


import statistics as s
import math
t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	ans = sum(a)
	print(-(-ans // n))


import math
for x in range(int(input())):
	r = 0
	i0 = int(input())
	i1 = list(input().split())
	for y in range(len(i1)):
		i1[y] = int(i1[y])
		r += i1[y]
	print(math.ceil(r / i0))


from math import ceil
queries = int(input())
for y in range(queries):
	n = int(input())
	prices = sorted(list(map(int, input().split())))
	avg = ceil(sum(prices) / n)
	print(avg)


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	a.sort()
	b = sum(a)
	d = set(a)
	if len(d) == 1:
		print(a[0])
	else:
		v = b % n
		h = b // n
		if v == 0:
			print(h)
		else:
			print(h + 1)


q = int(input())
for _ in range(q):
	n = int(input())
	dat = list(map(int, input().split()))
	import math
	print(math.ceil(sum(dat) / n))


q = int(input())
for i in range(q):
	n = int(input())
	a = list(map(int, input().split(maxsplit=n)))
	print((sum(a) + n - 1) // n)


for i in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	b = sum(a)
	if b % n == 0:
		print(b // n)
	else:
		print(b // n + 1)


import math
n = int(input())
results = []
for i in range(n):
	m = int(input())
	num_arr = list(map(int, input().split()))
	sum_num_arr = sum(num_arr)
	results.append(math.ceil(sum_num_arr * 1.0 / len(num_arr)))
for i in range(len(results)):
	print(results[i])


q = int(input())
for i in range(q):
	n = int(input())
	l = input().split()
	l = [int(i) for i in l]
	a = len(l)
	b = sum(l)
	if b % a == 0:
		print(b // a)
	else:
		print(b // a + 1)


t = int(input())
l = []
while t > 0:
	t -= 1
	n = int(input())
	a = list(map(int, input().split(' ')))
	p = sum(a) / n
	p = int(p) + int(not p % 1 == 0)
	l.append(p)
print(*l, sep='\n')


for _ in range(int(input())):
	n = int(input())
	sp = list(map(int, input().split()))
	a = sum(sp) / len(sp)
	if int(a) < a:
		print(int(a) + 1)
	else:
		print(int(a))


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


import re, math, decimal, bisect

def read():
	return input().strip()

def iread():
	return int(input().strip())

def viread():
	return [int(_) for _ in input().strip().split()]

def round(n):
	return int(n + 0.5)
DEBUG = 1
DEBUG = 0

def debug(*args, **kwargs):
	if DEBUG:
		print(*args, **kwargs)
t = iread()
for _ in range(t):
	n = iread()
	arr = viread()
	debug('--', sum(arr), sum(arr) / n)
	print(math.ceil(sum(arr) / n))


q = int(input(''))
b = []
for i in range(q):
	n = int(input(''))
	a = list(map(int, input().split(' ')))
	s = sum(a)
	avg = int(s / n)
	r = s % n
	if r != 0:
		avg = avg + 1
	b.append(avg)
for i in range(q):
	print(b[i])


for i in range(int(input())):
	n = int(input())
	lis = map(int, input().split(' '))
	su = sum(lis)
	if su % n == 0:
		print(int(su / n))
	else:
		print(int(su / n) + 1)


for x in range(int(input())):
	a = int(input())
	b = sum([int(x) for x in input().split()])
	print(b // a if b % a == 0 else b // a + 1)


from math import ceil
from statistics import mean

def soln() -> None:

	def logic() -> None:
		n = int(input())
		arr = [int(x) for x in input().split()]
		print(ceil(mean(arr)))
	for _ in range(int(input())):
		logic()
soln()


import math
t = int(input())
for i in range(t):
	n = int(input())
	sum = 0
	for x in input().split():
		sum += int(x)
	print(math.ceil(sum / n))


t = int(input())
while t > 0:
	t -= 1
	n = int(input())
	a = list(map(int, input().split()))
	s = 0
	for i in a:
		s += i
	x = s // n
	if s % n != 0:
		x += 1
	print(x)


for i in range(int(input())):
	n = int(input())
	s = input().split()
	suma = 0
	for el in s:
		suma += int(el)
	if suma % n == 0:
		print(suma // n)
	else:
		print(suma // n + 1)


import sys
input = sys.stdin.readline

def main():
	q = int(input())
	for _ in range(q):
		n = int(input())
		a = [int(x) for x in input().split()]
		print(-(-sum(a) // n))
main()


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


from math import ceil
for i in range(int(input())):
	n = int(input())
	l = [int(s) for s in input().split()]
	s = 0
	for i in range(len(l)):
		s = s + l[i]
	p = s / n
	print(ceil(p))


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


from sys import stdin, stdout
for _ in range(int(stdin.readline())):
	n = int(stdin.readline())
	a = list(map(int, stdin.readline().split()))
	each = sum(a) // n
	if each * n < sum(a):
		each += 1
	print(each)


from sys import stdin
import math

def solve(n, a):
	ans = int(math.ceil(sum(a) / n))
	print(ans)
	return

def main():
	inp = stdin.readline
	for _ in range(int(inp())):
		n = int(inp())
		a = list(map(int, inp().split()))
		solve(n, a)
main()


from math import *
q = int(input())
a = [0] * q
s = 0
mi = 0
ma = 0
for j in range(q):
	n = int(input())
	f = [int(b) for b in input().split()]
	for g in f:
		s = s + int(g)
	s = ceil(s / n)
	a[j] = s
	s = 0
for i in a:
	print(i)


t = int(input())
while t:
	t = t - 1
	n = int(input())
	a = list(map(int, input().split()))
	sum1 = sum(a)
	n = len(a)
	sum1 = sum1 / n
	if sum1 > int(sum1):
		print(int(sum1) + 1)
	else:
		print(int(sum1))


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


from math import ceil
q = int(input())
for _ in range(q):
	n = int(input())
	A = list(map(int, input().split()))
	print(ceil(sum(A) / n))


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


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


import math
s = []
for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	total = 0
	for i in range(len(l)):
		total += l[i]
	s.append(math.ceil(total / n))
for item in s:
	print(item)


q = int(input())
for _ in range(q):
	n = int(input())
	s = sum(list(map(int, input().split())))
	print((s + n - 1) // n)


q = int(input())
for I in range(q):
	n = int(input())
	a = [int(i) for i in input().split()]
	tot = sum(a)
	ans = tot // n
	if ans * n >= tot:
		print(ans)
	else:
		print(ans + 1)


import math as m
for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	su = sum(l)
	print(m.ceil(su / n))


for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	s = 0
	for i in range(n):
		s += l[i]
	if s % n == 0:
		print(s // n)
	else:
		print(s // n + 1)


q = int(input())
s = 0
for i in range(q):
	n = int(input())
	a = list(map(int, input().split()))
	for k in range(len(a)):
		s += a[k]
	if s % n == 0:
		print(s // n)
		s = 0
	else:
		print(s // n + 1)
		s = 0


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


import sys

def input():
	return sys.stdin.readline().strip()

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
for _ in range(INT()):
	N = INT()
	A = LIST()
	print(ceil(sum(A), N))


import math
q = int(input())
c = []
for i in range(q):
	n = int(input())
	a = [int(i) for i in input().split()]
	c.append(math.ceil(sum(a) / n))
[print(i) for i in c]


t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	avg = sum(a) / n
	if avg - int(avg) == 0:
		print(int(avg))
	else:
		print(int(avg) + 1)


t = int(input())
m = 0
while m < t:
	n = int(input())
	a = list(map(int, input().split()))
	s = sum(a)
	if s % n == 0:
		print(s // n)
	else:
		print(s // n + 1)
	m = m + 1


q = int(input())
for i in range(q):
	n = int(input())
	sum_ai = sum(list(map(int, input().split())))
	print(sum_ai // n if sum_ai % n == 0 else sum_ai // n + 1)


t = int(input())
for i in range(t):
	n = int(input())
	arr = [int(x) for x in input().split()]
	s = sum(arr)
	avg = s // n
	if avg * n < s:
		avg += 1
	print(avg)


import math
case = int(input())
for caseNum in range(0, case):
	n = int(input())
	numList = [int(x) for x in input().split()]
	print(math.ceil(sum(numList) / n))


import math
T = int(input())
while T > 0:
	n = int(input())
	list1 = [int(x) for x in input().split()]
	print(math.ceil(sum(list1) / n))
	T = T - 1


import math
n = int(input())
for i in range(n):
	l = int(input())
	a = list(map(int, input().split()))
	sum = 0
	total = 0
	for i in range(len(a)):
		sum += a[i]
	total = math.ceil(sum / l)
	print(total)


import math
t = int(input())
for i in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	arrsum = sum(arr) / n
	print(math.ceil(arrsum))


import math
q = int(input())
for i in range(q):
	n = int(input())
	A = [x for x in map(int, input().split())]
	print(math.ceil(sum(A) / n))


from math import ceil

def main():
	for _ in range(int(input())):
		s = int(input())
		a = sum([int(i) for i in input().split()])
		print(ceil(a / s))
main()


q = int(input())
for i in range(q):
	n = int(input())
	a = [int(x) for x in input().split()]
	tot = 0
	for j in range(n):
		tot += a[j]
	print(int(tot / n + 0.999))


x = int(input())
for __ in range(x):
	n = int(input())
	a = list(map(int, input().split()))
	if len(set(a)) == 1:
		print(a[0])
	else:
		b = sum(a) / len(a)
		if b == int(b):
			print(int(b))
		else:
			print(int(b) + 1)


import math
for _ in range(int(input())):
	n = int(input())
	l = [int(x) for x in input().split()]
	print(math.ceil(sum(l) / n))


import math
q = int(input())
while q != 0:
	n = int(input())
	a = []
	a = list(map(int, input().strip().split()))[:n]
	sum = 0
	for i in range(0, n):
		sum = sum + a[i]
	print(int(math.ceil(sum / n)))
	q = q - 1


import math
for _ in range(int(input())):
	n = int(input())
	m = 0
	ls = [int(x) for x in input().split()]
	m = math.ceil(sum(ls) / n)
	print(m)


from collections import defaultdict as dd
from collections import deque
import bisect
import heapq

def ri():
	return int(input())

def rl():
	return list(map(int, input().split()))
q = ri()
for _ in range(q):
	n = ri()
	a = rl()
	ans = sum(a) // n
	if ans < sum(a) / n:
		ans += 1
	print(ans)


from sys import stdin
from math import ceil
input = stdin.readline
for _ in range(int(input())):
	n = int(input())
	print(ceil(sum(sorted(list(map(int, input().split())))) / n))


import math
T = int(input())
for _ in range(T):
	N = int(input())
	sums = sum(map(int, input().split()))
	print(math.ceil(sums / N))


def store(s):
	l = len(s)
	su = sum(s)
	if su % l == 0:
		return su // l
	else:
		return su // l + 1
q = input()
q = int(q)
while q:
	n = input()
	s = list(map(int, input().split()))
	print(store(s))
	q -= 1


t = int(input())
while t:
	t -= 1
	n = int(input())
	ar = list(map(int, input().split()))
	if sum(ar) % n == 0:
		print(sum(ar) // n)
	else:
		print(sum(ar) // n + 1)


ls = []
for _ in range(int(input())):
	(n, gs) = (int(input()), list(map(int, input().split())))
	r = sum(gs) // n
	ls.append(r if sum(gs) % n == 0 else r + 1)
for x in ls:
	print(x)


import math
q = int(input())
for i in range(q):
	n = int(input())
	prices = input()
	prices_list = map(lambda x: int(x), prices.split(' '))
	avg = math.ceil(sum(prices_list) / n)
	print(avg)


q = int(input())
for z in range(q):
	n = int(input())
	a = input().split()
	s = 0
	for w in a:
		s += int(w)
	if s % n == 0:
		print(s // n)
	else:
		print(s // n + 1)


rinta = lambda : list(map(int, input().split()))
rint = lambda : int(input())
q = rint()
for k in range(q):
	n = rint()
	a = rinta()
	s = int(sum(a))
	print((s + n - 1) // n)


t = int(input())
while t > 0:
	t -= 1
	n = int(input())
	a = [int(i) for i in input().split()]
	s = sum(a)
	x = n
	while s % x != 0:
		s += 1
	ans = s // x
	print(ans)


import math
tcase = eval(input())
for i in range(0, tcase):
	n = eval(input())
	sum = 0
	for t in input().split(' '):
		sum = sum + int(t)
	print(math.ceil(sum / n))


from math import ceil
queries = int(input())
for i in range(queries):
	number_of_goods = int(input())
	goods_prices = [int(x) for x in input().split()]
	sum_of_prices = sum(goods_prices)
	new_price = ceil(sum_of_prices / number_of_goods)
	print(new_price)


q = int(input())
for i in range(q):
	n = int(input())
	a = [int(x) for x in input().split()]
	total = sum(a)
	if total % n == 0:
		print(total // n)
	else:
		print(total // n + 1)


tc = int(input())
import math
for ts in range(tc):
	n = int(input())
	li = list(map(int, input().split()))
	avg = math.ceil(sum(li) / len(li))
	print(avg)


from math import *
R = lambda : list(map(int, input().split()))
q = R()[0]
for i1 in range(q):
	n = R()[0]
	s = R()
	print(ceil(sum(s) / n))


import math
q = int(input())
for qu in range(q):
	n = int(input())
	a = list(map(int, input().split()))
	print(math.ceil(sum(a) / len(a)))


import math
for _ in range(int(input())):
	n = int(input())
	a = [int(i) for i in input().split()]
	s = 0
	for i in a:
		s += i
	print(math.ceil(s / n))


q = int(input())
for _ in range(q):
	n = int(input())
	l = list(map(int, input().split()))
	if sum(l) % n == 0:
		print(sum(l) // n)
	else:
		print(sum(l) // n + 1)


for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	s = sum(l)
	if s % n == 0:
		print(s // n)
	else:
		print((s + (n - s % n)) // n)


import math
t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	s = sum(a)
	avg = s / len(a)
	print(math.ceil(avg))


for _ in range(int(input())):
	(n, sm) = (int(input()), sum(map(int, input().split())))
	print(int(sm / n) + bool(sm % n))


import math

def solve():
	n = int(input())
	ar = list(map(int, input().split()))
	s = sum(ar)
	ans = math.ceil(s / n)
	print(ans)
t = int(input())
while t > 0:
	solve()
	t -= 1


import math
for _ in range(int(input())):
	m = int(input())
	a = list(map(int, input().split()))
	x = sum(a)
	x = x / len(a)
	x = math.ceil(x)
	a = []
	print(x)


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


q = int(input())
while q > 0:
	q -= 1
	n = int(input())
	a = [int(i) for i in input().split(' ')]
	s = sum(a)
	print(s // n + (s % n > 0))


_ = int(input())
for i in range(_):
	n = int(input())
	sum = 0
	v = [int(x) for x in input().split()]
	for j in range(n):
		sum += v[j]
	if sum % n == 0:
		print(sum // n)
	else:
		print(sum // n + 1)


q = int(input())
N = [0] * q
A = [0] * q
for i in range(q):
	N[i] = int(input())
	A[i] = input().split(' ')
for i in range(q):
	s = sum((int(A[i][j]) for j in range(N[i])))
	prm = s // N[i]
	if s % N[i]:
		print(prm + 1)
	else:
		print(prm)


from sys import stdin
input = lambda : stdin.readline()
ii = lambda : int(input())
mi = lambda : map(int, input().split())
li = lambda : list(map(int, input().split()))
from math import *
for _ in range(ii()):
	n = ii()
	l = li()
	s = sum(l)
	print(ceil(s / n))


T = int(input())
while T > 0:
	n = int(input())
	ans = 0
	a = list(map(int, input().split()))
	for i in range(0, n):
		ans += a[i]
	if ans % n == 0:
		ans /= n
	else:
		ans = ans / n + 1
	ans = int(ans)
	print(ans)
	T -= 1


import math
n = int(input())
for _ in range(n):
	y = int(input())
	x = [int(p) for p in input().split(' ')]
	print(math.ceil(sum(x) / y))


import math
t = int(input())
for i in range(0, t):
	j = int(input())
	s = list(map(int, input().split()))
	p = math.ceil(sum(s) / j)
	print(p)


import math
p = input()
n = int(p)
for i in range(0, n, 1):
	import array
	arr1 = array.array('l', [])
	arr2 = array.array('l', [])
	p = input()
	n2 = int(p)
	arr1 = [int(j) for j in input().split()]
	s = 0
	for j in range(0, n2, 1):
		s = s + arr1[j]
	c = math.ceil(s / n2)
	print(c)


def main():
	for _ in range(int(input())):
		n = int(input())
		x = list(map(int, input().split()))
		s = sum(x)
		if s % n == 0:
			ans = s // n
		else:
			ans = s // n + 1
		print(ans)
main()


import math
t = int(input())
for i in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	print(math.ceil(sum(a) / len(a)))


import time
import math
LOCAL = False
start_time = None
if LOCAL:
	start_time = time.time()
q = int(input())
while q:
	q -= 1
	n = int(input())
	poses = list(map(lambda x: int(x), input().split(' ')))
	s = sum(poses)
	print(math.ceil(s / n))
if LOCAL:
	print('--- %s seconds ---' % (time.time() - start_time))


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


import math

def solve(a):
	return math.ceil(sum(a) / len(a))
q = int(input())
for _ in range(q):
	input()
	a = list(map(int, input().split()))
	print(solve(a))


q = int(input())
for i in range(q):
	n = int(input())
	prices = list(map(int, input().split()))
	s = sum(prices)
	print(s // n + (s % n > 0))


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


from sys import stdin, stdout
import math
q = int(stdin.readline())
for i in range(q):
	n = int(stdin.readline())
	arr = [int(x) for x in stdin.readline().split()]
	sumi = sum(arr)
	ans = math.ceil(sumi / n)
	stdout.write(str(ans) + '\n')


from math import ceil as x
for _ in ' ' * int(input()):
	a = int(input())
	print(x(sum(map(int, input().split())) / a))


q = int(input())
for i in range(q):
	n = int(input())
	s = sum(map(int, input().split()))
	if s % n != 0:
		print(s // n + 1)
	else:
		print(s // n)


from math import ceil
q = int(input())
for j in range(q):
	n = int(input())
	b = [int(i) for i in input().split()]
	print(ceil(sum(b) / n))


def main():
	from math import ceil
	q = int(input())
	for query in range(q):
		N = int(input())
		A = [int(i) for i in input().split()]
		print(ceil(sum(A) / len(A)))
main()


q = int(input())
while q > 0:
	t = int(input())
	tablica = list(map(int, input().split()))
	suma = sum(tablica)
	if suma % t != 0:
		temp = t - suma % t
		suma += temp
	print(suma // t)
	q -= 1


import math
for _ in range(int(input())):
	n = int(input())
	arr = list((int(i) for i in input().split()))
	print(math.ceil(sum(arr) / n))


import math
t = int(input())
while t != 0:
	t = t - 1
	n = int(input())
	l = list(map(int, input().split()))
	k = sum(l)
	res = math.ceil(k / n)
	print(res)


import functools
q = int(input())
for i in range(q):
	n = int(input())
	l = list(map(int, input().split()))
	s = functools.reduce(lambda x, y: x + y, l)
	if s % n == 0:
		print(int(s / n))
	else:
		print(int(s / n) + 1)


q = int(input())
for i in range(q):
	n = int(input())
	a = list(map(int, input().split()))
	sum_ = 0
	for i in a:
		sum_ += i
	ans = (sum_ + len(a) - 1) // len(a)
	print(ans)


import math
q = int(input())
for _ in range(q):
	n = int(input())
	arr = list(map(int, input().split()))
	avg = sum(arr) / n
	avg = math.ceil(avg)
	print(avg)


l = []
for i in range(int(input())):
	n = int(input())
	l.append((sum(list(map(int, input().split()))) + n - 1) // n)
print(*l, sep='\n')


import math
q = int(input())
while q:
	n = int(input())
	res = 0
	li = [int(i) for i in input().split()]
	for i in range(0, len(li)):
		res = res + li[i]
	p = res / len(li)
	print(math.ceil(p))
	q = q - 1


from math import ceil
q = int(input())
for i in range(q):
	n = int(input())
	good = list(map(int, input().split()))
	minimum_value = ceil(sum(good) / n)
	print(minimum_value)


from math import ceil
t = int(input())
while t:
	n = int(input())
	s = sum([int(x) for x in input().split()])
	print(ceil(s / n))
	t -= 1


import math
elem = int(input())
for x in range(elem):
	elem2 = int(input())
	ar = []
	for x in input().split(' '):
		ar.append(int(x))
	print(math.ceil(sum(ar) / elem2))


def sol(a, b):
	if a > b:
		return 1
	return 0
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	m = sum(a) // n
	print(m + sol(sum(a), m * n))


for i in range(int(input())):
	n = int(input())
	s = sum([int(s) for s in input().split()])
	print((s + n - 1) // n)


q = int(input())
n = []
a = []
for i in range(q):
	n.append(int(input()))
	a.append([int(x) for x in input().split()])
for i in range(q):
	sum_of_prices = sum(a[i])
	avg_price = int((sum_of_prices + n[i] - 1) / n[i])
	ans = avg_price
	print(ans)


x = int(input())
import math
a = []
b = []
for i in range(x):
	y = int(input())
	z = sum(list(map(int, input().split())))
	a.append(y)
	b.append(z)
for i in range(x):
	print(math.ceil(b[i] / a[i]))


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


t = int(input())
while t:
	x = int(input())
	y = input()
	lis = [int(n) for n in y.split()]
	s = sum(lis)
	a = x - s % x
	if a != x:
		print((s + a) // x)
	else:
		print(s // x)
	t -= 1


import math
q = int(input())
while q:
	a = int(input())
	al = [int(x) for x in input().split()]
	result = math.ceil(sum(al) / a)
	print(result)
	q -= 1


for q in range(int(input())):
	n = int(input())
	A = list(map(int, input().split()))
	S = sum(A)
	ans = S / n
	if ans % 1 != 0:
		ans = int(ans) + 1
	print(int(ans))


q = int(input())
for j in range(0, q):
	n = int(input())
	a = list(map(int, input().split()))
	l = sum(a) // n
	if sum(a) % n != 0:
		l += 1
	print(l)


from math import ceil
q = int(input())
for _ in range(0, q):
	n = int(input())
	str = input()
	tokens = str.split(' ')
	sum = 0
	for token in tokens:
		a = int(token)
		sum += a
	print(ceil(sum / n))


q = int(input())
while q > 0:
	n = int(input())
	l = [int(x) for x in input().split()]
	y = sum(l)
	if y % n == 0:
		print(y // n)
	else:
		print(y // n + 1)
	q -= 1


def solve(a, n):
	s = sum(a)
	if s % n == 0:
		return int(s / n)
	else:
		return int(s / n) + 1
t = int(input())
for i in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	print(solve(a, n))


q = int(input())
for i in range(q):
	n = int(input())
	p = sorted(list(map(int, input().split(' '))))
	s = sum(p)
	m = s // n + 1
	while m * n > s:
		m -= 1
	if m * n < s:
		print(m + 1)
	else:
		print(m)


import math

def maximumPrice(arr):
	return math.ceil(sum(arr) / len(arr))
for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	print(maximumPrice(arr))


x = int(input())
l2 = []
for i in range(x):
	y = int(input())
	l1 = [int(a) for a in input().split()]
	c1 = 0
	for k in range(y):
		c1 += l1[k]
	if c1 % y == 0:
		l2.append(int(c1 / y))
	else:
		l2.append(int(c1 / y) + 1)
for k in range(x):
	print(l2[k])


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	z = sum(a)
	c = z / n
	if sum(a) <= n * round(c):
		print(round(c))
	else:
		print(round(c) + 1)


import math
ans = []
q = int(input())
for i in range(q):
	p = int(input())
	s = sum(list(map(int, input().strip().split())))
	ans.append(math.ceil(s / float(p)))
for a in ans:
	print(a)


for _ in range(int(input())):
	s = int(input())
	coins = list(map(int, input().split()))
	total_price = sum(coins)
	res = int(total_price // s)
	if res * s == total_price:
		print(res)
	else:
		while True:
			if (res + 1) * s >= total_price:
				print(res + 1)
				break
			else:
				res += 1


t = int(input())
s = []
for jgg in range(0, t):
	n = int(input())
	x = input()
	xx = x.split()
	g = 0
	for i in xx:
		g += int(i)
	h = int(g // n)
	if g % n != 0:
		h += 1
	s.append(h)
for i in s:
	print(i)


for i in range(int(input())):
	n = int(input())
	a = map(int, input().split())
	print((sum(a) + n - 1) // n)


testes = int(input())
for t in range(testes):
	num = int(input())
	itens = input().split(' ')
	soma = 0
	for k in itens:
		soma += int(k)
	media = soma // num
	if media * num == soma:
		print(media)
	else:
		print(media + 1)


import sys
import os
from io import IOBase, BytesIO

def main():
	from math import ceil
	for tc in range(int(input())):
		n = int(input())
		arr = get_array()
		total = sum(arr)
		x = ceil(total / n)
		print(x)
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		py2 = round(0.5)
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2 == 1:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			self.write = lambda s: self.buffer.write(s.encode('ascii'))
			self.read = lambda : self.buffer.read().decode('ascii')
			self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def get_array():
	return list(map(int, sys.stdin.readline().split()))

def get_ints():
	return map(int, sys.stdin.readline().split())

def input():
	return sys.stdin.readline().strip()
main()


t = int(input())
import math
while t > 0:
	n = int(int(input()))
	x = [int(x) for x in input().split()]
	s = sum(x)
	ans = math.ceil(s / n)
	t -= 1
	print(ans)


from math import ceil
for _ in range(int(input())):
	input()
	sp = list(map(int, input().split()))
	print(ceil(sum(sp) / len(sp)))


q = int(input())
import math
for _ in range(q):
	n = int(input())
	a = list(map(int, input().split()))
	s = sum(a)
	q1 = math.ceil(s / n)
	print(q1)


import math
q = int(input())
for i in range(q):
	n = int(input())
	a = list(map(int, input().split()))
	s = 0
	for i in a:
		s += i
	ans = math.ceil(s / n)
	print(ans)


n = int(input())
for i in range(n):
	s = 0
	x = int(input())
	l = list(map(int, input().split()))
	for j in range(len(l)):
		s = s + l[j]
	if s % x == 0:
		print(s // x)
	else:
		print(s // x + 1)


import math
q = int(input())
for i in range(q):
	n = int(input())
	a = [int(x) for x in input().split(' ')]
	total = sum(a)
	amount = total / n
	print(math.ceil(amount))


import math

def run():
	n = eval(input())
	vals = []
	for _ in range(n):
		input()
		vals.append(list(map(int, input().split())))
	for arr in vals:
		print(math.ceil(sum(arr) / len(arr)))
run()


nLoops = int(input())

def ceil(n):
	if int(n) < n:
		return int(n) + 1
	return int(n)
for _ in range(nLoops):
	nItems = int(input())
	sumPrices = sum([int(i) for i in input().split()])
	print(ceil(sumPrices / nItems))


q = int(input())
for i in range(q):
	n = int(input())
	x = list(map(int, input().split()))
	av = sum(x) // n
	if sum(x) % n != 0:
		av += 1
	print(av)


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	s = sum(a)
	a.sort()
	print(s // n + (int(s % n) > 0))


for t in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	sum = 0
	for k in a:
		sum += k
	i = 0
	while True:
		if (sum + i) % n == 0:
			print((sum + i) // n)
			break
		else:
			i += 1


for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	print((sum(l) + n - 1) // n)


t = int(input())
while t:
	n = int(input())
	li = [int(i) for i in input().split()]
	s = sum(li)
	if s % n == 0:
		print(s // n)
	else:
		print(s // n + 1)
	t -= 1


Answers = []
for i in range(int(input())):
	customers = int(input())
	prices = map(int, input().split())
	s = sum(prices)
	if s % customers == 0:
		Answers.append(s // customers)
	else:
		while s % customers != 0:
			s += 1
		Answers.append(s // customers)
for i in Answers:
	print(i)


t = int(input())
while t:
	n = int(input())
	l = list(map(int, input().split()))
	req = sum(l)
	if req % n == 0:
		print(req // n)
	else:
		print(req // n + 1)
	t = t - 1


def f():
	n = int(input())
	l = list(map(int, list(input().split())))
	if n == 0:
		return 0
	else:
		x = round(sum(l) / n)
		if x * n >= sum(l):
			return x
		else:
			return x + 1
n = int(input())
re = []
for i in range(0, n):
	re.append(f())
for i in re:
	print(i)


V = []
for _ in range(int(input())):
	l = int(input())
	q = sum(map(int, input().split()))
	V.append(-(-q // l))
print(*V, sep='\n')


t = int(input())
for i in range(t):
	n = int(input())
	ar = [int(x) for x in input().split()]
	s = sum(ar)
	if s % n == 0:
		ans = s // n
	else:
		ans = s // n + 1
	print(ans)


import math
n = int(input())
for i in range(n):
	k = int(input())
	a = [int(i) for i in input().split()]
	print(math.ceil(sum(a) / k))


n = int(input())
for i in range(n):
	m = input()
	s = input().split()
	l = 0
	for j in range(len(s)):
		l += int(s[j])
	print((l - 1) // len(s) + 1)


import math
for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	x = len(l)
	sume = sum(l)
	print(int(math.ceil(sume / x)))


import sys

def rint():
	return map(int, sys.stdin.readline().split())
q = int(input())
for _ in range(q):
	n = int(input())
	a = list(rint())
	s = sum(a)
	m = s // n
	r = s % n
	if r:
		m += 1
	print(m)


(q, ans) = (int(input()), [])
for i in range(q):
	n = int(input())
	l = list(map(int, input().split()))
	ans.append(int(sum(l) / n + 0.99999999))
for i in range(q):
	print(ans[i])


q = int(input())
for i in range(q):
	n = int(input())
	g = [int(j) for j in input().split()]
	g.sort()
	ans = sum(g)
	if ans % n == 0:
		print(int(ans / n))
	else:
		p = int(ans / n)
		print(p + 1)


for y in range(int(input())):
	a = int(input())
	temp = input().split(' ')
	num = []
	for y in range(len(temp)):
		num.append(int(temp[y]))
	u = sum(num)
	k = len(num)
	if u % k == 0:
		print(int(u / k))
	else:
		print(int(u / k + 1))


import math
q = int(input())
for i in range(q):
	n = int(input())
	preco = [int(x) for x in input().split(' ')]
	soma = sum(preco)
	print(math.ceil(soma / len(preco)))


q = int(input())
for i in range(q):
	n = int(input())
	a = list(map(int, input().split()))
	s = sum(a)
	t = s // n
	if t * n < s:
		t += 1
	print(t)


import math
Q = int(input())
for q in range(Q):
	N = int(input())
	A = list(map(int, input().split()))
	S = sum(A)
	ans = math.ceil(S / N)
	print(ans)


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


from math import ceil
q = int(input())
for _q in range(q):
	n = int(input())
	a = [int(x) for x in input().split()]
	print(ceil(sum(a) / len(a)))


queries = int(input())
for q in range(queries):
	n_objects = int(input())
	prices = list(map(int, input().split()))
	big_money = sum(prices)
	if big_money // n_objects * n_objects >= big_money:
		print(big_money // n_objects)
	else:
		print(big_money // n_objects + 1)


import sys
import math
for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	s = sum(l)
	ans = s // n
	if s % n:
		ans += 1
	print(ans)


from math import ceil
q = int(input())
for _ in range(q):
	n = int(input())
	price = ceil(sum(map(int, input().split())) / n)
	print(price)


from sys import setcheckinterval, stdin, setrecursionlimit
setcheckinterval(1000)
setrecursionlimit(10 ** 7)

def iin():
	return int(stdin.readline())

def lin():
	return list(map(int, stdin.readline().split()))
for _ in range(iin()):
	n = iin()
	a = lin()
	sm = sum(a)
	print((sm + n - 1) // n)


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


n = int(input())
for _ in range(n):
	k = int(input())
	s = sum(map(int, input().split()))
	print(s // k + bool(s % k))


from math import ceil
q = int(input())
for i in range(q):
	n = int(input())
	A = [int(i) for i in input().split()]
	print(ceil(sum(A) / n))


t = int(input())
while t != 0:
	n = int(input())
	l = [int(x) for x in input().split()]
	x = sum(l)
	print((x + n - 1) // n)
	t -= 1


q = int(input())
for _ in range(q):
	n = int(input())
	prices = [int(i) for i in input().split()]
	result = sum(prices) // len(prices) if sum(prices) % len(prices) == 0 else sum(prices) // len(prices) + 1
	print(result)


def string_splitter(s, a):
	output_list = []
	intermediate_str = ''
	for i in range(len(s)):
		if s[i] != a:
			intermediate_str += s[i]
			if i == len(s) - 1:
				output_list.append(int(intermediate_str))
		elif intermediate_str:
			output_list.append(int(intermediate_str))
			intermediate_str = ''
	return output_list

def joiner(l, a):
	output_str = ''
	for loc in range(len(l)):
		if not loc == len(l) - 1:
			output_str += l[loc] + a
	output_str += l[-1]
	return output_str

def sum_up_list(l):
	sum = 0
	for i in l:
		sum += i
	return sum

def book_shelf():
	a = input()
	output_list = []
	for i in range(int(a)):
		b = input()
		c = input()
		b = int(b)
		c = string_splitter(c, ' ')
		sumof = sum_up_list(c)
		if not sumof % len(c):
			price = sumof // len(c)
		else:
			remainder = sumof % len(c)
			price = (sumof + (len(c) - remainder)) // len(c)
		output_list.append(price)
	for j in output_list:
		print(j)
book_shelf()


t = int(input())
for i in range(0, t):
	n = int(input())
	sum = 0
	a = list(map(int, input().split()))
	for j in range(0, n):
		sum = sum + a[j]
	if sum % n == 0:
		ans = sum // n
	else:
		ans = sum // n + 1
	print(ans)


q = int(input())
for i in range(q):
	n = int(input())
	arr = [int(elem) for elem in input().split()]
	if sum(arr) // n == sum(arr) / n:
		print(sum(arr) // n)
	else:
		print(sum(arr) // n + 1)


t = int(input())
while t > 0:
	t -= 1
	n = int(input())
	s = input()
	v = s.split()
	for i in range(0, n):
		v[i] = int(v[i])
	usu = sum(v)
	usu2 = usu // n
	if usu2 * n != usu:
		usu2 += 1
	print(str(usu2))


import math
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	sum = 0
	for i in a:
		sum += i
	x = sum / len(a)
	print(math.ceil(x))


import math
t = int(input())
for i in range(t):
	sum1 = 0
	n = int(input())
	s = input().split()
	for x in s:
		f = int(x)
		sum1 += f
	y = sum1 / n
	print(math.ceil(y))


for _ in range(int(input())):
	n = int(input())
	summ = sum(map(int, input().split()))
	print(summ // n + (summ % n != 0))


from math import *

def equalize(l):
	return ceil(sum(l) / len(l))

def io():
	q = int(input())
	for i in range(q):
		n = int(input())
		l = list(map(int, input().split()))
		print(equalize(l))
io()


import math
tc = int(input())
while tc > 0:
	size = int(input())
	l = list(map(int, input().split()))
	print(math.ceil(sum(l) / size))
	tc -= 1


innum = int(input())
total = 0
for i in range(innum):
	n = int(input())
	x = input().split()
	total = sum([int(j) for j in x])
	fin = int(total / n)
	if total % n == 0:
		print(fin)
	else:
		print(fin + 1)


from math import ceil

def solve():
	n = int(input())
	l = list(map(int, input().split()))
	sum = 0
	for i in l:
		sum += i
	print(ceil(sum / n))
n = int(input())
for i in range(n):
	solve()


t = int(input())
while t > 0:
	t -= 1
	n = int(input())
	l = list(map(int, input().split()))
	print((sum(l) + n - 1) // n)


n = int(input())
for i in range(0, n):
	k = 0
	x = int(input())
	l = [int(a) for a in input().split()]
	for j in range(0, x):
		k = k + l[j]
	if k % x == 0:
		g = k / x
	else:
		g = k // x + 1
	print(int(g))


t = int(input())
while t > 0:
	n = int(input())
	a = [int(i) for i in input().split()]
	b = sum(a)
	print(b // n + 1 if b % n > 0 else b // n)
	t = t - 1


import math
a = int(input())
TempSum = 0
for i in range(a):
	q = int(input())
	n = [int(i) for i in input().split()]
	for j in range(len(n)):
		TempSum += n[j]
	print(math.ceil(TempSum / q))
	n = []
	TempSum = 0


test_cases = int(input())
for i in range(test_cases):
	items = int(input())
	costs = list(map(int, input().split(' ')))
	min_price = sum(costs) // items
	if sum(costs) % items == 0:
		print(min_price)
	else:
		print(min_price + 1)


import math
for _ in range(int(input())):
	n = int(input())
	lis = list(map(int, input().split()))
	s = math.ceil(sum(lis) / n)
	print(s)


n = int(input())
for i in range(n):
	k = int(input())
	s = [int(i) for i in input().split()]
	summ = 0
	for j in range(k):
		summ += s[j]
	z = summ // k
	while z * k < summ:
		z += 1
	print(z)


for i in range(int(input())):
	m = int(input())
	n = list(map(int, input().split()))
	if sum(n) % len(n) == 0:
		print(sum(n) // len(n))
	else:
		print(sum(n) // len(n) + 1)


import sys
input = sys.stdin.readline
q = int(input())
for testcases in range(q):
	n = int(input())
	A = list(map(int, input().split()))
	print(-(-sum(A) // n))


def binarySearch(alist, item):
	first = 0
	last = alist
	while last - first > 1:
		midpoint = (first + last) // 2
		if midpoint * n >= item:
			last = midpoint
		else:
			first = midpoint
	return last
q = int(input())
for _ in range(q):
	n = int(input())
	a = [int(x) for x in input().split()]
	s = sum(a)
	ans = binarySearch(max(a), s)
	if (ans - 1) * n >= s:
		print(ans - 1)
	else:
		print(ans)


import math
T = int(input())
for t_case in range(T):
	n = int(input())
	arr = list(map(int, input().split()))
	ans = math.ceil(sum(arr) / n)
	print(ans)


import sys
input = sys.stdin.readline

def getInt():
	return int(input())

def getVars():
	return map(int, input().split())

def getList():
	return list(map(int, input().split()))

def getStr():
	return input().strip()

def addDictList(d, key, val):
	if key not in d:
		d[key] = []
	d[key].append(val)

def addDictInt(d, key, val):
	if key not in d:
		d[key] = 0
	d[key] = val

def addDictCount(d, key):
	if key not in d:
		d[key] = 0
	d[key] += 1

def addDictSum(d, key, val):
	if key not in d:
		d[key] = 0
	d[key] += val
t = getInt()
for i in range(t):
	n = getInt()
	a = getList()
	s = sum(a)
	if s % n == 0:
		print(s // n)
	else:
		print(s // n + 1)


t = int(input())

def fon(s, n):
	if sum(s) // n * n < sum(s):
		return sum(s) // n + 1
	else:
		return sum(s) // n
for i in range(t):
	n = int(input())
	s = [int(i) for i in input().split()]
	print(fon(s, n))


N = int(input())
for i in range(1, N + 1):
	n = int(input())
	L = list(map(int, input().split()))
	if float(sum(L) / n) > int(sum(L) / n):
		print(int(sum(L) / n) + 1)
	else:
		print(int(sum(L) / n))


for t in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	s = sum(a)
	f = float(s) / n
	if f == int(f):
		print(int(f))
	else:
		print(int(f) + 1)


q = int(input())
for i in range(q):
	n = int(input())
	arr = list(map(int, input().split()))
	sum = 0
	for k in arr:
		sum += k
	res = sum // len(arr)
	if res * len(arr) < sum:
		res += 1
	print(res)


from fractions import gcd
from math import ceil

def N():
	return int(input())

def NK():
	return map(int, input().split())

def LS():
	return [int(x) for x in input().split()]

def main():
	q = N()
	for _ in range(q):
		n = N()
		ls = LS()
		print(ceil(sum(ls) / n))
main()


N = int(input())
for i in range(N):
	n = int(input())
	a = input()
	a = [int(j) for j in a.split(' ')]
	x = sum(a) / n
	if x - int(x) != 0:
		print(int(x + 1))
	else:
		print(int(x))


from statistics import mean
import math
for _ in range(int(input())):
	n = int(input())
	p = list(map(int, str.split(input())))
	x = mean(p)
	print(math.ceil(x))


def main(n, a):
	index = 0
	sum = 0
	while index < n:
		sum = sum + a[index]
		index = index + 1
	c = int(sum / n)
	if sum % n != 0:
		c = c + 1
	return c
q = int(input())
for q_itr in range(q):
	n = int(input())
	a = list(map(int, input().rstrip().split()))
	res = main(n, a)
	print(res)


import math
for i in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	s = sum(a) / n
	s = int(s)
	if s * n == sum(a):
		print(s)
	else:
		print(s + 1)


Q = int(input())
for q in range(Q):
	n = int(input())
	arr = list(map(int, input().split()))
	ans = sum(arr) / len(arr)
	if ans == int(ans):
		print(int(ans))
	else:
		print(int(ans + 1))


import sys
import math
CASE = 1
rla = ''

def solve():
	n = int(input())
	li = [int(i) for i in input().split()]
	print(sum(li) // n + int(sum(li) % n != 0))
while True:
	rla = sys.stdin.readline()
	cases = 1
	if not rla:
		break
	if (rla == '\n') | (rla == ''):
		continue
	if CASE == 1:
		cases = int(rla)
	for cas in range(cases):
		solve()


I = input
for _ in [0] * int(I()):
	n = int(I())
	print(0 - -sum(map(int, I().split())) // n)


import math
for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	s = sum(l)
	av = math.ceil(s / n)
	print(av)


Q = int(input())
data = []
for _ in range(Q):
	N = int(input())
	A = list(map(int, input().split()))
	data.append((N, A))
for (N, A) in data:
	S = sum(A)
	ans = S // N
	if S % N != 0:
		ans += 1
	print(ans)


from statistics import mean
from math import ceil
q = int(input())
for _ in range(q):
	input()
	arr = map(int, input().split())
	print(ceil(mean(arr)))


n = int(input())
ans_ind = [0 for i in range(110)]
for i in range(n):
	m = int(input())
	tl = list(map(int, input().split()))
	min_summ = sum(tl)
	ans_ind[i] = min_summ // m
	if ans_ind[i] * m < min_summ:
		ans_ind[i] += 1
for i in range(n):
	print(ans_ind[i])


def equalize(q):
	ans = []
	while q > 0:
		n = int(input())
		a = list(map(int, input().split()))
		sumi = sum(a)
		a.sort()
		first = a[0]
		while True:
			if first * n >= sumi:
				ans.append(first)
				break
			first += 1
		q -= 1
	return ans
q = int(input())
ans = equalize(q)
for j in ans:
	print(j)


for q in range(int(input())):
	n = int(input())
	a = sum([int(x) for x in input().split()])
	k = a // n
	if a % n != 0:
		k += 1
	print(k)


from math import ceil
q = int(input())
for i in range(q):
	n = int(input())
	s1 = sum(map(int, input().split()))
	res = ceil(s1 / n)
	print(res)


from bisect import *
from collections import *
from itertools import *
import functools
import sys
import math
from decimal import *
from copy import *
from heapq import *
getcontext().prec = 30
MAX = sys.maxsize
MAXN = 1000010
MOD = 10 ** 9 + 7
spf = [i for i in range(MAXN)]

def sieve():
	for i in range(2, MAXN, 2):
		spf[i] = 2
	for i in range(3, int(MAXN ** 0.5) + 1):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i

def fib(n, m):
	if n == 0:
		return [0, 1]
	else:
		(a, b) = fib(n // 2)
		c = a % m * (b % m * 2 - a % m) % m
		d = a % m * (a % m) % m + b % m * b % m % m
		if n % 2 == 0:
			return [c, d]
		else:
			return [d, c + d]

def charIN(x=' '):
	return sys.stdin.readline().strip().split(x)

def arrIN(x=' '):
	return list(map(int, sys.stdin.readline().strip().split(x)))

def ncr(n, r):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % MOD
		den = den * (i + 1) % MOD
	return num * pow(den, MOD - 2, MOD) % MOD

def flush():
	return sys.stdout.flush()
for _ in range(int(input())):
	n = int(input())
	a = arrIN()
	s = sum(a)
	x = (s + n - 1) // n
	print(x)


from math import *
from copy import *
from string import *
from sys import stdin
from sys import maxsize
from operator import *
from itertools import *
from collections import Counter
T = int(input())
for _ in range(T):
	N = int(stdin.readline())
	l = list(map(int, stdin.readline().rstrip().split()))
	k = sum(l)
	ans = ceil(k / N)
	print(ans)


from math import ceil
n = int(input())
l = []
for i in range(n):
	k = int(input())
	lis = [int(k) for k in input().split(' ')]
	l.append(ceil(sum(lis) / len(lis)))
print('\n'.join((str(k) for k in l)))


import math
t = int(input())

def fun(n, a):
	s = 0
	for i in range(n):
		s += a[i]
	ans = math.ceil(s / n)
	print(int(ans))
while t:
	t -= 1
	n = int(input())
	a = [int(i) for i in input().split()]
	fun(n, a)


import math

def pieces(arr):
	val = sum(arr) / len(arr)
	return math.ceil(val)
q = int(input())
for i in range(q):
	n = int(input())
	ar = list(map(int, input().rstrip().split()))
	print(pieces(ar))


q = int(input())
for _ in range(q):
	n = int(input())
	l = list(map(int, input().split()))
	summ = sum(l)
	ans = -(-summ // n)
	print(ans)


import math
countRequest = int(input())
countProduct = int(input())
prices = []
middlePrices = []
price = ''
summ = 0
for i in range(countRequest):
	price = input().split()
	for j in range(len(price)):
		summ = summ + int(price[j])
	middlePrice = summ / countProduct
	summ = 0
	middlePrices.append(math.ceil(middlePrice))
	if i < countRequest - 1:
		countProduct = int(input())
for i in middlePrices:
	print(i)


for _ in range(int(input())):
	n = int(input())
	A = list(map(int, input().split()))
	s = sum(A)
	avg = s // n
	while avg * n < s:
		avg += 1
	print(avg)


import sys
import itertools
import math
import collections
from collections import Counter

def pow(x, y, mod):
	r = 1
	x = x % mod
	while y > 0:
		if y & 1:
			r = r * x % mod
		y = y >> 1
		x = x * x % mod
	return r

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 1
	prime[0] = prime[1] = False
	r = [p for p in range(n + 1) if prime[p]]
	return r

def divs(n, start=1):
	r = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				r.append(i)
			else:
				r.extend([i, n // i])
	return r

def cdiv(n, k):
	return n // k + (n % k != 0)

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))

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

def prr(a, sep=' '):
	print(sep.join(map(str, a)))

def dd():
	return collections.defaultdict(int)
q = ii()
for _ in range(q):
	n = ii()
	d = li()
	t = cdiv(sum(d), n)
	print(t)


import math
cases = int(input())
for k in range(cases):
	bens = int(input())
	bens_l = input().split()
	soma = 0
	for k in bens_l:
		soma += int(k)
	print(math.ceil(soma / len(bens_l)))


from math import ceil
q = int(input())
while q:
	n = int(input())
	a = [int(x) for x in input().split()]
	print(ceil(sum(a) / n))
	q -= 1


t = int(input())
for t in range(t):
	p = int(input())
	lst = list(map(int, input().split()))
	q = sum(lst)
	if q % p == 0:
		q /= p
	else:
		q //= p
		q += 1
	print(int(q))


from math import ceil
q = int(input())
output = []
for i in range(q):
	n = int(input())
	nums = list(map(int, input().split()))
	sum = 0
	for num in nums:
		sum += num
	sum = ceil(float(sum) / n)
	output.append(sum)
for num in output:
	print(num)


q = int(input())
res = list()
for i in range(0, q):
	n = int(input())
	total = sum([int(x) for x in input().split()])
	avg = total // n
	if total % n > 0:
		avg = avg + 1
	res.append(avg)
for r in res:
	print(r)


a = int(input())
for _ in range(a):
	n = 0
	x = int(input())
	y = input()
	m = y.split()
	for b in m:
		n = n + int(b)
	if n % x == 0:
		print(int(n / x))
	else:
		print(n // x + 1)


import math
q = int(input())
an = []
for i in range(0, q):
	n = int(input())
	b = [None] * n
	b = list(map(int, input().split()))
	s = 0
	for j in range(0, n):
		s += b[j]
	ans = math.ceil(s / n)
	an.append(ans)
for r in range(0, q):
	print(an[r])


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


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	s = sum(a)
	m = s
	flag = True
	while True:
		x = m // n
		if x * n >= s:
			print(x)
			flag = False
			break
		else:
			m += 1


import math
q = int(input())
for i in range(q):
	n = int(input())
	prices = list(map(int, input().split()))
	totPrice = sum(prices)
	print(int(math.ceil(totPrice / n)))


def solve(n, ar):
	summ = sum(ar)
	lenn = len(ar)
	if summ % lenn == 0:
		print(summ // lenn)
	else:
		print(summ // lenn + 1)
t = int(input())
for _ in range(t):
	n = int(input())
	ar = list(map(int, input().split()))
	solve(n, ar)


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	ans = sum(a) // n
	if ans < sum(a) / n:
		ans += 1
	print(ans)


import sys
import math
input = sys.stdin.readline
t = 1
t = int(input())
for _ in range(t):
	n = int(input())
	a = [int(x) for x in input().split()]
	s = sum(a)
	print(int(math.ceil(s / n)))


q = int(input())
ss = []
for i in range(q):
	n = int(input())
	s = map(int, input().split())
	s = list(s)
	x = sum(s) / n
	ss.append(x)
import math
for i in range(len(ss)):
	print(math.ceil(ss[i]))


q = int(input())
while q > 0:
	n = int(input())
	a = [int(x) for x in input().split()]
	x = sum(a)
	if x % len(a) == 0:
		print(x // len(a))
	else:
		print(x // len(a) + 1)
	q -= 1


import math
q = int(input())
for i in range(q):
	n = int(input())
	lst1 = list(map(int, input().split()))
	len1 = len(lst1)
	sum1 = sum(lst1)
	print(math.ceil(sum1 / len1))


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


q = int(input())
for i in range(q):
	lenn = int(input())
	li = list(map(int, input().split()))
	if sum(li) % lenn != 0:
		print(sum(li) // lenn + 1)
	else:
		print(sum(li) // lenn)


from math import ceil
tests = int(input())
while tests > 0:
	amountOfGoods = int(input())
	goods = [int(i) for i in input().split(' ')]
	print(ceil(sum(goods) / amountOfGoods))
	tests = tests - 1


n = int(input().split()[0])
for i in range(n):
	x = int(input().split()[0])
	a = [int(j) for j in input().split()]
	ans = 0
	for c in a:
		ans += c
	if ans % len(a) == 0:
		print(int(ans / len(a)))
	else:
		print(int(ans / len(a)) + 1)


import math

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


input = __import__('sys').stdin.readline
print = __import__('sys').stdout.write
for i in range(int(input())):
	num = int(input())
	k = list(map(int, input().split()))
	su = sum(k)
	if su % num == 0:
		print(str(su // num) + '\n')
	else:
		print(str(su // num + 1) + '\n')


import math as m

def rep(n, contents):
	answers = []
	for i in range(len(n)):
		temp = 0
		for p in range(n[i]):
			temp += contents[i][p]
		answers.append(m.ceil(temp / n[i]))
	return answers
q = int(input())
n = []
contents = list()
for r in range(q):
	temp = []
	n.append(int(input()))
	contents.insert(r, list(map(int, input().split())))
a = rep(n, contents)
for i in range(len(a)):
	print(a[i])


from collections import Counter
from collections import deque
for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	to = sum(l) // n + 1 if sum(l) / n > sum(l) // n else sum(l) // n
	print(to)


def mean(arr):
	avg = sum(arr) / len(arr)
	if avg > round(avg):
		return round(avg) + 1
	return round(avg)
q = int(input())
arr = []
for i in range(q):
	n = int(input())
	a = list(map(int, input().split()))
	arr.append(mean(a))
for i in range(q):
	print(arr[i])


q = int(input())
while q > 0:
	n = int(input())
	a = list(map(int, input().rstrip().split()))
	s = sum(a)
	if s % len(a) != 0:
		s = s / len(a)
		k = int(s) + 1
	else:
		s = s / len(a)
		k = int(s)
	print(k)
	q -= 1


for _ in range(int(input())):
	q = int(input())
	l1 = [int(__) for __ in input().split()]
	if sum(l1) % q == 0:
		print(sum(l1) // q)
	else:
		print(1 + sum(l1) // q)


q = int(input())
for i in range(q):
	n = int(input())
	a = map(int, input().split())
	suma = sum(a)
	if suma % n == 0:
		print(int(suma / n))
	else:
		print(suma // n + 1)


a = int(input())
for i in range(a):
	b = int(input())
	l = list(map(int, input().split()))
	print((sum(l) + b - 1) // b)


from math import ceil
q = int(input())
for i in range(q):
	n = int(input())
	entrada = list(map(int, input().split()))
	soma = 0
	for nums in entrada:
		soma += nums
	print(ceil(soma / n))


import math
t = int(input())
for _ in range(t):
	n = int(input())
	x = [int(i) for i in input().split()]
	s = sum(x)
	print(math.ceil(s / n))


import math
res = []
for rpt in range(int(input())):
	gcount = int(input())
	prices = [int(x) for x in input().split(' ')]
	ideal = math.ceil(sum(prices) / gcount)
	print(ideal)


def n_price(n, vals):
	t_vals = sum(vals)
	if t_vals % n == 0:
		return int(t_vals / n)
	while True:
		t_vals += 1
		if t_vals % n == 0:
			return int(t_vals / n)
n = int(input())
(g_n, p_n) = (list(), list())
for _ in range(n):
	g_n.append(int(input()))
	p_n.append([int(val) for val in input().split()])
result = list()
for i in range(len(g_n)):
	result.append(n_price(g_n[i], p_n[i]))
for i in result:
	print(i)


import math
num = int(input())
tuplist = []
for x in range(num):
	queries = int(input())
	query = input()
	prices = query.split(' ')
	prices2 = [int(i) for i in prices]
	total = sum(prices2)
	total_thing = total / len(prices2)
	print(math.ceil(total_thing))


import math as m
t = int(input())
while t:
	t = t - 1
	n = int(input())
	a = [int(x) for x in input().split()]
	s = sum(a)
	print(m.ceil(s / n))


import math
t = int(input())
for i in range(1, t + 1):
	n = int(input())
	a = [int(x) for x in input().split()]
	print(math.ceil(math.fsum(a) / n))


for x in range(int(input())):
	len = int(input())
	l = []
	l = list(map(int, input().split()))
	if sum(l) % len == 0:
		res = sum(l) // len
		print(res)
	else:
		res = sum(l) // len + 1
		print(res)


import re, math, decimal, bisect

def read():
	return input().strip()

def iread():
	return int(input().strip())

def viread():
	return [int(_) for _ in input().strip().split()]
for i in range(iread()):
	n = iread()
	cost = sum(viread())
	print(math.ceil(cost / n))


for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	f = sum(arr)
	if f % n == 0:
		print(f // n)
	else:
		print(f // n + 1)


for i in range(int(input())):
	n = int(input())
	L = list(map(int, input().split()))
	s = sum(L)
	if s / n == s // n:
		print(s // n)
	else:
		print(s // n + 1)


import math
for _ in range(int(input())):
	n = int(input())
	A = list(map(int, input().split()))
	sum = 0
	for i in A:
		sum += i
	print(math.ceil(sum / n))


q = int(input())
for i in range(q):
	n = int(input())
	a = list(map(int, input().split()))
	if sum(a) % len(a) == 0:
		x = sum(a) // len(a)
	else:
		x = sum(a) // len(a) + 1
	print(x)


q = int(input())
for m in range(q):
	n = int(input())
	a = list(map(int, input().split()))
	summa = 0
	for i in a:
		summa += i
	if summa % n == 0:
		print(summa // n)
	else:
		print(summa // n + 1)


import math
q = int(input())

def cen():
	for i in range(q):
		n = int(input())
		a = list(map(int, input().split()))
		s = 0
		c = 0
		for j in range(n):
			s += a[j]
			c += 1
		print(math.ceil(s / c))
cen()


import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from heapq import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def value():
	return tuple(map(int, input().split()))

def array():
	return [int(i) for i in input().split()]

def Int():
	return int(input())

def Str():
	return input()

def arrayS():
	return [i for i in input().split()]
for _ in range(Int()):
	n = Int()
	a = array()
	print(ceil(sum(a) / n))


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_int_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_intList_from_str = lambda : list(map(int, list(sys.stdin.readline().strip())))
get_charList_from_str = lambda : list(sys.stdin.readline().strip())
get_char_list = lambda : sys.stdin.readline().strip().split()
get_int = lambda : int(sys.stdin.readline())
pt = lambda x: sys.stdout.write(str(x))
for _ in range(get_int()):
	n = get_int()
	s = sum(get_int_list())
	print(math.ceil(s / n))


import math

def func(arr, n):
	return math.ceil(sum(arr) / n)
T = int(input())
while T > 0:
	n = int(input())
	arr = list(map(int, input().split()))
	print(func(arr, n))
	T -= 1


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().strip().split()))[:n]
	if sum(a) / n == sum(a) // n:
		print(sum(a) // n)
	else:
		print(int(sum(a) / n + 1))


for j in range(int(input())):
	n = int(input())
	an = list(map(int, input().split()))
	t = 0
	for i in an:
		t += i
	if t % n == 0:
		print(int(t / n))
	if t % n != 0:
		print(int(t / n) + 1)


t = int(input())
price = 0
ans = []
for i in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	price = sum(a)
	if price % n != 0:
		price = price // n + 1
	else:
		price = price // n
	ans.append(price)
for i in range(len(ans)):
	print(ans[i])


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


import math
q = int(input())
for i in range(q):
	a = int(input())
	s = sum(map(int, input().split()))
	print(math.ceil(s / a))


import sys
q = int(sys.stdin.readline())
for _ in range(q):
	n = int(sys.stdin.readline())
	a = list(map(int, sys.stdin.readline().split()))
	total = sum(a)
	ans = (total + n - 1) // n
	print(ans)


from sys import stdin
from collections import defaultdict
import math
q = int(stdin.readline().strip())
for _ in range(q):
	n = int(stdin.readline().strip())
	arr = list(map(int, stdin.readline().split()))
	s = sum(arr)
	print(math.ceil(s / n))


import math
for _ in range(int(input())):
	z = input
	x = int(z())
	l = list(map(int, z().split()))
	p = max(l)
	l = sum(l)
	t = math.ceil(l / x)
	if t > p:
		t = p
	print(t)


from bisect import bisect_right as br
import sys
from collections import *
from math import *
import re

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	c = 0
	for i in range(2, n):
		if prime[i]:
			c += 1
	return c

def iseven(n):
	return [False, True][0 if n % 2 else 1]

def inp_arr():
	return list(map(int, input().split()))

def inp():
	return map(int, input().split())

def lcm(a, b):
	return a * b / gcd(a, b)
max_int = sys.maxsize
mod = 10 ** 9 + 7
q = int(input())
while q:
	n = int(input())
	arr = inp_arr()
	print(ceil(sum(arr) / n))
	q -= 1


import math
tc = int(input())
for t in range(tc):
	n = int(input())
	sum = 0
	arr = list(map(int, input().strip().split()))[:n]
	for i in range(n):
		sum += arr[i]
	print(math.ceil(sum / n))


def avarage(x, n):
	s = 0
	for i in x:
		s += i
	return int(s / n + 0.99)
for _ in range(int(input())):
	n = int(input())
	x = list(map(int, input().split()))
	print(avarage(x, n))


from math import ceil
t = int(input())
for i in range(t):
	n = int(input())
	l = [int(x) for x in input().split()]
	print(ceil(sum(l) / n))


import sys
import math
from collections import defaultdict

def rl():
	return sys.stdin.readline().strip()

def rn():
	return list(map(int, sys.stdin.readline().strip().split()))

def rln(n):
	l = [None] * n
	for i in range(n):
		l[i] = int(rl())
	return l
t = int(input())
for _ in range(t):
	n = int(input())
	tab = rn()
	s = sum(tab)
	print(math.ceil(s / n))


import math
import statistics
t = int(input())
for i in range(t):
	n = int(input())
	x = list(map(int, input().split()))
	a = math.ceil(statistics.mean(x))
	print(a)


Q = int(input())
ans = []
for q in range(Q):
	N = int(input())
	a_list = list(map(int, input().split()))
	ans.append((sum(a_list) + N - 1) // N)
for a in ans:
	print(a)


for t in range(int(input())):
	n = int(input())
	a = [int(x) for x in input().rstrip().split()]
	print(0 - -sum(a) // n)


from math import ceil

def solve():
	n = int(input())
	ss = sum([int(i) for i in input().split()])
	print(ceil(ss / n))
t = int(input())
for _ in range(0, t):
	solve()


q = int(input())
while q:
	n = int(input())
	a = [int(n) for n in input().split()]
	s = sum(a)
	if s % n == 0:
		print(s // n)
	else:
		print(s // n + 1)
	q = q - 1


import math
q = int(input())
for i in range(0, q):
	n = int(input())
	l = list(map(int, input().split(' ')))
	s = sum(l)
	r = int(math.ceil(s / n))
	print(r)


import math
t = int(input())
for _ in range(t):
	n = int(input())
	l = map(int, input().strip().split())
	s = sum(l)
	print(math.ceil(s / n))


from math import ceil
for _ in range(int(input())):
	n = int(input())
	tp = sum(map(int, input().split()))
	print(ceil(tp / n))


import math
n = int(input())
a = []
i = 0
while i < n:
	i2 = 0
	q = int(input())
	x = list(map(int, input().split()))
	s = 0
	while i2 < q:
		s += x[i2]
		i2 += 1
	a.append(math.ceil(s / len(x)))
	i += 1
i = 0
while i < len(a):
	print(a[i])
	i += 1


q = int(input())
for queries in range(q):
	nGoods = int(input())
	prices = list(map(int, input().split()))
	soma = sum(prices)
	preco = soma // nGoods
	if preco < soma / nGoods:
		preco += 1
	print(preco)


count = int(input())
answer = []
for _ in range(count):
	num = int(input())
	prices = list(map(lambda num: int(num), input().split()))
	total = sum(prices)
	if total % num == 0:
		new = total // num
	else:
		new = total // num + 1
	answer.append(str(new))
print('\n'.join(answer))


q = int(input())
for j in range(q):
	n = int(input())
	f = list(map(int, input().split()))
	s = 0
	for i in range(n):
		s += f[i]
	sr = s // n
	if sr * n < sum(f):
		sr += 1
	print(sr)


t = int(input())
for i in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	sumi = sum(a)
	k = sumi // n
	l = sumi / n
	if l - k > 0:
		print(k + 1)
	else:
		print(k)


from math import ceil
n = int(input())
for _ in range(n):
	qty = int(input())
	vetor = list(map(int, input().split()))
	media = ceil(sum(vetor) / qty)
	print(media)


n = int(input())
a = []
f = 0
for i in range(n):
	s = int(input())
	f = 0
	l = list(map(int, input().split()))
	for j in range(s):
		f = f + l[j - 1]
	if f % s == 0:
		r = int(f / s)
	else:
		r = int(f / s) + 1
	a.append(r)
for i in range(n):
	print(a[i])


N = int(input())
for i in range(N):
	n = int(input())
	a = list(map(int, input().split()))
	ans = sum(a) / len(a)
	if int(ans) < ans:
		print(int(ans) + 1)
	else:
		print(int(ans))


num_of_q = int(input())
prices = [0 for i in range(0, num_of_q)]
for i in range(0, num_of_q):
	num_of_goods = int(input())
	price = sum(list(map(int, input().split(' ')))) / num_of_goods
	if price != int(price):
		price = int(price) + 1
	prices[i] = int(price)
for price in prices:
	print(price)


from math import ceil
for _ in range(int(input())):
	N = int(input())
	S = sum(list(map(int, input().split())))
	print(int(ceil(S / N)))


import math

def li():
	return list(map(int, input().split()))

def num():
	return map(int, input().split())

def nu():
	return int(input())

def solve():
	q = nu()
	for _ in range(q):
		n = nu()
		l = li()
		su = 0
		for i in l:
			su += i
		print(math.ceil(su / n))
solve()


import math
queries = int(input())
sets = []
user_set = {}
prices = []
for query in range(0, queries):
	n = int(input())
	prices = input()
	prices = [int(price) for price in prices.split()]
	user_set = {'n': n, 'prices': prices}
	sum_user_set = sum(user_set['prices'])
	price = max(user_set['prices'])
	max_price = math.ceil(2 * sum_user_set / user_set['n'])
	min_price = math.ceil(sum_user_set / user_set['n'])
	sum_prices = price * user_set['n']
	print(min_price)


from math import ceil
q = int(input())
for i in range(q):
	input()
	a = [int(i) for i in input().split()]
	print(ceil(sum(a) / len(a)))


import math

def media(lista, tamQ):
	soma = 0
	for e in lista:
		soma += int(e)
	return int(math.ceil(soma / tamQ))
queries = int(input())
for __ in range(queries):
	tamQ = int(input())
	query = input().split()
	print(media(query, tamQ))


def arr_inp():
	return [int(x) for x in input().split()]
from math import *
q = int(input())
for i in range(q):
	(n, a) = (int(input()), arr_inp())
	print(ceil(sum(a) / n))


q = int(input())
while q:
	n = int(input())
	arr = list(map(int, input().split()))
	s = 0
	for i in arr:
		s += i
	if s % n > 0:
		print(s // n + 1)
	else:
		print(s // n)
	q -= 1


t = int(input())
for j in range(t):
	n = int(input())
	a = [int(x) for x in input().split()]
	m = sum(a)
	ans = m // n
	if m % n != 0:
		ans += 1
	print(ans)


import math
n = int(input())
l1 = []
for i in range(n):
	m = int(input())
	x = input().split()
	x = list(map(int, x))
	l1.append(math.ceil(sum(x) / float(len(x))))
for j in range(len(l1)):
	print(int(l1[j]))


for _ in range(int(input())):
	N = int(input())
	K = sum(map(int, input().split()))
	if K % N == 0:
		print(K // N)
	else:
		print(K // N + 1)


q = int(input())
for i in range(q):
	n = int(input())
	a = list(map(int, input().split()))
	summ = sum(a)
	ans = summ // n
	if ans * n < summ:
		print(ans + 1)
	else:
		print(ans)


t = int(input())
for ag in range(t):
	n = int(input())
	a = list(map(int, input().strip().split()))
	s = sum(a)
	s1 = s // n
	if n * s1 == s:
		print(s1)
	else:
		print(s1 + 1)


N = 1001
T = int(input())
x = []
while T > 0:
	T -= 1
	n = int(input())
	a = input().split()
	s = 0
	for i in a:
		s += int(i)
	ans = int(s / n)
	if n * ans != s:
		ans += 1
	print(ans)


from collections import defaultdict as df
import heapq
import bisect
import math
from itertools import combinations, permutations
from collections import deque
q = int(input())
for i in range(q):
	n = int(input())
	a = list(map(int, input().rstrip().split()))
	if sum(a) % n == 0:
		print(sum(a) // n)
	else:
		print(sum(a) // n + 1)


for _ in range(int(input())):
	a = int(input())
	arr = list(map(int, input().split()))
	x = sum(arr)
	if x // a == x / a:
		print(x // a)
	else:
		print(x // a + 1)


q = int(input())
for i in range(q):
	n = int(input())
	prices_sum = sum(list(map(int, input().split())))
	print(prices_sum // n + bool(prices_sum % n))


import math
import sys
import re
for x in range(int(input())):
	n = int(input())
	l = list(map(int, input().rstrip().split()))
	s = int((sum(l) + n - 1) / n)
	print(s)


def main():
	for _ in range(int(input())):
		n = int(input())
		print((sum(map(int, input().split())) + n - 1) // n)
main()


from math import ceil

def main():
	q = int(input())
	for _ in range(q):
		n = int(input())
		a = list(map(int, input().split()))
		s = sum(a)
		print(ceil(s / n))
main()


from math import ceil
q = int(input())
for i in range(q):
	n = int(input())
	tot_price = sum((int(x) for x in input().split()))
	print(ceil(tot_price / n))


import math
t = int(input())
a = []
b = []
for i in range(t):
	n = int(input())
	sum = 0
	a = list(map(int, input().split()))
	for k in range(n):
		sum += a[k]
	b.append(math.ceil(sum / n))
	a.clear()
for i in b:
	print(i, end='\n')


q = int(input())
for _ in range(q):
	n = int(input())
	A = [*map(int, input().split())]
	p = sum(A) // n
	if p * n < sum(A):
		p += 1
	print(p)


import math
for _ in range(int(input())):
	n = int(input())
	ls = list(map(float, input().split()))
	s = sum(ls)
	print(math.ceil(s / n))


import math
q = int(input())
ans = []
for i in range(q):
	no = int(input())
	l = list(map(int, input().split()))
	s = sum(l)
	k = float(s / no)
	ans.append(math.ceil(k))
for e in ans:
	print(e)


t = int(input())
for i in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	target = sum(a)
	print(target // n + int(target % n > 0))


for _ in range(int(input())):
	n = int(input())
	s = sum(map(int, input().split()))
	(q, r) = divmod(s, n)
	print(q + (r > 0))


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


for _ in range(int(input())):
	n = int(input())
	lst = [int(i) for i in input().split()]
	sum1 = sum(lst)
	if sum1 % n == 0:
		print(sum1 // n)
	else:
		print(sum1 // n + 1)


for _ in range(int(input())):
	n = int(input())
	total = sum([int(i) for i in input().split()])
	print(total // n if total % n == 0 else total // n + 1)


def main():
	q = int(input())
	for i in range(q):
		n = int(input())
		a = tuple(map(int, input().split()))
		s = sum(a)
		result = int(s / n) if s % n == 0 else int(s / n) + 1
		print(result)
main()


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	s = sum(a)
	res = -1
	if s % n == 0:
		res = s // n
	else:
		res = s // n + 1
	print(res)


import math

def func():
	ctr = int(input())
	inp_prices = []
	no_of_products = []
	out = []
	while ctr != 0:
		no_of_products.append(input())
		inp_prices.append([input().split()])
		ctr = ctr - 1
	for (x, y) in zip(no_of_products, inp_prices):
		for z in y:
			sum = 0
			for f in z:
				sum = sum + int(f)
			print(math.ceil(sum / int(x)))
func()


MOD = 1000000007
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
from math import *
for _ in range(ii()):
	n = ii()
	l = il()
	print(int(ceil(sum(l) / n)))


from math import ceil
q = int(input())
for i in range(q):
	p = int(input())
	m = list(map(int, input().split()))
	print(ceil(sum(m) / p))


for i in range(int(input())):
	n = int(input())
	(a, b) = (0, 0)
	l = []
	lst = list(map(int, input().split()))
	s = sum(lst)
	r = int(s / n)
	if r * n >= s:
		print(r)
	else:
		print(r + 1)


n = int(input())
while n > 0:
	n -= 1
	s = 0
	k = int(input())
	a = [int(i) for i in input().split()]
	for i in range(k):
		s += a[i]
	print((s + k - 1) // k)


from math import ceil
t = int(input())
while t:
	n = int(input())
	l = list(map(int, input().split()))
	s = sum(l)
	print(ceil(s / n))
	t -= 1


import math
T = int(input())
while T >= 1:
	t = input()
	listr = list(map(int, input().split()))
	print(math.ceil(sum(listr) / len(listr)))
	T -= 1


from sys import *
for i in range(int(input())):
	n = int(stdin.readline())
	A = list(map(int, stdin.readline().split()))
	ini = sum(A)
	if ini % n == 0:
		print(ini // n)
	else:
		print(ini // n + 1)


import math
for _ in range(int(input())):
	n = int(input())
	a = [int(x) for x in input().split()]
	s = sum(a)
	print(math.ceil(s / n))


import sys
sys.setrecursionlimit(10000000)

def input():
	return sys.stdin.readline()[:-1]
from bisect import *
from collections import *
from heapq import *
import itertools
import math
INF = 10 ** 9
MOD = 10 ** 9 + 7
q = int(input())
for i in range(q):
	n = int(input())
	a = [int(x) for x in input().split()]
	print(math.ceil(sum(a) / n))


import statistics
import math
n = int(input())
while n:
	i = int(input())
	a = []
	s = input()
	a = s.split(' ')
	for z in range(len(a)):
		a[z] = int(a[z])
	print(math.ceil(statistics.mean(a)))
	n = n - 1


import math
t = int(input())
i = 0
while i < t:
	goods = int(input())
	prices = list(map(int, input().split(' ')))
	totalPrice = sum(prices)
	newPrice = math.ceil(totalPrice / goods)
	print(int(newPrice))
	i += 1


import math
q = int(input())
for i in range(q):
	n = int(input())
	lst = list(map(int, input().split()))
	total = sum(lst)
	print(math.ceil(total / n))


import math

def EqualizePricesAgain(l):
	sum_ = 0
	for i in l:
		sum_ += int(i)
	if int(math.ceil(sum_ / len(l))) * len(l) < sum_:
		print(sum)
	else:
		print(math.ceil(sum_ / len(l)))
n = int(input())
for i in range(0, n):
	n_ = input()
	l = list(map(str, input().rstrip().split()))
	EqualizePricesAgain(l)


from statistics import mean
from math import ceil

def solve(l):
	return ceil(mean(l))
problems = int(input())
for i in range(problems):
	input()
	print(solve([int(i) for i in input().split(' ')]))


import math
for i in range(int(input())):
	n = int(input())
	arr = list(map(int, input().strip().split()))
	s = sum(arr)
	print(math.ceil(s / n))


from math import *
t = int(input().strip())
for i in range(t):
	q = int(input().strip())
	a = [int(x) for x in input().strip().split(' ')]
	print(ceil(sum(a) / q))


import math
t = int(input())
for j in range(t):
	n = int(input())
	sum = 0
	temp = input()
	temp = temp.split()
	for i in temp:
		sum += int(i)
	if sum / n != sum // n:
		print(sum // n + 1)
	else:
		print(sum // n)


import math
for i in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	sum = 0
	for j in a:
		sum += j
	print(math.ceil(sum / n))


def solve(test):
	n = int(input())
	a = list(map(int, input().split()))
	ans = (sum(a) + n - 1) // n
	print(ans)
t = int(input())
for _ in range(t):
	solve(_ + 1)


import math
Q = int(input())
for q in range(Q):
	n = int(input())
	l = input().split()
	l = [int(x) for x in l]
	sum_ = math.ceil(sum(l) / n)
	print(sum_)


import random

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

def lcm(a, b):
	return a * b / gcd(a, b)
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	k = sum(a)
	if k / n == k // n:
		print(k // n)
	else:
		print(k // n + 1)


import math
t = input()
t = int(t)
for tt in range(0, t):
	n = input()
	n = int(n)
	arr = input().split()
	total = 0
	for (b, c) in enumerate(arr):
		arr[b] = int(c)
		total += int(c)
	print(math.ceil(total / n))


import math
q = int(input())
answers = []
for i in range(q):
	a = int(input())
	vals = list(map(int, input().split()))
	mean = 0
	for val in vals:
		mean += val
	mean = math.ceil(mean / len(vals))
	answers.append(mean)
for answer in answers:
	print(answer)


import math
import statistics
for _ in range(int(input())):
	n = int(input())
	li = list(map(int, input().split()))
	mean = statistics.mean(li)
	print(math.ceil(mean))


for i in range(int(input())):
	x = int(input())
	l = list(map(int, input().split()))
	print(int((sum(l) + x - 1) / x))


import math
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	mean = sum(a) / n
	print(int(math.ceil(mean)))


for _ in range(int(input())):
	n = int(input())
	c = list(map(int, input().split(' ')))
	l = len(c)
	s = sum(c)
	while s % l != 0:
		s += 1
	print(s // l)


import math
test = int(input())
while test > 0:
	n = int(input())
	list_of_input = list(map(int, input().split()))
	total = 0
	for _ in list_of_input:
		total += _
	avg = math.ceil(total / n)
	print(avg)
	test = test - 1


def bin_search():
	l = -1
	r = 1000000000
	while r - l > 1:
		m = (l + r) // 2
		if check(m):
			r = m
		else:
			l = m
	return r

def check(b):
	if b * len(a) >= sum(a):
		return True
	else:
		return False
q = int(input())
for i in range(q):
	n = int(input())
	a = list(map(int, input().split()))
	print(bin_search())


for i in range(int(input())):
	N = int(input())
	A = list(map(int, input().split()))
	i = 0
	average = sum(A) // N
	while average * N < sum(A):
		average += 1
	print(average)


from sys import stdin
import math
t = int(stdin.readline())
while t:
	n = int(stdin.readline())
	a = list(map(int, stdin.readline().split()))
	k = math.ceil(sum(a) / n)
	print(k)
	t -= 1


import math
x = int(input())
lst = []
for i in range(0, x):
	n = int(input())
	m = list(map(int, input().split()))
	lst.append(math.ceil(sum(m) / len(m)))
print(*lst, sep='\n')


import math

def main():
	t = int(input())
	for i in range(t):
		n = int(input())
		arr = map(int, input().split())
		print(math.ceil(sum(arr) / n))
main()


import sys

def b_search(n, org):
	low = 1
	high = pow(10, 7) + 1
	while low < high:
		mid = low + (high - low) // 2
		if mid * n >= org:
			high = mid
		else:
			low = mid + 1
	return low
q = int(sys.stdin.readline())
ans_arr = []
for i in range(q):
	n = int(sys.stdin.readline())
	a = [int(j) for j in sys.stdin.readline().split()]
	org = sum(a)
	ans = b_search(n, org)
	ans_arr.append(str(ans))
print('\n'.join(ans_arr))


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


from math import ceil
queries = int(input())
result = []
for i in range(queries):
	items = int(input())
	totalPrice = 0
	priceList = input().split(' ')
	priceList = [int(i) for i in priceList]
	for j in priceList:
		totalPrice += j
	result.append(ceil(totalPrice / len(priceList)))
for i in result:
	print(i)


cases = int(input())
for _ in range(cases):
	n = int(input())
	l = [int(i) for i in input().split(' ')]
	s = sum(l) / n
	if s == int(s):
		print(int(s))
	else:
		print(int(s) + 1)


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


for _ in range(int(input())):
	n = int(input())
	a = [*map(int, input().split())]
	s = sum(a)
	print((s + n - 1) // n)


import math
for _ in range(int(input())):
	n = int(input())
	arr = [int(x) for x in input().split()]
	val = math.ceil(sum(arr) / n)
	print(val)


import math
q = int(input())
while q:
	q -= 1
	n = int(input())
	l = list(map(int, input().split()))
	print(math.ceil(sum(l) / n))


import math

def calculatePrice(priceInput: str, goodsNum: int) -> int:
	priceList = priceInput.split()
	priceSum = 0
	for price in priceList:
		priceSum = priceSum + float(price)
	averagePrice = priceSum / goodsNum
	return math.ceil(averagePrice)

def main():
	queries = int(input())
	answerList = []
	for i in range(queries):
		goodsNum = int(input())
		goodsPrice = input()
		goodPrice = calculatePrice(goodsPrice, goodsNum)
		answerList.append(goodPrice)
	for answer in answerList:
		print(answer)
main()


import math
q = int(input())
result = [0] * q
for i in range(q):
	n = int(input())
	a = list(map(int, input().split(' ')))
	count = 0
	for j in range(n):
		count += a[j]
	print(math.ceil(count / n))


t = int(input())
from math import ceil
for i in range(t):
	a = int(input())
	b = [int(s) for s in input().split()]
	ss = ceil(sum(b) / len(b))
	print(ss)


t = int(input())
for i in range(t):
	n = int(input())
	prices = list(map(int, input().split(' ')))
	sum_prices = 0
	for i in prices:
		sum_prices += i
	temp_prices = sum_prices // n
	if temp_prices * n >= sum_prices:
		print(temp_prices)
	else:
		print(temp_prices + 1)


from statistics import mean
from math import ceil
t = int(input())
for i in range(0, t):
	n = int(input())
	l = list(map(int, input().split()))
	print(int(ceil(mean(l))))


n = int(input())
for i in range(n):
	num = int(input())
	a = list(map(int, input().split()))
	s = sum(a) // num
	if s * num < sum(a):
		s += 1
	print(s)


from sys import stdin, stdout
import math
queries = int(stdin.readline())
for i in range(queries):
	items = int(stdin.readline())
	prices = [int(x) for x in stdin.readline().strip('\n').split()]
	sum = 0
	for price in prices:
		sum += price
	average = math.ceil(sum / items)
	stdout.write(str(average))
	stdout.write('\n')


t = int(input())
import math
for i in range(t):
	n = int(input())
	a = list(map(int, input().strip().split()))[:n]
	result = sum(a)
	result2 = sum(a) / n
	if result % float(n) == 0:
		print(result // n)
	elif result % float(n) != 0:
		print(math.ceil(result2))


for i in range(int(input())):
	a = int(input())
	b = list(map(int, input().split()))
	s = sum(b)
	m = len(b)
	if s % m == 0:
		print(s // m)
	else:
		print(s // m + 1)


import math
q = int(input())
for i in range(q):
	n = int(input())
	A = list(map(int, input().split()))
	s = sum(A)
	print(int(math.ceil(s / n)))


import math, itertools, fractions, heapq, collections, bisect, sys, queue, copy
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def LS():
	return sys.stdin.readline().split()

def S():
	return input()

def main():
	n = I()
	ans = []
	for _ in range(n):
		k = I()
		l = LI()
		sm = sum(l)
		ans.append((sm + k - 1) // k)
	for x in ans:
		print(x)
main()


for _ in range(int(input())):
	n = int(input())
	a = [*map(int, input().split())]
	ans = sum(a)
	if ans % n == 0:
		a = ans // n
	else:
		a = ans // n + 1
	print(a)


import math
q = int(input())
for i in range(q):
	su = 0
	n = int(input())
	l = list(map(int, input().split()))
	for k in range(n):
		su = su + l[k]
	avg = math.ceil(su / n)
	print(avg)


from math import ceil
for _ in range(int(input())):
	l = float(input())
	print(ceil(sum(map(int, input().split())) / l))


number_of_querries = int(input())
output = []
for querries in range(0, number_of_querries):
	number_of_Items = int(input())
	prices = input().split()
	prices = [int(i) for i in prices]
	real_new_price = int(sum(prices) / number_of_Items)
	new_price = sum(prices) / number_of_Items
	if new_price > real_new_price:
		real_new_price = real_new_price + 1
	output.append(real_new_price)
for querries in range(0, number_of_querries):
	print(output[querries])


q = int(input())
for fwefe in range(q):
	n = int(input())
	l = list(map(int, input().split()))
	s = sum(l)
	if n == 1:
		print(s)
	else:
		print((s + n - 1) // n)


q = int(input())
inn = []
ins = []
for i in range(q):
	inn.append(int(input()))
	s = input()
	s = s.strip()
	ins.append(s.split())
for i in range(q):
	sum = 0
	for j in range(inn[i]):
		sum += int(ins[i][j])
	if sum % inn[i] == 0:
		print(sum // inn[i])
	else:
		print(sum // inn[i] + 1)


from math import ceil
q = int(input())
l = []
for i in range(q):
	n = int(input())
	li = list(map(int, input().split()))
	l.append(ceil(sum(li) / len(li)))
print(*l, sep='\n')


for i in range(int(input())):
	a = int(input())
	li = list(map(int, input().split()))
	print(-(-sum(li) // a))


for i in range(int(input())):
	q = int(input())
	suma = sum(list(map(int, input().split())))
	print((suma - 1) // q + 1)


import math

def avarage(*args):
	a = list(*args)
	s = 0
	for i in a:
		s += i
	return math.ceil(s / len(a))
t = int(input())
for i in range(0, t):
	input()
	args = map(int, input().split())
	print(avarage(args))


from math import ceil
q = int(input())
nsum = 0
a = []
for i in range(q):
	n = int(input())
	a = str(input()).split()
	for i in range(n):
		nsum += int(a[i])
	print(ceil(nsum / n))
	nsum = 0


from math import ceil
t = int(input())
for _ in range(t):
	n = int(input())
	ar = list(map(int, input().split()))
	print(ceil(sum(ar) / n))


t = int(input())
for i in range(t):
	n = int(input())
	l = list(map(int, input().split(' ')))
	s = sum(l)
	print(int((s + n - 1) / n))


foo = []
n = input()
for i in range(int(n)):
	q = input()
	s = 0
	x = input().split()
	for j in x:
		s += int(j)
	if s % int(q) == 0:
		foo.append(s // int(q))
	else:
		foo.append(s // int(q) + 1)
for i in foo:
	print(i)


for i in range(int(input())):
	a = int(input())
	b = list((int(x) for x in input().split()))
	sum = 0
	for j in b:
		sum += j
	if sum % a == 0:
		print(int(sum / a))
	else:
		print(int(sum // a + 1))


import math
entrada = int(input())
for k in range(entrada):
	num = int(input())
	items = input().split(' ')
	soma = 0
	for i in range(num):
		soma += int(items[i])
	soma = soma / num
	print(math.ceil(soma))


import sys, os, io

def rs():
	return sys.stdin.readline().rstrip()

def ri():
	return int(sys.stdin.readline())

def ria():
	return list(map(int, sys.stdin.readline().split()))

def ws(s):
	sys.stdout.write(s + '\n')

def wi(n):
	sys.stdout.write(str(n) + '\n')

def wia(a):
	sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math, datetime, functools
from collections import deque, defaultdict, OrderedDict
import collections

def main():
	starttime = datetime.datetime.now()
	if os.path.exists('input.txt'):
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
	zz = 0
	for _ in range(int(input())):
		zz += 1
		n = int(input())
		a = [int(x) for x in input().split()]
		c = sum(a)
		z = math.ceil(c / n)
		print(z)
	endtime = datetime.datetime.now()
	time = (endtime - starttime).total_seconds() * 1000
	if os.path.exists('input.txt'):
		print('Time:', time, 'ms')

class FastReader(io.IOBase):
	newlines = 0

	def __init__(self, fd, chunk_size=1024 * 8):
		self._fd = fd
		self._chunk_size = chunk_size
		self.buffer = io.BytesIO()

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self, size=-1):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

class FastWriter(io.IOBase):

	def __init__(self, fd):
		self._fd = fd
		self.buffer = io.BytesIO()
		self.write = self.buffer.write

	def flush(self):
		os.write(self._fd, self.buffer.getvalue())
		(self.buffer.truncate(0), self.buffer.seek(0))

class FastStdin(io.IOBase):

	def __init__(self, fd=0):
		self.buffer = FastReader(fd)
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

class FastStdout(io.IOBase):

	def __init__(self, fd=1):
		self.buffer = FastWriter(fd)
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.flush = self.buffer.flush
sys.stdin = FastStdin()
sys.stdout = FastStdout()
main()


import math
q = int(input())
for _ in range(q):
	n = int(input())
	ar = list(map(int, input().split()))
	sum_ = sum(ar)
	print(math.ceil(sum_ / n))


from math import ceil
for x in range(int(input())):
	a = int(input())
	b = sum(list(map(int, input().split())))
	print(ceil(b / a))


t = int(input())
while t:
	t -= 1
	n = int(input())
	ar = [int(i) for i in input().strip().split()]
	s = sum(ar)
	if s % n == 0:
		print(s // n)
	else:
		print(s // n + 1)


import math
k = int(input())
ans = []
for _ in range(k):
	n = int(input())
	arr = list(map(int, input().split()))
	ans.append(math.ceil(sum(arr) / len(arr)))
print(*ans, sep='\n')


y = int(input())
for i in range(y):
	p = int(input())
	x = list(map(int, input().split()))
	t = int(sum(x) // p)
	if t * p < sum(x):
		print(t + 1)
	else:
		print(t)


import math
for _ in range(int(input())):
	n = int(input())
	a = [int(i) for i in input().split()]
	s = sum(a)
	ans = math.ceil(s / n)
	print(ans)


for i in [0] * int(input()):
	a = int(input())
	print(-int(eval(input().replace(' ', '+')) // -a))


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	s = sum(a)
	a.sort()
	if (s / n).is_integer():
		print(s // n)
	else:
		print(s // n + 1)


q = int(input())
for i in range(q):
	n = int(input())
	x = input()
	y = x.split()
	z = [int(d) for d in y]
	if sum(z) % len(z) == 0:
		print(sum(z) // len(z))
	else:
		print(sum(z) // len(z) + 1)


q = int(input())
for i in range(q):
	n = int(input())
	ar = [int(i) for i in input().split()]
	s = sum(ar)
	if int(s / n) == s / n:
		print(int(s / n))
	else:
		print(int(s / n) + 1)


q = int(input())
for i in range(q):
	n = int(input())
	s1 = [int(x) for x in input().split()]
	sum = 0
	for j in range(n):
		sum += s1[j]
	if sum % n == 0:
		print(sum // n)
	else:
		print(sum // n + 1)


import math
test = int(input())
for case in range(test):
	k = int(input())
	price = list(map(int, input().split()))
	sum = 0
	for i in range(k):
		sum += price[i]
	ans = math.floor(sum / k)
	if sum % k:
		ans += 1
	print(ans)


a = int(input())
for i in range(a):
	b = int(input())
	c = [int(_) for _ in input().split()]
	d = 0
	for j in c:
		d += j
	if d % b == 0:
		print(int(d / b))
	else:
		print(int(d / b) + 1)


n = int(input())
for i in range(n):
	q = int(input())
	w = []
	r = 0
	w[0:q] = map(int, input().split())
	if sum(w) % q > 0:
		r = 1
	print(sum(w) // q + r)


import math
q = int(input())
while q != 0:
	q -= 1
	n = int(input())
	a = [int(x) for x in input().split()]
	s = sum(a)
	p = math.ceil(s / n)
	print(p)


q = int(input())
results = []
for i in range(q):
	n = int(input())
	mass = [int(elem) for elem in input().split()]
	k = sum(mass) // len(mass)
	results.append(k if sum(mass) % len(mass) == 0 else k + 1)
for z in results:
	print(z)


import math
n = int(input())
for i in range(n):
	m = int(input())
	a = list(map(int, input().split()))
	summa = sum(a)
	key = math.ceil(summa / len(a))
	print(key)


import sys
input = sys.stdin.readline

def main():
	Q = int(input())
	ans = []
	for _ in range(Q):
		N = int(input())
		A = map(int, input().split())
		new_price = (sum(A) + N - 1) // N
		ans.append(new_price)
	print('\n'.join(map(str, ans)))
main()


from sys import stdin, exit
import math
n = int(stdin.readline())
while n > 0:
	stdin.readline()
	arr = list(map(int, stdin.readline().rstrip().split(' ')))
	s = math.ceil(sum(arr) / len(arr))
	print(s)
	n -= 1


import math

def main():
	n = int(input())
	a = [int(s) for s in input().split()]
	return math.ceil(sum(a) / n)
t = int(input())
for i in range(t):
	print(main())


gheimat = []
q = int(input())
for k in range(q):
	n = int(input())
	jam = 0
	i = []
	i = [int(x) for x in input().split(' ')]
	for j in range(n):
		jam += i[j]
	final = jam // n
	if final * n < jam:
		final += 1
	gheimat.append(final)
for k in range(q):
	print(gheimat[k])


import math

def f():
	n = int(input())
	for _ in range(n):
		size = int(input())
		arr = list(map(int, input().split()))
		sm = sum(arr)
		answer = math.ceil(sm / float(size))
		print(answer)
f()


import math
testcase = int(input())
for case in range(testcase):
	query = int(input())
	price = list(map(int, input().split()))
	result = sum(price) / query
	print(math.ceil(result))


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


import math
t = int(input())
for _ in range(t):
	n = int(input())
	arr = [int(i) for i in input().split()]
	summation = math.ceil(sum(arr) / len(arr))
	print(int(summation))


from math import ceil
q = int(input())
massivesum = []
massivekolvo = []
i = 0
k = 0
for i in range(q):
	n = int(input())
	a = list(map(int, input().split()))
	k = 0
	sum = 0
	for k in range(len(a)):
		sum = sum + a[k]
	massivesum.append(sum)
	massivekolvo.append(n)
i = 0
for i in range(q):
	print(ceil(massivesum[i] / massivekolvo[i]))


for case in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	print((sum(a) + n - 1) // n)


from math import ceil
q = int(input())
for each in range(q):
	n = int(input())
	a = [int(i) for i in input().split()]
	sum_of_initial = sum(a)
	print(ceil(sum_of_initial / n))


import math
for k in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	print(math.ceil(sum(a) / n))


import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline

def solve():
	n = int(input())
	L = list(map(int, input().split()))
	ave = sum(L) / n
	ans = -(-ave // 1)
	print(int(ans))
N = int(input())
for _ in range(N):
	solve()


q = int(input())
for tmp in range(q):
	n = int(input())
	s = list(map(int, input().split()))
	res = sum(s)
	ans = res // n if res % n == 0 else res // n + 1
	print(ans)


from math import ceil
n_sets = int(input())
for i in range(n_sets):
	_ = input()
	a = list(map(int, input().split()))
	print(ceil(sum(a) / len(a)))


from math import ceil
Test = int(input())
for x in range(Test):
	n = int(input())
	a = map(int, input().split())
	print(ceil(sum(a) / n))


import math as th
for _ in range(int(input())):
	n = int(input())
	s = [] + list(map(int, input().split()))
	print(th.ceil(sum(s) / n))


q = int(input())
import math as m
for i in range(q):
	n = int(input())
	price = list((int(x) for x in input().split()))
	sumPrice = 0
	for i in price:
		sumPrice += i
	avg = m.ceil(sumPrice / n)
	print(avg)


import math
q = int(input())
for i in range(q):
	n = int(input())
	arr = [int(k) for k in input().split()]
	sum = 0
	for i in arr:
		sum += i
	print(math.ceil(sum / n))


import math
n = int(input())
for x in range(n):
	k = int(input())
	arr = [] * k
	arr = list(map(int, input().split()))
	tota = 0
	for i in arr:
		tota += i
	tota /= k
	print(math.ceil(tota))


from sys import stdin, stdout
from math import ceil

def solution(t):
	sol_arr = []
	readline = stdin.readline
	for i in range(t):
		n = int(readline())
		arr = map(int, readline().split())
		sol_arr.append(ceil(sum(arr) / n))
	stdout.write('\n'.join(map(str, sol_arr)))

def main():
	t = int(stdin.readline())
	solution(t)
main()


import math
N = int(input())
for i in range(N):
	n = int(input())
	prices = list(map(int, input().split()))
	mean_price = sum(prices) / n
	print(math.ceil(mean_price))


from math import ceil
for i in range(int(input())):
	N = int(input())
	X = list(map(int, input().split()))
	print(ceil(sum(X) / N))


import math
t = int(input())
for _ in range(t):
	n = int(input())
	a = [int(x) for x in input().split()]
	b = sum(a)
	print(math.ceil(b / n))


for i in range(int(input())):
	a = int(input())
	t = list(map(int, input().split()))
	p = sum(t)
	for j in range(p, 100000000000):
		s = j // a
		if s * a >= p:
			print(s)
			break


t = int(input())
for i in range(t):
	num_goods = int(input())
	goods = [int(x) for x in input().split()]
	s = sum(goods)
	ans = s / num_goods
	ans_int = int(ans)
	if ans_int < ans:
		print(int(ans_int + 1))
	else:
		print(int(ans))


q = int(input())
for i in range(q):
	n = int(input())
	k = list(map(int, input().split()))
	j = sum(k) // n
	while sum(k) > j * n:
		j += 1
	else:
		print(j)


import math
from statistics import mean
n = int(input())
result = []
for i in range(n):
	m = int(input())
	a = list(map(int, input().split()))
	result.append(math.ceil(mean(a)))
for i in range(n):
	print(result[i])


import math
q = int(input())
for i in range(q):
	n = int(input())
	vals = list(map(int, input().split()))
	total = 0
	for i in vals:
		total += i
	out = total / n
	out = math.ceil(out)
	print(out)


test = int(input())
for i in range(test):
	a = int(input())
	prices = list(map(int, input().split(' ')))
	sum = 0
	for i in range(len(prices)):
		sum += prices[i]
	min = int(sum / a)
	if min * a >= sum:
		print(min)
	else:
		print(min + 1)


import math
querry = int(input())
for i in range(querry):
	items = int(input())
	prices = list(map(int, input().split()))
	avg = sum(prices) / items
	print(math.ceil(avg))


import sys
input = sys.stdin.readline
for nt in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	s = sum(a)
	print((s - 1) // n + 1)


import math
t = int(input())
a = []
for i in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	a.append(b)
for i in a:
	k = sum(i)
	p = len(i)
	print(math.ceil(k / p))


import array

def imp():
	req = int(input())
	for i in range(req):
		length = int(input())
		prices = array_to_int(input().split(' '))
		suma = sum(prices)
		print(suma // length if suma % length == 0 else suma // length + 1)

def solution():
	req = int(input())
	for i in range(req):
		input

def count_of_one(number):
	result = 0
	while number:
		result += number % 2
		number //= 2
	return result

def rindex(seq, thing):
	for i in range(len(seq) - 1, -1, -1):
		if seq[i] == thing:
			return i

def to_mixed_frac(first, second):
	while True:
		for i in range(2, first + 1):
			if first % i == 0 and second % i == 0:
				first //= i
				second //= i
				break
		else:
			break
	return str(first) + '/' + str(second)

def array_to_int(array):
	for i in range(len(array)):
		array[i] = int(array[i])
	return array

def join0(array):
	result = ''
	for i in array:
		result += str(i)
	return result

def replace(string, new_ch, index):
	new_str = ''
	for i in range(len(string)):
		if i == index:
			new_str += new_ch
		else:
			new_str += string[i]
	return new_str
imp()


def program():
	n = int(input())
	l = list(map(int, input().split()))
	if sum(l) % n == 0:
		print(sum(l) // n)
	else:
		print(sum(l) // n + 1)
t = int(input())
for i in range(t):
	program()


t = int(input())
for _ in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	s = sum(arr)
	if s % n == 0:
		print(s // n)
	else:
		r = s // n
		print(r + 1)


def line():
	return map(int, input().split())

def num():
	return int(input())
from itertools import repeat
from math import ceil
q = num()
for _ in repeat(None, q):
	n = num()
	sa = sum(line())
	print(ceil(sa / n))


def isFloat(number):
	num = int(number)
	return num != number

def average(numberOfItem, costOfItems):
	sum = 0
	for cost in costOfItems:
		sum += int(cost)
	result = sum / numberOfItem
	return result

def round(avg):
	if isFloat(avg):
		avg = int(avg) + 1
	else:
		avg = int(avg)
	return avg
numberOfInput = int(input())
for i in range(numberOfInput):
	numberOfItem = int(input())
	costOfItems = input().split()
	avg = average(numberOfItem, costOfItems)
	result = round(avg)
	print(result)


q = int(input())
b = [0] * q
for g in range(0, q):
	s = 0
	n = int(input())
	a = list(map(int, input().split()))
	for i in range(0, n):
		s = s + a[i]
	b[g] = s * -1 // n
for g in range(0, q):
	print(b[g] * -1)


a = int(input())
input1 = [0] * a
x = 0
for x in range(a):
	b = int(input())
	input2 = [0] * b
	input2 = list(map(int, input().strip().split()))[:b]
	if sum(input2) % b == 0:
		input1[x] = int(sum(input2) / b)
	else:
		input1[x] = int(sum(input2) / b) + 1
for z in range(a):
	print(input1[z])


import math
queries = int(input())
for _ in range(queries):
	n = float(input())
	costs = [int(x) for x in input().split(' ')]
	print(math.ceil(sum(costs) / n))


t = int(input(''))
import math
for v in range(t):
	n = int(input(''))
	a = list(map(int, input('').split(' ')))
	tot = sum(a)
	ans = math.ceil(tot / n)
	print(ans)


q = int(input())
q_list = []
a_list = []
for i in range(q):
	q_list.append(int(input()))
	a_list.append(list(map(int, input().split())))
for i in range(q):
	q = q_list[i]
	a = a_list[i]
	sum = 0
	for j in a:
		sum += j
	if sum % q != 0:
		print(sum // q + 1)
	elif sum % q == 0:
		print(sum // q)


for c in range(int(input())):
	n = int(input())
	a = map(int, input().split())
	tot = sum(a)
	print((tot + n - 1) // n)


from math import ceil
d = []
for i in range(int(input())):
	a = int(input())
	b = [int(n) for n in input().split()]
	c = sum(b)
	d.append(ceil(c / a))
print(*d, sep='\n')


import sys
import math
try:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
except:
	pass

def takeInput():
	return [int(x) for x in input().strip().split()]
t = int(input())
while t != 0:
	t -= 1
	n = int(input())
	a = takeInput()
	ans = math.ceil(sum(a) / n)
	print(int(ans))


import os
import sys
from io import BytesIO, IOBase
from math import ceil

def solution(n, arr):
	write(ceil(sum(arr) / n))

def main():
	for _ in range(r_int()):
		n = r_int()
		arr = r_array()
		solution(n, arr)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def input():
	return sys.stdin.readline().rstrip('\r\n')

def write(*args, end='\n'):
	for x in args:
		sys.stdout.write(str(x) + ' ')
	sys.stdout.write(end)

def r_array():
	return [int(x) for x in input().split()]

def r_int():
	return int(input())

def w_array(arr):
	for x in arr:
		write(x, end=' ')
	write()
main()


import math
q = int(input())
r = []
for i in range(0, q):
	n = int(input())
	a = list(map(int, input().split()))
	k = math.ceil(sum(a) / n)
	r.append(k)
print(*r, sep='\n')


n = int(input())
for _ in range(n):
	_ = input()
	a = list(map(int, input().split(' ')))
	s = sum(a)
	p = s // len(a)
	while p * len(a) < s:
		p += 1
	print(p)


import io, sys, atexit, os
import math as ma
from decimal import Decimal as dec
from itertools import permutations
from itertools import combinations

def li():
	return list(map(int, sys.stdin.readline().split()))

def num():
	return map(int, sys.stdin.readline().split())

def nu():
	return int(input())

def find_gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def lcm(x, y):
	gg = find_gcd(x, y)
	return x * y // gg
mm = 1000000007

def solve():
	t = nu()
	for tt in range(t):
		n = nu()
		a = li()
		s = sum(a)
		print(int(ma.ceil(s / n)))

def __starting_point():
	solve()
__starting_point()


import math
q = int(input())
while q > 0:
	n = int(input())
	a = list(map(int, input().split()))
	s = sum(a)
	y = math.ceil(s / n)
	print(y)
	q = q - 1


q = int(input())
for i in range(q):
	n = int(input())
	a = list(map(int, input().strip().split()))
	price = sum(a) / len(a)
	if int(price) == price:
		print(int(price))
	else:
		print(int(price) + 1)


import math
for t in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	summ = sum(arr)
	print(math.ceil(summ / n))


from math import ceil
q = int(input())
for i in range(q):
	n = int(input())
	suma = 0
	suma = sum(list(map(int, input().split(' '))))
	print(ceil(suma / n))


for _ in range(int(input())):
	n = int(input())
	prices = list(map(int, input().split()))
	total = sum(prices)
	p = total / n
	if p == int(p):
		p = int(p)
	else:
		m = max(prices)
		p = int(p)
		while p < m:
			if p * n > total:
				break
			else:
				p += 1
	print(p)


req = int(input())
for z in range(req):
	amount = int(input())
	price = sum(list(map(int, input().split())))
	print((price - 1) // amount + 1)


n = int(input())
for i in range(n):
	k = int(input())
	sum = 0
	m = [int(m) for m in input().split()]
	for q in range(k):
		sum = sum + m[q]
	if sum % k == 0:
		av = sum // k
	else:
		av = sum // k + 1
	print(av)


import sys, math

def main():

	def input():
		return sys.stdin.readline()[:-1]
	q = int(input())
	for _ in range(q):
		n = int(input())
		a = list(map(int, input().split()))
		print(math.ceil(sum(a) / n))
main()


q = int(input())
for i in range(q):
	n = int(input())
	arr = [int(s) for s in input().split()]
	sum_loc = sum(arr)
	if sum_loc % n == 0:
		print(sum_loc // n)
	else:
		print(sum_loc // n + 1)


import math
test = int(input())
for i in range(test):
	size = int(input())
	lst = [int(x) for x in input().split()]
	print(math.ceil(sum(lst) / size))


from math import ceil

def solve():
	q = int(input())
	for i in range(q):
		n = int(input())
		m = [int(s) for s in input().split()]
		s = ceil(sum(m) / n)
		print(s)
solve()


import math
t = int(input())
answers = []
for ti in range(t):
	n = int(input())
	prices = list(map(int, input().split()))
	aver = math.ceil(sum(prices) / n)
	answers.append(aver)
for a in answers:
	print(a)


import math
import itertools
import collections

def getdict(n):
	d = {}
	if type(n) is list or type(n) is str:
		for i in n:
			if i in d:
				d[i] += 1
			else:
				d[i] = 1
	else:
		for i in range(n):
			t = ii()
			if t in d:
				d[t] += 1
			else:
				d[t] = 1
	return d

def cdiv(n, k):
	return n // k + (n % k != 0)

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))

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

def wr(arr):
	return ''.join(map(str, arr))

def revn(n):
	return int(str(n)[::-1])

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True
q = ii()
for i in range(q):
	n = ii()
	a = li()
	print(math.ceil(sum(a) / n))


for _ in range(int(input())):
	x = int(input())
	print((sum(list(map(int, input().split()))) + x - 1) // x)


import math
lis = []
q = int(input())
for i in range(q):
	n = int(input())
	nums = input().split()
	nu = 0
	for a in nums:
		nu += int(a)
	nu /= n
	nu = math.ceil(nu)
	lis.append(nu)
for i in lis:
	print(i)


n = int(input())
a = []
b = []
for _ in range(n):
	a.append(int(input()))
	b.append(list(map(int, input().split())))
ans = []
import math
for i in range(n):
	ans.append(math.ceil(sum(b[i]) / a[i]))
for i in ans:
	print(i)


t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	soma = sum(a)
	while soma % n != 0:
		soma += 1
	print(soma // n)


q = input()
for i in range(int(q)):
	sum1 = 0
	n = int(input())
	inp = input().split()
	for item in inp:
		sum1 = sum1 + int(item)
	if sum1 % n == 0:
		print(sum1 // n)
	else:
		print((sum1 + n - 1) // n)


querries = int(input())
for querry in range(querries):
	num = input()
	goods = input().split()
	total = 0
	for good in range(len(goods)):
		goods[good] = int(goods[good])
		total = total + goods[good]
	if total % len(goods) == 0:
		print(int(total / len(goods)))
	else:
		while total % len(goods) != 0:
			total = total + 1
		print(int(total / len(goods)))


import math
for q in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	b = sum(a)
	a.sort()
	if b % n == 0:
		print(b // n)
	else:
		print(b // n + 1)


n = int(input())
for i in range(n):
	z = int(input())
	y = list(map(int, input().split()))
	if sum(y) % z == 0:
		print(sum(y) // z)
	else:
		print(sum(y) // z + 1)


from math import *
q = int(input())
for i in range(q):
	w = int(input())
	e = list(map(int, input().split()))
	s = sum(e)
	print(ceil(s / w))


from math import ceil
for i in range(int(input())):
	n = int(input())
	ar = list(map(int, input().split()))
	x = sum(ar)
	if x % len(ar) == 0:
		print(x // len(ar))
	else:
		print(ceil(x / len(ar)))


import math
q = int(input())
for case in range(q):
	n = int(input())
	a = [int(s) for s in input().split(' ')]
	print(int(math.ceil(sum(a) / len(a))))


for t in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	sum = 0
	for k in a:
		sum += k
	print((sum + n - 1) // n)


q = int(input())
while q > 0:
	n = int(input())
	ar = list(map(int, input().strip().split()))
	l = sum(ar) // len(ar)
	while l < sum(ar) / len(ar):
		l += 1
	print(l)
	q -= 1


import math
answer = []
q = int(input())
for i in range(q):
	n = int(input())
	elements = list(map(int, input().split()))
	check = math.ceil(sum(elements) / n)
	answer.append(check)
for element in answer:
	print(element)


import math
q = int(input())
for i in range(q):
	n = int(input())
	a = []
	cen = 0
	a = input().split()
	for elem in a:
		cen += int(elem)
	print(math.ceil(cen / n))


for _ in range(int(input())):
	a = int(input())
	b = list(map(int, input().split()))
	print(sum(b) // a if sum(b) % a == 0 else sum(b) // a + 1)


import math
T = int(input())
for _ in range(T):
	n = int(input())
	arr = [int(i) for i in input().split()]
	summ = sum(arr)
	price = math.floor(summ / n)
	if price * n < summ:
		print(price + 1)
	else:
		print(price)


import math as m
q = int(input())
i = 0
while i < q:
	n = int(input())
	l = list(map(int, input().split()))
	val = m.ceil(sum(l) / len(l))
	print(val)
	i += 1


import math
q = int(input())
for i in range(q):
	n = int(input())
	arr = list(map(int, input().split()))
	sum1 = sum(arr)
	print(math.ceil(sum1 / n))


from math import ceil

def main():
	q = int(input())
	for _ in range(q, 0, -1):
		n = int(input())
		prices = [int(x) for x in input().split()]
		mean = ceil(sum(prices) / n)
		print(mean)
main()


q = int(input())
for _ in range(q):
	n = int(input())
	a = sorted([int(x) for x in input().split()])
	k = sum(a)
	if k % n:
		print(k // n + 1)
	else:
		print(k // n)


from math import gcd, ceil
from collections import defaultdict, deque
from sys import stdin, stdout
from bisect import bisect_left, bisect_right
from copy import deepcopy
inp = lambda : int(stdin.readline())
sip = lambda : stdin.readline()
mulip = lambda : map(int, stdin.readline().split())
lst = lambda : list(map(int, stdin.readline().split()))
slst = lambda : list(sip())
M = pow(10, 9) + 7
for _ in range(inp()):
	n = inp()
	A = lst()
	print(ceil(sum(A) / n))


def calc(suma, n):
	medie = suma // n
	if medie * n < suma:
		return medie + 1
	return medie
q = int(input())
while q > 0:
	q -= 1
	n = int(input())
	x = input()
	lista = x.split()
	suma = 0
	for i in range(0, n):
		suma += int(lista[i])
	print(calc(suma, n))


import math
for i in range(int(input())):
	items = int(input())
	price = list(map(int, input().split()))
	newprice = math.ceil(sum(price) / items)
	print(newprice)


import math
c = int(input())
for i in range(c):
	n = int(input())
	arr = list(map(int, input().split()))
	summ = sum(arr)
	print(math.ceil(summ / n))


u = int(input())
j = []
for i in range(0, u):
	g = int(input())
	f = list(map(int, input().split()))
	d = (sum(f) - 1) // len(f) + 1
	j.append(str(d))
print('\n'.join(j))


from math import *
from sys import *
for i in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	s = sum(l)
	print(ceil(s / n))


import math
t = int(input())
for u in range(0, t):
	n = int(input())
	a = list(map(int, str(input()).split()))
	m = math.ceil(sum(a) / n)
	print(m)


import math
t = int(input())
for i in range(t):
	x = int(input())
	sum = 0
	A = map(int, input().split())
	for j in A:
		sum = sum + j
	print(math.ceil(sum / x))


def ii():
	return int(input())

def fi():
	return float(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	return list(mi())
q = ii()
while q:
	n = ii()
	a = li()
	sum = 0
	for i in range(n):
		sum += a[i]
	x = sum // n
	if x * n < sum:
		x = x + 1
	print(x)
	q -= 1


import math
t = int(input())
for q in range(0, t):
	n = int(input())
	a = [int(i) for i in input().split()]
	s = sum(a)
	print(math.ceil(s / n))


import array
import math
import os
import sys

def main():
	Q = read_int()
	for _ in range(Q):
		N = read_int()
		A = read_ints()
		print(solve(N, A))

def solve(N, A):
	s = sum(A)
	a = s // N
	if a * N < s:
		a += 1
	return a
DEBUG = 'DEBUG' in os.environ

def inp():
	return sys.stdin.readline().rstrip()

def read_int():
	return int(inp())

def read_ints():
	return [int(e) for e in inp().split()]

def dprint(*value, sep=' ', end='\n'):
	if DEBUG:
		print(*value, sep=sep, end=end)
main()


queries = int(input())
for i in range(queries):
	n = int(input())
	items = list(map(int, input().split()))
	average = sum(items) / n
	faverage = sum(items) // n
	if average == faverage:
		print(faverage)
	else:
		print(faverage + 1)


import math
t = int(input())
for i in range(t):
	n = int(input())
	arr = [int(x) for x in input().split()]
	sumarr = sum(arr)
	c = math.ceil(sumarr / n)
	print(c)


t = int(input())
import math
for i in range(0, t, 1):
	sum = 0
	n = int(input())
	m = input().split()
	for k in range(0, n, 1):
		sum = sum + int(m[k])
	num = math.ceil(sum / n)
	print(num)


q = int(input())
out = []
for i in range(q):
	s = 0
	n = int(input())
	na = [int(c) for c in input().split()]
	for j in range(n):
		s = s + na[j]
	if s % n == 0:
		out.append(s // n)
	else:
		out.append(int(s / n) + 1)
for i in range(q):
	print(out[i])


import sys
input = sys.stdin.readline
n = int(input())
for _ in range(n):
	m = int(input())
	a = list(map(int, input().split()))
	k = sum(a)
	if k % m == 0:
		print(k // m)
	else:
		print(k // m + 1)


import math
q = int(input())
while q > 0:
	n = int(input())
	a = list(map(int, input().split()))
	s = 0
	for i in range(len(a)):
		s += a[i]
	print(math.ceil(s / len(a)))
	q -= 1


import math
queries = int(input())
avg_values = []
for i in range(queries):
	amount = int(input())
	avg_values.append(math.ceil(sum(map(lambda x: int(x), input().split(' '))) / amount))
for price in avg_values:
	print(price)


for tc in range(int(input())):
	n = int(input())
	lis = list(map(int, input().split()))
	sum1 = 0
	for i in lis:
		sum1 = sum1 + i
	if sum1 % n == 0:
		print(int(sum1 / n))
	else:
		print(int(sum1 / n + 1))


try:
	t = int(input())
	i = 0
	while i < t:
		n = int(input())
		l = list(map(int, input().split()))
		s = sum(l)
		if s % n == 0:
			print(s // n)
		else:
			p = s % n
			s = s + n - p
			print(s // n)
		i += 1
except:
	pass


for _ in range(int(input())):
	n = int(input())
	seq = sum([int(x) for x in input().split()])
	print(int(seq / n) + (1 if seq % n != 0 else 0))


import math
Q = input()
q = int(Q)
for case in range(q):
	sump = 0
	N = input()
	n = int(N)
	p = input().split()
	for i in range(len(p)):
		p[i] = int(p[i])
		sump = sump + p[i]
	print(math.ceil(sump / n))


import sys
import math
fileoperation = 0
if fileoperation:
	orig_stdout = sys.stdout
	orig_stdin = sys.stdin
	inputfile = open('W:/Competitive Programming/input.txt', 'r')
	outputfile = open('W:/Competitive Programming/output.txt', 'w')
	sys.stdin = inputfile
	sys.stdout = outputfile
mod = 1000000007

def nospace(l):
	ans = ''.join((str(i) for i in l))
	return ans
t = int(input())
for tt in range(t):
	n = int(input())
	a = list(map(int, sys.stdin.readline().split(' ')))
	s = sum(a)
	v = s // n
	if v * n < s:
		v += 1
	print(v)
if fileoperation:
	sys.stdout = orig_stdout
	sys.stdin = orig_stdin
	inputfile.close()
	outputfile.close()


from math import ceil
for t in range(int(input())):
	n = int(input())
	a = [int(x) for x in input().split()]
	z = sum(a)
	print(ceil(z / n))


def shop(A):
	sm = sum(A)
	l = len(A)
	i = 1
	while True:
		p = l * i
		if sm <= p:
			return i
		i += 1
for i in range(int(input())):
	p = int(input())
	A = list(map(int, input().strip().split()))
	print(shop(A))


q = int(input())
for i in range(q):
	n = int(input())
	a = list(map(int, input().strip().split(' ')))
	x = sum(a)
	x1 = x // n
	if x % n:
		x1 += 1
	print(x1)


def sol(n):
	ls = [int(x) for x in input().split()]
	m = math.ceil(sum(ls) / n)
	return m
import math
for _ in range(int(input())):
	n = int(input())
	print(sol(n))


import math

def main():
	n = int(input())
	for _ in range(n):
		num = int(input())
		arr = list(map(int, input().rstrip().split()))
		sum = 0
		for i in arr:
			sum += i
		print(math.ceil(sum / num))
main()


tc = int(input())
for _ in range(tc):
	n = int(input())
	tot = sum(map(int, input().split()))
	if tot % n == 0:
		print(tot // n)
	else:
		print(tot // n + 1)


def mean(numbers):
	return float(sum(numbers)) / max(len(numbers))
q = int(input())
a = []
f = []
for i in range(q):
	n = int(input())
	b = [int(j) for j in input().split()]
	a.append(b)
	f.append(n)
for i in range(q):
	if sum(a[i]) / f[i] == sum(a[i]) // f[i]:
		print(sum(a[i]) // f[i])
	else:
		print(sum(a[i]) // f[i] + 1)


q = int(input())
for i in range(q):
	n = int(input())
	a = input().split()
	k = 0
	for j in range(len(a)):
		k += int(a[j])
	if k % n == 0:
		print(k // n)
	else:
		print(k // n + 1)


for i in range(int(input())):
	n = int(input())
	arr = [int(i) for i in input().split()]
	s = sum(arr)
	t = s // n
	if t * n == s:
		print(t)
	else:
		print(t + 1)


from math import ceil, sqrt, floor
for i in range(int(input())):
	q = int(input())
	print(ceil(sum(list(map(int, input().split()))) / q))


for q in range(int(input())):
	n = int(input())
	s = sum([int(i) for i in input().split()])
	nn = s // n
	if s % n != 0:
		nn += 1
	print(nn)


import math
t = int(input())
while t:
	n = int(input())
	a = [int(x) for x in input().split()]
	c = sum(a)
	print(math.ceil(c / n))
	t = t - 1


q = int(input())
for i in range(q):
	n = int(input())
	S = list(map(int, input().split()))
	print((sum(S) + n - 1) // n)


import math
for case in range(int(input())):
	n = int(input())
	p = input().split()
	sum = 0
	for i in range(n):
		p[i] = int(p[i])
		sum += p[i]
	print(math.ceil(sum / n))


from math import *

def solve(n, l):
	s = sum(l)
	return ceil(s / n)
for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	print(solve(n, l))


queryes = int(input())
for q in range(queryes):
	n = int(input())
	a = list(map(int, input().split()))
	s = sum(a)
	money = s // n
	if s % n > 0:
		money += 1
	print(money)


import math
test = int(input())
while test:
	q = int(input())
	sum = 0
	arr = [int(x) for x in input().split()]
	for i in arr:
		sum += i
	res = math.ceil(sum / q)
	print(res)
	test -= 1


import math

def peq(arr, N):
	total = sum(arr)
	eachprice = int(math.ceil(total / N))
	print(eachprice)
TCs = int(input())
for i in range(TCs):
	N = int(input())
	arr = [int(x) for x in input().split()]
	peq(arr, N)


print('\n'.join(((lambda n, s: str((s + n - 1) // n))(int(input()), sum(map(int, input().split()))) for _ in range(int(input())))))


t = int(input())
for i in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	ans = 0
	for i in arr:
		ans += i
	z = ans // n
	while z * n < ans:
		z += 1
	print(z)


import math
inp = lambda cast=int: [cast(x) for x in input().split()]
printf = lambda s='', *args, **kwargs: print(str(s).format(*args), flush=True, **kwargs)
(t,) = inp()
for _ in range(t):
	(n,) = inp()
	A = inp()
	s = sum(A)
	if s % n == 0:
		print(s // n)
	else:
		print(s // n + 1)


import math
x = []
q = int(input())
for i in range(q):
	n = int(input())
	no = list(map(int, input().split()))
	x.append(math.ceil(sum(no) / n))
for i in x:
	print(i)


q = int(input())
while q > 0:
	q = q - 1
	n = int(input())
	a = [int(x) for x in input().split()]
	s = sum(a)
	ans = s // n
	if s % n != 0:
		ans = ans + 1
	print(ans)


t = int(input())
for j in range(t):
	n = int(input())
	lista = list(map(int, input().split()))
	sum1 = 0
	for i in lista:
		sum1 += i
	if sum1 / n == sum1 // n:
		print(sum1 // n)
	else:
		print(sum1 // n + 1)


from math import ceil
q = int(input())
for _ in range(q):
	n = int(input())
	arr = [int(j) for j in input().split()]
	su = sum(arr)
	print(ceil(su / n))


import math
q = int(input())
while q > 0:
	q -= 1
	n = int(input())
	arr = list(map(int, input().split()))
	total = sum(arr)
	print(math.ceil(total / n))


from math import *
q = int(input())
for i in range(q):
	o = int(input())
	liste = list(map(int, input().split()))
	a = sum(liste)
	print(ceil(a / o))


import math
number_of_queries = int(input())
number_of_items_per_query = []
prices_of_items = []
for i in range(0, number_of_queries):
	number_of_items_per_query.append(int(input()))
	prices_of_items.append(str(input()).split(' '))
for i in range(0, number_of_queries):
	average_price = 0
	for j in range(0, number_of_items_per_query[i]):
		average_price = average_price + int(prices_of_items[i][j])
	print(math.ceil(average_price / number_of_items_per_query[i]))


for _ in range(int(input())):
	n = int(input())
	l = [int(i) for i in input().split()]
	s = sum(l)
	from math import ceil
	print(ceil(s / n))


import math
t = int(input())
k = 0
for i in range(1, t + 1, 1):
	b = int(input())
	l = list(map(int, input().split()))
	print(math.ceil(sum(l) / b))


import math
q = int(input())
for _ in range(q):
	n = int(input())
	a = map(int, input().split())
	print(math.ceil(sum(a) / n))


n = int(input())
for i in range(n):
	a = int(input())
	b = list(map(int, input().split()))
	c = 0
	for x in b:
		c += x
	print(-(-c // a))


def answer():
	n = int(input())
	while n:
		t = int(input())
		s = [int(x) for x in input().split()]
		if sum(s) % len(s):
			av = int(sum(s) / t) + 1
		else:
			av = int(sum(s) / t)
		print(av)
		n -= 1
answer()


q = int(input())
for _ in range(q):
	n = int(input())
	a = list(map(int, input().split()))
	s = 0
	for i in range(n):
		s += a[i]
	print((s + n - 1) // n)


import math
t = int(input())
for i in range(t):
	n = int(input())
	num = list(map(int, input().split()))
	avg = sum(num) / n
	print(math.ceil(avg))


q = int(input())
for _ in range(q):
	n = int(input())
	print((sum(map(int, input().rstrip().split())) + n - 1) // n)


q = int(input())
for case in range(q):
	n = int(input())
	a = list(map(int, input().split()))
	s = sum(a)
	if s / n > s // n:
		print(s // n + 1)
	else:
		print(s // n)


from math import ceil
q = int(input())
for i in range(q):
	n = int(input())
	l = list(map(int, input().split()))
	t = sum(l)
	ans = ceil(t / n)
	print(ans)


q = int(input())
for _ in range(q):
	n = int(input())
	s = sum(list(map(int, input().split())))
	b = int(s // n)
	c = b * n
	if c >= s:
		print(b)
	else:
		print(b + 1)


q = int(input())
for testcase in range(0, q):
	n = int(input())
	a = list(map(int, input().split()))
	sum = 0
	for x in a:
		sum += x
	ans = sum // n
	while ans * n < sum:
		ans += 1
	print(ans)


q = int(input())
result_list = []
for i in range(q):
	n = int(input())
	input_list = input().split()
	for j in range(n):
		input_list[j] = int(input_list[j])
	average = sum(input_list) / n
	result_list.append(int(average))
	if result_list[i] < average:
		result_list[i] += 1
for result in result_list:
	print(result)


from math import ceil
q = int(input())
for i in range(q):
	n = int(input())
	preco = map(int, input().split())
	sum = 0
	for i in preco:
		sum += i
	gaba = ceil(sum / n)
	print(gaba)


import math as m
a = int(input())
for i in range(a):
	b = int(input())
	c = sum(map(int, input().strip().split()))
	print(m.ceil(c / b))


import math
for _ in range(int(input())):
	x = int(input())
	y = list(map(int, input().split()))
	s = math.ceil(sum(y) / x)
	print(s)


t = int(input())
for i in range(t):
	n = int(input())
	a = [int(x) for x in input().split(' ')]
	if sum(a) % n == 0:
		print(sum(a) // n)
	else:
		print(sum(a) // n + 1)


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


n = int(input())
from math import ceil
for i in range(n):
	k = int(input())
	a = list(map(int, input().split()))
	s = sum(a)
	print(ceil(s / k))


def func(n):
	n = list(map(int, n.split()))
	if sum(n) % len(n) == 0:
		return sum(n) // len(n)
	else:
		return sum(n) // len(n) + 1

def main():
	q = int(input())
	q_input = []
	for i in range(q):
		input()
		q_input.append(input())
	for i in list(map(func, q_input)):
		print(i)
main()


for _ in range(int(input())):
	n = int(input())
	Sum = sum(list(map(int, input().split())))
	if Sum % n:
		print(Sum // n + 1)
	else:
		print(Sum // n)


def call():
	N = int(input())
	l = [int(x) for x in input().split()]
	s = sum(l)
	print((s + N - 1) // N)
for _ in range(int(input())):
	call()


import math
q = int(input())
for i in range(q):
	n = int(input())
	a = [int(x) for x in input().split()]
	print(math.ceil(sum(a) / len(a)))


BS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'

def to_base(s, b):
	res = ''
	while s:
		res += BS[s % b]
		s //= b
	return res[::-1] or '0'
from math import ceil
t = int(input())
for i in range(t):
	n = int(input())
	nums = list(map(int, input().split()))
	s = sum(nums)
	print(ceil(s / n))


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


q = int(input())
for i in range(q):
	n = int(input())
	a = sum(map(int, input().split()))
	x = int(a / n)
	while x * n < a:
		x += 1
	else:
		print(x)


def min_tsen(n, A):
	s = 0
	for el in A:
		s += el
	return (s + n - 1) // n
q = int(input())
for i in range(q):
	n = int(input())
	A = list(map(int, input().split()))
	print(min_tsen(n, A))


m = int(input())
for i in range(m):
	k = int(input())
	j = [int(i) for i in input().split()]
	g = round(sum(j) / k)
	if g < sum(j) / k:
		print(int(g + 1))
	else:
		print(int(g))


n = int(input())
for i in range(n):
	k = int(input())
	su = 0
	s = input().split()
	for j in range(len(s)):
		su += int(s[j])
	if float(su / k) > int(su / k):
		print(int(su / k) + 1)
	else:
		print(int(su / k))


num = int(input())
for i in range(num):
	l = int(input())
	vals = [int(x) for x in input().split()]
	thesum = sum(vals)
	if thesum % l == 0:
		print(thesum // l)
	else:
		print(thesum // l + 1)


for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	k = sum(arr) / n
	if k == int(k):
		print(int(k))
	else:
		print(int(k + 1))


t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	add = sum(a)
	print((add + n - 1) // n)


from collections import Counter
q = int(input())
for t in range(q):
	n = int(input())
	l = [int(i) for i in input().split(' ')]
	s = sum(l)
	if s % n == 0:
		print(s // n)
	else:
		print(s // n + 1)


for _ in range(int(input())):
	x = 0
	f = int(input())
	a = list(map(int, input().split()))
	for i in range(0, f):
		x += a[i]
	print((x + f - 1) // f)


q = int(input())
ans = []
for i in range(q):
	n = int(input())
	a = list(map(int, input().split()))
	sum1 = sum(a)
	if sum1 % n == 0:
		ans.append(sum1 // n)
	else:
		ans.append(sum1 // n + 1)
for i in range(q):
	print(ans[i])


from math import ceil
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	s = 0
	for i in a:
		s += i
	s = ceil(s / n)
	print(s)


import math
q = int(input())
ans = []
for i in range(q):
	n = int(input())
	prices = list(map(int, input().split()))
	average = sum(prices) / n
	ans.append(average)
for i in range(q):
	print(math.ceil(ans[i]))


q = int(input())
for query in range(q):
	n = int(input())
	sm = sum(list(map(int, input().split())))
	if sm % n == 0:
		print(sm // n)
	else:
		print(sm // n + 1)


try:
	t = int(input())
	for i in range(t):
		n = int(input())
		l = list(map(int, input().split()))
		x = sum(l)
		if x % len(l) == 0:
			print(x // len(l))
		else:
			print(x // len(l) + 1)
except Exception as e:
	pass


import math
for _ in range(int(input())):
	n = int(input())
	lst = map(int, input().split())
	s = sum(lst)
	print(math.ceil(s / n))


Tks = int(input())
for i in range(Tks):
	n = int(input())
	ar = []
	ar = str(input()).split()
	sum = 0
	for j in range(n):
		sum += int(ar[j])
	print((sum + n - 1) // n)


def min_price(l):
	sum = 0
	ln = len(l)
	for x in l:
		sum = sum + x
	if sum % ln == 0:
		d = int(sum / ln)
	else:
		d = int(sum / ln)
		d = d + 1
	return d
n = int(input())
l = []
for i in range(n):
	p = int(input())
	a = []
	a = [int(x) for x in input().split()]
	d = min_price(a)
	l.append(d)
for x in l:
	print(x)


import math

def equalPriceAg(arr):
	return math.ceil(sum(arr) / len(arr))
tc = int(input())
for i in range(tc):
	n = int(input())
	inp = list(map(int, input().split()))
	print(equalPriceAg(inp))


gi = lambda : list(map(int, input().split()))
for k in range(gi()[0]):
	(n,) = gi()
	l = gi()
	print(sum(l) // n if sum(l) % n == 0 else sum(l) // n + 1)


t = input()
t = int(t)
while t:
	n = input()
	n = int(n)
	l = list(map(int, input().split()))
	l.sort()
	suma = sum(l)
	if suma % n == 0:
		print(int(suma / n))
	else:
		print(int(suma // n + 1))
	t -= 1


import math
q = int(input())
for i in range(q):
	n = int(input())
	p = [int(x) for x in input().split(' ')]
	print(math.ceil(sum(p) / n))


t = int(input())
i = 0
k = 0
a = list()
for i in range(0, t):
	sum = 0
	n = int(input())
	p = list(map(int, input().split()))
	for k in range(0, n):
		sum = sum + p[k]
	np = sum // n
	if np * n == sum:
		a.append(np)
	else:
		a.append(np + 1)
print(*a, sep='\n')


q = int(input())
for j in range(q):
	n = int(input())
	f = list(map(int, input().split()))
	(s, i) = (0, 0)
	for i in range(n):
		s += f[i]
	if s > round(s / n) * n:
		print(round(s / n) + 1)
	else:
		print(round(s / n))


import math
q = int(input())
result = [0] * q
i = 0
while i < q:
	n = int(input())
	a = [0] * n
	a = list(map(int, input().split()))
	print(math.ceil(sum(a) / n))
	i += 1


t = int(input())
for i in range(t):
	n = int(input())
	l = list([int(x) for x in input().split()])
	s = 0
	for j in range(n):
		s += l[j]
	k = s % n
	if k != 0:
		s = s + (n - k)
	s = s / n
	print(int(s))


for i in range(int(input())):
	k = int(input())
	a = list(map(int, input().split()))
	c = sum(a)
	d = c // k
	if c % k == 0:
		print(d)
	else:
		print(d + 1)


import math
q = int(input())
for k in range(q):
	n = int(input())
	summ = 0
	A = list(map(int, input().split()))
	for x in A:
		summ += x
	ans = math.ceil(summ / n)
	print(ans)


def program():
	length = int(input())
	l = list(map(int, input().strip().split()))
	s = sum(l)
	rem = s % length
	if rem == 0:
		return s // length
	else:
		return s // length + 1
case = int(input())
for i in range(case):
	print(program())


q = int(input())
data = []
for w in range(q):
	a = int(input())
	data.append(list(map(int, input().split())))
c = 0
need = []
for i in range(len(data)):
	c = 0
	for j in range(len(data[i])):
		c += data[i][j]
	if c % len(data[i]) == 0:
		need.append(c // len(data[i]))
	else:
		need.append(c // len(data[i]) + 1)
for k in range(len(need)):
	print(need[k])


import math
for i in range(int(input())):
	n = int(input())
	lst = [int(x) for x in input().split()]
	s = sum(lst)
	ans = s / n
	ans = math.ceil(ans)
	ans = int(ans)
	print(ans)


import math
n = int(input())
a = []
for i in range(n):
	k = int(input())
	l = list(map(int, input().split()))
	sum = 0
	for j in range(k):
		sum = sum + l[j]
	new = sum / k
	new = math.ceil(new)
	new = int(new)
	a.append(new)
print(*a, sep='\n')


for _ in range(int(input())):
	n = int(input())
	arr_init = list(map(int, input().split()))
	init_sum = sum(arr_init)
	avg = init_sum // n
	if init_sum % n == 0:
		print(avg)
	else:
		print(avg + 1)


import math
q = int(input())
for i in range(q):
	g = int(input())
	a = []
	a = [int(i) for i in input().split()]
	print(math.ceil(sum(a) / float(len(a))), end='\n')


import math

def calc(n: int, items: list):
	totalPrice: int = sum(items)
	priceAvg: float = totalPrice / n
	return math.ceil(priceAvg)

def main():
	for _ in range(int(input())):
		n: int = int(input())
		items: list = list(map(int, input().split()))
		print(calc(n, items))
main()


t = int(input())
if 1 <= t <= 100:
	for i in range(t):
		b = int(input())
		n = input().split()
		m = list(map(int, n))
		a = sum(m)
		if a % b == 0:
			k = a / b
			k = int(k)
			print(k)
		else:
			k = a // b + 1
			k = int(k)
			print(k)


import math
for q in range(int(input())):
	n = int(input())
	a = [int(i) for i in input().strip().split()]
	s = sum(a)
	print(math.ceil(s / n))


import atexit
import io
import sys
import math
_INPUT_LINES = sys.stdin.read().splitlines()
input = iter(_INPUT_LINES).__next__
_OUTPUT_BUFFER = io.StringIO()
sys.stdout = _OUTPUT_BUFFER

@atexit.register
def write():
	sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().strip().split()))
	s = sum(arr)
	print(math.ceil(s / n))


import math
for q in range(int(input())):
	n = int(input())
	s = sum([int(x) for x in input().split()])
	print(math.ceil(s / n))


import math
n = int(input())
for i in range(n):
	m = int(input())
	mas = list(map(int, input().split()))
	summ = sum(mas)
	print(int((summ + m - 1) / m))


import math
test = int(input())
for i in range(test):
	size = int(input())
	li = list(map(int, input().split()))
	sum1 = 0
	for i in range(len(li)):
		sum1 += li[i]
	a = math.ceil(sum1 / len(li))
	print(a)


mod = 10 ** 9 + 7
from sys import stdin, stdout
import bisect
from bisect import bisect_left as bl
from bisect import bisect_right as br
import itertools
import collections
import math
import heapq
from random import randint as rn

def modinv(n, p):
	return pow(n, p - 2, p)

def ncr(n, r, p):
	t = fact[n] * (ifact[r] * ifact[n - r] % p) % p
	return t

def cin():
	return map(int, sin().split())

def ain():
	return list(map(int, sin().split()))

def sin():
	return input()

def inin():
	return int(input())

def GCD(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def main():
	t = inin()
	for _ in range(t):
		n = inin()
		l = ain()
		m = sum(l)
		print(math.ceil(m / n))
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			self.write = lambda s: self.buffer.write(s.encode('ascii'))
			self.read = lambda : self.buffer.read().decode('ascii')
			self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


test_case = int(input())
for _ in range(test_case):
	n = int(input())
	price = list(map(int, input().split()))
	print(sum(price) // n if sum(price) % n == 0 else sum(price) // n + 1)


import math

def resu(a, l):
	res = math.ceil(sum(l) / a)
	return res
t = int(input())
for i in range(t):
	n = int(input())
	lis = list(map(int, input().split()))
	print(resu(n, lis))


from math import ceil
q = int(input())
for _ in range(q):
	n = int(input())
	a_s = sum([int(x) for x in input().split()])
	print(ceil(a_s / n))


import math
for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	count = 0
	for i in arr:
		count += i
	print(math.ceil(count / n))


import math
for i in range(int(input())):
	n = int(input())
	goods = [int(elem) for elem in input().split()]
	price = math.ceil(sum(goods) / n)
	print(price)


q = int(input())
for t in range(q):
	n = int(input())
	a = list(map(int, input().split()))
	print((sum(a) - 1) // n + 1)


import math
q = int(input())
ls = [list(map(int, input().split())) for _ in range(2 * q)]
n = []
a = []
for i in range(2 * q):
	if i % 2 == 0:
		n.append(ls[i])
	elif i % 2 == 1:
		a.append(ls[i])
for j in range(q):
	print(math.ceil(sum(a[j]) / n[j][0]))


from math import *
q = int(input())
for _ in range(q):
	n = int(input())
	a = list(map(int, input().split()))
	sn = sum(a)
	t = ceil(sn / n)
	print(t)


import math
querycount = input()
for q in range(int(querycount)):
	_ = input()
	lineprice = input()
	prices = [int(x) for x in lineprice.split(' ')]
	newprice = math.ceil(sum(prices) / len(prices))
	print(newprice)


tc = int(input())
for i in range(tc):
	n = int(input())
	all = [int(i) for i in input().split()]
	avg = sum(all)
	fin = avg // n
	ok = fin * n
	if ok < avg:
		fin += 1
	print(fin)


def main():
	q = int(input())
	for _ in range(q):
		n = int(input())
		a = list(map(int, input().split()))
		k = sum(a)
		ans = (k + n - 1) // n
		print(ans)
	return
main()


import sys
q = int(sys.stdin.readline())
for i in range(q):
	n = int(sys.stdin.readline())
	s = sum(map(int, sys.stdin.readline().split(' ')))
	print((s + n - 1) // n)


import math
test = int(input())
for _ in range(test):
	n = int(input())
	arr = list(map(int, input().split()))
	sum_element = sum(arr)
	print(math.ceil(sum_element / n))


def ii():
	return int(input())

def fi():
	return float(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	return list(mi())
import math
q = ii()
for i in range(q):
	n = ii()
	a = li()
	s = sum(a)
	ans = math.ceil(s / n)
	print(ans)


from math import *
t = int(input())
for i in range(t):
	n = int(input())
	s = list(map(int, input().split()))
	total = sum(s)
	p = 0
	if total % n == 0:
		p = total // n
	else:
		p = total // n + 1
	print(p)


def rint():
	return int(input())

def rints():
	return list(map(int, input().split()))
q = rint()
for _ in range(q):
	n = rint()
	a = rints()
	print((sum(a) + n - 1) // n)


q = int(input())
for i in range(q):
	n = int(input())
	l = list(map(int, input().split(' ')))
	tot = 0
	for i in l:
		tot = tot + i
	if tot % n == 0:
		print(int(tot / n))
	else:
		d = tot % n
		tot = tot - d
		c = int(tot / n)
		print(c + 1)


import math
q = int(input())
ans = []
for i in range(q):
	summ = 0
	a = int(input())
	money = [int(i) for i in input().split()]
	for i in range(a):
		summ = summ + money[i]
	summ = math.ceil(summ / a)
	ans.append(summ)
for i in range(q):
	print(ans[i])


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


q = int(input())
for i in range(q):
	n = int(input())
	a = list(map(int, input().rstrip().split()))
	res = sum(a) / n
	if res > int(res):
		print(int(res) + 1)
	else:
		print(int(res))


import sys
q = int(sys.stdin.readline())
for _ in range(q):
	n = int(sys.stdin.readline())
	arr = list(map(int, sys.stdin.readline().split()))
	arr_sum = sum(arr)
	if arr_sum % n == 0:
		print(arr_sum // n)
	else:
		print(arr_sum // n + 1)


from math import ceil
for _ in range(int(input())):
	n = int(input())
	arr = sorted([int(x) for x in input().split()])
	print(ceil(sum(arr) / n))


for _ in range(int(input())):
	n = int(input())
	A = sum([int(_) for _ in input().split()]) / n
	A = A if int(A) == A else A + 1
	print(int(A))


from math import ceil
q = int(input())
for i in range(q):
	n = int(input())
	p = list(map(int, input().split()))
	s = ceil(sum(p) / len(p))
	print(s)


t = int(input())
for i in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	a = sum(arr)
	print((a + n - 1) // n)


def bin_search(prices):
	(l, r) = (-1, max(prices) + 1)
	s = sum(prices)
	while r - l > 1:
		m = (r + l) // 2
		if m * len(prices) < s:
			l = m
		else:
			r = m
	return r
t = int(input())
for q in range(t):
	n = int(input())
	goods = list(map(int, input().split()))
	a = bin_search(goods)
	print(a)


import math
for _ in range(int(input())):
	n = int(input())
	nums = [int(j) for j in input().split()]
	result = sum(nums) / n
	print(math.ceil(result))


import math
n = int(input())
for i in range(n):
	s = 0
	m = int(input())
	a = [int(x) for x in input().split()]
	s = sum(a)
	print(math.ceil(s / m))


q = int(input())
for i in range(q):
	n = int(input())
	a = [int(x) for x in input().split()]
	som = sum(a)
	if som / n == int(som / n):
		print(int(som / n))
	else:
		print(int(som / n) + 1)


from math import ceil

def arifm(m):
	s = 0
	for i in range(len(m)):
		s += int(m[i])
	s = ceil(s / len(m))
	return s
n = int(input())
m = []
m2 = []
a = []
for i in range(n):
	m2.append(int(input()))
	m.append(input().split())
for i in range(len(m)):
	for j in range(len(m[i])):
		a.append(m[i][j])
	print(arifm(a))
	a = []


q = int(input())
for i in range(q):
	n = int(input())
	a = input().split(' ')
	allSum = 0
	for ai in a:
		allSum += int(ai)
	minPrice = allSum // n
	if n * minPrice < allSum:
		minPrice += 1
	print(minPrice)


q = int(input())
for i in range(q):
	n = int(input())
	a = [int(el) for el in input().split()]
	s = sum(a)
	print(s // n) if s % n == 0 else print(s // n + 1)


n = int(input())
a = []

def f(y):
	s = 0
	for i in y:
		s = s + int(i)
	if s % len(y) != 0:
		return s // len(y) + 1
	return s // len(y)
for i in range(n):
	x = int(input())
	y = input().split()
	a.append(f(y))
for i in a:
	print(i)


import math
q = int(input())
ans = ''
for i in range(q):
	n = int(input())
	a = list(map(int, input().strip().split()))
	ans += str(math.ceil(sum(a) / n))
	if i < q - 1:
		ans += '\n'
print(ans)


import math
q = int(input())
for query in range(q):
	n = int(input())
	sumall = sum(list(map(int, input().split())))
	print(math.ceil(sumall / n))


q = int(input())
for i in range(0, q):
	o = int(input())
	p = input().rstrip().split(' ')
	S = 0
	for j in range(0, len(p)):
		S += int(p[j])
	I = 0
	J = 100000000 - 1
	while I <= J:
		m = (I + J) // 2
		if m * o >= S:
			V = m
			J = m - 1
		else:
			I = m + 1
	print(V)


q = int(input())
for j in range(q):
	n = int(input())
	l = list(map(int, input().split()))
	s = 0
	for i in range(n):
		s += l[i]
	print((s + n - 1) // n)


from sys import stdin, stdout
import bisect
import math

def st():
	return list(stdin.readline())

def inp():
	return int(stdin.readline())

def li():
	return list(map(int, stdin.readline().split()))

def mp():
	return map(int, stdin.readline().split())

def pr(n):
	stdout.write(str(n) + '\n')

def soe(limit):
	l = [1] * (limit + 1)
	prime = []
	for i in range(2, limit + 1):
		if l[i]:
			for j in range(i * i, limit + 1, i):
				l[j] = 0
	for i in range(2, limit + 1):
		if l[i]:
			prime.append(i)
	return prime

def segsoe(low, high):
	limit = int(high ** 0.5) + 1
	prime = soe(limit)
	n = high - low + 1
	l = [0] * (n + 1)
	for i in range(len(prime)):
		lowlimit = low // prime[i] * prime[i]
		if lowlimit < low:
			lowlimit += prime[i]
		if lowlimit == prime[i]:
			lowlimit += prime[i]
		for j in range(lowlimit, high + 1, prime[i]):
			l[j - low] = 1
	for i in range(low, high + 1):
		if not l[i - low]:
			if i != 1:
				print(i)

def power(a, n):
	r = 1
	while n:
		if n & 1:
			r = r * a
			n = n - 1
		else:
			a = a * a
			n = n >> 1
	return r

def solve():
	n = inp()
	l = li()
	s = sum(l)
	x = math.ceil(s / n)
	y = s // n
	z = min(x * n, y * n)
	if z == x * n:
		if x in l:
			if z >= s:
				pr(x)
			else:
				pr(y)
		else:
			pr(y)
	elif y in l:
		if z >= s:
			pr(y)
		else:
			pr(x)
	else:
		pr(x)
for _ in range(inp()):
	solve()


import math
t = int(input())
while t > 0:
	t -= 1
	n = int(input())
	arr = list(map(float, input().split()))
	print(math.ceil(sum(arr) / n))


from math import *
q = int(input())
for numbers in range(q):
	n = int(input())
	list_a = list(map(int, input().split()))
	print(ceil(sum(list_a) / n))


def solve(arr, count):
	return str(int(sum(arr)) // count + (int(sum(arr)) % count > 0)) + '\n'
line = input().split(' ')
output = ''
for i in range(int(line[0])):
	count = int(input().split(' ')[0])
	arr = [int(x) for x in input().split(' ')]
	output += solve(arr, count)
print(output)


for _ in range(int(input())):
	n = int(input())
	data = [int(i) for i in input().split()]
	print((sum(data) + n - 1) // n)


from sys import stdin
from collections import deque
from math import sqrt, floor, ceil, log, log2, log10, pi

def ii():
	return int(stdin.readline())

def fi():
	return float(stdin.readline())

def mi():
	return map(int, stdin.readline().split())

def fmi():
	return map(float, stdin.readline().split())

def li():
	return list(mi())

def si():
	return stdin.readline()
for i in range(ii()):
	n = ii()
	a = sum(li())
	print(ceil(a / n))


from math import ceil
for _ in range(int(input())):
	n = int(input())
	a = [int(i) for i in input().split()]
	print(ceil(sum(a) / n))


T = int(input())
for t in range(1, T + 1):
	N = int(input())
	nl = list(map(int, input().split()))
	tmp = sum(nl)
	r = tmp // N + 1 if tmp % N else tmp // N
	print(r)


def answer(a):
	summ = sum(a)
	oneEl = summ // len(a)
	if oneEl * len(a) == summ:
		return oneEl
	else:
		return oneEl + 1
result = []
n = int(input())
for i in range(0, n):
	k = input()
	result.append(answer(tuple((int(a) for a in input().split(' ')))))
for el in result:
	print(el)


n = int(input())
B = []
for i in range(n):
	b = int(input())
	A = list(map(int, input().split()))
	if sum(A) % b == 0:
		B.append(sum(A) // b)
	else:
		B.append(sum(A) // b + 1)
for i in range(n):
	print(B[i])


q = int(input())
li = []
for i in range(int(q)):
	n = int(input())
	s = 0
	st = [int(c) for c in input().split()]
	for i in st:
		s += i
	s = s / int(n)
	if s % 1 == 0:
		s = int(s)
	else:
		s = int(s) + 1
	li.append(s)
for i in li:
	print(i)


import math
is_debug = False
q = int(input())
for _ in range(q):
	n = int(input())
	a = sum(map(int, input().split()))
	print(f'{math.ceil(a / n)}')


import math

class Read:

	@staticmethod
	def string():
		return input()

	@staticmethod
	def int():
		return int(input())

	@staticmethod
	def list(sep=' '):
		return input().split(sep)

	@staticmethod
	def list_int(sep=' '):
		return list(map(int, input().split(sep)))

def solve():
	n = Read.int()
	a = Read.list_int()
	s = 0
	for i in a:
		s += i
	print(math.ceil(s / n))
query_count = Read.int()
for j in range(query_count):
	solve()


from math import ceil

def res(nums):
	s = sum(nums)
	x = s // len(nums)
	y = ceil(s / len(nums))
	if x * len(nums) >= s:
		print(x)
		return
	print(y)
	return
n = int(input())
for i in range(n):
	input()
	x = list(map(int, input().split(' ')))
	res(x)


import math

def equal(arr):
	a = sum(arr)
	avg = math.ceil(a / len(arr))
	return avg
q = int(input())
n = []
p = list()
for i in range(q):
	n.append(int(input()))
	prices = list(map(int, input().rstrip().split()))
	p.append(prices)
for i in range(q):
	temp = p[i]
	print(equal(temp))


q = input()
inp = [input() for i in range(int(q) * 2)]
k = 0
while k <= len(inp) - 1:
	lenth = int(inp[k])
	arr = inp[k + 1].split()
	sum = 0
	for i in range(len(arr)):
		sum += int(arr[i])
	print(-(sum // -lenth))
	k += 2


import math
ans = []
for i in range(int(input())):
	n = int(input())
	lst = list(map(int, input().split()))
	sum = 0
	for i in lst:
		sum += i
	ans.append(math.ceil(sum / n))
for i in ans:
	print(i)


q = int(input())
res = []
for i in range(q):
	n = int(input())
	a = [int(i) for i in input().split()]

	def get_res():
		_res = sum(a)
		result = _res // len(a)
		result += 1 if _res % len(a) else 0
		return result
	res.append(get_res())
for i in res:
	print(i)


for _ in range(int(input())):
	n = int(input())
	print(-(-sum(map(int, input().split())) // n))


t = int(input())
for i in range(t):
	x = int(input())
	sum1 = 0
	l = list(map(int, input().split()))
	sum1 = sum(l)
	print((sum1 + x - 1) // x)


import math
n = int(input())
r = []
for i in range(n):
	a = int(input())
	l = input().split()
	for i in range(len(l)):
		l[i] = int(l[i])
	r.append(math.ceil(sum(l) / a))
for i in r:
	print(i)


N = int(input())
ans = []
for i in range(N):
	M = int(input())
	s = 0
	ln = [int(j) for j in input().split()]
	for j in range(M):
		s += ln[j]
	ans.append(s // M)
	if s % M > 0:
		ans[i] += 1
for i in range(N):
	print(ans[i])


import math
t = int(input())
for i in range(t):
	n = int(input())
	l = [int(x) for x in input().split()]
	sum = 0
	for j in range(len(l)):
		sum += l[j]
	sum = math.ceil(sum / n)
	print(sum)


for t in range(int(input())):
	n = int(input())
	total = sum(map(int, input().split()))
	print(total // n + (0 if total % n == 0 else 1))


from functools import reduce
from math import ceil
t = int(input())
for i in range(0, t):
	n = int(input())
	L = list(map(int, input().split()))
	s = reduce(lambda x, y: x + y, L)
	print(ceil(s / n))


import math
for q in range(int(input())):
	n = int(input())
	l1 = list(map(int, input().split()))
	print(math.ceil(sum(l1) / n))


q = int(input())
a = 0
for z in range(q):
	n = 0
	a = 0
	b = 0
	n = int(input())
	a = list(map(int, input().split()))
	for h in range(n):
		b = b + a[h]
	if b % n == 0:
		print(b // n)
	else:
		print(b // n + 1)


for _ in range(int(input())):
	q = int(input())
	a = list(map(int, input().split()))
	i = 0
	sum = 0
	while i < len(a):
		sum = sum + a[i]
		i = i + 1
	if sum % q == 0:
		print(int(sum / q))
	elif sum % q != 0:
		print(int(sum // q + 1))


import sys
inf = float('inf')
mod = 1000000007

def get_array():
	return list(map(int, sys.stdin.readline().split()))

def get_ints():
	return map(int, sys.stdin.readline().split())

def input():
	return sys.stdin.readline()

def int1():
	return int(input())
import math
from itertools import combinations

def main():
	t = int1()
	while t > 0:
		x = int1()
		a = get_array()
		z = sum(a) / x
		z = math.ceil(z)
		print(z)
		t = t - 1
main()


import math
t = int(input())
for i in range(t):
	n = int(input())
	arr = [int(x) for x in input().split()]
	d = sum(arr)
	print(math.ceil(d / n))


import math
casos = int(input())
for i in range(casos):
	ar = int(input())
	precios = list(map(int, input().split()))
	print(math.ceil(sum(precios) / ar))


import math
t = int(input())
ans = []
for i in range(t):
	n = int(input())
	ls = list(map(int, input().split()))
	sm = sum(ls)
	ans.append(math.ceil(sm / n))
for i in range(t):
	print(ans[i])


import math
q = int(input())
for i in range(q):
	n = int(input())
	summ = 0
	nums = input().split()
	for j in nums:
		summ = summ + int(j)
	avg = math.ceil(summ / n)
	print(avg)


for i in range(int(input())):
	a = int(input())
	q = input().split()
	sum = 0
	for ii in range(a):
		sum += int(q[ii])
	if sum / a > sum // a:
		print(sum // a + 1)
	else:
		print(sum // a)


import math
number = int(input())
for i in range(0, number):
	n = int(input())
	summ = 0
	arr = [int(x) for x in input().split()]
	for j in arr:
		summ += j
	print(math.ceil(summ / n))


t = int(input())
for i in range(t):
	s = 0
	a = int(input())
	b = input().split()
	for i in b:
		s = s + int(i)
	if s % a == 0:
		print(int(s / a))
	else:
		print(int(s / a) + 1)


from math import ceil
for t in range(int(input())):
	n = int(input())
	summ = sum([int(x) for x in input().split()])
	print(ceil(summ / n))


import math
q = int(input())
for _ in range(q):
	n = int(input())
	s = sum(list(map(lambda x: int(x), input().split(' '))))
	print(math.ceil(s / n))


def cf(n, a):
	s = sum(a)
	if s % n == 0:
		return s // n
	else:
		return s // n + 1
q = int(input())
y = []
for i in range(q):
	h = int(input())
	p = list(map(int, input().split()))
	r = cf(h, p)
	y.append(r)
for j in range(len(y)):
	print(y[j])


n = int(input())
for i in range(n):
	n1 = int(input())
	s = sum(map(int, input().split()))
	while s % n1 != 0:
		s += 1
	print(int(s / n1))


n = int(input())
for i in range(n):
	k = int(input())
	ele = list(map(int, input().rstrip().split()))
	ans = sum(ele) / k
	if int(ans) == ans:
		print(int(ans))
	else:
		print(int(ans + 1))


m = input()
for i in range(int(m)):
	nlist = []
	n = input()
	nl = input()
	nli = nl.split(' ')
	for i in nli:
		nlist.append(int(i))
	print(int(sum(nlist) / len(nlist) + 0.99))


import math
n = int(input())
for _ in range(n):
	k = int(input())
	ls = list(map(int, input().split()))
	avg = sum(ls) / k
	print(math.ceil(avg))


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


t = int(input().strip())
while t:
	n = int(input().strip())
	a = [int(i) for i in input().split()]
	print(int(sum(a) / n) + min(sum(a) % n, 1))
	t -= 1


a = int(input())
for i in range(a):
	b = int(input())
	l = list(map(int, input().split()))
	s = sum(l) / b
	if s > int(s):
		print(int(s) + 1)
	else:
		print(int(s))


t = int(input())
while t > 0:
	n = int(input())
	a = list((int(x) for x in input().split()))
	b = sum(a)
	if b % n == 0:
		print(b // n)
	else:
		print(b // n + 1)
	t -= 1


import math
t = int(input())
for i in range(t):
	n = int(input())
	sum = 0
	ar = list(map(int, input().split()))
	for j in range(n):
		sum = sum + ar[j]
	if sum % n == 0:
		print(math.floor(sum / n))
	else:
		print(math.ceil(sum / n))


import math
query = int(input())
while query > 0:
	total = int(input())
	all_nums = map(int, input().split(' '))
	answer = sum(all_nums)
	print(math.ceil(answer / total))
	query -= 1


import math
from statistics import mean

def main():
	q = int(input())
	for i in range(0, q):
		n = int(input())
		a = [int(i) for i in input().split()]
		print(math.ceil(mean(a)))
main()


import math
t = int(input())
for _ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	l.sort()
	print(math.ceil(sum(l) / n))


for k in range(int(input())):
	n = input()
	l = list(map(int, input().split(' ')))
	s = sum(l)
	if s // int(n) * int(n) < s:
		print(s // int(n) + 1)
	else:
		print(s // int(n))


from math import *
q = int(input())
indexes = []
arr = []
for i in range(0, q):
	n = int(input())
	indexes.append(n)
	inputed = [int(i) for i in input().split()]
	arr.append(inputed)
ans = []
for j in range(0, q):
	ans.append(ceil(sum(arr[j]) / indexes[j]))
for k in ans:
	print(k)


t = int(input())
count = 0
final = []
while count < t:
	n = int(input())
	price = input()
	price = [int(x) for x in price.split(' ')]
	initial_sum = sum(price)
	if initial_sum % n == 0:
		final.append(initial_sum // n)
	else:
		final.append(initial_sum // n + 1)
	count += 1
for y in final:
	print(y)


q = int(input())
out = list()
for i in range(q):
	n = int(input())
	a = [int(j) for j in input().split()]
	sum = 0
	for e in a:
		sum += e
	if sum % n == 0:
		out.append(sum // n)
	else:
		out.append(int(sum // n) + 1)
for o in out:
	print(o)


import math
q = int(input(''))
data = []
for i in range(q):
	n = int(input(''))
	prices = list(map(int, input('').split(' ')))
	data.append({'n': n, 'prices': prices})
for d in data:
	print(math.ceil(sum(d['prices']) / d['n']))


import math
T = int(input())
while T:
	N = int(input())
	lst = list(map(int, input().split()))
	print(math.ceil(sum(lst) / N))
	T -= 1


Tks = int(input())
for i in range(Tks):
	n = int(input())
	ar = []
	ar = list(map(int, input().split()))
	sum = 0
	for j in range(n):
		sum += int(ar[j])
	print((sum + n - 1) // n)


test = int(input())
arr = []
array = []
for i in range(0, test):
	arr.append(list(map(int, input().split())))
	array.append(list(map(int, input().split())))
arr1 = []
for i in range(0, test):
	sum = 0
	for j in range(0, len(array[i])):
		sum += array[i][j]
	sum1 = sum / len(array[i])
	if sum1 - int(sum1) != 0:
		sum1 = int(sum1) + 1
	arr1.append(int(sum1))
	print(int(sum1))


import math

def price_generator(price_seq=[]):
	n = len(price_seq)
	total_sum = sum(price_seq)
	new_price = int(math.ceil(total_sum / n))
	return new_price
	pass

def price_seq_splitter(price_seq_str):
	return [int(price) for price in price_seq_str.split(' ')]
	pass
n_tests = 0
tests = []
n_tests = int(input())
for i in range(n_tests):
	n_vals = int(input())
	price_seq = price_seq_splitter(input())
	generated_price = price_generator(price_seq)
	tests.append([price_seq, generated_price])
	pass
for i in range(n_tests):
	print(tests[i][1])
	pass


def f(A):
	ans = sum(A) / len(A)
	if ans == int(ans):
		return ans
	else:
		return ans + 1
a = int(input())
for tc in range(a):
	b = input()
	c = list(map(int, input().split()))
	print(int(f(c)))


t = int(input())
ans = []
for i in range(t):
	n = int(input())
	a = [int(i) for i in input().split()]
	k = sum(a) / n
	if k > int(k):
		k = int(k) + 1
	else:
		k = int(k)
	ans.append(k)
for i in ans:
	print(i)


q = int(input())
lst1 = []
for i in range(0, q):
	n = int(input())
	if n >= 1:
		lst = [int(i) for i in input().split()]
		x = round(sum(lst) / len(lst))
		if x * n >= sum(lst):
			lst1.append(x)
		else:
			lst1.append(x + 1)
print('\n'.join((str(value) for value in lst1)))


def solve(n, a):
	return sum(a) // n if sum(a) % n == 0 else sum(a) // n + 1
for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	print(solve(n, a))


from math import ceil
t = int(input())
for _ in range(t):
	n = int(input())
	array = list(map(int, input().split()))
	s = sum(array)
	ans = ceil(s / n)
	print(ans)


n = int(input())
for i in range(0, n):
	m = int(input())
	print((sum(map(int, input().split())) + m - 1) // m)


q = int(input())
while q > 0:
	n = int(input())
	l = list(map(int, input().split()))
	s = sum(l)
	if s % n == 0:
		print(int(s / n))
	else:
		print(int(s / n) + 1)
	q -= 1


q = int(input())
import math
for _ in range(q):
	n = int(input())
	l = list(map(int, input().split(' ')))
	s = sum(l)
	if s % n == 0:
		print(s // n)
	else:
		print(math.ceil(s / n))


def mp():
	return map(int, input().split())
q = int(input())
for qq in range(q):
	n = int(input())
	a = list(mp())
	s = sum(a)
	print((s + n - 1) // n)


from functools import reduce

def main():
	q = int(input())
	for i in range(0, q):
		n = int(input())
		vals = map(int, input().split())
		sum = reduce(lambda x, y: x + y, vals)
		print((sum - 1) // n + 1)
main()


import sys, atexit
from io import BytesIO
inp = BytesIO(sys.stdin.buffer.read())
input = lambda : inp.readline().decode('ascii')
buf = BytesIO()
atexit.register(lambda : sys.__stdout__.buffer.write(buf.getvalue()))
from math import ceil
for i in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	s = sum(a)
	print(ceil(s / n))


n1 = int(input())
result = []
for k in range(n1):
	n2 = int(input())
	mynumbers = list(map(int, input().split()))
	suma = 0
	for i in range(n2):
		suma += mynumbers[i]
	prom = suma / n2
	r_prom = round(prom)
	if r_prom * n2 < suma:
		r_prom += 1
	result.append(r_prom)
for k in range(n1):
	print(result[k])


q = int(input())
for i in range(q):
	n = int(input())
	a = input().split()
	b = []
	for o in a:
		b.append(int(o))
	c = sum(b) / len(b)
	if c % 1 != 0:
		c = int(c)
		c += 1
	print(int(c))


t = int(input())
for i in range(t):
	n = int(input())
	inp = list(map(int, input().split()))
	x = sum(inp)
	if x % len(inp) == 0:
		print(x // len(inp))
	else:
		print(x // len(inp) + 1)


aaa = int(input())
tab = []
for _ in range(aaa):
	a = int(input())
	b = list(map(int, input().split(' ')))
	tab.append([a, b])
for sub in tab:
	moy = sum(sub[1])
	mini = moy // sub[0]
	if str(moy / sub[0])[-1] != '0':
		print(mini + 1)
	else:
		print(mini)


q = int(input())
for i in range(q):
	n = int(input())
	a = [int(j) for j in input().split()]
	s = sum(a)
	print(s // n + (s % n != 0))


import math
from collections import deque, defaultdict
from sys import stdin, stdout
input = stdin.readline
listin = lambda : list(map(int, input().split()))
mapin = lambda : map(int, input().split())
for _ in range(int(input())):
	n = int(input())
	a = listin()
	s = sum(a) * 1.0
	print(int(math.ceil(s / n)))


import math
t = int(input())
while t > 0:
	n = int(input())
	ar = list(map(int, input().split()))
	x = math.ceil(sum(ar) / n)
	print(x)
	t -= 1


import math
q = int(input())
while q > 0:
	q -= 1
	n = int(input())
	data = input().split()
	data = [int(i) for i in data]
	dataSum = sum(data)
	tmp = math.ceil(dataSum / n)
	if tmp * n >= dataSum:
		print(tmp)
	else:
		print(tmp + 1)


n = int(input())
for i in range(n):
	m = int(input())
	vet = list(map(int, input().split()))
	tam = sum(vet)
	o = tam // m
	if o * m >= tam:
		print(o)
	else:
		print(o + 1)


lamb = lambda : [*map(int, input().split())]
q = int(input())
lis = []

def didi(m, n):
	if m % n == 0:
		return m // n
	else:
		return m // n + 1
for i in range(q):
	n = int(input())
	a = lamb()
	m = sum(a)
	lis.append(didi(m, n))
for i in range(q):
	print(lis[i])


q = int(input())
for i in range(q):
	n = int(input())
	cost = list(map(int, input().split()))
	S = sum(cost)
	if S / n == S // n:
		print(S // n)
	else:
		print(int(S / n + 1))


from math import ceil
t = int(input())
for i in range(t):
	ar = int(input())
	values = list(map(int, input().split()))
	suma = sum(values)
	print(ceil(suma / ar))


import math
q = int(input())
for i in range(q):
	n = int(input())
	s = [int(i) for i in input().split()]
	print(math.ceil(sum(s) / len(s)))


import math
q = int(input())
for _ in range(q):
	n = int(input())
	ls = list(map(int, input().split()))
	res = int(math.ceil(sum(ls) / n))
	print(res)


x = int(input())
for i in range(x):
	z = input()
	z = int(z)
	c = input().split()
	c = [int(cc) for cc in c]
	ss = sum(c)
	if ss % z == 0:
		print(ss // z)
	else:
		print(ss // z + 1)


import math
n = int(input())
for item in range(n):
	a = int(input())
	b = list(map(int, input().split()))
	print(math.ceil(sum(b) / len(b)))


from math import ceil
for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	k = ceil(sum(l) / len(l))
	print(k)


from math import ceil
precios = []
n = int(input())
for i in range(n):
	m = input()
	nuevosPrecios = input().split(' ')
	precios.append(nuevosPrecios)
for arreglo in precios:
	suma = 0
	for precio in arreglo:
		suma += int(precio)
	print(ceil(suma / len(arreglo)))


from math import ceil, sqrt, floor, sqrt
import collections
from typing import List
from fractions import gcd
from collections import deque
from collections import Counter, deque
t = int(input())
for _ in range(t):
	n = int(input())
	A = list(map(int, input().split()))
	print(ceil(sum(A) / n))


def priravnivanie(n, lst):
	s = sum(lst)
	if s % n == 0:
		return s // n
	return s // n + 1
q = int(input())
for i in range(q):
	t = int(input())
	a = [int(j) for j in input().split()]
	print(priravnivanie(t, a))


import sys, math, queue
MOD = 10 ** 9 + 7
sys.setrecursionlimit(1000000)
for _ in range(int(input())):
	n = int(input())
	s = sum(list(map(int, input().split())))
	print(math.ceil(s / n))


n = int(input())
for i in range(n):
	x = int(input())
	s = 0
	arr = list(map(int, input().split()))
	for i in range(x):
		s = s + arr[i]
	if s % x == 0:
		print(int(s / x))
	else:
		print(int(s / x) + 1)


from math import ceil
for _ in range(int(input())):
	lens = int(input())
	vals = [int(x) for x in input().split()]
	print(ceil(sum(vals) / lens))


test = int(input())
while test > 0:
	n = int(input())
	x = list(map(int, input().split()))
	y = sum(x)
	if y % n == 0:
		print(int(y / n))
	else:
		print(int(y / n) + 1)
	test -= 1


a = int(input())
for i in range(a):
	b = int(input())
	d = list(map(int, input().split()))
	summ = sum(d)
	s1 = len(d)
	kol = summ // s1
	while s1 * kol < summ:
		kol += 1
	print(kol)


t = int(input())
while t:
	t -= 1
	m = int(input())
	l = list(map(int, input().split()))
	s = sum(l)
	if s % m == 0:
		print(s // m)
	else:
		print(s // m + 1)


no = int(input())
res = []
for i in range(no):
	n = int(input())
	a = list(map(int, input().split()))
	add = sum(a)
	main = (add + n - 1) // n
	res.append(main)
for i in res:
	print(i)


from fractions import gcd
from datetime import date, timedelta
from heapq import *
import math
from collections import defaultdict, Counter
import sys
from bisect import *
sys.setrecursionlimit(10 ** 7)
MOD = 10 ** 9 + 7

def main():
	t = int(input())
	for i in range(t):
		n = int(input())
		a = list(map(int, input().split()))
		print(math.ceil(sum(a) / n))
main()


import math
q = int(input())
for i in range(q):
	n = int(input())
	a = [int(i) for i in input().split()]
	sumA = 0
	for i in range(n):
		sumA += a[i]
	print(math.ceil(sumA / n))


import math
q = int(input())
for _ in range(q):
	n = int(input())
	a = [int(i) for i in input().split()]
	b = sum(a) / n
	b = math.ceil(b)
	print(b)


t = int(input())
for _ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	k = sum(l)
	z = k // n
	if k % n == 0:
		print(z)
	else:
		print(z + 1)


def main():
	T = int(input().strip())
	for case in range(T):
		n = int(input().strip())
		a = map(int, input().strip().split())
		k = sum(a)
		print((k + n - 1) // n)
main()


n = int(input())
b = []
for i in range(n):
	m = int(input())
	a = list(map(int, input().split()))
	s = 0
	for i in a:
		s = s + i
	if s % m == 0:
		b.append(s // m)
	else:
		b.append(s // m + 1)
for i in range(n):
	print(b[i])


for i in range(int(input())):
	n = int(input())
	l = [int(i) for i in input().split()]
	s = sum(l)
	a = 0
	while s % n != 0:
		s += 1
	print(s // n)


q = int(input())
for i in range(q):
	w = int(input())
	e = sum(list(map(int, input().split())))
	if e / w > e // w:
		print(int(e // w) + 1)
	else:
		print(int(e // w))


q = int(input())
for ii in range(q):
	n = int(input())
	arr = list(map(int, input().split()))
	ss = sum(arr)
	flag = False
	ans = 10000000
	start = 0
	end = 10000000
	while start <= end:
		mid = (start + end) // 2
		temp = mid * n
		if temp >= ss:
			ans = min(ans, mid)
			end = mid - 1
		else:
			start = mid + 1
	print(ans)


import math
n = int(input())
for i in range(n):
	items = int(input())
	x = list(map(int, input().split()))
	sum_ = sum(x)
	divide_ = sum_ / items
	print(math.ceil(divide_))


import sys
import math
from math import ceil
import bisect

def input():
	return sys.stdin.readline().strip()

def iinput():
	return int(input())

def finput():
	return float(input())

def tinput():
	return input().split()

def rinput():
	return map(int, tinput())

def rlinput():
	return list(rinput())

def modst(a, s):
	res = 1
	while s:
		if s % 2:
			res *= a
		a *= a
		s //= 2
	return res

def main():
	n = iinput()
	print(ceil(sum(rlinput()) / n))
for i in range(iinput()):
	main()


q = int(input())
for _ in range(q):
	n = int(input())
	lol = [int(n) for n in input().split()]
	mean = sum(lol) // n
	if mean * n < sum(lol):
		print(mean + 1)
	else:
		print(mean)


import sys
inf = float('inf')
(mod, MOD) = (1000000007, 998244353)
from math import ceil, floor, log, sqrt, factorial, pow, pi, gcd, log10, atan, tan

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def input():
	return sys.stdin.readline().strip()
T = int(input())
while T:
	n = int(input())
	Arr = get_array()
	s = sum(Arr)
	ans = ceil(s / n)
	print(ans)
	T -= 1


from collections import defaultdict as dc
import sys
import math
mod = 10 ** 9 + 7

def inp():
	p = sys.stdin.readline()
	return p

def prf(a, n):
	q = sum(a)
	p = math.ceil(q / n)
	return p
for _ in range(int(inp())):
	n = int(inp())
	a = list(map(int, inp().split()))
	print(prf(a, n))


t = int(input())
for i in range(t):
	n = int(input())
	L = [int(i) for i in input().split()]
	if sum(L) % n == 0:
		print(sum(L) // n)
	else:
		print((sum(L) + (n - sum(L) % n)) // n)


req = int(input())
for _ in range(req):
	goods = int(input())
	price = sum(list(map(int, input().split(' '))))
	print(price // goods if price % goods == 0 else price // goods + 1)


import math
t = int(input())
for i in range(t):
	N = int(input())
	TotalPrice = list(map(int, input().split()))
	print(math.ceil(sum(TotalPrice) / N))


T = int(input())
for _ in range(T):
	n = int(input())
	p = list(map(int, input().split()))
	value = sum(p)
	if value / n - int(value / n) > 0:
		print(int(value / n + 1))
	else:
		print(int(value / n))


q = int(input())
for _ in range(q):
	n = int(input())
	prices = [int(c) for c in input().split()]
	s = sum(prices)
	if s % n == 0:
		print(s // n)
	else:
		print(s // n + 1)


from math import ceil

def func(n):
	for i in range(n):
		k = int(input())
		l = list(map(int, input().split()))
		print(ceil(sum(l) / k))
n = int(input())
func(n)


import math

def equal_prices(arr, len):
	return math.ceil(sum(arr) / len)

def get_input(flag=0):
	if flag:
		return int(input())
	return [int(i) for i in input().split()]
q = get_input(1)
for i in range(q):
	len = get_input(1)
	arr = get_input()
	print(equal_prices(arr, len))


q = int(input())
while q:
	n = int(input())
	x = input().split()
	s = 0
	for i in x:
		s += int(i)
	if s % n == 0:
		print(s // n)
	else:
		print(s // n + 1)
	q = q - 1


e = int(input())
for ee in range(e):
	n = int(input())
	a = [int(i) for i in input().split(' ', n - 1)]
	g = sum(a) // n
	if g * n < sum(a):
		print(g + 1)
	else:
		print(g)


q = int(input())
for i in range(q):
	s = 0
	n = int(input())
	a = list(map(int, input().split()))
	for j in range(n):
		s = s + a[j]
	v = s // n
	if v * n < s:
		v += 1
	print(v)


import math
num_testcases = int(input())
testcases = []
while num_testcases:
	num_testcases -= 1
	n = int(input())
	testcases.append(list(map(int, input().split(' '))))

def work(testcase):
	n = len(testcase)
	return math.ceil(sum(testcase) / n)
for testcase in testcases:
	print(work(testcase))


import math

def main():
	q = int(input())
	for i in range(q):
		n = int(input())
		list1 = list(map(int, input().split(' ')))
		sum1 = sum(list1)
		print(int(math.ceil(sum1 / n)))
main()


ntc = int(input())
for tcs in range(ntc):
	n = int(input())
	num = list(map(int, input().split()))
	s = sum(num)
	avg = s // n
	while True:
		if s <= avg * n:
			res = avg
			break
		avg += 1
	print(res)


import math
import copy
t = int(input())
for _ in range(t):
	n = int(input())
	a = [int(i) for i in input().split()]
	c = 0
	for i in a:
		c += i
	print(math.ceil(c / n))


import sys
import collections
input = sys.stdin.readline

def printnl(val):
	sys.stdout.write(str(val) + '\n')
q = int(input())
for Q in range(q):
	n = int(input())
	ans = sum(list(map(int, input().split())))
	printnl((ans + n - 1) // n)


import sys, math
I = sys.stdin.readline
ans = ''
for _ in range(int(I())):
	n = int(I())
	a = list(map(int, I().split()))
	ans += '{}\n'.format(math.ceil(sum(a) / n))
print(ans)


import math
n = int(input())
for i in range(n):
	x = int(input())
	y = input().split()
	y = [int(i) for i in y]
	print(math.ceil(sum(y) / x))


import math
q = int(input())
for w in range(q):
	n = int(input())
	l = [int(i) for i in input().split()]
	s = sum(l)
	k = math.ceil(s / n)
	print(int(k))


import math
from statistics import mean
for k in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	s = mean(l)
	print(math.ceil(s))


import math
q = int(input())
for _ in range(q):
	n = int(input())
	ais = list(map(int, input().split()))
	tot = sum(ais)
	ans = math.ceil(tot / n)
	print(ans)


for itr in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	s = sum(a)
	k = s // n
	if k * n == s:
		print(k)
	else:
		print(k + 1)


n = int(input())
for _ in range(n):
	m = int(input())
	number = list(map(int, input().split(' ')))
	print(int(sum(number) / len(number))) if sum(number) / len(number) == sum(number) // len(number) else print(sum(number) // len(number) + 1)


for _ in range(int(input())):
	n = int(input())
	arr = [int(k) for k in input().split()]
	t = 0
	for i in range(n):
		t += arr[i]
	if t % n == 0:
		print(t // n)
	else:
		print(t // n + 1)


answer = []
for x in range(int(input())):
	size = int(input())
	prices = [int(x) for x in input().split()]
	sum = 0
	for p in prices:
		sum += p
	if sum % len(prices) == 0:
		answer.append(int(sum / len(prices)))
	else:
		answer.append(int(sum / len(prices) + 1))
for a in answer:
	print(a)


Q = int(input())
for q in range(Q):
	N = int(input())
	a = list(map(int, input().split()))
	r = 0
	for i in range(N):
		r = r + a[i]
	r = r + N - 1
	r = r // N
	print(r)


class avg:

	def sumof(self, n):
		lst = [int(i) for i in input().split()]
		average = math.ceil(sum(lst) / n)
		return average
import math
for i in range(int(input())):
	n = int(input())
	x = avg()
	print(x.sumof(n))


import math
for _ in range(int(input())):
	x = int(input())
	a = list(map(int, input().split()))
	y = sum(a)
	res = y / x
	print(int(math.ceil(res)))


from math import ceil
cases = int(input())
for i in range(cases):
	sum = 0
	gar = int(input())
	for val in [int(x) for x in input().split()]:
		sum += int(val)
	print(ceil(sum / gar))


import math
t = int(input())
for _ in range(t):
	n = int(input())
	s = list(map(int, input().split()))
	x = sum(s)
	if x == 0:
		print(0)
	else:
		x = x / n
		print(int(math.ceil(x)))


import math
n = int(input())
for _ in range(n):
	le = int(input())
	a = [int(i) for i in input().split()]
	s = sum(a)
	print(math.ceil(sum(a) / len(a)) // 1)


t = int(input())
for j in range(0, t):
	s = 0
	n = int(input())
	l = [int(e) for e in input().split(' ')]
	for i in range(0, n):
		s = s + l[i]
	import math
	print(math.ceil(s / n))


from sys import stdin, stdout
from math import ceil

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

def sp():
	return [str(i) for i in stdin.readline().split()]

def pp(A):
	for i in A:
		print(i)

def solve():
	n = int(input())
	A = ip()
	return ceil(sum(A) / n)
t = int(input())
for i in range(t):
	print(solve())


q = int(input())
ans = []
for i in range(q):
	n = int(input())
	s = list(map(int, input().split(' ')))
	ans.append((sum(s) + n - 1) // n)
print(*ans, sep='\n')


def find_min(n, arr):
	s = sum(arr)
	if s % n == 0:
		q = s // n
	else:
		q = s // n
		q += 1
	return q
for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().strip().split()))
	print(find_min(n, arr))


import math

def array_sum(lst):
	sum = 0
	for elem in lst:
		sum += elem
	return sum
q = int(input())
for _ in range(q):
	n = int(input())
	lst = list([int(x) for x in input().split()])
	sum = array_sum(lst)
	print(math.ceil(sum / n))


import math
t = int(input())
f_a = []
for i in range(t):
	n = int(input())
	a = [int(i) for i in input().split()]
	ans = int(math.ceil(sum(a) / n))
	f_a.append(ans)
for j in range(len(f_a)):
	print(f_a[j])


import math
inp = int(input())
for i in range(inp):
	n = int(input())
	num = list(map(int, input().split()))
	x = sum(num)
	print(math.ceil(x / n))


q = int(input())
for j in range(q):
	n = int(input())
	L = list(map(int, input().split()))
	k = sum(L)
	if k % n == 0:
		print(int(k / n))
	else:
		print(int(k / n) + 1)


import math
t = int(input())
for case in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	sol = sum(a) / n
	print(math.ceil(sol))


from math import ceil
t = int(input())
for i in range(t):
	n = int(input())
	soma = sum(list(map(int, input().split(' '))))
	res = ceil(soma / n)
	print('%i' % res)


t = int(input())
for i in range(t):
	n = int(input())
	lst = list(map(int, input().split()))
	oldSum = sum(lst)
	avg = oldSum // n
	if avg * n < oldSum:
		avg += 1
	print(avg)


tc = int(input())
import math
ans = []
for i in range(tc):
	z = input()
	temp = [int(i) for i in input().split()]
	temp_ans = math.ceil(sum(temp) / len(temp))
	ans.append(temp_ans)
for i in ans:
	print(i)


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
import math
testcases = int(input())
for j in range(testcases):
	n = int(input())
	vals = list(map(int, input().split()))
	initial = 0
	for s in range(n):
		initial += vals[s]
	print(math.ceil(initial / n))


q = int(input())
q1 = q
while q1 > 0:
	n = int(input())
	l = map(int, input().split(' '))
	sumatotal = sum(l)
	rpta = int(sumatotal / n)
	if sumatotal % n != 0:
		rpta = rpta + 1
	print(rpta)
	q1 = q1 - 1


for u in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	s = sum(l)
	z = s / n
	if z == int(z):
		print(int(z))
	else:
		print(int(z) + 1)


def feed(n, a):
	p = sum(a)
	qt = p / n
	q1 = int(qt) - qt
	if abs(q1) == 0:
		print(int(qt))
	else:
		print(int(qt + 1))
q = int(input())
for i in range(q):
	n = int(input())
	a = [int(i) for i in input().split()]
	ans = feed(n, a)
	ans


import math
t = int(input())
while t:
	t -= 1
	l = int(input())
	p = list(map(int, input().split()))
	s = sum(p)
	print(math.ceil(s / l))


import math
import statistics
for _ in range(int(input())):
	input()
	print(math.ceil(statistics.mean(map(int, input().split()))))


n = int(input())
for i in range(n):
	num = int(input())
	lst = sum(list(map(int, input().split())))
	print(-(-lst // num))


from math import ceil
for i in range(int(input())):
	x = int(input())
	p = sum(map(int, input().split()))
	print(ceil(p / x))


for i in range(int(input())):
	n = int(input())
	s = list(map(int, input().split()))
	r = sum(s)
	m = int(r / n)
	if n * m < r:
		m = m + 1
	print(m)


from math import ceil
q = int(input())
for i in range(q):
	n = int(input())
	goods = [int(x) for x in input().split()]
	s = ceil(sum(goods) / n)
	print(s)


Q = int(input())
for _ in range(Q):
	K = int(input())
	L = list(map(int, input().split()))
	value = sum(L)
	print(int(value / K) if value % K == 0 else int(value / K + 1))


def main():
	t = int(input())
	for _ in range(t):
		n = int(input())
		l = list(map(int, input().split()))
		s = sum(l)
		ans = s // n
		if s % n != 0:
			ans += 1
		print(ans)
main()


Q = int(input())
for q in range(Q):
	n = int(input())
	arr = list(map(int, input().split()))
	hap = sum(arr)
	print((hap + n - 1) // n)


import sys, os, io

def rs():
	return sys.stdin.readline().rstrip()

def ri():
	return int(sys.stdin.readline())

def ria():
	return list(map(int, sys.stdin.readline().split()))

def ws(s):
	sys.stdout.write(s + '\n')

def wi(n):
	sys.stdout.write(str(n) + '\n')

def wia(a):
	sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math as mt
from collections import deque

def main():
	for _ in range(int(input())):
		n = int(input())
		a = [int(x) for x in input().split()]
		c = sum(a)
		z = mt.ceil(c / n)
		print(z)

class FastReader(io.IOBase):
	newlines = 0

	def __init__(self, fd, chunk_size=1024 * 8):
		self._fd = fd
		self._chunk_size = chunk_size
		self.buffer = io.BytesIO()

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self, size=-1):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

class FastWriter(io.IOBase):

	def __init__(self, fd):
		self._fd = fd
		self.buffer = io.BytesIO()
		self.write = self.buffer.write

	def flush(self):
		os.write(self._fd, self.buffer.getvalue())
		(self.buffer.truncate(0), self.buffer.seek(0))

class FastStdin(io.IOBase):

	def __init__(self, fd=0):
		self.buffer = FastReader(fd)
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

class FastStdout(io.IOBase):

	def __init__(self, fd=1):
		self.buffer = FastWriter(fd)
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.flush = self.buffer.flush
sys.stdin = FastStdin()
sys.stdout = FastStdout()
main()


import math
for i in range(int(input())):
	n = int(input())
	arr = [int(i) for i in input().split(' ')]
	sum1 = sum(arr)
	print(math.ceil(sum1 / n))


n = int(input())
for x in range(n):
	a = int(input())
	array = list(map(int, input().split()))
	value = sum(array)
	current = value / a
	if current == current // 1:
		print(int(current))
	else:
		print(int(current // 1) + 1)


def query(given_list):
	s = sum(given_list) // len(given_list)
	if sum(given_list) % len(given_list) == 0:
		return s
	else:
		return s + 1

def main():
	ans = []
	for i in range(int(input())):
		num = input()
		given_list = list(map(int, input().split(' ')))
		ans.append(query(given_list))
	for i in ans:
		print(i)
main()


import math
import bisect
from functools import reduce
from collections import defaultdict

def inn():
	return int(input())

def inl():
	return list(map(int, input().split()))
MOD = 10 ** 9 + 7
INF = inf = 10 ** 18 + 5
for t in range(inn()):
	n = inn()
	a = inl()
	s = sum(a)
	print(math.ceil(s / n))


t = int(input())
for q in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	x = sum(l) / n
	if int(x) != x:
		x = int(x) + 1
	x = int(x)
	print(x)


import math

def compute(arr, n):
	cur_sum = 0
	for i in arr:
		cur_sum += i
	return math.ceil(cur_sum / n)
t = int(input())
for _ in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	print(compute(arr, n))


import math
tests = int(input())
while tests > 0:
	tests -= 1
	n = int(input())
	arr = list(map(int, input().split()))
	oldSum = 0
	for x in arr:
		oldSum += x
	res = int(math.ceil(oldSum / n))
	print(res)


q = int(input())
while q:
	q += -1
	n = int(input())
	l = list(map(int, input().split()))
	s = sum(l)
	t = s // n
	t2 = t * n
	if t2 >= s:
		print(t)
	else:
		print(t + 1)


q = int(input())
for _ in range(q):
	n = int(input())
	s = [int(x) for x in input().split()]
	tot = 0
	for i in range(0, len(s)):
		tot += s[i]
	ans = n * (tot // n)
	if tot % n != 0:
		ans += n
	print(ans // n)


for _ in range(int(input())):
	a = int(input())
	b = list(map(int, input().split()))
	print((sum(b) + a - 1) // a)


import math

def newCost(a):
	x = sum(a)
	avg = int(math.ceil(x / len(a)))
	return avg
t = int(input())
for i in range(t):
	n = int(input())
	a = list(map(int, input().rstrip().split()))
	res = newCost(a)
	print(res)


import math
for i in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	k = n // 2
	s = sum(arr)
	ans = s / n
	print(math.ceil(ans))


from functools import reduce
d = []
for i in range(int(input())):
	a = int(input())
	b = [int(n) for n in input().split()]
	c = sum(b)
	if c % a == 0:
		d.append(c // a)
	else:
		d.append((c // a * a + a) // a)
print(*d, sep='\n')


import sys, math
from collections import deque
inp = sys.stdin.readline
ans = ''
for _ in range(int(inp())):
	n = int(inp())
	ans += str(math.ceil(sum(map(int, inp().split())) / n)) + '\n'
print(ans)


q = int(input())
for i in range(q):
	sum = 0
	n = input()
	prices = input().split()
	for p in range(len(prices)):
		sum += int(prices[p])
	div1 = sum / len(prices)
	div2 = sum // len(prices)
	if div1 > div2:
		print(div2 + 1)
	else:
		print(int(div1))


import math
for test in range(int(input())):
	no = input()
	li = [int(_) for _ in input().split()]
	avg = int(math.ceil(sum(li) / len(li)))
	print(avg)


q = int(input())
for _ in range(q):
	n = int(input())
	m = [int(x) for x in input().strip().split(' ')]
	s = sum(m)
	if s / n == s // n:
		print(s // n)
	else:
		print(s // n + 1)


import math
q = int(input())
for i in range(q):
	n = int(input())
	l = list(map(int, input().split()))
	s = sum(l)
	avg = s / n
	x = math.ceil(avg)
	print(x)


for a0 in range(int(input())):
	n = int(input())
	q = list(map(int, input().split()))
	if sum(q) % n == 0:
		print(sum(q) // n)
	else:
		print(sum(q) // n + 1)


import math
list = []
S = 0
q = int(input())
for i in range(q):
	n = int(input())
	list = input().split()
	S = sum((int(i) for i in list))
	print(math.ceil(S / n))
	S = 0


zapros = int(input())
for i in range(zapros):
	number = int(input())
	cost = list(map(int, input().split()))
	ave = sum(cost) // number
	if sum(cost) % number == 0:
		print(ave)
	else:
		print(ave + 1)


import math
x = int(input())
for i in range(x):
	l = int(input())
	m = list(map(int, input().split()))
	x = 0
	for i in m:
		x += i
	print(math.ceil(x / l))


q = int(input())
out = []
for i in range(q):
	n = int(input())
	s = sum(map(int, input().split())) / n
	if s % 1 == 0:
		out.append(int(s))
	else:
		out.append(int(s) + 1)
print('\n'.join([str(i) for i in out]))


from math import ceil
tc = int(input())
while tc > 0:
	tc -= 1
	n = int(input())
	all_count = sum(map(int, input().split()))
	print(ceil(all_count / n))


import math
from sys import stdin
t = int(stdin.readline())
l = []
for i in range(t):
	n = int(stdin.readline())
	lis = [int(x) for x in stdin.readline().split()]
	sum = 0.0
	for x in lis:
		sum += x
	sum = sum / n
	sum = math.ceil(sum)
	l += [sum]
for x in l:
	print(x)


def fastio():
	import sys
	from io import StringIO
	from atexit import register
	global input
	sys.stdin = StringIO(sys.stdin.read())
	input = lambda : sys.stdin.readline().rstrip('\r\n')
	sys.stdout = StringIO()
	register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()
MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
from math import *
(t,) = I()
while t:
	t -= 1
	(n,) = I()
	l = I()
	s = sum(l)
	print(ceil(s / n))


test_case = int(input())
for _ in range(test_case):
	n = int(input())
	price = list(map(int, input().split()))
	print(abs(-sum(price) // n))


from math import ceil
output = []
queries = int(input())
for _ in range(queries):
	input()
	inputList = list(map(int, input().split()))
	output.append(ceil(sum(inputList) / len(inputList)))
for i in output:
	print(i)


import math
t = int(input())
for i in range(t):
	n = int(input())
	arr = [int(i) for i in input().split()]
	sum = 0
	for i in arr:
		sum += i
	a = sum / n
	print(math.ceil(a))


tr = int(input())
for i in range(tr):
	length = int(input())
	pi = list(map(int, input().split()))
	averageT = 0
	for i in range(length):
		averageT += pi[i]
	if averageT / length != averageT // length:
		print(averageT // length + 1)
	else:
		print(averageT // length)


import math
t = int(input())
for _ in range(t):
	n = int(input())
	s = input().split()
	sx = 0
	for i in range(n):
		sx += int(s[i])
	print(math.ceil(sx / n))


from sys import stdin
import math
A = int(stdin.readline())
for t in range(0, A):
	B = int(stdin.readline())
	C = list(map(int, stdin.readline().split()))
	sum = 0
	for k in C:
		sum += k
	print(int(math.ceil(sum / B)))


from math import *
q = int(input())
for g in range(q):
	n = int(input())
	s = 0
	for x in input().split():
		s += int(x)
	ans = ceil(s / n)
	print(ans)


for q in range(int(input())):
	n = int(input())
	a = [int(x) for x in input().split()]
	price = sum(a) / len(a)
	if not price.is_integer():
		price += 1
	print(str(int(price)))


for _ in range(int(input())):
	n = int(input())
	s = sum((int(v) for v in input().split()))
	print((s - 1) // n + 1)


import sys
import math

def read_int_lines():
	lines = []
	for line in sys.stdin:
		my_line = line.split()
		my_line = [int(x) for x in my_line]
		lines.append(my_line)
	num_queries = lines[0]
	del lines[0]
	num_goods = None
	prices = None
	output = []
	for (idx, vals) in enumerate(lines):
		if idx % 2 == 0:
			num_goods = vals[0]
		else:
			prices = vals
			new_output = math.ceil(sum(prices) / num_goods)
			output.append(new_output)
	for o in output:
		print(o)
read_int_lines()


from math import ceil
n = int(input())
for i in range(n):
	k = int(input())
	ls = list(map(int, input().split()))
	sm = sum(ls)
	print(ceil(sm / k))


ii = lambda : int(input())
kk = lambda : map(int, input().split())
ll = lambda : list(kk())
for _ in range(ii()):
	(n, s) = (ii(), sum(kk()))
	print(s // n + min(1, s % n))


i = int(input())
for k in range(i):
	b = int(input())
	liste = list(map(int, input().split(' ')))
	den1 = sum(liste) / b
	if den1 > int(den1):
		print(int(den1) + 1)
	else:
		print(int(den1))


q = int(input())
all = 0
lis1 = []
for i in range(q):
	n = int(input())
	p = input().split()
	for j in range(0, n):
		all += int(p[j])
	if all % n == 0:
		ans = all // n
	else:
		ans = all // n + 1
	lis1.append(ans)
	all = 0
for z in range(len(lis1)):
	print(lis1[z])


import math
q = int(input())
for _ in range(q):
	n = int(input())
	a = list(map(int, input().split()))
	ans = math.ceil(sum(a) * 1.0 / n)
	print(ans)


MOD = 1000000007
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
from collections import *
for _ in range(ii()):
	n = ii()
	l = il()
	if sum(l) % n == 0:
		print(sum(l) // n)
	else:
		print(sum(l) // n + 1)


import math as m
t = int(input())
for i in range(t):
	n = int(input())
	lst = list(map(int, input().strip().split()))[:n]
	print(m.ceil(sum(lst) / n))


import math

def main():
	lista = []
	q = int(input())
	for i in range(q):
		summa = 0
		n = int(input())
		s = input()
		s2 = s.split()
		for x in s2:
			summa += int(x)
		avg = summa / n
		if type(avg) == int:
			lista.append(avg)
		else:
			avg2 = math.ceil(avg)
			lista.append(avg2)
	for y in lista:
		print(y)
main()


q = int(input())
for _ in range(q):
	n = int(input())
	nums = sum(map(int, input().split()))
	if nums % n == 0:
		print(nums // n)
	else:
		print(nums // n + 1)


import sys, os, re, datetime, copy
from collections import *
from bisect import *
from math import *

def mat(v, *dims):

	def dim(i):
		return [copy.copy(v) for _ in range(dims[-1])] if i == len(dims) - 1 else [dim(i + 1) for _ in range(dims[i])]
	return dim(0)
__cin__ = None

def cin():
	global __cin__
	if __cin__ is None:
		__cin__ = iter(input().split(' '))
	try:
		return next(__cin__)
	except StopIteration:
		__cin__ = iter(input().split(' '))
		return next(__cin__)

def iarr(T, n):
	return [T(cin()) for _ in range(n)]

def carr(n):
	return input()

def imat(T, n, m):
	return [iarr(T, m) for _ in range(n)]

def cmat(n, m):
	return [input() for _ in range(n)]

def solve():
	n = int(cin())
	a = iarr(int, n)
	s = 0
	for v in a:
		s += v
	b = s // n
	r = s % n
	if r > 0:
		print(b + 1, sep='')
	else:
		print(b, sep='\n')
q = int(cin())
for i in range(q):
	solve()


from math import ceil

def calc(price_amount):
	_sum = 0
	_input = [int(i) for i in input().split()]
	for price in _input:
		_sum += price
	return ceil(_sum / price_amount)
count = int(input())
while count:
	print(calc(int(input())))
	count -= 1


for k in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	if sum(a) % n == 0:
		print(sum(a) // n)
	else:
		print(sum(a) // n + 1)


from math import ceil
for i in range(int(input())):
	k = int(input())
	nums = map(int, input().split())
	print(ceil(sum(nums) / k))


from math import *
from sys import stdin, stdout
import itertools, os, sys, threading
from collections import deque, Counter, OrderedDict, defaultdict
from heapq import *
from fractions import Fraction

def ii():
	return int(input())

def si():
	return str(input())

def mi():
	return map(int, input().split())

def li():
	return list(mi())

def fii():
	return int(stdin.readline())

def fsi():
	return str(stdin.readline())

def fmi():
	return map(int, stdin.readline().split())

def fli():
	return list(fmi())
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}

def getKey(item):
	return item[0]

def sort2(l):
	return sorted(l, key=getKey)

def d2(n, m, num):
	return [[num for x in range(m)] for y in range(n)]

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def ntl(n):
	return [int(i) for i in str(n)]

def powerMod(x, y, p):
	res = 1
	x %= p
	while y > 0:
		if y & 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res
graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000

def bfs(d, v):
	q = []
	q.append(v)
	visited[v] = 1
	while len(q) != 0:
		x = q[0]
		q.pop(0)
		for i in d[x]:
			if visited[i] != 1:
				visited[i] = 1
				q.append(i)
		print(x)

def make_graph(e):
	d = {}
	for i in range(e):
		(x, y, z) = mi()
		if x not in d:
			d[x] = [[z, y]]
		else:
			d[x].append([z, y])
		if y not in d:
			d[y] = [[z, x]]
		else:
			d[y].append([z, x])
	return d

def gr2(n):
	d = defaultdict(list)
	for i in range(n):
		(x, y) = mi()
		d[x].append(y)
	return d

def connected_components(graph):
	seen = set()

	def dfs(v):
		vs = set([v])
		component = []
		while vs:
			v = vs.pop()
			seen.add(v)
			vs |= set(graph[v]) - seen
			component.append(v)
		return component
	ans = []
	for v in graph:
		if v not in seen:
			d = dfs(v)
			ans.append(d)
	return ans

def primeFactors(n):
	s = set()
	while n % 2 == 0:
		s.add(2)
		n = n // 2
	for i in range(3, int(sqrt(n)) + 1, 2):
		while n % i == 0:
			s.add(i)
			n = n // i
	if n > 2:
		s.add(n)
	return s

def find_all(a_str, sub):
	start = 0
	while True:
		start = a_str.find(sub, start)
		if start == -1:
			return
		yield start
		start += len(sub)

def SieveOfEratosthenes(n, isPrime):
	isPrime[0] = isPrime[1] = False
	for i in range(2, n):
		isPrime[i] = True
	p = 2
	while p * p <= n:
		if isPrime[p] == True:
			i = p * p
			while i <= n:
				isPrime[i] = False
				i += p
		p += 1
	return isPrime

def dijkstra(edges, f, t):
	g = defaultdict(list)
	for (l, r, c) in edges:
		g[l].append((c, r))
	(q, seen, mins) = ([(0, f, ())], set(), {f: 0})
	while q:
		(cost, v1, path) = heappop(q)
		if v1 not in seen:
			seen.add(v1)
			path = (v1, path)
			if v1 == t:
				return (cost, path)
			for (c, v2) in g.get(v1, ()):
				if v2 in seen:
					continue
				prev = mins.get(v2, None)
				next = cost + c
				if prev is None or next < prev:
					mins[v2] = next
					heappush(q, (next, v2, path))
	return float('inf')
t = ii()
for a0 in range(t):
	n = ii()
	l = li()
	s = sum(l)
	print(ceil(s / n))


ilist = lambda : list(map(int, input().split()))
import math
nb_q = int(input())
for i in range(nb_q):
	input()
	items = ilist()
	print(math.ceil(sum(items) / len(items)))


import math
q = int(input())
for _ in range(q):
	n = int(input())
	a = [int(x) for x in input().split()]
	total = sum(a)
	print(math.ceil(total / n))


def ab():
	b = int(input())
	sum = 0
	c = list(map(int, input().split()))
	for i in range(0, len(c)):
		sum = sum + c[i]
	while sum % b != 0:
		sum = sum + 1
	print(int(sum / b))
a = int(input())
for i in range(0, a):
	ab()


n = int(input())
for i in range(n):
	k = int(input())
	S = [int(i) for i in input().split()]
	summ = 0
	for j in S:
		summ += j
	if summ % k == 0:
		print(summ // k)
	else:
		print(summ // k + 1)


for _ in range(int(input())):
	t = int(input())
	a = [int(s) for s in input().split()]
	s = sum(a)
	if s % t == 0:
		print(s // t)
	else:
		print(s // t + 1)


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


import math
from math import gcd
from collections import defaultdict, deque
from sys import stdin, stdout
from bisect import bisect_left, bisect_right
from copy import deepcopy
int_input = lambda : int(stdin.readline())
string_input = lambda : stdin.readline()
multi_input = lambda : map(int, stdin.readline().split())
list_input = lambda : list(map(int, stdin.readline().split()))
string_list_input = lambda : list(string_input())
MOD = pow(10, 9) + 7
test = int_input()
for _ in range(test):
	n = int_input()
	cost = list_input()
	average = 0
	for i in cost:
		average += i
	average = average / n
	average = math.ceil(average)
	print(int(average))


import math
cases = int(input())
for _ in range(cases):
	input()
	all_prices = list(map(int, input().split()))
	new_price = math.ceil(sum(all_prices) / len(all_prices))
	print(new_price)


from math import ceil
q = int(input())
ans = []
for i in range(q):
	n = int(input())
	a = list(map(int, input().split(' ')))[0:n]
	ans.append(ceil(sum(a) / n))
for i in ans:
	print(i)


n = int(input())
for t in range(n):
	l = int(input())
	L = input().split()
	s = 0
	k = 0
	for i in range(l):
		L[i] = int(L[i])
		s += L[i]
	if s % l == 0:
		k = s // l
	else:
		k = s // l + 1
	print(k)


for i in range(int(input())):
	a = int(input())
	b = list(map(int, input().split()))
	ans = -(-sum(b) // a)
	print(ans)


for i in range(int(input())):
	z = int(input())
	l = list(map(int, input().split()))
	q = sum(l) // z
	if sum(l) % z == 0:
		print(q)
	else:
		print(q + 1)


t = int(input())
while t != 0:
	a = int(input())
	b = list(map(int, input().split(' ')))
	c = sum(b)
	d = c // a
	if c % a > 0:
		print(d + 1)
	else:
		print(d)
	t = t - 1


q = int(input())
for _ in range(0, q):
	n = int(input())
	a = list(map(int, input().split()))
	sum = 0
	for i in range(0, n):
		sum += a[i]
	ans = sum // n
	if sum % n != 0:
		ans += 1
	print(ans)


for t in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	d = sum(a)
	av = d // n
	if av * n >= d:
		print(av)
	else:
		print(av + 1)


n = int(input())
for i in range(n):
	k = int(input())
	l = list(map(int, input().split()))
	l.sort()
	s = 0
	for j in l:
		s += j
	if s % k == 0:
		print(int(s / k))
	else:
		print(int(s / k + 1))


import math

def main():
	a = int(input())
	for i in range(a):
		size = int(input())
		data = list(map(int, input().split()))
		total = sum(data)
		print(math.ceil(total / size))
main()


from sys import stdin
import math
for _ in range(int(stdin.readline())):
	n = int(stdin.readline())
	a = list(map(int, stdin.readline().rstrip().split()))
	avg = int(math.ceil(sum(a) / n))
	print(avg)


for i in range(int(input())):
	t = int(input())
	p = [int(x) for x in input().split()]
	k = sum(p)
	if k % t == 0:
		a = int(k / t)
	else:
		a = int(k / t) + 1
	print(a)


import math
Q = int(input())
for q in range(Q):
	n = int(input())
	arr = [int(x) for x in input().split()]
	print(int(math.ceil(sum(arr) / len(arr))))


from math import *
from sys import *
from heapq import *
from collections import defaultdict
import os, sys
from io import IOBase, BytesIO
M = 10 ** 9 + 7

def pow(a, b):
	res = 1
	while b > 0:
		if b & 1:
			res *= a
		a *= a
		b >>= 1
	return res

def powmod(a, b, m):
	res = 1
	while b > 0:
		if b & 1:
			res = res * a % m
		a *= a
		b >>= 1
	return res

def inv(a, m):
	return powmod(a, m - 2, m)

def alldivisors(n):
	list = []
	arr = []
	for i in range(1, int(sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				arr += [i]
			else:
				arr += [i]
				list.append(n // i)
	arr += list[::-1]
	return arr

def primefactorisation(n):
	potentional_p = 3
	itog_list = defaultdict(int)
	if n % 2 == 0:
		itog_list[2] = 0
	while n % 2 == 0:
		n = n // 2
		itog_list[2] += 1
	while n - 1:
		if potentional_p > n ** 0.5:
			itog_list[n] += 1
			return itog_list
		while n % potentional_p == 0:
			n = n // potentional_p
			itog_list[potentional_p] += 1
		potentional_p += 2
	return itog_list

def main():
	t = int(input())
	for _ in range(t):
		n = int(input())
		a = list(map(int, input().split()))
		print(ceil(sum(a) / n))
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


import math
q = eval(input())
temp = []
for i in range(q):
	n = eval(input())
	arr = list(map(int, input().split()))
	print(math.ceil(sum(arr) / float(n)))


t = int(input())
Ans = []
for i in range(0, t):
	n = int(input())
	A = list(map(int, input().split()))
	temp = sum(A) / n
	temp1 = round(temp)
	if temp1 > temp:
		Ans.append(temp1)
	elif temp == temp1:
		Ans.append(temp1)
	else:
		Ans.append(temp1 + 1)
for i in Ans:
	print(i)


import math
for t in range(int(input())):
	N = int(input())
	ls = list(map(int, input().split()))
	s = sum(ls)
	ans = math.ceil(s / N)
	ans = int(ans)
	print(ans)


import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log2, ceil
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
from bisect import insort
from collections import Counter
from collections import deque
from heapq import heappush, heappop, heapify
from itertools import permutations, combinations
from itertools import accumulate as ac
mod = int(1000000000.0) + 7
ip = lambda : int(stdin.readline())
inp = lambda : map(int, stdin.readline().split())
ips = lambda : stdin.readline().rstrip()
out = lambda x: stdout.write(str(x) + '\n')
t = ip()
for _ in range(t):
	n = ip()
	arr = list(inp())
	ans = sum(arr) / n
	ans = ceil(ans)
	print(ans)


q = int(input())
while q:
	n = int(input())
	a = input().split()
	for i in range(n):
		a[i] = int(a[i])
	if sum(a) % n == 0:
		print(sum(a) // n)
	else:
		print(sum(a) // n + 1)
	q -= 1


n = int(input(''))
SOL = []
for i in range(n):
	x = int(input(''))
	prices = list(map(int, input('').split()))
	total = sum(prices)
	if total % x == 0:
		SOL.append(int(total / x))
	else:
		SOL.append(int(total / x + 1))
for i in SOL:
	print(i)


q = int(input())
for i in range(q):
	n = int(input())
	a = list(map(int, input().split()))
	j = sum(a)
	ans = j // len(a)
	if j % len(a):
		ans += 1
	print(ans)


def main():
	Q = int(input())
	for query in range(Q):
		N = int(input())
		A = [int(i) for i in input().split()]
		sumA = sum(A)
		print(0 - -sumA // N)
main()


t = int(input())
for i in range(t):
	n = int(input())
	ls = [int(i) for i in input().split()]
	summ = sum(ls)
	res = int(summ / n)
	if res * n == summ:
		print(res)
	else:
		print(res + 1)


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


from collections import defaultdict as dc
import sys
import math
input = sys.stdin.readline
for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	s = sum(l)
	if s % n == 0:
		print(s // n)
	else:
		print(s // n + 1)


num_queries = int(input())
for i in range(num_queries):
	n = int(input())
	arr = input().split()
	sum = 0
	for i in range(len(arr)):
		arr[i] = int(arr[i])
		sum += arr[i]
	if sum % n == 0:
		delta = int(sum // n)
	else:
		delta = int(sum // n) + 1
	print(delta)


import math
q = int(input())
for _ in range(q):
	n = int(input())
	arr = [int(j) for j in input().split()]
	arr.sort()
	result = math.ceil(sum(arr) / n)
	print(result)


import math
import sys
input = sys.stdin.readline

def li():
	return [int(i) for i in input().rstrip('\n').split()]

def value():
	return int(input())
for _ in range(int(input())):
	n = value()
	l = li()
	l = math.ceil(sum(l) / len(l))
	print(l)


Q = int(input())
for _ in range(Q):
	N = int(input())
	(*A,) = map(int, input().split())
	print((sum(A) + N - 1) // N)


import math
q = int(input())
i = 0
while i < q:
	n = int(input())
	a = input().split()
	summ = 0
	for j in a:
		summ += int(j)
	answer = math.ceil(summ / n)
	print(answer)
	i += 1


t = int(input())
for _ in range(t):
	(n, res) = (int(input()), 0)
	a = list(map(int, input().split()))
	for x in a:
		res += x
	print([res // n + 1, res // n][res // n * n == res])


for _ in range(int(input())):
	n = int(input())
	li = list(map(int, input().split()))
	k = sum(li) // n
	if k * n < sum(li):
		k += 1
	print(k)


import math
from collections import *
import sys
from functools import reduce

def get_ints():
	return map(int, input().strip().split())

def get_list():
	return list(get_ints())

def get_string():
	return list(input().strip().split())

def printxsp(*args):
	return print(*args, end='')

def printsp(*args):
	return print(*args, end=' ')
UGLYMOD = int(1000000000.0) + 7
SEXYMOD = 998244353
MAXN = int(100000.0)
for _testcases_ in range(int(input())):
	n = int(input())
	print((sum(get_list()) + n - 1) // n)


q = int(input())
for w in range(0, q):
	n = int(input())
	cost_elements = [-5 for i in range(n)]
	a = input().split()
	for i in range(0, n):
		cost_elements[i] = int(a[i])
	sum_cost = sum(cost_elements)
	ans = int(sum_cost / n)
	if ans * n == sum_cost:
		print(ans)
	else:
		print(ans + 1)


import sys
import os
from io import IOBase, BytesIO
import math

def get_array():
	return list(map(int, sys.stdin.readline().split()))
for j in range(int(input())):
	n = int(input())
	temp = get_array()
	tot = sum(temp)
	print(math.ceil(tot / n))


import math
for _ in range(int(input())):
	inp = int(input())
	l = sum(list(map(int, input().split())))
	print(math.ceil(l / inp))


import math

def dtb(n):
	return bin(n).replace('0b', '')

def btd(n):
	return int(n, 2)
t = int(input())
for k in range(t):
	n = int(input())
	a = list(map(int, input().split()))[:n]
	s = sum(a)
	ans = s // n
	if ans * n == s:
		print(ans)
	else:
		print(ans + 1)


import math
a = int(input())
for _ in range(a):
	n = int(input())
	b = list(map(int, input().split()))
	sum1 = 0
	for i in range(n):
		sum1 += b[i]
	print(math.ceil(sum1 / n))


from statistics import mean
import math
for i in range(int(input())):
	n = int(input())
	numbers = list(map(int, input().split()))
	print(math.ceil(mean(numbers)))


ll = lambda : list(map(int, input().split()))
testcases = 1
[testcases] = ll()
import math
for _ in range(testcases):
	[n] = ll()
	a = ll()
	print(math.ceil(sum(a) / n))


from sys import stdin

def main():
	input = lambda : stdin.readline()[:-1]
	Q = int(input())
	for _ in [0] * Q:
		N = int(input())
		A = list(map(int, input().split()))
		ans = (sum(A) + (N - 1)) // N
		print(ans)
main()


import math

def find_total_no_of_items(string):
	sum = 0
	for i in string.split(' '):
		sum = sum + int(i)
	return sum
no_of_testcases = int(input())
for i in range(no_of_testcases):
	n = int(input())
	sum_of_goods = find_total_no_of_items(input())
	print(math.ceil(sum_of_goods / n))


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
mod2 = 998244353
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def main():
	t = I()
	rr = []
	for _ in range(t):
		n = I()
		a = LI()
		rr.append((sum(a) + n - 1) // n)
	return JA(rr, '\n')
print(main())


a = int(input())
for i in range(a):
	b = int(input())
	sumr = 0
	c = list(map(int, input().split()))
	for i in c:
		sumr = sumr + i
	cost = sumr / b
	if sumr % b == 0:
		print(int(cost))
	else:
		print(int(cost) + 1)


import math
for __ in range(int(input())):
	n = int(input())
	prices = list(map(int, input().split()))
	sum = 0
	for ele in prices:
		sum = sum + ele
	min = 0
	min = int(math.ceil(sum / n))
	print(min)


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


n = int(input())
for _ in range(n):
	input()
	a = [int(x) for x in input().split()]
	t = int(sum(a) / len(a))
	if t * len(a) < sum(a):
		t += 1
	print(t)


import sys

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))
for i in range(int(input())):
	n = int(input())
	ar = get_list()
	summ = sum(ar)
	ans = divmod(summ, n)
	if ans[1] == 0:
		print(ans[0])
	else:
		print(ans[0] + 1)


from math import ceil
n = int(input())
for i in range(n):
	k = int(input())
	arr = [int(i) for i in input().split(' ')]
	sum = 0
	for j in arr:
		sum += j
	print(ceil(sum / k))


from math import *

def ri():
	return int(input())

def rli():
	return list(map(int, input().split()))
q = ri()
for _ in range(q):
	n = ri()
	a = rli()
	p = int(ceil(sum(a) / n))
	print(p)


__author__ = 'Esfandiar'
from math import ceil, sqrt
for i in range(int(input())):
	n = int(input())
	a = sum(list(map(int, input().split())))
	print(ceil(a / n))


t = int(input())
for cases in range(t):
	n = int(input())
	nums = list(map(int, input().split()))
	s = sum(nums)
	s = -(-s // n)
	print(s)


import math
result = []
for i in range(int(input())):
	total = 0
	div = int(input())
	string = input()
	prices = [int(x) for x in string.split()]
	for i in prices:
		total += i
	result.append(total / div)
	prices.clear()
for i in result:
	print(math.ceil(i))


num = int(input())
b = 0
while num:
	size = int(input())
	arr = list(map(int, input().split()))
	v = sum(arr)
	b = v / size
	if b % int(b) != 0:
		b = b + 1
	print(int(b))
	num -= 1


n = int(input())
while n:
	input()
	l = list(map(int, input().split()))
	v = int(round(sum(l) / len(l)))
	print(v + 1 if v * len(l) < sum(l) else v)
	n -= 1


import math
test = int(input())
while test:
	n = int(input())
	sum = 0
	prices = list(map(int, input().split()))
	for i in prices:
		sum += i
	price_new = math.ceil(sum / n)
	print(price_new, '\n')
	test -= 1


t = int(input())
for _ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	x = sum(l)
	y = x // n
	if y * n >= x:
		print(y)
	else:
		print(y + 1)


def solve():
	q = eval(input())
	while q > 0:
		q -= 1
		n = eval(input())
		s_a = input()
		a = [eval(x) for x in s_a.split()]
		Sum = 0
		for item in a:
			Sum += item
		res = Sum // n
		if Sum % n != 0:
			res += 1
		print(res)
solve()


import math
for _ in range(int(input())):
	n = int(input())
	A = [int(i) for i in input().split()]
	avg = math.ceil(sum(A) / n)
	print(avg)


import math
tc = input()
for t in range(0, int(tc)):
	n = input()
	price = input().split()
	total = 0
	for i in price:
		total += int(i)
	print(math.ceil(total / int(n)))


import math
t = int(input())
goods = []
price = []
for x in range(t):
	goods.append(int(input()))
	price.append(list(map(int, input().split(None, goods[x])[:goods[x]])))
	sum = 0
	for y in range(goods[x]):
		sum += price[x][y]
	print(math.ceil(sum / goods[x]))


n = int(input())
for i in range(n):
	t = int(input())
	a = list(map(int, input().split()))
	avg = sum(a) // t
	if abs(avg) * t < sum(a):
		print(int(abs(avg) + 1))
	else:
		print(int(abs(avg)))


q = int(input())
for i in range(q):
	n = int(input())
	ai = list(map(int, input().split()))
	print(sum(ai) // n + (sum(ai) % n != 0))


import math
t = int(input())
for _t in range(t):
	n = int(input())
	li = [int(x) for x in input().strip().split()]
	s = 0
	for x in li:
		s += x
	print(math.ceil(s / n))


import math
q = int(input())
for qq in range(q):
	n = int(input())
	l = list(map(int, input().split()))
	r = math.ceil(sum(l) / len(l))
	print(r)


q = int(input())
for w in range(0, q):
	n = int(input())
	e = list(map(int, input().split()))
	s = sum(e)
	f = s // n
	while f * n < s:
		f += 1
	print(f)


n = int(input())
for _ in range(n):
	a = int(input())
	li = list(map(int, input().split()))
	result = sum(li)
	result1 = result // a
	if result % a != 0:
		print(result1 + 1)
	else:
		print(result1)


from math import ceil
Q = int(input())
for _ in range(Q):
	N = int(input())
	sk = [int(x) for x in input().split()]
	price = int(ceil(sum(sk) / N))
	print(price)


import sys
q = int(sys.stdin.readline())
for _ in range(q):
	n = int(sys.stdin.readline())
	nums = list(map(int, sys.stdin.readline().split()))
	total = sum(nums)
	avg = total // n
	if avg * n == total:
		print(avg)
	else:
		print(avg + 1)


import math as m
q = int(input())
for i in range(q):
	temp = int(input())
	a = list(map(int, input().split()))
	print(m.ceil(sum(a) / temp))


i = lambda : sum(map(int, input().split()))
for _ in [0] * i():
	n = i()
	print(-(-i() // n))


import math
t = int(input())
for _ in range(t):
	n = int(input())
	l = [int(i) for i in input().split()]
	print(math.ceil(1.0 * sum(l) / n))


x = input()
outputarr = []
for a in range(0, int(x)):
	y = input()
	z = input()
	z = z.split()
	for e in range(0, len(z)):
		z[e] = int(z[e])
	s = sum(z)
	avg = s / len(z)
	if avg > int(avg):
		avg = int(avg) + 1
	outputarr.append(int(avg))
for each in outputarr:
	print(each)


for y in range(int(input())):
	n = int(input())
	lst = list(map(int, input().split()))
	if sum(lst) % n == 0:
		print(int(sum(lst) // n))
	else:
		print(int(sum(lst) // n) + 1)


import math
for _ in range(int(input())):
	n = int(input())
	arr = map(int, input().strip().split())
	print(math.ceil(sum(arr) / n))


q = int(input())
for i in range(q):
	n = int(input())
	x = sum(map(int, input().split())) / n
	print(int(x) if x == int(x) else int(x) + 1)


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	mean = sum(a) // n
	if mean * n == sum(a):
		print(mean)
	elif mean * n < sum(a):
		print(mean + 1)
	elif mean * n > sum(a):
		print(mean - 1)


import math

class Magazine:

	def __init__(self, n, a):
		self.n = n
		self.a = a

	def result(self):
		return math.ceil(sum(a) / n)
q = int(input())
resultslist = list(range(q))
for i in range(q):
	n = int(input())
	a = [int(x) for x in input().split(' ')]
	t = Magazine(n, a)
	resultslist[i] = t.result()
for i in range(q):
	print(resultslist[i])


a = int(input())
for i in range(a):
	b = int(input())
	c = [int(c) for c in input().split()]
	l = sum(c)
	l1 = sum(c) / b
	if l1 == int(sum(c) / b):
		print(int(l1))
	else:
		print(int(sum(c) / b) + 1)


for _ in range(int(input())):
	n = int(input())
	a = [int(c) for c in input().split()]
	s = sum(a)
	r = round(s / n)
	if r * n < s:
		print(r + 1)
	else:
		print(r)


t = int(input())
for i in range(t):
	x = int(input())
	l1 = list(map(int, input().split()))
	print(sum(l1) // len(l1) + int(sum(l1) % len(l1) != 0))


import math
q = int(input())
result = []
for i in range(0, q):
	n = int(input())
	a = list(map(int, input().split()))
	total = sum(a)
	ans = math.ceil(total / n)
	result.append(ans)
for j in range(0, q):
	print(result[j])


q = int(input())
for i in range(q):
	n = int(input())
	a = input()
	a = a.split()
	rev = 0
	for i in a:
		rev += int(i)
	if rev % n == 0:
		print(rev // n)
	else:
		print(rev // n + 1)


import math
q = int(input())
while q > 0:
	n = int(input())
	l = list(map(int, input().split()))
	s = 0
	for i in l:
		s = s + i
	print(math.ceil(s / n))
	q = q - 1


import math
i = int(input())
result = []
while i:
	i -= 1
	n = input()
	s = input().split()
	result.append(math.ceil(float(sum(map(int, s))) / len(s)))
for i in result:
	print(i)


a = int(input())
l = []
for i in range(a):
	d = int(input())
	m = input().split(' ')
	j = 0
	for i in m:
		j = j + int(i)
	if j / d == j // d:
		l.append(j / d)
	else:
		l.append(j // d + 1)
for i in l:
	print(int(i))


tc = int(input())
for i in range(tc):
	lenn = input()
	arr = list(map(int, input().split(' ')))
	avg = sum(arr) / len(arr)
	if int(avg) == avg:
		print(int(avg))
	else:
		print(int(avg) + 1)


for i in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	c = sum(arr) / n
	if c == int(c):
		print(int(c))
	else:
		print(int(c) + 1)


import math
n = int(input())
for p in range(n):
	a = int(input())
	b = map(int, input().split())
	print(math.ceil(sum(b) / a))


import math
n = int(input())
k = 0
while k < n:
	ran = int(input())
	inn = input().split()
	num = []
	for i in inn:
		num.append(int(i))
	print(math.ceil(sum(num) / len(inn)))
	k += 1


q = int(input())
A = [-1] * 100
for i in range(q):
	k = 0
	n = int(input())
	t = [n for n in map(int, input().split())]
	for f in range(n):
		k += t[f]
	if k % n != 0:
		k = k // n + 1
	else:
		k = k // n
	A[i] = k
for i in range(q):
	print(A[i])


q = int(input())
for _ in range(q):
	n = int(input())
	a = list(map(int, input().split()))
	sum_a = sum(a)
	new_price = sum_a // n
	if sum_a % n != 0:
		new_price += 1
	print(new_price)


q = int(input())
for _ in range(q):
	n = int(input())
	a = [int(x) for x in input().split()]
	print((sum(a) + n - 1) // n)


q = int(input())
for _ in range(q):
	n = int(input())
	total = sum((int(x) for x in input().split()))
	if total % n != 0:
		total += n - total % n
	print(total // n)


n = int(input())
(k, I) = ([], [])
for i in range(n):
	l = int(input())
	k.append(l)
	x = [int(i) for i in input().split()]
	I.append(x)

def output(a, b):
	s = 0
	for i in b:
		s += i
	if s % a == 0:
		return s // a
	else:
		b[0] += 1
		return output(a, b)
for i in range(n):
	m = output(k[i], I[i])
	print(m)


import math
from decimal import Decimal
import heapq

def na():
	n = int(input())
	b = [int(x) for x in input().split()]
	return (n, b)

def nab():
	n = int(input())
	b = [int(x) for x in input().split()]
	c = [int(x) for x in input().split()]
	return (n, b, c)

def dv():
	(n, m) = map(int, input().split())
	return (n, m)

def dva():
	(n, m) = map(int, input().split())
	a = [int(x) for x in input().split()]
	b = [int(x) for x in input().split()]
	return (n, m, b)

def eratosthenes(n):
	sieve = list(range(n + 1))
	for i in sieve:
		if i > 1:
			for j in range(i + i, len(sieve), i):
				sieve[j] = 0
	return sorted(set(sieve))

def lol(lst, k):
	k = k % len(lst)
	ret = [0] * len(lst)
	for i in range(len(lst)):
		if i + k < len(lst) and i + k >= 0:
			ret[i] = lst[i + k]
		if i + k >= len(lst):
			ret[i] = lst[i + k - len(lst)]
		if i + k < 0:
			ret[i] = lst[i + k + len(lst)]
	return ret

def nm():
	n = int(input())
	b = [int(x) for x in input().split()]
	m = int(input())
	c = [int(x) for x in input().split()]
	return (n, b, m, c)

def dvs():
	n = int(input())
	m = int(input())
	return (n, m)

def Factor(n):
	Ans = []
	d = 2
	while d * d <= n:
		if n % d == 0:
			Ans.append(d)
			n //= d
		else:
			d += 1
	if n > 1:
		Ans.append(n)
	return Ans
q = int(input())
for i in range(q):
	(n, a) = na()
	print(math.ceil(sum(a) / n))


q = int(input())
for _ in range(q):
	n = int(input())
	a = [int(t) for t in input().split(' ')]
	s = sum(a)
	r = s // n
	if s % n != 0:
		r += 1
	print(r)


import sys
import os
from io import IOBase, BytesIO
import math
mod = 10 ** 9 + 7
pie = 3.1415926536

def modinv(n, p):
	return pow(n, p - 2, p)

def ncr(n, r, p):
	t = fact[n] * (ifact[r] * ifact[n - r] % p) % p
	return t

def ain():
	return list(map(int, sin().split()))

def sin():
	return input().strip()

def GCD(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def read2DIntArray(row, col):
	arr = []
	for i in range(0, row):
		temp = list(map(int, sin().split()))
		arr.append(temp)
	return arr

def read2DCharArray(row, col):
	arr = []
	for i in range(0, row):
		temp = str(sin())
		arr.append(temp)
	return arr

def smallestNumber(n):
	lst = list(str(n))
	lst.sort()
	tmp = ''
	for (i, n) in enumerate(lst):
		if n != '0':
			tmp = lst.pop(i)
			break
	return str(tmp) + ''.join(lst)

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 1
	prime[0] = False
	prime[1] = False
	lst = []
	for p in range(n + 1):
		if prime[p]:
			lst.append(p)
	return lst

def nCr(n, r):
	a = 1
	b = 1
	c = 1
	for i in range(1, n + 1):
		c *= i
	for i in range(1, r + 1):
		b *= i
	for i in range(1, n - r + 1):
		a *= i
	return c // (a * b)

def sieveOfEratosthenes1(N, s):
	prime = [False] * (N + 1)
	for i in range(2, N + 1, 2):
		s[i] = 2
	for i in range(3, N + 1, 2):
		if prime[i] == False:
			s[i] = i
			for j in range(i, int(N / i) + 1, 2):
				if prime[i * j] == False:
					prime[i * j] = True
					s[i * j] = i

def generatePrimeFactors(N):
	s = [0] * (N + 1)
	sieveOfEratosthenes1(N, s)
	curr = s[N]
	cnt = 1
	factors = []
	power = []
	while N > 1:
		N //= s[N]
		if curr == s[N]:
			cnt += 1
			continue
		factors.append(curr)
		power.append(cnt)
		curr = s[N]
		cnt = 1
	return (factors, power)

def main():
	for _ in range(int(sin())):
		n = int(sin())
		a = ain()
		ans = sum(a) / n
		if ans == int(ans):
			ans = int(ans)
		else:
			ans = int(ans) + 1
		print(ans)
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			self.write = lambda s: self.buffer.write(s.encode('ascii'))
			self.read = lambda : self.buffer.read().decode('ascii')
			self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def input():
	return sys.stdin.readline().rstrip('\r\n')
main()


from math import ceil

def getEqualizedPrice(priceArr, length):
	avg = sum(priceArr) / length
	return ceil(avg)

def main():
	for _ in range(int(input())):
		length = int(input().strip())
		priceArr = [int(x) for x in input().strip().split()]
		print(getEqualizedPrice(priceArr, length))
main()


from math import ceil
t = int(input())
for i in range(t):
	g = int(input())
	lista = [int(i) for i in input().split()]
	print(ceil(sum(lista) / g))


w = int(input())
a = []
for i in range(0, w):
	t = int(input())
	p = input().split()
	a.append(p)
for i in range(0, w):
	r = a[i]
	s = 0
	for j in range(len(r)):
		s += int(r[j])
	if s % len(r) == 0:
		u = int(s / len(r))
		print(u)
	else:
		u = int(s / len(r)) + 1
		print(u)


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


n = int(input())
for i in range(n):
	s = int(input())
	x = list(map(int, input().split()))
	c = 0
	for i in x:
		c += i
	(f, d) = (c / s, c // s)
	if f % d != 0:
		d += 1
	print(d)


q = int(input())
for i in range(0, q):
	n = int(input())
	a = [int(val) for val in input().split()]
	s = sum(a)
	avg = s // n
	if avg * n < s:
		avg += 1
	print(avg)


case = int(input())
for i in range(case):
	n = int(input())
	list1 = [int(v) for v in input().split()]
	if sum(list1) % n == 0:
		print(sum(list1) // n)
	else:
		print(sum(list1) // n + 1)


from math import *
q = int(input())
for i in range(0, q):
	n = int(input())
	s = 0
	x = map(int, input().split())
	for j in x:
		s = s + j
	m = ceil(s / n)
	print(m)


q = int(input())
for _ in range(q):
	n = int(input())
	L = sum(list(map(int, input().split())))
	x = L // n
	if x * n >= L:
		print(x)
	else:
		print(x + 1)


import math
q = int(input())

def solve():
	n = int(input())
	a = [int(x) for x in input().split()]
	print(int(math.ceil(sum(a) / n)))
for _ in range(q):
	solve()


import math
n = int(input())
for i in range(n):
	j = int(input())
	a = list(map(int, input().split(' ')))
	s = sum(a)
	ans = math.ceil(s / len(a))
	print(ans)


import math
q = int(input())
for _ in range(q):
	n = int(input())
	a = list(map(int, input().rstrip().split()))
	c = sum(a) / n
	if c == math.floor(c):
		c = int(c)
	else:
		c = int(c) + 1
	print(c)


for _ in range(int(input())):
	n = int(input())
	data = list(map(int, input().split()))
	ans = int(-(-(sum(data) / n) // 1))
	print(ans)


t = int(input())
while t > 0:
	t -= 1
	n = int(input())
	arr = list(map(int, input().split()))
	sum1 = 0
	for item in arr:
		sum1 += item
	if sum1 % n == 0:
		print(sum1 // n)
	else:
		print(sum1 // n + 1)


import math
n = int(input())
for i in range(n):
	m = int(input())
	mean = 0
	x = list(map(int, input().split()))
	for j in range(m):
		mean += x[j]
	mean = math.ceil(mean / m)
	print(mean)


test = int(input())
for counter in range(test):
	n = int(input())
	array = list(map(int, input().strip().split()))
	total = sum(array)
	min1 = total // n
	if n * min1 == total:
		print(min1)
	else:
		print(min1 + 1)


import math
t = int(input())
for test in range(t):
	n = int(input())
	goods = [int(x) for x in input().split()]
	x = sum(goods)
	if x % n == 0:
		print(x // n)
	else:
		print(int(math.ceil(x / n)))


import math
test = int(input())
while test > 0:
	test -= 1
	x = int(input())
	lis = list(map(int, input().split()))
	y = sum(lis) / x
	print(math.ceil(y))


q = int(input())
n = []
a = []
for i in range(q):
	n.append(int(input()))
	a.append([int(x) for x in input().split()])
for i in range(q):
	print(int((sum(a[i]) + n[i] - 1) / n[i]))


a = int(input())
count = 0
while count < a:
	b = int(input())
	c = list(map(int, input().split()))
	sum1 = 0
	sum1 = sum(c)
	m = max(c)
	d = round(sum1 / b)
	while d * b < sum1:
		d = d + 1
	print(d)
	count += 1


from math import ceil
t = int(input())
for _ in range(0, t):
	n = int(input())
	aa = sum([int(i) for i in input().split()])
	print(ceil(aa / n))


from math import ceil

def find_average(n, arr):
	res = ceil(sum(arr) / n)
	return res
q = int(input())
for i in range(q):
	n = int(input())
	arr = list(map(int, input().split()))
	print(find_average(n, arr))


import sys
input = lambda : sys.stdin.readline().rstrip('\r\n')
from math import ceil
for _ in range(int(input())):
	n = int(input())
	s = sum([int(x) for x in input().split()])
	print(ceil(s / n))


import math
t = int(input())
for i in range(t):
	lst = []
	num = int(input())
	ar = list(map(int, input().strip().split(' ')))
	s = sum(ar)
	avg = math.ceil(s / num)
	print(avg)


def solve():
	n = int(input())
	a = list(map(int, input().split()))
	s = sum(a)
	print((s + n - 1) // n)

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


import math
t = int(input())
for x in range(t):
	a = int(input())
	b = list(map(int, input().split()))
	c = sum(b)
	print(math.ceil(c / a))


q = int(input())
while q > 0:
	q = q - 1
	n = int(input())
	x = list(map(int, input().split()))
	flag = 0
	a = sum(x)
	a = a / n
	if a == int(a):
		print(int(a))
	else:
		print(int(a) + 1)


from sys import stdin
import math
import functools
q = int(stdin.readline().strip())
for _ in range(q):
	n = int(stdin.readline().strip())
	arr = [int(x) for x in stdin.readline().strip().split(' ')]
	res = math.ceil(functools.reduce(lambda a, b: a + b, arr) / n)
	print(res)


(S, R) = (0, '')
for i in range(int(input())):
	X = int(input())
	L = list(map(int, input().split()))
	S = sum(L)
	if S % X == 0:
		R += str(int(S / X)) + '\n'
	else:
		while S % X != 0:
			S += 1
		R += str(int(S / X)) + '\n'
print(R)


from math import ceil
for _ in range(int(input())):
	divisor = int(input())
	sumi = sum(list(map(int, input().split())))
	print(ceil(sumi / divisor))


import math as m
q = int(input())
for i in range(q):
	n = int(input())
	print(m.ceil(sum([int(x) for x in input().split()]) / n))


import math
q = int(input())
for i in range(q):
	_ = input()
	seq = list(map(int, input().split(' ')))
	print(math.ceil(sum(seq) / len(seq)))