output_description: Print two lines.  
  The first line should contain the maximum possible arithmetic mean of the
  values of selected items. The output should be considered correct if the
  absolute or relative error is at most 10^{-6}.  
  The second line should contain the number of ways to select items so that the
  mean of the values of selected items is maximized.
  
  * * *
input_description: The input is given from Standard Input in the following format:
  
      
      
      N A B
      v_1
      v_2
      ...
      v_N
attempt: import sys, bisect, string, math, time, functools, random, fractions
  from heapq import heappush, heappop, heapify
  from collections import deque, defaultdict, Counter
  from itertools import permutations, combinations, groupby
  
  rep = range
  R = range
  
  
  def Golf():
      n, *t = map(int, open(0).read().split())
  
  
  def I():
      return int(input())
  
  
  def S_():
      return input()
  
  
  def IS():
      return input().split()
  
  
  def LS():
      return [i for i in input().split()]
  
  
  def MI():
      return map(int, input().split())
  
  
  def LI():
      return [int(i) for i in input().split()]
  
  
  def LI_():
      return [int(i) - 1 for i in input().split()]
  
  
  def NI(n):
      return [int(input()) for i in range(n)]
  
  
  def NI_(n):
      return [int(input()) - 1 for i in range(n)]
  
  
  def StoLI():
      return [ord(i) - 97 for i in input()]
  
  
  def ItoS(n):
      return chr(n + 97)
  
  
  def LtoS(ls):
      return "".join([chr(i + 97) for i in ls])
  
  
  def RA():
      return map(int, open(0).read().split())
  
  
  def GI(V, E, ls=None, Directed=False, index=1):
      org_inp = []
      g = [[] for i in range(V)]
      FromStdin = True if ls == None else False
      for i in range(E):
          if FromStdin:
              inp = LI()
              org_inp.append(inp)
          else:
              inp = ls[i]
          if len(inp) == 2:
              a, b = inp
              c = 1
          else:
              a, b, c = inp
          if index == 1:
              a -= 1
              b -= 1
          aa = (a, c)
          bb = (b, c)
          g[a].append(bb)
          if not Directed:
              g[b].append(aa)
      return g, org_inp
  
  
  def GGI(
      h, w, search=None, replacement_of_found=".", mp_def={"#": 1, ".": 0}, boundary=1
  ):
      # h,w,g,sg=GGI(h,w,search=['S','G'],replacement_of_found='.',mp_def={'#':1,'.':0},boundary=1) # sample usage
      mp = [boundary] * (w + 2)
      found = {}
      for i in R(h):
          s = input()
          for char in search:
              if char in s:
                  found[char] = (i + 1) * (w + 2) + s.index(char) + 1
                  mp_def[char] = mp_def[replacement_of_found]
          mp += [boundary] + [mp_def[j] for j in s] + [boundary]
      mp += [boundary] * (w + 2)
      return h + 2, w + 2, mp, found
  
  
  def TI(n):
      return GI(n, n - 1)
  
  
  def accum(ls):
      rt = [0]
      for i in ls:
          rt += [rt[-1] + i]
      return rt
  
  
  def bit_combination(n, base=2):
      rt = []
      for tb in R(base**n):
          s = [tb // (base**bt) % base for bt in R(n)]
          rt += [s]
      return rt
  
  
  def gcd(x, y):
      if y == 0:
          return x
      if x % y == 0:
          return y
      while x % y != 0:
          x, y = y, x % y
      return y
  
  
  def YN(x):
      print(["NO", "YES"][x])
  
  
  def Yn(x):
      print(["No", "Yes"][x])
  
  
  def show(*inp, end="\n"):
      if show_flg:
          print(*inp, end=end)
  
  
  # mo=10**9+7
  mo = 2305843009213693951
  inf = float("inf")
  FourNb = [(-1, 0), (1, 0), (0, 1), (0, -1)]
  EightNb = [(-1, 0), (1, 0), (0, 1), (0, -1), (1, 1), (-1, -1), (1, -1), (-1, 1)]
  compas = dict(zip("WENS", FourNb))
  cursol = dict(zip("LRUD", FourNb))
  l_alp = string.ascii_lowercase
  # sys.setrecursionlimit(10**7)
  read = sys.stdin.buffer.read
  readline = sys.stdin.buffer.readline
  input = lambda: sys.stdin.readline().rstrip()
  
  
  ########################################################################################################################################################################
  class Comb:
      def __init__(self, n, mo=2305843009213693951):
          self.fac = [0] * (n + 1)
          self.inv = [1] * (n + 1)
          self.fac[0] = 1
          self.fact(n)
          for i in range(1, n + 1):
              self.fac[i] = i * self.fac[i - 1] % mo
              self.inv[n] *= i
              self.inv[n] %= mo
          self.inv[n] = pow(self.inv[n], mo - 2, mo)
          for i in range(1, n):
              self.inv[n - i] = self.inv[n - i + 1] * (n - i + 1) % mo
          return
  
      def fact(self, n):
          return self.fac[n]
  
      def invf(self, n):
          return self.inv[n]
  
      def comb(self, x, y):
          if y < 0 or y > x:
              return 0
          return self.fac[x] * self.inv[x - y] * self.inv[y] % mo
  
  
  show_flg = False
  show_flg = True
  
  ans = 0
  
  
  F = [1]
  for i in range(110):
      F += (F[i] * -~i,)
  C = lambda A, B: (A >= B >= 0) * F[A] // F[A - B] // F[B]
  
  
  n, a, b = LI()
  v = LI()
  v = sorted(v)[::-1]
  print(sum(v[:a]) / a)
  m = v[a - 1]
  x = v[:a].count(m)
  y = v[a:].count(m)
  ans = 1
  if x != a:
      ans = C(x + y, x)
      print(ans)
  else:
      ans = 0
      for i in range(a, min(b, x + y) + 1):
          ans += C(x + y, i)
      print(ans)
  
problem_description: Statement
  
  You are given N items.  
  The _value_ of the i-th item (1 \leq i \leq N) is v_i.  
  Your have to select at least A and at most B of these items.  
  Under this condition, find the maximum possible arithmetic mean of the values
  of selected items.  
  Additionally, find the number of ways to select items so that the mean of the
  values of selected items is maximized.
samples: [{"input": "5 2 2\n    1 2 3 4 5", "output": "4.500000\n    1\n    \n\nThe mean of the values of selected items will be maximized when selecting the\nfourth and fifth items. Hence, the first line of the output should contain\n4.5.  \nThere is no other way to select items so that the mean of the values will be\n4.5, and thus the second line of the output should contain 1.\n\n* * *"}, {"input": "4 2 3\n    10 20 10 10", "output": "15.000000\n    3\n    \n\nThere can be multiple ways to select items so that the mean of the values will\nbe maximized.\n\n* * *"}, {"input": "5 1 5\n    1000000000000000 999999999999999 999999999999998 999999999999997 999999999999996", "output": "1000000000000000.000000\n    1"}]