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 Go (1.6) (judge verdict: Accepted)

package main
import (
  "fmt"
  "os"
  "bufio"
  "strings"
  "strconv"
  "sort"
)

// var f, _ = os.Open("input.txt")
// var rdr = bufio.NewReaderSize(f, 1000000)
var rdr = bufio.NewReaderSize(os.Stdin, 1000000)

func read_line() string {
    buf := make([]byte, 0, 1000000)
    for {
        l, p, e := rdr.ReadLine()
        if e != nil {
            panic(e)
        }
        buf = append(buf, l...)
        if !p {
            break
        }
    }
    return string(buf)
}

func upper(Ls [] int, val int) int {
    var low int = 0
    var high int = len(Ls)
    mid := (high + low) / 2
    for high - low > 1 {
        if Ls[mid] > val {
            high = mid
        } else {
            low = mid
        }
        mid = (high + low) / 2
    }

    if Ls[low] > val {
        return low
    }
    return high
}

func upper_equal(Ls [] int, val int) int {
    var low int = 0
    var high int = len(Ls)
    mid := (high + low) / 2
    for high - low > 1 {
        if Ls[mid] >= val {
            high = mid
        } else {
            low = mid
        }
        mid = (high + low) / 2
    }

    if Ls[low] >= val {
        return low
    }
    return high
}

func main() {
    // as := make([] int, 5)
    // for i, word := range strings.Split(read_line(), " ") {
    //     as[i], _ = strconv.Atoi(word)
    // }

    N, _ := strconv.Atoi(read_line())
    Ls := make([] int, N)
    for i, L := range strings.Split(read_line(), " ") {
        Ls[i], _ = strconv.Atoi(L)
    }

    sort.Ints(Ls)    

    var res int = 0
    for i := 0; i < N; i++ {
        for j := i + 1; j < N; j++ {
            max_index := upper_equal(Ls, Ls[j] + Ls[i])
            min_index := upper(Ls, Ls[j] - Ls[i])
            res += max_index - min_index
            if min_index <= i && i < max_index {
                res--
            }
            if min_index <= j && j < max_index {
                res--
            }
        }
    }

    fmt.Println(res / 3)
}