Print N-bit binary numbers having more 1’s than 0’s in all prefixes

Difficulty Level : Medium
Last Updated : 17 Nov, 2020

Given a positive integer n, print all n-bit binary numbers having more 1’s than 0’s for any prefix of the number.

Examples:

Input : n = 2
Output : 11 10

Input : n = 4
Output : 1111 1110 1101 1100 1011 1010

A simple but not efficient solution will be to generate all N-bit binary numbers and print those numbers that satisfy the conditions. The time complexity of this solution is exponential.

An efficient solution is to generate only those N-bit numbers that satisfy the given conditions. We use recursion. At each point in the recursion, we append 0 and 1 to the partially formed number and recur with one less digit.

C++

// CPP program to print all N-bit binary
#include <bits/stdc++.h>
using namespace std;
 
/* function to generate n  digit numbers*/
void printRec(string number, int extraOnes,
              int remainingPlaces)
{
    /* if number generated */
    if (0 == remainingPlaces) {
        cout << number << " ";
        return;
    }
 
    /* Append 1 at the current number and reduce
       the remaining places by one */
    printRec(number + "1", extraOnes + 1,
             remainingPlaces - 1);
 
    /* If more ones than zeros, append 0 to the
       current number and reduce the remaining
       places by one*/
    if (0 < extraOnes)
        printRec(number + "0", extraOnes - 1,
                 remainingPlaces - 1);
}
 
void printNums(int n)
{
    string str = "";
    printRec(str, 0, n);
}
 
// Driver code
int main()
{
    int n = 4;
   
    // Function call
    printNums(n);
    return 0;
}

Java

// java program to print all N-bit binary
import java.io.*;
 
class GFG {
    // function to generate n digit numbers
    static void printRec(String number, 
                         int extraOnes,
                         int remainingPlaces)
    {
        // if number generated
        if (0 == remainingPlaces) {
            System.out.print(number + " ");
            return;
        }
 
        // Append 1 at the current number and
        // reduce the remaining places by one
        printRec(number + "1", extraOnes + 1,
                 remainingPlaces - 1);
 
        // If more ones than zeros, append 0 to the
        // current number and reduce the remaining
        // places by one
        if (0 < extraOnes)
            printRec(number + "0", extraOnes - 1,
                     remainingPlaces - 1);
    }
 
    static void printNums(int n)
    {
        String str = "";
        printRec(str, 0, n);
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int n = 4;
       
        // Function call
        printNums(n);
    }
}
 
// This code is contributed by vt_m

Python3

# Python 3 program to print all N-bit binary
 
# function to generate n digit numbers
 
 
def printRec(number, extraOnes, remainingPlaces):
 
    # if number generated
    if (0 == remainingPlaces):
        print(number, end=" ")
        return
 
    # Append 1 at the current number and
    # reduce the remaining places by one
    printRec(number + "1", extraOnes + 1,
             remainingPlaces - 1)
 
    # If more ones than zeros, append 0 to
    # the current number and reduce the
    # remaining places by one
    if (0 < extraOnes):
        printRec(number + "0", extraOnes - 1,
                 remainingPlaces - 1)
 
 
def printNums(n):
    str = ""
    printRec(str, 0, n)
 
 
# Driver Code
if __name__ == '__main__':
    n = 4
      
    # Function call
    printNums(n)
 
# This code is contributed by
# Surendra_Gangwar

C#

// C# program to print all N-bit binary
using System;
 
class GFG {
 
    // function to generate n digit numbers
    static void printRec(String number, 
                         int extraOnes,
                         int remainingPlaces)
    {
 
        // if number generated
        if (0 == remainingPlaces) 
        {
            Console.Write(number + " ");
            return;
        }
 
        // Append 1 at the current number and
        // reduce the remaining places by one
        printRec(number + "1", extraOnes + 1,
                 remainingPlaces - 1);
 
        // If more ones than zeros, append
        // 0 to the current number and
        // reduce the remaining places
        // by one
        if (0 < extraOnes)
            printRec(number + "0", extraOnes - 1,
                     remainingPlaces - 1);
    }
    static void printNums(int n)
    {
        String str = "";
        printRec(str, 0, n);
    }
 
    // Driver code
    public static void Main()
    {
        int n = 4;
       
        // Function call
        printNums(n);
    }
}
 
// This code is contributed by Nitin Mittal.

PHP

<?php
// PHP program to print all N-bit binary
 
// function to generate n digit numbers
function printRec($number, $extraOnes, 
                  $remainingPlaces)
{
    // if number generated 
    if (0 == $remainingPlaces) 
    {
        echo( $number . " ");
        return;
    }
 
    // Append 1 at the current number and 
    // reduce the remaining places by one 
    printRec($number . "1", $extraOnes + 1, 
                      $remainingPlaces - 1);
 
    // If more ones than zeros, append 0 to the 
    // current number and reduce the remaining 
    // places by one
    if (0 < $extraOnes) 
        printRec($number . "0", $extraOnes - 1, 
                          $remainingPlaces - 1); 
}
 
function printNums($n)
{
    $str = "";
    printRec($str, 0, $n);
}
 
// Driver Code
$n = 4;
 
// Function call
printNums($n);
 
// This code is contributed by Mukul Singh. 

Output

1111 1110 1101 1100 1011 1010

A non-recursive solution also exists, the idea is to directly generate the numbers in the range of 2^N to 2^(N-1), then quire only these which satisfies the condition:

C++

// CPP program to print all N-bit binary
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
 
 
// Function to get the biary representation
// of the number N
string getBinaryRep(int N, int num_of_bits)
{
    string r = "";
    num_of_bits--;
   
    // loop for each bit
    while (num_of_bits >= 0) 
    {
        if (N & (1 << num_of_bits))
            r.append("1");
        else
            r.append("0");
        num_of_bits--;
    }
    return r;
}
 
vector<string> NBitBinary(int N)
{
    vector<string> r;
    int first = 1 << (N - 1);
    int last = first * 2;
     
    // generate numbers in the range of (2^N)-1 to 2^(N-1)
    // inclusive
    for (int i = last - 1; i >= first; --i)
    {
        int zero_cnt = 0;
        int one_cnt = 0;
        int t = i;
        int num_of_bits = 0;
         
        // longest prefix check
        while (t) 
        {
            if (t & 1)
                one_cnt++;
            else
                zero_cnt++;
            num_of_bits++;
            t = t >> 1;
        }
       
        // if counts of 1 is greater than
        // counts of zero
        if (one_cnt >= zero_cnt)
        {
            // do sub-prefixes check
            bool all_prefix_match = true;
            int msk = (1 << num_of_bits) - 2;
            int prefix_shift = 1;
            while (msk) 
            {
 
                int prefix = (msk & i) >> prefix_shift;
                int prefix_one_cnt = 0;
                int prefix_zero_cnt = 0;
                while (prefix)
                {
                    if (prefix & 1)
                        prefix_one_cnt++;
                    else
                        prefix_zero_cnt++;
                    prefix = prefix >> 1;
                }
                if (prefix_zero_cnt > prefix_one_cnt)
                {
                    all_prefix_match = false;
                    break;
                }
                prefix_shift++;
                msk = msk & (msk << 1);
            }
            if (all_prefix_match)
            {
                r.push_back(getBinaryRep(i, num_of_bits));
            }
        }
    }
    return r;
}
 
// Driver code
int main()
{
    int n = 4;
   
    // Function call
    vector<string> results = NBitBinary(n);
    for (int i = 0; i < results.size(); ++i)
        cout << results[i] << " ";
    cout << endl;
    return 0;
}

Python3

# Python3 program to print 
# all N-bit binary
 
# Function to get the biary 
# representation of the number N
def getBinaryRep(N, num_of_bits):
 
    r = "";
    num_of_bits -= 1
   
    # loop for each bit
    while (num_of_bits >= 0):    
        if (N & (1 << num_of_bits)):
            r += ("1");
        else:
            r += ("0");
        num_of_bits -= 1
     
    return r;
 
def NBitBinary(N):
 
    r = []
    first = 1 << (N - 1);
    last = first * 2;
     
    # generate numbers in the range 
    # of (2^N)-1 to 2^(N-1) inclusive
    for i in range (last - 1,
                    first - 1, -1):    
        zero_cnt = 0;
        one_cnt = 0;
        t = i;
        num_of_bits = 0;
         
        # longest prefix check
        while (t):        
            if (t & 1):
                one_cnt += 1
            else:
                zero_cnt += 1
            num_of_bits += 1
            t = t >> 1;        
       
        # if counts of 1 is greater 
        # than counts of zero
        if (one_cnt >= zero_cnt):
         
            # do sub-prefixes check
            all_prefix_match = True;
            msk = (1 << num_of_bits) - 2;
            prefix_shift = 1;
             
            while (msk):            
                prefix = ((msk & i) >> 
                           prefix_shift);
                prefix_one_cnt = 0;
                prefix_zero_cnt = 0;
                 
                while (prefix):                
                    if (prefix & 1):
                        prefix_one_cnt += 1
                    else:
                        prefix_zero_cnt += 1
                    prefix = prefix >> 1;
                 
                if (prefix_zero_cnt > 
                    prefix_one_cnt):                
                    all_prefix_match = False;
                    break;
                 
                prefix_shift += 1
                msk = msk & (msk << 1);
             
            if (all_prefix_match):            
                r.append(getBinaryRep(i, 
                                      num_of_bits));          
    return r
 
# Driver code
if __name__ == "__main__":
  
    n = 4;
   
    # Function call
    results = NBitBinary(n);
    for i in range (len(results)):
        print (results[i], 
               end = " ")
    print ()
     
# This code is contributed by Chitranayal

Output

1111 1110 1101 1100 1011 1010

This article is contributed by Pranav. 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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes

Related Articles

C++

Java

Python3

C#

PHP

C++

Python3