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 Scala (2.11.7) (judge verdict: Accepted)

import scala.math.min
object Main {
  def main(args:Array[String]) = {
    
    // printf("%d\n", b(Array(218, 233, 389, 645, 704, 728), 2, 5, v => v < 218+233))
    // System.exit(0)

    val sc = new java.util.Scanner(System.in)
    val n = sc.nextInt
    val lines = Array.fill(n)(sc.nextInt).sorted
    var sum = 0
    for(i <- 0 to lines.size-1) {
      for(j <- i+1 to lines.size-2) {
        val r  = b(lines, j+1, lines.size-1, v => v < lines(i)+lines(j))
        sum += r
        // printf("%d:%d -> %d\n", lines(i), lines(j), r)
      }
    }
    println(sum)
  }
  def b(ar:Array[Int], start:Int, end:Int, f: Int=> Boolean): Int = {
    // @scala.annotation.tailrec
    def b_(start2 :Int, end2 :Int): Int = {
      // printf("%d:%d\n", start2, end2)
      // 要素が残り1つ
      if (start2 == end2) {
        if (f(ar(start2))) {
          return end + 1 - start // 右端に到達
        } else {
          return 0               // 左端に到達
        }
      }
      // 要素が残り2つ
      if (start2+1 == end2) {
        return (f(ar(start2)), f(ar(end2))) match {
          case (true, false)  => end2 - start
          case (_,    _)      => b_(start2, start2)
        }
      }
      // 要素が3つ以上
      var middle = (start2 + end2) / 2
      return (f(ar(middle)), f(ar(middle+1))) match {
        case (true, false)  => middle+1 - start
        case (true, true)   => b_(middle, end2)
        case (false, false) => b_(start2, middle)
      }
    }
    b_(start, end)
  }
}