Problem:
Score: 500 points

Problem Statement

You are the top spy of AtCoder Kingdom. To prevent the stolen secret from being handed to AlDebaran Kingdom, you have sneaked into the party where the transaction happens.

There are N attendees in the party, and they are given attendee numbers from 1 through N. The height of Attendee i is A_i.

According to an examination beforehand, you know that a pair of attendees satisfying the condition below will make the transaction.

The absolute difference of their attendee numbers is equal to the sum of their heights.

There are \frac{N(N-1)}{2} ways to choose two from the N attendees and make a pair. Among them, how many satisfy the condition above?

P.S.: We cannot let you know the secret.

Constraints

All values in input are integers.

2 \leq N \leq 2 \times 10^5

1 \leq A_i \leq 10^9\ (1 \leq i \leq N)

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 \dots A_N

Output

Print the number of pairs satisfying the condition.

Sample Input 1

6
2 3 3 1 3 1

Sample Output 1

3

A_1 + A_4 = 3, so the pair of Attendee 1 and 4 satisfy the condition.

A_2 + A_6 = 4, so the pair of Attendee 2 and 6 satisfy the condition.

A_4 + A_6 = 2, so the pair of Attendee 4 and 6 satisfy the condition.

No other pair satisfies the condition, so you should print 3.

Sample Input 2

6
5 2 4 2 8 8

Sample Output 2

0

No pair satisfies the condition, so you should print 0.

Sample Input 3

32
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3 8 3 2 7 9 5

Sample Output 3

22

Solution in Java (OpenJDK 11.0.6) (judge verdict: Accepted)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.StringTokenizer;



public class Main
{	
	
	static class Pair implements Comparable<Pair>
	{
		int x;
		int y;
		int type;
		Pair(int x,int y,int type)
		{
			this.x = x;
			this.y = y;
			this.type = type;
		}
		
		@Override
		public int compareTo(Pair o)
		{
			if(x != o.x)
			{	
				if(x < o.x)
				return -1;
				
				else return 1;
			}
			else
			{	
				if(y < o.y)
				return -1;
				
				else return 1;
			}
		}
	}
	 
	static class FastReader 
	{ 
	    BufferedReader br; 
	    StringTokenizer st; 

	    public FastReader() 
	    { 
	        br = new BufferedReader(new
	                 InputStreamReader(System.in)); 
	    } 

	    String next() 
	    { 
	        while (st == null || !st.hasMoreElements()) 
	        { 
	            try
	            { 
	                st = new StringTokenizer(br.readLine()); 
	            } 
	            catch (IOException  e) 
	            { 
	                e.printStackTrace(); 
	            } 
	        } 
	        return st.nextToken(); 
	    } 

	    int nextInt() 
	    { 
	        return Integer.parseInt(next()); 
	    } 

	    long nextLong() 
	    { 
	        return Long.parseLong(next()); 
	    } 

	    double nextDouble() 
	    { 
	        return Double.parseDouble(next()); 
	    } 

	    String nextLine() 
	    { 
	        String str = ""; 
	        try
	        { 
	            str = br.readLine(); 
	        } 
	        catch (IOException e) 
	        { 
	            e.printStackTrace(); 
	        } 
	        return str; 
	    } 
	}

	static int maxN = 2000000;
	static int fact[] = new int[maxN+1];
	static int factorialNumInverse[] = new int[maxN+1];
	static int naturalNumInverse[] = new int[maxN+1];
	
	static void InverseofNumber() 
	{ 	
		int p = mod;
	    naturalNumInverse[0] = naturalNumInverse[1] = 1; 
	    for (int i = 2; i <= maxN; i++) 
	        naturalNumInverse[i] = (int)((1L *naturalNumInverse[p % i] * (p - p / i))%p); 
	}
	
	static void InverseofFactorial() 
	{ 	
		int p = mod;
	    factorialNumInverse[0] = factorialNumInverse[1] = 1; 
	  
	    for (int i = 2; i <= maxN; i++) 
	        factorialNumInverse[i] = (int)((1L*naturalNumInverse[i] * factorialNumInverse[i - 1]) % p); 
	} 
	
	static void Factorial()
	{
		
		fact[0] = 1;
		for(int i = 1; i < maxN; i++) 
		{
			fact[i] = (int)(1L *fact[i - 1] * i % mod);
		}
	}
	
	static int Binomial(int N, int R) 
	{ 
	    int p = mod;
	    int ans = (int)((1L *(1L*fact[N] * factorialNumInverse[R]) % p * factorialNumInverse[(N - R)]) % p); 
	    return ans; 
	} 
	static int paths(int x1,int y1,int x2,int y2)
	{	
		int x = Math.abs(x2-x1);
		int y = Math.abs(y2-y1);
		
		int N = x+y;
		int R = x;
		
		int ans = Binomial(N,R);
		return ans;
	}
	
	static int mod = 998244353;
	
	// a b c d e f g h i j k
	// 0 1 0 1 0 1 0 1 0 1 0
	
	
	
	
	public static void main(String[] args) 
	{
		OutputStream outputStream = System.out;
		FastReader sc = new FastReader();
        PrintWriter out = new PrintWriter(outputStream);
        
        
        int n = sc.nextInt();
        long a[] = new long[n];
        
        for(int i = 0; i < n; i++)
        {
        	a[i] = sc.nextLong();
        }
        HashMap<Long,Long> hm = new HashMap<>();
        
        long ans = 0;
        for(int i = 0; i < n; i++)
        {
        	if(hm.containsKey(i-a[i]))
        	{
        		ans += hm.get(i-a[i]);
        	}
        	
        	hm.put(i+a[i],hm.getOrDefault(i+a[i],0L)+1L);
        }
        
        out.println(ans);
        out.close();
        

	}
 
}