input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import bisect
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):
k = bisect.bisect_left(l, l[i]+l[j])
if k > j:
ans += k - j - 1
print(ans)
| import bisect
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):
k = bisect.bisect_left(l, l[i]+l[j])
#if k > j:
ans += k - j - 1
print(ans)
| p02888 |
N = int(eval(input()))
L = list(map(int, input().split()))
from itertools import permutations, combinations,combinations_with_replacement,product
C = list(combinations(L,3))
ans = 0
for i in C:
a, b, c = i
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()))
ans = 0
for a in range(0, N-2):
for b in range(a+1, N-1):
for c in range(b+1, N):
n1, n2, n3 = L[a], L[b], L[c]
if n1<n2+n3 and n2<n3+n1 and n3<n1+n2:
ans += 1
print(ans)
exit()
from itertools import permutations, combinations,combinations_with_replacement,product
C = list(combinations(L,3))
ans = 0
for i in C:
a, b, c = i
if a<b+c and b<c+a and c<a+b:
ans += 1
print(ans) | p02888 |
N = int(eval(input()))
L = list(map(int, input().split()))
ans = 0
for a in range(0, N-2):
for b in range(a+1, N-1):
for c in range(b+1, N):
n1, n2, n3 = L[a], L[b], L[c]
if n1<n2+n3 and n2<n3+n1 and n3<n1+n2:
ans += 1
print(ans)
exit()
from itertools import permutations, combinations,combinations_with_replacement,product
C = list(combinations(L,3))
ans = 0
for i in C:
a, b, c = i
if a<b+c and b<c+a and c<a+b:
ans += 1
print(ans) | N = int(eval(input()))
L = sorted(list(map(int, input().split())))
ans = 0
import bisect
for a in range(N):
for b in range(a):
A=L[a]
B=L[b]
c=bisect.bisect_left(L, A+B)
ans+=c-a-1
print(ans) | p02888 |
#それゆけにぶたんまん
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):
#jより大きい整数kでl[k]<l[i]+l[j]を満たす最大のk
le = j
ri = n
while ri-le>1:
m = (ri+le)//2
if l[m]<l[i]+l[j]:
le = m
else:
ri = m
ans += le-j
print(ans)
| #それゆけにぶたんまん
#python3.8.2のTLEの壁に阻まれました
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):
#jより大きい整数kでl[k]<l[i]+l[j]を満たす最大のk
le = j
ri = n
while ri-le>1:
m = (ri+le)//2
if l[m]<l[i]+l[j]:
le = m
else:
ri = m
ans += le-j
print(ans)
| p02888 |
import sys
import bisect
def slove():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n = int(input().rstrip('\n'))
a = list(map(int, input().rstrip('\n').split()))
a.sort()
cnt = 0
for i in range(n-2):
for j in range(i + 1, n-1):
p = bisect.bisect_left(a, a[i] + a[j])
cnt += (p - j - 1)
print(cnt)
if __name__ == '__main__':
slove()
| import sys
import bisect
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n = int(input().rstrip('\n'))
l = list(map(int, input().rstrip('\n').split()))
l.sort()
t = 0
for i in range(n):
for j in range(i + 1, n - 1):
p = bisect.bisect_left(l, l[i] + l[j])
t += p - (j + 1)
print(t)
if __name__ == '__main__':
solve()
| p02888 |
import bisect
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
ans = 0
for a in range(len(L)-2):
for b in range(a+1, len(L)-1):
ans += bisect.bisect_left(L[b+1:], L[a]+L[b])
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):
ans += bisect.bisect_left(L, L[a]+L[b]) - (b+1)
print(ans) | p02888 |
n = int(eval(input()))
l = list(map(int, input().split()))
cnt = 0
for i in range(n):
for j in range(i):
a = l[i]+l[j]
for k in l:
if a > k:
continue
cnt += 1
print((n*(n-1)*(n-2)//6-cnt)) | n = int(eval(input()))
l = sorted(map(int, input().split()))
cnt = 0
m = n-1
g = []
for i in range(n):
for j in range(i):
g.append(l[i]+l[j])
g = sorted(g,reverse = True)
for i in g:
while l[m] >= i:
m-=1
cnt += n-m-1
print((n*(n-1)*(n-2)//6-cnt)) | p02888 |
# a < b + c
# b < a + C
# c < a + b
# 4 3 2 1
# a b c
# abs(a - b) < c < a + b
# a < b < c
# b - a < b < c
# c < a + b
from math import ceil, floor
from bisect import bisect_left, bisect_right
def solution(N, data): # O(N^2 * logN)
data = sorted(data)
c = 0
for i in range(N-2):
for j in range(i+1, N-1):
c += bisect_left(data[j+1:], data[i] + data[j])
return c
if __name__ == '__main__':
N = int(eval(input()))
L_i = list(map(int, input().split()))
a = solution(N, L_i)
print(a)
| # a < b + c
# b < a + C
# c < a + b
# 4 3 2 1
# a b c
# abs(a - b) < c < a + b
# a < b < c
# b - a < b < c
# c < a + b
from math import ceil, floor
from bisect import bisect_left, bisect_right
def solution(N, data): # O(N^2 * logN)
data.sort()
c = 0
for i in range(N-2):
for j in range(i+1, N-1):
c += bisect_left(data, data[i] + data[j], j) - j - 1
return c
if __name__ == '__main__':
N = int(eval(input()))
L_i = list(map(int, input().split()))
a = solution(N, L_i)
print(a)
| p02888 |
# a < b + c
# b < a + C
# c < a + b
# 4 3 2 1
# a b c
# abs(a - b) < c < a + b
# a < b < c
# b - a < b < c
# c < a + b
from math import ceil, floor
from bisect import bisect_left, bisect_right
def solution(N, data): # O(N^2 * logN)
data.sort()
c = 0
for i in range(N-2):
for j in range(i+1, N-1):
# c += bisect_left(data, data[i] + data[j], j) - j - 1
c += bisect_left(data[j+1:], data[i] + data[j])
return c
if __name__ == '__main__':
N = int(eval(input()))
L_i = list(map(int, input().split()))
a = solution(N, L_i)
print(a)
| # a < b + c
# b < a + C
# c < a + b
# 4 3 2 1
# a b c
# abs(a - b) < c < a + b
# a < b < c
# b - a < b < c
# c < a + b
from math import ceil, floor
from bisect import bisect_left, bisect_right
def solution(N, data): # O(N^2 * logN)
data.sort()
c = 0
for i in range(N-2):
for j in range(i+1, N-1):
c += bisect_left(data, data[i] + data[j], j) - j - 1
return c
if __name__ == '__main__':
N = int(eval(input()))
L_i = list(map(int, input().split()))
a = solution(N, L_i)
print(a)
| p02888 |
import itertools
n = int(eval(input()))
a = list(map(int, input().split()))
count = [0]
x = list(itertools.combinations(a, 3))
def check_triangle(li):
li.sort(reverse=True)
if li[0] < li[1] + li[2]:
count[0] += 1
for i in x:
check_triangle(list(i))
print((count[0]))
| n = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
count = 0
def binary_search(numbers, target_number):
# 最小値を仮決め
low = 0
# 範囲内の最大値
high = len(numbers)
# 目的地を探し出すまでループ
while low <= high:
if low == high:
return low
# 中央値を求める（index）
middle = (low + high) // 2
# 中央値のnumbersの値とtarget_numberが等しい場合
if numbers[middle] == target_number:
return middle
# 中央値のnumbersの値がtarget_numberより小さい場合
elif numbers[middle] < target_number:
low = middle + 1
# 中央値のnumbersの値がtarget_numberより大きい場合
else:
high = middle - 1
return max(low, high)
for i in range(n-2):
for j in range(i+1, n-1):
if a[i] + a[j] > max(a):
count += n - (j+1)
continue
elif a[i] + a[j] == max(a):
count += n - (j+1) - 1
continue
index = binary_search(a, (a[i]+a[j]))
if a[i] + a[j] == a[index] or a[i] + a[j] < a[index]:
count += (index-(j+1))
else:
count += (index - j)
print(count)
| p02888 |
#D
n = int(eval(input()))
l = list(map(int,input().split()))
cnt = 0
l.sort(reverse=True)
for i in range(len(l)-2):
for j in range(i+1,len(l)-1):
x = l[i]-l[j]
right = n-1
left = j
while left <= right:
mid = (right + left) //2
if l[mid] == x:
mid -= 1
break
elif l[mid] > x:
left = mid+1
elif l[mid] < x:
right = mid-1
if (mid - j) > 0:
cnt += mid - j
print(cnt) | import bisect
n = int(eval(input()))
l = list(map(int,input().split()))
cnt = 0
l.sort()
for i in range(n):
for j in range(i+1,n):
k = bisect.bisect_left(l,l[i]+l[j])
if k > j:
cnt += k - j - 1
else:
pass
print(cnt) | p02888 |
import sys
import itertools
input = sys.stdin.readline
N = int(eval(input()))
edge = list(map(int, input().split()))
patterns = list(itertools.combinations(edge, 3))
# print(patterns)
sum = 0
for p in patterns:
# print(p)
if p[0] < (p[1] + p[2]) and p[1] < (p[0] + p[2]) and p[2] < (p[0] + p[1]):
sum += 1
print(sum)
| import sys
input = sys.stdin.readline
N = int(eval(input()))
lines = list(map(int, input().split()))
lines.sort()
# print(lines)
sum = 0
for i in range(N):
for j in range(i + 2, N):
# print("i,j:{0},{1}".format(i, j))
# print("lines[i],lines[j]:{0},{1}".format(lines[i], lines[j]))
k = j - 1
while i < k:
# print("i,j,k:{0},{1},{2}".format(i, j, k))
# print("lines[i],lines[j],lines[k]:{0},{1},{2}".format(lines[i], lines[j], lines[k]))
if ((lines[i] + lines[j]) > lines[k]) and (lines[i] + lines[k]) > lines[j]:
# print("count up")
sum += 1
k -= 1
print(sum)
| p02888 |
import bisect
n = int(eval(input()))
l = list(map(int,input().split()))
l.sort()
ans = 0
for i in range(n):
d = []
for j in range(i+1,n):
index = bisect.bisect_left(l,l[i]+l[j])
for k in range(i+1,j):
if l[j] < l[k] + l[i]:
if [k,j] not in d:
d.append([k,j])
ans += 1
for k in range(j+1,index):
if l[k] < l[j] + l[i]:
if [j,k] not in d:
d.append([j,k])
ans += 1
print(ans)
| import bisect
n = int(eval(input()))
l = list(map(int,input().split()))
l.sort()
#print(l)
ans = 0
for i in range(n-1):
a = l[i]
for j in range(i+2,n):
b = l[j]
c = bisect.bisect_left(l,b-a+1)
if j - c > 0:
if i >= c:
ans += j-i-1
else:
ans += j-c
#print(i,j,c,ans)
print(ans)
| p02888 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from itertools import combinations
from bisect import bisect_left
def main():
N = int(readline())
L = [int(i) for i in readline().split()]
L.sort()
sig = 0
for i in range(N):
for j in range(i+1, N):
l = bisect_left(L[j+1:], L[i]+L[j])
sig += l
print(sig)
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from itertools import combinations
from bisect import bisect_left
def main():
N = int(readline())
L = [int(i) for i in readline().split()]
L.sort()
sig = 0
for i in range(N):
for j in range(i+1, N):
l = bisect_left(L, L[i]+L[j], j+1)
sig += l-j-1
print(sig)
if __name__ == '__main__':
main()
| p02888 |
from bisect import *
n = int(eval(input()))
l = sorted(list(map(int, input().split())))
cnt = 0
for i in range(n):
a = l[i]
for j in range(i+1, n):
b = l[j]
lower = max(j+1, bisect_right(l, b-a))
upper = bisect_left(l, a+b)
cnt += max(0, upper-lower)
print(cnt) | from bisect import *
n = int(eval(input()))
l = sorted(list(map(int, input().split())))
cnt = 0
for i in range(n):
a = l[i]
for j in range(i+1, n):
b = l[j]
lower = max(j+1, bisect_right(l, b-a))
upper = bisect_left(l, a+b)
cnt += upper-lower
print(cnt) | p02888 |
N = int(eval(input()))
l = list(map(int, input().split(" ")))
l.sort()
t = 0
for i in range(N-2):
a = l[i]
for j in range(i+1, N-1):
b = l[j]
low, upp = abs(b-a), a+b
flag = 0
for k in range(j+1, N):
if low < l[k] < upp:
t += 1
flag = 1
else:
if flag == 1:
break
else:
continue
print(t) | from bisect import bisect_right
def main():
N = int(eval(input()))
L = list(map(int, input().split(" ")))
L.sort()
k = 0
for i in reversed(list(range(2, N))):
a = L[i]
for j in reversed(list(range(1, i))):
b = L[j]
index = bisect_right(L, a-b, hi=j)
k += j - index
print(k)
if __name__ == "__main__":
main() | p02888 |
from bisect import bisect_left
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
cnt = 0
for i in range(0,N-2):
for j in range(i+1,N-1):
t = L[i]+L[j]
idx = bisect_left(L,t,lo=j+1)
cnt += max(0,idx-j-1)
print(cnt) | N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
from bisect import bisect_left
cnt = 0
for i in range(0,N):
for j in range(i+1,N):
t = L[i]+L[j]
idx = bisect_left(L,t)
cnt += max(0,idx-j-1)
print(cnt) | p02888 |
from bisect import bisect_left
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
cnt = 0
for i in range(0,N-2):
for j in range(i+1,N-1):
t = L[i]+L[j]
idx = bisect_left(L,t,lo=j)
cnt += max(0,idx-j-1)
print(cnt) | 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, j+1)
ans += max(0, idx-j-1)
print(ans) | p02888 |
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
from bisect import bisect_left
cnt = 0
for i in range(0,N-2):
for j in range(i+1,N-1):
t = L[i]+L[j]
idx = bisect_left(L,t)
cnt += max(0,idx-j-1)
print(cnt) | N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
from bisect import bisect_left
cnt = 0
for i in range(0,N-2):
for j in range(i+1,N-1):
t = L[i]+L[j]
idx = bisect_left(L,t,j+1)
cnt += max(0,idx-j-1)
print(cnt) | p02888 |
def binarySearch(A, head, tail, key):
left = head
right = tail - 1 # 探索範囲:[left, right]
i = 0
while left <= right:
mid = (left + right) // 2
if key == A[mid]:
return mid
elif key < A[mid]:
right = mid - 1
i = mid
else:
left = mid + 1
i = mid + 1
return i
if __name__ == "__main__":
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
# print(L)
sum = 0
for a in range(N - 2):
for b in range(a + 1, N - 1):
key = L[a] + L[b]
c = binarySearch(L, b + 1, N, key)
# print(a, b, c, c - b - 1)
sum += c - b - 1
print(sum) | from bisect import bisect_left
if __name__ == "__main__":
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
# print(L)
sum = 0
for a in range(N - 2):
for b in range(a + 1, N - 1):
key = L[a] + L[b]
i = bisect_left(L, key)
# print(a, b, i, i - b)
sum += i - b - 1
print(sum) | p02888 |
import itertools
N=int(eval(input()))
L=list(map(int, input().split()))
def tri_d(a,b,c):
if (a+b>c) and (b+c>a) and (c+a>b):
return True
else:
return False
ans=0
C=list(itertools.combinations(L, 3))
for a,b,c in C:
if tri_d(a,b,c):
ans+=1
print(ans) | import bisect
N=int(eval(input()))
L=list(map(int, input().split()))
L=sorted(L)
count=0
for i in range(N-2):
a=L[i]
for j in range(i+1, N-1):
b=L[j]
r=bisect.bisect_left(L, a+b)
count+=r-1-j
print(count) | p02888 |
import bisect
N=int(eval(input()))
L=list(map(int, input().split()))
#a<b+c
#b<c+a
#c<a+b
#a<=b<=c
#c<a+b
L=sorted(L)
ans=0
for i in range(N-2):
for j in range(i+1,N-1):
x=bisect.bisect_left(L,L[i]+L[j])
ans+=x-(j+1)
print(ans) | N=int(eval(input()))
L=list(map(int, input().split()))
L=sorted(L)
import bisect
ans=0
for i in range(N-1):
for j in range(i+1,N):
a=L[i]
b=L[j]
upper = bisect.bisect_left(L,a+b)
lower=max(j+1, bisect.bisect_right(L, a-b), bisect.bisect_right(L, b-a))
#print(upper, lower)
ans+=max(0, upper-lower)
print(ans) | p02888 |
from itertools import combinations
N = int(eval(input()))
L = sorted(list(map(int, input().split())))
count = 0
for bars in list(combinations(L, 3)):
if bars[2] < bars[0] + bars[1]:
if bars[1] - bars[0] < bars[2]:
count += 1
print(count) | N = int(eval(input()))
L = sorted(list(map(int, input().split())), reverse=True)
def aaa(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
print((aaa(L))) | p02888 |
from bisect import*
N,*L=list(map(int,open(0).read().split()));L.sort()
a=0
l=[]
r=[]
for i in range(1001):
l.append(bisect_left(L,i))
r.append(bisect(L,i))
for p in L:
for q in L:
x=p+q
y=abs(p-q)
a+=(l[x]if x<1001else N)-(r[y]if 0<y<1001else(y>1000)*N)
for p in L:
x=2*p
a-=3*(l[x]if x<1001else N)
print(((a+2*N)//6)) | from bisect import*
N,*L=list(map(int,open(0).read().split()));L.sort()
a=0
for i in range(N):
for j in range(i+1,N):
a+=bisect_left(L,L[i]+L[j],j+1)-j-1
print(a) | p02888 |
from bisect import*
N,*L=list(map(int,open(0).read().split()));L.sort()
a=0
for i in range(N):
for j in range(i+1,N):
a+=bisect_left(L,L[i]+L[j],j+1)-j-1
print(a) | from bisect import*;N,*L=list(map(int,open(0).read().split()));L.sort();print((sum(bisect_left(L,L[i]+L[j],j+1)-j-1for i in range(N)for j in range(i+1,N)))) | p02888 |
import math
def rank(arr):
lastIndex = len(arr) - 1
while lastIndex > 0:
for i in range(lastIndex):
if arr[i + 1] < arr[i]:
tmp = arr[i + 1]
arr[i + 1] = arr[i]
arr[i] = tmp
lastIndex = lastIndex - 1
return arr
def half_search(arr, N, startIndex, endIndex):
if startIndex == endIndex:
if arr[startIndex] > N:
return startIndex
else:
return -1
if endIndex - startIndex == 1:
if arr[startIndex] > N:
return startIndex
else:
if arr[endIndex] <= N:
return -1
return endIndex
m = (startIndex + endIndex) % 2
if m == 1:
# 偶数 2,5 => 3,4
s1 = int((startIndex + endIndex - 1) / 2)
s2 = s1 + 1
value1 = arr[s1]
if N < value1:
return half_search(arr, N, startIndex, s2)
else:
return half_search(arr, N, s1, endIndex)
else:
# 奇数 3,6 => 5
#
midIndex = int((startIndex + endIndex + 1) / 2)
midValue = arr[midIndex]
if midValue > N:
return half_search(arr, N, startIndex, midIndex)
else:
return half_search(arr, N, midIndex, endIndex)
def calculate(arr):
if len(arr) < 3:
return 0
index = len(arr) - 1
result = 0
while index - 2 >= 0:
s1 = arr[index] # 最大的值
secondIndex = index - 1
while secondIndex - 1 >= 0:
s2 = arr[secondIndex]
left = arr[:secondIndex]
dirrerence = math.fabs(s2 - s1)
t = half_search(left, dirrerence, 0, len(left) - 1)
res = 0
if t >= 0:
res = len(left) - t
result = result + res
secondIndex = secondIndex - 1
index = index - 1
return result
N = eval(input())
S = list(input().split(' '))
S = list(map(int, S))
arr = rank(S)
result = calculate(arr)
print(result) | import bisect
N = int(eval(input()))
ARR = list(map(int,input().split()))
def calculate(n,arr):
arr = sorted(arr)
sum = 0
for i in range(n-1):
for j in range(i+1,n):
mmm = arr[j] + arr[i] - 1
nnn = bisect.bisect_right(arr,mmm)
sum = sum + nnn - (j + 1)
print(sum)
calculate(N,ARR)
| p02888 |
from bisect import bisect_left
n = int(eval(input()))
l_ls = sorted(map(int, input().split()))
ans = 0
for i, a in enumerate(l_ls):
for j, b in enumerate(l_ls):
if i >= j:
continue
ls = l_ls[:i] + l_ls[i+1:j] + l_ls[j+1:]
left = bisect_left(ls, max(a-b, b-a)+1)
right = bisect_left(ls, a+b)
ans += right-left
print((ans//3)) | from bisect import bisect_left
n = int(eval(input()))
l_ls = sorted(map(int, input().split()))
ans = 0
for i in range(n):
for j in range(i+1, n):
a, b = l_ls[i], l_ls[j]
right = bisect_left(l_ls, a+b)
ans += right-(j+1)
print(ans) | p02888 |
n=int(eval(input()))
l=sorted([int(i) for i in input().split()],reverse=True)
#print(l)
co=0
for i in range(n-2):
c=l[i]
x=0
for j in range(i+1,n-1):
b=l[j]
for k in range(j+1,n):
a=l[k]
if c<(a+b):
co+=1
else:
if k==j+1:
x=1
break
if x==1:
break
print(co) | import bisect
def solve():
N = int(eval(input()))
Ls = list(map(int, input().split()))
Ls.sort()
# O(N^2 * logN)の全探索で解く
ans = 0
for a_i in range(N):
for b_i in range(a_i+1, N):
c_i = bisect.bisect_left(Ls, Ls[a_i]+Ls[b_i])
if c_i > b_i:
ans += c_i - b_i - 1
else:
pass
print(ans)
if __name__ == "__main__":
solve() | p02888 |
N = int(eval(input()))
l = list(map(int,input().split()))
l.sort()
ans = 0
max = l[N-1]
tc = N
st = [j+1 for j in range(N-1)]
for i in range(N-2):
if l[i]+l[i+1] > max:
k = N-i-1
ans += ((k-1)*k*(k+1))//6
break
for j in range(i+1,N-1):
if j == tc:
ans += tp
break
s = l[i]+l[j]
if s <= l[j+1]:
continue
if s > max:
tc = j
tp = (N-j-1) * (N-j) //2
ans += tp
break
start = st[j]
end = N
while start != end:
center = (start + end)//2
if s <= l[center]:
end = center
else:
start = center + 1
st[j] = end
ans += end-j-1
print(ans) | N = int(eval(input()))
l = list(map(int,input().split()))
l.sort()
ans = 0
max = l[N-1]
tc = N
st = [j+1 for j in range(N-1)]
for i in range(N-2):
if l[i]+l[i+1] > max:
k = N-i-1
ans += ((k-1)*k*(k+1))//6
break
for j in range(i+1,N-1):
if j == tc:
ans += tp
break
s = l[i]+l[j]
if s <= l[j+1]:
continue
if s > max:
tc = j
tp = (N-j-1) * (N-j) //2 #これをiの中でできないか
ans += tp
break
start = st[j]
if s <= l[start]:
ans += start-j-1
continue
end = N
while start != end:
center = (start + end)//2
if s <= l[center]:
end = center
else:
start = center + 1
st[j] = end
ans += end-j-1
print(ans) | p02888 |
N = int(eval(input()))
l = list(map(int,input().split()))
l.sort()
ans = 0
max = l[N-1]
tc = N
st = [j+1 for j in range(N-1)]
for i in range(N-2):
if l[i]+l[i+1] > max:
k = N-i-1
ans += ((k-1)*k*(k+1))//6
break
for j in range(i+1,N-1):
if j == tc:
ans += tp
break
s = l[i]+l[j]
if s <= l[j+1]:
continue
if s > max:
tc = j
tp = (N-j-1) * (N-j) //2 #これをiの中でできないか
ans += tp
break
start = st[j]
if s <= l[start]:
ans += start-j-1
continue
end = N
while start != end:
center = (start + end)//2
if s <= l[center]:
end = center
else:
start = center + 1
st[j] = end
ans += end-j-1
print(ans) | 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):
s = l[i]+l[j]
start = j+1
end = N
while start != end:
center = (start + end)//2
if s <= l[center]:
end = center
else:
start = center + 1
ans += end-j-1
print(ans)
| p02888 |
N = int(eval(input()))
L = [int(x) for x in input().split()]
import bisect
L = sorted(L)
ans = 0
for i in range(1, N - 1):
for j in reversed(list(range(i + 1, N))):
k = bisect.bisect_right(L[0:i], L[j] - L[i])
ans += i - k
print(ans) | N = int(eval(input()))
L = [int(x) for x in input().split()]
import bisect
L = sorted(L)
ans = 0
for i in range(N - 2):
for j in reversed(list(range(i + 1, N - 1))):
k = bisect.bisect_left(L, L[i] + L[j], j)
ans += k - j - 1
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):
a = L[i]
for j in range(i+1, N):
b = L[j]
idx = bisect_left(L, a+b)
ans += max(idx - (j+1), 0)
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 permutations, combinations,combinations_with_replacement,product
N = int(eval(input()))
L = list(map(int,input().split()))
L.sort()
cnt = 0
l = list(combinations(L,3))
for i in l:
if i[0] + i[1] > i[2]:
cnt += 1
else:
pass
print(cnt)
| from itertools import permutations, combinations,combinations_with_replacement,product
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):
for k in range(j+1,N):
if L[i] + L[j] > L[k]:
cnt += 1
print(cnt)
| p02888 |
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]
for k in range(j + 1, n):
c = L[k]
if c >= a + b:
break
ans += 1
print(ans)
| n = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
ans = 0
for i in range(n - 2):
a = L[i]
k = i
for j in range(i + 1, n - 1):
b = L[j]
while k < n and L[k] < a + b:
k += 1
ans += k - (j + 1)
print(ans)
| p02888 |
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):
a=l[i]
b=l[j]
ans+=i-bisect.bisect_right(l[:i],b-a)
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):
m=bisect.bisect_right(l,l[j]-l[i])
if i>m:
ans+=i-m
print(ans)
| p02888 |
n = int(eval(input()))
ll = [int(w) for w in input().split()]
ll.sort(reverse=True)
ans = 0
for ei, i in enumerate(ll):
for ej, j in enumerate(ll[ei + 1:]):
ans += len([w for w in ll[ei + ej + 2:] if w > i - j])
print(ans)
| import bisect
n = int(eval(input()))
ll = [int(w) for w in input().split()]
ll.sort()
ans = 0
for i in range(n):
for j in range(i + 1, n):
ans += bisect.bisect_left(ll, ll[i] + ll[j]) - (j + 1)
print(ans)
| p02888 |
from bisect import bisect_left, bisect_right
n = int(eval(input()))
l_list = [int(x) for x in input().split()]
l_list.sort()
ans = 0
for i in range(n - 2):
continue_flag = False
for j in range(i + 1, n - 1):
l = bisect_right(l_list, l_list[j] - l_list[i])
l = l if l > j else j + 1
if l == n:
continue_flag = True
break
r = bisect_left(l_list, l_list[j] + l_list[i])
ans += r - l
if continue_flag:
continue
print(ans) | from bisect import bisect_left
n = int(eval(input()))
l_list = [int(x) for x in input().split()]
l_list.sort()
# print(l_list)
ans = 0
for i in range(n - 2):
continue_flag = False
for j in range(i + 1, n - 1):
ans += bisect_left(l_list, l_list[j] + l_list[i]) - (j + 1)
print(ans) | p02888 |
import itertools as it
n=int(eval(input()))
l=list(map(int,input().split()))
com=list(it.combinations(l,3))
# print(com)
# print(len(com))
cnt=0
for i in com:
if i[0]+i[1]>i[2] and i[1]+i[2]>i[0] and i[0]+i[2]>i[1]:
cnt+=1
else:
cnt+=0
print(cnt) | N=int(eval(input()))
l=list(map(int,input().split()))
l.sort()
cnt=0
for i in range(N-1):
for j in range(i+1,N):
k=j+1
while k<N:
if l[i]+l[j]>l[k]:
cnt+=1
k+=1
else:
cnt+=0
k+=1
print(cnt)
| p02888 |
import itertools
N = int(eval(input()))
L = list(map(int, input().split()))
A = list(itertools.combinations(L, 3))
ans = 0
for i in A:
if i[0] >= i[1]+i[2]:
continue
if i[1] >= i[0]+i[2]:
continue
if i[2] >= i[1]+i[0]:
continue
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-1, 1,-1):
for j in range(i-1,0,-1):
x = L[i]-L[j]
maxindex = bisect.bisect_right(L, x)
if j>maxindex:
ans += j-maxindex
print(ans)
| p02888 |
import bisect
def LI():
return list(map(int, input().split()))
N = int(eval(input()))
L = LI()
L.sort()
ans = 0
for i in range(N-1, 1, -1):
for j in range(i-1, 0, -1):
xl = L[i]-L[j]
ind = bisect.bisect_right(L, xl)
if j > ind:
ans += j-ind
print(ans)
| import bisect
def LI():
return list(map(int, input().split()))
N = int(eval(input()))
L = LI()
L.sort()
ans = 0
for i in range(N-1, 1, -1):
for j in range(i-1, 0, -1):
ind = bisect.bisect_right(L, L[i]-L[j])
if ind < j:
ans += j-ind
print(ans)
| p02888 |
import bisect
N = int(eval(input()))
ans = 0
L = list(map(int,input().split()))
L = sorted(L)
for i in range(N-1):
for j in range(i+1,N):
a = bisect.bisect(L,L[i]+L[j])
if L[i]+L[j] in L:
a -= 1
ans += a-j-1
print(ans)
| import bisect
N = int(eval(input()))
ans = 0
L = list(map(int,input().split()))
L = sorted(L)
for i in range(N-1):
for j in range(i+1,N):
a = bisect.bisect(L,L[i]+L[j]-1)
ans += a-j-1
print(ans)
| p02888 |
from itertools import combinations
N = int(eval(input()))
L = [int(i) for i in input().split()]
c = 0
def check(a, b, c):
return (a < b+c) and (b < c+a) and (c < a+b)
for i, j, k in combinations(L, 3):
c += check(i, j, k)
print(c)
| from bisect import bisect_left
N = int(eval(input()))
L = sorted([int(i) for i in input().split()])
res = 0
for i in range(N):
for j in range(i+1, N):
r = bisect_left(L, L[i]+L[j])
res += max(r-(j+1), 0)
print(res)
| p02888 |
# coding: utf-8
import itertools
num = int(eval(input()))
lines = list(int(i) for i in input().split())
lines.sort(reverse=True)
counter = 0
comb = itertools.combinations(lines, 3)
for c in comb:
cl = list(c)
if cl[0] < cl[1] + cl[2]:
counter += 1
print(counter) | import bisect
n = int(eval(input()))
lines = list(int(i) for i in input().split())
lines.sort()
counter = 0
for i in range(n-2):
for j in range(i+1, n-1):
counter += bisect.bisect_left(lines, lines[i] + lines[j]) - (j + 1)
print(counter) | p02888 |
import bisect
N=int(eval(input()))
L=list(map(int,input().split()))
L.sort()
ans=0
for i in range(len(L)-1):
for j in range(i+1,len(L)):
left=bisect.bisect_left(L, L[i]+L[j])
right=bisect.bisect_right(L, L[j]-L[i])
if left > j:
ans+=left-j-1
# break
print(ans) | import bisect
N=int(eval(input()))
L=list(map(int,input().split()))
L.sort()
ans=0
for i in range(len(L)-1):
for j in range(i+1,len(L)):
left=bisect.bisect_left(L, L[i]+L[j])
if left > j:
ans+=left-j-1
print(ans) | p02888 |
N = int(eval(input()))
L = list(map(int,input().split()))
count = 0
import itertools
C = list(itertools.combinations(L,3))
l = len(C)
for i in range(l):
s = sorted(C[i])
if s[0] + s[1] <= s[2]:
pass
else:
count = count + 1
print(count) | N = int(eval(input()))
L = list(map(int, input().split()))
C = sorted(L)
count = 0
import bisect
for i in range(N - 2):
for j in range(N - i - 2):
s = C[i] + C[j + i + 1]
t = bisect.bisect_left(C,s)
u = t - (j + i + 1) - 1
if u <= 0:
pass
else:
count = count + u
print(count) | p02888 |
from bisect import bisect_left
n = int(eval(input()))
llist = list(map(int, input().split()))
llist.sort()
res = 0
for i in range(n-2):
for j in range(i+1,n-1):
num = llist[i] + llist[j]
idx = bisect_left(llist, num, lo=j+1, hi=n)
res += idx - j - 1
print(res) | n = int(eval(input()))
llist = list(map(int, input().split()))
llist.sort()
res = 0
for i in range(n-2):
prev = n-1
for j in range(n-2,i,-1):
for k in range(prev, j, -1):
if llist[k] < llist[i] + llist[j]:
res += k - j
prev = k
break
print(res) | p02888 |
import bisect
n = int(eval(input()))
l = list(map(int, input().split()))
count = 0
l.sort(reverse = False)
for i in range(len(l)-1, 1, -1):
for j in range(i-1, 0, -1):
pt = bisect.bisect_right(l, l[i] - l[j])
count += max(j - pt, 0)
print(count)
| import bisect
n = int(eval(input()))
l = list(map(int, input().split()))
count = 0
l.sort()
for i in range(len(l)-1, 1, -1):
for j in range(i-1, 0, -1):
count += max(j - (bisect.bisect_right(l, l[i] - l[j])), 0)
print(count)
| p02888 |
n= int(eval(input()))
l=list(map(int,input().split()))
cnt=0
ls = sorted(l)
for i in range(n-1):
for j in range(i+1,n-1):
for h in range(j+1,n):
a,b,c=ls[i],ls[j],ls[h]
if(a+b<c):
break
if(a<b+c)and(b<a+c)and(c<a+b):
cnt+=1
print(cnt) | from bisect import bisect_left
n = int(eval(input()))
l = list(map(int,input().split()))
l.sort()
count = 0
for i in range(n-2):
for j in range(i+1,n-1):
count+=bisect_left(l,l[j]+l[i])-j-1
print(count) | p02888 |
from bisect import bisect_left
N = int(eval(input()))
L = list(map(int,input().split()))
L_1 = sorted(L)
ans = 0
for i in range(N-1):
for j in range(i+1,N-1):
A = bisect_left(L_1,L_1[i]+L_1[j])
for k in range(j+1,A):
if L_1[i]+L_1[j] > L_1[k]:
ans += 1
print(ans) | from bisect import bisect_left
N = int(eval(input()))
L = list(map(int,input().split()))
L_1 = sorted(L)
ans = 0
for i in range(N-1):
for j in range(i+1,N-1):
ans +=bisect_left(L_1,L_1[i]+L_1[j])-j-1
print(ans) | p02888 |
import itertools
d = int(eval(input()))
d = list(map(int,input().split()))
n = 3
ans = 0
for i in itertools.combinations(d,n):
if i[0] < i[1]+i[2] and i[1] < i[0]+i[2] and i[2] < i[1]+i[0]:
ans += 1
print(ans) | import bisect
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):
k = bisect.bisect_left(l,l[i]+l[j])
if k > j:
ans += k - j -1
print(ans)
| p02888 |
from itertools import combinations
n = int(eval(input()))
l = list(map(int, input().split()))
cnt = 0
for i in combinations(list(range(n)), 3):
a,b,c = i
if (l[a] < l[b] + l[c]) and (l[b] < l[c] + l[a]) and (l[c] < l[b] + l[a]):
cnt += 1
print(cnt) | from bisect import bisect_left
n = int(eval(input()))
l = sorted(list(map(int, input().split())))
#aを1番短い辺、bを2番めに短い辺とする
cnt = 0
for i in range(n-2):
for j in range(i+1, n-1):
c_i = bisect_left(l, l[i] + l[j])
cnt += c_i - (j+1)
print(cnt) | p02888 |
from bisect import bisect_left
n, *l = list(map(int, open(0).read().split()))
l.sort()
ans = 0
for i in range(n):
for j in range(i + 1, n):
ng = n - bisect_left(l, l[i] + l[j]) + 1
ans += (n - j) - ng
print(ans)
| from bisect import bisect_left
n, *l = list(map(int, open(0).read().split()))
l.sort()
print((sum(bisect_left(l, l[i] + l[j]) - 1 - j for i in range(n)
for j in range(i + 1, n))))
| p02888 |
import itertools
n = int(eval(input()))
l = list(map(int, input().split()))
ll = list(itertools.combinations(l, 3))
ans = 0
for a, b, c in ll:
if a < b+c and b < c+a and c<a+b:
ans += 1
print(ans) | import bisect
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):
s = l[i]+l[j]
tmpl = l[j+1:n]
ans += bisect_left(l[j+1:n], s)
print(ans) | p02888 |
import bisect
N = int(eval(input()))
L = list(map(int, input().split()))
L = sorted(L)
ans = 0
for i in range(N-1):
a = L[i]
for j in range(i+1, N):
b = L[j]
r = bisect.bisect_left(L, a+b)
l = max(i, j) + 1
ans += max(0, r-l)
print(ans)
| import bisect
N = int(eval(input()))
L = list(map(int, input().split()))
L = sorted(L)
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 |
import bisect
def main():
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
ans = 0
for ai in range(N-2):
a = L[ai]
for bi in range(ai+1,N-1):
b = L[bi]
cleft = max((a - b), (b - a))
cright = a + b
left_index = bisect.bisect_left(L[bi+1:],cleft)
right_index = bisect.bisect_left(L[bi+1:],cright)
if left_index == right_index:
if L[bi+1+left_index] < cright:
ans += 1
else:
ans += (right_index - left_index)
print(ans)
if __name__ == "__main__":
main()
| import bisect
def main():
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
ans = 0
for ai in range(N-2):
a = L[ai]
for bi in range(ai+1,N-1):
b = L[bi]
cmax = a + b
m_index = bisect.bisect_left(L,cmax)
ans += max(m_index - bi - 1, 0)
print(ans)
if __name__ == "__main__":
main()
| p02888 |
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
k2 = 2
ans = 0
for i in range(N-2):
for j in range(1,N-1-i):
s = L[i] + L[N-j-1]
if L[N-j] >= s:
ans += j
else:
for k in range(N-j+1,N):
if L[k] >= s:
ans += N-k
break
print(((N*(N-1)*(N-2))//6 - ans)) | import bisect as bs
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):
s = L[i] + L[j]
ans += bs.bisect_left(L,s) - j - 1
# bisect.bisect_left(list, x)
# はリストにxを挿入できる点を返す
# すなわち、
# (val < x for val in list[0:i]) + (val >= x for val in list[i:len(list)])
print(ans) | p02888 |
N = int(eval(input()))
L = [int(i) for i in input().split()]
import random
import time
from bisect import bisect_left
L_len = len(L)
L.sort()
count = 0
for i in range(0, L_len - 2):
for j in range(i + 1, L_len - 1):
length = L[i] + L[j]
idx = bisect_left(L, length, lo = j + 1, hi = L_len)
count += idx - j - 1
print(count)
| N = int(eval(input()))
L = [int(i) for i in input().split()]
from bisect import bisect_left
L.sort()
count = 0
for i in range(0, N - 2):
for j in range(i + 1, N - 1):
length = L[i] + L[j]
idx = bisect_left(L, length)
count += idx - j - 1
print(count)
| p02888 |
import itertools
n = int(eval(input()))
l = list(map(int, input().split()))
p = list(itertools.combinations(l,3))
def triangle(a, b, c):
if a < b + c and b < c + a and c < a + b:
return True
else:
return False
ans = 0
for i in p:
if triangle(i[0], i[1], i[2]):
ans += 1
print(ans) | 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
def bisect_right_reverse(a, x):
'''
reverseにソートされたlist aに対してxを挿入できるidxを返す。
xが存在する場合には一番右側のidx+1となる。
'''
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
n = int(eval(input()))
llis = list(map(int, input().split()))
lis = sorted(llis, reverse=True)
ans = 0
for i in range(n-2):
for j in range(i+1, n-1):
ans += max(bisect_left_reverse(lis, lis[i]-lis[j]) - j - 1, 0)
print(ans) | p02888 |
from bisect import bisect_left
import copy
from itertools import combinations
n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
li = list(combinations(l, 2))
ans = 0
for i in li:
x = copy.deepcopy(l)
x.remove(i[0])
x.remove(i[1])
left = abs(i[0] - i[1])
small = min(i[0], i[1])
x = [i for i in x if i < small]
if len(x) != 0:
left_div = bisect_left(x, left+1)
ans += max(0, len(x) - left_div)
print(ans) | from bisect import bisect_left
import copy
n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
ans = 0
for small in range(n - 2):
for mid in range(small + 1, n - 1):
div = bisect_left(l, l[small] + l[mid], 0, n)
if div > mid + 1:
ans += div - mid - 1
print(ans) | p02888 |
def binary_search(l, item):
if len(l) == 0 or l[0] <= item:
return -1
if item < l[-1]:
return len(l) - 1
list2 = [1001] + l + [0]
low = 0
high = len(list2) - 1
while low <= high:
mid = (low + high) // 2
bigger = list2[mid]
smaller = list2[mid+1]
if smaller <= item and item < bigger:
return mid - 1
if smaller > item:
low = mid + 1
else:
high = mid - 1
return -1
import heapq
N = int(eval(input()))
L = []
for l in map(int, input().split(' ')):
heapq.heappush(L, l*(-1))
L = [heapq.heappop(L)*(-1) for _ in range(N)]
# L = sorted(L, reverse=True)
result = 0
for i, a in enumerate(L[:-2:]):
for j, b in enumerate(L[i+1:-1:]):
k = binary_search(L[i+j+2::], a-b)
if k == -1:
break
result += k + 1
print(result)
| from bisect import bisect_left
N = int(eval(input()))
L = list([int(l)*(-1) for l in input().split()])
L.sort()
result = 0
for i, a in enumerate(L[:-2:]):
for ii, b in enumerate(L[i+1:-1:]):
c_list = L[i+ii+2::]
c_index = bisect_left(c_list, a-b)
result += c_index
print(result)
| p02888 |
#ABC143-D:二分探索
n=int(eval(input()))
l=list(map(int,input().split()))
l=sorted(l,reverse=True)
ans=0
#print(l)
for i in range(n-2):
for j in range(i+1,n-1):
b=l[i]
c=l[j]
#二分探索
ok=j
ng=n
while ng-ok>1:
mid=(ok+ng)//2
if l[mid]>b-c:
#b>=cはわかってる
ok=mid
else:
ng=mid
ans+=ok-j
print(ans) | #ABC143-D
n=int(eval(input()))
l=list(map(int,input().split()))
l=sorted(l,reverse=True)
ans=0
#print(l)
for i in range(n-2):
for j in range(i+1,n-1):
b=l[i]
c=l[j]
#二分探索
ok=j
ng=n
while ng-ok>1:
mid=(ok+ng)//2
if l[mid]>b-c:
#b>=cはわかってる
ok=mid
else:
ng=mid
ans+=ok-j
print(ans) | p02888 |
from collections import Counter
n = int(eval(input()))
l = list(map(int,input().split()))
l = sorted(l)
CNT = Counter(l)
cnt = 0
for i in range(n - 2):
for j in range(i + 1, n - 1):
temp0 = l[j] - l[i]
temp1 = l[j] + l[i]
for k in range(l[j] + 1, temp1):
#print(k,CNT[k])
cnt += CNT[k]
if k == l[j]:cnt += -1
if k == l[i]:cnt += -1
print(cnt)
#print(CNT) | def low(list, j, tag):
ok = j
ng = n
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if list[mid] >= tag:ok = mid
else:ng = mid
return ok
n = int(eval(input()))
l = list(map(int,input().split()))
l = sorted(l, reverse = True)
#print(l)
cnt = 0
for i in range(n - 2):
for j in range(i + 1, n - 1):
temp0 = l[i] - l[j]
temp1 = l[j] + l[i]
cnt += low(l, j, temp0 + 1) - j
#print((l[i],l[j]), j, low(l, j, temp0 + 1) - j, cnt)
print(cnt)
| p02888 |
N = int(eval(input()))
L = list(map(int, input().split()))
# import bisect
L.sort()
# print(L)
ans = 0
for l1ix in range(N-1, -1, -1):
for l2ix in range(l1ix - 1, -1, -1):
# binsearch
l = -1
r = l2ix + 1
while (r - l) > 1:
mid = l + (r - l) // 2
if L[mid] < (L[l1ix] + L[l2ix]) and L[l2ix] < L[mid] + L[l1ix] and L[l1ix] < L[mid] + L[l2ix]:
#ok
r = mid
else:
#ng
l = mid
l3ix = r
# if l2ix != l3ix:
# print("1,2,3=", L[l1ix], L[l2ix], L[l3ix])
anst = l2ix - l3ix
ans += anst if anst > 0 else 0
print(ans)
"""
O(N^3)だから間に合わない．明らかに間に合うアルゴリズムを探す
ans = 0
for aix in range(N):
for bix in range(aix + 1, N):
for cix in range(bix + 1, N):
if L[aix] < L[bix] + L[cix] and L[bix] < L[aix] + L[cix] and L[cix] < L[aix] + L[bix]:
# print("ok:", aix,",", bix,",", cix)
ans += 1
print(ans)
"""
| N = int(eval(input()))
L = list(map(int, input().split()))
import bisect
L.sort()
# print(L)
ans = 0
for i in range(0, N-1):
for j in range(i+1, N-1):
ix = bisect.bisect_left(L, L[i] + L[j])
ans += max(0, ix - j - 1)
print(ans) | p02888 |
import bisect
N = int(eval(input()))
L = list(map(int,input().split()))
L = sorted(L)
res = 0
for i in range(N-2):
for j in range(i+1,N-1):
tgt = L[i]+L[j] - 0.1
res += bisect.bisect_right(L, tgt)-(j+1)
print(res)
| import bisect
N = int(eval(input()))
L = list(map(int,input().split()))
L = sorted(L)
res = 0
for i in range(N-2):
for j in range(i+1,N-1):
tgt = L[i]+L[j]
res += bisect.bisect_left(L, tgt)-(j+1)
print(res)
| p02888 |
n = int(eval(input()))
l = [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):
if l[j] + l[k] <= l[i]:
continue
elif l[i] + l[j] <= l[k]:
continue
elif l[k] + l[i] <= l[j]:
continue
ans += 1
print(ans) | import bisect
n = int(eval(input()))
l = [int(x) for x in input().split()]
l.sort()
ans = 0
for a in range(n):
for b in range(a + 1, n):
c = bisect.bisect_left(l, l[a] + l[b])
if b < c:
ans += c - (b + 1)
print(ans) | p02888 |
import time
from bisect import bisect_left
n = int(eval(input()))
l = list(map(int, input().split()))
l = sorted(l)
start = time.time()
res = 0
for i in range(n):
for j in range(i+1,n):
ab = l[i] + l[j]
c_index = bisect_left(l, ab)
res += c_index - j - 1
print(res)
| from bisect import bisect_left
N = int(eval(input()))
Lmat = [int(n) for n in input().split()]
Lmat.sort()
sum = 0
for i in range(N):
for j in range(i+1,N):
sum+= bisect_left(Lmat, Lmat[i]+Lmat[j]) - j - 1
print(sum) | p02888 |
import sys
input=sys.stdin.readline
n=int(eval(input()))
l=list(map(int,input().split()))
l.sort()
import bisect
ans=0
for i in range(n):
for j in range(i+1,n):
x=bisect.bisect_left(l[j+1:n],l[i]+l[j])
ans+=x
print(ans)
| import sys
input=sys.stdin.readline
n=int(eval(input()))
l=list(map(int,input().split()))
l.sort()
import bisect
ans=0
for i in range(n):
for j in range(i+1,n):
x=bisect.bisect_left(l,l[i]+l[j],lo=j+1)
ans+=x-j-1
print(ans)
| p02888 |
a = int(eval(input()))
b = [int(i) for i in input().split()]
print(((int)(sum(1 for x in range(a-2) for y in range(x+1,a-1) for z in range(y+1,a) if (b[x]<b[y]+b[z] and b[y]<b[x]+b[z] and b[z]<b[x]+b[y])))))
| a = int(eval(input()))
arr = [int(i) for i in input().split()]
arr.sort()
count = 0
for i in range(0,a-2):
k = i + 2
for j in range(i+1,a):
while (k < a and arr[i] + arr[j] > arr[k]):
k += 1
if(k>j):
count += k - j - 1
print(count)
| p02888 |
from bisect import bisect_left
N = int(eval(input()))
L = sorted([int(i) for i in input().split()])
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 = sorted([int(i) for i in input().split()])
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 |
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=j
while k<n and l[k]<a+b:
k+=1
ans+=k-j-1
print(ans)
| n=int(eval(input()))
l=list(map(int,input().split()))
l.sort()
ans=0
for i in range(n-2):
a=l[i]
k=i
for j in range(i+1,n-1):
b=l[j]
while k<n and l[k]<a+b:
k+=1
ans+=k-j-1
print(ans)
| p02888 |
def upperbound(nums, value):
low = 0
high = len(nums)
while low < high:
mid = (low + high) >> 1
if value > nums[mid]:
low = mid + 1
else:
high = mid
return low
n = int(eval(input()))
ar = list(map(int, input().split()))
ar.sort()
total = 0
for i in range(n):
for j in range(i + 1, n):
sum2edge = ar[i] + ar[j]
index = upperbound(ar, sum2edge)
if index > j:
total += (index - j - 1)
print(total) | def findnumberofTriangles(arr):
# Sort array and initialize count as 0
n = len(arr)
arr.sort()
count = 0
# Fix the first element. We need to run till n-3 as
# the other two elements are selected from arr[i+1...n-1]
for i in range(0,n-2):
# Initialize index of the rightmost third element
k = i + 2
# Fix the second element
for j in range(i+1,n):
# Find the rightmost element which is smaller
# than the sum of two fixed elements
# The important thing to note here is, we use
# the previous value of k. If value of arr[i] +
# arr[j-1] was greater than arr[k], then arr[i] +
# arr[j] must be greater than k, because the array
# is sorted.
while (k < n and arr[i] + arr[j] > arr[k]):
k += 1
# Total number of possible triangles that can be
# formed with the two fixed elements is k - j - 1.
# The two fixed elements are arr[i] and arr[j]. All
# elements between arr[j+1] to arr[k-1] can form a
# triangle with arr[i] and arr[j]. One is subtracted
# from k because k is incremented one extra in above
# while loop. k will always be greater than j. If j
# becomes equal to k, then above loop will increment k,
# because arr[k] + arr[i] is always greater than arr[k]
if(k>j):
count += k - j - 1
return count
n = int(eval(input()))
ar = list(map(int, input().split()))
print((findnumberofTriangles(ar)))
| p02888 |
import sys
stdin = sys.stdin
ns = lambda : stdin.readline().rstrip()
ni = lambda : int(ns())
na = lambda : list(map(int, stdin.readline().split()))
def C(n,r):
if n < 0 or r < 0 or n < r:
return 0
elif n == 0 or r == 0:
return 1
return C(n-1,r-1)+C(n-1,r)
def main():
n = ni()
l = sorted(na())
j = n - 2
k = n - 1
cnt = 0
dame = []
for i in range(n - 3, -1, -1):
try:
if i in dame or j in dame or k in dame:
continue
a = l[i]
b = l[j]
c = l[k]
if a < b + c and b < a + c and c < a + b:
cnt += C(n - i - len(dame) - 1, 2)
j -= 1
k -= 1
else:
tmp = j
while True:
a = l[i]
b = l[j]
c = l[k]
if a < b + c and b < a + c and c < a + b:
break
j += 1
k += 1
tmp = j
cnt += C(n - tmp - 1 - len(dame), 2)
dame.append(i)
except:
break
print(cnt)
main() | import sys
stdin = sys.stdin
ns = lambda : stdin.readline().rstrip()
ni = lambda : int(ns())
na = lambda : list(map(int, stdin.readline().split()))
from bisect import bisect_left
def main():
n = ni()
l = sorted(na())
ans = 0
for i in range(n):
for j in range(i+1, n):
t = l[i] + l[j]
ind = bisect_left(l, t)
ans += max(0, ind - j - 1)
print(ans)
main() | p02888 |
def is_triangle(a, b, c):
if a >= b + c:
return False
if b >= a + c:
return False
if c >= a + b:
return False
return True
def main():
N = int(eval(input()))
L = list([int(x) for x in input().split()])
L.sort(reverse=True)
count = 0
for index, a in enumerate(L):
if index + 2 == N:
break
for b_i in range(index+1, N):
b = L[b_i]
c_i = 1
while not is_triangle(a, b, L[-c_i]):
if c_i + b_i == N:
break
c_i += 1
count += (N - b_i - c_i)
print(count)
if __name__ == '__main__':
main()
|
def is_triangle(a, b, c):
if a >= b + c:
return False
if b >= a + c:
return False
if c >= a + b:
return False
return True
def main():
N = int(eval(input()))
L = list([int(x) for x in input().split()])
L.sort(reverse=True)
count = 0
for a_i in range(N-2):
b_i = a_i + 1
c_i = 1
while b_i + c_i < N:
if not is_triangle(L[a_i], L[b_i], L[-c_i]):
c_i += 1
else:
count += (N - b_i - c_i)
b_i += 1
print(count)
if __name__ == '__main__':
main()
| p02888 |
import bisect
import sys
input = sys.stdin.readline
def read_i():
return list(map(int, input().split()))
n = int(eval(input()))
ls = sorted(read_i())
ls2 = ls[::-1]
res = 0
for i, x in enumerate(ls2):
for j, y in enumerate(ls2[i + 1:], i + 1):
res += n - j - 1 - bisect.bisect(ls[:-(j + 1)], x - y)
print(res) | import bisect
import sys
input = sys.stdin.readline
def read_i():
return list(map(int, input().split()))
n = int(eval(input()))
ls = sorted(read_i())
res = 0
for i in range(n - 2):
x = ls[i]
for j in range(i + 1, n - 1):
y = ls[j]
res += bisect.bisect_left(ls, x + y) - j - 1
print(res) | p02888 |
def is_triangle(a, b, c):
return a < b + c and b < c + a and c < a + b
def main():
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):
if not is_triangle(L[j + 1], L[i], L[j]):
# cannot construct with L[k] for all k > j
continue
if is_triangle(L[N - 1], L[i], L[j]):
# can construct with L[k] for all k > j
cnt += N - 1 - j
continue
# binary search
ok = j + 1
ng = N - 1
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if is_triangle(L[mid], L[i], L[j]):
ok = mid
else:
ng = mid
cnt += ok - j
print(cnt)
if __name__ == '__main__':
main() | import bisect
def main():
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):
index = bisect.bisect_left(L, L[i] + L[j])
cnt += max([0, index - j - 1])
print(cnt)
if __name__ == '__main__':
main() | p02888 |
n = int(eval(input()))
l = list(map(int, input().split()))
l = sorted(l)
res = 0
for i in range(n):
for j in range(i+1, n, 1):
a = l[i]
b = l[j]
ab = a + b
f = 0
for k in range(j+1, n, 1):
if l[k] < ab:
res += 1
f = 1
else:
break
if f == 0:
continue
print(res) | from bisect import bisect_left
n = int(eval(input()))
l = list(map(int, input().split()))
l = sorted(l)
res = 0
for i in range(n):
for j in range(i+1,n):
ab = l[i] + l[j]
c_index = bisect_left(l, ab)
res += c_index - j - 1
print(res) | p02888 |
import math
import collections
import itertools
import sys
import bisect
from heapq import heappop,heappush,heapify
sys.setrecursionlimit(10**6)
def MAP(): return list(map(int,input().split()))
def INT(): return int(eval(input()))
def FLOAT(): return float(eval(input()))
MOD = 10**9+7
from math import factorial
def comb(n,r):
return factorial(n) // (factorial(r) * factorial(n - r))
n = INT()
l = MAP()
l.sort()
res=0
for i in range(n-2):
for j in range(i+1,n-1):
for k in range(j+1,n):
if l[i]+l[j]<=l[k]:
res+=n-k
break
else:
break
print((comb(n,3)-res)) | import math
import collections
import itertools
import sys
import bisect
from heapq import heappop,heappush,heapify
sys.setrecursionlimit(10**6)
def MAP(): return list(map(int,input().split()))
def INT(): return int(eval(input()))
def FLOAT(): return float(eval(input()))
MOD = 10**9+7
n = INT()
l = MAP()
l.sort()
ans=0
for i in range(n):
for j in range(i+1,n):
idx = bisect.bisect_left(l,l[i]+l[j])
ans+=idx-j-1
print(ans) | p02888 |
#!/usr/bin/env python3
import bisect
N = int(input().split()[0])
l_list = list(map(int, input().split()))
l_list = sorted(l_list)
p_list = []
for a_i, a in enumerate(l_list):
for b_i, b in enumerate(l_list):
if a_i == b_i:
continue
c_kouho = a + b
c_i = bisect.bisect_left(l_list, c_kouho)
p_list += [
sorted([a, b, c])
for c_i, c in enumerate(l_list[: c_i + 1])
if c_i != a_i and c_i != b_i and abs(b - c) < a < b + c
]
p_list = ["{}_{}_{}".format(p[0], p[1], p[2]) for p in p_list]
ans = len(set(p_list))
print(ans)
| #!/usr/bin/env python3
import bisect
N = int(input().split()[0])
l_list = list(map(int, input().split()))
l_list = sorted(l_list)
total = 0
for a_i, a in enumerate(l_list):
# 一番長い辺を固定
for b_i, b in enumerate(l_list[:a_i]):
# 2番目に長い辺を固定
c_i = bisect.bisect_right(l_list, abs(a - b))
total += max(b_i - c_i, 0)
ans = total
print(ans)
| p02888 |
N = str(eval(input()))
N = int(N)
Lines = input().split(" ")
Lines = list(map(int, Lines))
answer = 0
for lineI in range(N):
for lineJ in range(lineI+1,N):
for lineK in range(lineJ+1,N):
if (Lines[lineI] + Lines[lineJ] > Lines[lineK]) and (Lines[lineK] + Lines[lineJ] > Lines[lineI]) and (Lines[lineK] + Lines[lineI] > Lines[lineJ]):
answer += 1
print(answer)
| N = int(eval(input()))
Lines = list(map(int, input().split(" ")))
Lines.sort()
answer = 0
import bisect
for lineI in range(N):
for lineJ in range(lineI+1,N):
answer += bisect.bisect_left(Lines,Lines[lineI]+Lines[lineJ])-lineJ-1
print(answer)
| p02888 |
import bisect
n=int(eval(input()))
L=list(map(int, input().split()))
L.sort()
#m = bisect.bisect_left(l, a + b)
#count += (m - j - 1)
count = 0
for i in range(n-1):
a = L[i]
for k in range(i+1,n-1):
b = L[k]
L_temp = L[k+1:]
count += (bisect.bisect_left(L_temp, a + b))
print(count) | import bisect
n=int(eval(input()))
L=list(map(int, input().split()))
L.sort()
count = 0
for i in range(n-2):
a = L[i]
for k in range(i+1,n-1):
b = L[k]
count += bisect.bisect_left(L, a + b) - k -1
print(count) | p02888 |
n = int(eval(input()))
L = list(map(int,input().split()))
ans = 0
import itertools
for l in list(itertools.combinations(L,3)):
a, b, c = l
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(reverse=True)
ans = 0
for i in range(n-2):
tmp = 0
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 a < b + c and b < a + c and c < a + b:
ans += 1
print(ans) | p02888 |
import bisect
N = int(eval(input()))
L = sorted([int(n) for n in input().split()])
#print(L)
count = 0
for i in range(N-1):
for j in range(i+1, N):
count += bisect.bisect_left(L[j+1:], L[i]+L[j])
print(count)
| import bisect
N = int(eval(input()))
L = sorted([int(n) for n in input().split()])
#print(L)
count = 0
for i in range(N-1):
b = L[:i]
c = L[i+1:]
for j in b:
count += bisect.bisect_left(c, L[i] + j)
print(count) | p02888 |
N = int(eval(input()))
S = list(sorted(map(int,input().split())))
cnt = 0
for i in range(N-2):
for j in range(i+1,N-1):
for k in range(j+1,N):
# print("{} {} {} {} {} {}".format(i,j,k,S[i],S[j],S[k]))
if S[i]+S[j] <= S[k]:
#print("break")
cnt += k-j-1
break
else:
cnt += k-j
print(cnt) | N = int(eval(input()))
S = list(sorted(map(int,input().split())))
cnt = 0
for j in range(1,N-1):
k=j+1
for i in range(j):
while True:
if k == N or S[i]+S[j] <= S[k]:
k-=1
break
k+=1
#print(i,j,k)
#print(S[i],S[j], S[j+1:k+1],k-j)
cnt += k-j
print(cnt)
| p02888 |
from bisect import bisect
N = int(eval(input()))
L = sorted([int(_) for _ in input().split()])
ans = 0
for a in range(N - 2):
for b in range(a + 1, N - 1):
#print(bisect(L,L[a]+L[b]-1)-b-1)
ans += bisect(L, L[a] + L[b] - 1) - b - 1
print(ans) | from bisect import bisect
n=int(eval(input()))
L=sorted(list(map(int,input().split())))
cnt=0
for i in range(n-2):
for j in range(i+1,n-1):
cnt +=bisect(L,L[i]+L[j]-1)-j-1
print(cnt) | p02888 |
from itertools import combinations
N = int(eval(input()))
L = list(map(int, input().split()))
c = combinations(L, 3)
ans = 0
for v in c:
a, b, c = v
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 i in range(N-1, 1, -1):
for j in range(i-1, 0, -1):
a, b = L[i], L[j]
c = a - b + 1
if c > b: continue
ans += (j - bisect.bisect_left(L, c))
print(ans) | p02888 |
def bin_search(list,value,low,high):
middle = int((low + high) / 2)
if low > high :
return 'nothing'
else:
if list[middle] == value:
return middle
elif list[middle] > value:
return bin_search(list,value,low,middle - 1)
elif list[middle] < value:
return bin_search(list,value,middle + 1,high)
n = int(eval(input()))
list = [int(x) for x in input().split()]
list.sort()
count = 0
for i in range(n - 1):
for j in range(i,n-1):
a = list[n - i - 1]
b = list[n - j - 2]
c = a - b + 1
while b > c :
if bin_search(list,c,0,len(list)-1) != 'nothing':
count += 1
c += 1
print(count)
| from bisect import bisect_left
count = 0
n = int(eval(input()))
list = sorted([int(x) for x in input().split()])
for i in range(n):
for j in range(i + 1, n) :
sum = list[i] + list[j]
a = bisect_left(list,sum)
count += a - j - 1
print(count)
| p02888 |
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):
x=bisect.bisect_left(l,l[i]+l[j])-j-1
ans+=max(0,x)
print(ans) | 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
print(ans) | p02888 |
n = int(eval(input()))
l = list(map(int, input().split()))
import itertools
def findsubsets(s, n):
return list(itertools.combinations(s, n))
s = set(range(0, n))
com = findsubsets(s, 3)
c = 0
fin = []
for i in com:
tem = list(i)
tem.sort()
fin.append(tem)
l.sort()
for i in fin:
if l[i[0]] + l[i[1]] > l[i[2]]: c += 1
print(c) | n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
c = 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]: c += 1
else: break
print(c) | p02888 |
import sys
input = sys.stdin.readline
def main():
n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
l.append(99999999)
c = 0
for i in range(n - 2):
t = i + 2
for j in range(i + 1, n - 1):
for k in range(t, n + 1):
if l[i] + l[j] <= l[k]:
t = k
break
if t > j: c += t - j - 1
if j + 1 == t: t += 1
print(c)
if __name__ == "__main__":
main()
| def main():
n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
l.append(99999999)
c = 0
for i in range(n - 2):
t = i + 2
for j in range(i + 1, n - 1):
for k in range(t, n + 1):
if l[i] + l[j] <= l[k]:
t = k
break
if t > j: c += t - j - 1
if j + 1 == t: t += 1
print(c)
if __name__ == "__main__":
main()
| p02888 |
import bisect
n = int(eval(input()))
length = list([int(x) for x in input().split()])
length.sort()
ans = 0
for i in range(n-2):
a = length[i]
for j in range(i+1,n-1):
b = length[j]
if i >= j:
continue
else:
c_candidates = length[j+1:]
max_bar = bisect.bisect_left(c_candidates,a+b)
ans += max_bar
print(ans) | import bisect
n = int(eval(input()))
#length = list(map(lambda x:int(x), input().split()))
length = list(map(int, input().split()))
length.sort()
ans = 0
for i in range(n-2):
a = length[i]
for j in range(i+1,n-1):
b = length[j]
if i >= j:
continue
else:
max_bar = bisect.bisect_left(length,a+b)
ans += max_bar - j - 1
print(ans) | p02888 |
import itertools
N = int(eval(input()))
A = list(map(int,input().split()))
B = list(itertools.combinations(A, 3))
ans = 0
for b in B:
if b[0] < b[1] + b[2] and b[1] < b[0] + b[2] and b[2] < b[0] + b[1]:
ans += 1
print(ans)
| N = int(eval(input()))
A = 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):
if A[i] < A[j] + A[k]:
if A[j] < A[i] + A[k]:
if A[k] < A[j] + A[i]:
ans += 1
print(ans)
| p02888 |
import sys
def main():
n = int(sys.stdin.readline().strip())
l = [int(s) for s in sys.stdin.readline().strip().split()]
# n = 4
# l = [1, 2, 3, 4]
l.sort()
# [lo, hi)
# Returns -1 if no valid item
def b_search(lo, hi, limit):
if lo >= hi:
return -1
if lo + 1 == hi:
return lo
assert lo + 1 < hi
mid = (lo + hi) // 2
if l[mid] < limit:
return b_search(mid, hi, limit)
else:
return b_search(lo, mid, limit)
ans = 0
for i in range(n-2):
for j in range(i+1, n-1):
a_plus_b = l[i] + l[j]
valid_longest_idx = b_search(j, n, a_plus_b)
ans += valid_longest_idx - j
print(ans)
main()
| import sys
def main():
n = int(sys.stdin.readline().strip())
l = [int(s) for s in sys.stdin.readline().strip().split()]
# n = 4
# l = [1, 2, 3, 4]
l.sort()
# [lo, hi)
# Returns -1 if no valid item
def b_search(lo, hi, limit):
while lo + 1 < hi:
mid = (lo + hi) // 2
if l[mid] < limit:
lo = mid
else:
hi = mid
if lo >= hi:
return -1
if lo + 1 == hi:
return lo
ans = 0
for i in range(n-2):
for j in range(i+1, n-1):
a_plus_b = l[i] + l[j]
valid_longest_idx = b_search(j, n, a_plus_b)
ans += valid_longest_idx - j
print(ans)
main()
| p02888 |
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):
k = bisect_left(l[j:], l[i] + l[j]) + j
ans += k - j - 1
print(ans) | from bisect import bisect_left
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):
k = bisect_left(l,l[i]+l[j])
ans += k - j - 1
print(ans) | p02888 |
import bisect
N = int(eval(input()))
Ls = list(map(int, input().split()))
Ls.sort()
# index: 0,...,N-1
ans = 0
print((sum(bisect.bisect_left(Ls[j+1:], J + I) for i,I in enumerate(Ls[:-2]) for j,J in enumerate(Ls[i+1:-1], start=i+1))))
# i: 0,...,N-3
# j: i+1,...,N-2
# k: j+1,...,N-1
| import bisect
N = int(eval(input()))
L = list(map(int, input().split()))
L.sort() # index: 0,...,N-1
ans = 0
for i in range(N-2): # i: 0,...,N-3
for j in range(i+1, N-1): # j: i+1,...,N-2
# k の満たすべき条件:
# 1. L[k] > L[j] - L[i]
# L[k] > L[j] なので自動的に満たす
# 2. L[k] < L[i] + L[j]
x = bisect.bisect_left(L, L[i]+L[j])
# (<L[i]+L[j]), (<L[i]+L[j]), ..., (<L[i]+L[j]) | (L[i]+L[j]<=), (L[i]+L[j]<=), ...
# | (x) より左側はOK
# j+1 より右側はOK
# L[j]<L[i]+L[j] と L[i]+L[j]<=L[x] より L[j]<L[x] つまり j<x
ans += x - (j + 1)
print(ans)
| p02888 |
def tri(l):
if l[0]<l[1]+l[2] and l[1]<l[2]+l[0] and l[2]<l[0]+l[1]:
return True
else: return False
import itertools
n=int(eval(input()))
l=list(map(int,input().split()))
li=list(itertools.combinations(l,3))
print((sum([tri(i) for i in li]))) | import itertools
n=int(eval(input()))
l=sorted(list(map(int,input().split())),reverse=True)
ans,tmp=0,0
ls=[sum(i) for i in list(itertools.combinations(l,2))]
for i in range(n-2):
tmp+=n-1-i
ans+=sum([j>l[i] for j in ls])-tmp
print(ans) | p02888 |
import sys
from bisect import bisect_left
input = sys.stdin.readline
def main():
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):
k = bisect_left(L, a + L[j])
ans += (k - 1 - j)
print(ans)
if __name__ == "__main__":
main()
| import sys
import bisect
input = sys.stdin.readline
def main():
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]) - 1
ans += c - b
print(ans)
if __name__ == "__main__":
main()
| p02888 |
import sys
import bisect
input = sys.stdin.readline
def main():
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]) - 1
ans += c - b
print(ans)
if __name__ == "__main__":
main()
| import sys
from bisect import bisect_left
input = sys.stdin.readline
def main():
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):
k = bisect_left(L, a + L[j])
ans += (k - 1 - j)
print(ans)
if __name__ == "__main__":
main()
| p02888 |
from bisect import bisect
from bisect import bisect_left
n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
ans = 0
for i in range(n):
for j in range(i+1, n):
left = l[j]-l[i]
right = l[i]+l[j]
ans += max(0, bisect_left(l, right) - max(j+1, bisect(l,left)))
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):
for j in range(i+1, n):
left = l[j]-l[i]
right = l[i]+l[j]
ans += max(0, bisect_left(l, right) - (j+1))
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):
for j in range(i+1, n):
left = l[j]-l[i]
right = l[i]+l[j]
ans += max(0, bisect_left(l, right) - (j+1))
print(ans) | n = int(eval(input()))
l = list(map(int, input().split()))
l.sort()
lt = [n] * (l[n-1] + l[n-2] + 1)
ans = 0
for i in range(l[0]+1):
lt[i] = 0
length = l[0]
for i in range(1, n):
if length < l[i]:
for j in range(length+1, l[i]+1):
lt[j] = i
length = l[i]
for i in range(n):
for j in range(i+1, n):
right = l[i]+l[j]
ans += max(0, lt[right] - (j+1))
print(ans) | p02888 |
import itertools
n = int(eval(input()))
l = list(map(int, input().split()))
def is_triangle(l):
a, b, c = l
if a >= b + c or b >= c + a or c >= a + b :
return 0
else:
return 1
ans = 0
for m in list(itertools.combinations(l,3)):
ans += is_triangle(m)
print(ans) | n = int(eval(input()))
l = list(map(int, input().split()))
def is_triangle(a,b,c):
if a < b + c and b < a + c:
return True
else:
return False
l.sort(reverse=True)
ans = 0
for i in range(n):
for j in range(i+1,n):
for k in range(j+1,n):
if is_triangle(l[i], l[j], l[k]):
ans += 1
else:
break
print(ans) | p02888 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.