# Permutation Coefficient

• Difficulty Level : Easy
• Last Updated : 25 Feb, 2023

Permutation refers to the process of arranging all the members of a given set to form a sequence. The number of permutations on a set of n elements is given by n! , where “!” represents factorial.

The Permutation Coefficient represented by P(n, k) is used to represent the number of ways to obtain an ordered subset having k elements from a set of n elements.
Mathematically it’s given as:

Image Source : Wiki
Examples :

```P(10, 2) = 90
P(10, 3) = 720
P(10, 0) = 1
P(10, 1) = 10```

The coefficient can also be computed recursively using the below recursive formula:

`P(n, k) = P(n-1, k) + k* P(n-1, k-1)   `

The recursive formula for permutation-coefficient is :
P(n, k) = P(n-1, k) + k* P(n-1, k-1)

But how ??
here is the proof,

The binomial coefficient is nCk =       n!
k! (n-k)!
and, permutation-coefficient nPr =     n!
(n-k)!

So, I can write
nCk =     nPk
k!
=> k! * nCk = nPk â€”——————- eq.1

The recursive formula for the Binomial coefficient nCk can be written as,
nCk(n,k) = nCk(n-1,k-1) + nCk(n-1,k) you can refer to the following article for more details
https://www.geeksforgeeks.org/binomial-coefficient-dp-9/
Basically, it makes use of Pascal’s triangle which states that in order to fill the value at nCk[n][k] you need the summation of nCk[n-1][k-1] and nCk[n-1][k] along with some base cases. i.e,
nCk[n][k] = nCk[n-1][k-1]+nCk[n-1][k].
nCk[n][0] = nCk[n][n] = 1 (Base Case)

Anyways, let’s proceed with our eq.1

=> k! * nCk = nPk

=> k! * ( nCk(n-1,k-1) + nCk(n-1,k) ) = nPk      [ as, nCk = nCk(n-1,k-1)+nCk(n-1,k) ]

=> k! * (            (n-1)!                 +            (n-1)!       ) = nPk
((n-1)-(k-1))! * (k-1)!            (n-1-k)! * k!

=>                   k! * (n-1)!              +           k! * (n-1)!        = nPk
((n-1)-(k-1))! * (k-1)!                 (n-1-k)! * k!

=>                  k * (k-1)! * (n-1)!          +         k! * (n-1)!        = nPk      [ as, k! = k*(k-1)! ]
((n-1)-(k-1))! * (k-1)!                 (n-1-k)! * k!

=>               k * (n-1)!            +          (n-1)!        =  nPk
((n-1)-(k-1))!                    (n-1-k)!

(n-1)!         can be replaced by nPk(n-1,k-1) as per the permutation-coefficient
((n-1) – (k-1))!

Similarly,        (n-1)!        can be replaced by nPk(n-1,k).
(n-1-k)!

Therefore,

=>   k * nPk(n-1, k-1) + nPk(n-1, k)  = nPk

Finally, that is where our recursive formula came from.
P(n, k) = P(n-1, k) + k* P(n-1, k-1)

If we observe closely, we can analyze that the problem has an overlapping substructure, hence we can apply dynamic programming here. Below is a program implementing the same idea.

## C++

 `// C++ program of the above approach``#include ``using` `namespace` `std;` `// A Dynamic Programming based``// solution that uses table P[][]``// to calculate the Permutation``// Coefficient``#include`` ` `// Returns value of Permutation``// Coefficient P(n, k)``int` `permutationCoeff(``int` `n, ``int` `k)``{``    ``int` `P[n + 1][k + 1];`` ` `    ``// Calculate value of Permutation``    ``// Coefficient in bottom up manner``    ``for` `(``int` `i = 0; i <= n; i++)``    ``{``        ``for` `(``int` `j = 0; j <= std::min(i, k); j++)``        ``{``            ``// Base Cases``            ``if` `(j == 0)``                ``P[i][j] = 1;`` ` `            ``// Calculate value using``            ``// previously stored values``            ``else``                ``P[i][j] = P[i - 1][j] +``                        ``(j * P[i - 1][j - 1]);`` ` `            ``// This step is important``            ``// as P(i,j)=0 for j>i``            ``P[i][j + 1] = 0;``        ``}``    ``}``    ``return` `P[n][k];``}`` `  `// Driver Code``int` `main()``{``    ``int` `n = 10, k = 2;``    ``cout << ``"Value of P("` `<< n <<``" "` `<< k<< ``") is "` `<<  permutationCoeff(n, k);` `    ``return` `0;``}` `// This code is contributed by code_hunt.`

## C

 `// A Dynamic Programming based``// solution that uses table P[][]``// to calculate the Permutation``// Coefficient``#include` `// Returns value of Permutation``// Coefficient P(n, k)``int` `permutationCoeff(``int` `n, ``int` `k)``{``    ``int` `P[n + 1][k + 1];` `    ``// Calculate value of Permutation``    ``// Coefficient in bottom up manner``    ``for` `(``int` `i = 0; i <= n; i++)``    ``{``        ``for` `(``int` `j = 0; j <= std::min(i, k); j++)``        ``{``            ``// Base Cases``            ``if` `(j == 0)``                ``P[i][j] = 1;` `            ``// Calculate value using``            ``// previously stored values``            ``else``                ``P[i][j] = P[i - 1][j] +``                        ``(j * P[i - 1][j - 1]);` `            ``// This step is important``            ``// as P(i,j)=0 for j>i``            ``P[i][j + 1] = 0;``        ``}``    ``}``    ``return` `P[n][k];``}` `// Driver Code``int` `main()``{``    ``int` `n = 10, k = 2;``    ``printf``(``"Value of P(%d, %d) is %d "``,``            ``n, k, permutationCoeff(n, k));``    ``return` `0;``}`

## Java

 `// Java code for Dynamic Programming based``// solution that uses table P[][] to``// calculate the Permutation Coefficient``import` `java.io.*;``import` `java.math.*;` `class` `GFG``{``    ` `    ``// Returns value of Permutation``    ``// Coefficient P(n, k)``    ``static` `int` `permutationCoeff(``int` `n,``                                ``int` `k)``    ``{``        ``int` `P[][] = ``new` `int``[n + ``2``][k + ``2``];``    ` `        ``// Calculate value of Permutation``        ``// Coefficient in bottom up manner``        ``for` `(``int` `i = ``0``; i <= n; i++)``        ``{``            ``for` `(``int` `j = ``0``;``                ``j <= Math.min(i, k);``                ``j++)``            ``{``                ``// Base Cases``                ``if` `(j == ``0``)``                    ``P[i][j] = ``1``;``    ` `                ``// Calculate value using previously``                ``// stored values``                ``else``                    ``P[i][j] = P[i - ``1``][j] +``                            ``(j * P[i - ``1``][j - ``1``]);``    ` `                ``// This step is important``                ``// as P(i,j)=0 for j>i``                ``P[i][j + ``1``] = ``0``;``            ``}``        ``}``        ``return` `P[n][k];``    ``}``    ` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `n = ``10``, k = ``2``;``        ``System.out.println(``"Value of P( "` `+ n + ``","``+ k +``")"` `+``                        ``" is "` `+ permutationCoeff(n, k) );``    ``}``}` `// This code is contributed by Nikita Tiwari.`

## Python3

 `# A Dynamic Programming based``# solution that uses``# table P[][] to calculate the``# Permutation Coefficient` `# Returns value of Permutation``# Coefficient P(n, k)``def` `permutationCoeff(n, k):` `    ``P ``=` `[[``0` `for` `i ``in` `range``(k ``+` `1``)]``            ``for` `j ``in` `range``(n ``+` `1``)]` `    ``# Calculate value of Permutation``    ``# Coefficient in``    ``# bottom up manner``    ``for` `i ``in` `range``(n ``+` `1``):``        ``for` `j ``in` `range``(``min``(i, k) ``+` `1``):` `            ``# Base cases``            ``if` `(j ``=``=` `0``):``                ``P[i][j] ``=` `1` `            ``# Calculate value using``            ``# previously stored values``            ``else``:``                ``P[i][j] ``=` `P[i ``-` `1``][j] ``+` `(``                        ``j ``*` `P[i ``-` `1``][j ``-` `1``])` `            ``# This step is important``            ``# as P(i, j) = 0 for j>i``            ``if` `(j < k):``                ``P[i][j ``+` `1``] ``=` `0``    ``return` `P[n][k]` `# Driver Code``n ``=` `10``k ``=` `2``print``(``"Value of P("``, n, ``", "``, k, ``") is "``,``    ``permutationCoeff(n, k), sep ``=` `"")` `# This code is contributed by Soumen Ghosh.`

## C#

 `// C# code for Dynamic Programming based``// solution that uses table P[][] to``// calculate the Permutation Coefficient``using` `System;` `class` `GFG``{``    ` `    ``// Returns value of Permutation``    ``// Coefficient P(n, k)``    ``static` `int` `permutationCoeff(``int` `n,``                                ``int` `k)``    ``{``        ``int` `[,]P = ``new` `int``[n + 2,k + 2];``    ` `        ``// Calculate value of Permutation``        ``// Coefficient in bottom up manner``        ``for` `(``int` `i = 0; i <= n; i++)``        ``{``            ``for` `(``int` `j = 0;``                ``j <= Math.Min(i, k);``                ``j++)``            ``{``                ``// Base Cases``                ``if` `(j == 0)``                    ``P[i,j] = 1;``    ` `                ``// Calculate value using previously``                ``// stored values``                ``else``                    ``P[i,j] = P[i - 1,j] +``                            ``(j * P[i - 1,j - 1]);``    ` `                ``// This step is important``                ``// as P(i,j)=0 for j>i``                ``P[i,j + 1] = 0;``            ``}``        ``}``        ``return` `P[n,k];``    ``}``    ` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``int` `n = 10, k = 2;``        ``Console.WriteLine(``"Value of P( "` `+ n +``                        ``","``+ k +``")"` `+ ``" is "` `+``                        ``permutationCoeff(n, k) );``    ``}``}` `// This code is contributed by anuj_67..`

## PHP

 `i``            ``\$P``[``\$i``][``\$j` `+ 1] = 0;``        ``}``    ``}``    ``return` `\$P``[``\$n``][``\$k``];``}` `    ``// Driver Code``    ``\$n` `= 10; ``\$k` `= 2;``    ``echo` `"Value of P("``,``\$n``,``" ,"``,``\$k``,``") is "``,``            ``permutationCoeff(``\$n``, ``\$k``);` `// This code is contributed by anuj_67.``?>`

## Javascript

 ``

Output :

`Value of P(10, 2) is 90 `

Here as we can see the time complexity is O(n*k) and space complexity is O(n*k) as the program uses an auxiliary matrix to store the result.

Can we do it in O(n) time ?
Let us suppose we maintain a single 1D array to compute the factorials up to n. We can use computed factorial value and apply the formula P(n, k) = n! / (n-k)!. Below is a program illustrating the same concept.

## C++

 `// A O(n) solution that uses``// table fact[] to calculate``// the Permutation Coefficient``#include``using` `namespace` `std;` `// Returns value of Permutation``// Coefficient P(n, k)``int` `permutationCoeff(``int` `n, ``int` `k)``{``    ``int` `fact[n + 1];` `    ``// Base case``    ``fact[0] = 1;` `    ``// Calculate value``    ``// factorials up to n``    ``for``(``int` `i = 1; i <= n; i++)``    ``fact[i] = i * fact[i - 1];` `    ``// P(n,k) = n! / (n - k)!``    ``return` `fact[n] / fact[n - k];``}` `// Driver Code``int` `main()``{``    ``int` `n = 10, k = 2;``    ` `    ``cout << ``"Value of P("` `<< n << ``", "``        ``<< k << ``") is "``        ``<< permutationCoeff(n, k);` `    ``return` `0;``}` `// This code is contributed by shubhamsingh10`

## C

 `// A O(n) solution that uses``// table fact[] to calculate``// the Permutation Coefficient``#include` `// Returns value of Permutation``// Coefficient P(n, k)``int` `permutationCoeff(``int` `n, ``int` `k)``{``    ``int` `fact[n + 1];` `    ``// base case``    ``fact[0] = 1;` `    ``// Calculate value``    ``// factorials up to n``    ``for` `(``int` `i = 1; i <= n; i++)``        ``fact[i] = i * fact[i - 1];` `    ``// P(n,k) = n! / (n - k)!``    ``return` `fact[n] / fact[n - k];``}` `// Driver Code``int` `main()``{``    ``int` `n = 10, k = 2;``    ``printf` `(``"Value of P(%d, %d) is %d "``,``            ``n, k, permutationCoeff(n, k) );``    ``return` `0;``}`

## Java

 `// A O(n) solution that uses``// table fact[] to calculate``// the Permutation Coefficient``import` `java .io.*;` `public` `class` `GFG {``    ` `    ``// Returns value of Permutation``    ``// Coefficient P(n, k)``    ``static` `int` `permutationCoeff(``int` `n,``                                ``int` `k)``    ``{``        ``int` `[]fact = ``new` `int``[n+``1``];``    ` `        ``// base case``        ``fact[``0``] = ``1``;``    ` `        ``// Calculate value``        ``// factorials up to n``        ``for` `(``int` `i = ``1``; i <= n; i++)``            ``fact[i] = i * fact[i - ``1``];``    ` `        ``// P(n,k) = n! / (n - k)!``        ``return` `fact[n] / fact[n - k];``    ``}``    ` `    ``// Driver Code``    ``static` `public` `void` `main (String[] args)``    ``{``        ``int` `n = ``10``, k = ``2``;``        ``System.out.println(``"Value of"``        ``+ ``" P( "` `+ n + ``", "` `+ k + ``") is "``        ``+ permutationCoeff(n, k) );``    ``}``}` `// This code is contributed by anuj_67.`

## Python3

 `# A O(n) solution that uses``# table fact[] to calculate``# the Permutation Coefficient` `# Returns value of Permutation``# Coefficient P(n, k)``def` `permutationCoeff(n, k):``    ``fact ``=` `[``0` `for` `i ``in` `range``(n ``+` `1``)]` `    ``# base case``    ``fact[``0``] ``=` `1` `    ``# Calculate value``    ``# factorials up to n``    ``for` `i ``in` `range``(``1``, n ``+` `1``):``        ``fact[i] ``=` `i ``*` `fact[i ``-` `1``]` `    ``# P(n, k) = n!/(n-k)!``    ``return` `int``(fact[n] ``/` `fact[n ``-` `k])` `# Driver Code``n ``=` `10``k ``=` `2``print``(``"Value of P("``, n, ``", "``, k, ``") is "``,``        ``permutationCoeff(n, k), sep ``=` `"")` `# This code is contributed``# by Soumen Ghosh`

## C#

 `// A O(n) solution that uses``// table fact[] to calculate``// the Permutation Coefficient``using` `System;` `public` `class` `GFG {``    ` `    ``// Returns value of Permutation``    ``// Coefficient P(n, k)``    ``static` `int` `permutationCoeff(``int` `n,``                                ``int` `k)``    ``{``        ``int` `[]fact = ``new` `int``[n+1];``    ` `        ``// base case``        ``fact[0] = 1;``    ` `        ``// Calculate value``        ``// factorials up to n``        ``for` `(``int` `i = 1; i <= n; i++)``            ``fact[i] = i * fact[i - 1];``    ` `        ``// P(n,k) = n! / (n - k)!``        ``return` `fact[n] / fact[n - k];``    ``}``    ` `    ``// Driver Code``    ``static` `public` `void` `Main ()``    ``{``        ``int` `n = 10, k = 2;``        ``Console.WriteLine(``"Value of"``        ``+ ``" P( "` `+ n + ``", "` `+ k + ``") is "``        ``+ permutationCoeff(n, k) );``    ``}``}` `// This code is contributed by anuj_67.`

## PHP

 ``

## Javascript

 ``

Output :

`Value of P(10, 2) is 90 `

A O(n) time and O(1) Extra Space Solution

## C++

 `// A O(n) time and O(1) extra``// space solution to calculate``// the Permutation Coefficient``#include ``using` `namespace` `std;` `int` `PermutationCoeff(``int` `n, ``int` `k)``{``    ``int` `P = 1;` `    ``// Compute n*(n-1)*(n-2)....(n-k+1)``    ``for` `(``int` `i = 0; i < k; i++)``        ``P *= (n-i) ;` `    ``return` `P;``}` `// Driver Code``int` `main()``{``    ``int` `n = 10, k = 2;``    ``cout << ``"Value of P("` `<< n << ``", "` `<< k``         ``<< ``") is "` `<< PermutationCoeff(n, k);` `    ``return` `0;``}`

## Java

 `// A O(n) time and O(1) extra``// space solution to calculate``// the Permutation Coefficient``import` `java.io.*;` `class` `GFG``{``    ``static` `int` `PermutationCoeff(``int` `n,``                                ``int` `k)``    ``{``        ``int` `Fn = ``1``, Fk = ``1``;``    ` `        ``// Compute n! and (n-k)!``        ``for` `(``int` `i = ``1``; i <= n; i++)``        ``{``            ``Fn *= i;``            ``if` `(i == n - k)``            ``Fk = Fn;``        ``}``        ``int` `coeff = Fn / Fk;``        ``return` `coeff;``    ``}``    ` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `n = ``10``, k = ``2``;``        ``System.out.println(``"Value of P( "` `+ n + ``","` `+``                                         ``k +``") is "` `+``                            ``PermutationCoeff(n, k) );``    ``}``}``    ` `// This code is contributed by Nikita Tiwari.`

## C#

 `// A O(n) time and O(1) extra``// space solution to calculate``// the Permutation Coefficient``using` `System;` `class` `GFG {``    ` `    ``static` `int` `PermutationCoeff(``int` `n,``                                ``int` `k)``    ``{``        ``int` `Fn = 1, Fk = 1;``    ` `        ``// Compute n! and (n-k)!``        ``for` `(``int` `i = 1; i <= n; i++)``        ``{``            ``Fn *= i;``            ``if` `(i == n - k)``                ``Fk = Fn;``        ``}``        ``int` `coeff = Fn / Fk;``        ` `        ``return` `coeff;``    ``}``    ` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``int` `n = 10, k = 2;``        ``Console.WriteLine(``"Value of P( "``                   ``+ n + ``","` `+ k +``") is "``              ``+ PermutationCoeff(n, k) );``    ``}``}``    ` `// This code is contributed by anuj_67.`

## PHP

 ``

## Javascript

 ``

## Python3

 `# A O(n) solution that uses``# table fact[] to calculate``# the Permutation Coefficient` `# Returns value of Permutation``# Coefficient P(n, k)``def` `permutationCoeff(n, k):``  ` `  ``f``=``1``    ` `  ``for` `i ``in` `range``(k): ``#P(n,k)=n*(n-1)*(n-2)*....(n-k-1)``    ``f``*``=``(n``-``i)``        ` `  ``return` `f  ``#This code is contributed by Suyash Saxena` `# Driver Code``n ``=` `10``k ``=` `2``print``(``"Value of P("``, n, ``", "``, k, ``") is "``,``        ``permutationCoeff(n, k))`

Output :

`Value of P(10, 2) is 90 `

Thanks to Shiva Kumar for suggesting this solution.