output_description: Print the minimum possible number of different colors of the users, and the
  maximum possible number of different colors, with a space in between.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      a_1 a_2 ... a_N
attempt: import sys
  import heapq
  import re
  from itertools import permutations
  from bisect import bisect_left, bisect_right
  from collections import Counter, deque
  from fractions import gcd
  from math import factorial, sqrt
  from functools import lru_cache
  
  INF = 1 << 60
  mod = 1000000007
  sys.setrecursionlimit(10**7)
  input = sys.stdin.readline
  
  
  # UnionFind
  class UnionFind:
      def __init__(self, n):
          self.n = n
          self.parents = [-1] * n
  
      def find(self, x):
          if self.parents[x] < 0:
              return x
          else:
              self.parents[x] = self.find(self.parents[x])
              return self.parents[x]
  
      def union(self, x, y):
          x = self.find(x)
          y = self.find(y)
  
          if x == y:
              return
  
          if self.parents[x] > self.parents[y]:
              x, y = y, x
  
          self.parents[x] += self.parents[y]
          self.parents[y] = x
  
      def size(self, x):
          return -self.parents[self.find(x)]
  
      def same(self, x, y):
          return self.find(x) == self.find(y)
  
      def members(self, x):
          root = self.find(x)
          return [i for i in range(self.n) if self.find(i) == root]
  
      def roots(self):
          return [i for i, x in enumerate(self.parents) if x < 0]
  
      def group_count(self):
          return len(self.roots())
  
      def all_group_members(self):
          return {r: self.members(r) for r in self.roots()}
  
      def __str__(self):
          return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())
  
  
  # ダイクストラ
  def dijkstra_heap(s, edge, n):
      # 始点sから各頂点への最短距離
      d = [10**20] * n
      used = [True] * n  # True:未確定
      d[s] = 0
      used[s] = False
      edgelist = []
      for a, b in edge[s]:
          heapq.heappush(edgelist, a * (10**6) + b)
      while len(edgelist):
          minedge = heapq.heappop(edgelist)
          # まだ使われてない頂点の中から最小の距離のものを探す
          if not used[minedge % (10**6)]:
              continue
          v = minedge % (10**6)
          d[v] = minedge // (10**6)
          used[v] = False
          for e in edge[v]:
              if used[e[1]]:
                  heapq.heappush(edgelist, (e[0] + d[v]) * (10**6) + e[1])
      return d
  
  
  # 　素因数分解
  def factorization(n):
      arr = []
      temp = n
      for i in range(2, int(-(-(n**0.5) // 1)) + 1):
          if temp % i == 0:
              cnt = 0
              while temp % i == 0:
                  cnt += 1
                  temp //= i
              arr.append([i, cnt])
  
      if temp != 1:
          arr.append([temp, 1])
  
      if arr == []:
          arr.append([n, 1])
  
      return arr
  
  
  # ここから書き始める
  # Colorful Leaderboard
  n = int(input())
  a = list(map(int, input().split()))
  s = [0] * 8
  cnt = 0
  for i in a:
      if i < 3200:
          s[i // 400] = 1
      else:
          cnt += 1
  # print(s)
  maximum = sum(s) + cnt
  minimum = max(sum(s), 1)
  print(minimum, maximum)
  
  # @lru_cache(maxsize=1000)
  # def dfs(total, index):
  #     if index == n:
  #         if total % 10 != 0:
  #             return total
  #         return 0
  #     return max(dfs(total + s[index], index + 1), dfs(total, index + 1))
  
  # n = int(input())
  # s = [0] * n
  # for i in range(n):
  #     s[i] = int(input())
  # ans = dfs(0, 0)
  # print(ans)
  
problem_description: Statement
  
  In AtCoder, a person who has participated in a contest receives a _color_ ,
  which corresponds to the person's rating as follows:
  
    * Rating 1-399 : gray
    * Rating 400-799 : brown
    * Rating 800-1199 : green
    * Rating 1200-1599 : cyan
    * Rating 1600-1999 : blue
    * Rating 2000-2399 : yellow
    * Rating 2400-2799 : orange
    * Rating 2800-3199 : red
  
  Other than the above, a person whose rating is 3200 or higher can freely pick
  his/her color, which can be one of the eight colors above or not.  
  Currently, there are N users who have participated in a contest in AtCoder,
  and the i-th user has a rating of a_i.  
  Find the minimum and maximum possible numbers of different colors of the
  users.
samples: [{"input": "4\n    2100 2500 2700 2700", "output": "2 2\n    \n\nThe user with rating 2100 is \"yellow\", and the others are \"orange\". There are\ntwo different colors.\n\n* * *"}, {"input": "5\n    1100 1900 2800 3200 3200", "output": "3 5\n    \n\nThe user with rating 1100 is \"green\", the user with rating 1900 is blue and\nthe user with rating 2800 is \"red\".  \nIf the fourth user picks \"red\", and the fifth user picks \"blue\", there are\nthree different colors. This is one possible scenario for the minimum number\nof colors.  \nIf the fourth user picks \"purple\", and the fifth user picks \"black\", there are\nfive different colors. This is one possible scenario for the maximum number of\ncolors.\n\n* * *"}, {"input": "20\n    800 810 820 830 840 850 860 870 880 890 900 910 920 930 940 950 960 970 980 990", "output": "1 1\n    \n\nAll the users are \"green\", and thus there is one color."}]