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 C (GCC 5.4.1) (judge verdict: Time Limit Exceeded)

#include <stdio.h>
#include <stdlib.h>

typedef struct  s_edge
{
    int l;
    int u;
}               t_edge;

int compare_edges(const void* a, const void* b)
{
    t_edge arg1 = *(const t_edge*)a;
    t_edge arg2 = *(const t_edge*)b;
 
    if (arg1.l < arg2.l) return -1;
    if (arg1.l > arg2.l) return 1;
    return 0;
}

int	main(void)
{
  	int	N;
  	t_edge  L[2001];
 	int	num;
  	int	i;
  	int	j;
  	int k;
  	int count;
  
  	num = scanf("%d\n", &N);
  	if (num != 1)
      	return (0);
  
  	for (i=0; i<N; i++)
    {
      	num = scanf("%d", &L[i].l);
      	if (num != 1)
          	return (0);
        L[i].u = 0;
    }
  
    qsort(L, N, sizeof(t_edge), compare_edges);
  
  	count = 0;
  	for (i=0; i<N-2; i++)
    {
      	for (j=i+1; j<N-1; j++)
        {
          	for (k=j+1; k<N; k++)
            {
                L[i].u = 1;
                if (L[j].u == 1)
                {
                    L[i].u = 0;
                    break ;
                }
                L[j].u = 1;
                if (L[k].u == 1)
                {
                    L[i].u = 0;
                    L[j].u = 0;
                    break ;
                }
              	if (L[k].l < L[i].l + L[j].l && L[j].l < L[k].l + L[i].l && L[i].l < L[j].l + L[k].l)
              	    count++;
                L[i].u = 0;
                L[j].u = 0;
            }
        }
    }
    
  	printf("%d", count);
  	return (0);
}