Wednesday, November 20, 2024
Google search engine
HomeData Modelling & AICompute the maximum power with a given condition

Compute the maximum power with a given condition

Given 3 integers N, M, and K. The task is to find maximum P such that N * KP ? M.

Examples:  

Input :N = 1, K = 2, M = 5 
Output :2
Explanation: 1*2² = 5, which is <= to M(5), also for p = 3 the value would be 1*2³=9, this is not a feasible solution. Thus 2 is the answer.

Input: N = 5, K = 25, M = 100 
Output: 0  
Explanation: 5*25?=5, which is <= to M(100), also for p =1 the value would be 125, which is greater than the M(100), thus not a feasible solution. Hence 0 is the required answer.

Approach: 
In this algorithm, simply multiply N with K and update the current value of N with the result and increase variable power (initially 0) by 1
To achieve this, a recursive function is defined which has 2 base cases.  

  1. Initially, N is greater than required, therefore, return 0.
  2. Otherwise, return power – 1.
  • If the current value of N is equal to the M then return power.
  • Recursive condition if current N < M
    ? Update N as (N * k) and power as current power + 1
     

Below is the implementation of the above approach: 

C++




// Compute maximum power to which K can be raised so
// that given condition remains true
#include <bits/stdc++.h>
using namespace std;
 
#define ll long long
 
// Function to return the largest
// power
int calculate(ll int n, ll int k,
              ll int m, ll int power)
{
 
    // If n is greater than given M
    if (n > m) {
        if (power == 0)
            return 0;
        else
            return power - 1;
    }
 
    // If n == m
    else if (n == m)
        return power;
 
    else
        // Checking for the next power
        return calculate(n * k, k, m, power + 1);
}
 
// Driver Code
int main()
{
    ll N = 1, K = 2, M = 5;
 
    cout << calculate(N, K, M, 0);
 
    return 0;
}


Java




// Java program for Compute maximum power
// to which K can be raised so that
// given condition remains true
class GFG
{
 
// Function to return the largest
// power
static int calculate(int n, int k,
                     int m, int power)
{
 
    // If n is greater than given M
    if (n > m)
    {
        if (power == 0)
            return 0;
        else
            return power - 1;
    }
 
    // If n == m
    else if (n == m)
        return power;
 
    else
        // Checking for the next power
        return calculate(n * k, k, m,
                          power + 1);
}
 
// Driver Code
public static void main (String[] args)
{
    int N = 1, K = 2, M = 5;
 
    System.out.println(calculate(N, K, M, 0));
}
}
 
// This code is contributed by AnkitRai01


Python




# Compute maximum power to
# which K can be raised so
# that given condition
# remains true
 
 
# Function to return the largest
# power
def calculate(n, k, m, power):    
     
    # If n is greater than given M                        
    if n > m:
        if power == 0:
            return 0
        else:
            return power-1
     
    # If n == m
    elif n == m:
        return power
    else:
        # Checking for the next power
        return calculate(n * k, k, m, power + 1)
 
# Driver's code    
if __name__=="__main__":
     
    N = 1
    K = 2
    M = 5
     
    print(calculate(N, K, M, 0))


C#




// C# program for Compute maximum power
// to which K can be raised so that
// given condition remains true
using System;
class GFG
{
 
// Function to return the largest
// power
static int calculate(int n, int k,
                     int m, int power)
{
 
    // If n is greater than given M
    if (n > m)
    {
        if (power == 0)
            return 0;
        else
            return power - 1;
    }
 
    // If n == m
    else if (n == m)
        return power;
 
    else
        // Checking for the next power
        return calculate(n * k, k, m,
                         power + 1);
}
 
// Driver Code
public static void Main (String[] args)
{
    int N = 1, K = 2, M = 5;
 
    Console.WriteLine(calculate(N, K, M, 0));
}
}
 
// This code is contributed by PrinciRaj1992


Javascript




<script>
// javascript program for Compute maximum power
// to which K can be raised so that
// given condition remains true    
// Function to return the largest
    // power
    function calculate(n , k , m , power) {
 
        // If n is greater than given M
        if (n > m) {
            if (power == 0)
                return 0;
            else
                return power - 1;
        }
 
        // If n == m
        else if (n == m)
            return power;
 
        else
            // Checking for the next power
            return calculate(n * k, k, m, power + 1);
    }
 
    // Driver Code
     
        var N = 1, K = 2, M = 5;
 
        document.write(calculate(N, K, M, 0));
 
// This code contributed by aashish1995
</script>


Output

2

Time Complexity:– O(1)
Auxiliary Space: O(1), as no extra space is used.

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!

RELATED ARTICLES

Most Popular

Recent Comments