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 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++ Program to implement
// the above approach
#include <bits/stdc++.h>
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);
}

#include <stdio.h>

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

<script>

// JavaScript Program to implement
// the above approach

function maximizedNdigit(n)
{

    let count0s, count9s;
    // If n is divisible by 4
    if (n % 4 == 0) {

        count0s = Math.floor(n / 4);
        count9s = n - Math.floor(n / 4);
    }

    // Otherwise
    else {

        count0s = Math.floor(n / 4) + 1;
        count9s = n - count0s;
        count0s--;
    }

    while (count9s--)
        document.write('9');

    if (n % 4 != 0)
        document.write('8');

    while (count0s--)
        document.write('0');
    document.write("<br>");
}

// Driver Code

    let n = 5;
    maximizedNdigit(n);


// This code is contributed by Surbhi Tyagi.

</script>

99980

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