There are n boxes with colored balls on the table. Colors are numbered from 1 to n. i-th box contains a_{i} balls, all of which have color i. You have to write a program that will divide all balls into sets such that:  each ball belongs to exactly one of the sets,  there are no empty sets,  there is no set containing two (or more) balls of different colors (each set contains only balls of one color),  there are no two sets such that the difference between their sizes is greater than 1. 

Print the minimum possible number of sets.


-----Input-----

The first line contains one integer number n (1 ≤ n ≤ 500).

The second line contains n integer numbers a_1, a_2, ... , a_{n} (1 ≤ a_{i} ≤ 10^9).


-----Output-----

Print one integer number — the minimum possible number of sets.


-----Examples-----
Input
3
4 7 8

Output
5

Input
2
2 7

Output
4



-----Note-----

In the first example the balls can be divided into sets like that: one set with 4 balls of the first color, two sets with 3 and 4 balls, respectively, of the second color, and two sets with 4 balls of the third color.

Difficulty: interview

Starter code:

Solutions:
# -*- coding: utf-8 -*-
"""
Created on Sun Apr  2 22:42:34 2017

@author: Sean38
"""

n = int(input().rstrip())
s = input()
a = [int(ch) for ch in s.split()]
a = a[0:n]
a.sort()

def check_num(p, i):

    # i = ap + b(p+1)
    # min(a+b) <=> max(b)
    # b(p+1) <= i
    # b == i (mod p)
    max_b = (i // (p + 1))
    b = i % p + ((max_b - i % p) // p) * p
    # cur = a + b
    cur = (i - b) // p

    #print(cur - b, b, p)
    if b < 0:
        return None
    return cur

def sets_num(p):
    
    total = 0
    for i in a:
        if check_num(p, i):
            total += check_num(p, i)
        else:
            return None
    return total

for div_sets in range(1, a[0] + 1):
    p, q = divmod(a[0], div_sets)
    if (q == 0):
        if sets_num(p):
            print(sets_num(p))
            break
        if (p > 0) and sets_num(p - 1):
            print(sets_num(p - 1))
            break
    else:
        if sets_num(p):
            print(sets_num(p))
            break

from math import sqrt

def divide_into_p(p, a):
    q = a // (p+1)
    r = a % (p+1)
    if r == 0:
        return q
    elif q + r >= p:
        return q+1
    else:
        return None

def divisible_into_p(p, lst):
    lgth = 0
    for l in lst:
        dp = divide_into_p(p, l)
        if dp == None:
            return None
        else:
            lgth += dp
    return lgth

def index_lst(a,sqrta):
    lst = []
    for i in range(1, sqrta + 1):
        p = a//i
        lst.append(p)
        if not a%p:
            lst.append(p-1)
    for i in range(sqrta+1,0,-1):
        lst.append(i)
    return lst

def check_all_p(balls):
    a = balls[0]
    sqrt_a = int(sqrt(a))
    indices = index_lst(a,sqrt_a)
    for i in indices:
        dp = divisible_into_p(i, balls)
        if dp != None:
            return dp
    
        
input()
balls = sorted([int(x) for x in input().split()])

print(check_all_p(balls))



# Returns the number of coins that is necessary for paying the amount
# with the two types of coins that have value of coin and coin + 1
def pay(coin, amount):
    if amount // coin < amount % coin:
        return -1;
    if amount < coin * (coin + 1):
        return amount // coin
    return (amount - 1) // (coin + 1) + 1;

def pay_all(coin):
    sum = 0
    for i in range(n):
        p = pay(coin, a[i])
        if p == -1:
            return -1
        sum += p
    return sum

n = int(input())
a = list(map(int, input().split()))
amin = min(a)
coin = amin
k = 1
p = -1
while p == -1:
    p = pay_all(coin)
    if p == -1 and amin % coin == 0:
        p = pay_all(coin - 1)
    k += 1
    coin = amin // k
print(p)

3
import sys

n = int(sys.stdin.readline())
a = [int(x) for x in sys.stdin.readline().split()]

def is_valid(s, k):
    # Ali lahko zapakiramo s steklenic v škatle velikosti k in k + 1?
    # s = x * k + y * (k + 1) = (x + y) * k + y, kjer je 0 <= y < k
    y = s % k
    return s // k >= y

def all_valid(a, k):
    for s in a:
        if not is_valid(s, k):
            return False
    return True

best_sol = 1

k = 1
while k*k <= a[0]:
    if all_valid(a, k):
        best_sol = max(best_sol, k)
    k += 1

# t je skupno število škatel.
t = 1
while t*t <= a[0]:
    k = a[0] // t
    if all_valid(a, k):
        best_sol = max(best_sol, k)
    if a[0] % t == 0 and k > 1:
        if all_valid(a, k - 1):
            best_sol = max(best_sol, k - 1)
    t += 1

# print(best_sol, best_sol + 1)

print(sum(s // (best_sol + 1) + (0 if s % (best_sol + 1) == 0 else 1) for s in a))


def judge(lists, x):
    ans = 0
    for i in lists:
        t = i//x
        d = i%x
        if d == 0:
            ans += t
        elif t+d >= x-1:
            ans += t+1
        else:
            return -1

    return ans

while True:
    try:
        n = input()
        balls = list(map(int, input().split()))
        minn = min(balls)
        for i in range(1, minn+1):
            if judge(balls, minn//i + 1) >= 0:
                ans = judge(balls, minn//i + 1)
                break
            elif judge(balls, minn//i) >= 0:
                ans = judge(balls, minn//i)
                break
            
        print(ans)
    except EOFError:
        break



import time
import sys
from math import sqrt

n = int(input())
a = list(map(int, input().split()))

sq = int(sqrt(a[0]))+2
s = set()

for box in range(1, sq):
    if a[0] % box == 0:
        s.add(a[0] // box)
        s.add(a[0] // box - 1)
    else:
        s.add(a[0] // box)

for balls in range(1, sq):
    if a[0] % balls <= a[0] // balls:
        s.add(balls)


for size in sorted(s, reverse=True):
    ans = 0
    for x in a:
        if x / size >= x % size:
            ans += (x+size) // (size+1)
        else:
            break
    else:
        print(ans)
        return