Given a number of digits ‘N’ and base ‘B’, the task is to count all the ‘N’ digit numbers without leading zeros that are in base ‘B’
Examples:
Input: N = 2, B = 2 Output: 2 All possible numbers without leading zeros are 10 and 11. Input: N = 5, B = 8 Output: 28672
Approach:
- If the base is ‘B’ then every digit of the number can take any value within the range [0, B-1].
- So, B
‘N’ digit numbers are possible with base ‘B’ (including the numbers with leading zeros). - And, if we fix the first digit as ‘0’ then the rest of the ‘N-1’ digits can form a total of B
numbers. - So, the total number of ‘N’ digit numbers with base ‘B’ possible without leading zeros are B
– B .
Below is the implementation of the above approach:
C++
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std;
// function to count // all permutations void countPermutations( int N, int B)
{ // count of
// all permutations
int x = pow (B, N);
// count of permutations
// with leading zeros
int y = pow (B, N - 1);
// Return the permutations
// without leading zeros
cout << x - y << "\n" ;
} // Driver code int main()
{ int N = 6;
int B = 4;
countPermutations(N, B);
return 0;
} |
Java
// Java implementation of the approach class GFG
{ // function to count // all permutations static void countPermutations( int N, int B)
{ // count of
// all permutations
int x = ( int )Math.pow(B, N);
// count of permutations
// with leading zeros
int y = ( int )Math.pow(B, N - 1 );
// Return the permutations
// without leading zeros
System.out.println(x - y);
} // Driver code public static void main(String[] args)
{ int N = 6 ;
int B = 4 ;
countPermutations(N, B);
} } // This code is contributed by mits |
Python3
# Python3 implementation of the approach # function to count all permutations def countPermutations(N, B):
# count of all permutations
x = B * * N
# count of permutations
# with leading zeros
y = B * * (N - 1 )
# Return the permutations
# without leading zeros
print (x - y)
# Driver code if __name__ = = "__main__" :
N, B = 6 , 4
countPermutations(N, B)
# This code is contributed by Rituraj Jain |
C#
// C# implementation of the approach using System;
class GFG
{ // function to count // all permutations static void countPermutations( int N, int B)
{ // count of
// all permutations
int x = ( int )Math.Pow(B, N);
// count of permutations
// with leading zeros
int y = ( int )Math.Pow(B, N - 1);
// Return the permutations
// without leading zeros
Console.WriteLine(x - y);
} // Driver code public static void Main()
{ int N = 6;
int B = 4;
countPermutations(N, B);
} } // This code is contributed // by Akanksha Rai(Abby_akku) |
PHP
<?php // PHP implementation of the approach // function to count all permutations function countPermutations( $N , $B )
{ // count of all permutations
$x = pow( $B , $N );
// count of permutations
// with leading zeros
$y = pow( $B , $N - 1);
// Return the permutations
// without leading zeros
echo ( $x - $y ), "\n" ;
} // Driver code $N = 6;
$B = 4;
countPermutations( $N , $B );
// This code is contributed // by Sach_Code` ?> |
Javascript
<script> // Javascript implementation of the approach // function to count // all permutations function countPermutations(N, B)
{ // count of
// all permutations
var x = Math.pow(B, N);
// count of permutations
// with leading zeros
var y = Math.pow(B, N - 1);
// Return the permutations
// without leading zeros
document.write( x - y );
} // Driver code var N = 6;
var B = 4;
countPermutations(N, B); </script> |
Output:
3072
Time Complexity: O(logn), since pow function takes logn time to find the power of a number to base n.Auxiliary Space: O(1), since no extra space has been taken.