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 Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.io.*;
import java.util.*;

class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int N = Integer.parseInt(sc.next());
    
    Integer[] L = new Integer[N];
    for (int i = 0; i < N; i++) {
      L[i] = Integer.parseInt(sc.next());
    }
    
    Comparator<Integer> comparator =
     new Comparator<Integer>() {
      @Override
      public int compare(Integer o1, Integer o2) {
        return o2.compareTo(o1);
      }
    };
    Arrays.sort(L, comparator);
    
    int count = 0;
    for (int i = 0; i < N-2; i++) {
      for (int j = i+1; j < N-1; j++) {
        // kはj+1からN-1までの中にいる
        // Lは大きい順にソートされている
        // L[k] > L[i]-L[j] を満たすものを探せば良い
        // 2分岐探索で求めることができるはず
        // L[k_ans]がギリギリ満たすとすると、
        // N-k_ansの数をカウントしてやれば良い
        
        int min = j+1;
        int max = N-1;
        if (L[i] < L[j] + L[max]) {
            count += max - min + 1;
            continue;
        }
        if (L[i] >= L[j] + L[min]) {
            continue;
        }
        
        int k;
        while (true) {
          k = (min + max) / 2;
          if (L[i] < L[j] + L[k]) {
            min = k;
          } else {
            max = k;
          }
          if (max - min <= 1) {
            break;
          }
        }
        count += k - j;
      }
    }
    
    System.out.println(count);
  }
}