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: Accepted)

import java.util.*

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

    var res = 0L

    for (i in L.indices) for (j in i + 1 until L.size) {
        val l = Math.abs(L[i] - L[j])
        val u = L[i] + L[j]

        val a = Math.max(upperBound(L, l), j + 1)
        val b = lowerBound(L, u)

        if (b < a) {
            continue
        }

        res += (b - a)

        if (i in a until b) {
            res -= 1L
        }
        if (j in a until b) {
            res -= 1L
        }
    }

    println(res)
}

private fun lowerBound(list: List<Int>, v: Int): Int {
    if (list.last() < v) {
        return list.size
    }

    var l = -1
    var u = list.size - 1

    while (u - l > 1) {
        val c = (u + l) / 2
        if (list[c] >= v) {
            u = c
        } else {
            l = c
        }
    }

    return u
}

private fun upperBound(list: List<Int>, v: Int): Int {
    var l = 0
    var u = list.size

    while (u - l > 1) {
        val c = (u + l) / 2
        if (list[c] > v) {
            u = c
        } else {
            l = c
        }
    }

    return u
}