Related Articles

# Count the number of special permutations

• Difficulty Level : Medium
• Last Updated : 01 Sep, 2021

Given two positive integers n and k, the task is to count the number of special permutations. A special permutation P is defined as a permutation of first n natural numbers in which there exists at least (n – k) indices such that Pi = i
Prerequisite: Derangements

Examples:

Input: n = 4, k = 2
Output:
{1, 2, 3, 4}, {1, 2, 4, 3}, {4, 2, 3, 1}, {2, 1, 3, 4}, {1, 4, 3, 2}, {1, 3, 2, 4} and {3, 2, 1, 4} are the only possible special permutations.

Input: n = 5, k = 3
Output: 31

Approach: Let the function fx denote the number of special permutations in which there exists exactly x indices such that Pi = i. Hence, the required answer will be:

f(n – k) + f(n – k + 1) + f(n – k + 2) + … + f(n – 1) + fn

Now, fx can be calculated by choosing x indices from n where Pi = i and calculating the number of derangements for (n – i) other indices as for them Pi should not be equal to i then multiplying the result by nCx as there can be different ways to select x indices from n.

Below is the implementation of the above approach:

## C++

 `// C++ program to count the number``// of required permutations``#include ``using` `namespace` `std;``#define ll long long int` `// Function to return the number of ways``// to choose r objects out of n objects``int` `nCr(``int` `n, ``int` `r)``{``    ``int` `ans = 1;``    ``if` `(r > n - r)``        ``r = n - r;``    ``for` `(``int` `i = 0; i < r; i++) {``        ``ans *= (n - i);``        ``ans /= (i + 1);``    ``}``    ``return` `ans;``}` `// Function to return the number``// of derangements of n``int` `countDerangements(``int` `n)``{``    ``int` `der[n + 1];` `    ``der = 1;``    ``der = 0;``    ``der = 1;` `    ``for` `(``int` `i = 3; i <= n; i++)``        ``der[i] = (i - 1) * (der[i - 1]``                         ``+ der[i - 2]);``    ``return` `der[n];``}` `// Function to return the required``// number of permutations``ll countPermutations(``int` `n, ``int` `k)``{``    ``ll ans = 0;``    ``for` `(``int` `i = n - k; i <= n; i++) {` `        ``// Ways to choose i indices from n indices``        ``int` `ways = nCr(n, i);` `        ``// Dearangements of (n - i) indices``        ``ans += ways * countDerangements(n - i);``    ``}``    ``return` `ans;``}` `// Driver Code to test above functions``int` `main()``{``    ``int` `n = 5, k = 3;``    ``cout << countPermutations(n, k);``    ``return` `0;``}`

## Java

 `// Java program to count the number``// of required permutations``    ` `public` `class` `GFG{``    ` `    ``// Function to return the number of ways``    ``// to choose r objects out of n objects``    ``static` `int` `nCr(``int` `n, ``int` `r)``    ``{``        ``int` `ans = ``1``;``        ``if` `(r > n - r)``            ``r = n - r;``        ``for` `(``int` `i = ``0``; i < r; i++) {``            ``ans *= (n - i);``            ``ans /= (i + ``1``);``        ``}``        ``return` `ans;``    ``}``    ` `    ``// Function to return the number``    ``// of derangements of n``    ``static` `int` `countDerangements(``int` `n)``    ``{``        ``int` `der[] = ``new` `int``[ n + ``3``];``    ` `        ``der[``0``] = ``1``;``        ``der[``1``] = ``0``;``        ``der[``2``] = ``1``;``    ` `        ``for` `(``int` `i = ``3``; i <= n; i++)``            ``der[i] = (i - ``1``) * (der[i - ``1``]``                            ``+ der[i - ``2``]);``        ``return` `der[n];``    ``}``    ` `    ``// Function to return the required``    ``// number of permutations``    ``static` `int` `countPermutations(``int` `n, ``int` `k)``    ``{``        ``int` `ans = ``0``;``        ``for` `(``int` `i = n - k; i <= n; i++) {``    ` `            ``// Ways to choose i indices from n indices``            ``int` `ways = nCr(n, i);``    ` `            ``// Dearangements of (n - i) indices``            ``//System.out.println(ans) ;``            ``ans += (ways * countDerangements(n- i));``        ``}``        ``return` `ans;``    ``}``    ` `    ``// Driver Code to test above functions``    ``public` `static` `void` `main(String []args)``    ``{``        ``int` `n = ``5``, k = ``3``;``        ``System.out.println(countPermutations(n, k)) ;``    ``}``    ``// This code is contributed by Ryuga``}`

## Python3

 `# Python 3 program to count the number``# of required permutation` `# function to return the number of ways``# to chooser objects out of n objects``def` `nCr(n, r):``    ``ans ``=` `1``    ``if` `r > n ``-` `r:``        ``r ``=` `n ``-` `r``    ``for` `i ``in` `range``(r):``        ``ans ``*``=` `(n ``-` `i)``        ``ans ``/``=` `(i ``+` `1``)``    ``return` `ans` `# function to return the number of``# degrangemnets of n``def` `countDerangements(n):``    ``der ``=` `[``0` `for` `i ``in` `range``(n ``+` `3``)]``    ` `    ``der[``0``] ``=` `1``    ``der[``1``] ``=` `0``    ``der[``2``] ``=` `1``    ` `    ``for` `i ``in` `range``(``3``, n ``+` `1``):``        ``der[i] ``=` `(i ``-` `1``) ``*` `(der[i ``-` `1``] ``+``                            ``der[i ``-` `2``])``        ` `    ``return` `der[n]` `# function to return the required``# number of permutations``def` `countPermutations(n, k):``    ``ans ``=` `0``    ``for` `i ``in` `range``(n ``-` `k, n ``+` `1``):``        ` `        ``# ways to chose i indices``        ``# from n indices``        ``ways ``=` `nCr(n, i)``        ` `        ``# Dearrangements of (n-i) indices``        ``ans ``+``=` `ways ``*` `countDerangements(n ``-` `i)``    ``return` `ans` `# Driver Code``n, k ``=` `5``, ``3` `print``(countPermutations(n, k))` `# This code is contributed by``# Mohit kumar 29 (IIIT gwalior)`

## C#

 `    ` `// C# program to count the number``// of required permutations``using` `System;   ``public` `class` `GFG{``     ` `    ``// Function to return the number of ways``    ``// to choose r objects out of n objects``    ``static` `int` `nCr(``int` `n, ``int` `r)``    ``{``        ``int` `ans = 1;``        ``if` `(r > n - r)``            ``r = n - r;``        ``for` `(``int` `i = 0; i < r; i++) {``            ``ans *= (n - i);``            ``ans /= (i + 1);``        ``}``        ``return` `ans;``    ``}``     ` `    ``// Function to return the number``    ``// of derangements of n``    ``static` `int` `countDerangements(``int` `n)``    ``{``        ``int` `[]der = ``new` `int``[ n + 3];``     ` `        ``der = 1;``        ``der = 0;``        ``der = 1;``     ` `        ``for` `(``int` `i = 3; i <= n; i++)``            ``der[i] = (i - 1) * (der[i - 1]``                            ``+ der[i - 2]);``        ``return` `der[n];``    ``}``     ` `    ``// Function to return the required``    ``// number of permutations``    ``static` `int` `countPermutations(``int` `n, ``int` `k)``    ``{``        ``int` `ans = 0;``        ``for` `(``int` `i = n - k; i <= n; i++) {``     ` `            ``// Ways to choose i indices from n indices``            ``int` `ways = nCr(n, i);``     ` `            ``// Dearangements of (n - i) indices``            ``//System.out.println(ans) ;``            ``ans += (ways * countDerangements(n- i));``        ``}``        ``return` `ans;``    ``}``     ` `    ``// Driver Code to test above functions``    ``public` `static` `void` `Main()``    ``{``        ``int` `n = 5, k = 3;``        ``Console.WriteLine(countPermutations(n, k)) ;``    ``}``}``// This code is contributed by 29AjayKumar`

## PHP

 ` ``\$n` `- ``\$r``)``        ``\$r` `= ``\$n` `- ``\$r``;``    ``for` `(``\$i` `= 0; ``\$i` `< ``\$r``; ``\$i``++)``    ``{``        ``\$ans` `*= (``\$n` `- ``\$i``);``        ``\$ans` `/= (``\$i` `+ 1);``    ``}``    ``return` `\$ans``;``}` `// Function to return the number``// of derangements of n``function` `countDerangements(``\$n``)``{``    ``\$der` `= ``array``(``\$n` `+ 1);` `    ``\$der`` = 1;``    ``\$der`` = 0;``    ``\$der`` = 1;` `    ``for` `(``\$i` `= 3; ``\$i` `<= ``\$n``; ``\$i``++)``        ``\$der``[``\$i``] = (``\$i` `- 1) *``                   ``(``\$der``[``\$i` `- 1] +``                    ``\$der``[``\$i` `- 2]);``    ``return` `\$der``[``\$n``];``}` `// Function to return the required``// number of permutations``function` `countPermutations(``\$n``, ``\$k``)``{``    ``\$ans` `= 0;``    ``for` `(``\$i` `= ``\$n` `- ``\$k``; ``\$i` `<= ``\$n``; ``\$i``++)``    ``{` `        ``// Ways to choose i indices``        ``// from n indices``        ``\$ways` `= nCr(``\$n``, ``\$i``);` `        ``// Dearangements of (n - i) indices``        ``\$ans` `+= ``\$ways` `* countDerangements(``\$n` `- ``\$i``);``    ``}``    ``return` `\$ans``;``}` `// Driver Code``\$n` `= 5;``\$k` `= 3;``echo` `(countPermutations(``\$n``, ``\$k``));` `// This code is contributed``// by Shivi_Aggarwal``?>`

## Javascript

 ``
Output:
`31`

Time Complexity: O(N^2)
Auxiliary Space: O(N)

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