# Minimum sum of two integers whose product is strictly greater than N

• Last Updated : 19 Oct, 2022

Given an integer N, the task is to find two integers with minimum possible sum such that their product is strictly greater than N.

Examples:

Input: N = 10
Output: 7
Explanation: The integers are 3 and 4. Their product is 3 × 4 = 12, which is greater than N.

Input: N = 1
Output: 3
Explanation: The integers are 1 and 2. Their product is 1 × 2 = 2, which is greater than N.

Naive Approach: Let the required numbers be A and B. The idea is based on the observation that in order to minimize their sum A should be the smallest number greater than √N. Once A is found, B will be equal to the smallest number for which A×B > N, which can be found linearly

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

Efficient Approach: The above solution can be optimized by using Binary Search to find A and B. Follow the steps below to solve the problem:

• Initialize two variables low = 0  and high = 109.
• Iterate until (high – low) is greater than 1 and do the following:
• Find the value of middle-range mid as (low + high)/2.
• Now, compare √N with the middle element mid, and if √N is less than or equal to the middle element,  then high as mid.
• Else, update low as mid.
• After all the above steps set A = high.
• Repeat the same procedure to find B such that A×B > N.
• After the above steps, print the sum of A and B as the result.

Below is the implementation of the above approach:

## C++14

 `// C++ program for the above approach``#include ``using` `namespace` `std;``#define ll long long int` `// Function to find the minimum sum of``// two integers such that their product``// is strictly greater than N``void` `minSum(``int` `N)``{``    ``// Initialise low as 0 and``    ``// high as 1e9``    ``ll low = 0, high = 1e9;` `    ``// Iterate to find the first number``    ``while` `(low + 1 < high) {` `        ``// Find the middle value``        ``ll mid = low + (high - low) / 2;` `        ``// If mid^2 is greater than``        ``// equal to A, then update``        ``// high to mid``        ``if` `(mid * mid >= N) {``            ``high = mid;``        ``}` `        ``// Otherwise update low``        ``else` `{``            ``low = mid;``        ``}``    ``}` `    ``// Store the first number``    ``ll first = high;` `    ``// Again, set low as 0 and``    ``// high as 1e9``    ``low = 0;``    ``high = 1e9;` `    ``// Iterate to find the second number``    ``while` `(low + 1 < high) {` `        ``// Find the middle value``        ``ll mid = low + (high - low) / 2;` `        ``// If first number * mid is``        ``// greater than N then update``        ``// high to mid``        ``if` `(first * mid > N) {``            ``high = mid;``        ``}` `        ``// Else, update low to mid``        ``else` `{``            ``low = mid;``        ``}``    ``}` `    ``// Store the second number``    ``ll second = high;` `    ``// Print the result``    ``cout << first + second;``}` `// Driver Code``int` `main()``{``    ``int` `N = 10;` `    ``// Function Call``    ``minSum(N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;` `class` `GFG{``    ` `// Function to find the minimum sum of``// two integers such that their product``// is strictly greater than N``static` `void` `minSum(``int` `N)``{``    ` `    ``// Initialise low as 0 and``    ``// high as 1e9``    ``long` `low = ``0``, high = ``1000000000``;` `    ``// Iterate to find the first number``    ``while` `(low + ``1` `< high)``    ``{``        ` `        ``// Find the middle value``        ``long` `mid = low + (high - low) / ``2``;` `        ``// If mid^2 is greater than``        ``// equal to A, then update``        ``// high to mid``        ``if` `(mid * mid >= N)``        ``{``            ``high = mid;``        ``}` `        ``// Otherwise update low``        ``else``        ``{``            ``low = mid;``        ``}``    ``}` `    ``// Store the first number``    ``long` `first = high;` `    ``// Again, set low as 0 and``    ``// high as 1e9``    ``low = ``0``;``    ``high = ``1000000000``;` `    ``// Iterate to find the second number``    ``while` `(low + ``1` `< high)``    ``{``        ` `        ``// Find the middle value``        ``long` `mid = low + (high - low) / ``2``;` `        ``// If first number * mid is``        ``// greater than N then update``        ``// high to mid``        ``if` `(first * mid > N)``        ``{``            ``high = mid;``        ``}` `        ``// Else, update low to mid``        ``else``        ``{``            ``low = mid;``        ``}``    ``}` `    ``// Store the second number``    ``long` `second = high;` `    ``// Print the result``    ``System.out.println(first + second);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `N = ``10``;``    ` `    ``// Function Call``    ``minSum(N);``}``}` `// This code is contributed by Dharanendra L V`

## Python3

 `# Python3 program for the above approach` `# Function to find the minimum sum of``# two integers such that their product``# is strictly greater than N``def` `minSum(N):``    ` `    ``# Initialise low as 0 and``    ``# high as 1e9``    ``low ``=` `0``    ``high ``=` `1000000000` `    ``# Iterate to find the first number``    ``while` `(low ``+` `1` `< high):``        ` `        ``# Find the middle value``        ``mid ``=` `low ``+` `(high ``-` `low) ``/` `2` `        ``# If mid^2 is greater than``        ``# equal to A, then update``        ``# high to mid``        ``if` `(mid ``*` `mid >``=` `N):``            ``high ``=` `mid` `        ``# Otherwise update low``        ``else``:``            ``low ``=` `mid` `    ``# Store the first number``    ``first ``=` `high` `    ``# Again, set low as 0 and``    ``# high as 1e9``    ``low ``=` `0``    ``high ``=` `1000000000` `    ``# Iterate to find the second number``    ``while` `(low ``+` `1` `< high):` `        ``# Find the middle value``        ``mid ``=` `low ``+` `(high ``-` `low) ``/` `2` `        ``# If first number * mid is``        ``# greater than N then update``        ``# high to mid``        ``if` `(first ``*` `mid > N):``            ``high ``=` `mid` `        ``# Else, update low to mid``        ``else``:``            ``low ``=` `mid` `    ``# Store the second number``    ``second ``=` `high` `    ``# Print the result``    ``print``(``round``(first ``+` `second))` `# Driver Code``N ``=` `10` `# Function Call``minSum(N)` `# This code is contributed by Dharanendra L V`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{``  ` `// Function to find the minimum sum of``// two integers such that their product``// is strictly greater than N``static` `void` `minSum(``int` `N)``{``    ` `    ``// Initialise low as 0 and``    ``// high as 1e9``    ``long` `low = 0, high = 1000000000;` `    ``// Iterate to find the first number``    ``while` `(low + 1 < high)``    ``{``        ` `        ``// Find the middle value``        ``long` `mid = low + (high - low) / 2;` `        ``// If mid^2 is greater than``        ``// equal to A, then update``        ``// high to mid``        ``if` `(mid * mid >= N)``        ``{``            ``high = mid;``        ``}` `        ``// Otherwise update low``        ``else``        ``{``            ``low = mid;``        ``}``    ``}` `    ``// Store the first number``    ``long` `first = high;` `    ``// Again, set low as 0 and``    ``// high as 1e9``    ``low = 0;``    ``high = 1000000000;` `    ``// Iterate to find the second number``    ``while` `(low + 1 < high)``    ``{``        ` `        ``// Find the middle value``        ``long` `mid = low + (high - low) / 2;` `        ``// If first number * mid is``        ``// greater than N then update``        ``// high to mid``        ``if` `(first * mid > N)``        ``{``            ``high = mid;``        ``}` `        ``// Else, update low to mid``        ``else``        ``{``            ``low = mid;``        ``}``    ``}` `    ``// Store the second number``    ``long` `second = high;` `    ``// Print the result``    ``Console.WriteLine( first + second);``}` `// Driver Code``static` `public` `void` `Main()``{``    ``int` `N = 10;``    ` `    ``// Function Call``    ``minSum(N);``}``}` `// This code is contributed by Dharanendra L V`

## Javascript

 ``

Output:

`7`

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

Most Efficient Approach: To optimize the above approach, the idea is based on Inequality of Arithmetic and Geometric progression as illustrated below.

From the inequality, If there are two integers A and B,
(A + B)/2 ≥ √(A×B)
Now, A×B = Product of the two integers, which is N and A+B is sum(=S).
Therefore, S ≥ 2*√N
To get strictly greater product than N, the above equation transforms to: S ≥ 2*√(N+1)

Below is the program for the above approach:

## C++14

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the minimum sum of``// two integers such that their product``// is strictly greater than N``void` `minSum(``int` `N)``{``    ``// Store the answer using the``    ``// AP-GP inequality``    ``int` `ans = ``ceil``(2 * ``sqrt``(N + 1));` `    ``// Print the answer``    ``cout << ans;``}` `// Driver Code``int` `main()``{``    ``int` `N = 10;` `    ``// Function Call``    ``minSum(N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.lang.*;` `class` `GFG{``    `  `// Function to find the minimum sum of``// two integers such that their product``// is strictly greater than N``static` `void` `minSum(``int` `N)``{``    ` `    ``// Store the answer using the``    ``// AP-GP inequality``    ``int` `ans = (``int``)Math.ceil(``2` `* Math.sqrt(N + ``1``));` `    ``// Print the answer``    ``System.out.println( ans);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `N = ``10``;``    ` `    ``// Function Call``    ``minSum(N);``}``}` `// This code is contributed by Dharanendra L V`

## Python3

 `# Python3 program for the above approach``import` `math` `# Function to find the minimum sum of``# two integers such that their product``# is strictly greater than N``def` `minSum(N):``    ` `    ``# Store the answer using the``    ``# AP-GP inequality``    ``ans ``=` `math.ceil(``2` `*` `math.sqrt(N ``+` `1``))``    ` `    ``# Print the result``    ``print``(math.trunc(ans))` `# Driver Code``N ``=` `10` `# Function Call``minSum(N)` `# This code is contributed by Dharanendra L V`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to find the minimum sum of``// two integers such that their product``// is strictly greater than N``static` `void` `minSum(``int` `N)``{``    ` `    ``// Store the answer using the``    ``// AP-GP inequality``    ``int` `ans = (``int``)Math.Ceiling(2 * Math.Sqrt(N + 1));` `    ``// Print the answer``    ``Console.WriteLine( ans);``}` `// Driver Code``static` `public` `void` `Main()``{``    ``int` `N = 10;``    ` `    ``// Function Call``    ``minSum(N);``}``}` `// This code is contributed by Dharanendra L V`

## Javascript

 ``

Output:

`7`

Time Complexity: O(logN) because it is using inbuilt sqrt function
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up