Related Articles

Related Articles

Length of smallest sequence having sum X and product Y
  • Last Updated : 14 Oct, 2020

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

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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