import math

        

def combination(n, k):

    return math.factorial(n) // math.factorial(k) // math.factorial(n - k)

            

import collections  

    

n,a,b = list(map(int,input().split()))



t = list(map(int,input().split()))



c = collections.Counter(t)



c = sorted(list(c.items()), key=lambda x:-x[0])



memo = 0



for k,i in enumerate(c):

    #print(k,i[0],i[1])

    memo += i[1]

    if a<=memo:

        ans = 0

        memo2 = 0

        for j in range(k+1):

            if j != k:

                memo2 += c[j][1]

                ans += c[j][0]*c[j][1]

            else:

                ans += c[j][0]*(a-memo2)

        print((ans/a))

        break

if c[0][1] <= a:  

    print((combination(c[j][1],a-memo2)))

else:

    ans1=0

    for l in range(a,min(c[0][1],b)+1):

        ans1 += combination(c[j][1],l)

    print(ans1)
import math

 

def combination(n, k):

    return math.factorial(n) // math.factorial(k) // math.factorial(n - k)



N,A,B = list(map(int,input().split()))



V = list(map(int,input().split()))



v_count = {}



for v in V:

    if v not in v_count:

        v_count[v] = 1

    else:

        v_count[v] += 1



v_count = sorted(list(v_count.items()), key=lambda x:-x[0])



tmp_count = [0]

ans = 0

for val,count in v_count:

    tmp_count.append(tmp_count[-1]+count)

    if tmp_count[-1] < A:

        ans += val*count

    else:

        ans += val*(A-tmp_count[-2])

        print((ans/A))

        break

#print(tmp_count, ans)

if v_count[0][1] < A:

    comb = A-tmp_count[-2]

    root = combination(v_count[len(tmp_count)-2][1],comb)

else:

    root = 0

    for i in range(A, min(v_count[0][1],B)+1):

        root += combination(v_count[0][1],i)



print(root)
import math


def combination(n, k):
    return math.factorial(n) // math.factorial(k) // math.factorial(n - k)


import collections

n, a, b = list(map(int, input().split()))
t = list(map(int, input().split()))
c = collections.Counter(t)
c = sorted(list(c.items()), key=lambda x: -x[0])
memo = 0
for k, i in enumerate(c):
    # print(k,i[0],i[1])
    memo += i[1]
    if a <= memo:
        ans = 0
        memo2 = 0
        for j in range(k + 1):
            if j != k:
                memo2 += c[j][1]
                ans += c[j][0] * c[j][1]
            else:
                ans += c[j][0] * (a - memo2)
        print((ans / a))
        break
if c[0][1] <= a:
    print((combination(c[j][1], a - memo2)))
else:
    ans1 = 0
    for l in range(a, min(c[0][1], b) + 1):
        ans1 += combination(c[j][1], l)
    print(ans1)

import math


def combination(n, k):
    return math.factorial(n) // math.factorial(k) // math.factorial(n - k)


N, A, B = list(map(int, input().split()))
V = list(map(int, input().split()))
v_count = {}
for v in V:
    if v not in v_count:
        v_count[v] = 1
    else:
        v_count[v] += 1
v_count = sorted(list(v_count.items()), key=lambda x: -x[0])
tmp_count = [0]
ans = 0
for val, count in v_count:
    tmp_count.append(tmp_count[-1] + count)
    if tmp_count[-1] < A:
        ans += val * count
    else:
        ans += val * (A - tmp_count[-2])
        print((ans / A))
        break
# print(tmp_count, ans)
if v_count[0][1] < A:
    comb = A - tmp_count[-2]
    root = combination(v_count[len(tmp_count) - 2][1], comb)
else:
    root = 0
    for i in range(A, min(v_count[0][1], B) + 1):
        root += combination(v_count[0][1], i)
print(root)

-import collections - -n, a, b = list(map(int, input().split())) -t = list(map(int, input().split())) -c = collections.Counter(t) -c = sorted(list(c.items()), key=lambda x: -x[0]) -memo = 0 -for k, i in enumerate(c): -    # print(k,i[0],i[1]) -    memo += i[1] -    if a <= memo: -        ans = 0 -        memo2 = 0 -        for j in range(k + 1): -            if j != k: -                memo2 += c[j][1] -                ans += c[j][0] * c[j][1] -            else: -                ans += c[j][0] * (a - memo2) -        print((ans / a)) +N, A, B = list(map(int, input().split())) +V = list(map(int, input().split())) +v_count = {} +for v in V: +    if v not in v_count: +        v_count[v] = 1 +    else: +        v_count[v] += 1 +v_count = sorted(list(v_count.items()), key=lambda x: -x[0]) +tmp_count = [0] +ans = 0 +for val, count in v_count: +    tmp_count.append(tmp_count[-1] + count) +    if tmp_count[-1] < A: +        ans += val * count +    else: +        ans += val * (A - tmp_count[-2]) +        print((ans / A)) -if c[0][1] <= a: -    print((combination(c[j][1], a - memo2))) +# print(tmp_count, ans) +if v_count[0][1] < A: +    comb = A - tmp_count[-2] +    root = combination(v_count[len(tmp_count) - 2][1], comb) -    ans1 = 0 -    for l in range(a, min(c[0][1], b) + 1): -        ans1 += combination(c[j][1], l) -    print(ans1) +    root = 0 +    for i in range(A, min(v_count[0][1], B) + 1): +        root += combination(v_count[0][1], i) +print(root)