Skip to content
Related Articles

Related Articles

Improve Article
Length of smallest sequence having sum X and product Y
  • Difficulty Level : Easy
  • Last Updated : 04 May, 2021

Given two integers X and Y, the task is to find the length of the smallest sequence consisting of positive integers having sum X and product Y. If no such sequence can be generated, print -1.

Examples:

Input: X = 5, Y = 5
Output: 1
Explanation:
The smallest possible sequence having sum 5 and product 5 is {5}. Therefore, the required answer is length of the sequence(= 1).

Input: X = 9, Y = 8
Output: 2
Explanation:
The smallest possible sequence is {1, 8} with sum X (= 1 + 8 = 9) and product Y(= 1 * 8 = 8).

Approach: The idea is to implement Binary Search to solve the given problem on the required size in the range [1, floor(x/e)] where e is the Euler constant.



  • Initialize two variables low and high to 1 and floor(x/e) respectively.
  • If X is equal to Y, then the maximum size of the sequence can always be 1. Therefore, print it.
  • Otherwise, iterate until the difference between high and low exceeds 1 and calculate mid each time.
  • Reset the values of high and low as per the boundary conditions at each step and print the final value of high at the end.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
#define ll long long
#define pb push_back
 
// Function for checking valid or not
double temp(int n, int x)
{
    return pow(x * 1.0 / n, n);
}
 
// Function for checking boundary
// of binary search
bool check(int n, int y, int x)
{
    double v = temp(n, x);
    return (v >= y);
}
 
// Function to calculate the
// minimum sequence size
// using binary search
void find(int x, int y)
{
    // Initialize high and low
    int high = (int)floor(x / exp(1.0));
    int low = 1;
 
    // Base case
    if (x == y)
        cout << 1 << endl;
 
    // Print -1 if a sequence
    // cannot be generated
    else if (!check(high, y, x))
        cout << -1 << endl;
 
    // Otherwise
    else {
 
        // Iterate until difference
        // between high and low exceeds 1
        while (high - low > 1) {
 
            // Calculate mid
            int mid
                = (high + low) / 2;
 
            // Reset values of high
            // and low accordingly
            if (check(mid, y, x))
                high = mid;
            else
                low = mid;
        }
 
        // Print the answer
        cout << high << endl;
    }
}
 
// Driver Code
int main()
{
 
    int x = 9, y = 8;
 
    // Function call
    find(x, y);
 
    return 0;
}
Java



// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function for checking valid or not
static double temp(int n, int x)
{
    return Math.pow(x * 1.0 / n, n);
}
 
// Function for checking boundary
// of binary search
static boolean check(int n, int y, int x)
{
    double v = temp(n, x);
    return (v >= y);
}
 
// Function to calculate the
// minimum sequence size
// using binary search
static void find(int x, int y)
{
     
    // Initialize high and low
    int high = (int)Math.floor(x /
                    Math.exp(1.0));
    int low = 1;
 
    // Base case
    if (x == y)
        System.out.print(1 + "\n");
 
    // Print -1 if a sequence
    // cannot be generated
    else if (!check(high, y, x))
        System.out.print(-1 + "\n");
 
    // Otherwise
    else
    {
 
        // Iterate until difference
        // between high and low exceeds 1
        while (high - low > 1)
        {
             
            // Calculate mid
            int mid = (high + low) / 2;
 
            // Reset values of high
            // and low accordingly
            if (check(mid, y, x))
                high = mid;
            else
                low = mid;
        }
 
        // Print the answer
        System.out.print(high + "\n");
    }
}
 
// Driver Code
public static void main(String[] args)
{
    int x = 9, y = 8;
 
    // Function call
    find(x, y);
}
}
 
// This code is contributed by Amit Katiyar
Python3



# Python3 program for the above approach
from math import floor, exp
 
# Function for checking valid or not
def temp(n, x):
     
    return pow(x * 1 / n, n)
 
# Function for checking boundary
# of binary search
def check(n, y, x):
     
    v = temp(n, x)
    return (v >= y)
 
# Function to calculate the
# minimum sequence size
# using binary search
def find(x, y):
     
    # Initialize high and low
    high = floor(x / exp(1.0))
    low = 1
 
    # Base case
    if (x == y):
        print(1)
 
    # Print -1 if a sequence
    # cannot be generated
    elif (not check(high, y, x)):
        print(-1)
 
    # Otherwise
    else:
 
        # Iterate until difference
        # between high and low exceeds 1
        while (high - low > 1):
 
            # Calculate mid
            mid = (high + low) // 2
 
            # Reset values of high
            # and low accordingly
            if (check(mid, y, x)):
                high = mid
            else:
                low = mid
 
        # Print the answer
        print(high)
 
# Driver Code
if __name__ == '__main__':
 
    x = 9
    y = 8
 
    # Function call
    find(x, y)
 
# This code is contributed by mohit kumar 29
C#



// C# program for
// the above approach
using System;
class GFG{
 
// Function for checking
// valid or not
static double temp(int n,
                   int x)
{
  return Math.Pow(x * 1.0 / n, n);
}
 
// Function for checking
// boundary of binary search
static bool check(int n,
                  int y, int x)
{
  double v = temp(n, x);
  return (v >= y);
}
 
// Function to calculate the
// minimum sequence size
// using binary search
static void find(int x, int y)
{
  // Initialize high and low
  int high = (int)Math.Floor(x /
                  Math.Exp(1.0));
  int low = 1;
 
  // Base case
  if (x == y)
    Console.Write(1 + "\n");
 
  // Print -1 if a sequence
  // cannot be generated
  else if (!check(high, y, x))
    Console.Write(-1 + "\n");
 
  // Otherwise
  else
  {
    // Iterate until difference
    // between high and low exceeds 1
    while (high - low > 1)
    {
      // Calculate mid
      int mid = (high + low) / 2;
 
      // Reset values of high
      // and low accordingly
      if (check(mid, y, x))
        high = mid;
      else
        low = mid;
    }
 
    // Print the answer
    Console.Write(high + "\n");
  }
}
 
// Driver Code
public static void Main(String[] args)
{
  int x = 9, y = 8;
 
  // Function call
  find(x, y);
}
}
 
// This code is contributed by Rajput-Ji
Javascript



<script>
 
// JavaScript program for the above approach
 
// Function for checking valid or not
function temp(n, x)
{
    return Math.pow((x * 1.0) / n, n);
}
 
// Function for checking boundary
// of binary search
function check(n, y, x)
{
    var v = temp(n, x);
    return v >= y;
}
 
// Function to calculate the
// minimum sequence size
// using binary search
function find(x, y)
{
     
    // Initialize high and low
    var high = parseInt(Math.floor(x /
                        Math.exp(1.0)));
    var low = 1;
     
    // Base case
    if (x == y)
        document.write(1 + "<br>");
     
    // Print -1 if a sequence
    // cannot be generated
    else if (!check(high, y, x))
        document.write(-1 + "<br>");
         
    // Otherwise
    else
    {
         
        // Iterate until difference
        // between high and low exceeds 1
        while (high - low > 1)
        {
             
            // Calculate mid
            var mid = (high + low) / 2;
             
            // Reset values of high
            // and low accordingly
            if (check(mid, y, x))
                high = mid;
            else
                low = mid;
        }
         
        // Print the answer
        document.write(high + "<br>");
    }
}
 
// Driver Code
var x = 9,
y = 8;
 
// Function call
find(x, y);
 
// This code is contributed by rdtank
 
</script>
Output
2
Time Complexity: O(log2(X/e)) 
Auxiliary Space: O(1) 
Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.



My Personal Notes
arrow_drop_up
Previous
Hitting Set problem is NP Complete
Next

Check if sum of array can be reduced to zero by repetitively reducing array element by their index value
Recommended Articles
Page :
Nth term of a sequence formed by sum of current term with product of its largest and smallest digit
28, May 20
Lexicographically smallest permutation of a string that can be reduced to length K by removing K-length prefixes from palindromic substrings of length 2K
11, Nov 20
Lexicographically smallest permutation of length 2N that can be obtained from an N-length array satisfying given conditions
17, Jun 21
Smallest pair of indices with product of subarray co-prime with product of the subarray on the left or right
23, Nov 20
Digit - Product - Sequence
27, Sep 17
Maximum product quadruple (sub-sequence of size 4) in array
04, Jun 18
Find the lexicographically smallest sequence which can be formed by re-arranging elements of second array
02, May 19
Generate an N-length sequence from two given arrays whose GCD is K
04, Mar 21
Maximum Sequence Length | Collatz Conjecture
20, Sep 19
Smallest number whose product with N has sum of digits equal to that of N
15, Dec 20
Smallest number k such that the product of digits of k is equal to n
25, Sep 17
Generate Bitonic Sequence of length N from integers in a given range
17, Nov 20
Length of second longest sequence of consecutive 1s in a binary array
17, Sep 20
Length of the longest increasing subsequence which does not contain a given sequence as Subarray
01, Nov 20
Sum and product of k smallest and k largest composite numbers in the array
15, Nov 18
Sum and product of k smallest and k largest prime numbers in the array
15, Nov 18
Find a valid parenthesis sequence of length K from a given valid parenthesis sequence
10, Sep 20
Smallest string without any multiplication sign that represents the product of two given numbers
10, Sep 20
Smallest index that splits an array into two subarrays with equal product
13, May 21
Kth Smallest Element of a Matrix of given dimensions filled with product of indices
22, Jul 20
Maximum Length of Sequence of Sums of prime factors generated by the given operations
18, Aug 20
Lexicographically largest N-length Bitonic sequence made up of elements from given range
09, Dec 20
Length of the smallest subarray with maximum possible sum
15, Jun 21
Sum of length of two smallest subsets possible from a given array with sum at least K
10, Mar 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
grand_master
@grand_master
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox