output_description: Print N integers. The t-th (1 \le t \le N) of them should be the answer for
  the case K=t.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      A_1 A_2 \ldots A_N
attempt: import math
  import os
  import sys
  
  import numpy as np
  
  if os.getenv("LOCAL"):
      sys.stdin = open("_in.txt", "r")
  
  sys.setrecursionlimit(2147483647)
  INF = float("inf")
  IINF = 10**18
  MOD = 10**9 + 7
  
  
  def get_primes(max=None, count=None):
      """
      素数列挙
      昇順にソートされています
      https://qiita.com/Ishotihadus/items/73e107271275611f05f2
      :param int max:
      :param int count:
      :return:
      """
      assert max or count
      if count:
          raise NotImplementedError()
      if max <= 1:
          return []
  
      primes = [2]
      sieve = [False for _ in range(max + 1)]
      p = 3
      while p <= max:
          primes.append(p)
          sieve[p] = True
          if p <= math.sqrt(max):
              for i in range(p * (p | 1), max + 1, p * 2):
                  sieve[i] = True
          while p <= max and sieve[p]:
              p += 2
  
      return primes
  
  
  N = int(sys.stdin.readline())
  A = list(map(int, sys.stdin.readline().split()))
  
  primes = get_primes(max=N)
  
  
  def count(k):
      if memo[k]:
          bc, ret = memo[k]
      else:
          bc = np.bincount(A)
          bc.sort()
          bc = bc[np.searchsorted(bc, 1) :]
          bc = bc[::-1]
          ret = 0
  
      while len(bc) >= k:
          bc[:k] -= 1
          bc.sort()
          bc = bc[np.searchsorted(bc, 1) :]
          bc = bc[::-1]
          ret += 1
      for p in primes:
          if p >= k:
              break
          if k % p == 0:
              memo[k // p] = bc, ret * (k // p)
              break
      return ret
  
  
  ans = [0] * N
  memo = [None for _ in range(N + 1)]
  for k in reversed(range(1, N + 1)):
      ans[k - 1] = count(k)
  print(*ans, sep="\n")
  
problem_description: Statement
  
  Takahashi has N cards. The i-th of these cards has an integer A_i written on
  it.
  
  Takahashi will choose an integer K, and then repeat the following operation
  some number of times:
  
    * Choose exactly K cards such that the integers written on them are all different, and eat those cards. (The eaten cards disappear.)
  
  For each K = 1,2, \ldots, N, find the maximum number of times Takahashi can do
  the operation.
samples: [{"input": "3\n    2 1 2", "output": "3\n    1\n    0\n    \n\nFor K = 1, we can do the operation as follows:\n\n  * Choose the first card to eat.\n  * Choose the second card to eat.\n  * Choose the third card to eat.\n\nFor K = 2, we can do the operation as follows:\n\n  * Choose the first and second cards to eat.\n\nFor K = 3, we cannot do the operation at all. Note that we cannot choose the\nfirst and third cards at the same time.\n\n* * *"}, {"input": "5\n    1 2 3 4 5", "output": "5\n    2\n    1\n    1\n    1\n    \n\n* * *"}, {"input": "4\n    1 3 3 3", "output": "4\n    1\n    0\n    0"}]