Skip to content
Related Articles

Related Articles

Count Arithmetic Progressions having sum N and common difference equal to 1
  • Difficulty Level : Basic
  • Last Updated : 08 Mar, 2021

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 <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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :