Open In App

Generate all binary permutations such that there are more or equal 1’s than 0’s before every point in all permutations

Generate all permutations of a given length such that every permutation has more or equals 1’s than 0’s in all prefixes of the permutation.
 

Examples: 

Input: len = 4
Output: 1111 1110 1101 1100 1011 1010
Note that a permutation like 0101 can not be in output because
there are more 0's from index 0 to 2 in this permutation.

Input: len = 3
Output: 111 110 101

Input: len = 2
Output: 11 10 

Like permutation generation problems, recursion is the simplest approach to solve this. We start with an empty string, attach 1 to it and recur. While recurring, if we find more 1’s at any point, we append a 0 and make one more recursive call.
Below is the implementation: 




// C++ program to generate all permutations of 1's and 0's such that
// every permutation has more 1's than 0's at all indexes.
#include <iostream>
#include <cstring>
using namespace std;
 
// ones & zeroes --> counts of 1's and 0's in current string 'str'
// len ---> desired length of every permutation
void generate(int ones, int zeroes, string str, int len)
{
    // If length of current string becomes same as desired length
    if (len == str.length())
    {
        cout << str << "  ";
        return;
    }
 
    // Append a 1 and recur
    generate(ones+1, zeroes, str+"1", len);
 
    // If there are more 1's, append a 0 as well, and recur
    if (ones > zeroes)
        generate(ones, zeroes+1, str+"0", len);
}
 
// Driver program to test above function
int main()
{
    string str = "";
    generate(0, 0, str, 4);
    return 0;
}




// Java program to generate all permutations of 1's and 0's such that
// every permutation has more 1's than 0's at all indexes.
 
class GFG {
 
// ones & zeroes --> counts of 1's and 0's in current string 'str'
// len ---> desired length of every permutation
    static void generate(int ones, int zeroes, String str, int len) {
        // If length of current string becomes same as desired length
        if (len == str.length()) {
            System.out.print(str + " ");
            return;
        }
 
        // Append a 1 and recur
        generate(ones + 1, zeroes, str + "1", len);
 
        // If there are more 1's, append a 0 as well, and recur
        if (ones > zeroes) {
            generate(ones, zeroes + 1, str + "0", len);
        }
    }
 
// Driver program to test above function
    public static void main(String[] args) {
        String str = "";
        generate(0, 0, str, 4);
    }
}
 
/* This Java code is contributed by PrinciRaj1992*/




# Python 3 program to generate all permutations of 1's and 0's such that
# every permutation has more 1's than 0's at all indexes.
 
# ones & zeroes --> counts of 1's and 0's in current string 'str'
# len ---> desired length of every permutation
def generate(ones, zeroes, str, len1):
    # If length of current string becomes same as desired length
    if (len1 == len(str)):
        print(str,end =" ")
        return
     
    # Append a 1 and recur
    generate(ones+1, zeroes, str+"1", len1)
 
    # If there are more 1's, append a 0 as well, and recur
    if (ones > zeroes):
        generate(ones, zeroes+1, str+"0", len1)
 
# Driver program to test above function
if __name__ == '__main__':
    str = ""
    generate(0, 0, str, 4)
 
# This code is contributed by
# Surendra_Gangwar




// C# program to generate all permutations of 1's and 0's such that
// every permutation has more 1's than 0's at all indexes.
  
using System;
                     
 
public class GFG {
  
// ones & zeroes --> counts of 1's and 0's in current string 'str'
// len ---> desired length of every permutation
    static void generate(int ones, int zeroes, String str, int len) {
        // If length of current string becomes same as desired length
        if (len == str.Length) {
            Console.Write(str + " ");
            return;
        }
  
        // Append a 1 and recur
        generate(ones + 1, zeroes, str + "1", len);
  
        // If there are more 1's, append a 0 as well, and recur
        if (ones > zeroes) {
            generate(ones, zeroes + 1, str + "0", len);
        }
    }
  
// Driver program to test above function
    public static void Main() {
        String str = "";
        generate(0, 0, str, 4);
    }
}
  
/* This Java code is contributed by 29AjayKumar*/




<script>
      // JavaScript program to generate all permutations of 1's and 0's such that
      // every permutation has more 1's than 0's at all indexes.
 
      // ones & zeroes --> counts of 1's and 0's in current string 'str'
      // len ---> desired length of every permutation
      function generate(ones, zeroes, str, len) {
          // If length of current string becomes same as desired length
        if (len === str.length) {
            document.write(str + " ");
              return;
        }
 
        // Append a 1 and recur
        generate(ones + 1, zeroes, str + "1", len);
 
        // If there are more 1's, append a 0 as well, and recur
        if (ones > zeroes) {
              generate(ones, zeroes + 1, str + "0", len);
        }
      }
 
      // Driver program to test above function
      var str = "";
      generate(0, 0, str, 4);
</script>

Output: 

1111  1110  1101  1100  1011  1010

Time Complexity: O(2N), as we are using two recursive calls. Where N is the given length of the string.

Auxiliary Space: O(N)

This article was contributed by Sachin.
 


Article Tags :