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
Explanation: 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.
- The count of the permutations from the previous step is the answer.
Efficient Approach: Let the length of the string be ‘l’ and the 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++ 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 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 |
# 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# 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 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 ?> |
<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> |
840
Complexity Analysis:
- Time Complexity: O(n) where n is the size of the string.
- Auxiliary Space: O(1) as constant space is taken.