# Count of ways to generate Sequence of distinct consecutive odd integers with sum N

• Last Updated : 10 Mar, 2022

Given an integer N,  the task is to find the total number of ways a sequence can be formed consisting of distinct consecutive odd integers that add up to N.

Examples:

Input: N = 45
Output: 3
Explanation: 3 ways to choose distinct consecutive odd numbers that add up to 45 are –
{5, 7, 9, 11, 13}, {13, 15, 17} and {45}.

Input : N = 20
Output : 1
Explanation: 9 and 11 are the only consecutive odd numbers whose sum is 20

Approach:  The idea to solve the problem is based on the idea of sum of first K consecutive odd integers:

• The sum of first K consecutive odd integers is K2.
• Let there be a sequence of consecutive odd integers from (y+1)th odd number to xth odd number (x > y), whose sum is N.
• Then, x2 – y2 = N or (x + y) * (x – y) = N.
• Let a and b be two divisors of N. Therefore, a * b=N.
• Hence, x + y = a & x – y = b
• Solving these two, we get x = (a + b) / 2.
• This implies, if (a + b) is even, then x and y would be integral, which means there would exist a sequence of consecutive odd integers that adds up to N.

Follow the steps mentioned below to implement the above observation:

• Iterate through all pairs of divisors, such that their product is N.
• If the sum of such a pair of divisors is even, increment the count of answer by 1.
• Return the final count at the end.

Below is the implementation of the above approach.

## C++

 `// C++ program for above approach:``#include ``using` `namespace` `std;` `// Function to calculate``// Number of sequence of odd integers that``// Contains distinct consecutive odd integers``// That add up to N.``int` `numberOfSequences(``int` `N)``{``    ``// Initializing count variable by 0,``    ``// That stores the number of sequences``    ``int` `count = 0;` `    ``// Iterating through all divisors of N``    ``for` `(``int` `i = 1; i * i <= N; i++) {``        ``if` `(N % i == 0) {` `            ``// If sum of the two divisors``            ``// Is even, we increment``            ``// The count by 1``            ``int` `divisor1 = i;``            ``int` `divisor2 = N / i;``            ``int` `sum = divisor1 + divisor2;``            ``if` `(sum % 2 == 0) {``                ``count++;``            ``}``        ``}``    ``}` `    ``// Returning total count``    ``// After completing the iteration``    ``return` `count;``}` `// Driver Code``int` `main()``{``    ``int` `N = 45;` `    ``// Function call``    ``int` `number_of_sequences = numberOfSequences(N);``    ``cout << number_of_sequences;``    ``return` `0;``}`

## Java

 `// JAVA program to check whether sum``// Is equal to target value``// After K operations``import` `java.util.*;``class` `GFG``{` `  ``// Function to calculate``  ``// Number of sequence of odd integers that``  ``// Contains distinct consecutive odd integers``  ``// That add up to N.``  ``static` `int` `numberOfSequences(``int` `N)``  ``{``    ``// Initializing count variable by 0,``    ``// That stores the number of sequences``    ``int` `count = ``0``;` `    ``// Iterating through all divisors of N``    ``for` `(``int` `i = ``1``; i * i <= N; i++) {``      ``if` `(N % i == ``0``) {` `        ``// If sum of the two divisors``        ``// Is even, we increment``        ``// The count by 1``        ``int` `divisor1 = i;``        ``int` `divisor2 = N / i;``        ``int` `sum = divisor1 + divisor2;``        ``if` `(sum % ``2` `== ``0``) {``          ``count++;``        ``}``      ``}``    ``}` `    ``// Returning total count``    ``// After completing the iteration``    ``return` `count;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `N = ``45``;` `    ``// Function call``    ``int` `number_of_sequences = numberOfSequences(N);``    ``System.out.print(number_of_sequences);``  ``}``}` `// This code is contributed by sanjoy_62.`

## Python3

 `# Python code for the above approach``import` `math` `# Function to calculate``# Number of sequence of odd integers that``# Contains distinct consecutive odd integers``# That add up to N.``def` `numberOfSequences(N):` `    ``# Initializing count variable by 0,``    ``# That stores the number of sequences``    ``count ``=` `0``;` `    ``# Iterating through all divisors of N``    ``for` `i ``in` `range``(``1``,math.ceil(math.sqrt(N))):``        ``if` `(N ``%` `i ``=``=` `0``):``          ` `            ``# If sum of the two divisors``            ``# Is even, we increment``            ``# The count by 1``            ``divisor1 ``=` `i;``            ``divisor2 ``=` `N ``/``/``i;``            ``sum` `=` `divisor1 ``+` `divisor2;``            ``if` `(``sum` `%` `2` `=``=` `0``):``                ``count ``=` `count ``+` `1``            ` `    ``# Returning total count``    ``# After completing the iteration``    ``return` `count;` `# Driver Code``N ``=` `45``;` `# Function call``number_of_sequences ``=` `numberOfSequences(N);``print``(number_of_sequences);``   ` `# This code is contributed by Potta Lokesh`

## C#

 `// C# program for above approach:``using` `System;``class` `GFG {` `  ``// Function to calculate``  ``// Number of sequence of odd integers that``  ``// Contains distinct consecutive odd integers``  ``// That add up to N.``  ``static` `int` `numberOfSequences(``int` `N)``  ``{``    ``// Initializing count variable by 0,``    ``// That stores the number of sequences``    ``int` `count = 0;` `    ``// Iterating through all divisors of N``    ``for` `(``int` `i = 1; i * i <= N; i++) {``      ``if` `(N % i == 0) {` `        ``// If sum of the two divisors``        ``// Is even, we increment``        ``// The count by 1``        ``int` `divisor1 = i;``        ``int` `divisor2 = N / i;``        ``int` `sum = divisor1 + divisor2;``        ``if` `(sum % 2 == 0) {``          ``count++;``        ``}``      ``}``    ``}` `    ``// Returning total count``    ``// After completing the iteration``    ``return` `count;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main()``  ``{``    ``int` `N = 45;` `    ``// Function call``    ``int` `number_of_sequences = numberOfSequences(N);``    ``Console.Write(number_of_sequences);``  ``}``}` `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`3`

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

My Personal Notes arrow_drop_up