Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Smallest string without any multiplication sign that represents the product of two given numbers

  • Difficulty Level : Medium
  • Last Updated : 10 Jun, 2021

Given two numbers A and B, the task is to print the string of the smallest possible length which evaluates to the product of the two given numbers i.e., A*B, without using the multiplication sign.

Any perfect power of 2 can be expressed in the form of a left-shift operator. 
For Example: 
N = 2 = 1<<1 = “<<1” 
N = 4 = 1<<2 = “<<2” 
Using the above idea, any number can be expressed using a left-shift operator instead of a multiplication sign. 
For Example: 
N = 24 = 6*4 = 6(1<<2) = “6<<2”

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Examples:



Input: A = 6, B = 10 
Output: 6<<3+6<<1
Explanation: 
The product of the 2 numbers = 6 × 10 = 60. 
The above-given expression evaluates to 6 × (2 × 2 × 2) + 6 × 2 = 60. 
The string “10<<2+10<<1” also evaluates to 60. 
But “6<<3+6<<1” is the required output as its length is smaller.

Input: A = 5, B = 5 
Output: 5<<2+5
Explanation: 
The product of the 2 numbers = 5 × 5 = 25. 
The above-given expression evaluates to 5 × (2 × 2) + 5 = 25.

Approach: The idea is to use Left Shift Operator to find the product. Below are the steps: 

 Let B = 2k1 + 2k2 + … + 2kn, where k1 > k2 > .. > k

  • Therefore, the product of A and B can be written as

A * B = A * (2k1 + 2k2+ … + 2kn )

  • Use the “<<“ (left shift operator) to multiply a number by any power of two.
  • Thus A x B = A << k1 + A << k2 + … + A << kn
  • To find ki we use the log() function and continue the process with the remainder B – 2ki until the remainder becomes 0 or the log of the remainder becomes zero.
  • Similarly, represent A*B = B<< k1 + B<< k2 + … + B<< kn by representing A as the power of 2.
  • Compare the two representations and print the string with a smaller length.

Below is the implementation of the above approach:

C++




// C++ program for
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the string
// which evaluates to the
// product of A and B
string len(long A, long B)
{
  // Stores the result
  string res = "";
  long Log = 0;
 
  do
  {   
    // 2 ^ log <= B &&
    // 2 ^ (log + 1) > B
    Log = (long)(log(B) / log(2));
 
    // Update res to
    // res+=A X 2^log
    if (Log != 0)
    {
      res = res + to_string(A) +
            "<<" + to_string(Log);
    }
    else
    {
      // Update res to
      // res+=A X 2^0
      res += A;
      break;
    }
 
    // Find the remainder
    B = B - (long)pow(2, Log);
 
    // If remainder is
    // not equal to 0
    if (B != 0)
    {
      res += "+";
    }
    else
      break;
  } while (Log != 0);
 
  // Return the
  // resultant string
  return res;
}
 
// Function to find the minimum
// length representation of A*B
void minimumString(long A, long B)
{
  // Find representation of form
  // A << k1 + A << k2 + ... + A << kn
  string res1 = len(A, B);
 
  // Find representation of form
  // B << k1 + B << k2 + ... + B << kn
  string res2 = len(B, A);
 
  // Compare the length of
  // the representations
  if (res1.length() > res2.length())
  {
    cout << res2 << endl;
  }
  else
  {
    cout << res1 << endl;
  }
}
   
// Driver code
int main()
{
  // Product A X B
  long A = 6;
  long B = 10;
 
  // Function Call
  minimumString(A, B);
 
  return 0;
}
 
// This code is contributed by divyeshrabadiya07

Java




// Java program for the above approach
 
class GFG {
 
    // Function to find the string
    // which evaluates to the
    // product of A and B
    public static String len(long A,
long B)
    {
        // Stores the result
        String res = "";
        long log = 0;
 
        do {
 
            // 2 ^ log <= B &&
            // 2 ^ (log + 1) > B
            log = (long)(Math.log(B)
                         / Math.log(2));
 
            // Update res to
            // res+=A X 2^log
            if (log != 0) {
 
                res += A + "<<" + log;
            }
            else {
 
                // Update res to res+=A X 2^0
                res += A;
                break;
            }
 
            // Find the remainder
            B = B - (long)Math.pow(2, log);
 
            // If remainder is not equal
            // to 0
            if (B != 0) {
                res += "+";
            }
            else
                break;
        } while (log != 0);
 
        // Return the resultant string
        return res;
    }
 
    // Function to find the minimum
    // length representation of A*B
    public static void
    minimumString(long A, long B)
    {
        // Find representation of form
        // A << k1 + A << k2 + ... + A << kn
        String res1 = len(A, B);
 
        // Find representation of form
        // B << k1 + B << k2 + ... + B << kn
        String res2 = len(B, A);
 
        // Compare the length of
        // the representations
        if (res1.length() > res2.length()) {
            System.out.println(res2);
        }
        else {
            System.out.println(res1);
        }
    }
 
    // Driver Code
    public static void main(String args[])
    {
        // Product A X B
        long A = 6;
        long B = 10;
 
        // Function Call
        minimumString(A, B);
    }
}

Python3




# Python3 program for the above approach
from math import log
 
# Function to find the string
# which evaluates to the
# product of A and B
def lenn(A, B):
     
    # Stores the result
    res = ""
    logg = 0
 
    while True:
 
        # 2 ^ logg <= B &&
        # 2 ^ (logg + 1) > B
        logg =log(B) // log(2)
 
        # Update res to
        # res+=A X 2^logg
        if (logg != 0):
            res += (str(A) + "<<" +
                    str(int(logg)))
        else:
 
            # Update res to res+=A X 2^0
            res += A
            break
 
        # Find the remainder
        B = B - pow(2, logg)
 
        # If remainder is not equal
        # to 0
        if (B != 0):
            res += "+"
        else:
            break
             
        if logg == 0:
            break
 
    # Return the resultant string
    return res
 
# Function to find the minimum
# length representation of A*B
def minimumString(A, B):
     
    # Find representation of form
    # A << k1 + A << k2 + ... + A << kn
    res1 = lenn(A, B)
 
    # Find representation of form
    # B << k1 + B << k2 + ... + B << kn
    res2 = lenn(B, A)
 
    # Compare the length of
    # the representations
    if (len(res1) > len(res2)):
        print(res2)
    else:
        print(res1)
 
# Driver Code
if __name__ == '__main__':
     
    # Product A X B
    A = 6
    B = 10
 
    # Function call
    minimumString(A, B)
 
# This code is contributed by mohit kumar 29

C#




// C# program for the above approach
using System;
 
class GFG{
 
// Function to find the string
// which evaluates to the
// product of A and B
public static string len(long A, long B)
{
     
    // Stores the result
    string res = "";
    long log = 0;
 
    do
    {
         
        // 2 ^ log <= B &&
        // 2 ^ (log + 1) > B
        log = (long)(Math.Log(B) /
                     Math.Log(2));
 
        // Update res to
        // res+=A X 2^log
        if (log != 0)
        {
            res += A + "<<" + log;
        }
        else
        {
             
            // Update res to res+=A X 2^0
            res += A;
            break;
        }
 
        // Find the remainder
        B = B - (long)Math.Pow(2, log);
 
        // If remainder is not equal
        // to 0
        if (B != 0)
        {
            res += "+";
        }
        else
            break;
    } while (log != 0);
 
    // Return the resultant string
    return res;
}
 
// Function to find the minimum
// length representation of A*B
public static void minimumString(long A,
                                 long B)
{
     
    // Find representation of form
    // A << k1 + A << k2 + ... + A << kn
    string res1 = len(A, B);
 
    // Find representation of form
    // B << k1 + B << k2 + ... + B << kn
    string res2 = len(B, A);
 
    // Compare the length of
    // the representations
    if (res1.Length > res2.Length)
    {
        Console.WriteLine(res2);
    }
    else
    {
        Console.WriteLine(res1);
    }
}
 
// Driver Code
public static void Main()
{
     
    // Product A X B
    long A = 6;
    long B = 10;
 
    // Function call
    minimumString(A, B);
}
}
 
// This code is contributed by code_hunt

Javascript




<script>
// Javascript program for
// the above approach
 
 
// Function to find the string
// which evaluates to the
// product of A and B
function len(A, B) {
    // Stores the result
    let res = "";
    let Log = 0;
 
    do {
        // 2 ^ log <= B &&
        // 2 ^ (log + 1) > B
        Log = Math.floor(Math.log(B) / Math.log(2));
 
        // Update res to
        // res+=A X 2^log
        if (Log != 0) {
            res = res + String(A) + "<<" + String(Log);
        }
        else {
            // Update res to
            // res+=A X 2^0
            res += A;
            break;
        }
 
        // Find the remainder
        B = B - Math.pow(2, Log);
 
        // If remainder is
        // not equal to 0
        if (B != 0) {
            res += "+";
        }
        else
            break;
    } while (Log != 0);
 
    // Return the
    // resultant string
    return res;
}
 
// Function to find the minimum
// length representation of A*B
function minimumString(A, B) {
    // Find representation of form
    // A << k1 + A << k2 + ... + A << kn
    let res1 = len(A, B);
 
    // Find representation of form
    // B << k1 + B << k2 + ... + B << kn
    let res2 = len(B, A);
 
    // Compare the length of
    // the representations
    if (res1.length > res2.length) {
        document.write(res2 + "<br>");
    }
    else {
        document.write(res1 + "<br>");
    }
}
 
// Driver code
 
 
// Product A X B
let A = 6;
let B = 10;
 
// Function Call
minimumString(A, B);
 
 
// This code is contributed by gfgking
</script>
Output: 
6<<3+6<<1

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




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!