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

use std::vec::Vec;
use std::cmp::*;

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>().split_whitespace().map(|e| e.parse().ok().unwrap()).collect()
}

fn read_touple<T: std::str::FromStr + Copy>() -> (T, T) {
  let v: Vec<T> = read_vec();
  assert_eq!(v.len(), 2);
  (v[0], v[1])
}

fn main() {
  let n: usize = read();
  let mut l: Vec<usize> = read_vec();
  l.sort_by(|a, b| b.cmp(&a));
  let mut ans = 0;

  for i in 0..n-2 {
    for j in i+1..n-1 {
      let mut k = j + 1;
      while  k < n && l[k] > l[i] - l[j] {
        ans += 1;
        k += 1;
      }
    }
  }
  println!("{}", ans);
}


fn solve() {
    let n: usize = read();
  let mut l: Vec<usize> = read_vec();
  let m = l.iter().fold(0, |acc, &x| max(acc, x));
  l.sort();

  //count[i]は以下の数字の個数
  let mut count = vec![0; 2 * m + 2];
  for &e in &l {
    count[e] += 1;
  }
  for i in 0..2*m + 1 {
    count[i+1] += count[i];
  }
  
  //println!("{:?}", count);

  let mut ans: usize = 0;
  for i in 0..n {
    for j in i+1..n {
      let b = l[i] as i64;
      let c = l[j] as i64;
      let (left, right) = ((b - c).abs() as usize , (b + c) as usize);
      let l = count[left];
      let r = count[right-1];

      ans += r - l; 
      if left < (b as usize) && (b as usize) < right {
         ans -= 1;
      }
      if left < (c as usize) && (c as usize) < right {
         ans -= 1;
      }
      // println!("b = {}, c = {}", b, c);
      // println!("left = {}, right = {}", left, right);
      // println!("{} {}", count[left], count[right]);
      // println!("{}\n", ans);
    }
  }
  println!("{}", ans/3)
}