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 itertool... | 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 itertool... | 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 = ... | #それゆけにぶたんまん
#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... | 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... | 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] ... | 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):
... | # 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 ... | 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 ... | # 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 ... | 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
# 中央値を求める（inde... | 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] ==... | 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[... | 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]))
... | 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 i... | 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(a... | 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... | 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... | 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
... | 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__ ==... | 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__ == "__ma... | 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
pri... | 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(uppe... | 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
... | 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:
... | 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
... | 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 ... | 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)
... | 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:
... | 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:
... | 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 +=... | 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 +=... | 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 +=... | 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... | 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
p... | 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... | 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:
... | 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
bre... | 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
prin... | 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(... | 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_i... | 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)
a... | 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:
... | 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... | 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 = ... | 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
p... | 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[... | 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... | 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
pr... | 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 = ... | 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(resul... | 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... | #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:
... | 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... | 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):
... | 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
... | 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] + ... | 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... | 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 ... | 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():
... | 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):
... | 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
... |
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
... | 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[:-(... | 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) - ... | 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]):
... | 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... | 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
... | 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 factor... | 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(... | 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.... | #!/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)... | 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]) a... | 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))
pr... | 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
el... | 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] < valu... | 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... | 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]:
... | 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
... | 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:]
... | 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:
... | 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
... | 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 ... | 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... | 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])
... | 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
... | 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
... | 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])
... | 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 r... | 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... | p02888 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.