Open In App

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

Improve
Improve
Like Article
Like
Save
Share
Report

Given two integers a and b, the task is to find the log of a to any base b, i.e. logb 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 logb a, i.e, \LARGE log_{b}\text{ } a = \frac{log\text{ }a}{log\text{ }b}
     

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(logba)
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. logb 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(logba)
Auxiliary Space: O(logba) 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;
}


Java




/*package whatever //do not write package name here */
 
import java.io.*;
public class GFG {
    public static int logAToBaseB(int a, int b) {
        int ans = 0;
        while (a > 1) {
            a /= b;
            ans++;
        }
        return ans;
    }
// Drive Code
    public static void main(String[] args) {
        int a = 3;
        int b = 2;
        System.out.println(logAToBaseB(a, b));
 
        a = 256;
        b = 4;
        System.out.println(logAToBaseB(a, b));
    }
}
// This Program is Contributed by Shivam Tiwari


Python3




def log_a_to_base_b(a, b):
    ans = 0
    while a > 1:
        a //= b
        ans += 1
    return ans
 
# 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 Shivam Tiwari


C#




using System;
 
class Program
{
    // Method to calculate logarithm of a to the base b
    static int LogAToBaseB(int a, int b)
    {
        int ans = 0;
        while (a > 1)
        {
            a /= b;    // Divide a by b
            ans += 1;  // Increment ans by 1
        }
        return ans;
    }
 
    // Entry point of the program
    static void Main(string[] args)
    {
        int a = 3;
        int b = 2;
        Console.WriteLine(LogAToBaseB(a, b)); // Output: 1
 
        a = 256;
        b = 4;
        Console.WriteLine(LogAToBaseB(a, b)); // Output: 4
    }
}
// This Code is Contributed by Shivam Tiwari


Javascript




function log_a_to_base_b(a, b) {
    let ans = 0;
    while (a > 1) {
        a = Math.floor(a / b);
        ans++;
    }
    return ans;
}
 
// Driver code
let a = 3;
let b = 2;
console.log(log_a_to_base_b(a, b));
 
a = 256;
b = 4;
console.log(log_a_to_base_b(a, b));
// This Code is Contributed by Shivam Tiwari


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.



Last Updated : 28 Jul, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads