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 8.8.3) (judge verdict: Wrong Answer)

{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE UndecidableInstances #-}

module Main where

import Control.Category hiding (id, (.))
import Control.Monad
import Control.Monad.ST
import Control.Monad.State.Strict
import qualified Data.ByteString.Char8 as BS
import Data.List as List
import Data.Maybe
import Data.Set as Set
import qualified Data.Vector.Unboxing as U
import qualified Data.Vector.Unboxing.Mutable as UM
import GHC.Generics

readInt :: BS.ByteString -> Int
readInt = fst . fromJust . BS.readInt

readIntList :: BS.ByteString -> [Int]
readIntList = Prelude.map readInt . BS.words

getInt :: IO Int
getInt = readInt <$> BS.getLine

getIntList :: IO [Int]
getIntList = readIntList <$> BS.getLine

-- data Point = Pt {-# UNPACK #-} Int {-# UNPACK #-} Int
--   deriving (Generic)
--   deriving (U.Unboxable) via U.Generics Point

-- ptX :: Point -> Int
-- ptX (Pt x y) = x

-- ptY :: Point -> Int
-- ptY (Pt x y) = y

main :: IO ()
main = do
  n <- getIntList
  ls <- getIntList
  let lsVec = U.fromList ls
      appCnt = runST $ do
        table <- UM.new (10 ^ 3 + 1)
        forM_ ls $ \val -> do
          UM.modify table (+ (1 :: Int)) val
        U.freeze table
      uniqSortedVec = U.fromList . Set.toList . Set.fromList $ ls
      cnt = U.length uniqSortedVec
      accumAppCnt = runST $ do
        ans <- UM.new (10 ^ 3 + 2)
        forM_ [1 .. 10 ^ 3 + 1] $ \i -> do
          if i == 0
            then return ()
            else do
              prev <- UM.read ans (i -1)
              if appCnt U.! (i - 1) > 0
                then UM.write ans i (prev + 1)
                else UM.write ans i prev
        U.freeze $ ans
      count0 = (flip execState) (0 :: Int) $ do
        forM_ [0 .. cnt - 1] $ \i -> do
          forM_ [i + 1 .. cnt - 1] $ \j -> do
            let a = uniqSortedVec U.! i
                b = uniqSortedVec U.! j
                begin = b + 1
                end = min (10 ^ 3 + 1) (a + b)
                add = accumAppCnt U.! end - accumAppCnt U.! begin
            modify' (+ add)
      count1 = (flip execState) (0 :: Int) $ do
        forM_ [0 .. cnt - 1] $ \i -> do
          let a = uniqSortedVec U.! i
          if appCnt U.! a >= 2
            then do
              let begin = 1
                  end = min (10 ^ 3 + 1) (2 * a)
                  add0 = accumAppCnt U.! end - accumAppCnt U.! begin
                  add1 = add0 + if appCnt U.! a == 2 then -1 else 0
              modify' (+ add1)
            else return ()
  print (count0 + count1)

{-
9
218 786 704 704 704 233 645 728 389

-}