# Permutation Coefficient

• Difficulty Level : Easy
• Last Updated : 18 Nov, 2021

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:

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

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

## 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 fo 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 = 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 = 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 = 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.