input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
from collections import defaultdict
N = int(eval(input()))
A = [int(i) for i in input().split()]
P = []
H = defaultdict(list)
for i, v in enumerate(A):
H[i+v].append(i)
P.append((i, i-v))
ans = 0
for i, v in P:
for j in H[v]:
if i > j:
ans += 1
print(ans) | from collections import defaultdict
N = int(eval(input()))
A = [int(i) for i in input().split()]
H = defaultdict(int)
ans = 0
for i, v in enumerate(A):
ans += H[i-v]
H[i+v] += 1
print(ans) | p02691 |
import sys
def inpl(): return list(map(int, sys.stdin.readline().split()))
n = int(sys.stdin.readline())
a = inpl()
count = 0
maxx = max(a)
minn = min(a)
for i in range(n):
for j in range(i+1, n):
if a[i] + maxx < j-i:
break
elif a[i] + minn > j-i:
continue
if a[i] + a[j] == j - i:
count += 1
print(count) | import sys
def inpl(): return list(map(int, sys.stdin.readline().split()))
n = int(sys.stdin.readline())
a = inpl()
dic ={}
res = 0
for i in range(n):
res += dic.get(i - a[i], 0)
dic[i + a[i]] = dic.get(i + a[i], 0) + 1
print(res) | p02691 |
n = int(eval(input()))
a = list(map(int, input().split()))
total = 0
for i in range(n):
for j in range(i+1, n):
total += int(abs(j-i) == a[i]+a[j])
print(total) | n = int(eval(input()))
a = list(map(int, input().split()))
dict_diffs1 = dict()
dict_diffs2 = dict()
for i in range(1, n+1):
dict_diffs1[i+a[i-1]] = dict_diffs1.get(i+a[i-1], 0) + 1
dict_diffs2[i-a[i-1]] = dict_diffs2.get(i-a[i-1], 0) + 1
total = 0
for j in range(1, n+1):
total += dict_diffs1.get(j-a[j-1], 0)
total += dict_diffs2.get(j+a[j-1], 0)
total = total//2
print(total) | p02691 |
from collections import deque
N = int(eval(input()))
A = [
int(j) - i for i, j in enumerate(input().split())
]
ans = 0
d = deque(A)
for i in range(N):
a = d.popleft()
c = d.count(-a - 2 * i)
ans += c
print(ans) | from collections import deque, Counter
N = int(eval(input()))
A = [
int(j) - i for i, j in enumerate(input().split())
]
cnt_A = Counter(A)
ans = 0
d = deque(A)
for i in range(N):
a = d.popleft()
#c = d.count(-a - 2 * i)
c = cnt_A[-a - 2 * i]
ans += c
print(ans) | p02691 |
if __name__ == '__main__':
n = int(eval(input()))
a = [int(i) for i in input().split()]
d = dict()
count = 0
for no in a:
d[no] = set()
for i in range(n):
no = a[i]
pos = i+1
# print(d)
# print("> pos: "+str(pos))
if no < pos:
for j in range(no+1,pos,1):
# print(">> j: "+str(j))
if d.get(j-no) is not None and len(d.get(j-no)) > 0:
if pos - j in d.get(j-no):
count += 1
d[no].add(pos)
# print(d)
print(count)
| if __name__ == '__main__':
n = int(eval(input()))
a = [int(i) for i in input().split()]
d = dict()
count = 0
ar = [(a[i]+i+1) for i in range(n)]
br = [(i+1-a[i]) for i in range(n)]
for i in range(n):
if d.get(ar[i]) is not None:
d[ar[i]] += 1
else:
d[ar[i]] = 1
c = dict()
for i in range(n):
if c.get(br[i]) is not None:
c[br[i]] += 1
else:
c[br[i]] = 1
count = 0
for no in list(c.keys()):
if d.get(no) is not None:
count += (c[no]*d[no])
print(count)
| p02691 |
N=int(eval(input()))
Agents=list(map(int,input().split()))
from itertools import combinations
comb = list(combinations([i for i in range(N)],2))
cnt=0
for i in comb:
if Agents[i[0]] + Agents[i[1]] == abs(i[0] - i[1]):
cnt+=1
print(cnt)
| N=int(eval(input()))
Agents=list(map(int,input().split()))
# from itertools import combinations
# comb = list(combinations([i for i in range(N)],2))
# cnt=0
# for i in comb:
# if Agents[i[0]] + Agents[i[1]] == abs(i[0] - i[1]):
# print(i[0],i[1])
# cnt+=1
# print(cnt)
cnt=0
for i in range(0,N):
k=Agents[i]-(i+1)
if k<i:
k=i+1
for j in range(k,N):
if Agents[i]+Agents[j]==abs(i-j):
# print(i,j,Agents[i],Agents[j])
cnt+=1
print(cnt)
| p02691 |
N=int(eval(input()))
Agents=list(map(int,input().split()))
##Miss 1
# from itertools import combinations
# comb = list(combinations([i for i in range(N)],2))
# cnt=0
# for i in comb:
# if Agents[i[0]] + Agents[i[1]] == abs(i[0] - i[1]):
# print(i[0],i[1])
# cnt+=1
# print(cnt)
# Miss 2
# for i in range(0,N):
# k=Agents[i]-(i+1)
# if k<i:
# k=i+1
# for j in range(k,N):
# if Agents[i]+Agents[j]==abs(i-j):
# # print(i,j,Agents[i],Agents[j])
# cnt+=1
L={}
for i in range(N):
L['{}'.format(i+1)]=i+1 + Agents[i]
R={}
for j in range(N):
R['{}'.format(j+1)]=j+1 - Agents[j]
cnt=0
for key,value in list(L.items()):
for key2,value2 in list(R.items()):
if int(key) < int(key2) and value == value2:
cnt+=1
print(cnt)
| N=int(eval(input()))
Agents=list(map(int,input().split()))
##Miss 1
# from itertools import combinations
# comb = list(combinations([i for i in range(N)],2))
# cnt=0
# for i in comb:
# if Agents[i[0]] + Agents[i[1]] == abs(i[0] - i[1]):
# print(i[0],i[1])
# cnt+=1
# print(cnt)
# Miss 2
# for i in range(0,N):
# k=Agents[i]-(i+1)
# if k<i:
# k=i+1
# for j in range(k,N):
# if Agents[i]+Agents[j]==abs(i-j):
# # print(i,j,Agents[i],Agents[j])
# cnt+=1
L={}
for i in range(N):
s = i+1 + Agents[i]
if s in L:
L[s]+=1
else:
L[s]=1
R={}
for j in range(N):
s= j+1 - Agents[j]
if s in R:
R[s]+=1
else:
R[s]=1
cnt=0
for key,value in list(L.items()):
cnt += R.get(key,0) * value
# for key,value in L.items():
# for key2,value2 in R.items():
# if int(key) < int(key2) and value == value2:
# cnt+=1
print(cnt)
| p02691 |
import itertools
N = int(eval(input()))
A = list(map(int, input().split()))
array = list(itertools.combinations(list(range(N)), 2))
count = 0
for x in array:
if (A[x[1]] + A[x[0]]) == (x[1] - x[0]):
count += 1
print(count)
| N = int(eval(input()))
A = list(map(int, input().split()))
count = 0
l_array = []
r_array = []
for i, X in enumerate(A):
l_array.append(i + X)
r_array.append(i - X)
for x in l_array:
count += r_array.count(x)
print(count)
| p02691 |
import collections
N = int(eval(input()))
A = list(map(int, input().split()))
B = collections.defaultdict(int)
C = collections.defaultdict(int)
for i in range(N):
B[i-A[i]] += 1
C[i+A[i]] += 1
#print(B)
#print(C)
ans = 0
for i in B:
#print(i) i=Key
ans += B[i]*C[i]
print(ans) | import collections
N = int(eval(input()))
A = list(map(int, input().split()))
B = {}
C = {}
for i in range(N):
if i-A[i] in B:
B[i-A[i]] += 1
else:
B[i-A[i]] = 1
if i+A[i] in C:
C[i+A[i]] += 1
else:
C[i+A[i]] = 1
#print(B)
#print(C)
ans = 0
for i in B:
#print(i) i=Key
if i in C:
ans += B[i]*C[i]
print(ans) | p02691 |
import sys
input = sys.stdin.readline
n = int(eval(input()))
seq = [int(x) for x in input().split()]
visited = [False for _ in range(n)]
ans = 0
p = set()
for i, val in enumerate(seq):
if val > n:
continue
for j in range(min(n,i+val-2), n):
if abs(j-i) == val + seq[j]:
if not visited[i]:
visited[i] = True
if not visited[j]:
visited[j] = True
if (i,j) not in p:
ans += 1
p.add((i,j))
for j in range(0, max(i-val, 0)):
if abs(i - j) == val + seq[j]:
if not visited[i]:
visited[i] = True
if not visited[j]:
visited[j] = True
if (j,i) not in p:
ans += 1
p.add((j,i))
print(ans)
| import sys
input = sys.stdin.readline
n = int(eval(input()))
seq = [(int(x),i) for i, x in enumerate(input().split())]
seq1 =(i-x for x,i in seq)
seq2 =(i+x for x,i in seq)
d1 = dict()
d2 = dict()
s1 = set()
s2 = set()
for val in seq1:
try:
d1[val] += 1
except:
d1[val] = 1
for val in seq2:
try:
d2[val] += 1
except:
d2[val] = 1
ans = 0
for key in d1:
try:
ans += d1[key] * d2[key]
except:
pass
print(ans)
| p02691 |
N = int(eval(input()))
A = list(map(int, input().split()))
ans = 0
for i in range(N):
a = A[i]
for j in range(min(A[i] + i, N), N):
if a + A[j] == j - i:
ans += 1
print(ans)
| N = int(eval(input()))
A = list(map(int, input().split()))
ans = 0
d = {}
for i, a in enumerate(A):
tmp = i + 1 - a
if tmp in list(d.keys()):
d[tmp] += 1
else:
d[tmp] = 1
# print(d)
for i, a in enumerate(A):
tmp = a + i + 1
tmptmp = i + 1 - a
if tmp in list(d.keys()):
ans += d[tmp]
if tmptmp in list(d.keys()):
d[tmptmp] = max(0, d[tmptmp] - 1)
print(ans)
| p02691 |
import sys
input = lambda: sys.stdin.readline().rstrip()
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for i in range(1, n + 1):
now = a[i - 1]
for j in range(i + now, n):
if a[j] + now == (j+1) - i:
ans += 1
print(ans)
| import sys
input = lambda: sys.stdin.readline().rstrip()
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
R = {}
L = {}
for i in range(n):
r = i + a[i]
l = max(i - a[i], 0)
if r in R:
R[r] += 1
else:
R[r] = 1
if l in L:
L[l] += 1
else:
L[l] = 1
for k, v in list(R.items()):
if k in L:
ans += v * L[k]
print(ans)
| p02691 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import itertools
import math
N = int(eval(input()))
An = list(map(int,input().split()))
#組み合わせ nC2
numList = list(itertools.combinations(list(range(1,N+1)), 2))
count = 0
for pair in numList:
# 数字のdiff (絶対値) float型
numDiff = int(math.fabs(pair[1] - pair[0]))
# 身長の和
sumHeight = An[pair[0]-1] + An[pair[1]-1]
if numDiff == sumHeight:
count = count + 1
print(count) | N = int(eval(input()))
An = list(map(int,input().split()))
resultDict = {}
resultDict['diff'] = []
resultDict['sum'] = []
for num in range(1,N+1):
resultDict['diff'].append(int(num - An[num-1]))
resultDict['sum'].append(int(num + An[num-1]))
countN = 0
for i, name in enumerate(resultDict['diff']):
countN = countN + resultDict['sum'].count(name)
if name == resultDict['sum'][i]:
countN = countN - 1
print(countN) | p02691 |
class Map(dict):
def __missing__(self, key):
self[key] = 0
return 0
def main():
int(eval(input()))
d = Map()
ans = 0
for i, height in enumerate(input().split()):
height = int(height)
# 引き算のほうの i は足し算のよりも大きい。
# 従って，このように順番に見ていく必要がある。
d[i + height] += 1
ans += d[i - height]
return ans
if __name__ == '__main__':
print((main()))
# 大いに参考にした。
# https://kmjp.hatenablog.jp/entry/2020/05/03/1030
| # class Map(dict):
# def __missing__(self, key):
# # この割当てなしのほうが速い。
# # self[key] = 0
# return 0
def main():
int(eval(input()))
d = {}
ans = 0
for i, height in enumerate(input().split()):
height = int(height)
# 引き算のほうの i は足し算のよりも大きい。
# 従って，このように順番に見ていく必要がある。
got = d.get(i + height) or 0
d[i + height] = got + 1
ans += d.get(i - height) or 0
return ans
if __name__ == '__main__':
print((main()))
# 大いに参考にした。
# https://kmjp.hatenablog.jp/entry/2020/05/03/1030
| p02691 |
# class Map(dict):
# def __missing__(self, key):
# # この割当てなしのほうが速い。
# # self[key] = 0
# return 0
def main():
int(eval(input()))
d = {}
ans = 0
for i, height in enumerate(input().split()):
height = int(height)
# 引き算のほうの i は足し算のよりも大きい。
# 従って，このように順番に見ていく必要がある。
d.setdefault(i + height, 0)
d[i + height] += 1
ans += d.setdefault(i - height, 0)
return ans
if __name__ == '__main__':
print((main()))
# 大いに参考にした。
# https://kmjp.hatenablog.jp/entry/2020/05/03/1030
| # class Map(dict):
# def __missing__(self, key):
# # この割当てなしのほうが速い。
# # self[key] = 0
# return 0
def main():
int(eval(input()))
d = {}
ans = 0
d_setdefault = d.setdefault
for i, height in enumerate(input().split()):
height = int(height)
# 引き算のほうの i は足し算のよりも大きい。
# 従って，このように順番に見ていく必要がある。
d_setdefault(i + height, 0)
d[i + height] += 1
ans += d_setdefault(i - height, 0)
return ans
if __name__ == '__main__':
print((main()))
# 大いに参考にした。
# https://kmjp.hatenablog.jp/entry/2020/05/03/1030
| p02691 |
# class Map(dict):
# def __missing__(self, key):
# # この割当てなしのほうが速い。
# # self[key] = 0
# return 0
def main():
int(eval(input()))
d = {}
ans = 0
d_setdefault = d.setdefault
for i, height in enumerate(input().split()):
height = int(height)
# 引き算のほうの i は足し算のよりも大きい。
# 従って，このように順番に見ていく必要がある。
d_setdefault(i + height, 0)
d[i + height] += 1
ans += d_setdefault(i - height, 0)
return ans
if __name__ == '__main__':
print((main()))
# 大いに参考にした。
# https://kmjp.hatenablog.jp/entry/2020/05/03/1030
| # class Map(dict):
# def __missing__(self, key):
# # この割当てなしのほうが速い。
# # self[key] = 0
# return 0
def main():
int(eval(input()))
d = {}
ans = 0
d_setdefault = d.setdefault
d_get = d.get
for i, height in enumerate(input().split()):
height = int(height)
# 引き算のほうの i は足し算のよりも大きい。
# 従って，このように順番に見ていく必要がある。
got = d_get(i + height) or 0
d[i + height] = got + 1
ans += d_setdefault(i - height, 0)
return ans
if __name__ == '__main__':
print((main()))
# 大いに参考にした。
# https://kmjp.hatenablog.jp/entry/2020/05/03/1030
| p02691 |
# class Map(dict):
# def __missing__(self, key):
# # この割当てなしのほうが速い。
# # self[key] = 0
# return 0
def main():
int(eval(input()))
d = {}
ans = 0
d_setdefault = d.setdefault
d_get = d.get
for i, height in enumerate(input().split()):
height = int(height)
# 引き算のほうの i は足し算のよりも大きい。
# 従って，このように順番に見ていく必要がある。
got = d_get(i + height) or 0
d[i + height] = got + 1
ans += d_setdefault(i - height, 0)
return ans
if __name__ == '__main__':
print((main()))
# 大いに参考にした。
# https://kmjp.hatenablog.jp/entry/2020/05/03/1030
| def main():
int(eval(input()))
d = {}
ans = 0
d_get = d.get
for i, height in enumerate(input().split()):
height = int(height)
# 引き算のほうの i は足し算のよりも大きい。
# 従って，このように順番に見ていく必要がある。
got = d_get(i + height) or 0
d[i + height] = got + 1
ans += d_get(i - height) or 0
return ans
if __name__ == '__main__':
print((main()))
# 大いに参考にした。
# https://kmjp.hatenablog.jp/entry/2020/05/03/1030
| p02691 |
#!/usr/bin/env python3
from typing import Iterable
def main() -> None:
N = ri()
A = rmi()
max_A = max(A)
num = tuple(range(1, N + 1))
cand = 0
for a in range(N):
a_height = A[a]
for b in range(min(a + 1 + a_height, N), N):
diff_num = b - a
sum_height = A[a] + A[b]
if diff_num == sum_height:
cand += 1
w(cand)
def r() -> str:
return input().strip()
def ri() -> int:
return int(r())
def rmi(delim: str = ' ') -> int:
return tuple(map(int, input().split(delim)))
def w(data) -> None:
print(data)
def wm(data: Iterable) -> None:
print((' '.join(list(map(str, data)))))
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
from typing import Iterable
def main() -> None:
N = ri()
A = rmi()
num = tuple(range(1, N + 1))
cand = 0
log = {}
for i in range(0, N):
if i + 1 - A[i] in log:
cand += log[i + 1 - A[i]]
if i + 1 + A[i] in log:
log[i + 1 + A[i]] += 1
else:
log[i + 1 + A[i]] = 1
w(cand)
def r() -> str:
return input().strip()
def ri() -> int:
return int(r())
def rmi(delim: str = ' ') -> int:
return tuple(map(int, input().split(delim)))
def w(data) -> None:
print(data)
def wm(data: Iterable) -> None:
print((' '.join(list(map(str, data)))))
if __name__ == '__main__':
main()
| p02691 |
n = int(input().strip())
a = list(map(int, input().split()))
left = {}
for i in range(len(a)):
if left.get(a[i] + i):
left[a[i] + i].append(i)
else:
left[a[i] + i] = [i]
ans = 0
for i in range(len(a)):
if left.get(i - a[i]):
ans += len(list([x for x in left[i - a[i]] if x < i]))
print(ans)
| n = int(input().strip())
a = list(map(int, input().split()))
dic = {}
ans = 0
for i in range(len(a)):
if dic.get(i - a[i]):
ans += dic[i - a[i]]
if dic.get(a[i] + i):
dic[a[i] + i] += 1
else:
dic[a[i] + i] = 1
print(ans)
| p02691 |
from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
l = []
r = []
for i, ai in enumerate(a):
l.append(i+ai)
r.append(i-ai)
ans = 0
for i in l:
ans += r.count(i)
print(ans)
| from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
l = []
r = []
for i, ai in enumerate(a):
l.append(i+ai)
r.append(i-ai)
ans = 0
b = Counter(r)
for i in l:
ans += b.get(i, 0)
print(ans)
| p02691 |
n = int(eval(input()))
a = list(map(int,input().split()))
ans = 0
for i in range(n):
if a[i]>=n:
continue
for j in range(a[i]+1,n):
if a[j]==j-a[i]-i:
ans += 1
print(ans) | n = int(eval(input()))
a = list(map(int,input().split()))
ans = 0
d = {}
for i in range(n):
if d.get(i+a[i],0)==0:
d[i+a[i]] = [0,0]
if d.get(i-a[i],0)==0:
d[i-a[i]] = [0,0]
d[i+a[i]][0] += 1
d[i-a[i]][1] += 1
for v in list(d.values()):
ans += v[0]*v[1]
print(ans) | p02691 |
n = int(eval(input()))
a_list = list(map(int, input().split()))
agents = {}
n_pair = 0
for i, a in enumerate(a_list):
x = i - a
if x not in agents:
agents[x] = []
agents[x].append(i)
for i, a in enumerate(a_list):
x = i + a
if x in agents:
for j in agents[x]:
if i != j:
n_pair += 1
print(n_pair) | n = int(eval(input()))
a_list = list(map(int, input().split()))
agents = {}
n_pair = 0
for i, a in enumerate(a_list):
x = i - a
if x not in agents:
agents[x] = 0
agents[x] += 1
for i, a in enumerate(a_list):
x = i + a
if x in agents:
n_pair += agents[x]
print(n_pair)
| p02691 |
from collections import defaultdict
import bisect
N = int(eval(input()))
A = list(map(int,input().split()))
plus = [A[i]+(i+1) for i in range(N)]
diff = [-A[i]+(i+1) for i in range(N)]
plusc = defaultdict(list)
for i in range(N):
plusc[plus[i]].append(i)
ans = 0
for i in range(1,N):
ans += bisect.bisect_left(plusc[diff[i]],i)
print(ans) | N = int(eval(input()))
A = list(map(int,input().split()))
count = 0
dicta = {}
for i in range(N):
if i - A[i] in dicta:
count += dicta[i-A[i]]
if i + A[i] in dicta:
dicta[i+A[i]] += 1
else:
dicta[i+A[i]] = 1
print(count) | p02691 |
#!/usr/bin/env python3
from collections import defaultdict
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main(A, N):
d1 = defaultdict(int)
d2 = defaultdict(int)
for i, a in enumerate(A):
d1[i+a] += 1
for i, a in enumerate(A):
d2[i-a] += 1
mn_x = min(min(d1.keys()), min(d2.keys()))
mx_x = max(max(d1.keys()), max(d2.keys()))
cnt = 0
for x in range(mn_x, mx_x+1):
cnt += d1[x]* d2[x]
print(cnt)
pass
if __name__ == '__main__':
N = int(eval(input()))
A = list(map(int, input().split()))
main(A, N)
| #!/usr/bin/env python3
from collections import defaultdict
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main(A, N):
d1 = defaultdict(int)
d2 = defaultdict(int)
for i, a in enumerate(A):
d1[i+a] += 1
for i, a in enumerate(A):
d2[i-a] += 1
cnt = 0
for x in list(d1.keys())+list(d2.keys()):
cnt += d1[x]* d2[x]
print((cnt//2))
pass
if __name__ == '__main__':
N = int(eval(input()))
A = list(map(int, input().split()))
main(A, N)
| p02691 |
import bisect
N = int(eval(input()))
A = list(map(int, input().split()))
ans, d = 0, dict()
for i in range(N):
diff = A[i] + A[0] - i
if d.get(diff) == None:
d[diff] = [i]
else:
d[diff].append(i)
diff = 0
if d.get(0) != None:
ans += len(d[0])
for i in range(1, N):
diff -= A[i] - A[i-1] + 1
dl = d.get(diff)
if dl != None:
index = bisect.bisect_right(dl, i)
d[diff] = d[diff][index:]
ans += len(d[diff])
print(ans) | N = int(eval(input()))
A = list(map(int, input().split()))
ans, d = 0, dict()
for i in range(N):
key = A[i] + i
if d.get(key) == None:
d[key] = 1
else:
d[key] += 1
key = i - A[i]
if d.get(key) != None:
ans += d[key]
print(ans) | p02691 |
N = int(eval(input()))
A = list(map(int, input().split()))
AI = sorted([(a, i) for i, a in enumerate(A)])
dic = list()
tmp = 0
for i, (a, pos) in enumerate(AI):
if a > 2 * 10**5:
break
if tmp != a:
tmp = a
dic.append((a, i))
nums = [a for (a, i) in dic]
inds = [i for (a, i) in dic]
inds.append(N)
L = len(dic)
def check(p1, p2):
# print(p1, p2)
sumsum = nums[p1] + nums[p2]
ret = 0
for i in range(inds[p1], inds[p1+1]):
for j in range(inds[p2], inds[p2+1]):
if sumsum == abs(AI[i][1] - AI[j][1]):
ret += 1
# print("return ", ret)
return ret // 2 if p1 == p2 else ret
# print(dic)
# print(nums)
# print(inds)
ans = 0
for i in range(L):
for j in range(i, L):
if nums[i] + nums[j] > 2 * 10**5:
continue
ans += check(i, j)
print(ans)
| N = int(eval(input()))
A = list(map(int, input().split()))
L = {}
R = {}
for i, a in enumerate(A):
x = i + 1 + a
L[x] = L[x] + 1 if x in L else 1
x = i + 1 - a
R[x] = R[x] + 1 if x in R else 1
# print(L, R)
ans = 0
for x in list(L.keys()):
ans += L[x] * (R[x] if x in R else 0)
print(ans)
| p02691 |
n=int(eval(input()))
a=list(map(int,input().split()))
ans=0
for i in range(n-1):
for j in range(i,n):
if a[i]+a[j]==(j+1)-(i+1):
ans+=1
print(ans) | n=int(eval(input()))
a=list(map(int,input().split()))
l=[0]*n
r=[0]*n
for i in range(n):
if a[i]+i+1<n:
l[a[i]+i+1]+=1
if i+1-a[i]>0:
r[i+1-a[i]]+=1
ans=0
for i in range(n):
ans+=l[i]*r[i]
print(ans) | p02691 |
import sys
sys.setrecursionlimit(10 ** 6)
# input = sys.stdin.readline ####
def int1(x): return int(x) - 1
def II(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def MI1(): return list(map(int1, input().split()))
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return input().split()
def printlist(lst, k='\n'): print((k.join(list(map(str, lst)))))
INF = float('inf')
from math import ceil, floor, log2
from collections import deque
from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product
def solve():
n = II()
A = LI()
memo = {}
ans = 0
for i in range(n):
mae = (i+1) + A[i]
ima = (i+1) - A[i]
ans += memo.get(ima, 0)
memo[mae] = memo.get(mae, 0) + 1
# print(memo)
print(ans)
if __name__ == '__main__':
solve()
| import sys
sys.setrecursionlimit(10 ** 9)
# input = sys.stdin.readline ####
def int1(x): return int(x) - 1
def II(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def MI1(): return list(map(int1, input().split()))
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(eval(input()))
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print((k.join(list(map(str, lst)))))
INF = float('inf')
# from math import ceil, floor, log2
# from collections import deque
# from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product, permutations
# from heapq import heapify, heappop, heappush
# import numpy as np # cumsum
# from bisect import bisect_left, bisect_right
def solve():
N = II()
A = LI()
memo = {}
ans = 0
for i, a in enumerate(A):
i = i + 1
# print(i, a - i, i - a)
ans = ans + memo.get(i - a, 0)
memo[a + i] = memo.get(a + i, 0) + 1
print(ans)
if __name__ == '__main__':
solve()
| p02691 |
n = int(eval(input()))
a_list = list(map(int, input().split()))
count = 0
Jlist = []
for j in range(2, n+1):
if j > a_list[j-1]:
for i in range(1, j):
if j -a_list[j-1] == a_list[i-1] + i:
count += 1
print(count) | n = int(eval(input()))
a = list(map(int, input().split()))
count = 0
d={}
for i in range(n):
if i - a[i] in d:
count+=d[i - a[i]]
if i + a[i] in d:
d[i+a[i]] += 1
else:
d[i+a[i]] = 1
print(count) | p02691 |
N=int(eval(input()))
A=list(map(int,input().split()))
ans=0
for i in range(N):
if A[i]>N-2: continue
for j in range(i+A[i]+1,N):
s=A[i]+A[j]
if s==j-i:
ans+=1
print(ans) | N=int(eval(input()))
A=list(map(int,input().split()))
Aii=[0]*(N)
Ajj=[0]*(N)
for i in range(N):
x=A[i]+i+1
y=i+1-A[i]
if 1<x<N: Aii[x]+=1
if 1<y<N: Ajj[y]+=1
ans=0
for i in range(N):
ans+=Aii[i]*Ajj[i]
print(ans) | p02691 |
n = int(eval(input()))
a = list(map(int, input().split()))
c = [0]*n
d = [0]*n
for i, j in enumerate(a):
c[i] = j-i
for i, j in enumerate(a):
d[i] = -j-i
ans = 0
for i in range(n):
for j in range(n):
if c[i] == d[j]:
ans +=1
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
c = [0]*n
d = [0]*n
for i, j in enumerate(a):
c[i] = i + j
for i, j in enumerate(a):
d[i] = i - j
x = {}
for i, j in enumerate(c):
if j not in x:
x[j]=[i]
else:
x[j].append(i)
ans = 0
for i in d:
if i not in x:
continue
else:
ans += len(x[i])
print(ans) | p02691 |
import math
from collections import Counter
n=int(eval(input()))
l=[int(x) for x in input().split()]
f1=[]
f2=[]
for i in range(1,len(l)+1):
f1.append(i-l[i-1])
f2.append(l[i-1]+i)
c=0
for i in range(len(l)):
c+=f1.count(f2[i])
print(c)
| n=int(eval(input()))
l=[int(x) for x in input().split()]
f1={}
f2={}
for i in range(1,len(l)+1):
if i-l[i-1] in f1:
f1[i-l[i-1]]+=1
else:
f1[i-l[i-1]]=1
if l[i-1]+i in f2:
f2[l[i-1]+i]+=1
else:
f2[l[i-1]+i]=1
c=0
#print(f1)
#print(f2)
for u,v in list(f1.items()):
c+=f2.get(u,0)*v
print(c)
| p02691 |
n = int(eval(input()))
t = list(map(int, input().split()))
r = []
ans = 0
for i in range(len(t)):
r.append(i+1 + t[i])
for i in range(len(t)):
if((i+1 - t[i]) >= 1):
ans += r.count(i+1-t[i])
print(ans) | n = int(eval(input()))
t = list(map(int, input().split()))
r = {}
ans = 0
for i in range(len(t)):
try:
r[i+1 + t[i]] += 1
except KeyError:
r[i+1 + t[i]] = 1
for i in range(len(t)):
if((i+1 - t[i]) >= 1):
try:
ans += r[i+1-t[i]]
except KeyError:
continue
print(ans)
| p02691 |
import math
n=int(eval(input()))
A=list(map(int, input().split()))
L=['null']*n
R=['null']*n
c=0
for i,a in enumerate(A):
L[i]=i+a
R[i]=i-a
c+=L.count(R[i])
print(c)
| n=int(eval(input()))
A=list(map(int, input().split()))
d={}
c=0
for i,a in enumerate(A):
if i+a not in d:
d[i+a]=1
else:
d[i+a]+=1
if i-a in d:
c+=d[i-a]
print(c) | p02691 |
n = int(eval(input()))
height = [int(x) for x in input().split()]
cnt =0
for i_index, i in enumerate(height[:-1]):
if i+i_index >= n:
continue
for j_index, j in enumerate(height[i_index+i+1:]):
if j+i == j_index+i+1:
cnt += 1
# print(i,j,j_index)
print(cnt) | # n = int(input())
# height = [int(x) for x in input().split()]
# cnt =0
# for i_index, i in enumerate(height[:-1]):
# if i+i_index >= n:
# continue
# for j_index, j in enumerate(height[i_index+i+1:]):
# if j+i == j_index+i+1:
# cnt += 1
# # print(i,j,j_index)
# print(cnt)
def count(dic,x):
if x in dic:
dic[x]+=1
else:
dic[x]=1
N=int(eval(input()))
A=list(map(int,input().split()))
dic1={}
dic2={}
s=0
for i in range(N):
count(dic1,i-A[i])
count(dic2,i+A[i])
for x in dic1:
if x in dic2:
s+=dic1[x]*dic2[x]
print(s) | p02691 |
from itertools import combinations
N = int(eval(input()))
A = list(map(int, input().split()))
idx = list(range(0, N))
idx_comb = list(combinations(idx, 2))
count = 0
for i, j in idx_comb:
if abs(i-j) == (A[i] + A[j]):
count += 1
print(count) | from itertools import combinations
N = int(eval(input()))
A = tuple(map(int, input().split()))
idx = tuple(range(0, N))
idx_comb = tuple(combinations(idx, 2))
count = 0
for i, j in idx_comb:
if abs(i-j) == (A[i] + A[j]):
count += 1
print(count) | p02691 |
# -*- coding: utf-8 -*-
# 整数の入力
n = int(eval(input()))
h_list = input().split()
h_list = [int(h) for h in h_list]
count = 0
for i in range(n):
a_height = h_list[i]
n_aa = i + a_height + 1000000000 + 1
if n_aa > n:
n_aa = n
for k in range(i + 1 + a_height, n_aa):
b_height = h_list[k]
if k - i == a_height + b_height:
count += 1
print(count)
| # -*- coding: utf-8 -*-
# 整数の入力
n = int(eval(input()))
h_list = input().split()
h_list = [int(h) for h in h_list]
count = 0
result_dict = {}
for i in range(n):
key = (i+1) + h_list[i]
value = result_dict.get(key, 0)
result_dict[key] = value + 1
for j in range(n):
key = (j+1) - h_list[j]
count += result_dict.get(key, 0)
print(count)
| p02691 |
N = int(eval(input()))
A = list(map(int, input().split()))
import collections
count = 0
count_dict = collections.defaultdict(int)
for idx, a in enumerate(A):
if idx+a+1 in count_dict:
count += count_dict[idx+a+1]
continue
for i in range(idx+a+1, N):
if a + A[i] == i - idx:
count += 1
count_dict[idx+a+1] += 1
print(count) | N = int(eval(input()))
A = list(map(int, input().split()))
import collections
count = 0
count_dict = collections.defaultdict(int)
for idx, a in enumerate(A):
count_dict[idx-a] += 1
for idx, a in enumerate(A):
if idx+a in count_dict:
count += count_dict[idx+a]
continue
# for i in range(idx+a+1, N):
# if a + A[i] == i - idx:
# count += 1
# count_dict[idx+a+1] += 1
# print(count_dict)
print(count) | p02691 |
#!/usr/bin/env python3
import sys
import pprint
sys.setrecursionlimit(10 ** 6)
class Logger:
def __init__(self, debug):
self.debug = debug
def print(self, *args):
if self.debug:
pprint.pprint(args)
def main():
log = Logger(0)
n = int(sys.stdin.readline())
a = list(map(int, sys.stdin.readline().split()))
# a_ext = {}
b_sum_ext = {}
b_ext = []
# ai + aj = (j+1) - (i+1)
# ai + i + 1 = -aj + j + 1
for i, ai in enumerate(a):
# a_ext[a[i] + i + 1] = 1
log.print(a[i]+i+1, -a[i]+i+1)
b_sum_ext[-a[i]+i+1] = b_sum_ext.get(-a[i]+i+1, 0)+1
# log.print(b_sum_ext)
for i in range(n):
b_sum_ext[-a[i]+i+1] = b_sum_ext.get(-a[i]+i+1, 0)-1
b_ext.append(dict(b_sum_ext))
# log.print(b_ext)
cnt = 0
log.print(cnt)
cnt = 0
for i, ai in enumerate(a):
if b_ext[i].get(a[i] + i + 1, 0) != 0:
log.print(i+1, a[i] + i + 1)
cnt += b_ext[i].get(a[i] + i + 1, 0)
print(cnt)
main()
| #!/usr/bin/env python3
import sys
import pprint
sys.setrecursionlimit(10 ** 6)
class Logger:
def __init__(self, debug):
self.debug = debug
def print(self, *args):
if self.debug:
pprint.pprint(args)
def main():
log = Logger(0)
n = int(sys.stdin.readline())
a = list(map(int, sys.stdin.readline().split()))
# a_ext = {}
b_sum_ext = {}
b_ext = []
# ai + aj = (j+1) - (i+1)
# ai + i + 1 = -aj + j + 1
for i, ai in enumerate(a):
# a_ext[a[i] + i + 1] = 1
log.print(a[i]+i+1, -a[i]+i+1)
b_sum_ext[-a[i]+i+1] = b_sum_ext.get(-a[i]+i+1, 0)+1
cnt = 0
log.print(cnt)
cnt = 0
for i, ai in enumerate(a):
b_sum_ext[-a[i]+i+1] = b_sum_ext.get(-a[i]+i+1, 0)-1
if b_sum_ext.get(a[i] + i + 1, 0) != 0:
log.print(i+1, a[i] + i + 1)
cnt += b_sum_ext.get(a[i] + i + 1, 0)
print(cnt)
main()
| p02691 |
n = int(eval(input()))
a = list(map(int,input().split()))
add1 = []
sub1 = []
for i in range(n):
add1.append(a[i] + i)
sub1.append(i - a[i])
dict1 = {}
dict2 = {}
for i in add1:
if i in dict1:
dict1[i] += 1
else:
dict1[i] = 1
for i in sub1:
if i in dict2:
dict2[i] += 1
else:
dict2[i] = 1
sorted1 = sorted(list(dict1.items()), key = lambda x: x[0])
sorted2 = sorted(list(dict2.items()), key = lambda x: x[0])
cnt1 = 0
cnt2 = 0
ans = 0
while cnt1 < len(sorted1) and cnt2 < len(sorted2):
if sorted1[cnt1][0] == sorted2[cnt2][0]:
ans += sorted1[cnt1][1] * sorted2[cnt2][1]
cnt1 += 1
cnt2 += 1
elif sorted1[cnt1][0] > sorted2[cnt2][0]:
cnt2 += 1
else:
cnt1 += 1
print(ans)
| n = int(eval(input()))
a = list(map(int,input().split()))
add1 = []
sub1 = []
for i in range(n):
add1.append(a[i] + i)
sub1.append(i - a[i])
dict1 = {}
dict2 = {}
for i in add1:
if i in dict1:
dict1[i] += 1
else:
dict1[i] = 1
for i in sub1:
if i in dict2:
dict2[i] += 1
else:
dict2[i] = 1
ans = 0
for k,v in list(dict1.items()):
if k in dict2:
ans += v * dict2[k]
print(ans)
| p02691 |
#import numpy as np
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial#, gcd
from bisect import bisect_left #bisect_left(list, value)
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
def pri(x): print(('\n'.join(map(str, x))))
N = int(eval(input()))
A = list(map(int, input().split()))
cnt = 0
for i, a in enu(A):
if i+a+1<=N-1:
for j, b in enu(A[i+a+1:]):
if abs(j+a+1) == a + b:
cnt += 1
# print(i, i+a+1+j)
print(cnt) | #import numpy as np
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial#, gcd
from bisect import bisect_left #bisect_left(list, value)
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
def pri(x): print(('\n'.join(map(str, x))))
N = int(eval(input()))
A = list(map(int, input().split()))
cnt = 0
d = defaultdict(int)
for i, a in enu(A):
l = (i+1) + a
r = (i+1) - a
cnt += d[r]
d[l] += 1
print(cnt) | p02691 |
from itertools import permutations, combinations,combinations_with_replacement,product
N=int(eval(input()))
a=list(map(int,input().split()))
b=[i for i in range(N)]
A=list(combinations(a,2))
B=list(combinations(b,2))
C=[]
D=[]
for i in A:
tmp=i[0]+i[1]
C.append(tmp)
for i in B:
tmp=abs(i[0]-i[1])
D.append(tmp)
count=0
for i in range(len(C)):
if C[i]==D[i]:
count+=1
else:
pass
print(count)
| from itertools import permutations, combinations,combinations_with_replacement,product
N=int(eval(input()))
a=list(map(int,input().split()))
b=[i for i in range(N)]
count=0
C=[i[0]+i[1] for i in combinations(a,2)]
D=[abs(i[0]-i[1]) for i in combinations(b,2)]
for i in range(len(C)):
if C[i]==D[i]:
count+=1
print(count) | p02691 |
from itertools import permutations, combinations,combinations_with_replacement,product
N=int(eval(input()))
a=list(map(int,input().split()))
b=[i for i in range(N)]
count=0
C=[i[0]+i[1] for i in combinations(a,2)]
D=[abs(i[0]-i[1]) for i in combinations(b,2)]
for i in range(len(C)):
if C[i]==D[i]:
count+=1
print(count) | N=int(eval(input()))
A=list(map(int,input().split()))
result=[]
res=[]
for i in range(N):
tmp=i+A[i]
tmp2=i-A[i]
result.append(tmp)
res.append(tmp2)
count=0
for i in result:
for j in res:
if i==j:
count+=1
else:
pass
print(count)
| p02691 |
n=int(eval(input()))
a=list(map(int,input().split()))
b=[0]*n
for i , j in enumerate(a):
b[i]=j+i+1
c=[0]*n
q=[]
ans=0
for i , j in enumerate(a):
c[i]=1+i-j
from collections import Counter
def combination(n, r):
a = 1
b = 1
for i in range(r):
a *= (n - i)
b *= (i + 1)
return a // b
cc=Counter(c)
bb=Counter(b)
for i,j in list(bb.items()):
for k,l in list(cc.items()):
if i==k:
ans+=j*l
print(ans) | n=int(eval(input()))
a=list(map(int,input().split()))
b=[0]*n
for i , j in enumerate(a):
b[i]=j+i+1
c=[0]*n
q=[]
ans=0
for i , j in enumerate(a):
c[i]=1+i-j
from collections import Counter
def combination(n, r):
a = 1
b = 1
for i in range(r):
a *= (n - i)
b *= (i + 1)
return a // b
cc=Counter(c)
bb=Counter(b)
f=bb&cc
for i in list(f.keys()):
ans+=bb[i]*cc[i]
print(ans) | p02691 |
n = int(eval(input()))
l = list(map(int, input().split()))
d = [0] * n
cnt = 0
for i in range(len(l)):
if i + l[i] + 1 < n:
d[i + l[i]] += 1
if i - l[i] + 1 > 0:
cnt += d[i - l[i]]
print(cnt)
| N = int(eval(input()))
A = list(map(int, input().split()))
lst = [0] * N
ans = 0
for i in range(N):
if i + 1 + A[i] < N: #iは0から始まるので +1 してあげる
lst[i + A[i]] += 1
if i + 1 - A[i] >= 1:
ans += lst[i - A[i]]
print(ans) | p02691 |
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate, product, combinations_with_replacement
import sys
import bisect
import string
import math
import time
def I(): return int(input())
def S(): return input()
def MI(): return map(int, input().split())
def MS(): return map(str, input().split())
def LI(): return [int(i) for i in input().split()]
def LI_(): return [int(i)-1 for i in input().split()]
def StoI(): return [ord(i)-97 for i in input()]
def ItoS(nn): return chr(nn+97)
def input(): return sys.stdin.readline().rstrip()
def debug(table, *args):
ret = []
for name, val in table.items():
if val in args:
ret.append('{}: {}'.format(name, val))
print(' | '.join(ret), file=sys.stderr)
yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
show_flg = False
# show_flg = True
def main():
N = I()
A = LI()
ans = 0
for i in range(N):
for j in range(i+A[i]+1, N):
if A[i] + A[j] == abs(i - j):
ans += 1
print(ans)
if __name__ == '__main__':
main()
| from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate, product, combinations_with_replacement
import sys
import bisect
import string
import math
import time
def I(): return int(input())
def S(): return input()
def MI(): return map(int, input().split())
def MS(): return map(str, input().split())
def LI(): return [int(i) for i in input().split()]
def LI_(): return [int(i)-1 for i in input().split()]
def StoI(): return [ord(i)-97 for i in input()]
def ItoS(nn): return chr(nn+97)
def input(): return sys.stdin.readline().rstrip()
def debug(table, *args):
ret = []
for name, val in table.items():
if val in args:
ret.append('{}: {}'.format(name, val))
print(' | '.join(ret), file=sys.stderr)
yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
show_flg = False
# show_flg = True
def main():
N = I()
H = LI()
ans = 0
cnt_plus_height_minus_idx = defaultdict(int)
cnt_minus_height_minus_idx = defaultdict(int)
cnt_plus_height_plus_idx = defaultdict(int)
cnt_minus_height_plus_idx = defaultdict(int)
for idx in range(N):
cnt_plus_height_minus_idx[H[idx] - idx] += 1
cnt_minus_height_minus_idx[- H[idx] - idx] += 1
cnt_plus_height_plus_idx[H[idx] + idx] += 1
cnt_minus_height_plus_idx[- H[idx] + idx] += 1
ans = 0
for k, v in cnt_plus_height_minus_idx.items():
if k in cnt_minus_height_minus_idx:
ans += v * cnt_minus_height_minus_idx[k]
# print(v)
for k, v in cnt_plus_height_plus_idx.items():
if k in cnt_minus_height_plus_idx:
ans += v * cnt_minus_height_plus_idx[k]
print(ans // 2)
if __name__ == '__main__':
main()
| p02691 |
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate, product, combinations_with_replacement
import sys
import bisect
import string
import math
import time
def I(): return int(input())
def S(): return input()
def MI(): return map(int, input().split())
def MS(): return map(str, input().split())
def LI(): return [int(i) for i in input().split()]
def LI_(): return [int(i)-1 for i in input().split()]
def StoI(): return [ord(i)-97 for i in input()]
def ItoS(nn): return chr(nn+97)
def input(): return sys.stdin.readline().rstrip()
def debug(table, *args):
ret = []
for name, val in table.items():
if val in args:
ret.append('{}: {}'.format(name, val))
print(' | '.join(ret), file=sys.stderr)
yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
show_flg = False
# show_flg = True
def main():
N = I()
H = LI()
ans = 0
cnt_plus_height_minus_idx = defaultdict(int)
cnt_minus_height_minus_idx = defaultdict(int)
cnt_plus_height_plus_idx = defaultdict(int)
cnt_minus_height_plus_idx = defaultdict(int)
for idx in range(N):
cnt_plus_height_minus_idx[H[idx] - idx] += 1
cnt_minus_height_minus_idx[- H[idx] - idx] += 1
cnt_plus_height_plus_idx[H[idx] + idx] += 1
cnt_minus_height_plus_idx[- H[idx] + idx] += 1
ans = 0
for k, v in cnt_plus_height_minus_idx.items():
if k in cnt_minus_height_minus_idx:
ans += v * cnt_minus_height_minus_idx[k]
# print(v)
for k, v in cnt_plus_height_plus_idx.items():
if k in cnt_minus_height_plus_idx:
ans += v * cnt_minus_height_plus_idx[k]
print(ans // 2)
if __name__ == '__main__':
main()
| from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate, product, combinations_with_replacement
import sys
import bisect
import string
import math
import time
def I(): return int(input())
def S(): return input()
def MI(): return map(int, input().split())
def MS(): return map(str, input().split())
def LI(): return [int(i) for i in input().split()]
def LI_(): return [int(i)-1 for i in input().split()]
def StoI(): return [ord(i)-97 for i in input()]
def ItoS(nn): return chr(nn+97)
def input(): return sys.stdin.readline().rstrip()
def debug(table, *args):
ret = []
for name, val in table.items():
if val in args:
ret.append('{}: {}'.format(name, val))
print(' | '.join(ret), file=sys.stderr)
yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
show_flg = False
# show_flg = True
def main():
N = I()
H = LI()
ans = 0
cnt_plus_height_plus_idx = defaultdict(int)
cnt_minus_height_plus_idx = defaultdict(int)
for idx in range(N):
cnt_plus_height_plus_idx[H[idx] + idx] += 1
cnt_minus_height_plus_idx[- H[idx] + idx] += 1
ans = 0
for k, v in cnt_plus_height_plus_idx.items():
if k in cnt_minus_height_plus_idx:
ans += v * cnt_minus_height_plus_idx[k]
print(ans)
if __name__ == '__main__':
main()
| p02691 |
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
from bisect import bisect_left,bisect_right
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n = inp()
a = inpl()
sa = defaultdict(int)
for i,x in enumerate(a):
sa[(i+1)-x] += 1
res = 0
for i,x in enumerate(a):
res += sa[i+1+x]
print(res) | from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n = inp()
a = inpl()
d = defaultdict(int)
for i,x in enumerate(a):
d[i+1-x] += 1
res = 0
for i,x in enumerate(a):
res += d[i+1+x]
print(res) | p02691 |
n = int(eval(input()))
N = [i for i in range(n)]
A = list(map(int,input().split()))
L = [N[i]+A[i] for i in range(n)]
R = [N[j]-A[j] for j in range(n)]
ans = 0
for i in range(n):
for j in range(i+1,n):
if L[i] == R[j]:
ans += 1
print(ans)
| N = int(eval(input()))
A = list(map(int, input().split()))
X = dict()
ans = 0
for i in range(N):
L = i + A[i]
if L not in X:
X[L] = 1
else:
X[L] += 1
for i in range(N):
R = i - A[i]
if R in X:
ans += X[R]
print(ans)
| p02691 |
n = int(eval(input()))
a = list(map(int, input().split()))
cnt = 0
dist = [a[0]-1] + a[1:]
for i, ai in enumerate(a[1:]):
cnt += dist[:i+1].count(-ai)
dist[:i+2] = list([x-1 for x in dist[:i+2]])
print(cnt)
| n = int(eval(input()))
a = list(map(int, input().split()))
# i < j
# j - i = Aj + Ai
# j - Aj = i + Ai
ans = 0
adds = dict()
for j in range(n):
sub = j - a[j]
if sub in list(adds.keys()):
ans += adds[sub]
add = j + a[j]
if add in list(adds.keys()):
adds[add] += 1
else:
adds[add] = 1
print(ans)
| p02691 |
import itertools
N = int(eval(input()))
A = list(map(int, input().split()))
ans = 0
for i in range(N-1):
wa = i + A[i]
for j in range(i+1,N):
sa = j - A[j]
if wa == sa:
ans += 1
print(ans) | N = int(eval(input()))
A = list(map(int, input().split()))
ans = 0
D = {}
for j in range(N):
if j-A[j] in D:
ans += D[j-A[j]]
if j+A[j] in D:
D[j+A[j]] += 1
else:
D[j+A[j]] = 1
print(ans) | p02691 |
N = int(eval(input()))
As = list(map(int, input().split()))
i_plus_Ai = [0 for i in range(N)]
dict = {}
for i in range(N):
i_plus_Ai[i] = i + As[i]
tmp = i - As[i]
if tmp not in dict:
dict[tmp] = [i]
else:
dict[tmp].append(i)
dict[tmp].sort()
count = 0
for i in range(N):
if i_plus_Ai[i] in dict:
kouho = dict[i_plus_Ai[i]]
for j in range(len(kouho)):
if kouho[j] > i:
count += len(kouho) - j
break
print(count)
| N = int(eval(input()))
As = list(map(int, input().split()))
i_plus_Ai = [0 for i in range(N)]
dict = {}
for i in range(N):
i_plus_Ai[i] = i + As[i]
tmp = i - As[i]
if tmp not in dict:
dict[tmp] = [i]
else:
dict[tmp].append(i)
count = 0
for i in range(N):
if i_plus_Ai[i] in dict:
kouho = dict[i_plus_Ai[i]]
for j in range(len(kouho)):
if kouho[j] > i:
count += len(kouho) - j
break
print(count)
| p02691 |
from collections import Counter
import bisect
def make_divisors(n):
divisors = []
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n // i)
# divisors.sort()
return divisors
if __name__ == '__main__':
N = int(eval(input()))
A = list(map(int, input().split()))
negA = []
idx_negA = []
for i, a in enumerate(A):
negA.append(i - a)
idx_negA.append(i)
negA = sorted(negA)
ans = 0
for i in range(N):
searched_idx = bisect.bisect_left(negA, i + A[i])
if searched_idx == N:
continue
else:
if idx_negA[searched_idx] > i:
while negA[searched_idx] == i + A[i] and searched_idx <= N - 1:
ans += 1
if searched_idx == N - 1:
break
searched_idx += 1
print(ans)
| from collections import Counter
import bisect
def make_divisors(n):
divisors = []
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n // i)
# divisors.sort()
return divisors
if __name__ == '__main__':
N = int(eval(input()))
A = list(map(int, input().split()))
negA = []
idx_negA = []
for i, a in enumerate(A):
negA.append(i - a)
idx_negA.append(i)
cnt_negA = Counter(negA)
negA_keys = sorted(cnt_negA.keys())
ans = 0
for i in range(N):
if i + A[i] in cnt_negA:
ans += cnt_negA[i + A[i]]
print(ans)
| p02691 |
from collections import Counter
import bisect
def make_divisors(n):
divisors = []
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n // i)
# divisors.sort()
return divisors
if __name__ == '__main__':
N = int(eval(input()))
A = list(map(int, input().split()))
negA = []
idx_negA = []
for i, a in enumerate(A):
negA.append(i - a)
idx_negA.append(i)
cnt_negA = Counter(negA)
negA_keys = sorted(cnt_negA.keys())
ans = 0
for i in range(N):
if i + A[i] in cnt_negA:
ans += cnt_negA[i + A[i]]
print(ans)
| from collections import Counter
import bisect
def make_divisors(n):
divisors = []
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n // i)
# divisors.sort()
return divisors
if __name__ == '__main__':
N = int(eval(input()))
A = list(map(int, input().split()))
negA = []
for i, a in enumerate(A):
negA.append(i - a)
cnt_negA = Counter(negA)
negA_keys = sorted(cnt_negA.keys())
ans = 0
for i in range(N):
if i + A[i] in cnt_negA:
ans += cnt_negA[i + A[i]]
print(ans)
| p02691 |
from collections import defaultdict
n = int(eval(input()))
a = [int(i) for i in input().split()]
d = defaultdict(int)
for i in range(n): d[i+1+a[i]] += 1
ans = 0
for j in range(n): ans += d[j+1-a[j]]
print(ans) | from collections import defaultdict
n = int(eval(input()))
a = [int(i) for i in input().split()]
ans = 0
d = defaultdict(int)
for i in range(n):
ans += d[i+1-a[i]]
d[i+1+a[i]] += 1
print(ans) | p02691 |
n = int(eval(input()))
import itertools
a_list = list(map(int,input().split()))
cand_list = list(itertools.combinations([i for i in range(n)],2))
count = 0
for cand in cand_list:
if abs(cand[1] - cand[0]) == a_list[cand[0]] + a_list[cand[1]]:
count += 1
print(count)
| n = int(eval(input()))
a_list = list(map(int,input().split()))
c_list = a_list.copy()
for i in range(n):
a_list[i] -= i + 1
count = 0
for i in range(n-1):
target = a_list[i+1:]
count += target.count(-(c_list[i] + i + 1))
print(count)
| p02691 |
N=int(eval(input()))
A=list(map(int,input().split()))
ans=0
AA=[]
M=0
for i in range(N):
if A[i]<N:
M=max(A[i],M)
m=min(A)
cnt=0
for i in range(N):
LM=min(i+M+A[i]+1,N)
lm=max(i+m+A[i],i+1)
for j in range(lm,LM):
cnt+=1
if j-i==abs(A[i]+A[j]):
ans+=1
print(ans) | N=int(eval(input()))
A=list(map(int,input().split()))
L={}
R={}
ans=0
for i in range(N):
if i+A[i] in L:
L[i+A[i]]+=1
else:
L[i+A[i]]=1
if A[i]<=i:
if i-A[i] in R:
R[i-A[i]]+=1
else:
R[i-A[i]]=1
for r in R:
if r in L:
ans+=L[r]*R[r]
print(ans) | p02691 |
#!/usr/bin/env python3
from pprint import pprint
from collections import deque, defaultdict
import sys
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.buffer.readline
INF = float("inf")
N = int(eval(input()))
A = list(map(int, input().split()))
min_diff = 1
max_diff = N - 1
count = 0
for diff in range(min_diff, max_diff + 1):
pairs = []
i = 1
while True:
j = i + diff
if j <= N:
pairs.append([i, j])
else:
break
i += 1
# pprint(pairs)
for i, j in pairs:
if abs(i - j) == A[i-1] + A[j-1]:
count += 1
print(count)
| #!/usr/bin/env python3
from pprint import pprint
from collections import deque, defaultdict
import math
import itertools
import sys
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.buffer.readline
INF = float("inf")
N = int(eval(input()))
A = list(map(int, input().split()))
min_diff = 1
max_diff = N - 1
dl = defaultdict(list)
dr = defaultdict(list)
for i in range(1, N + 1):
key = i + A[i-1]
dl[key].append(i)
key = i - A[i-1]
if key > 0:
dr[key].append(i)
# pprint(dict(dl))
# pprint(dict(dr))
count = 0
for diff in range(min_diff, max_diff + 1):
count += len(dl[diff]) * len(dr[diff])
print(count)
| p02691 |
import sys,math,collections,itertools,bisect
input = sys.stdin.readline
N=int(eval(input()))
A=list(map(int,input().split()))
B = []
for i,a in enumerate(A):
if a <= N-1:
B.append([a,i])
if len(B)==0:
print((0))
exit()
B.sort()
cnt = 0
for i in range(len(B)):
for j in range(i+1,len(B)):
if B[i][0]+B[j][0]==abs(B[i][1]-B[j][1]):
cnt +=1
if B[i][0]+B[j][0]>=N:
break
print(cnt)
| import sys,collections
input = sys.stdin.readline
N=int(eval(input()))
A=list(map(int,input().split()))
B = []
C = []
for i,a in enumerate(A):
B.append(i+a)
C.append(i-a)
cnt = 0
Bc = collections.Counter(B)
Cc = collections.Counter(C)
for key,val in list(Bc.items()):
cnt += val*Cc[key]
print(cnt)
| p02691 |
n=int(eval(input()))
a_=list(map(int,input().split()))
from collections import defaultdict
a=[[i,ai] for i,ai in enumerate(a_)]
sa=defaultdict(lambda:0)
# sa[(i,j)]:i番目の人までで自分の番号-身長がjの人
d=defaultdict(lambda:0)
# 自分の番号-身長の累計
mt=0
for i,ai in a:
d[i-ai]+=1
for k,v in list(d.items()):
sa[(i+1,k)]=v
ans=0
for i,ai in a:
c=sa[(n,i+ai)]-sa[(i+1,i+ai)]
ans+=c
print(ans)
| def main(n,a_):
from collections import defaultdict
lr=[[i+ai,i-ai] for i,ai in enumerate(a_)]
rs=defaultdict(lambda:0)
ls=defaultdict(lambda:0)
ans=0
for l,r in lr:
rs[r]+=1
ls[l]+=1
for k in list(rs.keys()):
ans+=rs[k]*ls[k]
print(ans)
if __name__=='__main__':
n=int(eval(input()))
a_=list(map(int,input().split()))
#n=200000
#a_=[3 for _ in range(n)]
main(n,a_)
| p02691 |
# N人の参加者, 参加者iの身長はAi, 背番号の差の絶対値が身長の和に等しい組
from collections import defaultdict
N = int(eval(input()))
A = list(map(int, input().split()))
memo = defaultdict(int)
ans = 0
for i, x in enumerate(A, 1):
ans += memo[i-A[i-1]]
memo[i+A[i-1]] += 1
print(ans)
| from collections import defaultdict
N = int(eval(input()))
A = list(map(int, input().split()))
count = defaultdict(int)
ans = 0
for i in range(N):
ans += count[i-A[i]]
count[A[i]+i] += 1
print(ans)
| p02691 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
INF = 10**10
MOD = 10**9 + 7
N = int(eval(input()))
A = list(map(int,input().split()))
minus = []
plus = []
for i in range(len(A)):
minus.append(A[i]-(i+1))
plus.append(-A[i]-(i+1))
d = {}
for m in minus:
d[m] = d.get(m,0) + 1
ans = 0
for p in plus:
ans += d.get(p,0)
print (ans) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
INF = 10**10
MOD = 10**9 + 7
N = int(eval(input()))
A = list(map(int,input().split()))
minus = []
plus = []
for i in range(len(A)):
minus.append(A[i]-(i+1))
plus.append(A[i]+(i+1))
d = {}
for m in minus:
d[m] = d.get(m,0) + 1
ans = 0
for p in plus:
ans += d.get(-p,0)
print (ans) | p02691 |
def resolve():
N = int(eval(input()))
A = list(map(int, input().split()))
A.insert(0, 0)
ans = 0
for i in range(1, N+1):
for j in range(A[i]+i+1, N+1):
if j - i == A[j] + A[i]:
ans += 1
print(ans)
if __name__ == "__main__":
resolve() | def resolve():
N = int(eval(input()))
A = list(map(int, input().split()))
mp = dict()
ans = 0
for i in range(N):
x = i - A[i]
ans += mp.get(x, 0)
y = A[i] + i
mp[y] = mp.get(y, 0) + 1
print(ans)
if __name__ == "__main__":
resolve() | p02691 |
from collections import defaultdict
d_i = defaultdict(list)
d_j = defaultdict(list)
N = int(eval(input()))
A = [int(a) for a in input().split()]
for i in range(N):
d_i[i-A[i]].append(i)
d_j[i+A[i]].append(i)
cnt = 0
for key in list(d_j.keys()):
arr_i = d_i[key]
arr_j = d_j[key]
for i in arr_i:
for j in arr_j:
if i > j:
cnt += 1
print(cnt)
| from collections import defaultdict
d_i = defaultdict(list)
d_j = defaultdict(list)
N = int(eval(input()))
A = [int(a) for a in input().split()]
for i in range(N):
d_i[i-A[i]].append(i)
d_j[i+A[i]].append(i)
cnt = 0
for key in list(d_j.keys()):
arr_i = d_i[key]
arr_j = d_j[key]
cnt += len(arr_j) * len(arr_i)
print(cnt)
| p02691 |
from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
R = [None] * (N + 1)
R[N] = Counter()
L = [None] * (N + 1)
L[0] = Counter()
# n < i
# for i in range(N):
# c = Counter()
# c[A[i] + i] = 1
# L[i + 1] = L[i] | c
# n >= i
c = Counter()
for n in range(N - 1, -1, -1):
R[n] = R[n + 1] | c
R[n][(n + 1) - A[n]] += 1
ans = 0
for i, Ai in enumerate(A):
# n < a
# c0 = i - a
# l = L[i][c0]
# n >= a
c1 = Ai + (i + 1)
r = R[i + 1][c1]
ans += r
print(ans)
| from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
# R = [None] * (N + 1)
# R[N] = Counter()
R = Counter()
cnt = 0
for n in range(N - 1, 0, -1):
R[(n + 1) - A[n]] += 1
c = A[n - 1] + ((n - 1) + 1)
cnt += R[c]
# ans = 0
# for i, Ai in enumerate(A):
# # n < a
# # c0 = i - a
# # l = L[i][c0]
# # n >= a
# c1 = Ai + (i + 1)
# r = R[i + 1][c1]
# ans += r
print(cnt)
| p02691 |
from collections import Counter
N = int(eval(input()))
A = [int(a) for a in input().split()]
A1 = [0]*N
A2 = [0]*N
for i in range(N):
A1[i] = A[i] + i
A2[i] = i - A[i]
cnt = 0
for i in range(N):
c = Counter(A2[i+1:])
cnt += c[A1[i]]
print(cnt) | from collections import Counter
# import sys
# input = sys.stdin.readline
N = int(eval(input()))
A = [int(a) for a in input().split()]
A1 = [0]*N
A2 = [0]*N
for i in range(N):
A1[i] = A[i] + i
A2[i] = i - A[i]
c = Counter(A2)
cnt = 0
for i in range(N):
cnt += c[A1[i]]
print(cnt) | p02691 |
from collections import*
n,*a=list(map(int,open(0).read().split()))
s=0
d=defaultdict(int)
for i,a in enumerate(a):
s+=d[i-a]
d[i+a]+=1
print(s) | n,*a=list(map(int,open(0).read().split()))
i=s=0
d=[0]*n
for a in a:
if i>=a:s+=d[i-a]
if i+a<n:d[i+a]+=1
i+=1
print(s) | p02691 |
import sys
l = sys.stdin.readline().strip()
N = int(l)
l = sys.stdin.readline().strip()
a = list(map(int, l.split()))
count = 0
for i in range(N):
for j in range(i+1, N):
if j - i == a[j] + a[i]:
count += 1
print(count) | import sys
l = sys.stdin.readline().strip()
N = int(l)
l = sys.stdin.readline().strip()
a = list(map(int, l.split()))
count = 0
# j - i = Ai + Aj -> Ai +i = j - Aj
# Li = Ai + i
# Ri = j - Aj
L = []
R = []
for i, one in enumerate(a):
L.append(one + i+1)
if (i+1 - one) > 0:
R.append(i+1-one)
L = sorted(L)
R_count = {}
for one in R:
if one in R_count:
R_count[one] += 1
else:
R_count[one] = 1
count = 0
for one in L:
if one in R_count:
count += R_count[one]
print(count) | p02691 |
from collections import Counter
def main():
n = int(eval(input()))
a = list(map(int, input().split()))
bigger = [None]*n
smaller = [None]*n
for i, ai in enumerate(a):
bigger[i] = i - ai
smaller[i] = i + ai
b = sorted(Counter(bigger).items())
s = sorted(Counter(smaller).items())
nb = len(b)
ns = len(s)
b.append((10**10, 0))
s.append((10**11, 0))
i, j = 0, 0
ans = 0
while i < nb or j < ns:
bi, nbi = b[i]
si, nsi = s[j]
if bi == si:
ans += nbi*nsi
i += 1
j += 1
elif bi > si:
j += 1
else:
i += 1
print(ans)
if __name__ == "__main__":
main() | from collections import defaultdict
def main():
n = int(eval(input()))
a = list(map(int, input().split()))
d = defaultdict(lambda : 0)
ans = 0
for i, ai in enumerate(a):
sa = i - ai
ans += d[sa]
wa = i + ai
d[wa] += 1
print(ans)
if __name__ == "__main__":
main() | p02691 |
from collections import defaultdict
n = int(eval(input()))
a = list(map(int, input().split()))
d = defaultdict(int)
for i in range(n):
d[i+a[i]] += 1
ans = 0
for i in range(n):
ans += d[i-a[i]]
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
d = [0]*n
for i in range(n):
if i+a[i] < n: d[i+a[i]] += 1
ans = 0
for i in range(n):
if i-a[i] >= 0: ans += d[i-a[i]]
print(ans) | p02691 |
def main():
n = int(eval(input()))
a = list(map(int, input().split()))
d = [0]*n
for i in range(n):
if i+a[i] < n: d[i+a[i]] += 1
ans = 0
for i in range(n):
if i-a[i] >= 0: ans += d[i-a[i]]
print(ans)
main() | def main():
n = int(eval(input()))
a = list(map(int, input().split()))
d = [0]*n
for i, x in enumerate(a):
if i+x < n: d[i+x] += 1
ans = 0
for i, x in enumerate(a):
if i-x >= 0: ans += d[i-x]
print(ans)
main() | p02691 |
n,a=int(eval(input())),list(map(int, input().split()))
d=[0]*n
def main():
for i,x in enumerate(a):
if i+x<n:d[i+x]+=1
print((sum([d[i-x]for i,x in enumerate(a)if i-x>=0])))
main() | def main():
n,a=int(eval(input())),list(map(int, input().split()));d,s=[0]*n,0
for i,x in enumerate(a):
if i+x<n:d[i+x]+=1
if i-x>=0:s+=d[i-x]
print(s)
main() | p02691 |
from collections import defaultdict
def main():
N = int(eval(input()))
heights = list(map(int, input().split()))
"""
for j>i, j-i = Ai + Aj
i + Ai = j -Aj
"""
L = defaultdict(int)
R = defaultdict(int)
for i, height in enumerate(heights):
if i + height < N:
L[i + height] += 1
if i - height > 0:
R[i - height] += 1
total_count = 0
for x, count_l in list(L.items()):
if x in R:
count_r = R[x]
total_count += count_l * count_r
print(total_count)
if __name__ == "__main__":
main()
| def main():
N = int(eval(input()))
heights = list(map(int, input().split()))
"""
for j>i, j-i = Ai + Aj
i + Ai = j -Aj
"""
L = [0] * N
R = [0] * N
count = 0
for i, height in enumerate(heights):
right = i + height
left = i - height
if right < N:
R[right] += 1
if left > 0:
L[left] += 1
count += R[left]
print(count)
if __name__ == "__main__":
main()
| p02691 |
n=int(eval(input()))
l=list(map(int,input().split()))
r=[0]*(n-1)
t=[0]*(n)
dr={}
dt={l[0]:[0]}
for i in range(1,n):
x=i-l[i]
y=i+l[i]
if x in dr:
dr[x].append(i)
else:
dr[x]=[i]
if y in dt:
dt[y].append(i)
else:
dt[y]=[i]
ans=0
for x in list(dr.keys()):
if x>0 and x in dt:
y=dr[x]
z=dt[x]
for w in y:
for ww in z:
if w>ww:
ans+=1
print(ans) | n=int(eval(input()))
l=list(map(int,input().split()))
r=[0]*(n-1)
t=[0]*(n)
dr={}
dt={l[0]:[0]}
for i in range(1,n):
x=i-l[i]
y=i+l[i]
if x in dr:
dr[x].append(i)
else:
dr[x]=[i]
if y in dt:
dt[y].append(i)
else:
dt[y]=[i]
ans=0
for x in list(dr.keys()):
if x>0 and x in dt:
y=dr[x]
z=dt[x]
ans+=len(z)*len(y)
print(ans) | p02691 |
n=int(eval(input()))
A=list(map(int,input().split()))
S=[]
for i in range(n):
S.append([A[i],i])
S=list(reversed(sorted(S)))
#print(S)
F=[0]*n
ans=0
C=[0]*n
for i in range(n):
s=S.pop(0)
d=s[0] #距離
x=s[1] #座標
F[x]=1
L1=max(x-2*d,0)
L2=max(x-d,-1)
R1=min(x+d,n)
R2=min(x+2*d,n-1)
if L1<=L2:
for j in range(L1,L2+1):
if F[j]==1:
continue
if x-j==d+A[j]:
ans+=1
#print(s,j)
if R1<=R2:
for j in range(R1,R2+1):
if F[j]==1:
continue
if j-x==d+A[j]:
ans+=1
#print(s,j)
print(ans) | n=int(eval(input()))
A=list(map(int,input().split()))
C=[]
for i in range(n):
C.append([i+A[i],0])
C.append([i-A[i],1])
C.sort()
now=C[0][0]
c0=0
c1=0
ans=0
for c in C:
if now==c[0]:
if c[1]==0:
c0+=1
else:
c1+=1
else:
ans+=c0*c1
c0=0
c1=0
if c[1]==0:
c0+=1
else:
c1+=1
now=c[0]
ans+=c0*c1
print(ans) | p02691 |
from collections import Counter
from itertools import combinations
inputs = open(0).readlines()
n = int(inputs[0])
*A, = (list(map(int, inputs[1].split())))
B = [a+i for i, a in enumerate(A, 1)]
C = [i-a for i, a in enumerate(A, 1)]
ans = 0
for k1, v1 in list(Counter(B).items()):
for k2, v2 in list(Counter(C).items()):
if k1 == k2:
ans += v1*v2
print(ans) | from collections import Counter
inputs = open(0).readlines()
n = int(inputs[0])
*A, = (list(map(int, inputs[1].split())))
B = Counter([a+i for i, a in enumerate(A, 1)])
C = Counter([i-a for i, a in enumerate(A, 1)])
ans = 0
for k, v in list(B.items()):
if k in C:
ans += C[k]*v
print(ans) | p02691 |
from collections import Counter
inputs = open(0).readlines()
n = int(inputs[0])
*A, = (list(map(int, inputs[1].split())))
B = Counter([a+i for i, a in enumerate(A, 1)])
C = Counter([i-a for i, a in enumerate(A, 1)])
ans = 0
for k, v in list(B.items()):
if k in C:
ans += C[k]*v
print(ans) | n, *A = list(map(int, open(0).read().split()))
ans, d = 0, {}
for i, a in enumerate(A, 1):
x, y = i+a, i-a
d[x] = d.get(x, 0)+1
ans += d.get(y, 0)
print(ans) | p02691 |
n=int(eval(input()))
heights=list(map(int,input().split(" ")))
res=0
for i in range(n):
for j in range(n):
if abs(j-i)==heights[i]+heights[j]:
res+=1
print((int(res/2))) | n=int(eval(input()))
heights=list(map(int,input().split(" ")))
dic={}
res=0
for i in range(n):
if heights[i]-i not in dic:
dic[heights[i]-i]=1
else:
dic[heights[i]-i]+=1
for j in range(n):
if -heights[j]-j in dic:
res+=dic[-heights[j]-j]
print(res) | p02691 |
# なんか身長順でソートすればいいんじゃない？
# 身長差でありえるのは1〜Nなので，身長差が1になるエージェントの組み合わせをだして，それぞれの身長差について調べる
# でも結局全探索になるか？やっぱり配列を作ると同時に答えが独立してうまく求まるようなのがいいよね
# j-i = Aj+Ai となるのが求めるもの，これを変換してiとjの式のみに分離すると，うまく配列を作るだけでうまくいくようになる
# j-Aj = Ai+i となる．こうすると独立しているので,X=i-Ai,Y=Ai+iを作り，setもしくはdictで探索すればすぐです！
# i==jのときはi-i == Ai+Ai が絶対に成立しないので問題ない
N=int(eval(input()))
A=list(map(int,input().split()))
X=[i+1-A[i] for i in range(N)]
Y=[i+1+A[i] for i in range(N)]
#Y=set(Y) # set使うと同じ要素が減るのでだめ！！！
dicY=dict()
for y in Y:
if not y in dicY:
dicY[y]=1
else:
dicY[y]+=1
count=0
for x in X:
if x in Y:
count+=dicY[x]
print(count)
| # なんか身長順でソートすればいいんじゃない？
# 身長差でありえるのは1〜Nなので，身長差が1になるエージェントの組み合わせをだして，それぞれの身長差について調べる
# でも結局全探索になるか？やっぱり配列を作ると同時に答えが独立してうまく求まるようなのがいいよね
# j-i = Aj+Ai となるのが求めるもの，これを変換してiとjの式のみに分離すると，うまく配列を作るだけでうまくいくようになる
# j-Aj = Ai+i となる．こうすると独立しているので,X=i-Ai,Y=Ai+iを作り，setもしくはdictで探索すればすぐです！
# i==jのときはi-i == Ai+Ai が絶対に成立しないので問題ない
N=int(eval(input()))
A=list(map(int,input().split()))
X=[i+1-A[i] for i in range(N)]
Y=[i+1+A[i] for i in range(N)]
#Y=set(Y) # set使うと同じ要素が減るのでだめ！！！
dicY=dict()
for y in Y:
if not y in dicY:
dicY[y]=1
else:
dicY[y]+=1
count=0
for x in X:
if x in dicY:
count+=dicY[x]
print(count)
| p02691 |
from collections import defaultdict
from bisect import bisect_right
n = int(eval(input()))
a = list(map(int, input().split()))
b = []
c = []
for i in range(n):
b.append(i + 1 - a[i])
c.append(i + 1 + a[i])
cnt = defaultdict(list)
for i in range(n):
cnt[b[i]].append(i)
ans = 0
for i in range(n):
k = bisect_right(cnt[c[i]], i)
ans += len(cnt[c[i]][k:])
print(ans)
| from collections import defaultdict
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
cnt = defaultdict(int)
for i in range(n):
ans += cnt[i - a[i]]
cnt[i + a[i]] += 1
print(ans)
| p02691 |
n = int(eval(input()))
a = list(map(int, input().split()))
out = 0
for i in range(n):
w = i-a[i]
for j in range(i):
if(w == a[j] + j):
out += 1
print(out)
| n = int(eval(input()))
a = list(map(int, input().split()))
ml = [0] * n
pl = [0] * n
out = 0
for i in range(0, n):
if(i+a[i]<n):
pl[i+a[i]] += 1
if(i-a[i]>=0):
ml[i-a[i]] += 1
for i in range(0, n):
out += pl[i] * ml[i]
print(out)
| p02691 |
from collections import Counter
def main():
N = int(eval(input()))
A = tuple(int(c) for c in input().split(' '))
L = [i+a for i, a in enumerate(A)]
R = [i-a for i, a in enumerate(A)]
#print(L)
#print(R)
#はじめL_t = defaultdict(list)としてiの候補を追加していったが、iとjは重複しないのでチェックが不要
'''
L_t = defaultdict(int)
for i, l in enumerate(L):
L_t[l] += 1
R_t = defaultdict(int)
for j, r in enumerate(R):
R_t[r] += 1
'''
L_t = Counter(L)
R_t = Counter(R)
x_max = max(L)
x_min = min(R)
cnt = 0
for x in range(x_min, x_max+1):
l_candidate = L_t[x]
r_candidate = R_t[x]
cnt += l_candidate * r_candidate
print(cnt)
if __name__ == "__main__":
main() | #解説を見て実装
from collections import Counter
def main():
N = int(eval(input()))
A = tuple(int(c) for c in input().split(' '))
L = [i+a for i, a in enumerate(A)]
R = [i-a for i, a in enumerate(A)]
#print(L)
#print(R)
#はじめL_t = defaultdict(list)としてiの候補を追加していったが、iとjは重複しないのでチェックが不要
L_t = Counter(L)
R_t = Counter(R)
cnt = 0
x_candidate = set(L) & set(R)
for x in x_candidate:
l_candidate = L_t[x]
r_candidate = R_t[x]
cnt += l_candidate * r_candidate
print(cnt)
if __name__ == "__main__":
main() | p02691 |
N = int(eval(input()))
A = list(map(int, input().split()))
ans = 0
start_idx = [0] * N
for i, a in enumerate(A):
if i+1+a < N:
start_idx[i+1+a] += 1
if i-a+1 >= 0:
ans += start_idx[i-a+1]
print(ans)
| N = int(eval(input()))
A = list(map(int, input().split()))
ans = 0
start_idx = [0] * N
for i, a in enumerate(A):
if i+a < N:
start_idx[i+a] += 1
if i-a >= 0:
ans += start_idx[i-a]
print(ans)
| p02691 |
n=int(eval(input()))
A=list(map(int, input().split()))
s = -1
ans = 0
for i in range(n):
s +=1
for j in range(s,n):
#print(j)
if abs(i-j) == A[i] + A[j]:
ans += 1
print(ans)
| n = int(eval(input()))
a = list(map(int,input().split()))
x = {}
ans = 0
for i in range(n):
R = i + a[i]
if not R in x:
x[R]=1
else: x[R]+=1
for i in range(n):
L = i - a[i]
if L in x:
ans+=x[L]
print(ans) | p02691 |
from collections import defaultdict
N = int(eval(input()))
A = list(map(int, input().split()))
ans = 0
R = defaultdict(int)
#R= defaultdict(lambda:0)
for i ,Ai in enumerate(A,1):
R[i+Ai]+=1
L = defaultdict(int)
for j ,Aj in enumerate(A,1):
L[j-Aj]+=1
for i in R:
ans+=R.get(i,0)*L.get(i,0)
print(ans) | n = int(eval(input()))
la = [int(i) for i in input().split()]
ia = {}
pair = 0
for j, a in enumerate(la):
ia[j + a] = ia.get(j + a, 0) + 1
for j, a in enumerate(la):
pair += ia.get(j - a, 0)
print(pair)
| p02691 |
from collections import deque
def getInts():
return [ int(x) for x in input().split() ]
[N] = getInts()
As = getInts()
maxV = max(As)
minV = min(As)
count = 0
for i in range(N):
r2 = min(i+As[i]+minV, N-1)
for j in range(r2, N):
if As[j]+As[i] == abs(i-j):
count += 1
print(count) | def getInts():
return [ int(x) for x in input().split() ]
[N] = getInts()
As = getInts()
A = {}
for i in range(1, N+1):
A[i] = As[i-1]
L = {}
R = {}
for i in range(1, N+1):
if i - A[i] not in L:
L[i-A[i]] = 1
else:
L[i-A[i]] += 1
if i + A[i] not in R:
R[i+A[i]] = 1
else:
R[i+A[i]] += 1
count = 0
for k in list(R.keys()):
if k in L:
count += R[k]*L[k]
print(count)
| p02691 |
N = int(eval(input()))
A = list(map(int,input().split()))
counter = 0
for j in range(1, N):
for i in range(j + 1, N + 1):
if j + A[j-1] == i - A[i-1]:
counter += 1
print(counter) | N = int(eval(input()))
A = list(map(int,input().split()))
ans = 0
dic = {}
dic[1 + A[0]] = 1
for i in range(2, N+1):
if i - A[i-1] in dic:
ans += dic[i - A[i-1]]
if i + A[i-1] in dic:
dic[i + A[i-1]] = dic[i + A[i-1]] + 1
else:
dic[i + A[i-1]] = 1
print(ans) | p02691 |
from itertools import combinations
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for i, j in combinations(list(range(n)), 2):
if a[i] + a[j] == abs(i-j):
ans += 1
print(ans)
| n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
mp = {}
for i in range(n):
sa = i - a[i]
if sa in mp:
ans += mp[sa]
wa = i + a[i]
if wa in mp:
mp[wa] += 1
else:
mp[wa] = 1
print(ans)
| p02691 |
def getN():
return int(eval(input()))
def getNM():
return list(map(int, input().split()))
def getList():
return list(map(int, input().split()))
from collections import defaultdict, Counter
from sys import exit
import math
def main():
n = getN()
nums = getList()
den = [num - i for i, num in enumerate(nums)]
cnt = Counter(den)
ans = 0
for i in range(n-1):
k1, k2 = nums[i], nums[i+1]
su = k1 + k2
tgt = den[i+1] - su + 1
if tgt in list(cnt.keys()):
ans += cnt[tgt]
print(ans)
if __name__ == "__main__":
main() | import sys
from collections import defaultdict, deque
import math
# import copy
from bisect import bisect_left, bisect_right
# import heapq
# sys.setrecursionlimit(1000000)
# input aliases
input = sys.stdin.readline
getS = lambda: input().strip()
getN = lambda: int(eval(input()))
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]
INF = 10 ** 20
MOD = 10**9 + 7
def divide(k):
return pow(k, MOD-2, MOD)
def make_nck(n):
ret = [1]
for i in range(1, n+1):
ret.append((ret[-1] * (n + 1 - i) * divide(i)) % MOD)
# print(ret)
return ret
def make_nigojyo(n):
ret = [1]
for i in range(1, n+1):
ret.append((ret[-1] * 25) % MOD)
# print(ret)
return ret
def solve():
n = getN()
nums = getList()
agentss = [num - i for i, num in enumerate(nums)]
agents = [-num - i for i, num in enumerate(nums)]
agents.sort()
agentss.sort()
ans = 0
for ag in agentss:
ans += bisect_right(agents, ag) - bisect_left(agents,ag)
# print(ag, ans)
# bisect_left()
print(ans)
# print(agents)
# print(agentss)
def main():
n = getN()
for _ in range(n):
solve()
if __name__ == "__main__":
# main()
solve() | p02691 |
N=int(eval(input()))
listA=list(map(int,input().split()))
ans=0
L=[]
R=[]
for i in range(N):
L+=[i+listA[i]]
R+=[i-listA[i]]
setL=set(L)
setR=set(R)
for i in range(N):
if i in setL and i in setR:
ans+=L.count(i)*R.count(i)
print(ans) | N=int(eval(input()))
listA=list(map(int,input().split()))
ans=0
L=[]
R=[]
L1=[0]*N
R1=[0]*N
for i in range(N):
L+=[i+listA[i]]
R+=[i-listA[i]]
try:
L1[i+1+listA[i]]+=1
except:
pass
try:
if i-listA[i]>0:
R1[i+1-listA[i]]+=1
except:
pass
for i in range(N):
ans+=L1[i]*R1[i]
print(ans) | p02691 |
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# import numpy as np
# from itertools import *
# from collections import *
from collections import Counter
# S = input().split()
# N = int(input().split())
# N, K = [int(x) for x in input().split()]
N = int(eval(input()))
A = [int(x) for x in input().split()]
number = list(range(1, N+1))
numhei = [0] * N
for n in range(N):
numhei[n] = number[n] + A[n]
count = 0
for n in number:
count += Counter(numhei)[n - A[n-1]]
print(count)
| #!/usr/bin/python3
# -*- coding: utf-8 -*-
# import numpy as np
# from itertools import *
# from collections import *
from collections import Counter
# S = input().split()
# N = int(input().split())
# N, K = [int(x) for x in input().split()]
N = int(eval(input()))
A = [int(x) for x in input().split()]
number = list(range(1, N+1))
numhei = [0] * N
for n in range(N):
numhei[n] = number[n] + A[n]
c = Counter(numhei)
count = 0
for n in number:
count += c[n - A[n-1]]
print(count)
| p02691 |
def diff(a,b):
if a>b:
return(a-b)
else:
return(b-a)
n=int(eval(input()))
l=list(map(int,input().split()))
new=[]
count=0
for i in range(0,len(l)):
new.append((l[i],i+1))
new.sort()
for i in range(0,len(new)):
for j in range(i+1,len(new)):
if new[i][0]+new[j][0]>2*10**5:
break
if new[i][0]+new[j][0]==diff(new[i][1],new[j][1]):
count+=1
print(count)
| n=int(eval(input()))
l=list(map(int,input().split()))
count=0
new=[]
s=set()
d={}
for i in range(0,len(l)):
new.append(i+1-l[i])
s.add(i+1+l[i])
if i+1+l[i] in list(d.keys()):
d[i+1+l[i]]+=1
else:
d[i+1+l[i]]=1
for i in range(0,len(new)):
if new[i] in s:
count+=d[new[i]]
print(count) | p02691 |
import collections
def solve(K, r):
dic = collections.defaultdict(set)
for i, n in enumerate(r):
dic[n].add(i)
ans = 0
for i, n in enumerate(r):
for k in range(i,K):
target_sum = abs(k-i)-n
if k in dic[target_sum]:
ans+=1
return ans
k = int(eval(input()))
r = list(map(int, input().split()))
print((solve(k, r))) | import collections
def solve(k, r):
count = {}
ans = 0
for i, n in enumerate(r):
target = i-n
ans += count.get(target, 0)
count[i+n] = count.get(i+n, 0)+1
return ans
k = int(eval(input()))
r = list(map(int, input().split()))
print((solve(k, r))) | p02691 |
N = int(eval(input()))
A = list(map(int, input().split()))
ans = 0
for i in range(N-2):
j = i + 1
while j <= N-1:
if A[j] + A[i] == j - i:
ans += 1
else:
pass
j += 1
print(ans) | N = int(eval(input()))
dic = {}
ans = 0
A = list(map(int, input().split()))
for i in range(N):
dic[i] = 0
for i in range(N):
b = A[i]+N-i-1
if A[i] < N-i:
a = N-i-A[i]-1
dic[a] += 1
if b < N:
ans += dic[b]
print(ans) | p02691 |
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
import math
#from math import gcd
#inf = 10**17
#mod = 10**9 + 7
d = defaultdict(int)
res = 0
n = int(eval(input()))
a = list(map(int, input().split()))
for i in range(n-1, -1, -1):
res += d[i+a[i]]
d[i-a[i]] += 1
print(res)
if __name__ == '__main__':
main() | def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
import math
#from math import gcd
#inf = 10**17
#mod = 10**9 + 7
d = {}
res = 0
n = int(eval(input()))
a = list(map(int, input().split()))
for i in range(n-1, -1, -1):
if i+a[i] in d:
res += d[i+a[i]]
if i-a[i] not in d:
d[i-a[i]] = 1
else:
d[i-a[i]] += 1
print(res)
if __name__ == '__main__':
main() | p02691 |
def main():
_ = eval(input())
lst_a = [int(a) for a in input().strip().split(' ')]
# build hash table
hash_tbl = {}
for i, a_i in enumerate(lst_a):
n_i = i + 1
tmp = int(n_i - a_i)
if tmp > 0:
if tmp in list(hash_tbl.keys()):
hash_tbl[tmp].append(n_i)
else:
hash_tbl[tmp] = [n_i]
ans = 0
for j, a_j in enumerate(lst_a):
n_j = j + 1
tmp = int(n_j + a_j)
if tmp in list(hash_tbl.keys()):
ans += len([idx for idx in hash_tbl[tmp] if idx > j])
print((int(ans)))
if __name__ == '__main__':
main()
| def main():
_ = eval(input())
lst_a = [int(a) for a in input().strip().split(' ')]
# build hash table
hash_tbl = {}
for i, a_i in enumerate(lst_a):
n_i = i + 1
tmp = int(n_i - a_i)
if tmp > 0:
if tmp in list(hash_tbl.keys()):
hash_tbl[tmp].append(n_i)
else:
hash_tbl[tmp] = [n_i]
ans = 0
for j, a_j in enumerate(lst_a):
n_j = j + 1
tmp = int(n_j + a_j)
if tmp in list(hash_tbl.keys()):
# ans += len([idx for idx in hash_tbl[tmp] if idx > j])
ans += len(hash_tbl[tmp])
print((int(ans)))
if __name__ == '__main__':
main()
| p02691 |
N = int(eval(input()))
A = list(map(int, input().split()))
ans = 0
for i in range(N):
k = A[i]
ans += len([0 for j in range(i + k, N) if j - i == A[i] + A[j]])
else:
print(ans) | N = int(eval(input()))
A = list(map(int, input().split()))
L = {}
R = {}
ans = 0
for i in range(N):
t = i + 1 + A[i]
if t in L:
L[t] += 1
else:
L[t] = 1
t = i + 1 - A[i]
if t > 0:
if t in R:
R[t] += 1
else:
R[t] = 1
for i in R:
if i in L:
ans += R[i] * L[i]
print(ans) | p02691 |
n = int(eval(input()))
a = list(map(int, input().split()))
count = 0
for i in range(n):
for j in range(i + a[i],n):
if a[i] + a[j] == j - i:
count += 1
print(count) | n = int(eval(input()))
a = list(map(int, input().split()))
b = [0] * n
count = 0
for i in range(n):
if i + a[i] < n:
b[i + a[i]] += 1
if i - a[i] >= 0:
count += b[i-a[i]]
print(count) | p02691 |
import collections
n = int(input())
hs = list(map(int, input().split(' ')))
def f(hs):
#print sorted([(e,i) for i,e in enumerate(hs)])
count =0
for i in range(len(hs)):
for j in range(i+1, len(hs)):
if hs[i] + hs[j] == j-i:
count+=1
return count
print(f(hs)) | import collections
n = int(input())
hs = list(map(int, input().split(' ')))
def f(nums):
cc,count = collections.Counter(), 0
#j - i = aj + ai => ai + i = j - aj
for i in range(len(nums)-1, -1, -1):
count += cc[nums[i] + i]
cc[i - nums[i]]+=1
return count
print(f(hs)) | p02691 |
N=int(eval(input()))
A=list(map(int,input().split()))
pair=0
X2=[]
for i in range(N):
a=A[i]
x1=i+1-a
x2=i+1+a
pair+=X2.count(x1)
X2.append(x2)
print(pair) | N=int(eval(input()))
A=list(map(int,input().split()))
pair=0
As={}
for i in range(N):
a=A[i]
x1=i+1-a
x2=i+1+a
if x1 in As:
pair+=As[x1]
if x2 in As:
As[x2]+=1
else:
As[x2]=1
print(pair) | p02691 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.