# Count bases which contains a set bit as the Most Significant Bit in the representation of N

Given a positive integer **N**, the task is to count the number of different bases in which, when** N** is represented, the most significant bit of **N** is a found to be a set bit.

**Examples:**

Input:N = 6Output:4Explanation:The number 6 can be represented in 5 different bases, i.e. base 2, base 3, base 4, base 5, base 6.

- (6)
_{10}in base 2: (110)_{2}- (6)
_{10}in base 3: (20)_{3}- (6)
_{10 }in base 4: (12)_{4}- (6)
_{10}in base 5: (11)_{5}- (6)
_{10 }in base 6: (10)_{6}The base representation for (6)

_{10}in base 2, base 4, base 5, base 6 starts with 1. Hence, the required count of bases is 4.

Input:N = 5Output:4

**Approach:** The given problem can be solved by finding the MSB of the given number **N** for every possible base and count those bases that have **MSB** as **1**. Follow the steps below to solve the problem:

- Initialize a variable, say
**count**as**0**, to store the required result. - Iterate over the range
**[2, N]**using a variable, say**B**, and perform the following steps:- Store the highest power of base
**B****N**in a variable**P**. This can be easily achieved by finding the value of (**log N**to the base**B**) i.e.,**log**truncated to the nearest integer._{B}(N) - To find the value of
**log**use the log property:_{B}(N)**log**_{B}(N) = log(N)/log(B) - Store the most significant digit of
**N****N**by**(B)**. If it is equal to^{P}**1**, then increment the value of the**count**by 1.

- Store the highest power of base
- After completing the above steps, print the value of
**count**as the result.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to count bases` `// having MSB of N as a set bit` `int` `countOfBase(` `int` `N)` `{` ` ` `// Store the required count` ` ` `int` `count = 0;` ` ` `// Iterate over the range [2, N]` ` ` `for` `(` `int` `i = 2; i <= N; ++i) {` ` ` `int` `highestPower` ` ` `= (` `int` `)(` `log` `(N) / ` `log` `(i));` ` ` `// Store the MSB of N` ` ` `int` `firstDigit = N / (` `int` `)` `pow` `(` ` ` `i, highestPower);` ` ` `// If MSB is 1, then increment` ` ` `// the count by 1` ` ` `if` `(firstDigit == 1) {` ` ` `++count;` ` ` `}` ` ` `}` ` ` `// Return the count` ` ` `return` `count;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `N = 6;` ` ` `cout << countOfBase(N);` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.io.*;` `class` `GFG {` ` ` ` ` `public` `static` `int` `countOfBase(` `int` `N)` `{` ` ` ` ` `// Store the required count` ` ` `int` `count = ` `0` `;` ` ` `// Iterate over the range [2, N]` ` ` `for` `(` `int` `i = ` `2` `; i <= N; ++i) {` ` ` `int` `highestPower` ` ` `= (` `int` `)(Math.log(N) /Math.log(i));` ` ` `// Store the MSB of N` ` ` `int` `firstDigit = N / (` `int` `)Math.pow(` ` ` `i, highestPower);` ` ` `// If MSB is 1, then increment` ` ` `// the count by 1` ` ` `if` `(firstDigit == ` `1` `) {` ` ` `++count;` ` ` `}` ` ` `}` ` ` `// Return the count` ` ` `return` `count;` `}` ` ` `// DRIVER CODE` ` ` `public` `static` `void` `main (String[] args)` ` ` `{` ` ` `int` `N = ` `6` `;` ` ` `System.out.println(countOfBase(N));` ` ` `}` `}` ` ` `// This code is contributed by Potta Lokesh` |

## C#

`// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG{` `// Function to count bases` `// having MSB of N as a set bit` `static` `int` `countOfBase(` `int` `N)` `{` ` ` ` ` `// Store the required count` ` ` `int` `count = 0;` ` ` ` ` `// Iterate over the range [2, N]` ` ` `for` `(` `int` `i = 2; i <= N; ++i)` ` ` `{` ` ` ` ` `int` `highestPower = (` `int` `)(Math.Log(N) /` ` ` `Math.Log(i));` ` ` ` ` `// Store the MSB of N` ` ` `int` `firstDigit = N / (` `int` `)Math.Pow(` ` ` `i, highestPower);` ` ` ` ` `// If MSB is 1, then increment` ` ` `// the count by 1` ` ` `if` `(firstDigit == 1)` ` ` `{` ` ` `++count;` ` ` `}` ` ` `}` ` ` ` ` `// Return the count` ` ` `return` `count;` `}` `// Driver Code` `public` `static` `void` `Main()` `{` ` ` `int` `N = 6;` ` ` ` ` `Console.Write(countOfBase(N));` `}` `}` `// This code is contributed by ipg2016107` |

## Javascript

`<script>` ` ` `// JavaScript implementation of the approach` ` ` `function` `countOfBase(N)` ` ` `{` ` ` ` ` `// Store the required count` ` ` `let count = 0;` ` ` `// Iterate over the range [2, N]` ` ` `for` `(let i = 2; i <= N; ++i) {` ` ` `let highestPower` ` ` `= parseInt(Math.log(N) / Math.log(i));` ` ` `// Store the MSB of N` ` ` `let firstDigit = parseInt(N / Math.pow(` ` ` `i, highestPower));` ` ` `// If MSB is 1, then increment` ` ` `// the count by 1` ` ` `if` `(firstDigit == 1) {` ` ` `++count;` ` ` `}` ` ` `}` ` ` `// Return the count` ` ` `return` `count;` ` ` `}` ` ` ` ` `// Driver code` ` ` `let N = 6;` ` ` `document.write(countOfBase(N))` `// This code is contributed by Potta Lokesh` ` ` `</script>` |

## Python3

`# Python 3 program for the above approach` `import` `math` `# Function to count bases` `# having MSB of N as a set bit` `def` `countOfBase(N) :` ` ` ` ` `# Store the required count` ` ` `count ` `=` `0` ` ` `# Iterate over the range [2, N]` ` ` `for` `i ` `in` `range` `(` `2` `, N` `+` `1` `):` ` ` `highestPower ` `=` `int` `(math.log(N) ` `/` `math.log(i))` ` ` `# Store the MSB of N` ` ` `firstDigit ` `=` `int` `(N ` `/` `int` `(math.` `pow` `(i, highestPower)))` ` ` `# If MSB is 1, then increment` ` ` `# the count by 1` ` ` `if` `(firstDigit ` `=` `=` `1` `) :` ` ` `count ` `+` `=` `1` ` ` ` ` ` ` `# Return the count` ` ` `return` `count` `# Driver Code` `N ` `=` `6` `print` `(countOfBase(N))` |

**Output:**

4

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