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 Kotlin (1.0.0) (judge verdict: Time Limit Exceeded)

fun main(args: Array<String>) {
    val n = readLine()!!.toInt()
    val l = readLine()!!.split(" ").map { it.toInt() }.sorted()
    var ans = 0L

    for (ai in l.indices) {
        for (bi in l.indices) {
            if(ai == bi) continue
            // a-b < c
            // -a+b < c
            // a+b > c
            System.err.println("ai=$ai, bi=$bi")
            val if1 = l.upperBound(l[ai]-l[bi])
            System.err.println("if1=$if1")
            val if2 = l.upperBound(-l[ai]+l[bi])
            System.err.println("if2=$if2")
            val underIf = Math.max(if1, if2)
            val upperIf = l.lowerBound(l[ai]+l[bi])
            System.err.println("if3=$upperIf")
            var up = Math.max(0, upperIf - underIf)
            if(ai in underIf until upperIf) up--
            if(bi in underIf until upperIf) up--
            System.err.println("up:$up")
            ans += up
        }
    }

    System.err.println(ans)
    println(ans / 6)
}

/**
 * elementをキーとして、キー以上の要素の中で最も小さい位置のインデックスを返す。
 * 検索範囲は[fromIndex, toIndex)
 *
 * @param fromIndex この位置を含む範囲
 * @param toIndex この位置を含まない範囲
 * @return 0-indexedなインデックス
 */
fun <T : Comparable<T>> List<T>.lowerBound(
    element: T,
    fromIndex: Int = 0,
    toIndex: Int = size
): Int {
    rangeCheck(size, fromIndex, toIndex)

    var low = fromIndex - 1
    var high = toIndex

    while (high - low > 1) {
        val mid = low + (high - low) / 2
        val midVal = get(mid)
        if (midVal < element) low = mid
        else high = mid
    }

    return high
}

/**
 * elementをキーとして、キーより大きい要素の中で最も小さい位置のインデックスを返す。
 * 検索範囲は[fromIndex, toIndex)
 *
 * @param fromIndex この位置を含む範囲
 * @param toIndex この位置を含まない範囲
 * @return 0-indexedなインデックス
 */
fun <T : Comparable<T>> List<T>.upperBound(
    element: T,
    fromIndex: Int = 0,
    toIndex: Int = size
): Int {
    rangeCheck(size, fromIndex, toIndex)

    var low = fromIndex - 1
    var high = toIndex

    while (high - low > 1) {
        val mid = low + (high - low) / 2
        val midVal = get(mid)
        if (midVal <= element) low = mid
        else high = mid
    }

    return high
}

/**
 * Checks that `from` and `to` are in
 * the range of [0..size] and throws an appropriate exception, if they aren't.
 */
private fun rangeCheck(size: Int, fromIndex: Int, toIndex: Int) {
    when {
        fromIndex > toIndex -> throw IllegalArgumentException("fromIndex ($fromIndex) is greater than toIndex ($toIndex).")
        fromIndex < 0 -> throw IndexOutOfBoundsException("fromIndex ($fromIndex) is less than zero.")
        toIndex > size -> throw IndexOutOfBoundsException("toIndex ($toIndex) is greater than size ($size).")
    }
}