Problem:
Score : 400 points

Problem Statement

Takahashi has N sticks that are distinguishable from each other. The length of the i-th stick is L_i.

He is going to form a triangle using three of these sticks. Let a, b, and c be the lengths of the three sticks used. Here, all of the following conditions must be satisfied:

a < b + c

b < c + a

c < a + b

How many different triangles can be formed? Two triangles are considered different when there is a stick used in only one of them.

Constraints

All values in input are integers.

3 \leq N \leq 2 \times 10^3

1 \leq L_i \leq 10^3

Input

Input is given from Standard Input in the following format:

N
L_1 L_2 ... L_N

Constraints

Print the number of different triangles that can be formed.

Sample Input 1

4
3 4 2 1

Sample Output 1

1

Only one triangle can be formed: the triangle formed by the first, second, and third sticks.

Sample Input 2

3
1 1000 1

Sample Output 2

0

No triangles can be formed.

Sample Input 3

7
218 786 704 233 645 728 389

Sample Output 3

23

Solution in Haskell (GHC 7.10.3) (judge verdict: Time Limit Exceeded)

module Main where
import qualified Control.Monad as C
import qualified Data.Char as C
import qualified Data.List as L
import qualified Data.Map as M
import qualified Data.Array as A
import qualified Data.Vector as V
import qualified Data.Vector.Mutable as VM


int = read :: String -> Int

main = interact $ printer . solver . parser
parser = map int . tail . words
printer = (++"\n") . show

solver ss = answer
  where
    vec = V.fromList $ flip zip [0..] $ L.sort ss
    n = length vec
    list = do
      i <- [0..(n-3)]
      j <- [(i+1)..(n-2)]
      let u = ubound vec ((fst$vec V.!i)+(fst$vec V.!j)-1, 3000) 
      let l = lbound vec $ max ((fst$vec V.!j)-(fst$vec V.!i)+1, 0) (vec V.!(j+1))
      -- [(i,j,if l > u then 0 else u - l + 1)]
      [if u - l > 0 then u - l else 0 ]
    answer = sum list



lbound :: (Ord a) => V.Vector a -> a -> Int 
lbound v key = bound' v 0 (length v) (<=) key 

ubound :: (Ord a) => V.Vector a -> a -> Int 
ubound v key = bound' v 0 (length v) (<) key 

bound' :: (Ord a) => V.Vector a -> Int -> Int -> (a->a->Bool) -> a -> Int
bound' v f t op key 
  | f == t = f 
  | op key b = bound' v f m op key 
  | otherwise = bound' v (m+1) t op key 
  where
    m = (f + t) `div` 2
    b = v V.! m