Program to compute log a to any base b (logb a)

Given two integers a and b, the task is to find the log of a to any base b, i.e. log_b a.
Examples:

Input: a = 3, b = 2
Output: 1

Input: a = 256, b = 4
Output: 4

Using inbuilt log2 function

1. Find the log of a to the base 2 with the help of log2() method 
   
2. Find the log of b to the base 2 with the help of log2() method 
   
3. Divide the computed log a from the log b to get the log_b a, i.e,
   

Below is the implementation of the above approach 

C++

// C++ program to find log(a) on any base b
#include <bits/stdc++.h>
using namespace std;

int log_a_to_base_b(int a, int b)
{
    return log2(a) / log2(b);
}

// Driver code
int main()
{
    int a = 3;
    int b = 2;
    cout << log_a_to_base_b(a, b) << endl;

    a = 256;
    b = 4;
    cout << log_a_to_base_b(a, b) << endl;

    return 0;
}

// This code is contributed by shubhamsingh10, yousefonweb

C

// C program to find log(a) on any base b

#include <math.h>
#include <stdio.h>

int log_a_to_base_b(int a, int b)
{
    return log2(a) / log2(b);
}

// Driver code
int main()
{
    int a = 3;
    int b = 2;
    printf("%d\n",
           log_a_to_base_b(a, b));

    a = 256;
    b = 4;
    printf("%d\n",
           log_a_to_base_b(a, b));

    return 0;
}

Java

// Java program to find log(a) on any base b
class GFG
{

    static int log_a_to_base_b(int a, int b)
    {
        return (int)(Math.log(a) / Math.log(b));
    }

    // Driver code
    public static void main (String[] args)
    {
        int a = 3;
        int b = 2;
        System.out.println(log_a_to_base_b(a, b));

        a = 256;
        b = 4;
        System.out.println(log_a_to_base_b(a, b));
    }
}

// This code is contributed by AnkitRai01

Python3

# Python3 program to find log(a) on any base b
from math import log2

def log_a_to_base_b(a, b) :
    return log2(a) // log2(b);

# Driver code
if __name__ == "__main__" :

    a = 3;
    b = 2;
    print(log_a_to_base_b(a, b));

    a = 256;
    b = 4;
    print(log_a_to_base_b(a, b));

# This code is contributed by AnkitRai01

C#

// C# program to find log(a) on any base b

using System;

public class GFG
{

    static int log_a_to_base_b(int a, int b)
    {
        return (int)(Math.Log(a) / Math.Log(b));
    }

    // Driver code
    public static void Main()
    {
        int a = 3;
        int b = 2;
        Console.WriteLine(log_a_to_base_b(a, b));

        a = 256;
        b = 4;
        Console.WriteLine(log_a_to_base_b(a, b));
    }
}

// This code is contributed by AnkitRai01

Javascript

<script>

// Javascript program to find log(a) on any base b

function log_a_to_base_b(a, b)
{
    return parseInt(Math.log(a) / Math.log(b));
}

// Driver code
var a = 3;
var b = 2;
document.write(log_a_to_base_b(a, b) + "<br>");
a = 256;
b = 4;
document.write(log_a_to_base_b(a, b));

// This code is contributed by rutvik_56.
</script>

Output:

1
4

Time Complexity: O(log_ba)
Auxiliary Space: O(1)

Using Recursion

1. Recursively divide a by b till a is greater than b. 
   
2. Count the number of times the divide is possible. This is the log of a to the base b, i.e. log_b a
   

Below is the implementation of the above approach 

C++

// C++ program to find log(a) on
// any base b using Recursion
#include <iostream>
using namespace std;

// Recursive function to compute
// log a to the base b
int log_a_to_base_b(int a, int b)
{
    return (a > b - 1)
            ? 1 + log_a_to_base_b(a / b, b)
            : 0;
}

// Driver code
int main()
{
    int a = 3;
    int b = 2;
    cout << log_a_to_base_b(a, b) << endl;

    a = 256;
    b = 4;
    cout << log_a_to_base_b(a, b) << endl;

    return 0;
}

// This code is contributed by shubhamsingh10

C

// C program to find log(a) on
// any base b using Recursion

#include <stdio.h>

// Recursive function to compute
// log a to the base b
int log_a_to_base_b(int a, int b)
{
    return (a > b - 1)
               ? 1 + log_a_to_base_b(a / b, b)
               : 0;
}

// Driver code
int main()
{
    int a = 3;
    int b = 2;
    printf("%d\n",
           log_a_to_base_b(a, b));

    a = 256;
    b = 4;
    printf("%d\n",
           log_a_to_base_b(a, b));

    return 0;
}

Java

// Java program to find log(a) on
// any base b using Recursion
class GFG
{

    // Recursive function to compute
    // log a to the base b
    static int log_a_to_base_b(int a, int b)
    {
        int rslt = (a > b - 1)? 1 + log_a_to_base_b(a / b, b): 0;
        return rslt;
    }

    // Driver code
    public static void main (String[] args)
    {
        int a = 3;
        int b = 2;
        System.out.println(log_a_to_base_b(a, b));

        a = 256;
        b = 4;
        System.out.println(log_a_to_base_b(a, b));
    }
}

// This code is contributed by AnkitRai01

Python3

# Python3 program to find log(a) on
# any base b using Recursion

# Recursive function to compute
# log a to the base b
def log_a_to_base_b(a, b) :

    rslt = (1 + log_a_to_base_b(a // b, b)) if (a > (b - 1)) else 0;

    return rslt;

# Driver code
if __name__ == "__main__" :

    a = 3;
    b = 2;
    print(log_a_to_base_b(a, b));

    a = 256;
    b = 4;
    print(log_a_to_base_b(a, b));

# This code is contributed by AnkitRai01

C#

// C# program to find log(a) on
// any base b using Recursion
using System;

class GFG
{

    // Recursive function to compute
    // log a to the base b
    static int log_a_to_base_b(int a, int b)
    {
        int rslt = (a > b - 1)? 1 + log_a_to_base_b(a / b, b): 0;
        return rslt;
    }

    // Driver code
    public static void Main()
    {
        int a = 3;
        int b = 2;
        Console.WriteLine(log_a_to_base_b(a, b));

        a = 256;
        b = 4;
        Console.WriteLine(log_a_to_base_b(a, b));
    }
}

// This code is contributed by Yash_R

Javascript

<script>
// javascript program to find log(a) on
// any base b using Recursion

// Recursive function to compute
    // log a to the base b
    function log_a_to_base_b(a , b)
    {
        var rslt = (a > b - 1) ? 1 + log_a_to_base_b(parseInt(a / b), b) : 0;
        return rslt;
    }

    // Driver code
        var a = 3;
        var b = 2;
        document.write(log_a_to_base_b(a, b)+"<br/>");

        a = 256;
        b = 4;
        document.write(log_a_to_base_b(a, b));

// This code is contributed by umadevi9616
</script>

Output

1
4

Time Complexity: O(log_ba)
Auxiliary Space: O(log_ba) Space required for recursive call stack

Approach:

The approach is to repeatedly divide the given number ‘a’ by the base ‘b’ until ‘a’ becomes less than or equal to 1. In each division, we increment the answer by 1. Finally, we return the answer which represents the logarithm of ‘a’ to the base ‘b’.

• Initialize a variable ‘ans’ to 0.
• Repeat the following steps until ‘a’ becomes less than or equal to 1:
  a. Divide ‘a’ by ‘b’.
  b. Increment ‘ans’ by 1.
• Return ‘ans’ as the result.

C++

#include <bits/stdc++.h>
using namespace std;

int log_a_to_base_b(int a, int b)
{
    int ans = 0;
    while (a > 1) {
        a /= b;
        ans++;
    }
    return ans;
}

// Driver code
int main()
{
    int a = 3;
    int b = 2;
    cout << log_a_to_base_b(a, b) << endl;

    a = 256;
    b = 4;
    cout << log_a_to_base_b(a, b) << endl;

    return 0;
}

Output

1
4

Time Complexity: O(log a), as in each iteration, ‘a’ is divided by ‘b’.
Space Complexity:  O(1), as only a constant amount of extra space is required for storing the ‘ans’ variable.