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

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:2

All the unique permutations of AKA are : AKA, AAK and KAA

‘A’ comes consecutively only twice. Hence, the answer is 2Input: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 <bits/stdc++.h>` `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[26] = { 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` `[26];` ` ` ` ` `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

`<?php` `// PHP implementation of the approach` `// Function to return factorial of` `// the number passed as argument` `function` `fact(` `$n` `)` `{` ` ` `$result` `= 1;` ` ` `for` `(` `$i` `= 1; ` `$i` `<= ` `$n` `; ` `$i` `++)` ` ` `$result` `*= ` `$i` `;` ` ` `return` `$result` `;` `}` `// Function to get the total permutations` `// which satisfy the given condition` `function` `getResult(` `$str` `, ` `$ch` `)` `{` ` ` `// Create has to store count` ` ` `// of each character` ` ` `$has` `= ` `array_fill` `(0, 26, NULL);` ` ` `// Store character occurrences` ` ` `for` `(` `$i` `= 0; ` `$i` `< ` `strlen` `(` `$str` `); ` `$i` `++)` ` ` `$has` `[ord(` `$str` `[` `$i` `]) - ord(` `'A'` `)]++;` ` ` `// 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` `= ` `strlen` `(` `$str` `);` ` ` `// 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` `= 0; ` `$i` `< 26; ` `$i` `++)` ` ` `{` ` ` `if` `(` `$has` `[` `$i` `] > 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

`<script>` ` ` `// Javascript implementation of the approach` `// Function to return factorial of` `// the number passed as argument` `function` `fact(n)` `{` ` ` `let result = 1;` ` ` `for` `(let i = 1; i <= n; i++)` ` ` `result *= i;` ` ` `return` `result;` `}` `// Function to get the total permutations` `// which satisfy the given condition` `function` `getResult(str, ch)` `{` ` ` `// Create has to store count` ` ` `// of each character` ` ` `let has = ` `new` `Array(26).fill(` `null` `);` ` ` `// Store character occurrences` ` ` `for` `(let i = 0; i < str.length; i++)` ` ` `has[str.charCodeAt(i) - ` `'A'` `.charCodeAt(0)]++;` ` ` `// Count number of times` ` ` `// Particular character comes` ` ` `particular = has[ch.charCodeAt(0) - ` `'A'` `.charCodeAt(0)];` ` ` `// If particular character isn't` ` ` `// present in the string then return 0` ` ` `if` `(particular == 0)` ` ` `return` `0;` ` ` `// Remove count of particular character` ` ` `has[ch.charCodeAt(0) - 'A` `'.charCodeAt(0)] = 0;` ` ` `// Total length` ` ` `// of the string` ` ` `let total = str.length;` ` ` `// Assume all occurrences of` ` ` `// particular character as a` ` ` `// single character.` ` ` `total = total - particular + 1;` ` ` `// Compute factorial of the length` ` ` `let result = fact(total);` ` ` `// Divide by the factorials of` ` ` `// the no. of occurrences of all` ` ` `// the characters.` ` ` `for (let i = 0; i < 26; i++)` ` ` `{` ` ` `if (has[i] > 1)` ` ` `{` ` ` `result = result / fact(has[i]);` ` ` `}` ` ` `}` ` ` `// return the result` ` ` `return result;` `}` `// Driver Code` `let str = "MISSISSIPPI";` `// Assuming the string and the character` `// are all in uppercase` `document.write(getResult(str, '` `S') + ` `"<br>"` `);` `// This code is contributed by gfgking` `</script>` |

**Output:**

840

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.