排列单词以使元音不一起出现的方式数量

英文单词的长度最多为20个字符。计算排列单词以使元音不一起出现的方式的数量。

注意：如果给定单词中的元音总数为1，则结果应为0。

例子：

Input : allahabad
Output : 7200

Input : geeksforgeeks
Output : 32205600

Input : abcd
Output : 0

由于该词包含元音和辅音。计算排列给定单词的方式总数，然后减去将所有元音组合在一起的方式总数。要计算方法的总数，我们将使用以下公式：

No of ways = (n!) / (r1! * r2! * ... * rk!)

其中n是单词中不同字符的数量，r1，r2…rk是相同类型字符的频率。
为了计算使所有元音一起出现的方式的数量，我们将所有元音的组视为单个字符，并使用上述公式，我们将计算将所有元音在一起的方式的总数。现在，从获得结果的方法总数中减去它。

下面是上述方法的实现：

C++

// C++ code for above approach
#include 
#define ll long long int
using namespace std;
 
// Function to check if a character is vowel or consonent
bool isVowel(char ch)
{
    if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u')
        return true;
    else
        return false;
}
 
// Function to calculate factorial of a number
ll fact(ll n)
{
    if (n < 2)
        return 1;
    return n * fact(n - 1);
}
 
// Calculating no of ways for arranging vowels
ll only_vowels(map& freq)
{
    ll denom = 1;
    ll cnt_vwl = 0;
 
    // Iterate the map and count the number of vowels and calculate
    // no of ways to arrange vowels
    for (auto itr = freq.begin(); itr != freq.end(); itr++) {
        if (isVowel(itr->first)) {
            denom *= fact(itr->second);
            cnt_vwl += itr->second;
        }
    }
 
    return fact(cnt_vwl) / denom;
}
 
// calculating no of ways to arrange the given word such that all vowels
// come together
ll all_vowels_together(map& freq)
{
    // calculate no of ways to arrange vowels
    ll vow = only_vowels(freq);
 
    // to store denominator of fraction
    ll denom = 1;
 
    // count of consonents
    ll cnt_cnst = 0;
 
    for (auto itr = freq.begin(); itr != freq.end(); itr++) {
        if (!isVowel(itr->first)) {
            denom *= fact(itr->second);
            cnt_cnst += itr->second;
        }
    }
 
    // calculate the number of ways to arrange the word such that
    // all vowels come together
    ll ans = fact(cnt_cnst + 1) / denom;
 
    return (ans * vow);
}
 
// To calculate total number of permutations
ll total_permutations(map& freq)
{
    // To store length of the given word
    ll cnt = 0;
 
    // denominator of fraction
    ll denom = 1;
 
    for (auto itr = freq.begin(); itr != freq.end(); itr++) {
        denom *= fact(itr->second);
        cnt += itr->second;
    }
 
    // retur total number of permutations of the given word
    return fact(cnt) / denom;
}
 
// Function to calculate number of permutations such that
// no vowels come together
ll no_vowels_together(string& word)
{
    // to store frequency of character
    map freq;
 
    // count frequency of all characters
    for (int i = 0; i < word.size(); i++) {
        char ch = tolower(word[i]);
        freq[ch]++;
    }
 
    // calculate total number of permutations
    ll total = total_permutations(freq);
 
    // calculate total number of permutations such that
    // all vowels come together
    ll vwl_tgthr = all_vowels_together(freq);
 
    // substrat vwl_tgthr from total to get the result
    ll res = total - vwl_tgthr;
 
    // return the result
    return res;
}
 
// Driver code
int main()
{
 
    string word = "allahabad";
    ll ans = no_vowels_together(word);
    cout << ans << endl;
 
    word = "geeksforgeeks";
    ans = no_vowels_together(word);
    cout << ans << endl;
 
    word = "abcd";
    ans = no_vowels_together(word);
    cout << ans << endl;
    return 0;
}

Java

// Java code for above approach
import java.util.*;
import java.lang.*;
class GFG
{
  // Function to check if a character
  // is vowel or consonent
  static boolean isVowel(char ch)
  {
    if (ch == 'a' || ch == 'e' ||
        ch == 'i' || ch == 'o' ||
        ch == 'u')
      return true;
    else
      return false;
  }
 
  // Function to calculate factorial of a number
  static long fact(long n)
  {
    if (n < 2)
    {
      return 1;
    }
    return n * fact(n - 1);
  }
 
  // Calculating no of ways for arranging vowels
  static long only_vowels(HashMap freq)
  {
    long denom = 1;
    long cnt_vwl = 0;
 
    // Iterate the map and count the number
    // of vowels and calculate no of ways
    // to arrange vowels
    for (Map.Entry itr : freq.entrySet())
    {
      if (isVowel(itr.getKey()))
      {
        denom *= fact(itr.getValue());
        cnt_vwl += itr.getValue();
      }
    }
 
    return fact(cnt_vwl) / denom;
  }
 
  // Calculating no of ways to arrange
  // the given word such that all vowels
  // come together
  static long all_vowels_together(HashMap freq)
  {
 
    // Calculate no of ways to arrange vowels
    long vow = only_vowels(freq);
 
    // To store denominator of fraction
    long denom = 1;
 
    // Count of consonents
    long cnt_cnst = 0;
 
    for (Map.Entry itr : freq.entrySet())
    {
      if (!isVowel(itr.getKey()))
      {
        denom *= fact(itr.getValue());
        cnt_cnst += itr.getValue();
      }
    }
 
    // Calculate the number of ways to
    // arrange the word such that
    // all vowels come together
    long ans = fact(cnt_cnst + 1) / denom;
 
    return (ans * vow);
  }
 
  // To calculate total number of permutations
  static long total_permutations(HashMap freq)
  {
 
    // To store length of the given word
    long cnt = 0;
 
    // Denominator of fraction
    long denom = 1;       
    for (Map.Entry itr : freq.entrySet())
    {
      denom *= fact(itr.getValue());
      cnt += itr.getValue();
    }
 
    // Return total number of
    // permutations of the given word
    return fact(cnt) / denom;
  }
 
  // Function to calculate number of permutations
  // such that no vowels come together
  static long no_vowels_together(String word)
  {
 
    // To store frequency of character
    HashMap freq = new HashMap<>();
 
    // Count frequency of all characters
    for(int i = 0; i < word.length(); i++)
    {
      char ch = Character.toLowerCase(word.charAt(i));
      if (freq.containsKey(ch))
      {
        freq.put(ch, freq.get(ch)+1);
      }
      else
      {
        freq.put(ch, 1);
      }
    }
 
    // Calculate total number of permutations
    long total = total_permutations(freq);
 
    // Calculate total number of permutations
    // such that all vowels come together
    long vwl_tgthr = all_vowels_together(freq);
 
    // Subtract vwl_tgthr from total
    // to get the result
    long res = total - vwl_tgthr;
 
    // Return the result
    return res;
  }
 
  // Driver code
  public static void main(String[] args) {
    String word = "allahabad";
    long ans = no_vowels_together(word);
    System.out.println(ans);
 
    word = "geeksforgeeks";
    ans = no_vowels_together(word);
    System.out.println(ans);
 
    word = "abcd";
    ans = no_vowels_together(word);
    System.out.println(ans);
  }
}
 
// This code is contributed by divyesh072019

Python3

# Python3 code for above approach
 
# Function to check if a character is
# vowel or consonent
def isVowel(ch):
    if (ch == 'a' or ch == 'e' or
        ch == 'i' or ch == 'o' or ch == 'u') :
        return True
    else:
        return False
 
# Function to calculate factorial of a number
def fact(n):
    if (n < 2):
        return 1
    return n * fact(n - 1)
 
# Calculating no of ways for arranging vowels
def only_vowels(freq):
 
    denom = 1
    cnt_vwl = 0
 
    # Iterate the map and count the number of
    # vowels and calculate no of ways to arrange vowels
    for itr in freq:
        if (isVowel(itr)):
            denom *= fact(freq[itr])
            cnt_vwl += freq[itr]
 
    return fact(cnt_vwl) // denom
 
# calculating no of ways to arrange the given word
# such that vowels come together
def all_vowels_together(freq):
     
    # calculate no of ways to arrange vowels
    vow = only_vowels(freq)
 
    # to store denominator of fraction
    denom = 1
 
    # count of consonents
    cnt_cnst = 0
 
    for itr in freq:
        if (isVowel(itr) == False):
            denom *= fact(freq[itr])
            cnt_cnst += freq[itr]
 
    # calculate the number of ways to arrange
    # the word such that vowels come together
    ans = fact(cnt_cnst + 1) // denom
 
    return (ans * vow)
 
# To calculate total number of permutations
def total_permutations(freq):
     
    # To store length of the given word
    cnt = 0
 
    # denominator of fraction
    denom = 1
 
    for itr in freq:
        denom *= fact(freq[itr])
        cnt += freq[itr]
 
    # retur total number of permutations
    # of the given word
    return fact(cnt) // denom
 
# Function to calculate number of permutations
# such that no vowels come together
def no_vowels_together(word):
     
    # to store frequency of character
    freq = dict()
 
    # count frequency of acharacters
    for i in word:
        ch = i.lower()
        freq[ch] = freq.get(ch, 0) + 1
 
    # calculate total number of permutations
    total = total_permutations(freq)
 
    # calculate total number of permutations
    # such that vowels come together
    vwl_tgthr = all_vowels_together(freq)
 
    # substrat vwl_tgthr from total
    # to get the result
    res = total - vwl_tgthr
 
    # return the result
    return res
 
# Driver code
word = "allahabad"
ans = no_vowels_together(word)
print(ans)
 
word = "geeksforgeeks"
ans = no_vowels_together(word)
print(ans)
 
word = "abcd"
ans = no_vowels_together(word)
print(ans)
 
# This code is contributed by Mohit Kumar

C#

// C# code for above approach
using System;
using System.Collections.Generic;
 
class GFG{
     
// Function to check if a character
// is vowel or consonent
static bool isVowel(char ch)
{
    if (ch == 'a' || ch == 'e' ||
        ch == 'i' || ch == 'o' ||
        ch == 'u')
        return true;
    else
        return false;
}
   
// Function to calculate factorial of a number
static long fact(long n)
{
    if (n < 2)
    {
        return 1;
    }
    return n * fact(n - 1);
}
   
// Calculating no of ways for arranging vowels
static long only_vowels(Dictionary freq)
{
    long denom = 1;
    long cnt_vwl = 0;
 
    // Iterate the map and count the number
    // of vowels and calculate no of ways
    // to arrange vowels
    foreach(KeyValuePair itr in freq)
    {
        if (isVowel(itr.Key))
        {
            denom *= fact(itr.Value);
            cnt_vwl += itr.Value;
        }
    }
   
    return fact(cnt_vwl) / denom;
}
 
// Calculating no of ways to arrange
// the given word such that all vowels
// come together
static long all_vowels_together(Dictionary freq)
{
     
    // Calculate no of ways to arrange vowels
    long vow = only_vowels(freq);
   
    // To store denominator of fraction
    long denom = 1;
   
    // Count of consonents
    long cnt_cnst = 0;
   
    foreach(KeyValuePair itr in freq)
    {
        if (!isVowel(itr.Key))
        {
            denom *= fact(itr.Value);
            cnt_cnst += itr.Value;
        }
    }
   
    // Calculate the number of ways to
    // arrange the word such that
    // all vowels come together
    long ans = fact(cnt_cnst + 1) / denom;
   
    return (ans * vow);
}
   
// To calculate total number of permutations
static long total_permutations(Dictionary freq)
{
     
    // To store length of the given word
    long cnt = 0;
   
    // Denominator of fraction
    long denom = 1;
   
    foreach(KeyValuePair itr in freq)
    {
        denom *= fact(itr.Value);
        cnt += itr.Value;
    }
   
    // Return total number of
    // permutations of the given word
    return fact(cnt) / denom;
}
   
// Function to calculate number of permutations
// such that no vowels come together
static long no_vowels_together(string word)
{
     
    // To store frequency of character
    Dictionary freq = new Dictionary();
   
    // Count frequency of all characters
    for(int i = 0; i < word.Length; i++)
    {
        char ch = Char.ToLower(word[i]);
        if (freq.ContainsKey(ch))
        {
            freq[ch]++;
        }
        else
        {
            freq[ch] = 1;
        }
    }
   
    // Calculate total number of permutations
    long total = total_permutations(freq);
   
    // Calculate total number of permutations
    // such that all vowels come together
    long vwl_tgthr = all_vowels_together(freq);
   
    // Subtract vwl_tgthr from total
    // to get the result
    long res = total - vwl_tgthr;
   
    // Return the result
    return res;
}
 
// Driver Code
static void Main()
{
    string word = "allahabad";
    long ans = no_vowels_together(word);
    Console.WriteLine(ans);
     
    word = "geeksforgeeks";
    ans = no_vowels_together(word);
    Console.WriteLine(ans);
     
    word = "abcd";
    ans = no_vowels_together(word);
    Console.WriteLine(ans);
}
}
 
// This code is contributed by divyeshrabadiya07

输出：

7200
32205600
0