Open In App

Permutations of string such that no two vowels are adjacent

Improve
Improve
Like Article
Like
Save
Share
Report

Given a string consisting of vowels and consonants. The task is to find the number of ways in which the characters of the string can be arranged such that no two vowels are adjacent to each other. 
Note: Given that No. of vowels <= No. of consonants.

Examples: 

Input: str = "permutation"
Output : 907200

Input: str = "geeksforgeeks"
Output: 3175200 

Approach: 
Consider the above example string “permutation”: 

  • First place all of the consonants in the alternate places like below:
-- p -- r -- m -- t -- t -- n --
  • Number of ways to place consonants = 6! / 2!. as t          appears twice and should be considered once.
  • Then place the vowels in the remaining positions. We have 7 remaining positions and 5 vowels to fill these 7 places. 
    Therefore, the number of ways to fill vowels = $7_{C_5} \times 5!$          .
Total no. of ways =  (6! / 2!) \times 7_{C_5} \times 5!= 907200

Suppose, in a string, the number of vowels is vowelCount and the number of consonants is consonantCount

Therefore,
Total ways = (consonantCount! / duplicateConsonant!) * C(consonantCount+1 , vowelCount) * (vowelCount! / duplicateVowel!)

Algorithm:

  • Create a static method named “factorial” that takes an integer n as input and returns its factorial.                                                                          
  • Create a variable named “fact” and initialize it to 1.                                                                                                                                              
  • Traverse with the loop from 2 to n and update the value of fact as fact multiplied by the loop variable.                                                            
  • Return the value of “fact”.
  • Create a static method named “ncr” that takes two integers n and r as input and returns the value of n choose r.                                                  
  • Return the value of factorial(n) divided by the product of factorial(r) and factorial(n-r).
  • Create a static method named “countWays” that takes a String str as input and returns an integer representing the number of permutations of the string such that no two vowels are adjacent                                                                                                                                                          
  • Create an integer array named “freq” with size 26 and initialize all its elements as 0.                                                                                          
  • Start a for loop from 0 to 25 and initialize each element of freq as 0.                                                                                                                  
  • Create two integer variables named “nvowels” and “nconsonants” initialize them to 0.                                                                                      
  • Create three integer variables named “vplaces”, “cways”, and “vways”.                                                                                                                
  • Start a for loop from 0 to the length of the input string str and update the frequency of each character in the string in the freq array.          
  • Start a for loop from 0 to 25 and update the values of “nvowels” and “consonants” based on the frequency of vowels and consonants in          the input string str.                                                                                                                                                                                                
  • Calculate the number of “vplaces” as “consonants” + 1.                                                                                                                                      
  • Calculate the number of ways to fill the consonants as factorial(nconsonants) divided by the product of factorials of the                                    
  • frequencies of each consonant character.                                                                                                                                                                       
  • Calculate the number of ways to place the vowels as ncr(vplaces, nvowels) multiplied by factorial(nvowels) divided by the product of factorials of the frequencies of each vowel character.                                                                                                             
  • Return the product of cways and vways as the final output.

Below is the implementation of the above approach: 

C++

// CPP program to count permutations of string
// such that no two vowels are adjacent
 
#include <bits/stdc++.h>
using namespace std;
 
// Factorial of a number
int factorial(int n)
{
 
    int fact = 1;
    for (int i = 2; i <= n; i++)
        fact = fact * i;
 
    return fact;
}
 
// Function to find c(n, r)
int ncr(int n, int r)
{
    return factorial(n) / (factorial(r) * factorial(n - r));
}
 
// Function to count permutations of string
// such that no two vowels are adjacent
int countWays(string str)
{
    int freq[26] = { 0 };
    int nvowels = 0, nconsonants = 0;
 
    int vplaces, cways, vways;
 
    // Finding the frequencies of
    // the characters
    for (int i = 0; i < str.length(); i++)
        ++freq[str[i] - 'a'];
 
    // finding the no. of vowels and
    // consonants in given word
    for (int i = 0; i < 26; i++) {
 
        if (i == 0 || i == 4 || i == 8
            || i == 14 || i == 20)
            nvowels += freq[i];
        else
            nconsonants += freq[i];
    }
    // finding places for the vowels
    vplaces = nconsonants + 1;
 
    // ways to fill consonants 6! / 2!
    cways = factorial(nconsonants);
    for (int i = 0; i < 26; i++) {
        if (i != 0 && i != 4 && i != 8 && i != 14
            && i != 20 && freq[i] > 1) {
 
            cways = cways / factorial(freq[i]);
        }
    }
 
    // ways to put vowels 7C5 x 5!
    vways = ncr(vplaces, nvowels) * factorial(nvowels);
    for (int i = 0; i < 26; i++) {
        if (i == 0 || i == 4 || i == 8 || i == 14
            || i == 20 && freq[i] > 1) {
            vways = vways / factorial(freq[i]);
        }
    }
 
    return cways * vways;
}
 
// Driver code
int main()
{
    string str = "permutation";
 
    cout << countWays(str) << endl;
 
    return 0;
}

                    

Java

// Java program to count permutations of string
// such that no two vowels are adjacent
 
class GFG
{
             
        // Factorial of a number
        static int factorial(int n)
        {
         
            int fact = 1;
            for (int i = 2; i <= n; i++)
                fact = fact * i;
         
            return fact;
        }
         
        // Function to find c(n, r)
        static int ncr(int n, int r)
        {
            return factorial(n) / (factorial(r) * factorial(n - r));
        }
         
        // Function to count permutations of string
        // such that no two vowels are adjacent
        static int countWays(String str)
        {
            int freq[]=new int[26];
             
            for(int i=0;i<26;i++)
            {
                freq[i]=0;
            }
             
            int nvowels = 0, nconsonants = 0;
         
            int vplaces, cways, vways;
         
            // Finding the frequencies of
            // the characters
            for (int i = 0; i < str.length(); i++)
                ++freq[str.charAt(i) - 'a'];
         
            // finding the no. of vowels and
            // consonants in given word
            for (int i = 0; i < 26; i++) {
         
                if (i == 0 || i == 4 || i == 8
                    || i == 14 || i == 20)
                    nvowels += freq[i];
                else
                    nconsonants += freq[i];
            }
            // finding places for the vowels
            vplaces = nconsonants + 1;
         
            // ways to fill consonants 6! / 2!
            cways = factorial(nconsonants);
            for (int i = 0; i < 26; i++) {
                if (i != 0 && i != 4 && i != 8 && i != 14
                    && i != 20 && freq[i] > 1) {
         
                    cways = cways / factorial(freq[i]);
                }
            }
         
            // ways to put vowels 7C5 x 5!
            vways = ncr(vplaces, nvowels) * factorial(nvowels);
            for (int i = 0; i < 26; i++) {
                if (i == 0 || i == 4 || i == 8 || i == 14
                    || i == 20 && freq[i] > 1) {
                    vways = vways / factorial(freq[i]);
                }
            }
         
            return cways * vways;
        }
         
        // Driver code
        public static void main(String []args)
        {
            String str = "permutation";
         
            System.out.println(countWays(str));
         
         
        }
}
 
// This code is contributed
// by ihritik

                    

Python3

# Python3 program to count permutations of
# string such that no two vowels are adjacent
 
# Factorial of a number
def factorial(n) :
 
    fact = 1;
    for i in range(2, n + 1) :
        fact = fact * i
 
    return fact
 
# Function to find c(n, r)
def ncr(n, r) :
     
    return factorial(n) // (factorial(r) *
                            factorial(n - r))
 
# Function to count permutations of string
# such that no two vowels are adjacent
def countWays(string) :
 
    freq = [0] * 26
    nvowels, nconsonants = 0, 0
 
    # Finding the frequencies of
    # the characters
    for i in range(len(string)) :
        freq[ord(string[i]) - ord('a')] += 1
 
    # finding the no. of vowels and
    # consonants in given word
    for i in range(26) :
 
        if (i == 0 or i == 4 or i == 8
            or i == 14 or i == 20) :
            nvowels += freq[i]
        else :
            nconsonants += freq[i]
     
    # finding places for the vowels
    vplaces = nconsonants + 1
 
    # ways to fill consonants 6! / 2!
    cways = factorial(nconsonants)
    for i in range(26) :
        if (i != 0 and i != 4 and i != 8 and
            i != 14 and i != 20 and freq[i] > 1) :
 
            cways = cways // factorial(freq[i])
 
    # ways to put vowels 7C5 x 5!
    vways = ncr(vplaces, nvowels) * factorial(nvowels)
    for i in range(26) :
        if (i == 0 or i == 4 or i == 8 or i == 14
            or i == 20 and freq[i] > 1) :
            vways = vways // factorial(freq[i])
 
    return cways * vways;
 
# Driver code
if __name__ == "__main__" :
 
    string = "permutation"
 
    print(countWays(string))
 
# This code is contributed by Ryuga

                    

C#

// C# program to count permutations of string
// such that no two vowels are adjacent
 
using System;
class GFG
{
             
        // Factorial of a number
        static int factorial(int n)
        {
         
            int fact = 1;
            for (int i = 2; i <= n; i++)
                fact = fact * i;
         
            return fact;
        }
         
        // Function to find c(n, r)
        static int ncr(int n, int r)
        {
            return factorial(n) / (factorial(r) * factorial(n - r));
        }
         
        // Function to count permutations of string
        // such that no two vowels are adjacent
        static int countWays(String str)
        {
            int []freq=new int[26];
             
            for(int i=0;i<26;i++)
            {
                freq[i]=0;
            }
             
            int nvowels = 0, nconsonants = 0;
         
            int vplaces, cways, vways;
         
            // Finding the frequencies of
            // the characters
            for (int i = 0; i < str.Length; i++)
                ++freq[str[i] - 'a'];
         
            // finding the no. of vowels and
            // consonants in given word
            for (int i = 0; i < 26; i++) {
         
                if (i == 0 || i == 4 || i == 8
                    || i == 14 || i == 20)
                    nvowels += freq[i];
                else
                    nconsonants += freq[i];
            }
            // finding places for the vowels
            vplaces = nconsonants + 1;
         
            // ways to fill consonants 6! / 2!
            cways = factorial(nconsonants);
            for (int i = 0; i < 26; i++) {
                if (i != 0 && i != 4 && i != 8 && i != 14
                    && i != 20 && freq[i] > 1) {
         
                    cways = cways / factorial(freq[i]);
                }
            }
         
            // ways to put vowels 7C5 x 5!
            vways = ncr(vplaces, nvowels) * factorial(nvowels);
            for (int i = 0; i < 26; i++) {
                if (i == 0 || i == 4 || i == 8 || i == 14
                    || i == 20 && freq[i] > 1) {
                    vways = vways / factorial(freq[i]);
                }
            }
         
            return cways * vways;
        }
         
        // Driver code
        public static void Main()
        {
            String str = "permutation";
         
            Console.WriteLine(countWays(str));
         
         
        }
}
 
// This code is contributed
// by ihritik

                    

PHP

<?php
// CPP program to count permutations of string
// such that no two vowels are adjacent
  
// Factorial of a number
function factorial($n)
{
    $fact = 1;
    for ($i = 2; $i <= $n; $i++)
        $fact = $fact * $i;
  
    return $fact;
}
  
// Function to find c(n, r)
function ncr($n, $r)
{
    return factorial($n) / (factorial($r) * factorial($n - $r));
}
  
// Function to count permutations of string
// such that no two vowels are adjacent
function countWays($str)
{
    $freq = array_fill(0,26,NULL);
    $nvowels = 0;
    $nconsonants = 0;
  
    // Finding the frequencies of
    // the characters
    for ($i = 0; $i < strlen($str); $i++)
        ++$freq[ord($str[$i]) - ord('a')];
  
    // finding the no. of vowels and
    // consonants in given word
    for ($i = 0; $i < 26; $i++) {
  
        if ($i == 0 || $i == 4 || $i == 8
            || $i == 14 || $i == 20)
            $nvowels += $freq[$i];
        else
            $nconsonants += $freq[$i];
    }
    // finding places for the vowels
    $vplaces = $nconsonants + 1;
  
    // ways to fill consonants 6! / 2!
    $cways = factorial($nconsonants);
    for ($i = 0; $i < 26; $i++) {
        if ($i != 0 && $i != 4 && $i != 8 && $i != 14
            && $i != 20 && $freq[$i] > 1) {
  
            $cways = $cways / factorial($freq[$i]);
        }
    }
  
    // ways to put vowels 7C5 x 5!
    $vways = ncr($vplaces, $nvowels) * factorial($nvowels);
    for ($i = 0; $i < 26; $i++) {
        if ($i == 0 || $i == 4 || $i == 8 || $i == 14
            || $i == 20 && $freq[$i] > 1) {
            $vways = $vways / factorial($freq[$i]);
        }
    }
    return $cways * $vways;
}
  
// Driver code
 
$str = "permutation";
echo countWays($str)."\n";
return 0;
// this code is contributed by Ita_c.
?>

                    

Javascript

<script>
// Javascript program to count permutations of string
// such that no two vowels are adjacent
     
    // Factorial of a number
    function factorial(n)
    {
        let fact = 1;
            for (let i = 2; i <= n; i++)
                fact = fact * i;
           
            return fact;
    }
     
     // Function to find c(n, r)
    function ncr(n,r)
    {
        return Math.floor(factorial(n) / (factorial(r) * factorial(n - r)));
    }
     
    // Function to count permutations of string
        // such that no two vowels are adjacent
    function countWays(str)
    {
 
            let freq=new Array(26);
               
              for(let i=0;i<26;i++)
            {
                freq[i]=0;
            }
               
            let nvowels = 0, nconsonants = 0;
           
            let vplaces, cways, vways;
           
            // Finding the frequencies of
            // the characters
            for (let i = 0; i < str.length; i++)
                ++freq[str[i].charCodeAt(0) - 'a'.charCodeAt(0)];
           
            // finding the no. of vowels and
            // consonants in given word
            for (let i = 0; i < 26; i++) {
           
                if (i == 0 || i == 4 || i == 8
                    || i == 14 || i == 20)
                    nvowels += freq[i];
                else
                    nconsonants += freq[i];
            }
            // finding places for the vowels
            vplaces = nconsonants + 1;
           
            // ways to fill consonants 6! / 2!
            cways = factorial(nconsonants);
            for (let i = 0; i < 26; i++) {
                if (i != 0 && i != 4 && i != 8 && i != 14
                    && i != 20 && freq[i] > 1) {
           
                    cways = Math.floor(cways / factorial(freq[i]));
                }
            }
           
            // ways to put vowels 7C5 x 5!
            vways = ncr(vplaces, nvowels) * factorial(nvowels);
            for (let i = 0; i < 26; i++) {
                if (i == 0 || i == 4 || i == 8 || i == 14
                    || i == 20 && freq[i] > 1) {
                    vways = Math.floor(vways / factorial(freq[i]));
                }
            }
           
            return cways * vways;
             
    }
     
     // Driver code
    let str = "permutation";
    document.write(countWays(str));
     
     
     
// This code is contributed by rag2127
</script>

                    

Output: 

907200

Time Complexity: O(|str|)

Auxiliary Space: O(1)
 



Last Updated : 03 Apr, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads