Given a number **N** and two integers **A** and **B**, the task is to check if it is possible to convert the number to **1** by the following two operations:

- Multiply it by A
- Divide it by B

If it is possible to reduce **N** to **1** then print the minimum number of operations required to achieve it otherwise print **“-1”**.

**Examples:**

Input:N = 48, A = 3, B = 12Output:3Explanation:

Below are the 3 operations:

1. Divide 48 by 12 to get 4.

2. Multiply 4 by 3 to get 12.

3.Divide 12 by 12 to get 1.

Hence the total number of operation is 3.

Input:N = 26, A = 3, B = 9Output:-1Explanation:

It is not possible to convert 26 to 1.

**Approach:** The problem can be solved using Greedy Approach. The idea is to check if B is divisible by A or not and on the basis of that we have the below observations:

- If
**B%A****!= 0**, then it is only possible to convert**N**to**1**if**N**is completely divisible by**B**and it would require**N/B steps**to do so. whereas if**N = 1**then it would require 0 steps, otherwise it’s impossible and prints**“-1”**. - If
**B%A == 0**, then consider a variable**C**whose value is**B/A**Divide**.****N by B**, using the second operation until it cannot be divided any further, let’s call the number of division as**x.** - Again divide the remaining
**N**by**C**until it cannot be divided any further, let’s call the number of divisions in this operation be**y.** - If N does not equal 1 after the above operations then it is impossible to convert
**N**to**1**using the above-mentioned operations and the answer will be**“-1”**, but if it is equal to 1 then we can use the formulato calculate the total minimum steps required.**total_steps = x + (2 * y)**

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <iostream>` `using` `namespace` `std;` `// Function to check if it is possible` `// to convert a number N to 1 by a minimum` `// use of the two operations` `int` `findIfPossible(` `int` `n, ` `int` `a, ` `int` `b)` `{` ` ` `// For the Case b % a != 0` ` ` `if` `(b % a != 0) {` ` ` `// Check if n equal to 1` ` ` `if` `(n == 1)` ` ` `return` `0;` ` ` `// Check if n is not` ` ` `// divisible by b` ` ` `else` `if` `(n % b != 0)` ` ` `return` `-1;` ` ` `else` ` ` `return` `(` `int` `)n / b;` ` ` `}` ` ` `// For the Case b % a == 0` ` ` `// Initialize a variable 'c'` ` ` `int` `c = b / a;` ` ` `int` `x = 0, y = 0;` ` ` `// Loop until n is divisible by b` ` ` `while` `(n % b == 0) {` ` ` `n = n / b;` ` ` `// Count number of divisions` ` ` `x++;` ` ` `}` ` ` `// Loop until n is divisible by c` ` ` `while` `(n % c == 0) {` ` ` `n = n / c;` ` ` `// Count number of operations` ` ` `y++;` ` ` `}` ` ` `// Check if n is reduced to 1` ` ` `if` `(n == 1) {` ` ` `// Count steps` ` ` `int` `total_steps = x + (2 * y);` ` ` `// Return the total number of steps` ` ` `return` `total_steps;` ` ` `}` ` ` `else` ` ` `return` `-1;` `}` `// Driver Code` `int` `main()` `{` ` ` `// Given n, a and b` ` ` `int` `n = 48;` ` ` `int` `a = 3, b = 12;` ` ` `// Function Call` ` ` `cout << findIfPossible(n, a, b);` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.util.*;` `class` `GFG{` ` ` `// Function to check if it is possible` `// to convert a number N to 1 by a minimum` `// use of the two operations` `static` `int` `findIfPossible(` `int` `n, ` `int` `a, ` `int` `b)` `{` ` ` ` ` `// For the Case b % a != 0` ` ` `if` `(b % a != ` `0` `)` ` ` `{` ` ` `// Check if n equal to 1` ` ` `if` `(n == ` `1` `)` ` ` `return` `0` `;` ` ` `// Check if n is not` ` ` `// divisible by b` ` ` `else` `if` `(n % b != ` `0` `)` ` ` `return` `-` `1` `;` ` ` `else` ` ` `return` `(` `int` `)n / b;` ` ` `}` ` ` `// For the Case b % a == 0` ` ` `// Initialize a variable 'c'` ` ` `int` `c = b / a;` ` ` `int` `x = ` `0` `, y = ` `0` `;` ` ` `// Loop until n is divisible by b` ` ` `while` `(n % b == ` `0` `)` ` ` `{` ` ` `n = n / b;` ` ` `// Count number of divisions` ` ` `x++;` ` ` `}` ` ` `// Loop until n is divisible by c` ` ` `while` `(n % c == ` `0` `)` ` ` `{` ` ` `n = n / c;` ` ` `// Count number of operations` ` ` `y++;` ` ` `}` ` ` `// Check if n is reduced to 1` ` ` `if` `(n == ` `1` `)` ` ` `{` ` ` `// Count steps` ` ` `int` `total_steps = x + (` `2` `* y);` ` ` `// Return the total number of steps` ` ` `return` `total_steps;` ` ` `}` ` ` `else` ` ` `return` `-` `1` `;` `}` `// Driver Code` `public` `static` `void` `main(String s[])` `{` ` ` ` ` `// Given n, a and b` ` ` `int` `n = ` `48` `;` ` ` `int` `a = ` `3` `, b = ` `12` `;` ` ` ` ` `// Function Call` ` ` `System.out.println(findIfPossible(n, a, b));` `}` `}` `// This code is contributed by rutvik_56` |

## Python3

`# Python3 program for the above approach` `# Function to check if it is possible` `# to convert a number N to 1 by a minimum` `# use of the two operations` `def` `FindIfPossible(n, a, b):` ` ` ` ` `# For the Case b % a != 0` ` ` `if` `(b ` `%` `a) !` `=` `0` `:` ` ` ` ` `# Check if n equal to 1` ` ` `if` `n ` `=` `=` `1` `:` ` ` `return` `0` ` ` ` ` `# Check if n is not` ` ` `# divisible by b` ` ` `elif` `(n ` `%` `b) !` `=` `0` `:` ` ` `return` `-` `1` ` ` `else` `:` ` ` `return` `int` `(n ` `/` `b)` ` ` ` ` `# For the Case b % a == 0` ` ` `# Initialize a variable 'c'` ` ` `c ` `=` `b ` `/` `a` ` ` `x ` `=` `0` ` ` `y ` `=` `0` ` ` ` ` `# Loop until n is divisible by b` ` ` `while` `(n ` `%` `b ` `=` `=` `0` `):` ` ` `n ` `/` `=` `b` ` ` ` ` `# Count number of divisions` ` ` `x ` `+` `=` `1` ` ` ` ` `# Loop until n is divisible by c` ` ` `while` `(n ` `%` `c ` `=` `=` `0` `):` ` ` `n ` `/` `=` `c` ` ` ` ` `# Count number of operations` ` ` `y ` `+` `=` `1` ` ` ` ` `# Check if n is reduced to 1` ` ` `if` `n ` `=` `=` `1` `:` ` ` ` ` `# Count steps` ` ` `total_steps ` `=` `x ` `+` `2` `*` `y` ` ` ` ` `# Return the total number of steps` ` ` `return` `total_steps` ` ` `else` `:` ` ` `return` `-` `1` ` ` `# Driver code` `# Given n, a and b` `n ` `=` `48` `a ` `=` `3` `b ` `=` `12` `print` `(FindIfPossible(n, a, b))` `# This code is contributed by virusbuddah_` |

## C#

`// C# program for the above approach` `using` `System;` `class` `GFG{` ` ` `// Function to check if it is possible` `// to convert a number N to 1 by a minimum` `// use of the two operations` `static` `int` `findIfPossible(` `int` `n, ` `int` `a, ` `int` `b)` `{` ` ` ` ` `// For the Case b % a != 0` ` ` `if` `(b % a != 0)` ` ` `{` ` ` `// Check if n equal to 1` ` ` `if` `(n == 1)` ` ` `return` `0;` ` ` `// Check if n is not` ` ` `// divisible by b` ` ` `else` `if` `(n % b != 0)` ` ` `return` `-1;` ` ` `else` ` ` `return` `(` `int` `)n / b;` ` ` `}` ` ` `// For the Case b % a == 0` ` ` `// Initialize a variable 'c'` ` ` `int` `c = b / a;` ` ` `int` `x = 0, y = 0;` ` ` `// Loop until n is divisible by b` ` ` `while` `(n % b == 0)` ` ` `{` ` ` `n = n / b;` ` ` `// Count number of divisions` ` ` `x++;` ` ` `}` ` ` `// Loop until n is divisible by c` ` ` `while` `(n % c == 0)` ` ` `{` ` ` `n = n / c;` ` ` `// Count number of operations` ` ` `y++;` ` ` `}` ` ` `// Check if n is reduced to 1` ` ` `if` `(n == 1)` ` ` `{` ` ` `// Count steps` ` ` `int` `total_steps = x + (2 * y);` ` ` `// Return the total number of steps` ` ` `return` `total_steps;` ` ` `}` ` ` `else` ` ` `return` `-1;` `}` `// Driver Code` `public` `static` `void` `Main()` `{` ` ` ` ` `// Given n, a and b` ` ` `int` `n = 48;` ` ` `int` `a = 3, b = 12;` ` ` ` ` `// Function call` ` ` `Console.WriteLine(findIfPossible(n, a, b));` `}` `}` `// This code is contributed by Stream_Cipher` |

## Javascript

`<script>` `// Javascript program for the above approach` `// Function to check if it is possible` `// to convert a number N to 1 by a minimum` `// use of the two operations` `function` `findIfPossible(n, a, b)` `{` ` ` ` ` `// For the Case b % a != 0` ` ` `if` `(b % a != 0)` ` ` `{` ` ` `// Check if n equal to 1` ` ` `if` `(n == 1)` ` ` `return` `0;` ` ` `// Check if n is not` ` ` `// divisible by b` ` ` `else` `if` `(n % b != 0)` ` ` `return` `-1;` ` ` `else` ` ` `return` `n / b;` ` ` `}` ` ` `// For the Case b % a == 0` ` ` `// Initialize a variable 'c'` ` ` `let c = b / a;` ` ` `let x = 0, y = 0;` ` ` `// Loop until n is divisible by b` ` ` `while` `(n % b == 0)` ` ` `{` ` ` `n = n / b;` ` ` `// Count number of divisions` ` ` `x++;` ` ` `}` ` ` `// Loop until n is divisible by c` ` ` `while` `(n % c == 0)` ` ` `{` ` ` `n = n / c;` ` ` `// Count number of operations` ` ` `y++;` ` ` `}` ` ` `// Check if n is reduced to 1` ` ` `if` `(n == 1)` ` ` `{` ` ` `// Count steps` ` ` `let total_steps = x + (2 * y);` ` ` `// Return the total number of steps` ` ` `return` `total_steps;` ` ` `}` ` ` `else` ` ` `return` `-1;` `}` `// Driver Code` ` ` ` ` `// Given n, a and b` ` ` `let n = 48;` ` ` `let a = 3, b = 12;` ` ` ` ` `// Function Call` ` ` `document.write(findIfPossible(n, a, b));` ` ` `</script>` |

**Output:**

3

**Time Complexity:** *O(log (B/A))***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. 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 industry experts, please refer **Geeks Classes Live**