# Find the range [L, R] such that sum of numbers in this range equals to N

• Difficulty Level : Easy
• Last Updated : 28 Feb, 2022

Given an integer N (N ≠ 0), the task is to find a range [L, R] (−10⁻¹⁸ < L < R < 10¹⁸) such that sum of all integers in this range is equal to N.

L + (L+1) + … + (R−1) + R = N

Examples:

Input : N = 3
Output: -2 3
Explanation: For L = -2 and R = -3 the sum becomes -2 + (-1) + 0 + 1 + 2 + 3 = 3

Input : N = -6
Output: -6 5
Explanation: The sum for this range [-6, 5] is -6 + (-5) + (-4) + (-3) + (-2) + (-1) + 0 + 1+ 2 + 3 + 4 + 5 = -6

Naive Approach: For every value of L try to find a value R which satisfies the condition L + (L+1) + . . . + (R-1) + R = N, using nested loop.
Time Complexity: O(N2)
Auxiliary space: O(1)

Efficient Approach: Since L and R are integers and can be negative numbers as well, the above problem can be solved in O(1) efficiently. Consider the below observation:

• For N being a positive integer we can consider:

[−(N – 1)] + [−(N – 2)] + . . . -1 + 0 + 1 + . . . + (N − 1) + N =
-(N – 1) + (N – 1) – (N – 2) + (N – 2) + . . . + 1 – 1 + 0 + N = N
So, L = -(N – 1) and R = N

• Similarly for N being a negative, we can consider:

N + (N + 1) + . . . -1 + 0 + 1 + . . . + [-(N + 2)] + [-(N + 1)] =
(N + 1) – (N + 1) + (N + 2) – (N + 2) + . . . -1 + 1 + 0 + N = N
So L = N and R = -(N + 1)

Therefore, the solution to this problem in unit time complexity is:

L = -(N – 1) and R = N, when N is a positive integer.

L = N and R = -(N + 1), when N is a negative integer.

Note: This is the longest possible range, (i.e. R – L has the highest value) which satisfies the problem requirement.

Below is the implementation of the approach:

## C++

 `// C++ code to implement above approach`   `#include ` `using` `namespace` `std;`   `// Function to find two integers` `void` `Find_Two_Intergers(``long` `long` `int` `N)` `{` `    ``// Variable to store value of L and R` `    ``long` `long` `int` `L, R;`   `    ``// When N is positive` `    ``if` `(N > 0) {` `        ``L = -(N - 1);` `        ``R = N;` `    ``}`   `    ``// When N is negative` `    ``else` `{` `        ``L = N;` `        ``R = -(N + 1);` `    ``}` `    ``cout << L << ``" "` `<< R;` `}`   `// Driver Code` `int` `main()` `{` `    ``long` `long` `int` `N = 3;` `    ``Find_Two_Integers(N);` `    ``return` `0;` `}`

## C

 `// C code to implement above approach`   `#include `   `// Function to find two integers` `void` `Find_Two_Intergers(``long` `long` `int` `N)` `{` `    ``// Variable to store L and R` `    ``long` `long` `int` `L, R;`   `    ``// When N is positive` `    ``if` `(N > 0) {` `        ``L = -(N - 1);` `        ``R = N;` `    ``}`   `    ``// When N is negative` `    ``else` `{` `        ``L = N;` `        ``R = -(N + 1);` `    ``}` `    ``printf``(``"%lld %lld"``, L, R);` `}`   `// Driver code` `int` `main()` `{` `    ``long` `long` `int` `N = 3;` `    ``Find_Two_Integers(N);` `    ``return` `0;` `}`

## Java

 `// Java code for the above approach` `import` `java.io.*;`   `class` `GFG` `{` `  `  `  ``// Function to find two integers` `  ``static` `void` `Find_Two_Intergers(``long`  `N)` `  ``{` `    `  `    ``// Variable to store value of L and R` `    ``long`  `L, R;`   `    ``// When N is positive` `    ``if` `(N > ``0``) {` `      ``L = -(N - ``1``);` `      ``R = N;` `    ``}`   `    ``// When N is negative` `    ``else` `{` `      ``L = N;` `      ``R = -(N + ``1``);` `    ``}` `    ``System.out.print( L + ``" "` `+ R);` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main (String[] args) {`   `    ``long` `N = ``3``;` `    ``Find_Two_Integers(N);`   `  ``}` `}`   `// This code is contributed by Potta Lokesh`

## Python3

 `# Python code to implement above approach`   `# Function to find two integers` `def` `Find_Two_Intergers(N):` `    ``# variable to store L and R` `    ``L ``=` `0` `    ``R ``=` `0`   `    ``# When N is positive` `    ``if` `N > ``0``:` `        ``L ``=` `-``(N``-``1``)` `        ``R ``=` `N`   `    ``# When N is negative` `    ``else``:` `        ``L ``=` `N` `        ``R ``=` `-``(N``+``1``)`   `    ``print``(L, R)`     `# Driver code` `N ``=` `3` `Find_Two_Integers(N)`

## C#

 `// C# code for the above approach` `using` `System;`   `class` `GFG` `{` `  `  `  ``// Function to find two integers` `  ``static` `void` `Find_Two_Intergers(``long`  `N)` `  ``{` `    `  `    ``// Variable to store value of L and R` `    ``long`  `L, R;`   `    ``// When N is positive` `    ``if` `(N > 0) {` `      ``L = -(N - 1);` `      ``R = N;` `    ``}`   `    ``// When N is negative` `    ``else` `{` `      ``L = N;` `      ``R = -(N + 1);` `    ``}` `    ``Console.Write( L + ``" "` `+ R);` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main (String[] args) {`   `    ``long` `N = 3;` `    ``Find_Two_Integers(N);`   `  ``}` `}`   `// This code is contributed by Saurabh Jaiswal`

## Javascript

 ``

Output

`-2 3`

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :