Problem:
Score : 300 points

Problem Statement

Tak has N cards. On the i-th (1 \leq i \leq N) card is written an integer x_i.
He is selecting one or more cards from these N cards, so that the average of the integers written on the selected cards is exactly A.
In how many ways can he make his selection?

Constraints

1 \leq N \leq 50

1 \leq A \leq 50

1 \leq x_i \leq 50

N,\,A,\,x_i are integers.

Partial Score

200 points will be awarded for passing the test set satisfying 1 \leq N \leq 16.

Input

The input is given from Standard Input in the following format:

N A
x_1 x_2 ... x_N

Output

Print the number of ways to select cards such that the average of the written integers is exactly A.

Sample Input 1

4 8
7 9 8 9

Sample Output 1

5

The following are the 5 ways to select cards such that the average is 8:

Select the 3-rd card.

Select the 1-st and 2-nd cards.

Select the 1-st and 4-th cards.

Select the 1-st, 2-nd and 3-rd cards.

Select the 1-st, 3-rd and 4-th cards.

Sample Input 2

3 8
6 6 9

Sample Output 2

0

Sample Input 3

8 5
3 6 2 8 7 6 5 9

Sample Output 3

19

Sample Input 4

33 3
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3

Sample Output 4

8589934591

The answer may not fit into a 32-bit integer.

Solution in OCaml (4.02.3) (judge verdict: Accepted)

open Printf
open Scanf

let rec loop x fn =
  match fn x with
  | `Break x -> x
  | `Continue x -> loop x fn

let ( |- ) x f = f x; x
let flip f a b = f b a

module Int = struct
  include Int64
  module Infix = struct 
    let ( + ) = add and ( - ) = sub
    and ( * ) = mul and ( / ) = div
  end
end

let () =
  let read_ints () =
    let str = loop (Buffer.create 10) begin fun buf ->
        try 
          `Continue (buf |- (flip Buffer.add_bytes)
                       (read_line () ^ " "))
        with _ ->
          `Break (buf |> Buffer.contents) end in
    str |> Str.(split (regexp " ")) |> List.map int_of_string in

  let num:: avg:: xs = read_ints () in
  let xs = xs |> Array.of_list in

  let cache, cached, get = let open Hashtbl in
    let memo = create 10 in
    let cache = replace memo in
    let cached = mem memo in
    let get = find memo in
    cache, cached, get in

  let rec solve ~sum ~cnt ~idx : Int64.t =
    if cached (sum, cnt, idx)
    then get (sum, cnt, idx)
    else if idx >= num
    then if cnt != 0 && cnt * avg = sum then 1L else 0L
    else
      let idx' = idx + 1 in
      let sum' = sum + xs.(idx) and cnt' = cnt + 1 in
      let open Int.Infix in
      let ans = solve ~sum ~cnt ~idx: idx'
                + solve ~sum: sum' ~cnt: cnt' ~idx: idx' in
      ans |- cache (sum, cnt, idx) in

  let sum = 0 and cnt = 0 and idx = 0 in
  let ans = solve ~sum ~cnt ~idx in
  printf "%Ld\n" ans