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

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 probelm 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 Code ` `int` `main() ` `{ ` `    ``int` `n = 5; ` `    ``maximizedNdigit(n); ` `} `

## Java

 `// Java program to implement ` `// the above approach ` `import` `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 Code  ` `public` `static` `void` `main(String[] args) ` `{  ` `    ``int` `n = ``5``;  ` `     `  `    ``maximizedNdigit(n);  ` `}  ` `} ` ` `  `// This code is contributed by sanjoy_62 `

## Python3

 `# Python3 program to implement ` `# the above approach ` `def` `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 Code ` `if` `__name__ ``=``=` `"__main__"``: ` ` `  `    ``n ``=` `5` `    ``maximizedNdigit(n) ` ` `  `# This code is contributed by chitranayal `

## C#

 `// C# program to implement  ` `// the above approach  ` `using` `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 Code  ` `public` `static` `void` `Main() ` `{  ` `    ``int` `n = 5;  ` `     `  `    ``maximizedNdigit(n);  ` `}  ` `} ` ` `  `// This code is contributed by sanjoy_62 `

Output:

```99980
```

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

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : chitranayal, sanjoy_62

Article Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.