input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
from bisect import bisect_left, bisect_right
def count(i, j):
l1, l2 = L[i], L[j]
low = l2 - l1
high = l2 + l1
arr = L[j + 1:]
start = bisect_right(arr, low)
end = bisect_left(arr, high)
return end - start
if __name__ == '__main__':
eval(input())
L = [int(x) for x in input().split()]
L.sort()
total = 0
for i in range(len(L)):
for j in range(i + 1, len(L)):
total += count(i, j)
print(total) | from bisect import bisect_left, bisect_right
def count(i, j):
l1, l2 = L[i], L[j]
low = l2 - l1
high = l2 + l1
start = bisect_right(L, low, j + 1)
end = bisect_left(L, high, j + 1)
return end - start
if __name__ == '__main__':
eval(input())
L = [int(x) for x in input().split()]
L.sort()
total = 0
for i in range(len(L)):
for j in range(i + 1, len(L)):
total += count(i, j)
print(total) | p02888 |
from bisect import bisect_left,bisect_right
from copy import deepcopy
n = int(eval(input()))
L = list(map(int,input().split()))
L.sort()
LL = deepcopy(L)
LL.sort(reverse=1)
# print(L,LL)
ans = 0
for i_max,abc_max in enumerate(LL[:-2]):
ans_bef = ans
# print("i ",i_max,abc_max)
for j_mid,abc_mid in enumerate(LL[i_max+1:],i_max+1):
# print("j ",j_mid,abc_mid)
# for k_min,abc_min in enumerate(L[j_mid+1:]):
right = bisect_left(L,abc_max+1-abc_mid)
# print(right,abc_max+1-abc_mid)
cur = len(LL[j_mid:-(right+1)])
if not cur:
break
ans += cur
# print("ans->",ans)
print(ans) | from bisect import bisect_left
n =int(eval(input()))
L = list(map(int,input().split()))
L.sort()
#L[i]+L[j] > ?
ans = 0
for i in range(n-2):
for j in range(i+1,n-1):
zz = L[i]+L[j]
idx = bisect_left(L,zz)
ans += idx-j-1
print(ans) | p02888 |
n = int(eval(input()))
l = list(map(int,input().split()))
l.sort()
cnt = 0
for i in range(n-2):
for j in range(i+1, n-1):
for k in range(j+1, n):
if l[k]-l[j] < l[i] < l[k]+l[j]:
cnt += 1
print(cnt) | import bisect
n = int(eval(input()))
l = list(map(int,input().split()))
l.sort()
cnt = 0
for i in range(n-2):
for j in range(i+1, n-1):
bi = bisect.bisect_left(l, l[i]+l[j])
cnt += bi-j-1
print(cnt) | p02888 |
from itertools import combinations
n = int(eval(input()))
arr = list(map(int, input().split()))
def is_triangle(a, b, c):
return (a+b > c and a+c > b and b+c > a)
count = 0
for a, b, c in combinations(arr, 3):
if is_triangle(a, b, c):
count += 1
print(count) | n = int(eval(input()))
arr = list(map(int, input().split()))
arr.sort()
count = 0
for i in range(n-1, 0, -1):
l, r = 0, i - 1
while l < r:
if arr[l] + arr[r] > arr[i]:
count += r - l
r -= 1
else:
l += 1
print(count) | p02888 |
import bisect
n=int(eval(input()))
L=[]*n
L=list(map(int,input().split()))
L.sort()
cnt=0
for i in range(n-2):
for j in range(i+1,n-1):
ab=L[i]+L[j]
num=bisect.bisect_left(L[j+1:],ab)
cnt+=num
print(cnt) | import bisect
n=int(eval(input()))
L=[]*n
L=list(map(int,input().split()))
L.sort()
cnt=0
for i in range(n-2):
for j in range(i+1,n-1):
ab=L[i]+L[j]
num=bisect.bisect_left(L,ab,j+1,n)-j-1
cnt+=num
print(cnt) | p02888 |
import sys
import itertools
import bisect
import math
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
n = ni()
l = na()
l.sort()
ct = 0
for i in range(n):
for j in range(i+1, n):
tmp = l[i] + l[j]
ct += bisect.bisect_left(l[j+1:], tmp)
print(ct)
| import sys
import itertools
import bisect
import math
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
n = ni()
l = na()
l.sort()
ct = 0
for i in range(n):
for j in range(i+1, n):
tmp = l[i] + l[j]
ct += bisect.bisect_left(l, tmp) - (j + 1)
print(ct)
| p02888 |
import bisect
N = int(eval(input()))
L = sorted(list(map(int,input().split())))
lenl = len(L)
count = 0
for i in range(0,lenl-2):
for j in range(i+1,lenl-1):
count += bisect.bisect_left(L[j+1:],L[i]+L[j])
print(count) | import bisect
N = int(eval(input()))
L = sorted(list(map(int,input().split())))
lenl = len(L)
count = 0
for i in range(0,lenl-2):
for j in range(i+1,lenl-1):
count += bisect.bisect_left(L,L[i]+L[j])-j-1
print(count) | p02888 |
import itertools
n = int(eval(input()))
cnt = 0
l = list(map(int, input().split()))
for a, b, c in itertools.combinations(l, 3):
if abs(b - c) < a < b + c:
cnt += 1
print(cnt) | import bisect
n = int(eval(input()))
cnt = 0
l = sorted(list(map(int, input().split())))
for a in range(n - 2):
for b in range(a + 1, n - 1):
c_min = b + 1
c_max = bisect.bisect_left(l, l[a] + l[b]) - 1
cnt += c_max - c_min + 1
print(cnt) | p02888 |
N = int(eval(input()))
L = list(map(int,input().split()))
L.sort()
ans = 0
for i in range(N-2):
for j in range(i+1,N-1):
for k in range(j+1,N):
if L[k] < L[i] + L[j]:
ans += 1
else:
break
print(ans) | N = int(eval(input()))
L = list(map(int,input().split()))
L.sort()
ans = 0
x = []
for i in range(N-2):
check = 0
for j in range(i+1,N-1):
for k in range(j+1+check,N):
if L[k] < L[i]+L[j]:
check += 1
else:
break
ans += check
check -= 1
print(ans) | p02888 |
n = int(eval(input()))
l = list(map(int,input().split()))
ans = 0
l.sort()
for i in range(n):
for j in range(i+1,n):
for k in range(j+1,n):
if l[i]+l[j]>l[k]:
ans += 1
else:
break
print(ans) | n = int(eval(input()))
l = list(map(int,input().split()))
ans = 0
l.sort()
def bisec(i,k): #ギリギリokなj<=j_を探す
ci = i
ck = k
i+=1
k-=1
j = int((i+k)/2)
while k-i>1:
if l[ci]+l[j]>l[ck]:
k = j
j = int((i+k)/2)
else:
i = j+1
j = int((i+k)/2)
if l[ci]+l[i]>l[ck]:
return True,i
elif l[ci]+l[i+1]>l[ck]:
return True,i+1
else:
return False,-1
for i in range(n):
for k in range(i+2,n):
f,j = bisec(i,k)
if f:
ans += k-j
print(ans) | p02888 |
n = int(eval(input()))
l = list(map(int, input().split()))
l.sort(reverse=True)
m = sorted(l)
#print(l)
# print(m)
import bisect
ans = 0
for i in range(n-2):
a = l[i]
for j in range(i+1,n-1):
b = l[j]
x = a-b
ind = bisect.bisect_right(m,x)
#print(a, b, j, ind)
if n-1-j-ind >= 0:
ans += n-1-j-ind
print(ans)
| n = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
import bisect
ans = 0
for i in range(n-2):
b = L[i]
for j in range(i+1, n-1):
c = L[j]
p = bisect.bisect_left(L, b+c)
#print(b, c, j, p, p-j-1)
ans += max(p-j-1, 0)
print(ans) | p02888 |
import itertools
n = int(eval(input()))
lis = list(map(int,input().split()))
a = tuple(itertools.combinations(lis,3))
b = 0
for i in a:
if i[0] < i[1] + i[2] and i[1] < i[2] + i[0] and i[2] < i[0] + i[1]:
b += 1
print(b)
| import bisect
n = int(eval(input()))
lis = list(map(int,input().split()))
a = sorted(lis, reverse=True)
c = sorted(lis)
d = 0
for i in range(n):
for j in range(i + 1, n):
e = c[:-j-1]
b = bisect.bisect_right(e, int(a[i]-a[j]))
d += max(0, len(e) - b)
print(d)
| p02888 |
n = int(eval(input()))
L = list(map(int, input().split()))
# 各数値が何個あるか
C = [0]*(2100)
for l in L:
C[l] += 1
# 累積和を作成する
S = [0]
for i in range(2100):
S.append(S[i]+C[i])
ans = 0
for i in range(n):
for j in range(n):
if i == j:
continue
left = abs(L[i]-L[j])+1
right = L[i]+L[j]
tmp = S[right]-S[left]
if left <= L[i] <= right:
tmp -= 1
if left <= L[j] <= right:
tmp -= 1
ans += max(0, tmp)
print((ans//6))
| import bisect
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
ans = 0
for i in range(N-1):
for j in range(i+1, N-1):
idx = bisect.bisect_left(L, L[i]+L[j])
ans += max(0, idx-j-1)
print(ans)
| p02888 |
N = int(eval(input()))
L = list(map(int, input().split()))
import itertools
com = list(itertools.combinations(L, 3))
count = 0
for i in com:
#print(i)
if (i[0] < i[1] + i[2]) and (i[1] < i[0] + i[2]) and (i[2] < i[1] + i[0]):
count += 1
print(count) |
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
#print(L)
count = 0
for i in range(N):
for j in range(i+1, N):
for k in range(j+1, N):
#print(i, j, k)
#print(L[i], L[j], L[k])
#print(L[i] + L[j] > L[k])
if L[k] >= L[i] + L[j]:
break
count += 1
print(count) | p02888 |
n = int(eval(input()))
l_ls = list(map(int, input().split()))
l_ls.sort()
def check(a,b,c):
return abs(a-b) < c < a+b
ans = 0
for i in range(n):
short = l_ls[i]
num = 0
r = i+1
for l in range(i+1,n):
while r+1 < n and check(short, l_ls[l], l_ls[r+1]):
r += 1
num += r - l
if r == l:
r += 1
ans += num
print(ans)
| n = int(eval(input()))
a_ls = list(map(int, input().split()))
def isOK(a,b,c):
return abs(a-b) < c < a+b
a_ls.sort()
ans = 0
for i in range(n):
short = a_ls[i]
r = i+1
num = 0
for l in range(i+1,n-1):
while r+1 < n and isOK(short, a_ls[l], a_ls[r+1]):
r += 1
num += r - l
if l == r:
r += 1
ans += num
print(ans) | p02888 |
import itertools
def main():
n = int(input())
parts = list(map(int, input().split()))
result = 0
conditions = [
lambda a,b,c: a<b+c,
lambda a,b,c: b<c+a,
lambda a,b,c: c<a+b,
]
for comb in itertools.combinations(parts, 3):
if all([func(*comb) for func in conditions]):
result += 1
print(result)
main() | def main():
n = int(input())
sticks = list(sorted(map(int, input().split())))
result = 0
for x in range(n):
z = x + 2
for y in range(x+1, n):
while (z < n and sticks[x] + sticks[y] > sticks[z]):
z += 1
result += z - y -1
print(result)
main()
| p02888 |
N=int(eval(input()))
y=list(map(int, input().split()))
from itertools import combinations
C=list(combinations(list(range(N)), 3))
def cond(a, b, c):
c1=a+b>c
c2=b+c>a
c3=c+a>b
if c1 and c2 and c3:
return True
else:
return False
ans=0
for c in C:
if cond(y[c[0]], y[c[1]], y[c[2]]):
ans+=1
print(ans)
| N=int(eval(input()))
y=list(map(int, input().split()))
y.sort()
ans=0
for i in range(N-2):
for j in range(i+1, N-1):
tmp=y[i]+y[j]
for k in range(j+1, N):
if y[k]<tmp:
ans+=1
else:
break
print(ans) | p02888 |
from bisect import bisect_left
N=int(eval(input()))
y=list(map(int, input().split()))
y.sort()
ans=0
for i in range(N-2):
for j in range(i+1, N-1):
tmp=y[i]+y[j]
ans+=bisect_left(y[(j+1):],tmp)
print(ans) | from bisect import bisect_left
N=int(eval(input()))
y=list(map(int, input().split()))
y.sort()
ans=0
for i in range(N-2):
for j in range(i+1, N-1):
tmp=y[i]+y[j]
ans+=bisect_left(y,tmp)-j-1
print(ans)
| p02888 |
import itertools
N = int(eval(input()))
L = [int(a) for a in input().split()]
comb_sides = list(itertools.combinations(L, 3))
num_triangles = 0
for sides in comb_sides:
if sides[0] + sides[1] > sides[2] and sides[1] + sides[2] > sides[0] and sides[2] + sides[0] > sides[1]:
num_triangles += 1
print(num_triangles)
| N = int(eval(input()))
L = [int(a) for a in input().split()]
L.sort()
num_triangles = 0
for i in range(0, N - 2): # 0, 1, ..., N - 3
for j in range(i + 1, N - 1): # i+1, i+2, ..., N-2
for k in range(j + 1, N):
if L[i] + L[j] <= L[k]:
break
else:
num_triangles += 1
print(num_triangles)
| p02888 |
from itertools import combinations,combinations_with_replacement
N = int(eval(input()))
L = list(map(int, input().split()))
comb_list = list(combinations(L,3))
ans = 0
for i in range(len(comb_list)):
a, b, c = comb_list[i]
if (a < b + c) and (b < a + c) and (c < a + b):
ans += 1
print(ans) | def findnumberofTriangles(arr):
n = len(arr)
arr.sort()
count = 0
for i in range(0,n-2):
k = i + 2
for j in range(i+1,n):
while (k < n and arr[i] + arr[j] > arr[k]):
k += 1
if(k>j):
count += k - j - 1
return count
N = int(eval(input()))
L = list(map(int, input().split()))
print((findnumberofTriangles(L))) | p02888 |
n = int(eval(input()))
l = list(map(int, input().split()))
def meguru_nibutan(ar,m,key):
a = m
b = len(ar)
while(abs(a-b) > 1):
c = (a+b)//2
if (ar[c] > key):
a = c
else:
b = c
return a
def main():
cnt = 0
l.sort(reverse=True)
for a in range(0,n-2):
for b in range(a+1,n-1):
cnt += meguru_nibutan(l,b,l[a]-l[b]) - b
print(cnt)
if (__name__ == "__main__"):
main() | import bisect
n = int(eval(input()))
l = list(map(int, input().split()))
def meguru_nibutan(ar,m,key):
a = m
b = len(ar)
while(abs(a-b) > 1):
c = (a+b)//2
if (ar[c] > key):
a = c
else:
b = c
return a
def main():
cnt = 0
l.sort()
for a in range(0,n-2):
for b in range(a+1,n-1):
#cnt += meguru_nibutan(l,b,l[a]-l[b]) - b
cnt += bisect.bisect_left(l,l[a]+l[b]) - 1 - b
print(cnt)
if (__name__ == "__main__"):
main() | p02888 |
N=int(eval(input()))
L=list(map(int,input().split()))
import bisect
L.sort()
ans=0
i=0
while i<N-2:
j=i+1
while j<N-1:
x=bisect.bisect_left(L[j+1:],L[i]+L[j])
ans+=x
j+=1
i+=1
print(ans)
| N=int(eval(input()))
L=list(map(int,input().split()))
L.sort()
ans=0
i=0
while i<N-2:
j=i+1
k=j+1
while j<N-1:
while k<N:
if L[i]+L[j]<=L[k]:
ans+=k-j-1
break
k+=1
if k==N:
ans+=k-1-j
j+=1
i+=1
print(ans) | p02888 |
from itertools import combinations
n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
comb = list(combinations(l,3))
ans = 0
for c in comb:
if c[0] + c[1] - c[2] > 0:
ans += 1
print(ans)
| n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
# print(l)
ans = 0
for i in range(len(l)):
for j in range(i+1, len(l)):
k = j + 1
if k == len(l):
continue
if l[i] + l[j] <= l[k]:
continue
while k + 1 < len(l) and l[i] + l[j] > l[k+1]:
k += 1
ans += k - j
print(ans)
| p02888 |
def main():
n = int(eval(input()))
l_list = list(map(int, input().split()))
l_list.sort()
max_l = max(l_list)
ans = 0
for i, a in enumerate(l_list):
for j, b in enumerate(l_list[i+1:]):
if b - a > max_l:
break
for k, c in enumerate(l_list[i+1+j+1:]):
# if is_ok(a, b, c):
if c < a + b:
ans += 1
else:
break
print(ans)
if __name__ == '__main__':
main()
| import bisect
def main():
n = int(eval(input()))
l_list = list(map(int, input().split()))
l_list.sort()
ans = 0
for i, a in enumerate(l_list):
for j, b in enumerate(l_list[i+1:]):
x = a + b
temp = bisect.bisect_left(l_list, x)
ans += temp - (i + 1 + j + 1)
print(ans)
if __name__ == '__main__':
main()
| p02888 |
N=int(eval(input()))
L=list(map(int,input().split()))
L.sort()
from bisect import bisect_left
ans = 0
for i1 in range(N-2):
for i2 in range(i1+1,N-1):
l1,l2 = L[i1],L[i2]
th = bisect_left(L[i2+1:],l1+l2)
#print(l1,l2,L[i2+1:],(l2-l1+1)*(-1),th)
ans += th
print(ans) | N=int(eval(input()))
L=list(map(int,input().split()))
L.sort()
from bisect import bisect_left
ans = 0
for i1 in range(N-2):
for i2 in range(i1+1,N-1):
l1,l2 = L[i1],L[i2]
#th = bisect_left(L[i2+1:],l1+l2)
#print(l1,l2,L[i2+1:],(l2-l1+1)*(-1),th)
th = bisect_left(L,l1+l2)
ans += max(th-i2-1,0)
print(ans) | p02888 |
n=eval(input())
li=list(map(int,input().split()))
li.sort()
mod_li=[[i,num] for i,num in enumerate(li)]
result=0
for i in range(len(li)-2):
for j in range(i+1,len(li)-1):
temp_li=[num for num in mod_li[j+1:]]
while(len(temp_li)>1):
if temp_li[len(temp_li)//2][1]>=li[i]+li[j]:
temp_li=temp_li[:len(temp_li)//2]
else:
temp_li=temp_li[len(temp_li)//2:]
if temp_li[0][1]>=li[i]+li[j]:
result+=temp_li[0][0]-j-1
else:
result+=temp_li[0][0]-j
print(result) | n=eval(input())
li=list(map(int,input().split()))
li.sort()
#mod_li=[[i,num] for i,num in enumerate(li)]
result=0
for i in range(len(li)-2):
tmp=i+2
for j in range(i+1,len(li)-1):
for k in range(tmp,len(li)):
if li[i]+li[j]<=li[k]:
tmp=k-1
if tmp-j>0:
result+=tmp-j
break
elif k==len(li)-1:
tmp=k
result+=tmp-j
break
print(result) | p02888 |
from bisect import bisect_left
def main():
N = int(eval(input()))
L = sorted(list(map(int, input().split())))
ans = 0
for ia in range(N):
for ib in range(ia+1, N-1):
a = L[ia]
b = L[ib]
ic_end = bisect_left(L, a+b, lo=ib+1)
ans += ic_end - (ib+1)
print(ans)
main() | def main():
N = int(eval(input()))
L = sorted(list(map(int, input().split())))
ans = 0
for ia in range(N-2):
a = L[ia]
ic = ia + 2
for ib in range(ia+1, N-1):
b = L[ib]
while ic < N and L[ic] < a+b:
ic += 1
ans += ic - (ib + 1)
print(ans)
main() | p02888 |
import copy
N = int(eval(input()))
L = list(map(int,input().split()))
cnt = 0
for a in L:
L2 = copy.deepcopy(L)
L2.remove(a)
for b in L2:
L3 = copy.deepcopy(L2)
L3.remove(b)
for c in L3:
if a<b+c and b<c+a and c<a+b:
cnt+=1
print((cnt//6)) | import bisect
n=int(eval(input()))
a=list(map(int,input().split()))
a=sorted(a)
ans=0
for i in range(n-2):
for j in range(i+1,n-1):
tmp=a[i]+a[j]
index=bisect.bisect_left(a,tmp)
ans+=index-j-1
print(ans) | p02888 |
n = int(eval(input()))
l = list(map(int,input().split()))
l.sort()
#s = input()
ans = 0
for i in range(n-2):
for j in range(i+1,n-1):
tmp = l[i] + l[j]
for k in range(j+1,n):
#print(i,j,k)
if tmp > l[k]:
ans += 1
else:
break
print(ans) | import bisect as bi
n = int(eval(input()))
l = list(map(int,input().split()))
l.sort()
#print(l)
ans = 0
for i in range(n-2):
for j in range(i+1,n-1):
ans += (bi.bisect_left(l,l[i]+l[j]))-j-1
#print(i,j,bi.bisect_right(l,l[i]+l[j])-j-1)
#print(ans)
print(ans) | p02888 |
import sys
import bisect
input = sys.stdin.readline
def main():
N = int(eval(input()))
L = sorted(map(int, input().strip().split()))
bleft = bisect.bisect_left
bright = bisect.bisect
ans = 0
for i, a in enumerate(L):
if i > N-2:
break
for j, b in enumerate(L):
if j > N-1:
break
if j <= i:
continue
# print(a, b)
c_right = bleft(L, a+b)
# print(c_right)
if c_right == 0:
continue
now_seq = L[j+1:c_right]
c_left = bright(now_seq, b-a)
if c_left == N:
continue
ans += len(now_seq) - c_left
print(ans)
if __name__ == '__main__':
main()
| import sys
import bisect
input = sys.stdin.readline
def main():
N = int(eval(input()))
L = sorted(map(int, input().strip().split()))
bleft = bisect.bisect_left
bright = bisect.bisect
ans = 0
for i, a in enumerate(L):
if i > N-2:
break
for j, b in enumerate(L):
if j > N-1:
break
if j <= i:
continue
c_right = bleft(L[j+1:], a+b)
ans += c_right
print(ans)
if __name__ == '__main__':
main()
| p02888 |
# D TLE
import itertools
import bisect
N = list(map(int, input().split()))
L = list(map(int, input().split()))
L.sort()
value = 0
for i, j in itertools.combinations(list(range(len(L)-1)), 2):
index = bisect.bisect_left(L[j+1:], L[i]+L[j])
value+=index
print(value) | n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
from bisect import bisect_left
ans = 0
for i in range(n):
for j in range(i+1, n):
t = l[i]+l[j]
idx = bisect_left(l, t)
ans += max(0, idx-j-1)
print(ans) | p02888 |
N = int(eval(input()))
L = list(map(int, input().split()))
import itertools
l = list(itertools.combinations(L, 3))
a = 0
n = 0
for x in range(len(l)):
m = max(l[n])
if m < sum(l[n]) - m:
a += 1
n += 1
else:
n += 1
print(a) | N = int(eval(input()))
l = [int(x) for x in input().split()]
l.sort(reverse=True)
ans = 0
for i in range(N-2):
for j in range(i+1, N-1):
a = l[j+1:]
for x in range(len(a)):
if l[i] < l[j] + a[x] and abs(l[j] - a[x]) < l[i]:
ans += 1
print(ans) | p02888 |
import itertools
n=int(eval(input()))
l=list(map(int,input().split(' ')))
ans=0
for com in list(itertools.combinations(l,3)):
com=sorted(com)
if com[2]<com[0]+com[1]:
ans+=1
print(ans) | n=int(eval(input()))
l=list(map(int,input().split(' ')))
ans=0
for i in range(0,n-2):
for j in range(i+1,n-1):
for k in range(j+1,n):
if l[i]<l[j]+l[k]:
if l[j]<l[i]+l[k]:
if l[k]<l[i]+l[j]:
ans+=1
else:
continue
print(ans) | p02888 |
import itertools
n = int(eval(input()))
L = list(map(int, input().split()))
#%%
ans = 0
for c in itertools.combinations(L, 3):
if (c[0] < c[1] + c[2]) and (c[1] < c[0] + c[2]) and (c[2] < c[0] + c[1]):
ans += 1
print(ans)
| import bisect
n = int(eval(input()))
L = list(map(int, input().split()))
#%%
L.sort()
ans = 0
for i in range(n-2): # aを固定
for j in range(i+1, n-1): # bを固定
ab = L[i] + L[j]
idx = bisect.bisect_left(L, ab, lo=j)
ans += max(idx - (j+1), 0)
print(ans)
| p02888 |
import itertools
n = eval(input())
lengths = list(map(int, input().split()))
len_combs = list(itertools.combinations(lengths, 3))
res = sum([a < b + c and b < c + a and c < a + b for a, b, c in len_combs])
print(res)
| n = int(eval(input()))
lengths = list(map(int, input().split()))
res = 0
sorted_lengths = sorted(lengths)[::-1]
for i in range(n):
l1 = sorted_lengths[i]
for j in range(i+1, n):
l2 = sorted_lengths[j]
res += sum([l1 - l2 < _ < l1 + l2 for _ in sorted_lengths[j + 1:]])
print(res)
| p02888 |
from bisect import bisect_left
n = int(eval(input()))
lengths = sorted(map(int, input().split()))
res = 0
for i in range(n):
l1 = lengths[i]
for j in range(i + 1, n - 1):
l2 = lengths[j]
rem = lengths[j + 1:]
res += bisect_left(lengths, l1 + l2, j + 1) - j - 1
print(res) | from bisect import bisect_left
n = int(eval(input()))
lengths = sorted(map(int, input().split()))
res = 0
for i in range(n):
l1 = lengths[i]
for j in range(i + 1, n - 1):
l2 = lengths[j]
res += bisect_left(lengths, l1 + l2, j + 1) - j - 1
print(res) | p02888 |
# n = int(input())
# a, b = map(int, input().split())
# an = list(map(int, input().split()))
n = int(eval(input()))
ln = list(map(int, input().split()))
ln.sort(reverse=True)
bcs = []
for i in range(1, n-1):
row = []
for j in range(i+1, n):
row.append(ln[i] + ln[j])
bcs.append(row)
cnt = 0
ix = [0 for _ in range(n-2)]
# a > b,c
for i in range(n-2):
a = ln[i]
for j in range(i, n-2):
try:
while ix[j] < (n - 2 - j) and bcs[j][ ix[j] ] > a:
ix[j] += 1
except:
print((j, ix[j]))
exit()
cnt += sum(ix[i:])
print(cnt) | n = int(eval(input()))
ln = list(map(int, input().split()))
ln.sort(reverse=True)
bcs = []
for i in range(1, n-1):
row = []
for j in range(i+1, n):
row.append(ln[i] + ln[j])
bcs.append(row)
cnt = 0
ix = [0 for _ in range(n-2)]
# a > b,c
for i in range(n-2):
a = ln[i]
for j in range(i, n-2):
try:
while ix[j] < (n - 2 - j) and bcs[j][ ix[j] ] > a:
ix[j] += 1
except:
print((j, ix[j]))
exit()
cnt += sum(ix[i:])
print(cnt) | p02888 |
N = int(eval(input()))
L = list(map(int, input().split()))
def check_triangle(a, b, c):
if a < b + c and b < c + a and c < a + b:
return True
return False
sum = 0
L.sort()
for i, l_1 in enumerate(L[:-2]):
for j, l_2 in enumerate(L[i+1:-1]):
for l_3 in L[i + j + 2:]:
if check_triangle(l_1, l_2, l_3):
sum += 1
else:
break
print(sum)
| N = int(eval(input()))
L = list(map(int, input().split()))
count = 0
L.sort()
for i in range(N-2):
k = i + 2
for j in range(i+1,N):
while (k<N and L[i] + L[j] > L[k]):
k += 1
if k > j:
count += k - j - 1
print(count)
| p02888 |
import itertools
N = int(eval(input()))
L = list(map(int, input().split()))
cnt = 0
for a, b, c in list(itertools.combinations(L,3)):
if a<b+c and b<a+c and c<a+b:
cnt += 1
print(cnt) | N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
cnt = 0
for i in range(N-2):
a = L[i]
for j in range(i+1, N-1):
b = L[j]
for s in range(N-1, j, -1):
c = L[s]
if L[s]<L[i]+L[j]:
cnt += s - j
break
print(cnt) | p02888 |
import itertools
N = int(eval(input()))
L =list(map(int,input().split()))
S = []
ans = 0
for i, j, k in itertools.combinations(L,3):
S.append([i, j, k])
for a, b, c in S:
if a < b + c and b < c + a and c < a + b:
ans += 1
print(ans) | import bisect
N = int(eval(input()))
L = list(map(int,input().split()))
L = sorted(L)
ans = 0
for i in range(N):
for j in range(i+1,N):
x = bisect.bisect_left(L,L[i] + L[j])
ans += x - j - 1
print(ans) | p02888 |
n=int(eval(input()))
L=list(map(int,input().split()))
L=sorted(L)
from itertools import combinations
from bisect import bisect_right,bisect_left
comb=combinations(L, 2)
cnt=0
for cb in comb:
b,c=min(cb), max(cb)
# a must be b or lower
hi=bisect_left(L, b)
low=bisect_right(L, c-b)
#print(b,c,hi,low)
cnt+=max(0,hi-low)
print(cnt) | from bisect import bisect_left
n=int(eval(input()))
L=list(map(int,input().split()))
L=sorted(L)
ans=0
for i in range(n-2):
a=L[i]
for j in range(i+1,n-1):
ans+=bisect_left(L,a+L[j])-j-1
print(ans)
| p02888 |
n = int(eval(input()))
l = list(map(int, input().split()))
l = sorted(l, reverse = True)
ans = []
for i in range(len(l)-2):
for j in range(len(l)-2-i):
if l[i] > 2 * l[i+j+1]:
break
for k in range(len(l)-2-i-j):
if l[i] < l[i+j+1] + l[i+j+k+2]:
if [l[i], l[i+j+1], l[i+j+k+2]] not in ans:
ans.append([l[i], l[i+j+1], l[i+j+k+2]])
else:
break
print((len(ans)))
| n = int(eval(input()))
l = list(map(int, input().split()))
l.sort(reverse=True)
ans = 0
for i in range(n-2):
j = i+1
k = n-1
while (j < k):
if l[i] - l[j] - l[k] < 0:
ans += k - j
j += 1
else:
k -= 1
print(ans)
| p02888 |
import bisect
N = int(eval(input()))
arr = list(map(int,input().split()))
arr = sorted(arr)
cnt = 0
for i in range(N-1):
for j in range(N-i-1):
a = arr[i]
b = arr[i+j+1]
if (i+j+2) < N:
k = i+j+2
upper = bisect.bisect_left(arr[k:], (a+b))
cnt += upper
print(cnt) | n=int(eval(input()))
a=list(map(int,input().split()))
a = sorted(a)
def trian(a):
n=len(a)
res = 0
# 最小辺x
for x in range(n):
z=x+2
# 真ん中の辺y
for y in range(x+1,n):
# 最大の辺z
# nより小さく、二辺の和よりも小さい
while(z<n and a[x]+a[y]>a[z]):
z+=1
# y+1から毎回数えるのではなく、yが増えれば、zも増えるのを利用し、前回の値を保存しておく
res += z-y-1
return res
print((trian(a)))
| p02888 |
N = int(eval(input()))
L = sorted(map(int, input().split()), reverse=True)
cnt = 0
for i in range(N - 2):
c = L[i]
for j in range(i + 1, N - 1):
b = L[j]
l = j
r = N - 1
while True:
idx = -(-(l + r) // 2)
if L[idx] > abs(b - c):
if l == idx:
break
l = idx
else:
if r == idx:
break
r = idx
cnt += l - j
print(cnt) | N = int(eval(input()))
L = sorted(map(int, input().split()), reverse=True)
cnt = 0
for i in range(N - 2):
c = L[i]
for j in range(i + 1, N - 1):
b = L[j]
l = j
r = N - 1
while True:
idx = -(-(l + r) // 2)
if L[idx] > c - b:
if l == idx:
break
l = idx
else:
if r == idx:
break
r = idx
cnt += l - j
print(cnt) | p02888 |
N = int(eval(input()))
L = list(map(int,input().split()))
ans = 0
for i in range(N-2):
for j in range(i+1,N-1):
for k in range(j+1,N):
li = L[i]
lj = L[j]
lk = L[k]
if ((li+lj)>lk)&((lj+lk)>li)&((li+lk)>lj):
ans += 1
else:
continue
print(ans) | N = int(eval(input()))
L = list(map(int,input().split()))
import bisect
L.sort()
ans = 0
for i in range(N-2):
for j in range(i+1,N-1):
ans += bisect.bisect_left(L,L[i]+L[j])-(j+1)
print(ans) | p02888 |
from bisect import bisect_left, bisect_right
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
ans = 0
for i, a in enumerate(L):
for j, b in enumerate(L[i+1:]):
l = abs(a - b)
r = a + b
top = bisect_left(L[i+j+2:], r)
bot = bisect_right(L[i+j+2:], l)
ans += top - bot
print(ans)
| from bisect import bisect_left, bisect_right
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
ans = 0
for i in range(N-1, 1, -1):
for j in range(i - 1, 0, -1):
x = L[i] - L[j]
bottom = bisect_right(L, x)
if j > bottom:
ans += j - bottom
print(ans)
| p02888 |
n = int(eval(input()))
l = list(map(int, input().split()))
ans = 0
for i in range(n):
for j in range(i + 1, n):
for k in range(j + 1, n):
if l[i] < l[j] + l[k] and l[j] < l[i] + l[k] and l[k] < l[j] + l[i]:
ans += 1
print(ans)
| from bisect import bisect_left
n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
ans = 0
for i in range(n - 2):
for j in range(i + 1, n - 1):
ans += bisect_left(l, l[i] + l[j]) - j - 1
print(ans) | p02888 |
import itertools as it
n = eval(input())
l = list(map(int, input().split()))
l.sort()
triangles = set()
for a, b, c in it.combinations(l, 3):
if a + b > c and b + c > a and a + c > b:
triangles.add((a, b, c))
print((len(triangles))) | n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
count = 0
for i in range(0,n-2):
k = i + 2
for j in range(i+1,n):
while (k < n and l[i] + l[j] > l[k]):
k += 1
if(k>j):
count += k - j - 1
print(count) | p02888 |
import itertools
import sys
def main():
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 7)
n = int(eval(input()))
L = tuple(map(int, readline().split()))
cnt = 0
ls = tuple(itertools.combinations(L, 3))
for l in ls:
if sum(l) > max(l)*2:
cnt += 1
print(cnt)
if __name__ == '__main__':
main()
| import itertools
import sys
def main():
input = sys.stdin.readline
n = int(eval(input()))
L = list(map(int, input().split()))
cnt = 0
ls = itertools.combinations(L, 3)
for l in ls:
if sum(l) > max(l)*2:
cnt += 1
print(cnt)
if __name__ == '__main__':
main()
| p02888 |
from itertools import combinations
def check(l):
for i in range(3):
a = l[i % 3]
b = l[(i + 1) % 3]
c = l[(i + 2) % 3]
if a >= b + c:
return False
return True
n = int(eval(input()))
l = list(map(int , input().split()))
cnt = 0
for v in combinations(l, 3):
if check(v):
cnt += 1
print(cnt) | from bisect import bisect_left
n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
cnt = 0
for i in range(n-2):
a = l[i]
for j in range(i+1, n-1):
b = l[j]
cnt += bisect_left(l, a+b) - j - 1
# bisec_left(l, x)でlの中にxを挿入できる点を探す
print(cnt)
| p02888 |
N = int(eval(input()))
L = list(map(int, input().split()))
L_sorted = sorted(L)
def bis(left, right, SrcList, value):
if SrcList[left] >= value:
return -1 # no results
elif SrcList[right] < value:
return -2 # all results
while (left + 1 < right):
mid = (left + right) // 2
if SrcList[mid] < value:
left = mid
else:
right = mid
return left
count = 0
for i in range(0, N-2):
for j in range(i+1,N-1):
r = bis(j+1, N-1, L_sorted, L_sorted[i] + L_sorted[j])
if r == -1:
pass
elif r == -2:
count += ((N-j) * (N-j-1))//2
break
else:
count += r-j
print(count) | from bisect import bisect_right
N = int(eval(input()))
L = list(map(int, input().split()))
L_sorted = sorted(L)
count = 0
for i in range(N): # longest stick
for j in range(i): # second longest stick
r = bisect_right(L_sorted, L_sorted[i] - L_sorted[j])
count += max(0, j - r)
print(count) | p02888 |
from bisect import bisect_right
N = int(eval(input()))
L = list(map(int, input().split()))
L_sorted = sorted(L)
count = 0
for i in range(N): # longest stick
for j in range(i): # second longest stick
r = bisect_right(L_sorted, L_sorted[i] - L_sorted[j])
count += max(0, j - r)
print(count) |
from bisect import bisect_right
N = int(eval(input()))
L = list(map(int, input().split()))
L_sorted = sorted(L)
count = 0
for i in range(N): # longest stick
for j in reversed(list(range(i))): # second longest stick
r = bisect_right(L_sorted, L_sorted[i] - L_sorted[j])
if j <= r:
break
else:
count += j - r
print(count) | p02888 |
n=int(eval(input()))
l=list(map(int,input().split()))
import bisect
ans=0
l.sort()
for i in range(n):
a=l[i]#一番短い棒を確定
for j in range(i+1,n):
b=l[j]#二番目に短い棒を確定
ind=bisect.bisect_left(l,a+b)#二辺の和と同じだったら耐えないので，left
ans+=max(0,ind-(j+1))#三角形の成立条件と，一番長い棒であることを考える
print(ans) | import bisect
def main():
n = int(eval(input()))
ls = sorted(list(map(int, input().split())))
ans = 0
for i in range(n-1):
for j in range(i+1, n):
a = ls[i]
b = ls[j]
k = bisect.bisect_left(ls, a+b)
if k > j:
ans += k - j - 1
print(ans)
if __name__ == "__main__":
main() | p02888 |
import bisect
n = int(eval(input()))
l = sorted(map(int, input().split()))
ans = 0
for i in range(2,n)[::-1]:
for j in range(1,i)[::-1]:
a = bisect.bisect_left(l, l[i] + l[j] - 1, 0, j-1)
b = bisect.bisect_right(l, l[i] - l[j], 0, j-1)
#print(l[i] + l[j], l[i] , l[j], a, l[i] - l[j], l[i] - l[j] < l[a], a, b, l[:j])
if l[i] - l[j] < l[a]:
ans += a - b + 1
print(ans)
| import bisect
n = int(eval(input()))
l = sorted(map(int, input().split()))
ans = 0
for i in range(n-2):
for j in range(i+1,n-1):
ans += bisect.bisect_left(l,l[j]+l[i])-j-1
print(ans)
| p02888 |
N=int(eval(input()))
Ln=list(map(int,input().split()))
Ln.sort(reverse=True)
Ans=0
for i in range(N-2):
di=i+1
for j in range(N-di-1):
dj=di+j+1
for k in range(N-dj):
dk=dj+k+1
a=Ln[di-1]
b=Ln[dj-1]
c=Ln[dk-1]
if((a+b)>c)&((b+c)>a)&((c+a)>b) :
Ans +=1
print(Ans) | N=int(eval(input()))
Ln=list(map(int,input().split()))
Ln.sort(reverse=True)
Ans=0
left=0
right=0
for i in range(N-2):
di=i+1
for j in range(N-di-1):
dj=di+j+1
A=Ln[di-1]
B=Ln[dj-1]
if (B+Ln[dj])<A : break
right=N-1
left=dj
while left<=right :
mid=int((right+left)/2)
if (B+Ln[mid])>A :
left=mid+1
else :
right=mid-1
Ans+=(left-1)-(dj-1)
print(Ans) | p02888 |
import sys
N=int(eval(input()))
L=list(map(int,input().split()))
L.sort(reverse=True)
total = 0
def bisect_left_reverse(a, x):
'''
reverseにソートされたlist aに対してxを挿入できるidxを返す。
xが存在する場合には一番左側のidxとなる。
'''
if a[0] <= x:
return 0
if x < a[-1]:
return len(a)
# 二分探索
ok = len(a) - 1
ng = 0
while (abs(ok - ng) > 1):
mid = (ok + ng) // 2
if a[mid] <= x:
ok = mid
else:
ng = mid
return ok
for i in range(N):
for j in range(i + 1, N):
a = L[i] - L[j]
total += max(bisect_left_reverse(L, a) - j - 1, 0)
print(total)
| import sys
from bisect import bisect_left
N=int(eval(input()))
L=list(map(int,input().split()))
L.sort()
total = 0
for i in range(N):
for j in range(i + 1, N):
a = L[i] + L[j]
total += max(bisect_left(L, a) - j - 1, 0)
print(total) | p02888 |
# -*- coding: utf-8 -*-
N = int(eval(input()))
L = list(map(int, input().split()))
tri = 0
ran = list(range(N-2))
for i in ran:
for j in ran:
for k in range(N-2-i-j):
if ((L[i] + L[i+j+1]) > L[i+j+k+2]) and ((L[i] + L[i+j+k+2]) > L[i+j+1]) and ((L[i+j+k+2] + L[i+j+1]) > L[i]):
tri += 1
print(tri) | # -*- coding: utf-8 -*-
N = int(eval(input()))
L = list(map(int, input().split()))
def main():
tri = 0
L.sort()
for i in range(N-1,-1,-1): #range(初期値,終了条件,変化量)
mn = 0
sl = i-1
while(mn<sl):
if (L[mn] + L[sl]) > L[i]:
tri += sl - mn
sl -= 1
else:
mn += 1
print(tri)
main() | p02888 |
import sys
sys.setrecursionlimit(10**6)
n = int(eval(input()))
l = list(map(int, input().split()))
from itertools import combinations
l.sort()
ans = 0
seen = set()
for c in list(combinations(l,3)):
if c not in seen:
seen.add(c)
if c[0]+c[1]>c[2] and c[1]+c[2]>c[0] and c[2]+c[0]>c[1]:
ans += 1
print(ans) | import sys
sys.setrecursionlimit(10**6)
n = int(eval(input()))
l = list(map(int, input().split()))
from itertools import combinations
l.sort()
ans = 0
combs = set(combinations(l,3))
for c in combs:
if c[0]+c[1]>c[2] and c[1]+c[2]>c[0] and c[2]+c[0]>c[1]:
ans += 1
print(ans) | p02888 |
N=int(eval(input()))
L=list(map(int,input().split()))
L.sort()
count = 0
for i in range(N):
for j in range(i+1,N):
summation = L[i] + L[j]
subtract = L[j] - L[i]
D=L.copy()
del D[j]
del D[i]
#E=[ D[k] for k in range(N) if k!= i and k!= j ]
#求めるものはjよりも長くsummationよりも小さいもの
##summationより小さいかを二分探索
high = N-3
low = j-2
if D[0] >= summation:
upper = 0 #1つも満たさない
#print(L[i],L[j],D,upper)
elif D[-1] < summation:
upper = N-1-j #すべてOK
else:
while high > low+1:
mid =(high + low) // 2
if D[mid] >= summation: #大きすぎ
high = mid
# mid = low
else: #小さすぎかちょうど
low = mid
# mid =high
upper = high +1-j
#print("summation",summation,D,upper)
count += upper #-lower
print(count) | from bisect import bisect_left
N = int(eval(input()))
L = sorted(list(map(int, input().split())))
ans = 0
for i in range(N):
for j in range(i + 1, N):
a = L[i]
b = L[j]
idx = bisect_left(L, a + b)
ans += idx - 1 - j
print(ans) | p02888 |
def main():
N = int(eval(input()))
L = [int(i) for i in input().split()]
L.sort()
L_pair = []
for i in range(N):
for j in range(i+1, N):
L_pair.append((i, j))
def is_ok(mid, i, j):
if L[mid] < L[i] + L[j]:
return True
else:
return False
def binary_search_meguru(i, j):
left = j
right = N
while right - left > 1:
mid = left + ((right - left) // 2)
if is_ok(mid, i, j):
left = mid
else:
right = mid
return right
ans = 0
for i, j in L_pair:
r = binary_search_meguru(i, j)
ans += r - (j + 1)
print(ans)
if __name__ == '__main__':
main()
| def main():
from bisect import bisect_left
N = int(eval(input()))
L = [int(i) for i in input().split()]
L.sort()
ans = 0
for i in range(N):
for j in range(i+1, N):
ab = L[i] + L[j]
ri = bisect_left(L, ab)
le = j + 1
ans += ri - le
print(ans)
if __name__ == '__main__':
main()
| p02888 |
def main():
import sys
input = sys.stdin.buffer.readline
N = int(eval(input()))
L = [int(i) for i in input().split()]
L.sort()
# from bisect import bisect_left
ans = 0
for i in range(2, N):
# i番目を最長辺とする
for j in range(i):
for k in range(j+1, i):
if L[j]+L[k] > L[i]:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| def main():
import sys
input = sys.stdin.buffer.readline
N = int(eval(input()))
L = [int(i) for i in input().split()]
L.sort()
def is_ok(i, j, k):
if L[j]+L[k] > L[i]:
return True
else:
return False
def binary_search_meguru(i, j):
ng = -1
ok = j
while abs(ok - ng) > 1:
mid = ng + (ok - ng) // 2
if is_ok(i, j, mid):
ok = mid
else:
ng = mid
return ok
ans = 0
for i in range(2, N):
# i番目を最長辺とする
for j in range(i):
k = binary_search_meguru(i, j)
# print(i, j, k)
ans += j-k
print(ans)
if __name__ == '__main__':
main()
| p02888 |
N = int(eval(input()))
dlist = list(map(int, input().split()))
dlist.sort(reverse=True)
sum = 0
count_b = 0
count_c = 0
for a in range(N):
count_b += 1
count_c = count_b
for b in range(count_b, N):
count_c += 1
for c in range(count_c, N):
if dlist[a] < dlist[b] + dlist[c]:
sum += 1
else:
break
print(sum) | import bisect
N=int(eval(input()))
L=sorted(list(map(int,input().split())))
ans=0
for i in range(N-2):
for j in range(i+1,N-1):
ans+=bisect.bisect_left(L,L[i]+L[j])-j-1 # Code 1
# ans+=bisect.bisect_left(L,L[i]+L[j],j)-j-1 # Code 2
print(ans) | p02888 |
N = int(eval(input()))
L = list(map(int, input().split()))
ans = 0
for i in range(N-2):
a = L[i]
for j in range(i+1, N-1):
b = L[j]
for k in range(j+1, N):
c = L[k]
if a < b+c and b < c+a and c < a+b:
ans += 1
print(ans) | import bisect
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
ans = 0
for i in range(1, N-1):
for j in range(i+1, N):
ans += i - bisect.bisect_right(L[:i], L[j]-L[i])
print(ans)
| p02888 |
from bisect import bisect_left
n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
ans = 0
for i in range(n-2):
for j in range(i+1, n-1):
ans += bisect_left(l[j+1:], l[i]+l[j])
print(ans)
| from bisect import bisect_left
n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
ans = 0
for i in range(n-2):
for j in range(i+1, n-1):
ans += bisect_left(l, l[i]+l[j]) - j - 1
print(ans)
| p02888 |
import bisect
N = int(eval(input()))
Ls = list(map(int, input().split()))
sls = sorted(Ls)
count = 0
for i in range(N - 1):
for j in range(i+1, N):
cs = sls[j + 1:]
a, b = sls[i], sls[j]
count += bisect.bisect_left(cs, b + a)
print(count) | import bisect
N = int(eval(input()))
Ls = list(map(int, input().split()))
sls = sorted(Ls)
count = 0
for i in range(N - 1):
for j in range(i+1, N):
a, b = sls[i], sls[j]
right = bisect.bisect_left(sls, b + a)
count += right - j - 1
print(count) | p02888 |
n = int(eval(input()))
L = list(map(int,input().split()))
L.sort(reverse=True)
# print(L)
ans = 0
for i in range(n):
# print(i)
a = L[i]
ci = 0
for j in range(i+1,n-1):
b = L[j]
ci = n-1
# print("ci",ci)
while ci > j and b+L[ci] <= a:
ci -= 1
ans += ci-j
print(ans)
| n = int(eval(input()))
L = list(map(int,input().split()))
L.sort(reverse=True)
# print(L)
ans = 0
for i in range(n):
# print(i)
a = L[i]
ci = n-1
for j in range(i+1,n-1):
b = L[j]
ci = max(ci,j)
# print("ci",ci)
while ci > j and b+L[ci] <= a:
ci -= 1
ans += ci-j
print(ans)
| p02888 |
n = int(eval(input()))
l = list(map(int, input().split()))
# comb = list(combinations(l, 3))
ans = 0
l.sort(reverse=True)
# for i in comb:
# a = i[0]
# b = i[1]
# c = i[2]
# if (a < b + c) and (b < c + a) and (c < a + b):
# ans += 1
for i in range(n):
for j in range(i + 1, n):
a = l[i]
b = l[j]
for k in range(j + 1, n):
c = l[k]
# print(a, b, c)
if (a < b + c) and (b < c + a) and (c < a + b):
ans += 1
print(ans)
| from bisect import bisect_left
n = int(eval(input()))
l = list(map(int, input().split()))
ans = 0
l.sort()
for i in range(n):
for j in range(i + 1, n):
a = l[i]
b = l[j]
idx = bisect_left(l, a + b)
# print(a, b, idx)
ans += idx - (j + 1)
print(ans)
| p02888 |
from bisect import bisect_right
N = int(eval(input()))
D = list(map(int, input().split()))
D.sort(reverse=False)
count = 0
for i in range(N):
for j in range(i + 1, N - 1):
target = int(D[N - i - 1]) - int(D[N - j - 1])
l = D[:N - j - 1]
count += len(l) - bisect_right(l, target)
print(count)
| from bisect import bisect_right
N = int(eval(input()))
D = list(map(int, input().split()))
D.sort(reverse=False)
count = 0
for i in range(N - 2):
for j in range(i + 1, N - 1):
# target = int(D[N - i - 1]) - int(D[N - j - 1])
# l = D[:N - j - 1]
# count += len(l) - bisect_right(l, target)
ind = bisect_right(D, D[i] + D[j] - 1)
count += max(ind - j - 1, 0)
print(count)
| p02888 |
import itertools
n = int(eval(input()))
l = list(map(int, input().split()))
total = 0
for v in itertools.combinations(l, 3):
for j in itertools.combinations([0, 1, 2], 3):
a, b, c = j[0], j[1], j[2]
if abs(v[a] - v[b]) < v[c] < (v[a] + v[b]):
total += 1
break
print(total)
| import bisect
n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
total = 0
for a in range(n-2):
for b in range(a+1, n-1):
c = bisect.bisect_left(l, l[a] + l[b]) - b - 1
total += c
print(total) | p02888 |
from bisect import bisect_left
n = int(eval(input()))
l = list(map(int,input().split()))
l.sort()
ans = 0
for i in range(n-2):
for j in range(i+1,n-1):
ans += bisect_left(l,l[i]+l[j])-j-1
print(ans) | from bisect import bisect_left
def main():
n = int(eval(input()))
l = list(map(int,input().split()))
l.sort()
ans = 0
for i in range(n-2):
for j in range(i+1,n-1):
ans += bisect_left(l,l[i]+l[j])-j-1
print(ans)
if __name__ == '__main__':
main() | p02888 |
from bisect import bisect_right
N = int(eval(input()))
L = sorted(list(map(int,input().split())))
count = 0
for i in range(N-2):
for j in range(i+1,N-1):
ma = bisect_right(L[j+1:], L[i] + L[j] -1)
if ma >= 0:
count += ma
print(count)
|
import bisect
N = int(eval(input()))
L = list(map(int,input().split()))
count = 0
L.sort()
for i in range(N-2):
for j in range(i+1,N-1):
count += bisect.bisect(L,L[i]+L[j]-1)-j-1
print(count)
| p02888 |
N = int(eval(input()))
L = list(map(int,input().split()))
L = sorted(L)
ans = 0
for i in range(N):
for j in range(i+1,N):
a = L[i]
b = L[j]
for k in range(j+1,N):
c = L[k]
if (c < a + b) and (b < a + c) and (a < b + c):
ans += 1
else:
break
print(ans)
| from bisect import bisect_left
N = int(eval(input()))
L = list(map(int,input().split()))
L = sorted(L)
ans = 0
for i in range(N):
for j in range(i+1,N):
a = L[i]
b = L[j]
ans += bisect_left(L[j+1:], a+b)
print(ans)
| p02888 |
import itertools
N = int(eval(input()))
L = [int(x) for x in input().split(' ')]
count = 0
paris = list(itertools.combinations(L[1:], 2))
for i, a in enumerate(L[:-2]):
count += sum([(a < b + c) * (b < c + a) * (c < a + b) for b, c in paris])
del paris[:(N-i-2)]
print(count)
| N = int(eval(input()))
L = sorted([int(x) for x in input().split(' ')], reverse=True)
count = 0
while len(L) > 2:
a = L.pop(0)
ic = len(L) - 1
for ib, b in enumerate(L):
diff = a - b
while L[ic] <= diff and ib < ic:
ic -= 1
count += ic - ib
if ib >= ic:
break
print(count) | p02888 |
import bisect
N = int(eval(input()))
L = sorted(map(int, input().split()))
res = 0
for i in reversed(list(range(1, N))):
for j in reversed(list(range(i))):
index = bisect.bisect_left(L, L[i] + L[j])
n = N - index
res += (N - 1 - i) - n
print(res)
| import bisect
N = int(eval(input()))
L = sorted(map(int, input().split()))
res = 0
for i in range(N - 1):
for j in range(i + 1, N):
index = bisect.bisect_left(L, L[i] + L[j])
n = max(0, (index - 1) - j)
res += n
print(res)
| p02888 |
from bisect import bisect_left
from functools import lru_cache
n = int(eval(input()))
lll = list(map(int, input().split()))
lll.sort()
ans = 0
@lru_cache()
def bisect_left_cache(x):
return bisect_left(lll, x)
for i in range(n - 2):
li = lll[i]
for j in range(i + 1, n - 1):
k = bisect_left_cache(li + lll[j])
ans += k - j - 1
print(ans)
| from bisect import bisect_left
n = int(eval(input()))
lll = list(map(int, input().split()))
lll.sort()
ans = 0
def get_bisect_left():
cache = {}
def _f(x):
if x in cache:
return cache[x]
cache[x] = bisect_left(lll, x)
return cache[x]
return _f
bisect_left_cache = get_bisect_left()
for i in range(n - 2):
li = lll[i]
for j in range(i + 1, n - 1):
k = bisect_left_cache(li + lll[j])
ans += k - j - 1
print(ans)
| p02888 |
N=int(eval(input()))
L=list(map(int,input().split()))
ans=0
for i in range(N-2):
a=L[i]
for j in range(i+1,N-1):
b=L[j]
for k in range(j+1,N):
c=L[k]
if a<b+c and b<c+a and c<a+b:
ans+=1
print(ans) | N=int(eval(input()))
L=list(map(int,input().split()))
L.sort()
dp=[0]*(N+1)
ans=0
for i in range(3,N+1):
r=i-2
l=0
c=0
while r>l:
if L[r]+L[l]>L[i-1]:
c+=r-l
r-=1
else:
l+=1
dp[i]=dp[i-1]+c
print((dp[-1])) | p02888 |
import itertools
n = int(eval(input()))
l = list(map(int, input().split()))
triangle = itertools.combinations(l, 3)
cnt = 0
for i in triangle:
if max(i)*2 < sum(i):
cnt += 1
print(cnt) | import bisect
n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
cnt = 0
for i in range(n-2):
for j in range(i+1, n-1):
sum = l[i] + l[j]
index = bisect.bisect_left(l, sum)
cnt += index - j - 1
print(cnt) | p02888 |
n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
cnt = 0
for i in range(n):
for j in range(i + 1, n):
k = j
while k + 1 < n and l[k + 1] < l[i] + l[j]:
k += 1
cnt += k - j
print(cnt) | n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
cnt = 0
for i in range(n):
k = i + 1
for j in range(i + 1, n):
while k + 1 < n and l[k + 1] < l[i] + l[j]:
k += 1
cnt += k - j
print(cnt) | p02888 |
n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
cnt = 0
for i in range(n):
k = i + 1
for j in range(i + 1, n):
while k + 1 < n and l[k + 1] < l[i] + l[j]:
k += 1
cnt += k - j
print(cnt) | n = int(eval(input()))
l = sorted(list(map(int, input().split())))
cnt = 0
for i in range(n):
k = i + 1
for j in range(i + 1, n):
while k + 1 < n and l[k + 1] < l[i] + l[j]:
k += 1
cnt += k - j
print(cnt) | p02888 |
from bisect import bisect_left, bisect_right
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
result = 0
for i in range(N - 2):
a = L[i]
for j in range(i + 1, N - 1):
b = L[j]
result += bisect_left(L, a + b) - j - 1
print(result)
| from bisect import bisect_left
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
result = 0
for i in range(N - 2):
for j in range(i + 1, N - 1):
result += bisect_left(L, L[i] + L[j]) - j - 1
print(result)
| p02888 |
from bisect import bisect_left
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
result = 0
for i in range(N - 2):
for j in range(i + 1, N - 1):
result += bisect_left(L, L[i] + L[j]) - j - 1
print(result)
| from bisect import bisect_left
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
result = 0
for i in range(N - 2):
a = L[i]
for j in range(i + 1, N - 1):
result += bisect_left(L, a + L[j]) - j - 1
print(result)
| p02888 |
import itertools
N = int(eval(input()))
L = list(map(int,input().split()))
tmp = list(itertools.combinations(L,3))
ans = 0
for i in range(len(tmp)):
if abs(tmp[i][1] - tmp[i][2]) < tmp[i][0]:
if tmp[i][0] < (tmp[i][1] + tmp[i][2]):
ans += 1
print(ans) | import itertools
import bisect
N = int(eval(input()))
L = sorted(list(map(int,input().split())))
ans = 0
for i in range(N-2):
a = L[i]
for j in range(i+1,N-1):
b = L[j]
ind_cmin = j+1
ind_cmax = bisect.bisect_left(L,a+b)-1
ans += ind_cmax - ind_cmin + 1
print(ans) | p02888 |
N = int(eval(input()))
L = list(map(int, input().split()))
ans = 0
for i in range(N):
for j in range(i+1, N):
for k in range(j+1, N):
if L[i]<L[j]+L[k] and L[j]<L[k]+L[i] and L[k]<L[i]+L[j]:
ans += 1
print(ans)
| def is_ok1(a,b,c):
return L[b] < L[c] + L[a]
def is_ok2(a,b,c):
return L[c] < L[a] + L[b]
def meguru_bisect(ng, ok, is_ok, a, b):
'''
初期値のng,okを受け取り,is_okを満たす最小(最大)のokを返す
まずis_okを定義すべし
ng ok は とり得る最小の値-1 とり得る最大の値+1
最大最小が逆の場合はよしなにひっくり返す
'''
while (abs(ok - ng) > 1):
mid = (ok + ng) // 2
if is_ok(a, b, mid):
ok = mid
else:
ng = mid
return ok
N = int(eval(input()))
L = sorted(list(map(int, input().split())))
ans = 0
for a in range(N):
for b in range(a+1, N):
ans += max(0, meguru_bisect(N, b, is_ok2, a, b)-meguru_bisect(b, N, is_ok1, a, b)+1)
print(ans)
| p02888 |
N = int(eval(input()))
L = list(map(int, input().split()))
import itertools
A = list(itertools.combinations(L,3))
ans = 0
for a in A:
ok = True
if a[0] >= a[1]+a[2]:
ok = False
if a[1] >= a[0]+a[2]:
ok = False
if a[2] >= a[0]+a[1]:
ok = False
if ok:
ans += 1
print(ans) | N = int(eval(input()))
L = list(map(int, input().split()))
O = sorted(L, reverse=True)
def X(n,j):
C = sorted(L)
L1 = 0
L2 = N-1
while L1 != L2:
a = (L1+L2)//2
if C[a] == n:
nn = len(C[0:N-1-j])-len(C[0:a+1])
if nn > 0:
return nn
else:
return 0
if L2 - L1 <= 1:
if C[L1] > n:
nn = len(C[0:N-1-j])-len(C[0:L1])
else:
nn = len(C[0:N-1-j])-len(C[0:L2])
if nn > 0:
return nn
else:
return 0
elif C[a] < n:
L1 = a
else:
L2 = a
ans = 0
for i in range(N-2):
for j in range(i+1,N-1):
ans += X((O[i]-O[j]),j)
print(ans) | p02888 |
N = int(eval(input()))
L = list(map(int, input().split()))
C = sorted(L)
def X(n,j):
L1 = j+1
L2 = N-1
while L1 != L2:
a = (L1+L2)//2
if C[a] == n:
while C[a] == C[a-1]:
a = a-1
return len(C[j+1:a])
elif L2 - L1 <= 1:
while C[L1] == C[L1-1]:
if j+1 <= L1-1:
L1 = L1-1
else:
break
if C[L1] > n:
return len(C[j+1:L1])
elif C[L2] < n:
return len(C[j+1:L2+1])
elif C[L1] < n <= C[L2]:
return len(C[j+1:L2])
elif C[L1] == n:
while C[L1] == C[L1-1]:
L1 = L1-1
return len(C[j+1:L1])
elif C[a] < n:
L1 = a
else:
L2 = a
if C[L1] < n:
return 1
else:
return 0
ans = 0
# print(C)
for i in range(N-2):
for j in range(i+1,N-1):
# print(X((C[i]+C[j]),j))
ans += X((C[i]+C[j]),j)
print(ans) | N = int(eval(input()))
L = list(map(int, input().split()))
C = sorted(L)
def X(n,j):
L1 = j+1
L2 = N-1
while L1 != L2:
a = (L1+L2)//2
if C[a] == n:
while C[a] == C[a-1]:
a = a-1
return len(C[j+1:a])
elif L2 - L1 <= 1:
if C[L2] < n:
return len(C[j+1:L2+1])
elif C[L1] < n <= C[L2]:
return len(C[j+1:L2])
while C[L1] == C[L1-1]:
if j+1 <= L1-1:
L1 = L1-1
else:
break
if C[L1] > n:
return len(C[j+1:L1])
elif C[L1] == n:
return len(C[j+1:L1])
elif C[a] < n:
L1 = a
else:
L2 = a
if C[L1] < n:
return 1
else:
return 0
ans = 0
# print(C)
for i in range(N-2):
for j in range(i+1,N-1):
# print(X((C[i]+C[j]),j))
ans += X((C[i]+C[j]),j)
print(ans) | p02888 |
import bisect
N = int(eval(input()))
L = list(map(int,input().split()))
L.sort()
cnt=0
for i in range(N-1,1,-1):
for j in range(i-1,0,-1):
b = bisect.bisect_right(L[:j],L[i]-L[j])
cnt+=j-b
print(cnt) | import bisect
N = int(eval(input()))
L = list(map(int,input().split()))
L.sort()
cnt=0
for i in range(N-2):
for j in range(i+1,N-1):
b = bisect.bisect_left(L,L[i]+L[j])
cnt += b-j-1
print(cnt) | p02888 |
N = int(eval(input()))
l = [int(x) for x in input().split()]
L = sorted(l,reverse=True)
a = 0
for x in range(0,N-2):
for y in range(x+1,N-1):
for i in range(y+1,N):
if L[i] > L[x] - L[y]:
a += 1
print(a) | N = int(eval(input()))
l = [int(x) for x in input().split()]
l.sort(reverse=True)
ans = 0
for i in range(N-2):
j = i + 1
k = N - 1
while j < k:
if l[i] < l[j] + l[k]:
ans += k - j
j += 1
else:
k -= 1
print(ans) | p02888 |
n = int(eval(input()))
l = list(map(int,input().split()))
ans = 0
for i in range(n):
for j in range(i+1,n):
for k in range(j+1,n):
if l[i] < l[j] + l[k]:
if l[j] < l[i] + l[k]:
if l[k] < l[i] + l[j]:
ans += 1
print(ans)
| n = int(eval(input()))
l = list(map(int,input().split()))
l.sort()
ans = 0
#print(l)
for i in range(n):
for j in range(i+1,n):
val = l[i]+l[j]
ng = n
ok = j
while abs(ok - ng) > 1:
mid = (ok+ng)//2
if val > l[mid]:
ok = mid
else:
ng = mid
#print(i,j,ok,ng)
ans += ok - j
print(ans) | p02888 |
n = int(eval(input()))
l = list(map(int, input().split()))
ans = 0
for i in range(n - 2):
a = l[i]
for j in range(n - i - 2):
b = l[i + j + 1]
for k in range(n - i - j - 2):
c = l[i + j + k + 2]
if a < b + c and b < c + a and c < a + b:
ans += 1
print(ans)
| import bisect
n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
ans = 0
for i in range(n - 2):
a = l[i]
for j in range(n - i - 2):
b = l[i + j + 1]
index = bisect.bisect_left(l, a + b)
if index > i + j + 2:
ans += index - (i + j + 2)
print(ans)
| p02888 |
import itertools
n = int(eval(input()))
L = list(map(int,input().split()))
ans = 0
for a,b,c in itertools.combinations(L, 3):
if a<b+c and b<a+c and c<a+b:
ans += 1
print(ans) | import bisect
N = int(eval(input()))
L = list(map(int,input().split()))
L.sort()
ans = 0
for a in range(N-2):
for b in range(a+1,N-1):
c = bisect.bisect_left(L, L[a]+L[b])
ans += c - (b+1)
print(ans) | p02888 |
import bisect
n = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
ans = 0
for i in range(n - 2):
a = L[i]
for j in range(i + 1, n - 1):
b = L[j]
k = bisect.bisect_left(L[j + 1:], a + b)
ans += k
print(ans)
| import bisect
n = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
ans = 0
for i in range(n - 2):
a = L[i]
for j in range(i + 1, n - 1):
b = L[j]
k = bisect.bisect_left(L, a + b)
ans += k - j - 1
print(ans)
| p02888 |
n=int(eval(input()))
l=list(map(int,input().split()))
l.sort()
ans=0
for i in range(n-2):
for j in range(i+1,n-1):
num=l[i]+l[j]
for k in range(j+1,n):
if num<=l[k]:
break
else:
ans+=1
print(ans)
| n=int(eval(input()))
l=list(map(int,input().split()))
l.sort()
num=[0]*(max(l)+2)
for i in range(n):
num[l[i]]=i
for i in range(1,len(num)):
if num[i]==0:
num[i]=num[i-1]
ans=0
num3=l[n-1]
for i in range(n-2):
for j in range(i+1,n-1):
ans+=max(0,num[min(num3,l[i]+l[j]-1)]-j)
print(ans)
| p02888 |
n=int(eval(input()))
l=list(map(int,input().split()))
l.sort()
ans=0
import bisect
for i in range(n):
for j in range(n):
if i<j:
a=l[i]
b=l[j]
x=bisect.bisect_left(l,a+b)
y=bisect.bisect_right(l,b-a)
if b-a>=a:
ans+=max(0,x-y-1)
else:
ans+=max(0,x-y-2)
print((ans//3))
| n=int(eval(input()))
l=list(map(int,input().split()))
l.sort()
from bisect import bisect_left
ans=0
for i in range(n):
for j in range(i+1,n):
a=l[i]
b=l[j]
ans+=max(0,bisect_left(l,a+b)-j-1)
print(ans)
| p02888 |
n=int(eval(input()))
l=list(map(int,input().split()))
ans=0
for i in range(n-2):
for j in range(i+1,n-1):
for k in range(j+1,n):
a,b,c=l[i],l[j],l[k]
if abs(a-b)<c<a+b:
ans+=1
print(ans) | n=int(eval(input()))
l=list(map(int,input().split()))
l.sort()
ans=0
for i in range(n):
k=i
for j in range(i+1,n):
while k<n and l[k]<l[i]+l[j]:
k+=1
ans+=k-(j+1)
print(ans) | p02888 |
from itertools import combinations
n=int(eval(input()))
a=[int(i) for i in input().split()]
c = list(combinations(a,3))
ans=0
for i in range(len(c)):
#print(c[i][0],c[i][1],c[i][2])
if c[i][0] < c[i][1]+c[i][2] and c[i][1] < c[i][0]+c[i][2] and c[i][2] < c[i][1]+c[i][0]:
ans+=1
print(ans)
| n=int(eval(input()))
a=[int(i) for i in input().split()]
ans=0
for i in range(n-2):
for j in range(i+1,n-1):
for k in range(j+1,n):
#print(a[i],a[j],a[k])
if a[i]<a[j]+a[k] and a[j]<a[k]+a[i] and a[k]<a[i]+a[j]:
ans+=1
print(ans)
| p02888 |
n = int(eval(input()))
li = list(map(int,input().split()))
li2 = sorted(li,reverse=True)
cnt = 0
for i in range(n-2):
for j in range(i+1,n-1):
if li2[i] > li2[j] + li2[j+1]:
break
else:
for k in range(j+1,n):
if li2[i] < li2[j]+li2[k]:
cnt += 1
else:
break
print(cnt) | import bisect
n = int(eval(input()))
li = list(map(int,input().split()))
li2 = sorted(li)
cnt = 0
for i in range(n-2):
for j in range(i+1,n-1):
cnt += bisect.bisect_left(li2,li2[i]+li2[j]) - (j+1)
print(cnt) | p02888 |
import bisect
import copy
n = int(eval(input()))
list1 = list(map(int,input().split()))
list1.sort()
cout = 0
m,k = 0,0
for i in range(n-2):
o = list1.pop(0)
list1_c = copy.deepcopy(list1) #ここでjのためのdeepcopyを更新
for j in range(n-i-1):
p = list1_c.pop(0)
a = abs(o-p) +1
b = o+p -1 #<= ではなく<条件に揃える
d = bisect.bisect_right(list1_c,b)
cout += d
print(cout) | import bisect
import copy
n = int(eval(input()))
list1 = list(map(int,input().split()))
list1.sort()
cout = 0
m,k = 0,0
for i in range(n-2):
o = list1.pop(0)
for j in range(n-i-1):
p = list1[j]
a = abs(o-p) +1
b = o+p -1 #<= ではなく<条件に揃える
d = bisect.bisect_right(list1[j+1:],b)
cout += d
print(cout)
| p02888 |
import bisect
import copy
n = int(eval(input()))
list1 = list(map(int,input().split()))
list1.sort()
cout = 0
m,k = 0,0
for i in range(n-2):
o = list1.pop(0)
for j in range(n-i-1):
p = list1[j]
a = abs(o-p) +1
b = o+p -1 #<= ではなく<条件に揃える
d = bisect.bisect_right(list1[j+1:],b)
cout += d
print(cout)
| import bisect
#input
n = int(eval(input()))
list1 = list(map(int,input().split()))
list1.sort()
cout = 0 #最終的な三角形の個数
for i in range(n-2): #リストから三角形が作れなくなるまでループ
o = list1[i] #1辺を確定、そのままリストから消去
for j in range(i+1,n-1): #残りの二辺のループ(iで使っている次の値から)
p = list1[j] #２辺目を確定
b = o+p -1 #昇順にソートしてあるので、c<a+b条件のみ計算
d = bisect.bisect_right(list1[j+1:],b) #３辺目を確定
cout += d
print(cout) | p02888 |
#
import sys
sys.setrecursionlimit(12345678)
import itertools
from collections import Counter
from collections import defaultdict
from collections import deque
import bisect
from heapq import heappush, heappop
def main():
n = int(eval(input()))
ll = list(map(int, input().split()))
ll.sort()
ans = 0
for i in range(n - 2):
for j in range(i + 1, n - 1):
rest = ll[j + 1:]
a_plus_b = ll[i] + ll[j]
pos_right = bisect.bisect_left(rest, a_plus_b)
b_minus_a = ll[j] - ll[i]
pos_left = bisect.bisect_right(rest, b_minus_a)
count = pos_right - pos_left
ans += count
print(ans)
if __name__ == '__main__':
main()
| #
import sys
sys.setrecursionlimit(12345678)
import itertools
from collections import Counter
from collections import defaultdict
from collections import deque
import bisect
from heapq import heappush, heappop
def main():
n = int(eval(input()))
ll = list(map(int, input().split()))
ll.sort()
ans = 0
for i in range(n - 2):
for j in range(i + 1, n - 1):
rest = ll[j + 1:]
a_plus_b = ll[i] + ll[j]
pos_right = bisect.bisect_left(rest, a_plus_b)
count = pos_right
ans += count
print(ans)
if __name__ == '__main__':
main()
| p02888 |
n = int(eval(input()))
L = list(map(int,input().split()))
L = sorted(L,reverse=True)
total = 0
for i in range(0,n-2):
for j in range(i+1,n-1):
if L[j] > L[i]/2:
for k in range(j+1,n):
if L[j] + L[k] > L[i]:
total += 1
else:
break
else:
break
print(total)
| import bisect
n = int(eval(input()))
L = list(map(int,input().split()))
L = sorted(L)
ans = 0
for i in range(n-1):
for j in range(i+1,n):
limit = L[i]+L[j]
ans += bisect.bisect_left(L,limit) - (j+1)
print(ans)
| p02888 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.