# Number of permutations of a string in which all the occurrences of a given character occurs together

• Last Updated : 07 May, 2021

Given a string ‘s’ and a character ‘c’, the task is to find the number of permutations of the string in which all the occurrences of the character ‘c’ will be together (one after another).
Examples :

Input: Str = “AKA” ch = ‘A’
Output:
All the unique permutations of AKA are : AKA, AAK and KAA
‘A’ comes consecutively only twice. Hence, the answer is 2
Input: str= “MISSISSIPPI” ch = ‘S’
Output: 840

Naive Approach:

• Generate all the permutations of the given string.
• For each permutation check whether all occurrences of the character appear together.
• Count of the permutations from the previous step is the answer.

Efficient Approach: Let the length of the string be ‘l’ and frequency of the character in the string be ‘n’.

• Store the frequency of every character of the string.
• If the character is not present in the string then the output will be ‘0’.
• Consider all the occurrences of the character as a combined single character.
• So, ‘l’ will become ‘l – occ + 1’ where ‘occ’ is the total occurrence of the given character and ‘l’ is the new length of the string.
• Return ( (Factorial of l) / (Product of the factorials of the no. of occurrences of each character except the given character) )

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to return factorial``// of the number passed as argument``long` `long` `int` `fact(``int` `n)``{``    ``long` `long` `result = 1;``    ``for` `(``int` `i = 1; i <= n; i++)``        ``result *= i;``    ``return` `result;``}` `// Function to get the total permutations``// which satisfy the given condition``int` `getResult(string str, ``char` `ch)``{``    ``// Create has to store count``    ``// of each character``    ``int` `has = { 0 };` `    ``// Store character occurrences``    ``for` `(``int` `i = 0; i < str.length(); i++)``        ``has[str[i] - ``'A'``]++;` `    ``// Count number of times``    ``// Particular character comes``    ``int` `particular = has[ch - ``'A'``];` `    ``// If particular character isn't``    ``// present in the string then return 0``    ``if` `(particular == 0)``        ``return` `0;` `    ``// Remove count of particular character``    ``has[ch - ``'A'``] = 0;` `    ``// Total length``    ``// of the string``    ``int` `total = str.length();` `    ``// Assume all occurrences of``    ``// particular character as a``    ``// single character.``    ``total = total - particular + 1;` `    ``// Compute factorial of the length``    ``long` `long` `int` `result = fact(total);` `    ``// Divide by the factorials of``    ``// the no. of occurrences of all``    ``// the characters.``    ``for` `(``int` `i = 0; i < 26; i++) {``        ``if` `(has[i] > 1) {``            ``result = result / fact(has[i]);``        ``}``    ``}` `    ``// return the result``    ``return` `result;``}` `// Driver Code``int` `main()``{``    ``string str = ``"MISSISSIPPI"``;` `    ``// Assuming the string and the character``    ``// are all in uppercase``    ``cout << getResult(str, ``'S'``) << endl;` `  ``return` `0;``}`

## Java

 `  ` `// Java implementation of above approach``import` `java.util.*;``class` `solution``{` `// Function to return factorial``// of the number passed as argument`` ``static` `int` `fact(``int` `n)``{``     ``int` `result = ``1``;``    ``for` `(``int` `i = ``1``; i <= n; i++)``        ``result *= i;``    ``return` `result;``}` `// Function to get the total permutations``// which satisfy the given condition``static` `int` `getResult(String str, ``char` `ch)``{``    ``// Create has to store count``    ``// of each character``    ``int` `has[] = ``new` `int``[``26``];``    ` `    ``for``(``int` `i=``0``;i<``26``;i++)``    ``has[i]=``0``;` `    ``// Store character occurrences``    ``for` `(``int` `i = ``0``; i < str.length(); i++)``        ``has[str.charAt(i) - ``'A'``]++;` `    ``// Count number of times``    ``// Particular character comes``    ``int` `particular = has[ch - ``'A'``];` `    ``// If particular character isn't``    ``// present in the string then return 0``    ``if` `(particular == ``0``)``        ``return` `0``;` `    ``// Remove count of particular character``    ``has[ch - ``'A'``] = ``0``;` `    ``// Total length``    ``// of the string``    ``int` `total = str.length();` `    ``// Assume all occurrences of``    ``// particular character as a``    ``// single character.``    ``total = total - particular + ``1``;` `    ``// Compute factorial of the length``     ``int` `result = fact(total);` `    ``// Divide by the factorials of``    ``// the no. of occurrences of all``    ``// the characters.``    ``for` `(``int` `i = ``0``; i < ``26``; i++) {``        ``if` `(has[i] > ``1``) {``            ``result = result / fact(has[i]);``        ``}``    ``}` `    ``// return the result``    ``return` `result;``}` `// Driver Code``public` `static` `void` `main(String args[])``{``    ``String str = ``"MISSISSIPPI"``;` `    ``// Assuming the string and the character``    ``// are all in uppercase``    ``System.out.println( getResult(str, ``'S'``) );` `}``}``//contributed by Arnab Kundu`

## Python 3

 `# Python3 implementation of``# the approach` `# Function to return factorial``# of the number passed as argument``def` `fact(n) :` `    ``result ``=` `1` `    ``for` `i ``in` `range``(``1``, n ``+` `1``) :``        ``result ``*``=` `i` `    ``return` `result` `# Function to get the total permutations``# which satisfy the given condition``def` `getResult(string, ch):` `    ``# Create has to store count``    ``# of each character``    ``has ``=` `[``0``] ``*` `26` `    ``# Store character occurrences``    ``for` `i ``in` `range``(``len``(string)) :``        ``has[``ord``(string[i]) ``-` `ord``(``'A'``)] ``+``=` `1` `    ``# Count number of times``    ``# Particular character comes``    ``particular ``=` `has[``ord``(ch) ``-` `ord``(``'A'``)]` `    ``# If particular character isn't``    ``# present in the string then return 0``    ``if` `particular ``=``=` `0` `:``        ``return` `0` `    ``# Remove count of particular character``    ``has[``ord``(ch) ``-` `ord``(``'A'``)] ``=` `0` `    ``# Total length``    ``# of the string``    ``total ``=` `len``(string)` `    ``# Assume all occurrences of``    ``# particular character as a``    ``# single character.``    ``total ``=` `total ``-` `particular ``+` `1` `    ``# Compute factorial of the length``    ``result ``=` `fact(total)` `    ``# Divide by the factorials of``    ``# the no. of occurrences of all``    ``# the characters.``    ``for` `i ``in` `range``(``26``) :` `        ``if` `has[i] > ``1` `:``            ``result ``/``=` `fact(has[i])` `    ``# return the result``    ``return` `result`  `# Driver code``if` `__name__ ``=``=` `"__main__"` `:` `    ``string ``=` `"MISSISSIPPI"` `    ``# Assuming the string and the character``    ``# are all in uppercase``    ``print``(getResult(string,``'S'``))` `# This code is contributed``# by ANKITRAI1`

## C#

 `// C# implementation of above approach``using` `System;` `class` `GFG``{` `// Function to return factorial``// of the number passed as argument``static` `int` `fact(``int` `n)``{``    ``int` `result = 1;``    ``for` `(``int` `i = 1; i <= n; i++)``        ``result *= i;``    ``return` `result;``}` `// Function to get the total permutations``// which satisfy the given condition``static` `int` `getResult(``string` `str, ``char` `ch)``{``    ``// Create has to store count``    ``// of each character``    ``int` `[]has = ``new` `int``;``    ` `    ``for``(``int` `i = 0; i < 26; i++)``    ``has[i] = 0;` `    ``// Store character occurrences``    ``for` `(``int` `i = 0; i < str.Length; i++)``        ``has[str[i] - ``'A'``]++;` `    ``// Count number of times``    ``// Particular character comes``    ``int` `particular = has[ch - ``'A'``];` `    ``// If particular character``    ``// isn't present in the string``    ``// then return 0``    ``if` `(particular == 0)``        ``return` `0;` `    ``// Remove count of particular character``    ``has[ch - ``'A'``] = 0;` `    ``// Total length of the string``    ``int` `total = str.Length;` `    ``// Assume all occurrences of``    ``// particular character as a``    ``// single character.``    ``total = total - particular + 1;` `    ``// Compute factorial of the length``    ``int` `result = fact(total);` `    ``// Divide by the factorials of``    ``// the no. of occurrences of all``    ``// the characters.``    ``for` `(``int` `i = 0; i < 26; i++)``    ``{``        ``if` `(has[i] > 1)``        ``{``            ``result = result / fact(has[i]);``        ``}``    ``}` `    ``// return the result``    ``return` `result;``}` `// Driver Code``public` `static` `void` `Main()``{``    ``string` `str = ``"MISSISSIPPI"``;` `    ``// Assuming the string and the``    ``// character are all in uppercase``    ``Console.WriteLine(getResult(str, ``'S'``) );``}``}` `// This code is contributed by anuj_67`

## PHP

 ` 1)``        ``{``            ``\$result` `= ``\$result` `/ fact(``\$has``[``\$i``]);``        ``}``    ``}` `    ``// return the result``    ``return` `\$result``;``}` `// Driver Code``\$str` `= ``"MISSISSIPPI"``;` `// Assuming the string and the character``// are all in uppercase``echo` `getResult(``\$str``, ``'S'``).``"\n"` `;` `// This code is contributed by ita_c``?>`

## Javascript

 ``

Output:

`840`

My Personal Notes arrow_drop_up