#include <cstdio>
#include <functional>
#include <algorithm>
#include <vector>
#include <limits>
#include <numeric>
#include <type_traits>
#include <iostream>
#include <queue>
#include <math.h>
#include <bits/stdc++.h>
#include <queue>
#include <map>

using namespace std;

#define INF (1ll<<60)
#define INFint (1<<30)
#define MOD 1000000007
#define BOUND 27182818284

typedef long long ll;
typedef long long int lli;
typedef pair<ll,ll> P;

#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define repi(i,a,b) for(int i=int(a);i<int(b);++i)

template<class T>
bool umax(T &a, const T &b){
    if (a<b) {
        a=b; return true;
    }
    return false;
}

template<class T>
bool umin(T &a, const T &b) {
    if (b<a) {
        a=b; return true;
    }
    return false;
}

// gcd
template<typename T>
T gcd(T a, T b){
    if(a==0)
        return b;
    return gcd(b%a,a);
}

// gcd array
int findGCD(int arr[], int n){
    int result = arr[0];
    for (int i=1; i < n; i++)
        result = gcd(arr[i], result);
    return result;
}

template<typename T>
T lcm( T m, T n ){
    // 引数に0がある場合は0を返す
    if ( ( 0 == m ) || ( 0 == n ) )
        return 0;
    return ((m/gcd(m, n)) * n); // lcm = m * n / gcd(m,n)
}

template<typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val){
    fill( (T*)array, (T*)(array+N), val );
}


int dx[5]={1,0,-1,0};
int dy[5]={0,1,0,-1};
// v.front() = -BOUND;
// v.back() = BOUND;

struct edge{
    int cost, to;

    edge(int in_cost, int in_to){
        cost=in_cost;
        to=in_to;
    }
    bool operator<(const edge &a) const
    {
        return cost > a.cost;
    }
};

// Combination
class Combination{
    long long powmod(long long a, long long p){
        long long ans = 1LL;
        long long mul = a;
        while(p>0){
            if((p&1)==1) {
                ans = (ans * mul) % MOD;
            }
            mul=(mul*mul)%MOD;
            p>>=1;
        }
        return ans;
    }

public:
    int N;
    long long mod;
    vector<long long> fact;
    vector<long long> revfact;

    Combination(int n, long long m) : N(n), mod(m), fact(n+1), revfact(n+1){
        fact[0]=1;
        for(int i=1; i<=N; i++){
            fact[i]=fact[i-1]*i;
            fact[i]%=mod;
        }

        revfact[N] = powmod(fact[N], mod-2);
        for(int i=N-1; i>=0; i--){
            revfact[i]=revfact[i+1]*(i+1)%mod;
        }
    }

    long long getCombination(int a, int b){
        if(a<0 || b<0) return 0;
        if(b>a)return 0;
        return fact[a]*revfact[b]%mod*revfact[a-b]%mod;
    }
};

ll C[51][51];
void comb_table(int N){
    for(int i=0;i<=N;++i){
        for(int j=0;j<=i;++j){
            if(j==0 or j==i){
                C[i][j]=1LL;
                }else{
                C[i][j]=(C[i-1][j-1]+C[i-1][j]);
                }
             }
         }
}
int main() {
    int N, A, B;
    cin >> N >> A >> B;
    vector<ll>v(N,0LL);
    rep(i,N){
        cin >> v[i];
    }

    sort(v.begin(), v.end(), greater<ll>());

    long double sum=0;
    rep(i,A){
        sum+=v[i];
    }
    cout.precision(20);
    cout << fixed << sum/A << endl;

    ll minimum=v[A-1];
    int numA=0;
    for(int i=0; i<A; i++){
        if(minimum==v[i])
            numA++;
    }

    int numB=0;
    for(int i=A; i<N; i++){
        if(minimum==v[i])
            numB++;
    }

    comb_table(N);

    ll ans=0LL;
    if(v[0]!=v[A-1]){
        ans=C[numA+numB][numA];
    }else{
        for(int i=A; i<=B; i++){
            ans+=C[numA+numB][i];
        }
    }

    cout << ans << endl;
    return 0;
}


Measured memory_bytes: 256