Number of unique permutations starting with 1 of a Binary String

Given a binary string composed of 0’s and 1’s. The task is to find the number of unique permutation of the string which starts with 1.

Note: Since the answer can be very large, print the answer under modulo 109 + 7.

Examples:

Input : str ="10101001001"
Output : 210

Input : str ="101110011"
Output : 56

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

The idea is to first find the count of 1’s and the count of 0’s in the given string. Now let us consider that the string is of length and the string consists of at least one 1. Let the number of 1’s be and the number of 0’s be . Out of n number of 1’s we have to place one 1 at the beginning of the string so we have n-1 1’s left and m 0’s w have to permute these (n-1) 1’s and m 0’s in length (L-1) of the string.

Therefore, the number of permutation will be:

(L-1)! / ((n-1)!*(m)!)

Below is the implementation of the above idea:

C++

 // C++ program to find number of unique permutations // of a binary string starting with 1    #include using namespace std;    #define MAX 1000003 #define mod 1000000007    // Array to store factorial of i at // i-th index long long fact[MAX];    // Precompute factorials under modulo mod // upto MAX void factorial() {     // factorial of 0 is 1     fact = 1;        for (int i = 1; i < MAX; i++) {         fact[i] = (fact[i - 1] * i) % mod;     } }    // Iterative Function to calculate (x^y)%p in O(log y) long long power(long long x, long long y, long long p) {     long long res = 1; // Initialize result        x = x % p; // Update x if it is more than or     // equal to p        while (y > 0) {         // If y is odd, multiply x with result         if (y & 1)             res = (res * x) % p;            // y must be even now         y = y >> 1; // y = y/2         x = (x * x) % p;     }     return res; }    // Function to find the modular inverse long long inverse(int n) {        return power(n, mod - 2, mod); }    // Function to find the number of permutation // starting with 1 of a binary string int countPermutation(string s) {     // Generate factorials upto MAX     factorial();        int length = s.length(), num1 = 0, num0;     long long count = 0;        // find number of 1's     for (int i = 0; i < length; i++) {         if (s[i] == '1')             num1++;     }        // number of 0's     num0 = length - num1;        // Find the number of permuattion of     // string starting with 1 using the formulae:     // (L-1)! / ((n-1)!*(m)!)     count = (fact[length - 1] *              inverse((fact[num1 - 1] *                      fact[num0]) % mod)) % mod;        return count; }    // Driver code int main() {     string str = "10101001001";        cout << countPermutation(str);        return 0; }

Java

 // Java program to find number of unique permutations  // of a binary string starting with 1       public class Improve {            final static int MAX = 1000003 ;     final static int mod = 1000000007 ;            // Array to store factorial of i at      // i-th index      static long fact[] = new long [MAX];             // Pre-compute factorials under modulo mod      // upto MAX      static void factorial()      {          // factorial of 0 is 1          fact = 1;                   for (int i = 1; i < MAX; i++) {              fact[i] = (fact[i - 1] * i) % mod;          }      }               // Iterative Function to calculate (x^y)%p in O(log y)      static long power(long x, long y, long p)      {          long res = 1; // Initialize result                   x = x % p; // Update x if it is more than or          // equal to p                   while (y > 0) {              // If y is odd, multiply x with result              if (y % 2 != 0)                  res = (res * x) % p;                       // y must be even now              y = y >> 1; // y = y/2              x = (x * x) % p;          }          return res;      }               // Function to find the modular inverse      static long inverse(int n)      {                   return power(n, mod - 2, mod);      }               // Function to find the number of permutation      // starting with 1 of a binary string      static int countPermutation(String s)      {          // Generate factorials upto MAX          factorial();                   int length = s.length(), num1 = 0, num0;          long count = 0;                   // find number of 1's          for (int i = 0; i < length; i++) {              if (s.charAt(i) == '1')                  num1++;          }                   // number of 0's          num0 = length - num1;                   // Find the number of permuattion of          // string starting with 1 using the formulae:          // (L-1)! / ((n-1)!*(m)!)          count = (fact[length - 1] *                   inverse((int) ((fact[num1 - 1] *                           fact[num0]) % mod))) % mod;                   return (int) count;      }             // Driver code     public static void main(String args[])     {            String str = "10101001001";                           System.out.println(countPermutation(str));      }     // This Code is contributed by ANKITRAI1 }

Python 3

 # Python 3 program to find number  # of unique permutations of a # binary string starting with 1 MAX = 1000003 mod = 1000000007    # Array to store factorial of  # i at i-th index fact =  * MAX    # Precompute factorials under  # modulo mod upto MAX def factorial():            # factorial of 0 is 1     fact = 1        for i in range(1, MAX):         fact[i] = (fact[i - 1] * i) % mod    # Iterative Function to calculate # (x^y)%p in O(log y) def power(x, y, p):            res = 1 # Initialize result        x = x % p # Update x if it is                # more than or equal to p        while (y > 0) :                    # If y is odd, multiply         # x with result         if (y & 1):             res = (res * x) % p            # y must be even now         y = y >> 1 # y = y/2         x = (x * x) % p            return res    # Function to find the modular inverse def inverse( n):     return power(n, mod - 2, mod)    # Function to find the number of  # permutation starting with 1 of  # a binary string def countPermutation(s):            # Generate factorials upto MAX     factorial()        length = len(s)      num1 = 0     count = 0        # find number of 1's     for i in range(length) :         if (s[i] == '1'):             num1 += 1                    # number of 0's     num0 = length - num1        # Find the number of permuattion      # of string starting with 1 using      # the formulae: (L-1)! / ((n-1)!*(m)!)     count = (fact[length - 1] *             inverse((fact[num1 - 1] *                      fact[num0]) % mod)) % mod        return count    # Driver code if __name__ =="__main__":     s = "10101001001"        print(countPermutation(s))    # This code is contributed  # by ChitraNayal

C#

 // C# program to find number of  // unique permutations of a // binary string starting with 1  using System;        class GFG {  static int MAX = 1000003 ;  static int mod = 1000000007 ;     // Array to store factorial  // of i at i-th index  static long []fact = new long [MAX];     // Pre-compute factorials under  // modulo mod upto MAX  static void factorial()  {      // factorial of 0 is 1      fact = 1;             for (int i = 1; i < MAX; i++)      {          fact[i] = (fact[i - 1] * i) % mod;      }  }         // Iterative Function to calculate  // (x^y)%p in O(log y)  static long power(long x,                    long y, long p)  {      long res = 1; // Initialize result             x = x % p; // Update x if it is more                 // than or equal to p             while (y > 0)      {          // If y is odd, multiply          // x with result          if (y % 2 != 0)              res = (res * x) % p;                 // y must be even now          y = y >> 1; // y = y/2          x = (x * x) % p;      }      return res;  }         // Function to find the modular inverse  static long inverse(int n)  {      return power(n, mod - 2, mod);  }         // Function to find the number of  // permutation starting with 1 of // a binary string  static int countPermutation(string s)  {      // Generate factorials upto MAX      factorial();             int length = s.Length, num1 = 0, num0;      long count = 0;             // find number of 1's      for (int i = 0; i < length; i++)      {          if (s[i] == '1')              num1++;      }             // number of 0's      num0 = length - num1;             // Find the number of permuattion      // of string starting with 1 using      // the formulae: (L-1)! / ((n-1)!*(m)!)      count = (fact[length - 1] *               inverse((int) ((fact[num1 - 1] *                      fact[num0]) % mod))) % mod;             return (int) count;  }     // Driver code  public static void Main()  {      string str = "10101001001";                 Console.WriteLine(countPermutation(str));  }  }     // This code is contributed // by anuj_67

Output:

210

Time Complexity: O(n), where n is the length of the string.

My Personal Notes arrow_drop_up Second year Department of Information Technology Jadavpur University

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 : AnkitRai01, vt_m, chitranayal

Article Tags :
Practice Tags :

Be the First to upvote.

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