# Count the number of special permutations

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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[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 ` `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 premutation ` ` `  `# 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 premutations ` `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[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() ` `    ``{  ` `        ``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``[0] = 1; ` `    ``\$der``[1] = 0; ` `    ``\$der``[2] = 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  ` `?> `

Output:

```31
```

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.