Given an integer **N**, the task is to count all arithmetic progression with common difference equal to **1** and the sum of all its elements equal to **N.**

**Examples:**

Input:N = 12Output:3Explanation:

Following three APs satisfy the required conditions:

- {3, 4, 5}
- {−2, −1, 0, 1, 2, 3, 4, 5}
- {−11, −10, −9, …, 10, 11, 12]}

Input:N = 963761198400Output:1919

**Approach: **The given problem can be solved using the following properties of** AP:**

- The sum of an
**AP**series having**N**terms with first term as**A**and common difference**1**is given by the formula**S = (N / 2 )* ( 2 *A + N − 1)**. - Solving the above equation:

S = N / 2 [2 *A + N − 1].

Rearranging this and multiplying both sides by 2

=> 2 * S = N * (N + 2 * A − 1)Rearranging further

=> A = ((2 * N / i ) − i + 1) / 2.Now, iterate over all the factors of

2 * N, and check for each factori, whether(2 * N/i) − i + 1is even or not.

Follow the steps below to solve the problem:

- Initialize a variable, say
**count,**to store the number of AP series possible having given conditions. - Iterate through all the factors of
**2 * N**and for every**i**^{th}factor, check if**(2 * N / i) − i + 1**is even. - If found to be true, increment the count.
- Print
**count – 1**as the required answer, as the sequence consisting only of**N**needs to be discarded.

Below is the implementation of the above approach:

## C++14

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to count all possible` `// AP series with common difference` `// 1 and sum of elements equal to N` `void` `countAPs(` `long` `long` `int` `N)` `{` ` ` `// Stores the count of AP series` ` ` `long` `long` `int` `count = 0;` ` ` `// Traverse through all factors of 2 * N` ` ` `for` `(` `long` `long` `int` `i = 1;` ` ` `i * i <= 2 * N; i++) {` ` ` `long` `long` `int` `res = 2 * N;` ` ` `if` `(res % i == 0) {` ` ` `// Check for the given conditions` ` ` `long` `long` `int` `op = res / i - i + 1;` ` ` `if` `(op % 2 == 0) {` ` ` `// Increment count` ` ` `count++;` ` ` `}` ` ` `if` `(i * i != res` ` ` `and (i - res / i + 1) % 2 == 0) {` ` ` `count++;` ` ` `}` ` ` `}` ` ` `}` ` ` `// Print count - 1` ` ` `cout << count - 1 << ` `"\n"` `;` `}` `// Driver Code` `int` `main()` `{` ` ` `// Given value of N` ` ` `long` `long` `int` `N = 963761198400;` ` ` `// Function call to count` ` ` `// required number of AP series` ` ` `countAPs(N);` `}` |

## Java

`// Java program for the above approach` `import` `java.io.*;` `import` `java.lang.*;` `import` `java.util.*;` `class` `GFG {` ` ` `// Function to count all possible` ` ` `// AP series with common difference` ` ` `// 1 and sum of elements equal to N` ` ` `static` `void` `countAPs(` `long` `N)` ` ` `{` ` ` `// Stores the count of AP series` ` ` `long` `count = ` `0` `;` ` ` `// Traverse through all factors of 2 * N` ` ` `for` `(` `long` `i = ` `1` `; i * i <= ` `2` `* N; i++) {` ` ` `long` `res = ` `2` `* N;` ` ` `if` `(res % i == ` `0` `) {` ` ` `// Check for the given conditions` ` ` `long` `op = res / i - i + ` `1` `;` ` ` `if` `(op % ` `2` `== ` `0` `) {` ` ` `// Increment count` ` ` `count++;` ` ` `}` ` ` `if` `(i * i != res` ` ` `&& (i - res / i + ` `1` `) % ` `2` `== ` `0` `) {` ` ` `count++;` ` ` `}` ` ` `}` ` ` `}` ` ` `// Print count - 1` ` ` `System.out.println(count - ` `1` `);` ` ` `}` ` ` `// Driver code` ` ` `public` `static` `void` `main(String[] args)` ` ` `{` ` ` `// Given value of N` ` ` `long` `N = 963761198400L;` ` ` `// Function call to count` ` ` `// required number of AP series` ` ` `countAPs(N);` ` ` `}` `}` `// This code is contributed by Kingash.` |

## Python3

`# Python3 program to implement` `# the above approach` `# Function to count all possible` `# AP series with common difference` `# 1 and sum of elements equal to N` `def` `countAPs(N) :` ` ` ` ` `# Stores the count of AP series` ` ` `count ` `=` `0` ` ` `# Traverse through all factors of 2 * N` ` ` `i ` `=` `1` ` ` `while` `(i ` `*` `i <` `=` `2` `*` `N) :` ` ` `res ` `=` `2` `*` `N` ` ` `if` `(res ` `%` `i ` `=` `=` `0` `) :` ` ` `# Check for the given conditions` ` ` `op ` `=` `res ` `/` `i ` `-` `i ` `+` `1` ` ` `if` `(op ` `%` `2` `=` `=` `0` `) :` ` ` `# Increment count` ` ` `count ` `+` `=` `1` ` ` `if` `(i ` `*` `i !` `=` `res` ` ` `and` `(i ` `-` `res ` `/` `i ` `+` `1` `) ` `%` `2` `=` `=` `0` `) :` ` ` `count ` `+` `=` `1` ` ` `i ` `+` `=` `1` ` ` ` ` `# Prcount - 1` ` ` `print` `(count ` `-` `1` `)` `# Driver Code` `# Given value of N` `N ` `=` `963761198400` `# Function call to count` `# required number of AP series` `countAPs(N)` `# This code is contributed by sanjoy_62.` |

## C#

`// C# program for above approach` `using` `System;` `public` `class` `GFG` `{` ` ` `// Function to count all possible` ` ` `// AP series with common difference` ` ` `// 1 and sum of elements equal to N` ` ` `static` `void` `countAPs(` `long` `N)` ` ` `{` ` ` `// Stores the count of AP series` ` ` `long` `count = 0;` ` ` `// Traverse through all factors of 2 * N` ` ` `for` `(` `long` `i = 1; i * i <= 2 * N; i++) {` ` ` `long` `res = 2 * N;` ` ` `if` `(res % i == 0) {` ` ` `// Check for the given conditions` ` ` `long` `op = res / i - i + 1;` ` ` `if` `(op % 2 == 0) {` ` ` `// Increment count` ` ` `count++;` ` ` `}` ` ` `if` `(i * i != res` ` ` `&& (i - res / i + 1) % 2 == 0) {` ` ` `count++;` ` ` `}` ` ` `}` ` ` `}` ` ` `// Print count - 1` ` ` `Console.WriteLine(count - 1);` ` ` `}` ` ` `// Driver code` ` ` `public` `static` `void` `Main(String[] args)` ` ` `{` ` ` `// Given value of N` ` ` `long` `N = 963761198400L;` ` ` `// Function call to count` ` ` `// required number of AP series` ` ` `countAPs(N);` ` ` `}` `}` `// This code is contributed by sanjoy_62.` |

**Output:**

1919

**Time Complexity: **O(√N)**Auxiliary** **Space: **O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.