 Open in App
Not now

# 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 Code``int` `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 Code``int` `main()``{``  ``int` `n = 5;``  ``maximizedNdigit(n);``  ``return` `0;``}` `// This code is contributed by phalashi.`

## 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`

## Javascript

 ``

Output:

`99980`

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

My Personal Notes arrow_drop_up