use std::collections::HashMap;

fn main() {
    let n:usize = io::readln();
    let a:Vec<i32> = io::read_line().split_whitespace().map(|a| a.parse().unwrap()).collect::<Vec<i32>>().iter().map(|i| i/400).collect();
    let mut map:HashMap<i32, Vec<i32>> = HashMap::new();
    let (mut ans_min,mut ans_max) = (0, 0);
    for ai in a {
        map.entry(ai).or_insert(Vec::new()).push(ai);
    }

    let len = map.keys().len();
    ans_min += len;
    ans_max += len;
    if let Some(ais) = map.get(&8) {
        let len = ais.len() - 1;
        ans_min -= len;
        ans_max += len;
        
    }

    println!("{} {}",ans_min, ans_max);
}

pub mod io {
    use std::io;

    pub fn read_line() -> String {
        let mut s = String::new();
        io::stdin().read_line(&mut s).unwrap();
        s.trim_right().to_owned()
    }

    pub fn readln<T: Read>() -> T {
        let mut s = String::new();
        io::stdin().read_line(&mut s).unwrap();
        T::read(s.trim())
    }

    pub trait Read {
        fn read(s: &str) -> Self;
    }

    impl Read for String {
        fn read(s: &str) -> Self {
            s.to_string()
        }
    }

    impl<T: Read> Read for Vec<T> {
        fn read(s: &str) -> Self {
            s.split_whitespace().map(|w| T::read(w)).collect()
        }
    }

    macro_rules !def_read {
        ($t : ty) => {
            impl Read for $t {
                fn read(s : &str)->$t { s.parse().unwrap() }
            }
        }
    }

    macro_rules !def_read_tuple {
        ($($t : ident), *) => {
            impl<$($t : Read + Default), *> Read for ($($t), *) {
                fn read(s : &str)->Self {
                    let mut iter = s.split_whitespace();
                    ($($t::read(iter.next().unwrap())), *)
                }
            }
        };
    }

    def_read!(i32);
    def_read!(i64);
    def_read!(isize);
    def_read!(usize);
    def_read!(f32);
    def_read!(f64);
    def_read_tuple!(T0, T1);
    def_read_tuple!(T0, T1, T2);
    def_read_tuple!(T0, T1, T2, T3);
    def_read_tuple!(T0, T1, T2, T3, T4);
}