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 Haskell (GHC 7.10.3) (judge verdict: Accepted)

{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TupleSections #-}
import qualified Data.ByteString.Lazy.Char8 as B
import Data.Maybe
-- import Data.List
import qualified Data.Vector as V
import qualified Data.Vector.Unboxed as VU
-- import qualified Data.Vector.Unboxed.Mutable as VUM
-- import Control.Monad
-- import Control.Monad.ST
import Debug.Trace

solve :: Int -> Int -> [Int] -> Int
solve n a xs = sum [reduce V.! i VU.! (i*a) | i <- [1..n]]
  where

  reduce = foldl update initTbl xs

  initTbl = V.fromListN (n+1) (v1 : repeat v2)
    where v1 = VU.fromListN (a*n + 1) (1 : repeat 0)
          v2 = VU.fromListN (a*n + 1) (repeat 0)

  update :: V.Vector (VU.Vector Int) -> Int -> V.Vector (VU.Vector Int)
  update tbl x = V.fromListN (n+1) [upd i | i <- [0..n]]
    where upd :: Int -> VU.Vector Int
          upd 0 = tbl V.! 0
          upd i = upd0 (tbl V.! (i-1)) (tbl V.! i)
          upd0 :: VU.Vector Int -> VU.Vector Int -> VU.Vector Int
          upd0 v1 v2 = VU.zipWith (+) ((VU.replicate x 0) VU.++ v1) v2

readBInt :: B.ByteString -> Int
readBInt = fst . fromJust . B.readInt

tmain :: B.ByteString -> Int
tmain cont =
  let remLines0 = map B.words (B.lines cont)
      [bs_n,bs_a]:remLines1 = remLines0
      n = readBInt bs_n
      a = readBInt bs_a
      line2:remLines2 = remLines1
      xs = map readBInt line2
  in solve n a xs

outAnswer :: Int -> IO ()
outAnswer = putStrLn . show

main :: IO ()
main = outAnswer . tmain =<< B.getContents