Number of ways to arrange K different objects taking N objects at a time

31 May, 2022
Given two integers K and N, the task is to count the number of ways to arrange K different objects taking N objects at a time. Each arrangement contains one object at most once. The answer can be very large so return the answer modulo 109 + 7.Note: 1 <= N <= K <= 105. Prerequisites: Factorial of a number, Compute nCr % pExamples: 
Input : N = 3, K = 3 Output : 6 If 1, 2 and 3 be the K different objects, then the possible arrangements are {123, 132, 213, 231, 312, 321}.Input : N = 4, K = 6 Output : 360 
 
Approach: The problem can be solved using Permutation and Combination. As N is always less than or equal to K, an answer greater than 0 shall always exist. Any object among the K available objects can be used at most once in an arrangement. So, we need to select N objects out of the K available objects for a single arrangement. So, the total number of ways to select N objects from K objects is KCN . Any selected group of N objects can then be permuted among themselves in N ways. So, the answer to the problem is: 
(N! * KCN) % (109 +7)  
Below is the implementation of the above approach:  
C++
Java
Python3
C#
PHP
Javascript
// C++ implementation of the approach #include <bits/stdc++.h>using namespace std;#define ll long long#define mod (ll)(1e9 + 7) // Function to return n! % pll factorial(ll n, ll p){    ll res = 1; // Initialize result    for (int i = 2; i <= n; i++)        res = (res * i) % p;    return res;} // Iterative Function to calculate (x^y)%p// in O(log y)ll power(ll x, ll y, ll p){    ll res = 1; // Initialize result     x = x % p; // Update x if it is more than or    // equal to p     while (y > 0) {        // If y is odd, multiply x with result        if (y & 1)            res = (res * x) % p;         // y must be even now        y = y >> 1; // y = y/2        x = (x * x) % p;    }    return res;} // Returns n^(-1) mod pll modInverse(ll n, ll p){    return power(n, p - 2, p);} // Returns nCr % p using Fermat's little// theorem.ll nCrModP(ll n, ll r, ll p){    // Base case    if (r == 0)        return 1;     // Fill factorial array so that we    // can find all factorial of r, n    // and n-r    ll fac[n + 1];    fac[0] = 1;    for (int i = 1; i <= n; i++)        fac[i] = fac[i - 1] * i % p;     return (fac[n] * modInverse(fac[r], p) % p                    * modInverse(fac[n - r], p) % p) % p;} // Function to return the number of ways to// arrange K different objects taking N objects// at a timell countArrangements(ll n, ll k, ll p){    return (factorial(n, p) * nCrModP(k, n, p)) % p;} // Drivers Codeint main(){    ll N = 5, K = 8;     // Function call    cout << countArrangements(N, K, mod);     return 0;}
// Java implementation of the approach class GFG{     static long mod =(long) (1e9 + 7); // Function to return n! % pstatic long factorial(long n, long p){    long res = 1; // Initialize result    for (int i = 2; i <= n; i++)        res = (res * i) % p;    return res;} // Iterative Function to calculate (x^y)%p// in O(log y)static long power(long x, long y, long p){    long res = 1; // Initialize result     x = x % p; // Update x if it is more than or    // equal to p     while (y > 0)    {        // If y is odd, multiply x with result        if ((y & 1)==1)            res = (res * x) % p;         // y must be even now        y = y >> 1; // y = y/2        x = (x * x) % p;    }    return res;} // Returns n^(-1) mod pstatic long modInverse(long n, long p){    return power(n, p - 2, p);} // Returns nCr % p using Fermat's little// theorem.static long nCrModP(long n, long r, long p){    // Base case    if (r == 0)        return 1;     // Fill factorial array so that we    // can find all factorial of r, n    // and n-r    long fac[] = new long[(int)n + 1];    fac[0] = 1;    for (int i = 1; i <= n; i++)        fac[i] = fac[i - 1] * i % p;     return (fac[(int)n] * modInverse(fac[(int)r], p) % p                    * modInverse(fac[(int)n - (int)r], p) % p) % p;} // Function to return the number of ways to// arrange K different objects taking N objects// at a timestatic long countArrangements(long n, long k, long p){    return (factorial(n, p) * nCrModP(k, n, p)) % p;} // Driver Codepublic static void main(String[] args){    long N = 5, K = 8;    // Function call    System.out.println(countArrangements(N, K, mod));}} /* This code is contributed by PrinciRaj1992 */
# Python3 implementation of the approachmod = 10**9 + 7 # Function to return n! % pdef factorial(n, p):     res = 1 # Initialize result    for i in range(2, n + 1):        res = (res * i) % p    return res # Iterative Function to calculate# (x^y)%p in O(log y)def power(x, y, p):     res = 1 # Initialize result     x = x % p # Update x if it is              # more than or equal to p     while (y > 0):                 # If y is odd,        # multiply x with result        if (y & 1):            res = (res * x) % p         # y must be even now        y = y >> 1 # y = y/2        x = (x * x) % p         return res # Returns n^(-1) mod pdef modInverse(n, p):     return power(n, p - 2, p) # Returns nCr % p using Fermat's little# theorem.def nCrModP(n, r, p):     # Base case    if (r == 0):        return 1     # Fifactorial array so that we    # can find afactorial of r, n    # and n-r    fac = [0 for i in range(n + 1)]    fac[0] = 1    for i in range(1, n + 1):        fac[i] = fac[i - 1] * i % p     return (fac[n] * modInverse(fac[r], p) % p *                     modInverse(fac[n - r], p) % p) % p # Function to return the number of ways# to arrange K different objects taking# N objects at a timedef countArrangements(n, k, p):     return (factorial(n, p) *            nCrModP(k, n, p)) % p # Drivers CodeN = 5K = 8 # Function callprint(countArrangements(N, K, mod)) # This code is contributed by mohit kumar
// C# implementation of the approachusing System; class GFG{     static long mod =(long) (1e9 + 7); // Function to return n! % pstatic long factorial(long n, long p){    long res = 1; // Initialize result    for (int i = 2; i <= n; i++)        res = (res * i) % p;    return res;} // Iterative Function to calculate (x^y)%p// in O(log y)static long power(long x, long y, long p){    long res = 1; // Initialize result     x = x % p; // Update x if it is more than or    // equal to p     while (y > 0)    {        // If y is odd, multiply x with result        if ((y & 1)==1)            res = (res * x) % p;         // y must be even now        y = y >> 1; // y = y/2        x = (x * x) % p;    }    return res;} // Returns n^(-1) mod pstatic long modInverse(long n, long p){    return power(n, p - 2, p);} // Returns nCr % p using Fermat's little// theorem.static long nCrModP(long n, long r, long p){    // Base case    if (r == 0)        return 1;     // Fill factorial array so that we    // can find all factorial of r, n    // and n-r    long[] fac = new long[(int)n + 1];    fac[0] = 1;    for (int i = 1; i <= n; i++)        fac[i] = fac[i - 1] * i % p;     return (fac[(int)n] * modInverse(fac[(int)r], p) % p                    * modInverse(fac[(int)n - (int)r], p) % p) % p;} // Function to return the number of ways to// arrange K different objects taking N objects// at a timestatic long countArrangements(long n, long k, long p){    return (factorial(n, p) * nCrModP(k, n, p)) % p;} // Driver Codepublic static void Main(){    long N = 5, K = 8;         // Function call    Console.WriteLine(countArrangements(N, K, mod));}} /* This code is contributed by Code_Mech */
<?php// PHP implementation of the approach$mod = (1e9 + 7); // Function to return n! % pfunction factorial($n,$p){    $res = 1; // Initialize result    for ($i = 2; $i <= $n; $i++)        $res = ($res * $i) % $p;    return $res;} // Iterative Function to calculate (x^y)%p// in O(log y)function power($x, $y, $p){    $res = 1; // Initialize result     $x = $x % $p; // Update x if it is more than or    // equal to p     while ($y > 0)    {        // If y is odd, multiply x with result        if (($y & 1)==1)            $res = ($res * $x) % $p;         // y must be even now        $y = $y >> 1; // y = y/2        $x = ($x * $x) % $p;    }    return $res;} // Returns n^(-1) mod pfunction modInverse($n, $p){    return power($n, $p - 2, $p);} // Returns nCr % p using Fermat's little// theorem.function nCrModP($n, $r, $p){    // Base case    if ($r == 0)        return 1;     // Fill factorial array so that we    // can find all factorial of r, n    // and n-r    $fac= array((int)$n + 1);    $fac[0] = 1;    for ($i = 1; $i <= $n; $i++)        $fac[$i] = $fac[$i - 1] * $i % $p;     return ($fac[(int)$n] * modInverse($fac[(int)$r], $p) % $p                    * modInverse($fac[(int)$n - (int)$r], $p) % $p) % $p;} // Function to return the number of ways to// arrange K different objects taking N objects// at a timefunction countArrangements($n, $k, $p){    return (factorial($n, $p) * nCrModP($k, $n, $p)) % $p;} // Driver Code{    $N = 5; $K = 8;    // Function call    echo(countArrangements($N, $K, $mod));}  /* This code is contributed by Code_Mech*/
<script> // javascript implementation of the approach  var mod =parseInt(1e4 + 7); // Function to return n! % pfunction factorial(n , p){    var res = 1; // Initialize result    for (var i = 2; i <= n; i++)        res = (res * i) % p;    return res;} // Iterative Function to calculate (x^y)%p// in O(log y)function power(x , y , p){    var res = 1; // Initialize result     x = x % p; // Update x if it is more than or    // equal to p     while (y > 0)    {        // If y is odd, multiply x with result        if ((y & 1)==1)            res = (res * x) % p;         // y must be even now        y = y >> 1; // y = y/2        x = (x * x) % p;    }    return res;} // Returns n^(-1) mod pfunction modInverse(n , p){    return power(n, p - 2, p);} // Returns nCr % p using Fermat's little// theorem.function nCrModP(n , r , p){    // Base case    if (r == 0)        return 1;     // Fill factorial array so that we    // can find all factorial of r, n    // and n-r    var fac = Array.from({length: n+1}, (_, i) => 0);;    fac[0] = 1;    for (var i = 1; i <= n; i++)        fac[i] = fac[i - 1] * i % p;     return (fac[parseInt(n)] * modInverse(fac[parseInt(r)], p) % p                    * modInverse(fac[parseInt(n) - parseInt(r)], p) % p) % p;} // Function to return the number of ways to// arrange K different objects taking N objects// at a timefunction countArrangements(n , k , p){    return (factorial(n, p) * nCrModP(k, n, p)) % p;} // Driver Codevar N = 5, K = 8;// Function calldocument.write(countArrangements(N, K, mod));  // This code contributed by Princi Singh</script>
6720
 
Time Complexity: O(n), to fill a factorial arrayAuxiliary Space: O(n), extra space of size n used to make a factorial array
mohit kumar 29
princiraj1992
Code_Mech
princi singh
singhh3010
factorial
Combinatorial
Competitive Programming
Mathematical
Mathematical
Combinatorial
factorial
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.