#include <vector>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <numeric>
#include <tuple>
#include <iomanip>
#include<functional>

using namespace std;

//--------------mint
long long mul(long long a,long long b,const long long MOD){
    return b ? (mul(a*2,b/2,MOD)+(b&1?a:0))%MOD : 0;
}
 
long long bpow(long long a,long long b,const long long MOD){
    return (b ? bpow(a*a%MOD,b/2,MOD)*(b&1?a:1) : 1) % MOD;
}
 
long long inv(long long a,const long long MOD){
    return bpow(a, MOD-2, MOD);
}
/*
class mInt{
public:
    static const long long mod = 1000000007;
    long long v;
    mInt():v(0){}
    mInt(long long v):v((v%mod+mod)%mod){}
};
mInt& operator += (mInt &a,mInt b){ return a = a.v + b.v; }
mInt& operator -= (mInt &a,mInt b){ return a = a.v - b.v; }
mInt& operator *= (mInt &a,mInt b){ return a = a.v * b.v; }
mInt& operator /= (mInt &a,mInt b){ return a = a.v * inv(b.v,mInt::mod); }
mInt operator + (mInt a,mInt b){ return a += b; }
mInt operator - (mInt a,mInt b){ return a -= b; }
mInt operator * (mInt a,mInt b){ return a *= b; }
mInt operator / (mInt a,mInt b){ return a /= b; }
ostream& operator<<(ostream& os, const mInt& x){ return os << x.v; }
 */

vector<long long> MODS = {1000000007};
template<int kind = 0>
class mint{
public:
    long long v;

    mint() : v(0) {}
    mint(long long v) : v((v % MODS[kind] + MODS[kind]) % MODS[kind]) {}
    long long get_mod() {return MODS[kind];}
};

template<int kind>
ostream& operator<<(ostream& os, const mint<kind>& x){ return os << x.v; }

template<int kind>
mint<kind>& operator += (mint<kind> &a, mint<kind> b){ return a = a.v + b.v; }
template<int kind>
mint<kind>& operator -= (mint<kind> &a, mint<kind> b){ return a = a.v - b.v; }
template<int kind>
mint<kind>& operator *= (mint<kind> &a, mint<kind> b){ return a = a.v * b.v; }
template<int kind>
mint<kind>& operator/= (mint<kind> &a, mint<kind> b) {return a = a.v * inv(b.v, a.get_mod());}
template<int kind>
mint<kind> operator + (mint<kind> a, mint<kind> b){ return a += b; }
template<int kind>
mint<kind> operator - (mint<kind> a, mint<kind> b){ return a -= b; }
template<int kind>
mint<kind> operator * (mint<kind> a, mint<kind> b){ return a *= b; }
template<int kind>
mint<kind> operator / (mint<kind> a, mint<kind> b){ return a /= b; }
template<int kind>
mint<kind>& operator += (mint<kind> &a, long long b){ return a = a.v + b; }
template<int kind>
mint<kind>& operator -= (mint<kind> &a, long long b){ return a = a.v - b; }
template<int kind>
mint<kind>& operator *= (mint<kind> &a, long long b){ return a = a.v * b; }
template<int kind>
mint<kind>& operator /= (mint<kind> &a, long long b){return a = a.v * inv(b, a.get_mod()); }
template<int kind>
mint<kind> operator + (mint<kind> a, long long b){ return a += b; }
template<int kind>
mint<kind> operator - (mint<kind> a, long long b){ return a -= b; }
template<int kind>
mint<kind> operator * (mint<kind> a, long long b){ return a *= b; }
template<int kind>
mint<kind> operator / (mint<kind> a, long long b){ return a /= b; }


namespace detail{
    template< typename T, std::size_t NDIMS > struct vector_builder
    {
        using type = std::vector< typename vector_builder<T,NDIMS-1>::type > ;

        static type make( std::vector<std::size_t> dims, const T& v = {} )
        {
            const auto vec = std::vector<T>( dims.empty() ? 0 : dims.back(), v ) ;
            if( !dims.empty() ) dims.pop_back() ;
            return vector_builder< std::vector<T>, NDIMS-1 >::make( dims, vec ) ;
        }
    };

    template< typename T > struct vector_builder<T,1>
    {
        using type = std::vector<T> ;

        static type make( std::vector<std::size_t> dims, const T& v = {} )
        { return type( dims.empty() ? 0 : dims.back(), v ) ; }
    };

}


template< typename T, typename... SIZE_T >
auto exvector( const T& v, SIZE_T... dims )
{
    static_assert( sizeof...(dims) != 0, "invalid dimension" ) ;
    std::vector<std::size_t> vec_dims{ dims... } ;
    return detail::vector_builder< T, sizeof...(dims) >::make( vec_dims, v ) ;
}


using namespace std;
//********************  dumps ************************//

template<typename T>
void dump(const T& data, vector<int>& iter) {
    cout << data << " ";
}
template<typename T>
void dump(const vector<T>& data, vector<int>& iter) {
    for(auto elem: data)
        dump(elem, iter);
    cout << endl;
}

template<typename T>
void dump(const vector<vector<T>>& data, vector<int>& iter) {
    for(auto elem : iter) {
        cout << "[" << elem << "]" ;
    }
    cout << endl;
    for(int i=0; i<data.size(); i++) {
        iter.push_back(i);
        dump(data[i], iter);
        iter.pop_back();
    }
    cout << endl;
}

template<typename T>
void dump(const vector<T>& data, int dummy) {
    for(int i=0; i<data.size(); i++) {
        cout <<"[" << i << "] " <<  data[i] << endl;
    }
}
template<typename T>
void dump(const T& data) { // T : data, U = base type val.
    vector<int> iter;
    dump(data, iter);
}

// ===================================
// getter / setter

template<typename T, typename U>
void setval(T& container, vector<int>& pos, U val, int iter) {
    container = (T)val;
}

template<typename T, typename U>
void setval(vector<T>& container, vector<int>& pos, U val, int iter) {
    setval(container[pos[iter]], pos, val, iter+1);
}

template<typename T, typename U>
void setval(T& container, vector<int> pos,  U val) {
    int iter = 0;
    setval(container, pos, val, iter);    
}

template<typename T>
T getval(T& container, vector<int>& pos, T tmp,int iter) {
    return tmp = container;
}

template<typename T, typename U>
U getval(vector<T>& container, vector<int>& pos, U tmp, int iter) {
    return getval(container[pos[iter]], pos, tmp, iter+1);
}

template<typename T, typename U>
U getval(T& container, vector<int>& pos, U& tmp) {
    int iter = 0;
    return getval(container, pos, tmp, iter);    
}




template<typename T>
function<T(T, T)>  op_max = [] (T a, T b)-> T{
    return max(a, b);
};
template<typename T>
function<T(T, T)>  op_min = [] (T a, T b)-> T{
    return min(a, b);
};

template<typename T>
function<T(T, T)>  op_sum = [] (T a, T b)-> T{
    return a + b;
};


//-----------------------------------


template<typename T>
vector<vector<T>> update_dp(vector<T> base, int N, T id, 
        function<T(T, int, int, vector<T>&)> update) {
    vector<vector<T>> result;
    result.push_back(base);

    for(int i=0; i<N; i++) {
        vector<T>& prev = result.back();
        vector<T> cur(prev.size(), id);
        for(int j=0; j<cur.size(); j++) {
            cur[j] = update(id, i, j, prev);
        }
        result.push_back(cur);
        //dump(result);
    }
    return result;
}




template<typename T>
vector<T> ruiseki(vector<T> base, T id, bool reverse = false, 
        function<T(T,T)> op = op_sum<T>) {
    vector<T> res(base.size() + 1, id);
    if(!reverse)
        for(int i=0; i<base.size(); i++) 
            res[i+1] = op(base[i], res[i]);
    if(reverse)
        for(int i=base.size()-1; i>=0; i--) {
            res[i] = op(base[i], res[i+1]);
        }
    return ruiseki;

}



template<typename T, size_t NDIMS>
class MemoDP{
public:
    template<typename... SIZE_T>
    MemoDP(int n, SIZE_T... sizes) {
        N = n;
        dp = exvector(T(), sizes...);
        used = exvector(int(0), sizes...);
    }

    template<typename... SIZE_T>
    T do_dp_recursive(SIZE_T... pos) {
        // 3次元を仮定
        int x, y, z;
        tie(x, y, z) = tie(pos...);
        if(used[x][y][z]) {
            return dp[x][y][z];
        }
        if(x == 0 && y == 0 && z == 0) {
            return 0;
        }
        used[x][y][z] = 1;
        // 遷移
        double base = (double)(x+y+z) / N;
        T result = 1/base;
        if(z>=1) result += do_dp_recursive(x, y+1, z-1) * z  / base / N;
        if(y>=1) result += do_dp_recursive(x+1, y-1, z) * y / base / N;
        if(x>=1) result += do_dp_recursive(x-1, y, z) * x / base / N;

        //cout << x << " " << y << " " << z << " " << result << endl;
        return dp[x][y][z] = result;

    }

    template<typename... SIZE_T>
    typename detail::vector_builder<T,NDIMS>::type do_dp(SIZE_T... pos)
    {      
        do_dp_recursive(pos...);
        return dp;
    }

private:
    int N;
    typename detail::vector_builder<T, NDIMS >::type dp;
    typename detail::vector_builder<int, NDIMS>::type used;
};




typedef long long LL;

//-------------------------main
int main() {
    // MemoDP<LL, 3> hoge(1,2,3);
    //hoge.do_dp(0, 1, 2);



    int N;
    cin >> N;
    vector<int> input(N, 0);
    for(int i=0; i<N; i++) cin >> input[i];
    vector<int> A(4,0);
    for(auto elem : input) A[elem]++;

    MemoDP<double, 3> dp(N, 301, 301, 301);
    auto result = dp.do_dp(A[1], A[2], A[3]);
     cout << setprecision(10) <<  result[A[1]][A[2]][A[3]] << endl;
    

    return 0;
}


Measured memory_bytes: 541824