#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MX = 2e5 + 5;
template <class T>
bool ckmin(T &a, const T &b) {
  return a > b ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T &a, const T &b) {
  return a < b ? a = b, 1 : 0;
}
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
constexpr auto hasBegin(int) -> decltype(std::begin(std::declval<T>()), true) {
  return true;
}
constexpr bool hasBegin(...) { return false; }
template <typename T>
using IsContainer = std::integral_constant<bool, hasBegin<T>(0)>;
template <typename T>
std::istream &operator>>(std::istream &is, std::vector<T> &vec) {
  for (T &element : vec) {
    is >> element;
  }
  return is;
}
template <typename T, typename U>
std::istream &operator>>(std::istream &is, std::pair<T, U> &p) {
  is >> p.first;
  is >> p.second;
  return is;
}
template <class X, class Y>
std::ostream &operator<<(std::ostream &os, std::pair<X, Y> const &p) {
  return os << p.first << " " << p.second;
}
template <class Ch, class Tr, class Container>
std::basic_ostream<Ch, Tr> &operator<<(std::basic_ostream<Ch, Tr> &os,
                                       Container const &x) {
  bool first = true;
  for (auto &y : x) {
    if (first) {
      first = false;
    } else {
      os << " ";
    }
    os << y;
  }
  return os;
}
using namespace std;
class CColorfulLeaderboard {
 public:
  void solve(std::istream &in, std::ostream &out) {
    int n;
    in >> n;
    vector<int> A(n);
    in >> A;
    vector<int> counter(9);
    for (auto &x : A) {
      counter[min(8, x / 400)]++;
    }
    int mini = 0;
    for (int i = (0); i < (8); ++i) {
      if (counter[i]) {
        mini++;
      }
    }
    int maxi = mini + counter[8];
    out << mini << ' ' << maxi << '\n';
  }
  void setup() {}
};
int main() {
  std::ios_base::sync_with_stdio(false);
  CColorfulLeaderboard solver;
  solver.setup();
  std::istream &in(std::cin);
  std::ostream &out(std::cout);
  in.tie(nullptr);
  out << std::fixed;
  out.precision(20);
  solver.solve(in, out);
  return 0;
}
