# Count Arithmetic Progressions having sum N and common difference equal to 1

• Difficulty Level : Basic
• Last Updated : 02 Feb, 2022

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 = 12
Output: 3
Explanation:
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 = 963761198400
Output: 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 factor i, whether (2 * N/i) − i + 1 is 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 ith 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 ` `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` `  `  `    ``#  Print count - 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.`

## Javascript

 ``

Output:

`1919`

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :