 Open in App
Not now

# 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”

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

 ``

Output:

`6<<3+6<<1`

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

My Personal Notes arrow_drop_up