# Minimum N-Digit number required to obtain largest N-digit number after performing given operations

• Difficulty Level : Medium
• Last Updated : 22 Mar, 2022

Given a positive integer N, the task is to find the minimum N-digit number such that performing the following operations on it in the following order results into the largest N-digit number:

1. Convert the number to its Binary Coded Decimal form.
2. Concatenate all the resulting nibbles to form a binary number.
3. Remove the least significant N bits from the number.
4. Convert this obtained binary number to its decimal form.

Examples:

Input: N = 4
Output: 9990
Explanation:
Largest 4 digit number = 9999
BCD of 9999 = 1001 1001 1001 1001
Binary form = 1001100110011001
Replacing last 4 bits by 0000: 1001 1001 1001 0000 = 9990
Therefore, the minimum N-digit number that can generate 9999 is 9990

Input: N = 5
Output: 99980
Explanation:
Largest 5 digit number = 99999
BCD of 99999 = 1001 1001 1001 1001 1001
Binary for = 10011001100110011001
Replacing last 5 bits by 00000: 10011001100110000000 = 99980
Therefore, the minimum N-digit number that can generate 99999 is 99980

Approach: The problem can be solved based on the following observations of BCD numbers. Follow the steps below to solve the problem:

1. Each nibble in BCD does not increase beyond 1001 which is 9 in binary form, since the maximum single digit decimal number is 9.
2. Thus, it can be concluded that the maximum binary number that can be obtained by bringing N nibbles together is 1001 concatenated N times, whose decimal representation is have to be the digit 9 concatenated N times.
3. The last N LSBs from this binary form is required to be removed. Thus the values of these bits will not contribute in making the result larger. Therefore, keeping the last N bits as 9 is not necessary as we need the minimum number producing the maximum result.
4. The value of floor(N/4) will give us the number of nibbles that will be completely removed from the number. Assign these nibbles the value of 0000 to minimize the number.
5. The remainder of N/4 gives us the number of digits that would be switched to 0 from the LSB of the last non-zero nibble after having performed the previous step.
6. This BCD formed by performing the above steps, when converted to decimal, generates the required maximized N digit number.

Below is the implementation of the above approach:

## C++

 // C++ Program to implement// the above approach#include using namespace std; void maximizedNdigit(int n){     int count0s, count9s;    // If n is divisible by 4    if (n % 4 == 0) {         count0s = n / 4;        count9s = n - n / 4;    }     // Otherwise    else {         count0s = n / 4 + 1;        count9s = n - count0s;        count0s--;    }     while (count9s--)        cout << '9';     if (n % 4 != 0)        cout << '8';     while (count0s--)        cout << '0';    cout << endl;} // Driver Codeint main(){    int n = 5;    maximizedNdigit(n);}

## C

 #include  void maximizedNdigit(int n){   int count0s, count9s;  // If n is divisible by 4  if (n % 4 == 0) {     count0s = n / 4;    count9s = n - n / 4;  }   // Otherwise  else {     count0s = n / 4 + 1;    count9s = n - count0s;    count0s--;  }   while (count9s--)    printf("9");   if (n % 4 != 0)    printf("8");   while (count0s--)    printf("0");  printf("\n");} // Driver Codeint main(){  int n = 5;  maximizedNdigit(n);  return 0;} // This code is contributed by phalashi.

## Java

 // Java program to implement// the above approachimport java.io.*; class GFG{ static void maximizedNdigit(int n){    int count0s, count9s;         // If n is divisible by 4    if (n % 4 == 0)    {        count0s = n / 4;        count9s = n - n / 4;    }     // Otherwise    else    {        count0s = n / 4 + 1;        count9s = n - count0s;        count0s--;    }     while (count9s != 0)    {        count9s--;        System.out.print('9');    }     if (n % 4 != 0)        System.out.print('8');     while (count0s != 0)    {        count0s--;        System.out.print('0');    }         System.out.println();} // Driver Codepublic static void main(String[] args){    int n = 5;         maximizedNdigit(n);}} // This code is contributed by sanjoy_62

## Python3

 # Python3 program to implement# the above approachdef maximizedNdigit(n):     # If n is divisible by 4    if (n % 4 == 0):        count0s = n // 4        count9s = n - n // 4         # Otherwise    else:        count0s = n // 4 + 1        count9s = n - count0s        count0s -= 1         while (count9s):        print('9', end = "")        count9s -= 1     if (n % 4 != 0):        print('8', end = "")     while (count0s):        print('0', end = "")        count0s -= 1             print() # Driver Codeif __name__ == "__main__":     n = 5    maximizedNdigit(n) # This code is contributed by chitranayal

## C#

 // C# program to implement// the above approachusing System; class GFG{ static void maximizedNdigit(int n){    int count0s, count9s;         // If n is divisible by 4    if (n % 4 == 0)    {        count0s = n / 4;        count9s = n - n / 4;    }     // Otherwise    else    {        count0s = n / 4 + 1;        count9s = n - count0s;        count0s--;    }     while (count9s != 0)    {        count9s--;        Console.Write('9');    }     if (n % 4 != 0)        Console.Write('8');     while (count0s != 0)    {        count0s--;        Console.Write('0');    }             Console.WriteLine();} // Driver Codepublic static void Main(){    int n = 5;         maximizedNdigit(n);}} // This code is contributed by sanjoy_62

## Javascript



Output:

99980

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

My Personal Notes arrow_drop_up