Skip to content
Related Articles

Related Articles

Improve Article

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 <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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :